mblock_mul.cpp

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 "carrier/carrier.h"
#include "carrier/cluster.h"
 
#include "block/mblock.h"
#include "teensy/mblock_mul.h"
 
#include "block/mul_calibration.h"
 
extern int abs_clamp(float in, int min, int max);
 
blocks::MMulBlock *blocks::MMulBlock::from_entity_classifier(entities::EntityClassifier classifier,
                                                                      const bus::addr_t block_address) {
  if (!classifier or classifier.class_enum != CLASS_ or classifier.type != static_cast<uint8_t>(TYPE))
    return nullptr;
 
  // Currently, there are no different variants
  if (classifier.variant != entities::EntityClassifier::DEFAULT_)
    return nullptr;
 
  SLOT slot = block_address % 8 == 4 ? SLOT::M0 : SLOT::M1;
  // Return default implementation
  if (classifier.version < entities::Version(1))
    return nullptr;
  if (classifier.version < entities::Version(1, 1)) {
    auto *new_block = new MMulBlock(slot, new MMulBlockHAL_V_1_0_X(block_address));
    new_block->classifier = classifier;
    return new_block;
  }
  if (classifier.version <= entities::Version(1, 2)) {
    auto *new_block = new MMulBlock_FullAutoCalibration(slot, new MMulBlockHAL_V_1_1_X(block_address));
    new_block->classifier = classifier;
    return new_block;
  }
  if (classifier.version == entities::Version(1, -1)) {
    auto *new_block = new MMulBlock_FullAutoCalibration(slot, new MMulBlockHAL_V_1_M1_X(block_address));
    new_block->classifier = classifier;
    return new_block;
  }
  return nullptr;
}
 
UnitResult blocks::MMulBlock::calibrate(platform::Cluster *cluster, carrier::Carrier *carrier) {
  LOG(ANABRID_DEBUG_CALIBRATION, __PRETTY_FUNCTION__);
  TRY(calibrate_mul(carrier, cluster, this, calibration));
  return UnitResult::ok();
}
 
// V1.-1.0
blocks::MMulBlock_FullAutoCalibration::MMulBlock_FullAutoCalibration(
    blocks::MBlock::SLOT slot, blocks::MMulBlockHAL_FullAutoCalibration *hardware)
    : MMulBlock(slot, hardware), hardware(hardware) {}
 
UnitResult blocks::MMulBlock_FullAutoCalibration::write_calibration_to_hardware() {
  TRY(MMulBlock::write_calibration_to_hardware());
 
  for (size_t i = 0; i < MMulBlock::NUM_MULTIPLIERS; i++) {
    if (!hardware->write_calibration_gain(i, calibration[i].gain))
      return UnitResult::err_fmt("MMulBlock::calibration from json for multiplier %d values gain not accepted", i);
  }
  return UnitResult::ok();
}
 
// Hardware abstraction layer
blocks::MMulBlockHAL_V_1_0_X::MMulBlockHAL_V_1_0_X(bus::addr_t block_address)
    : MMulBlockHAL_Parent(block_address, 7), f_overload_flags_reset(bus::address_from_tuple(block_address, 3)),
      f_overload_flags(bus::replace_function_idx(block_address, 2), 7),
      f_calibration_dac_0(bus::address_from_tuple(block_address, 4), 7, 2.0f),
      f_calibration_dac_1(bus::address_from_tuple(block_address, 5), 7, 2.0f) {}
 
UnitResult blocks::MMulBlockHAL::init() { return MBlockHAL::init(); }
 
UnitResult blocks::MMulBlockHAL_V_1_0_X::init() {
  bool error = true;
  error &= f_calibration_dac_0.init();
  error &= f_calibration_dac_0.set_external_reference();
  error &= f_calibration_dac_0.set_double_gain();
  error &= f_calibration_dac_1.init();
  error &= f_calibration_dac_1.set_external_reference();
  error &= f_calibration_dac_1.set_double_gain();
  error &= MMulBlockHAL::init();
  if (!error)
    return UnitResult::err("Failed mmul-blck writing hardware");
  return UnitResult::ok();
}
 
void blocks::MMulBlockHAL_V_1_0_X::reset_overload_flags() { f_overload_flags_reset.trigger(); }
 
bool blocks::MMulBlockHAL_V_1_0_X::write_calibration_input_offsets(uint8_t idx, uint16_t offset_x,
                                                                            uint16_t offset_y) {
  return f_calibration_dac_0.set_channel_raw(idx * 2, offset_x) and
         f_calibration_dac_0.set_channel_raw(idx * 2 + 1, offset_y);
}
 
bool blocks::MMulBlockHAL_V_1_0_X::write_calibration_output_offset(uint8_t idx, uint16_t offset_z) {
  return f_calibration_dac_1.set_channel_raw(idx, offset_z);
}
 
std::bitset<8> blocks::MMulBlockHAL_V_1_0_X::read_overload_flags() {
  return f_overload_flags.read8();
}
 
blocks::MMulBlockHAL_V_1_M1_X::MMulBlockHAL_V_1_M1_X(bus::addr_t block_address)
    : MMulBlockHAL_V_1_0_X(block_address), f_gain_ch0_1(bus::replace_function_idx(block_address, 6), 7),
      f_gain_ch2_3(bus::replace_function_idx(block_address, 7), 7) {}
 
bool blocks::MMulBlockHAL_V_1_M1_X::write_calibration_gain(uint8_t idx, uint8_t gain) {
  if (idx < 2)
    return f_gain_ch0_1.write_channel_raw(idx, gain);
  else if (idx < 4)
    return f_gain_ch2_3.write_channel_raw(idx - 2, gain);
  else
    return false;
}
 
blocks::MMulBlockHAL_V_1_1_X::MMulBlockHAL_V_1_1_X(bus::addr_t block_address)
    : MMulBlockHAL_V_1_0_X(block_address), f_gain(bus::replace_function_idx(block_address, 6), 7) {}
 
bool blocks::MMulBlockHAL_V_1_1_X::write_calibration_gain(uint8_t idx, uint8_t gain) {
  if (idx == 0)
    return f_gain.write_channel_raw(2, gain);
  else if (idx == 1)
    return f_gain.write_channel_raw(0, gain);
  else if (idx == 2)
    return f_gain.write_channel_raw(1, gain);
  if (idx == 3)
    return f_gain.write_channel_raw(3, gain);
  return false;
}