ublock.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 <proto/main.pb.h>
 
#include <algorithm>
 
#include <block/ublock.h>
#include <entity/visitor.h>
#include <utils/logging.h>
 
void utils::shift_5_left(uint8_t *buffer, size_t size) {
  for (size_t idx = 0; idx < size - 1; idx++) {
    auto next = buffer[idx + 1];
    // Shift by 5, leaving zeros at 0-4
    buffer[idx] <<= 5;
    buffer[idx] |= (next >> 3) & 0x1F;
  }
  buffer[size - 1] <<= 5;
}
 
blocks::UBlock::UBlock(UBlockHAL *hardware)
    : FunctionBlock("U", hardware), hardware(hardware), output_input_map{} {
  classifier.class_enum = CLASS_;
  reset_connections();
}
 
metadata::eui_t blocks::UBlock::get_entity_eui() const {
  if (hardware)
    return hardware->get_entity_eui();
  return {};
}
 
bool blocks::UBlock::_i_sanity_check(const uint8_t input) { return input < NUM_OF_INPUTS; }
 
bool blocks::UBlock::_o_sanity_check(const uint8_t output) { return output < NUM_OF_OUTPUTS; }
 
bool blocks::UBlock::_io_sanity_check(const uint8_t input, const uint8_t output) {
  return _i_sanity_check(input) && _o_sanity_check(output);
}
 
bool blocks::UBlock::connect(const uint8_t input, const uint8_t output, bool force) {
  if (!_io_sanity_check(input, output))
    return false;
 
  output_input_map[output] = input;
  return true;
}
 
bool blocks::UBlock::connect_alternative(Transmission_Mode signal_mode, const uint8_t output,
                                                  bool force, bool use_a_side) {
  if (!_o_sanity_check(output))
    return false;
 
  // Do not consider Transmission_Mode::ANALOG_INPUT a valid mode
  if (signal_mode == Transmission_Mode::ANALOG_INPUT)
    return false;
 
  // Check for other connections on the same output, unless we don't care if we overwrite them
  if (!force and _is_output_connected(output))
    return false;
 
  // Check if the transmission mode makes the specified connection impossible and if the mode can or should be
  // chnged
  if (a_side_mode != signal_mode && use_a_side) {
    // TODO: force for a-side could be added, but since there wont be much use for an a-side
    // alternative signal, you have to use force or set the correct signal mode
    if (!force)
      return false;
    change_a_side_transmission_mode(signal_mode);
  }
 
  if (b_side_mode != signal_mode && !use_a_side) {
    if (!force)
      if (is_input_connected(14) || is_input_connected(15))
        return false;
    change_b_side_transmission_mode(signal_mode);
  }
 
  // Make a one to one connection if possible. Uses Input zero as fallback
  uint8_t input;
  if (use_a_side) {
    if (output < 15)
      input = output;
    else if (output == 15)
      input = 0;
    else if (output == 30)
      input = 0;
    else
      input = output - 16;
  } else {
    if (output < 16)
      input = 15;
    else
      input = 14;
  }
 
  connect(input, output);
  return true;
}
 
void blocks::UBlock::_disconnect(const uint8_t output) { output_input_map[output] = -1; }
 
bool blocks::UBlock::disconnect(const uint8_t input, const uint8_t output) {
  if (!_io_sanity_check(input, output))
    return false;
 
  if (_is_connected(input, output)) {
    _disconnect(output);
    return true;
  } else {
    return false;
  }
}
 
bool blocks::UBlock::disconnect(const uint8_t output) {
  if (!_o_sanity_check(output))
    return false;
  _disconnect(output);
  return true;
}
 
bool blocks::UBlock::_is_connected(const uint8_t input, const uint8_t output) const {
  return output_input_map[output] == input;
}
 
bool blocks::UBlock::is_connected(const uint8_t input, const uint8_t output) const {
  if (!_io_sanity_check(input, output))
    return false;
 
  return _is_connected(input, output);
}
 
bool blocks::UBlock::_is_output_connected(const uint8_t output) const {
  return output_input_map[output] >= 0;
}
 
bool blocks::UBlock::is_output_connected(const uint8_t output) const {
  if (!_o_sanity_check(output))
    return false;
 
  return _is_output_connected(output);
}
 
bool blocks::UBlock::_is_input_connected(const uint8_t input) const {
  for (const auto &output : output_input_map)
    if (output == input)
      return true;
  return false;
}
 
bool blocks::UBlock::is_input_connected(const uint8_t input) const {
  if (!_i_sanity_check(input))
    return false;
  return _is_input_connected(input);
}
 
bool blocks::UBlock::is_anything_connected() const {
  for (auto output : OUTPUT_IDX_RANGE())
    if (_is_output_connected(output))
      return true;
  return false;
}
 
void blocks::UBlock::change_a_side_transmission_mode(const Transmission_Mode mode) {
  a_side_mode = mode;
}
 
void blocks::UBlock::change_b_side_transmission_mode(const Transmission_Mode mode) {
  b_side_mode = mode;
}
 
void blocks::UBlock::change_all_transmission_modes(const Transmission_Mode mode) {
  change_a_side_transmission_mode(mode);
  change_b_side_transmission_mode(mode);
}
 
void
blocks::UBlock::change_all_transmission_modes(const std::pair<Transmission_Mode, Transmission_Mode> modes) {
  change_a_side_transmission_mode(modes.first);
  change_b_side_transmission_mode(modes.second);
}
 
std::pair<blocks::UBlock::Transmission_Mode, blocks::UBlock::Transmission_Mode>
blocks::UBlock::get_all_transmission_modes() const {
  return std::make_pair(a_side_mode, b_side_mode);
}
 
blocks::UBlock::Reference_Magnitude blocks::UBlock::get_reference_magnitude() {
  return ref_magnitude;
}
 
