carrier.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 <carrier/carrier.h>
#include <mode/mode.h>
#include <net/settings.h>
#include <utils/is_number.h>
 
#ifdef ANABRID_BROKEN_EEPROM_WORKAROUND
#include "block/teensy/ctrlblock.h" // in hardware library
#endif
 
// Keep in mind:
// Carrier is not a regular Entity: It lacks an EEPROM.
// However it has a temperature sensor.
 
FLASHMEM carrier::Carrier::Carrier(std::vector<platform::Cluster> clusters, carrier::Carrier_HAL *hardware)
    : Entity("", hardware), hardware(hardware), clusters(std::move(clusters)) {
  classifier.class_enum = CLASS_;
}
 
FLASHMEM utils::status carrier::Carrier::better_init() {
  LOG(ANABRID_DEBUG_INIT, __PRETTY_FUNCTION__);
 
  entity_id = net::StartupConfig::get().mac;
 
  if (entity_id.empty())
    return utils::status("Cannot determine Carrier MAC");
 
  // Detect CTRL-block
  ctrl_block = entities::detect<blocks::CTRLBlock>(bus::address_from_tuple(1, 0));
  if (!ctrl_block) {
    #ifndef ANABRID_BROKEN_EEPROM_WORKAROUND
    return utils::status("Missing CTRL Block");
    #else
    LOG_ALWAYS("Error: Cannot detect Control Block. Continuing");
    ctrl_block = new blocks::CTRLBlock(new blocks::CTRLBlockHAL_V_1_0_2(1));
    #endif
  }
 
  for (auto &cluster : clusters) {
    if (!cluster.init())
      return utils::status("Cannot initialize cluster");
  }
 
  reset(entities::ResetAction::EVERYTHING);
 
  return utils::status::success();
}
 
FLASHMEM std::vector<entities::Entity *> carrier::Carrier::get_child_entities() {
  std::vector<entities::Entity *> children;
  for (auto &cluster : clusters) {
    children.push_back(&cluster);
  }
  if (ctrl_block)
    children.push_back(ctrl_block);
  return children;
}
 
FLASHMEM entities::Entity *carrier::Carrier::get_child_entity(const std::string &child_id) {
  if (utils::is_number(child_id.begin(), child_id.end())) {
    auto cluster_idx = std::stol(child_id);
    if (cluster_idx < 0 or clusters.size() < cluster_idx)
      return nullptr;
    return &clusters[cluster_idx];
  }
  if (child_id == "CTRL")
    return ctrl_block;
  return nullptr;
}
 
FLASHMEM utils::status carrier::Carrier::config_self_from_json(JsonObjectConst cfg) {
  // TODO: Have an option to fail on unexpected configuration
  return utils::status::success();
}
 
FLASHMEM utils::status carrier::Carrier::write_to_hardware() {
  utils::status error;
  int cluster_index = 1;
  for (auto &cluster : clusters) {
    if (!cluster.write_to_hardware()) {
      error.code += cluster_index; // maxes to 6 = 0b110
      error.msg += "Cluster write failed.";
    }
    cluster_index++;
  }
  if (ctrl_block && !ctrl_block->write_to_hardware()) {
    error.code |= 0x8;
    error.msg += "CTRL Block write failed.";
  }
  if (!hardware->write_adc_bus_mux(adc_channels)) {
    error.code |= 0x10;
    error.msg += "ADC Bus write failed.";
  }
  return error;
}
 
FLASHMEM bool carrier::Carrier::calibrate_offset() {
  for (auto &cluster : clusters)
    if (!cluster.calibrate_offsets())
      return false;
  return true;
}
 
FLASHMEM bool carrier::Carrier::calibrate_routes_in_cluster(platform::Cluster &cluster) {
  // Save and change ADC bus selection
  auto old_adcbus = ctrl_block->get_adc_bus();
  ctrl_block->set_adc_bus_to_cluster_gain(cluster.get_cluster_idx());
  if (!ctrl_block->write_to_hardware())
    return false;
 
  // Calibrate routes in cluster
  if (!cluster.calibrate_routes())
    return false;
 
  // Restore ADC bus selection
  ctrl_block->set_adc_bus(old_adcbus);
  if (!ctrl_block->write_to_hardware())
    return false;
 
  return true;
}
 
FLASHMEM bool carrier::Carrier::calibrate_routes() {
  for (auto &cluster : clusters) {
    if (!calibrate_routes_in_cluster(cluster))
      return false;
  }
  return true;
}
 
FLASHMEM bool carrier::Carrier::calibrate_mblock(platform::Cluster &cluster, blocks::MBlock &mblock) {
  // CARE: This function does not preserve the currently configured routes
  LOG(ANABRID_DEBUG_CALIBRATION, __PRETTY_FUNCTION__);
 
  bool success = true;
 
  // The calibration for each M-Block is prepared by connecting all outputs
  // to the ADCs. This limits the calibration to one M-Block (and one cluster) at a time,
  // which is not a problem though.
  // Each M-Block must connect required reference signals by itself.
 
  LOG(ANABRID_DEBUG_CALIBRATION, "Connecting outputs to ADC...");
  for (auto output_idx : blocks::MBlock::SLOT_OUTPUT_IDX_RANGE()) {
    auto lane_idx = mblock.slot_to_global_io_index(output_idx);
    if (!set_adc_channel(output_idx, lane_idx))
      return false;
  }
  // Write to hardware
  if (!write_to_hardware())
    return false;
 
  // Pass to calibration function
  LOG(ANABRID_DEBUG_CALIBRATION, "Passing control to M-block...");
  success &= mblock.calibrate(&cluster, this);
 
  LOG(ANABRID_DEBUG_CALIBRATION, "Cleanup ADC connections...");
  reset_adc_channels();
 
  LOG(ANABRID_DEBUG_CALIBRATION, "Cleaning up calibration signals...");
  reset(entities::ResetAction::CIRCUIT_RESET);
 
  // Write final clean-up to hardware
  if (!write_to_hardware())
    return false;
 
  LOG(ANABRID_DEBUG_CALIBRATION, "Calibration done.");
 
  return success;
}
 
