lucidac.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 "pb_decode.h"
 
#include <entity/visitor.h>
#include <lucidac/lucidac.h>
#include <utils/mac.h>
 
platform::LUCIDAC::LUCIDAC(LUCIDAC_HAL *hardware)
    : Carrier({Cluster(0)}, hardware), hardware(hardware) {}
 
UnitResult platform::LUCIDAC::init() {
  LOG(ANABRID_DEBUG_INIT, __PRETTY_FUNCTION__);
  TRY(Carrier::init());
 
  LOG(ANABRID_DEBUG_INIT, "Detecting front panel...");
  if (!front_panel) {
    front_panel = entities::detect<LUCIDACFrontPanel>(bus::address_from_tuple(bus::FRONTPLANE_BADDR, 0));
    if (!front_panel) {
      LOG_ALWAYS("Warning: Front panel is missing or unknown.");
    } else {
      LOG(ANABRID_DEBUG_INIT, "Initialising detected front panel...");
      auto front_panel_result = front_panel->init();
      if (front_panel_result.is_err()) {
        LOG_ALWAYS("Error: Could not initialize front panel");
        return front_panel_result;
      } else {
        LOG(ANABRID_DEBUG_INIT, "Front panel initialized.");
      }
    }
  }
 
  return UnitResult::ok();
}
 
void platform::LUCIDAC::reset(entities::ResetAction action) {
  Carrier::reset(action);
  if (front_panel)
    front_panel->reset(action);
 
  if (action.has(entities::ResetAction::CIRCUIT_RESET)) {
    reset_acl_select();
    reset_adc_channels();
  }
}
 
UnitResult platform::LUCIDAC::route_in_external(uint8_t in, uint8_t i_out) {
  if (in > 7)
    return UnitResult::err("in must be less or equal to 7");
 
  TRY(clusters[0].iblock->connect(in + 24, i_out));
  return UnitResult::ok();
}
 
UnitResult platform::LUCIDAC::route_out_external(uint8_t u_in, uint8_t out, float c_factor) {
  if (out > 7)
    return UnitResult::err_fmt("out must be less or equal to 7 but is %d", out);
 
  TRY(clusters[0].ublock->connect(u_in, out + 24));
  TRY(clusters[0].cblock->set_factor(out + 24, c_factor));
  return UnitResult::ok();
}
 
std::vector<entities::Entity *> platform::LUCIDAC::get_child_entities() {
  auto entities = this->Carrier::get_child_entities();
  if (front_panel)
    entities.push_back(front_panel);
  return entities;
}
 
entities::Entity *platform::LUCIDAC::get_child_entity(std::string_view child_id) {
  if (child_id == "FP")
    return front_panel;
  return this->carrier::Carrier::get_child_entity(child_id);
}
 
UnitResult platform::LUCIDAC::write_to_hardware() {
  TRY(Carrier::write_to_hardware());
  if (front_panel) {
    auto result = front_panel->write_to_hardware();
    if (result.is_err())
      return UnitResult::err(result.err_value() + "Front Panel write failed.");
  }
  if (!hardware->write_acl(acl_select))
    UnitResult::err("Write ACL failed");
  return UnitResult::ok();
}
 
const std::array<platform::LUCIDAC::ACL, 8> &platform::LUCIDAC::get_acl_select() const {
  return acl_select;
}
 
void platform::LUCIDAC::set_acl_select(const std::array<ACL, 8> &acl_select_) {
  acl_select = acl_select_;
}
 
bool platform::LUCIDAC::set_acl_select(uint8_t idx, LUCIDAC::ACL acl) {
  if (idx >= acl_select.size())
    return false;
  acl_select[idx] = acl;
  return true;
}
 
void platform::LUCIDAC::reset_acl_select() {
  std::fill(acl_select.begin(), acl_select.end(), ACL::INTERNAL_);
}
 
