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 "block/mblock.h"
#include "utils/logging.h"
 
#include "entity/entity.h"
#include "etl/crc.h"
 
#include "carrier/carrier.h"
#include "carrier/cluster.h"
 
#include "teensy/mblock_mul.h"
#include <chips/AD840X.h>
#include <chips/DAC60508.h>
#include <chips/SR74HC16X.h>
#include <chips/SR74HCT595.h>
 
extern int abs_clamp(float in, int min, int max);
 
// V1.-1.0
 
FLASHMEM utils::status blocks::MMulBlock_FullAutoCalibration::write_calibration_to_hardware() {
  auto res = MMulBlock::write_calibration_to_hardware();
  if (!res)
    return res;
 
  for (size_t i = 0; i < MMulBlock::NUM_MULTIPLIERS; i++) {
    if (!hardware->write_calibration_gain(i, calibration[i].gain))
      return utils::status(777, "MMulBlock::calibration from json for multiplier %d values gain not accepted",
                           i);
  }
  return utils::status::success();
}
 
FLASHMEM bool blocks::MMulBlock_FullAutoCalibration::calibrate(platform::Cluster *cluster,
                                                               carrier::Carrier *carrier) {
  LOG(ANABRID_DEBUG_CALIBRATION, __PRETTY_FUNCTION__);
 
  // First do regular calibration
  bool success = MMulBlock::calibrate(cluster, carrier);
 
  // Automatic gain calibration can only be done by version 1.1
  LOG(ANABRID_DEBUG_CALIBRATION, "Calibrating output gains...");
 
  for (auto idx = 0u; idx < NUM_MULTIPLIERS; idx++) {
    if (!cluster->cblock->set_factor(slot_to_global_io_index(idx * 2),
                                     1.0f)) // Setting 1.0 to Y inputs which previously were 0.0
      return false;                         // fatal error
  }
  if (!cluster->cblock->write_to_hardware())
    return false; // fatal error
  // When changing a factor, we always have to calibrate offset
  if (!cluster->calibrate_offsets())
    return false; // fatal error
 
  delay(10);
 
  const float target_precision = 0.0005f;
  const int max_loops = 100;
 
  std::bitset<NUM_MULTIPLIERS> done_channels;
  int loop_count = 0;
 
  // start varying the gain factors
  while (!done_channels.all()) {
    auto read_outputs = daq::average(daq::sample, 4, 10);
 
    for (auto idx = 0u; idx < NUM_MULTIPLIERS; idx++) {
      if (fabs(read_outputs[idx] - 1.0f) < target_precision) {
        done_channels[idx] = true; // Already precice
        continue;
      }
      done_channels[idx] = false;
 
      // Little bounded proportional controller, to decrease calibration time
      int step = abs_clamp((read_outputs[idx] - 1.0f) * -1000.0f, 1, 70);
 
      if (calibration[idx].gain + step > 0xff || calibration[idx].gain + step < 0) {
        success = false; // Out of bounds for factor
        done_channels[idx] = true;
        continue;
      }
 
      calibration[idx].gain += step;
 
      if (!hardware->write_calibration_gain(idx, calibration[idx].gain)) {
        success = false; // Other issues
        done_channels[idx] = true;
        continue;
      }
    }
    delay(10); // Small transient time
 
    loop_count++;
    if (loop_count > max_loops) {
      LOG(ANABRID_DEBUG_CALIBRATION, "Calibration timed out!");
      break;
    }
  }
 
  return success;
}
 
// Hardware abstraction layer
 
FLASHMEM blocks::MMulBlockHAL_V_1_0_X::MMulBlockHAL_V_1_0_X(bus::addr_t block_address)
    : f_meta(block_address), f_overload_flags_reset(bus::address_from_tuple(block_address, 3)),
      f_overload_flags(bus::replace_function_idx(block_address, 2)),
      f_calibration_dac_0(bus::address_from_tuple(block_address, 4), 2.0f),
      f_calibration_dac_1(bus::address_from_tuple(block_address, 5), 2.0f) {}
 
FLASHMEM bool blocks::MMulBlockHAL::init() { return MBlockHAL::init(); }
 
FLASHMEM bool 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();
  return error;
}
 
FLASHMEM void blocks::MMulBlockHAL_V_1_0_X::reset_overload_flags() { f_overload_flags_reset.trigger(); }
 
FLASHMEM 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 + 1, offset_x) and
         f_calibration_dac_0.set_channel_raw(idx * 2, offset_y);
}
 
FLASHMEM 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);
}
 
FLASHMEM std::bitset<8> blocks::MMulBlockHAL_V_1_0_X::read_overload_flags() {
  return f_overload_flags.read8();
}
 
blocks::MMulBlock_FullAutoCalibration::MMulBlock_FullAutoCalibration(SLOT slot,
                                                                     blocks::MMulBlockHAL_V_1_M1_X *hardware)
    : MMulBlock(slot, hardware), hardware(hardware) {}
 
FLASHMEM 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)),
      f_gain_ch2_3(bus::replace_function_idx(block_address, 7)) {}
 
FLASHMEM 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;
}