mblock_mdr.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_mdr.h"
#include <block/teensy/mblock_mdr.h>
 
using namespace blocks;
 
extern int abs_clamp(float in, int min, int max);
 
blocks::MMDRBlock *blocks::MMDRBlock::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 MMDRBlock(slot, new MMDRBlockHAL_V_1_0_X(block_address));
    new_block->classifier = classifier;
    return new_block;
  }
  return nullptr;
}
 
UnitResult blocks::MMDRBlock::calibrate(platform::Cluster *cluster, carrier::Carrier *carrier) {
  LOG(ANABRID_DEBUG_CALIBRATION, __PRETTY_FUNCTION__);
 
  // Our first simple calibration process has been developed empirically and goes
  // 1. Set all inputs to zero
  //    - The input offsets are rather small, so inputs are 0+-epsilon
  //    - The output is then roughly 0 + epsilon^2 - offset_z ~= -offset_z
  // 2. Measure output and use it as a first estimate of offset_z
  // 3. Set inputs to 0 and 1 and change the first one's offset to get an output close to zero
 
  TRY(MBlock::calibrate(cluster, carrier));
 
  // TODO: keep old circuits alive
  cluster->reset(entities::ResetAction::CIRCUIT_RESET);
 
  // We can't iterativly calibrate, so we need to delete the old calibration values.
  reset(entities::ResetAction::CALIBRATION_RESET);
 
  // Connect zeros to all our inputs
  LOG(ANABRID_DEBUG_CALIBRATION, "Calibrating output offsets...");
  for (auto idx : SLOT_INPUT_IDX_RANGE())
    TRY(cluster->add_constant(UBlock::Transmission_Mode::GROUND, slot_to_global_io_index(idx), 0.0f,
                                         slot_to_global_io_index(idx)));
  TRY(cluster->write_to_hardware());
 
  // When setting routes we need to calibrate them
  TRY(carrier->calibrate_routes());
 
  // Measure offset_z and set it
  auto read_outputs = daq::average(daq::sample, 4, 10);
 
  for (auto idx = 0u; idx < NUM_CELLS; idx++) {
    calibration[idx].offset_z = MMDRBlockHAL_V_1_0_X::float_to_raw_calibration(-read_outputs[idx]);
    if (!hardware->write_calibration_output_offset(idx, calibration[idx].offset_z))
      return UnitResult::err("Writing output offsets failed");
  }
  delay(10); // Small transient time
 
  // Set some inputs to one
  LOG(ANABRID_DEBUG_CALIBRATION, "Calibrating x input offsets...");
  cluster->ublock->change_b_side_transmission_mode(UBlock::Transmission_Mode::POS_REF); // Set constant source
  for (auto idx = 0u; idx < NUM_CELLS; idx++)
    TRY(cluster->cblock->set_factor(slot_to_global_io_index(idx * 2), 1.0f)); // Setting 1.0 to Y inputs
 
  TRY(cluster->cblock->write_to_hardware());
  // When changing a factor, we always have to calibrate offset
  TRY(cluster->calibrate_offsets());
 
  delay(10);
 
  const float target_precision = 0.0005f;
  const int max_loops = 100;
 
  std::bitset<NUM_CELLS> done_channels;
  int loop_count = 0;
 
  // start varying the x input offsets
  while (!done_channels.all()) {
    read_outputs = daq::average(daq::sample, 4, 10);
 
    for (auto idx = 0u; idx < NUM_CELLS; idx++) {
      if (fabs(read_outputs[idx]) < target_precision) {
        done_channels[idx] = true; // Already precice
        continue;
      }
      done_channels[idx] = false;
 
      // Little bounded proportional controller, to decrease calibration time
      calibration[idx].offset_x += abs_clamp(read_outputs[idx] * 6000.0f, 1, 50);
 
      if (!hardware->write_calibration_input_offsets(idx, calibration[idx].offset_x,
                                                     calibration[idx].offset_y)) {
        calibration[idx].offset_x = std::clamp(calibration[idx].offset_x, MMDRBlockHAL_V_1_0_X::RAW_ZERO,
                                               MMDRBlockHAL_V_1_0_X::RAW_MAX);
        return UnitResult::err("Input X offsets out of range");
      }
    }
    delay(10); // Small transient time
 
    loop_count++;
    if (loop_count > max_loops) {
      return UnitResult::err("Calibration timed out!");
    }
  }
 
  LOG(ANABRID_DEBUG_CALIBRATION, "Calibrating y input offsets...");
  for (auto idx = 0u; idx < NUM_CELLS; idx++) {
    // Setting 0.0 to Y inputs which previously were 1.0
    // Setting 1.0 to X inputs
    TRY(cluster->cblock->set_factor(slot_to_global_io_index(idx * 2), 0.0f));
    TRY(cluster->cblock->set_factor(slot_to_global_io_index(idx * 2 + 1), 1.0f));
  }
  TRY(cluster->cblock->write_to_hardware());
  // When changing a factor, we always have to calibrate offset
  TRY(cluster->calibrate_offsets());
 
  delay(10);
 
  read_outputs = daq::average(daq::sample, 4, 10);
 
  done_channels.reset();
  loop_count = 0;
 
  // start varying the y input offsets
  while (!done_channels.all()) {
    read_outputs = daq::average(daq::sample, 4, 10);
 
    for (auto idx = 0u; idx < NUM_CELLS; idx++) {
      if (fabs(read_outputs[idx]) < target_precision) {
        done_channels[idx] = true; // Already precice
        continue;
      }
      done_channels[idx] = false;
 
      // Little bounded proportional controller, to decrease calibration time
      calibration[idx].offset_y += abs_clamp(read_outputs[idx] * 6000.0f, 1, 50);
 
      if (!hardware->write_calibration_input_offsets(idx, calibration[idx].offset_x,
                                                     calibration[idx].offset_y)) {
        calibration[idx].offset_y = std::clamp(calibration[idx].offset_y, MMDRBlockHAL_V_1_0_X::RAW_ZERO,
                                               MMDRBlockHAL_V_1_0_X::RAW_MAX);
        return UnitResult::err("Input Y offsets out of range");
        done_channels[idx] = true;
        continue;
      }
    }
    delay(10); // Small transient time
 
    loop_count++;
    if (loop_count > max_loops) {
      return UnitResult::err("Calibration timed out!");
    }
  }
 
  LOG(ANABRID_DEBUG_CALIBRATION, "Calibrating output gains...");
 
  // Setting 1.0 to Y inputs which previously were 0.0
  for (auto idx = 0u; idx < NUM_CELLS; idx++)
    TRY(cluster->cblock->set_factor(slot_to_global_io_index(idx * 2), 1.0f));
 
  TRY(cluster->cblock->write_to_hardware());
  // When changing a factor, we always have to calibrate offset
  TRY(cluster->calibrate_offsets());
 
  delay(10);
 
  loop_count = 0;
  done_channels.reset();
 
  // start varying the gain factors
  while (!done_channels.all()) {
    read_outputs = daq::average(daq::sample, 4, 10);
 
    for (auto idx = 0u; idx < NUM_CELLS; 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) {
        return UnitResult::err("Output gain out of range");
        done_channels[idx] = true;
        continue;
      }
 
      calibration[idx].gain += step;
 
      if (!hardware->write_calibration_gain(idx, calibration[idx].gain)) {
        return UnitResult::err("Writing output gain failed");
        done_channels[idx] = true;
        continue;
      }
    }
    delay(10); // Small transient time
 
    loop_count++;
    if (loop_count > max_loops) {
      return UnitResult::err("Calibration timed out!");
    }
  }
 
  return UnitResult::ok();
}
 
