iblock.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_encode.h"
 
#include <proto/main.pb.h>
 
#include <block/iblock.h>
#include <entity/visitor.h>
#include <utils/is_number.h>
#include <utils/logging.h>
 
blocks::IBlock::IBlock(IBlockHAL *hardware) : FunctionBlock("I", hardware), hardware(hardware), outputs{0} {
  classifier.class_enum = CLASS_;
}
 
blocks::IBlock::IBlock() : IBlock(new IBlockHALDummy(bus::NULL_ADDRESS)) {}
 
metadata::eui_t blocks::IBlock::get_entity_eui() const {
  if (hardware)
    return hardware->get_entity_eui();
  return {};
}
 
utils::status blocks::IBlock::write_to_hardware() {
  return utils::status(hardware->write_upscaling(scaling_factors) and hardware->write_outputs(outputs));
}
 
bool blocks::IBlock::init() {
  LOG(ANABRID_DEBUG_INIT, __PRETTY_FUNCTION__);
  if (!FunctionBlock::init()) {
    return false;
  };
  // I-Block matrix is not reset on power-cycle, apparently.
  if (!write_to_hardware())
    return false;
  return true;
}
 
bool blocks::IBlock::_is_connected(uint8_t input, uint8_t output) const {
  return outputs[output] & INPUT_BITMASK(input);
}
 
bool blocks::IBlock::_is_output_connected(uint8_t output) const { return outputs[output]; }
 
bool blocks::IBlock::is_connected(uint8_t input, uint8_t output) const {
  if (output >= NUM_OUTPUTS or input >= NUM_INPUTS)
    return false;
  return _is_connected(input, output);
}
 
bool blocks::IBlock::is_anything_connected() const {
  for (auto &output : OUTPUT_IDX_RANGE())
    if (_is_output_connected(output))
      return true;
  return false;
}
 
bool blocks::IBlock::connect(uint8_t input, uint8_t output, bool exclusive,
                                      bool allow_input_splitting) {
  if (output >= NUM_OUTPUTS or input >= NUM_INPUTS)
    return false;
 
  // Usually, we don't want to connect one input to multiple outputs, so check for other connections
  if (!allow_input_splitting) {
    for (size_t other_output_idx = 0; other_output_idx < outputs.size(); other_output_idx++) {
      if (output == other_output_idx)
        continue;
      if (is_connected(input, other_output_idx)) {
        return false;
      }
    }
  }
 
  if (exclusive)
    outputs[output] = INPUT_BITMASK(input);
  else
    outputs[output] |= INPUT_BITMASK(input);
  return true;
}
 
void blocks::IBlock::reset_outputs() {
  for (auto &output : outputs) {
    output = 0;
  }
}
 
void blocks::IBlock::reset(entities::ResetAction action) {
  FunctionBlock::reset(action);
 
  if (action.has(entities::ResetAction::CIRCUIT_RESET)) {
    reset_outputs();
    reset_upscaling();
  }
}
 
 
 
 
 
bool blocks::IBlock::disconnect(uint8_t input, uint8_t output) {
  // Fail if input was not connected
  if (!is_connected(input, output))
    return false;
  outputs[output] &= ~INPUT_BITMASK(input);
  return true;
}
 
bool blocks::IBlock::disconnect(uint8_t output) {
  if (output >= NUM_OUTPUTS)
    return false;
  outputs[output] = 0;
  return true;
}
 
bool blocks::IBlock::set_upscaling(uint8_t input, bool upscale) {
  if (input >= NUM_INPUTS)
    return false;
  scaling_factors[input] = upscale;
  return true;
}
 
void blocks::IBlock::set_upscaling(std::bitset<NUM_INPUTS> scales) { scaling_factors = scales; }
 
void blocks::IBlock::reset_upscaling() { scaling_factors.reset(); }
 
bool blocks::IBlock::get_upscaling(uint8_t input) const {
  if (input > 32)
    return false;
  else
    return scaling_factors[input];
}
 
const std::array<uint32_t, blocks::IBlock::NUM_OUTPUTS> &blocks::IBlock::get_outputs() const {
  return outputs;
}
 
void blocks::IBlock::set_outputs(const std::array<uint32_t, NUM_OUTPUTS> &outputs_) {
  outputs = outputs_;
}
 
 
void blocks::IBlock::extract(entities::ExtractVisitor &collector) {
  Entity::extract(collector);
  auto& cfg = collector.create(pb_Config_sum_config_tag);
  auto& sum_config = cfg.kind.sum_config = pb_SumConfig_init_default;
  auto& sum_connection_idx = sum_config.connections_count;
  for (size_t out_idx = 0; out_idx < NUM_OUTPUTS; ++out_idx) {
    auto &connection_config = sum_config.connections[sum_connection_idx];
    connection_config.output = out_idx;
    for (size_t in_idx = 0; in_idx < NUM_INPUTS; ++in_idx) {
      if (!_is_connected(in_idx, out_idx))
        continue;
      connection_config.inputs[connection_config.inputs_count++] = in_idx;
    }
 
    if (connection_config.inputs_count > 0)
      ++sum_connection_idx;
  }
 
  for (uint32_t in_idx = 0; in_idx < NUM_INPUTS; ++in_idx) {
    sum_config.upscales[sum_config.upscales_count++] = {
      .lane = in_idx,
      .enabled = get_upscaling(in_idx)
    };
  }
}
 
ConfigResult blocks::IBlock::config(const pb_Config &cfg) {
#ifdef ANABRID_DEBUG_ENTITY_CONFIG
  Serial.println(__PRETTY_FUNCTION__);
#endif
  if (cfg.which_kind != pb_Config_sum_config_tag) {
    return ConfigResult::err("expected i block config");
  }
 
  auto& sum_coef = cfg.kind.sum_config;
  auto res = apply_outputs(sum_coef);
  if (res.is_err())
    return res;
 
  auto res2 = apply_upscaling(sum_coef);
  if (res2.is_err())
    return res2;
 
  return ConfigResult::ok(true);
}
 
ConfigResult blocks::IBlock::apply_outputs(const pb_SumConfig &cfg) {
  // Handle a mapping of output to list of inputs
  // This only overrides outputs that are specifically mentioned
 
  reset(entities::ResetAction::CIRCUIT_RESET);
  for (size_t elem_idx = 0; elem_idx < cfg.connections_count; ++elem_idx) {
    auto& connection = cfg.connections[elem_idx];
    for (size_t input_idx = 0; input_idx < connection.inputs_count; ++input_idx) {
      auto input = connection.inputs[input_idx];
      if (!connect(input, connection.output)) {
        return ConfigResult::err_fmt("IBlock: Unable to connect input %d to output %d", input, connection.output);
      }
    }
  }
 
  return ConfigResult::ok(true);
}
 
ConfigResult blocks::IBlock::apply_upscaling(const pb_SumConfig &cfg) {
  for (auto upscale : cfg.upscales) {
    set_upscaling(upscale.lane, upscale.enabled);
  }
  return ConfigResult::ok(true);
}