mblock_int.h

Go to the documentation of this file.

// Copyright (c) 2024 anabrid GmbH
// Contact: https://www.anabrid.com/licensing/
// SPDX-License-Identifier: MIT OR GPL-2.0-or-later
 
#pragma once
 
#include "block/mblock.h"
 
namespace blocks {
 
struct __attribute__((packed)) IntegratorCalibration {
  uint8_t time_factor_gain_slow = 127; // Raw gain value, for step through. Equals mid setting
  uint8_t time_factor_gain_fast = 127; // Raw gain value, for step through. Equals mid setting
};
 
class MIntBlockHAL : public MBlockHAL {
public:
  virtual bool write_ic(uint8_t idx, float ic) = 0;
  virtual bool write_time_factor_switches(std::bitset<8> switches) = 0;
};
 
class MIntBlockHAL_Dummy : public MIntBlockHAL {
public:
  bool write_ic(uint8_t idx, float ic) override { return true; }
 
  bool write_time_factor_switches(std::bitset<8> switches) override { return true; }
 
  std::bitset<8> read_overload_flags() override { return {0}; }
 
  void reset_overload_flags() override {}
 
  explicit MIntBlockHAL_Dummy(bus::addr_t) {}
 
  metadata::eui_t get_entity_eui() const override { return {}; }
};
 
class MIntBlockHAL_V_1_0_X : public MIntBlockHAL {
protected:
  const metadata::MetadataEditor f_meta;
  const functions::DAC60508 f_ic_dac;
  const functions::SR74HCT595 f_time_factor;
  const functions::TriggerFunction f_time_factor_sync;
  const functions::TriggerFunction f_time_factor_reset;
  const functions::SR74HC16X f_overload_flags;
  const functions::TriggerFunction f_overload_flags_reset;
 
public:
  explicit MIntBlockHAL_V_1_0_X(bus::addr_t block_address);
 
  bool init() override;
 
  bool write_ic(uint8_t idx, float ic) override;
  bool write_time_factor_switches(std::bitset<8> switches) override;
 
  std::bitset<8> read_overload_flags() override;
  void reset_overload_flags() override;
 
  metadata::eui_t get_entity_eui() const override { return f_meta.read_eui(); }
};
 
class MIntBlockHAL_V_1_1_X : public MIntBlockHAL_V_1_0_X {
protected:
  functions::AD8403 f_time_factor_gain_0_3;
  functions::AD8403 f_time_factor_gain_4_7;
 
public:
  explicit MIntBlockHAL_V_1_1_X(bus::addr_t block_address);
 
  bool write_ic(uint8_t idx, float ic) override;
  bool write_time_factor_switches(std::bitset<8> switches) override;
 
  virtual bool write_limiters_enable(std::bitset<8> limiters);
  virtual bool write_time_factor_switches_and_limiters_enable(std::bitset<8> switches,
                                                              std::bitset<8> limiters);
 
  virtual bool write_time_factor_gain(uint8_t idx, uint8_t gain);
 
  metadata::eui_t get_entity_eui() const override { return f_meta.read_eui(); }
};
 
class MIntBlock : public MBlock {
public:
  // Entity hardware identifier information.
  static constexpr auto TYPE = MBlock::TYPES::M_INT8_BLOCK;
 
  static MIntBlock *from_entity_classifier(entities::EntityClassifier classifier, bus::addr_t block_address);
 
public:
  static constexpr uint8_t NUM_INTEGRATORS = 8;
  static constexpr unsigned int DEFAULT_TIME_FACTOR = 10000;
 
  static constexpr std::array<uint8_t, NUM_INTEGRATORS> INTEGRATORS_INPUT_RANGE() {
    return {0, 1, 2, 3, 4, 5, 6, 7};
  }
 
  static constexpr std::array<uint8_t, NUM_INTEGRATORS> INTEGRATORS_OUTPUT_RANGE() {
    return {0, 1, 2, 3, 4, 5, 6, 7};
  }
 
protected:
  MIntBlockHAL *hardware;
 
  std::array<float, NUM_INTEGRATORS> ic_values;
  std::array<unsigned int, NUM_INTEGRATORS> time_factors;
 
  utils::status _config_elements_from_json(const JsonVariantConst &cfg);
 
public:
  explicit MIntBlock(SLOT slot, MIntBlockHAL *hardware);
 
  explicit MIntBlock(SLOT slot) : MIntBlock(slot, new MIntBlockHAL_Dummy(bus::NULL_ADDRESS)) {}
 
  metadata::eui_t get_entity_eui() const override;
 
  bool init() override;
  void reset(entities::ResetAction action) override;
 
  [[nodiscard]] const std::array<float, 8> &get_ic_values() const;
  [[nodiscard]] float get_ic_value(uint8_t idx) const;
  bool set_ic_values(float value);
  bool set_ic_values(const std::array<float, 8> &ic_values_);
  bool set_ic_value(uint8_t idx, float value);
  void reset_ic_values();
 
  [[nodiscard]] const std::array<unsigned int, 8> &get_time_factors() const;
  unsigned int get_time_factor(uint8_t idx) const;
  bool set_time_factors(unsigned int k);
  bool set_time_factors(const std::array<unsigned int, 8> &time_factors_);
  bool set_time_factor(uint8_t int_idx, unsigned int k);
  void reset_time_factors();
 
  [[nodiscard]] utils::status write_to_hardware() override;
 
  utils::status config_self_from_json(JsonObjectConst cfg) override;
 
protected:
  void config_self_to_json(JsonObject &cfg) override;
};
 
class MIntBlock_V_1_1_X : public MIntBlock {
public:
  MIntBlock_V_1_1_X(SLOT slot, MIntBlockHAL_V_1_1_X *hardware);
 
  [[nodiscard]] utils::status write_to_hardware() override;
  void reset(entities::ResetAction action) override;
 
  [[nodiscard]] const std::array<IntegratorCalibration, NUM_INTEGRATORS> &get_calibration() const;
  [[nodiscard]] blocks::IntegratorCalibration get_calibration(uint8_t int_idx) const;
  utils::status write_calibration_to_hardware();
 
  bool calibrate(platform::Cluster *cluster, carrier::Carrier *carrier) override;
 
protected:
  MIntBlockHAL_V_1_1_X *hardware;
 
  std::array<IntegratorCalibration, NUM_INTEGRATORS> calibration{};
 
  bool _gain_calibration(bool use_slow_integration);
};
 
} // namespace blocks