roller_shutter_interface.h

// SPDX-FileCopyrightText: AC SOFTWARE SP. Z O.O.
// SPDX-License-Identifier: GPL-2.0-or-later
 
#ifndef SRC_SUPLA_CONTROL_ROLLER_SHUTTER_INTERFACE_H_
#define SRC_SUPLA_CONTROL_ROLLER_SHUTTER_INTERFACE_H_
 
#include "../action_handler.h"
#include "../channel_element.h"
 
#define UNKNOWN_POSITION   -1
#define STOP_POSITION      -2
#define MOVE_UP_POSITION   -3
#define MOVE_DOWN_POSITION -4
#define STOP_REQUEST       -5
#define RS_DEFAULT_OPERATION_TIMEOUT_MS 60000
#define RS_MAX_OPERATION_TIME_MS 600000  // Max opening/closing/tilting time
 
namespace Supla {
 
namespace Control {
 
bool isValidTiltControlType(uint32_t type);
constexpr uint32_t MAX_TILT_ANGLE_DEGREES = 180;
bool isValidTiltAngle(uint32_t angle);
bool requiresSeparateTiltPhase(uint8_t type);
bool isValidFacadeBlindTiming(uint8_t type,
                              uint32_t openingTimeMs,
                              uint32_t closingTimeMs,
                              uint32_t tiltingTimeMs);
 
class Button;
 
enum class Directions : uint8_t { STOP_DIR = 0, DOWN_DIR = 1, UP_DIR = 2 };
 
#pragma pack(push, 1)
struct RollerShutterConfig {
  uint8_t motorUpsideDown = 1;    // 0 - not set/not used, 1 - false, 2 - true
  uint8_t buttonsUpsideDown = 1;  // 0 - not set/not used, 1 - false, 2 - true
  int8_t timeMargin = -1;  // -1 default (device specific), 0 - not set/not used
                           // 1 - no margin,
                           // > 1 - 51% of opening/closing time added on extreme
                           // positions - value should be decremented by 1.
  uint8_t visualizationType = 0;  // 0 - default, other values depends on
                                  // Cloud and App support
};
 
struct TiltConfig {
  uint32_t tiltingTime = 0;
  uint16_t tilt0Angle = 0;    // 0 - 180 - degree corresponding to tilt 0
  uint16_t tilt100Angle = 0;  // 0 - 180 - degree corresponding to tilt 100
  uint8_t tiltControlType =
      SUPLA_TILT_CONTROL_TYPE_UNKNOWN;  // SUPLA_TILT_CONTROL_TYPE_
 
  void clear();
};
#pragma pack(pop)
 
class RollerShutterInterface : public ChannelElement, public ActionHandler {
 public:
  explicit RollerShutterInterface(bool tiltFunctionsEnabled = false);
 
  virtual ~RollerShutterInterface();
 
  RollerShutterInterface(const RollerShutterInterface &) = delete;
  RollerShutterInterface &operator=(const RollerShutterInterface &) = delete;
 
  void addTiltFunctions();
 
  bool isTiltFunctionsSupported() const;
 
  bool isTiltFunctionEnabled() const;
 
  bool isTiltConfigured() const;
 
  bool canExecuteTiltOnlyCommand(int tilt) const;
 
  bool isTopReached() const;
 
  bool isBottomReached() const;
 
  int32_t handleNewValueFromServer(TSD_SuplaChannelNewValue *newValue) override;
  void handleAction(int event, int action) override;
  int handleCalcfgFromServer(TSD_DeviceCalCfgRequest *request) override;
  Supla::ApplyConfigResult applyChannelConfig(TSD_ChannelConfig *result,
                                              bool local = false) override;
  void fillChannelConfig(void *channelConfig,
                         int *size,
                         uint8_t configType) override;
 
  // Method is used by external integrations to prepare TSD_SuplaChannelNewValue
  // value for specific channel type (i.e. to prefill durationMS field when
  // required)
  void fillSuplaChannelNewValue(TSD_SuplaChannelNewValue *value) override;
 
  virtual void close();         // Sets target position to 100%
  virtual void open();          // Sets target position to 0%
  virtual void stop();          // Stop motor
  virtual void moveUp();    // start opening roller shutter regardless of its
                            // position (keep motor going up)
  virtual void moveDown();  // starts closing roller shutter regardless of its
                            // position (keep motor going down)
 
  virtual void setTargetPosition(int newPosition,
                                 int newTilt = UNKNOWN_POSITION);
  void setCurrentPosition(int newPosition, int newTilt = UNKNOWN_POSITION);
  void setNotCalibrated();
  // Sets calibration ongoing flag, by setting calibration timeout.
  // calibrationTime = 1 is used to indicate ongoing calibration for
  // devices without explicit calibration time setting
  void setCalibrationOngoing(int calibrationTime = 1);
  void setCalibrationFinished();
 
  int getCurrentPosition() const;
 
  int getCurrentTilt() const;
 
  int getTargetPosition() const;
 
  int getTargetTilt() const;
 
  int getCurrentDirection() const;
 
  void configComfortUpValue(uint8_t position);
  void configComfortDownValue(uint8_t position);
  void configComfortUpTiltValue(uint8_t position);
  void configComfortDownTiltValue(uint8_t position);
 
