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
 
#include <algorithm>
#include <bitset>
 
#include <block/mblock_int.h>
 
#include <chips/AD840X.h>
#include <chips/DAC60508.h>
#include <chips/SR74HC16X.h>
#include <chips/SR74HCT595.h>
#include <entity/hardware.h>
 
namespace blocks {
 
using MIntBlockHAL_Parent = entities::EntitySharedHardware<MIntBlockHAL>;
 
class MIntBlockHAL_V_1_0_X : public MIntBlockHAL_Parent {
protected:
  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);
 
  UnitResult 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;
};
 
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;
 
  // Do not use this function on Version V1.1.0
  bool write_time_factor_switches(std::bitset<8> switches) override { return false; }
 
  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);
};
 
class MIntBlock_V_1_1_X : public MIntBlock {
public:
  MIntBlock_V_1_1_X(SLOT slot, MIntBlockHAL_V_1_1_X *hardware);
 
  [[nodiscard]] UnitResult 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;
  UnitResult write_calibration_to_hardware();
 
  UnitResult calibrate(platform::Cluster *cluster, carrier::Carrier *carrier) override;
 
  ConfigResult config(const pb_Item &item) override;
 
protected:
  MIntBlockHAL_V_1_1_X *hardware;
 
  std::array<IntegratorCalibration, NUM_INTEGRATORS> calibration{};
  std::bitset<NUM_INTEGRATORS> _limiters_enabled{};
 
  UnitResult _gain_calibration(bool use_slow_integration);
};
 
} // namespace blocks