FLASHMEM bool carrier::Carrier::calibrate_m_blocks() {
  bool success = true;
  for (auto &cluster : clusters)
    for (auto mblock : {cluster.m0block, cluster.m1block}) {
      if (mblock)
        if (!calibrate_mblock(cluster, *mblock))
          success = false;
    }
  return success;
}
 
FLASHMEM void carrier::Carrier::reset(entities::ResetAction action) {
  for (auto &cluster : clusters) {
    cluster.reset(action);
  }
  if (ctrl_block)
    ctrl_block->reset(action);
  reset_adc_channels();
}
 
FLASHMEM const std::array<int8_t, 8> &carrier::Carrier::get_adc_channels() const { return adc_channels; }
 
FLASHMEM bool carrier::Carrier::set_adc_channels(const std::array<int8_t, 8> &channels) {
  // Check that all inputs are < 15
  for (auto channel : channels) {
    if (channel > 15)
      return false;
  }
  // Check that all inputs are different
  // This is actually not necessary, in principle one could split one signal to multiple ADC.
  // But for now we prohibit this, as it's more likely an error than an actual use-case.
  for (auto &channel : channels) {
    if (channel < 0)
      continue;
    for (auto &other_channel : channels) {
      if (std::addressof(channel) == std::addressof(other_channel))
        continue;
      if (channel == other_channel)
        return false;
    }
  }
  adc_channels = channels;
  return true;
}
 
FLASHMEM bool carrier::Carrier::set_adc_channel(uint8_t idx, int8_t adc_channel) {
  if (idx >= adc_channels.size())
    return false;
  if (adc_channel < 0)
    adc_channel = ADC_CHANNEL_DISABLED;
 
  // Check if channel is already routed to an ADC
  // This is not really necessary, but probably a good idea (see set_adc_channels)
  if (adc_channel != ADC_CHANNEL_DISABLED)
    for (auto other_idx = 0u; other_idx < adc_channels.size(); other_idx++)
      if (idx != other_idx and adc_channels[other_idx] == adc_channel)
        return false;
 
  adc_channels[idx] = adc_channel;
  return true;
}
 
FLASHMEM void carrier::Carrier::reset_adc_channels() {
  std::fill(adc_channels.begin(), adc_channels.end(), ADC_CHANNEL_DISABLED);
}
 
FLASHMEM utils::status carrier::Carrier::user_set_extended_config(JsonObjectConst msg_in,
                                                                  JsonObject &msg_out) {
#ifdef ANABRID_DEBUG_COMMS
  Serial.println(__PRETTY_FUNCTION__);
#endif
 
  bool default_reset_before = true, default_sh_kludge = true, default_mul_calib_kludge = true,
       default_calibrate_mblock = false, default_calibrate_offset = false, default_calibrate_routes = false;
 
  if (msg_in["reset_before"] | default_reset_before) {
    reset(entities::ResetAction::CIRCUIT_RESET | entities::ResetAction::OVERLOAD_RESET |
          entities::ResetAction::CALIBRATION_RESET);
    write_to_hardware();
  }
 
  if (msg_in["sh_kludge"] | default_sh_kludge) {
    for (auto &cluster : clusters) {
      if (cluster.shblock) {
        cluster.shblock->set_state(blocks::SHState::TRACK);
        /*cluster.shblock->*/ write_to_hardware();
        delayMicroseconds(1000);
        cluster.shblock->set_state(blocks::SHState::INJECT);
        /*cluster.shblock->*/ write_to_hardware();
      }
    }
  }
 
  if ((msg_in["calibrate_mblock"] | default_calibrate_mblock) && !calibrate_m_blocks())
    return utils::status(10, "Calibrate MBlocks failed");
 
  auto res = user_set_config(msg_in, msg_out);
 
  if (!res)
    return res;
 
  if ((msg_in["calibrate_offset"] | default_calibrate_offset) && !calibrate_offset())
    return utils::status(10, "Calibrate-offset failed");
 
  if ((msg_in["calibrate_routes"] | default_calibrate_routes) && !calibrate_routes())
    return utils::status(10, "Calibrate-Routes failed");
 
  return utils::status::success();
}
 
FLASHMEM utils::status carrier::Carrier::user_get_overload_status(JsonObjectConst msg_in,
                                                                  JsonObject &msg_out) {
  msg_out["global_overload"] = mode::is_global_overload_active();
 
  auto flags = msg_out.createNestedObject("entity_overload");
  for (auto &cluster : clusters) {
    auto cluster_obj = flags.createNestedObject("/" + cluster.get_entity_id());
    for (auto &block : cluster.get_blocks()) {
      /*if (block && block->is_entity_class(blocks::MMulBlock::CLASS_)) {
        auto *mblock = static_cast<blocks::MBlock *>(block);
        auto block_obj = cluster_obj.createNestedArray("/" + block->get_entity_id());
        mblock->overload_flags_to_json(block_obj);
      }*/
    }
  }
 
  return utils::status::success();
}