  void onInit() override;
  void onLoadConfig(SuplaDeviceClass *sdc) override;
  void saveConfig();
  void onLoadState() override;
  void onSaveState() override;
  void purgeConfig() override;
  void iterateAlways() override;
 
  uint32_t getClosingTimeMs() const;
  uint32_t getOpeningTimeMs() const;
  uint32_t getTiltingTimeMs() const;
  uint32_t getTiltControlType() const;
 
  void attach(Supla::Control::Button *up, Supla::Control::Button *down);
  void attach(Supla::Control::Button *button, bool upButton, bool asInternal);
 
  virtual void triggerCalibration();
  void setCalibrationNeeded();
  bool isCalibrationRequested() const;
  bool isCalibrated() const;
 
  void setRsConfigMotorUpsideDownEnabled(bool enable);
 
  void setRsConfigButtonsUpsideDownEnabled(bool enable);
 
  void setRsConfigTimeMarginEnabled(bool enable);
 
  void setRsConfigMotorUpsideDownValue(uint8_t value);
 
  void setRsConfigButtonsUpsideDownValue(uint8_t value);
 
  void setRsConfigTimeMarginValue(int8_t value);
 
  uint8_t getMotorUpsideDown() const;
  uint8_t getButtonsUpsideDown() const;
  int8_t getTimeMargin() const;
 
  static void setRsStorageSaveDelay(int delayMs);
 
  virtual bool inMove();
  virtual bool isCalibrationInProgress() const;
  void startCalibration(uint32_t timeMs);
  void stopCalibration();
  bool isCalibrationFailed() const;
  bool isCalibrationLost() const;
  bool isMotorProblem() const;
 
  bool isFunctionSupported(int32_t channelFunction) const;
  bool isAutoCalibrationSupported() const;
 
  void setOpenCloseTime(uint32_t newClosingTimeMs, uint32_t newOpeningTimeMs);
  void setTiltingTime(uint32_t newTiltingTimeMs, bool local = true);
  void setTiltControlType(uint8_t newTiltControlType, bool local = true);
  bool applyFacadeBlindTimingConfig(uint32_t openingTimeMs,
                                    uint32_t closingTimeMs,
                                    uint32_t tiltingTimeMs,
                                    uint32_t tiltControlType,
                                    bool local = true);
 
  void setCalibrationFailed(bool value);
  void setCalibrationLost(bool value);
  void setMotorProblem(bool value);
 
 private:
  void clearTiltConfig();
 
 protected:
  RollerShutterInterface(bool tiltFunctionsEnabled,
                         Supla::Channel &externalChannel,
                         ElementMode mode);
  void loadRollerShutterConfigOnly();
  void validateTiltConfigAfterLoad();
  void purgeRollerShutterConfigOnly();
 
  struct ButtonListElement {
    Supla::Control::Button *button = nullptr;
    bool asInternal = true;
    bool upButton = true;
    ButtonListElement *next = nullptr;
  };
 
  void setupButtonActions(Supla::Control::Button *button,
                               bool upButton, bool asInternal);
 
 
  bool lastDirectionWasOpen() const;
  bool lastDirectionWasClose() const;
 
  // returns true, when opening/closing time is setable from config
  bool isTimeSettingAvailable() const;
  bool getCalibrate() const;
  void setCalibrate(bool value);
 
  void printConfig() const;
  uint32_t getTimeMarginValue(uint32_t fullTime) const;
  void logIgnoredTiltOnlyCommand(int tilt);
 
  uint8_t flags = 0;
 
  uint8_t comfortDownValue = 20;
  uint8_t comfortUpValue = 80;
  uint8_t comfortUpTiltValue = 0;
  uint8_t comfortDownTiltValue = 100;
 
  Directions currentDirection = Directions::STOP_DIR;  // stop, up, down
  Directions lastDirection = Directions::STOP_DIR;
 
  int16_t currentPosition =
      UNKNOWN_POSITION;  // 0 - open; 10000 - closed, in 0.01 units
  int16_t currentTilt =
      UNKNOWN_POSITION;  // 0 - opening position
                         // 10000 - closing position, in 0.01 units
  int8_t targetPosition = STOP_POSITION;         // 0-100
  int8_t targetTilt = UNKNOWN_POSITION;          // 0-100
  int16_t lastPositionBeforeMovement = UNKNOWN_POSITION;  // 0-100
  int16_t lastTiltBeforeMovement = UNKNOWN_POSITION;      // 0-100
  bool newTargetPositionAvailable = false;
  bool invalidTiltOnlyCommandWarningLogged = false;
 
  RollerShutterConfig rsConfig;
  TiltConfig tiltConfig;
 
  ButtonListElement *buttonList = nullptr;
 
  uint32_t closingTimeMs = 0;
  uint32_t openingTimeMs = 0;
  // Calibration time may be used also as indication of ongoing calibration,
  // but without information about calibration lenght. In general:
  // calibrationTime > 0 means that there is ongoing calibration
  uint32_t calibrationTime = 0;
  uint32_t lastUpdateTime = 0;
  bool rollerShutterStateLoaded = false;
 
  static int16_t rsStorageSaveDelay;
};
 
}  // namespace Control
}  // namespace Supla
 
 
#endif  // SRC_SUPLA_CONTROL_ROLLER_SHUTTER_INTERFACE_H_