cluster.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/cluster.h"
#include "utils/logging.h"
 
#include "block/cblock.h"
#include "block/iblock.h"
#include "block/mblock.h"
#include "block/ublock.h"
 
std::array<blocks::FunctionBlock *, 6> platform::Cluster::get_blocks() const { return {m0block, m1block, ublock, cblock, iblock, shblock}; }
 
bool platform::Cluster::init() {
  LOG(ANABRID_DEBUG_INIT, __PRETTY_FUNCTION__);
 
  // Dynamically detect installed blocks
  // Check if a block is already set, which may happen with a special constructor in the future
  LOG(ANABRID_DEBUG_INIT, "Detecting installed blocks...");
  if (!m0block) {
    m0block = entities::detect<blocks::MBlock>(bus::idx_to_addr(cluster_idx, bus::M0_BLOCK_IDX, 0));
    if (!m0block)
      LOG_ERROR("Warning: M0-block is missing or unknown.");
  }
  if (!m1block) {
    m1block = entities::detect<blocks::MBlock>(bus::idx_to_addr(cluster_idx, bus::M1_BLOCK_IDX, 0));
    if (!m1block)
      LOG_ERROR("Warning: M1-block is missing or unknown.");
  }
 
  if (!ublock) {
    ublock = entities::detect<blocks::UBlock>(bus::idx_to_addr(cluster_idx, bus::U_BLOCK_IDX, 0));
    if (!ublock)
      LOG_ERROR("Error: U-block is missing or unknown.");
  }
  if (!cblock) {
    cblock = entities::detect<blocks::CBlock>(bus::idx_to_addr(cluster_idx, bus::C_BLOCK_IDX, 0));
    if (!cblock)
      LOG_ERROR("Error: C-block is missing or unknown.");
  }
  if (!iblock) {
    iblock = entities::detect<blocks::IBlock>(bus::idx_to_addr(cluster_idx, bus::I_BLOCK_IDX, 0));
    if (!iblock)
      LOG_ERROR("Error: I-block is missing or unknown.");
  }
  if (!shblock) {
    shblock = entities::detect<blocks::SHBlock>(bus::idx_to_addr(cluster_idx, bus::SH_BLOCK_IDX, 0));
    if (!shblock)
      LOG_ERROR("Error: SH-block is missing or unknown.");
  }
 
  LOG(ANABRID_DEBUG_INIT, "Initialising detected blocks...");
  for (auto block : get_blocks()) {
    if (block && !block->init())
      return false;
  }
  LOG(ANABRID_DEBUG_INIT, "Cluster initialized.");
  reset(entities::ResetAction::EVERYTHING);
  return true;
}
 
platform::Cluster::Cluster(uint8_t cluster_idx) : entities::Entity(std::to_string(cluster_idx)), cluster_idx(cluster_idx) {
  classifier.class_enum = CLASS_;
}
 
status platform::Cluster::calibrate_offsets() {
  LOG(ANABRID_DEBUG_INIT, __PRETTY_FUNCTION__);
 
  status success;
 
  LOG_ANABRID_DEBUG_CALIBRATION("Calibrating offsets");
  if (!ublock or !shblock)
    success.attach("Writing to u-block failed");
 
  auto old_transmission_modes = ublock->get_all_transmission_modes();
 
  ublock->change_all_transmission_modes(blocks::UBlock::Transmission_Mode::GROUND);
  if (!ublock->write_to_hardware())
    success.attach("Writing to u-block failed");
 
  delay(10);
  shblock->compensate_hardware_offsets();
 
  ublock->change_all_transmission_modes(old_transmission_modes);
  if (!ublock->write_to_hardware())
    success.attach("Writing to u-block failed");
 
  delay(10);
 
  LOG(ANABRID_DEBUG_INIT, __PRETTY_FUNCTION__);
  return success;
}
 
status platform::Cluster::write_to_hardware() {
  status success;
  for (auto block : get_blocks())
    if (block)
      success.attach(block->write_to_hardware());
 
  return success;
}
 
status platform::Cluster::route(uint8_t u_in, uint8_t u_out, float c_factor, uint8_t i_out) {
  if (fabs(c_factor) > 1.0f) {
    c_factor = c_factor / 8.0f;
    iblock->set_upscaling(u_out, true);
  } else
    iblock->set_upscaling(u_out, false);
 
  if (!ublock->connect(u_in, u_out))
    return status("U block connection not possible");
  if (!cblock->set_factor(u_out, c_factor))
    return status("C block configuration not possible");
  if (!iblock->connect(u_out, i_out))
    return status("I block connection not possible");
  return status::success();
}
 
status platform::Cluster::add_constant(blocks::UBlock::Transmission_Mode signal_type, uint8_t u_out, float c_factor, uint8_t i_out) {
  if (fabs(c_factor) > 1.0f) {
    c_factor = c_factor / 8.0f;
    iblock->set_upscaling(u_out, true);
  } else
    iblock->set_upscaling(u_out, false);
 
  if (!ublock->connect_alternative(signal_type, u_out))
    return status("U block connection not possible");
  if (!cblock->set_factor(u_out, c_factor))
    return status("C block configuration not possible");
  if (!iblock->connect(u_out, i_out))
    return status("I block connection not possible");
  return status::success();
}
 
void platform::Cluster::reset(entities::ResetAction action) {
  for (auto block : get_blocks()) {
    if (block)
      block->reset(action);
  }
}
 
entities::Entity *platform::Cluster::get_child_entity(std::string_view child_id) {
  if (child_id == "M0")
    return m0block;
  else if (child_id == "M1")
    return m1block;
  else if (child_id == "U")
    return ublock;
  else if (child_id == "C")
    return cblock;
  else if (child_id == "I")
    return iblock;
  else if (child_id == "SH")
    return shblock;
  return nullptr;
}
 
ConfigResult platform::Cluster::config(const pb_Config &cfg) {
#ifdef ANABRID_DEBUG_ENTITY_CONFIG
  Serial.println(__PRETTY_FUNCTION__);
#endif
  // Cluster has no own configuration parameters currently
  return ConfigResult::ok(false);
}
 
std::vector<entities::Entity *> platform::Cluster::get_child_entities() {
#ifdef ANABRID_DEBUG_ENTITY_CONFIG
  Serial.println(__PRETTY_FUNCTION__);
#endif
  return {m0block, m1block, ublock, cblock, iblock, shblock};
}
 
uint8_t platform::Cluster::get_cluster_idx() const { return cluster_idx; }
 
std::pair<uint8_t, uint8_t> platform::Cluster::get_id_connection() const {
  blocks::MBlock *id_block = nullptr;
  if (m0block->has_id_lanes())
    id_block = m0block;
  if (m1block->has_id_lanes())
    id_block = m1block;
 
  if (id_block == nullptr)
    return {0xff, 0xff};
 
 
  for (uint8_t out = 0; out < 8; out++) {
    int8_t in = id_block->ID_OUTPUT_CONNECTIONS()[out];
    if (in != -1)
      return {id_block->slot_to_global_io_index(in), id_block->slot_to_global_io_index(out)};
  }
  return {0xff, 0xff};
}