mblock_mul.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 {
 
class MMulBlockHAL : public MBlockHAL {
public:
  virtual bool write_calibration_input_offsets(uint8_t idx, uint16_t offset_x, uint16_t offset_y) = 0;
  virtual bool write_calibration_output_offset(uint8_t idx, uint16_t offset_z) = 0;
 
  bool init() override;
};
 
class MMulBlockHAL_V_1_0_X : public MMulBlockHAL {
protected:
  const metadata::MetadataEditor f_meta;
  const functions::TriggerFunction f_overload_flags_reset;
  const functions::SR74HC16X f_overload_flags;
  const functions::DAC60508 f_calibration_dac_0;
  const functions::DAC60508 f_calibration_dac_1;
 
public:
  explicit MMulBlockHAL_V_1_0_X(bus::addr_t block_address);
 
  metadata::eui_t get_entity_eui() const override { return f_meta.read_eui(); }
 
  bool init() override;
 
public:
  bool write_calibration_input_offsets(uint8_t idx, uint16_t offset_x, uint16_t offset_y) override;
  bool write_calibration_output_offset(uint8_t idx, uint16_t offset_z) override;
 
  static constexpr float MIN_OFFSET = -0.1f;
  static constexpr float MAX_OFFSET = +0.1f;
 
  static float raw_to_float_calibration(uint16_t raw) {
    return map(static_cast<float>(raw), functions::DAC60508::RAW_ZERO, functions::DAC60508::RAW_MAX,
               MAX_OFFSET, MIN_OFFSET);
  }
 
  static uint16_t float_to_raw_calibration(float value) {
    return static_cast<uint16_t>(roundf(
        map(value, MIN_OFFSET, MAX_OFFSET, functions::DAC60508::RAW_MAX, functions::DAC60508::RAW_ZERO)));
  }
 
  std::bitset<8> read_overload_flags() override;
  void reset_overload_flags() override;
};
 
class MMulBlockHAL_FullAutoCalibration : public MMulBlockHAL_V_1_0_X {
public:
  explicit MMulBlockHAL_FullAutoCalibration(bus::addr_t block_address) : MMulBlockHAL_V_1_0_X(block_address) {}
 
  virtual bool write_calibration_gain(uint8_t idx, uint8_t gain) = 0;
};
 
class MMulBlockHAL_V_1_M1_X : public MMulBlockHAL_FullAutoCalibration {
protected:
  functions::AD8402 f_gain_ch0_1;
  functions::AD8402 f_gain_ch2_3;
 
public:
  explicit MMulBlockHAL_V_1_M1_X(bus::addr_t block_address);
 
  bool write_calibration_gain(uint8_t idx, uint8_t gain) override;
};
 
class MMulBlockHAL_V_1_1_X : public MMulBlockHAL_FullAutoCalibration {
protected:
  functions::AD8403 f_gain;
 
public:
  explicit MMulBlockHAL_V_1_1_X(bus::addr_t block_address);
 
  bool write_calibration_gain(uint8_t idx, uint8_t gain) override;
};
 
struct __attribute__((packed)) MultiplierCalibration {
  uint16_t offset_x = MMulBlockHAL_V_1_0_X::float_to_raw_calibration(0.0f),
           offset_y = MMulBlockHAL_V_1_0_X::float_to_raw_calibration(0.0f),
           offset_z = MMulBlockHAL_V_1_0_X::float_to_raw_calibration(0.0f);
  // Raw DAC values, because we need to step through them. Set to zero offset at first
 
  uint8_t gain = 127; // Raw gain value, for step through. Equals mid setting
};
 
class MMulBlock : public MBlock::MBlock {
public:
  // Entity hardware identifier information.
  static constexpr auto TYPE = MBlock::TYPES::M_MUL4_BLOCK;
 
  static MMulBlock *from_entity_classifier(entities::EntityClassifier classifier, bus::addr_t block_address);
 
public:
  static constexpr uint8_t NUM_MULTIPLIERS = 4;
 
  static constexpr std::array<uint8_t, NUM_MULTIPLIERS * 2> MULTIPLIERS_INPUT_RANGE() {
    return {0, 1, 2, 3, 4, 5, 6, 7};
  };
 
  static constexpr std::array<uint8_t, NUM_MULTIPLIERS> MULTIPLIERS_OUTPUT_RANGE() { return {0, 1, 2, 3}; };
 
protected:
  MMulBlockHAL *hardware;
 
  std::array<MultiplierCalibration, NUM_MULTIPLIERS> calibration{};
 
public:
  using MBlock::MBlock;
  MMulBlock(SLOT slot, MMulBlockHAL *hardware);
 
  metadata::eui_t get_entity_eui() const override;
 
  MMulBlock(bus::addr_t block_address, MMulBlockHAL *hardware);
 
  bool init() override;
 
  [[nodiscard]] utils::status write_to_hardware() override;
 
  bool calibrate(platform::Cluster *cluster, carrier::Carrier *carrier) override;
 
  void reset(entities::ResetAction action);
 
  [[nodiscard]] const std::array<MultiplierCalibration, NUM_MULTIPLIERS> &get_calibration() const;
  [[nodiscard]] blocks::MultiplierCalibration get_calibration(uint8_t mul_idx) const;
  virtual utils::status write_calibration_to_hardware();
 
protected:
  utils::status config_self_from_json(JsonObjectConst cfg) override;
  utils::status _config_elements_from_json(const JsonVariantConst &cfg);
  void config_self_to_json(JsonObject &cfg) override;
};
 
class MMulBlock_FullAutoCalibration : public MMulBlock {
public:
  MMulBlock_FullAutoCalibration(SLOT slot, blocks::MMulBlockHAL_FullAutoCalibration *hardware);
 
public:
  bool calibrate(platform::Cluster *cluster, carrier::Carrier *carrier) override;
  utils::status write_calibration_to_hardware() override;
 
protected:
  MMulBlockHAL_FullAutoCalibration *hardware;
};
 
} // namespace blocks