UnitResult blocks::MMDRBlockHAL::init() { return MBlockHAL::init(); }
 
MMDRBlockHAL_V_1_0_X::MMDRBlockHAL_V_1_0_X(bus::addr_t block_address)
    : MMDRBlockHAL_Parent(block_address, 0xff),
      f_overload_flags(bus::replace_function_idx(block_address, 2), 0xff),
      f_overload_flags_reset(bus::replace_function_idx(block_address, 3)),
      f_calibration_dac_0(bus::address_from_tuple(block_address, 4), 0xff, 2.0f),
      f_calibration_dac_1(bus::address_from_tuple(block_address, 5), 0xff, 2.0f),
      f_gain(bus::replace_function_idx(block_address, 6), 0xff),
      f_mode_config(bus::address_from_tuple(block_address, 7), 0xff, true),
      f_mode_config_sync(bus::address_from_tuple(block_address, 8)) {}
 
std::bitset<8> MMDRBlockHAL_V_1_0_X::read_overload_flags() { return f_overload_flags.read8(); }
 
void MMDRBlockHAL_V_1_0_X::reset_overload_flags() { f_overload_flags_reset.trigger(); }
 
bool MMDRBlockHAL_V_1_0_X::write_modes(MMDRBlock::CellMode m0, MMDRBlock::CellMode m1, MMDRBlock::CellMode m2,
                                       MMDRBlock::CellMode m3) {
  // Output of SR is
  // Last bit shifted in > [4bit Cell 3][4 bit Cell 2][4 bit Cell 1][4 bit Cell 0] < First bit shifted in
  // Data is transfered MSBFIRST, so should look like
  // MSB > [4bit Cell 0][Cell 1][Cell 2][Cell 3] < LSB
  uint16_t data = (static_cast<uint16_t>(m0) << 12) | (static_cast<uint16_t>(m1) << 8) |
                  (static_cast<uint16_t>(m2) << 4) | (static_cast<uint16_t>(m3) << 0);
  if (!f_mode_config.transfer16(data))
    return false;
  f_mode_config_sync.trigger();
 
  return true;
}
 
bool MMDRBlockHAL_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);
}
 
bool MMDRBlockHAL_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);
}
 
bool MMDRBlockHAL_V_1_0_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;
}