void blocks::UBlock::change_reference_magnitude(blocks::UBlock::Reference_Magnitude ref) {
  ref_magnitude = ref;
}
 
utils::status blocks::UBlock::write_to_hardware() {
  if (!hardware->write_outputs(output_input_map) or
      !hardware->write_transmission_modes_and_ref({a_side_mode, b_side_mode}, ref_magnitude)) {
    LOG(ANABRID_PEDANTIC, __PRETTY_FUNCTION__);
    return utils::status::failure();
  }
  return utils::status::success();
}
 
void blocks::UBlock::reset_connections() {
  std::fill(begin(output_input_map), end(output_input_map), -1);
}
 
void blocks::UBlock::reset(entities::ResetAction action) {
  FunctionBlock::reset(action);
 
  if (action.has(entities::ResetAction::CIRCUIT_RESET)) {
    change_all_transmission_modes(blocks::UBlock::Transmission_Mode::ANALOG_INPUT);
    reset_connections();
    reset_reference_magnitude();
  }
}
 
ConfigResult blocks::UBlock::config(const pb_Config &cfg) {
#ifdef ANABRID_DEBUG_ENTITY_CONFIG
  Serial.println(__PRETTY_FUNCTION__);
#endif
  if (cfg.which_kind != pb_Config_select_config_tag)
    return ConfigResult::err("expected select block config");
 
  auto& select_config = cfg.kind.select_config;
 
  auto res = apply_outputs(select_config);
  if (!res)
    return res;
 
  res = apply_constants(select_config);
  if (!res)
    return res;
 
  return ConfigResult::ok(true);
}
 
ConfigResult blocks::UBlock::apply_outputs(const pb_SelectConfig &cfg) {
  // Handle an array of outputs
  // In this case, all outputs are reset
  reset_connections();
  for (size_t idx = 0; idx < cfg.connections_count; ++idx) {
    auto& connection = cfg.connections[idx];
    if (!connect(connection.input, connection.output))
      return ConfigResult::err("UBlock: Cannot connect input at idx");
  }
  return ConfigResult::ok(true);
}
 
ConfigResult blocks::UBlock::apply_constants(const pb_SelectConfig &cfg) {
  if (cfg.constant == pb_SelectConfig_ConstantConfig_GROUND) {
    // Turn OFF constant usage. We don't use Transmission_Mode::GROUND because
    // that's really pointless, we then also can just not connect the relevant UBlock switch.
    change_b_side_transmission_mode(blocks::UBlock::Transmission_Mode::ANALOG_INPUT);
    reset_reference_magnitude();
    return ConfigResult::ok(true);
  }else if (cfg.constant == pb_SelectConfig_ConstantConfig_POS_REF) {
    change_b_side_transmission_mode(blocks::UBlock::Transmission_Mode::POS_REF);
  }
  else if (cfg.constant == pb_SelectConfig_ConstantConfig_NEG_REF) {
    change_b_side_transmission_mode(blocks::UBlock::Transmission_Mode::NEG_REF);
  }
  else
    return ConfigResult::err_fmt("UBlock::config_self_from_pb: Ground, pos_ref or neg_ref");
 
  if (cfg.magnitude == pb_SelectConfig_Magnitude_ONE_TENTH)
    change_reference_magnitude(blocks::UBlock::Reference_Magnitude::ONE_TENTH);
  else if (cfg.magnitude == pb_SelectConfig_Magnitude_ONE) {
    change_reference_magnitude(blocks::UBlock::Reference_Magnitude::ONE);
  }
  else
    return ConfigResult::err_fmt("UBlock::config_self_from_pb: Pass +-0.1 or +-1.");
 
 
  return ConfigResult::ok(true);
}
 
void blocks::UBlock::extract(entities::ExtractVisitor &collector) {
  Entity::extract(collector);
  auto& cfg = collector.create(pb_Config_select_config_tag);
 
  // Save outputs into cfg
  auto& select_config = cfg.kind.select_config = pb_SelectConfig_init_default;
  for (uint32_t idx = 0; idx < NUM_OF_OUTPUTS; ++idx) {
    auto input = output_input_map[idx];
    if (input < 0)
      continue;
 
    select_config.connections[select_config.connections_count++] = {
      .input= static_cast<uint32_t>(output_input_map[idx]),
      .output = idx
    };
  }
 
  // Constant setting to protobuf
  // we support here much more then at the setter side, because the firmware
  // side has so much more states that simply have no representation at client side.
  switch (b_side_mode) {
  case Transmission_Mode::POS_REF:
    select_config.constant = pb_SelectConfig_ConstantConfig_POS_REF;
    break;
  case Transmission_Mode::NEG_REF:
    select_config.constant = pb_SelectConfig_ConstantConfig_NEG_REF;
    break;
  default:
    select_config.constant = pb_SelectConfig_ConstantConfig_GROUND;
    break;
  }
 
  if (ref_magnitude == Reference_Magnitude::ONE_TENTH) {
    select_config.magnitude = pb_SelectConfig_Magnitude_ONE_TENTH;
  }else {
    select_config.magnitude = pb_SelectConfig_Magnitude_ONE;
  }
}
 
void blocks::UBlock::reset_reference_magnitude() { ref_magnitude = Reference_Magnitude::ONE; }
 
bool blocks::UBlockHAL_Dummy::write_outputs(std::array<int8_t, 32> outputs) { return true; }
 
bool blocks::UBlockHAL_Dummy::write_transmission_modes_and_ref(
    std::pair<Transmission_Mode, Transmission_Mode> modes, blocks::UBlockHAL::Reference_Magnitude ref) {
  return true;
}
 
void blocks::UBlockHAL_Dummy::reset_transmission_modes_and_ref() {}