// this variant of the config saves full and partial connections from the U-block
// as the Carrier class restores only
UnitResult platform::LUCIDAC::calibrate_routes() {
  LOG(ANABRID_DEBUG_CALIBRATION, __PRETTY_FUNCTION__);
 
  // collect current I-block connections (includes partial connections due to
  // analog IO)
  auto& cluster = clusters[0];
  std::array<std::vector<uint8_t>, blocks::IBlock::NUM_OUTPUTS> old_i_block_connections;
  for (auto i_out_idx : blocks::IBlock::OUTPUT_IDX_RANGE())
    for (auto i_in_idx : blocks::IBlock::INPUT_IDX_RANGE())
      if (cluster.iblock->is_connected(i_in_idx, i_out_idx))
        old_i_block_connections[i_out_idx].emplace_back(i_in_idx);
 
  // disconnect ACLs for Carrier-based calibration
  auto old_acl_selection = get_acl_select();
  reset_acl_select();
  if (!hardware->write_acl(acl_select))
    return UnitResult::err("Writing ACL before calibrate_routes() failed");
 
  TRY(Carrier::calibrate_routes());
 
  set_acl_select(old_acl_selection);
  if (!hardware->write_acl(acl_select))
    return UnitResult::err("Writing ACL after calibrate_routes() failed");
 
  // Restore I-block connections
  for (auto i_out_idx : blocks::IBlock::OUTPUT_IDX_RANGE())
    for (auto i_in_idx : old_i_block_connections[i_out_idx])
      TRY (cluster.iblock->connect(i_in_idx, i_out_idx));
 
  TRY(cluster.iblock->write_to_hardware());
 
  LOG(ANABRID_DEBUG_CALIBRATION, __PRETTY_FUNCTION__);
 
  return UnitResult::ok();
}
 
ConfigResult platform::LUCIDAC::config(const pb_Item &item) {
  if (item.which_kind == pb_Item_port_config_tag) {
    auto& port_config = item.kind.port_config;
 
    reset_acl_select();
    for (size_t idx = 0; idx < port_config.states_count ; ++idx) {
      acl_select[idx] = (port_config.states[idx] == pb_PortConfig_AclState_EXTERNAL) ? 
        ACL::EXTERNAL_ : ACL::INTERNAL_;
    }
 
    if (!hardware->write_acl(acl_select))
      return ConfigResult::err("cannot write acl select to hardware");
 
    return ConfigResult::ok(true);
  }
 
  return Carrier::config(item);
}
 
void platform::LUCIDAC::extract(entities::ExtractVisitor &collector) {
  Carrier::extract(collector);
 
  if (!collector.include_configuration()) return;
  auto& item = collector.create(pb_Item_port_config_tag);
  auto& lucidac_config = item.kind.port_config;
 
  lucidac_config.states_count = acl_select.size();
  for (size_t idx = 0; idx < acl_select.size(); idx++) {
    lucidac_config.states[idx] =
      (acl_select[idx] == ACL::EXTERNAL_)
        ? pb_PortConfig_AclState_EXTERNAL
        : pb_PortConfig_AclState_INTERNAL;
  }
}
 
UnitResult platform::LUCIDAC::calibrate_offsets() {
  LOG(ANABRID_DEBUG_CALIBRATION, __PRETTY_FUNCTION__);
 
  auto old_acl_selection = get_acl_select();
  reset_acl_select();
  if (!hardware->write_acl(acl_select))
    UnitResult::err("Writing ACL before calibrate_offsets() failed");
 
  TRY(Carrier::calibrate_offsets());
 
  set_acl_select(old_acl_selection);
  if (!hardware->write_acl(acl_select))
    UnitResult::err("Writing ACL after calibrate_offsets() failed");
 
  LOG(ANABRID_DEBUG_CALIBRATION, __PRETTY_FUNCTION__);
 
  return UnitResult::ok();
}
 
UnitResult platform::LUCIDAC::calibrate(const pb_CalibrationConfig &item) {
  TRY(Carrier::calibrate(item));
 
  if (item.gain != pb_CalibrationConfig_Kind_Disabled)
    TRY(calibrate_routes());
 
  return UnitResult::ok();
}