multi_ds_handler_base.h

/*
 Copyright (C) AC SOFTWARE SP. Z O.O.
 
 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
 
#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 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(DeviceAddress deviceAddress,
                                          int channelNumber = -1,
                                          int subDeviceId = -1);
  virtual int refreshSensorsCount() = 0;
  virtual void requestTemperatures() = 0;
  virtual bool getSensorAddress(uint8_t *address, int index) = 0;
 
 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;
 
  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_