multi_ds_handler_base.h

// SPDX-FileCopyrightText: AC SOFTWARE SP. Z O.O.
// SPDX-License-Identifier: GPL-2.0-or-later
 
#ifndef SRC_SUPLA_SENSOR_MULTI_DS_HANDLER_BASE_H_
#define SRC_SUPLA_SENSOR_MULTI_DS_HANDLER_BASE_H_
 
#include <SuplaDevice.h>
#include <supla/element.h>
#include <supla/log_wrapper.h>
#include <supla/local_action.h>
#include <supla/device/subdevice_pairing_handler.h>
#include <supla/device/channel_conflict_resolver.h>
 
#include "multi_ds_sensor.h"
 
#define MUTLI_DS_DEFAULT_PAIRING_DURATION_SEC 5
#define MULTI_DS_MAX_DEVICES_COUNT 10
#define MULTI_DS_MAX_ACTIONS 10
 
namespace Supla {
 
namespace Sensor {
 
enum class MultiDsState {
  READY,
  PARING
};
 
class MultiDsHandlerBase : public Element,
                           public Supla::Device::SubdevicePairingHandler,
                           public Supla::Device::ChannelConflictResolver {
 public:
  explicit MultiDsHandlerBase(SuplaDeviceClass *sdc, uint8_t pin);
  virtual ~MultiDsHandlerBase();
 
  void onRegistered(Supla::Protocol::SuplaSrpc *suplaSrpc) override;
  void iterateAlways() override;
  bool iterateConnected() override;
  void onLoadConfig(SuplaDeviceClass *sdc) override;
  void onInit() override;
 
  bool startPairing(Supla::Protocol::SuplaSrpc *srpc,
                    TCalCfg_SubdevicePairingResult *result) override;
 
  bool onChannelConflictReport(
      uint8_t *channelReport,
      uint8_t channelReportSize,
      bool hasConflictInvalidType,
      bool hasConflictChannelMissingOnServer,
      bool hasConflictChannelMissingOnDevice) override;
 
  virtual double getTemperature(const uint8_t *address) = 0;
 
  void setMaxDeviceCount(uint8_t count);
 
  void setRefreshIntervalMs(uint32_t intervalMs);
 
  void setChannelNumberOffset(uint8_t offset);
 
  void setUseSubDevices(bool useSubDevices);
 
  void setPairingTimeout(uint8_t timeout);
 
  void disableSensorsChannelState();
 
  void searchForFirstSensorDuringInitialization();
 
 protected:
  SuplaDeviceClass *sdc = nullptr;
  MultiDsSensor *sensors[MULTI_DS_MAX_DEVICES_COUNT] = {};
  Supla::Sensor::MultiDsSensor *addDevice(uint8_t *deviceAddress,
                                          int channelNumber = -1,
                                          int subDeviceId = -1);
  virtual int refreshSensorsCount() = 0;
  virtual void requestTemperatures() = 0;
  virtual bool getSensorAddress(uint8_t *address, int index) = 0;
 
  int findFreeSensorSlot() const;
  int findNextFreeSubDeviceId() const;
  int findChannelNumber(int sensorSlot) const;
 
 private:
  void notifySrpcAboutParingEnd(int pairingResult, const char *name = nullptr);
  void addressToString(char *buffor, uint8_t bufforLength, uint8_t *address);
  void initialSensorSearch();
 
  uint8_t pin;
  Supla::Protocol::SuplaSrpc *srpc = nullptr;
  MultiDsState state = MultiDsState::READY;
 
  uint32_t pairingStartTimeMs = 0;
  uint32_t helperTimeMs = 0;
  uint32_t lastBusReadTime = 0;
  uint32_t refreshIntervalMs = 10000;
 
  uint8_t maxDeviceCount = MULTI_DS_MAX_DEVICES_COUNT;
  uint8_t pairingTimeout = MUTLI_DS_DEFAULT_PAIRING_DURATION_SEC;
  int channelNumberOffset = -1;
  bool useSubDevices = true;
  bool channelStateDisabled = false;
  bool anySensorLoaded = false;
  bool searchFirstDevice = false;
};
 
};  // namespace Sensor
};  // namespace Supla
 
#endif  // SRC_SUPLA_SENSOR_MULTI_DS_HANDLER_BASE_H_