container.h

// SPDX-FileCopyrightText: AC SOFTWARE SP. Z O.O.
// SPDX-License-Identifier: GPL-2.0-or-later
 
#ifndef SRC_SUPLA_SENSOR_CONTAINER_H_
#define SRC_SUPLA_SENSOR_CONTAINER_H_
 
#include <supla/channel_element.h>
#include <supla/action_handler.h>
 
namespace Supla {
namespace Html {
class ContainerParameters;
}  // namespace Html
 
namespace Sensor {
 
#pragma pack(push, 1)
struct SensorData {
  uint8_t fillLevel = 0;
  uint8_t channelNumber = 255;  // not used
};
 
struct ContainerConfig {
  uint8_t warningAboveLevel = 0;  // 0 - not set, 1-101 for 0-100%
  uint8_t alarmAboveLevel = 0;    // 0 - not set, 1-101 for 0-100%
  uint8_t warningBelowLevel = 0;  // 0 - not set, 1-101 for 0-100%
  uint8_t alarmBelowLevel = 0;    // 0 - not set, 1-101 for 0-100%
 
  uint8_t muteAlarmSoundWithoutAdditionalAuth = 0;  // 0 - admin login is
                                                 // required, 1 - regular
                                                 // user is allowed
  SensorData sensorData[10] = {};
};
#pragma pack(pop)
 
enum class SensorState {
  Unknown = 0,
  Active = 1,
  Inactive = 2,
  Offline = 3
};
 
class Container : public ChannelElement, public ActionHandler {
 public:
  friend class Supla::Html::ContainerParameters;
  Container();
 
  void setInternalLevelReporting(bool internalLevelReporting);
 
  bool isInternalLevelReporting() const;
 
  void iterateAlways() override;
  void onLoadConfig(SuplaDeviceClass *) override;
  Supla::ApplyConfigResult applyChannelConfig(TSD_ChannelConfig *result,
                                              bool local = false) override;
  void fillChannelConfig(void *channelConfig,
                         int *size,
                         uint8_t configType) override;
  int handleCalcfgFromServer(TSD_DeviceCalCfgRequest *request) override;
 
  void handleAction(int event, int action) override;
 
  void printConfig() const;
  void saveConfig();
 
  // should return 0-100 value for 0-100 %, -1 if not available
  virtual int readNewValue();
 
  // 0-100 value for 0-100 %, -1 if not available
  void setValue(int value);
 
  bool isAlarmActive() const;
  bool isWarningActive() const;
  bool isInvalidSensorStateActive() const;
  bool isSoundAlarmOn() const;
 
  bool isExternalSoundAlarmOn() const;
 
  virtual void setReadIntervalMs(uint32_t timeMs);
 
  // set warning level as 0-100 value, where
  // -1 - not set, 1-100 for 0-100%
  void setWarningAboveLevel(int8_t warningAboveLevel);
  // returns 0-100 value for 0-100 %, -1 if not available
  int8_t getWarningAboveLevel() const;
  bool isWarningAboveLevelSet() const;
 
  // set alarm level as 0-100 value, where
  // -1 - not set, 0-100 for 0-100%
  void setAlarmAboveLevel(int8_t alarmAboveLevel);
  // returns 0-100 value for 0-100 %, -1 if not available
  int8_t getAlarmAboveLevel() const;
  bool isAlarmAboveLevelSet() const;
 
  // set warning level as 0-100 value, where
  // -1 - not set, 1-100 for 0-100%
  void setWarningBelowLevel(int8_t warningBelowLevel);
  // returns 0-100 value for 0-100 %, -1 if not available
  int8_t getWarningBelowLevel() const;
  bool isWarningBelowLevelSet() const;
 
  // set alarm level as 0-100 value, where
  // -1 - not set, 1-100 for 0-100%
  void setAlarmBelowLevel(int8_t alarmBelowLevel);
  // returns 0-100 value for 0-100 %, -1 if not available
  int8_t getAlarmBelowLevel() const;
  bool isAlarmBelowLevelSet() const;
 
  void setMuteAlarmSoundWithoutAdditionalAuth(
      bool muteAlarmSoundWithoutAdditionalAuth);
  bool isMuteAlarmSoundWithoutAdditionalAuth() const;
 
  bool setSensorData(uint8_t channelNumber, uint8_t fillLevel);
  void removeSensorData(uint8_t channelNumber);
 
  int getFillLevelForSensor(uint8_t channelNumber) const;
 
  bool isSensorDataUsed() const;
 
  bool isAlarmingUsed() const;
 
  void setSoundAlarmSupported(bool soundAlarmSupported);
  bool isSoundAlarmSupported() const;
 
  void muteSoundAlarm();
 
  void setExternalSoundAlarmOn();
  void setExternalSoundAlarmOff();
 
 protected:
  void updateConfigField(uint8_t *configField, int8_t value);
  int8_t getHighestSensorValueAndUpdateState();
  void setAlarmActive(bool alarmActive);
  void setWarningActive(bool warningActive);
  void setInvalidSensorStateActive(bool invalidSensorStateActive);
  void setSoundAlarmOn(uint8_t level);
 
  bool checkSensorInvalidState(const int8_t currentFillLevel,
                               const int8_t tolerance = 0) const;
 
  // returns -1 when sensor is not configured or on error
  // returns 0 when sensor is not active
  // returns 1 when sensor is active
  enum SensorState getSensorState(const uint8_t channelNumber) const;
  uint32_t lastReadTime = 0;
  uint32_t readIntervalMs = 1000;
  int8_t fillLevel = -1;
  bool soundAlarmSupported = false;
  uint8_t soundAlarmActivatedLevel = 0;
  bool externalSoundAlarm = false;
  bool sensorOfflineReported = false;
 
  ContainerConfig config = {};
};
 
static_assert(sizeof(ContainerConfig().sensorData) / sizeof(SensorData) ==
              sizeof(TChannelConfig_Container().SensorInfo) /
                  sizeof(TContainer_SensorInfo));
 
};  // namespace Sensor
};  // namespace Supla
 
 
#endif  // SRC_SUPLA_SENSOR_CONTAINER_H_