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 <block/iblock.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)) {}
 
FLASHMEM metadata::eui_t blocks::IBlock::get_entity_eui() const {
  if (hardware)
    return hardware->get_entity_eui();
  return {};
}
 
FLASHMEM utils::status blocks::IBlock::write_to_hardware() {
  return utils::status(hardware->write_upscaling(scaling_factors) and hardware->write_outputs(outputs));
}
 
FLASHMEM 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;
}
 
FLASHMEM bool blocks::IBlock::_is_connected(uint8_t input, uint8_t output) const {
  return outputs[output] & INPUT_BITMASK(input);
}
 
FLASHMEM bool blocks::IBlock::_is_output_connected(uint8_t output) const { return outputs[output]; }
 
FLASHMEM 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);
}
 
FLASHMEM bool blocks::IBlock::is_anything_connected() const {
  for (auto &output : outputs)
    if (_is_output_connected(output))
      return true;
  return false;
}
 
FLASHMEM 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;
}
 
FLASHMEM void blocks::IBlock::reset_outputs() {
  for (auto &output : outputs) {
    output = 0;
  }
}
 
FLASHMEM void blocks::IBlock::reset(entities::ResetAction action) {
  FunctionBlock::reset(action);
 
  if (action.has(entities::ResetAction::CIRCUIT_RESET)) {
    reset_outputs();
    reset_upscaling();
  }
}
 
FLASHMEM utils::status blocks::IBlock::config_self_from_json(JsonObjectConst cfg) {
#ifdef ANABRID_DEBUG_ENTITY_CONFIG
  Serial.println(__PRETTY_FUNCTION__);
#endif
  for (auto cfgItr = cfg.begin(); cfgItr != cfg.end(); ++cfgItr) {
    if (cfgItr->key() == "outputs") {
      auto res = _config_outputs_from_json(cfgItr->value());
      if (!res)
        return res;
    } else if (cfgItr->key() == "upscaling") {
      auto res = _config_upscaling_from_json(cfgItr->value());
      if (!res)
        return res;
    } else {
      return utils::status("IBlock: Unknown configuration key");
    }
  }
  return utils::status::success();
}
 
FLASHMEM utils::status blocks::IBlock::_config_outputs_from_json(const JsonVariantConst &cfg) {
  // Handle a mapping of output to list of inputs
  // This only overrides outputs that are specifically mentioned
  if (cfg.is<JsonObjectConst>()) {
    for (JsonPairConst keyval : cfg.as<JsonObjectConst>()) {
      // Key defines output
      // TODO: Check conversion from string to number
 
      std::string output_str = keyval.key().c_str();
      if (!utils::is_number(output_str.begin(), output_str.end()))
        return utils::status("IBlock: Expected number but key is '%s'", output_str.c_str());
 
      auto output = std::stoul(output_str);
      // Disconnect also sanity checks output index for us
      if (!disconnect(output))
        return utils::status("IBlock: Could not disconnect output '%d', probably out of range", output);
      // Input may be given as list or as a single number
      auto res = _connect_from_json(keyval.value(), output);
      if (!res)
        return res;
    }
    return utils::status::success();
  }
  // Handle a list of outputs
  // This must overwrite all outputs, so we clear all of them
  else if (cfg.is<JsonArrayConst>()) {
    auto outputs_json = cfg.as<JsonArrayConst>();
    if (outputs_json.size() != NUM_OUTPUTS)
      return utils::status("IBlock: Given array size %d does not meet expected %d", outputs_json.size(),
                           NUM_OUTPUTS);
    reset_outputs();
    uint8_t idx = 0;
    for (JsonVariantConst input_spec : outputs_json) {
      // Input may be given as list or as a single number
      auto res = _connect_from_json(input_spec, idx++);
      if (!res)
        return res;
    }
    return utils::status::success();
  }
  return utils::status("IBlock: Expected either array or object as configuration");
}
 
FLASHMEM utils::status blocks::IBlock::_config_upscaling_from_json(const JsonVariantConst &cfg) {
  if (cfg.is<JsonObjectConst>()) {
    for (JsonPairConst keyval : cfg.as<JsonObjectConst>()) {
      if (!keyval.value().is<bool>())
        return utils::status("IBlock upscaling must be boolean");
 
      auto input = std::stoul(keyval.key().c_str());
      if (input > NUM_INPUTS)
        return utils::status("IBlock upscaling too many values");
 
      set_upscaling(input, keyval.value());
      return utils::status::success();
    }
  } else if (cfg.is<JsonArrayConst>()) {
    auto array = cfg.as<JsonArrayConst>();
    if (array.size() != NUM_INPUTS)
      return utils::status("IBlock upscaling wrong number of inputs");
 
    for (uint8_t input = 0; input < NUM_INPUTS; input++) {
      if (!array[input].is<bool>())
        return utils::status("IBlock upscaling expecting boolean");
      set_upscaling(input, array[input]);
    }
    return utils::status::success();
  }
  return utils::status("IBlock upscaling: Either provide list or object");
}
 
FLASHMEM utils::status blocks::IBlock::_connect_from_json(const JsonVariantConst &input_spec, uint8_t output) {
  if (input_spec.isNull()) {
    // Output is already disconnected from outer code
  } else if (input_spec.is<JsonArrayConst>()) {
    for (auto input : input_spec.as<JsonArrayConst>()) {
      if (!input.is<uint8_t>())
        return utils::status("IBlock: input is not an integer");
      if (!connect(input, output))
        return utils::status("IBlock: Could not connect %d -> %d, probably out of bounds", input, outputs);
    }
  } else if (input_spec.is<uint8_t>()) {
    if (!connect(input_spec, output))
      return utils::status("IBlock: Could not connect %d -> %d.", input_spec, output);
  } else {
    return utils::status("IBlock: Illegal data type in input specification");
  }
  return utils::status::success();
}
 
FLASHMEM 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;
}
 
FLASHMEM bool blocks::IBlock::disconnect(uint8_t output) {
  if (output >= NUM_OUTPUTS)
    return false;
  outputs[output] = 0;
  return true;
}
 
FLASHMEM bool blocks::IBlock::set_upscaling(uint8_t input, bool upscale) {
  if (input >= NUM_INPUTS)
    return false;
  scaling_factors[input] = upscale;
  return true;
}
 
FLASHMEM void blocks::IBlock::set_upscaling(std::bitset<NUM_INPUTS> scales) { scaling_factors = scales; }
 
FLASHMEM void blocks::IBlock::reset_upscaling() { scaling_factors.reset(); }
 
FLASHMEM bool blocks::IBlock::get_upscaling(uint8_t output) const {
  if (output > 32)
    return false;
  else
    return scaling_factors[output];
}
 
FLASHMEM void blocks::IBlock::config_self_to_json(JsonObject &cfg) {
  Entity::config_self_to_json(cfg);
  // Save outputs into cfg
  auto outputs_cfg = cfg.createNestedArray("outputs");
  for (uint8_t output = 0; output < NUM_OUTPUTS; output++) {
    if (outputs[output]) {
      auto inputs_cfg = outputs_cfg.createNestedArray();
      for (uint8_t input = 0; input < NUM_INPUTS; input++)
        if (_is_connected(input, output))
          inputs_cfg.add(input);
    } else {
      outputs_cfg.add(nullptr);
    }
  }
 
  auto upscaling_cfg = cfg.createNestedArray("upscaling");
  for (uint8_t input = 0; input < NUM_INPUTS; input++) {
    if (scaling_factors[input])
      upscaling_cfg.add(true);
    else
      upscaling_cfg.add(false);
  }
}
 
FLASHMEM const std::array<uint32_t, blocks::IBlock::NUM_OUTPUTS> &blocks::IBlock::get_outputs() const {
  return outputs;
}
 
FLASHMEM void blocks::IBlock::set_outputs(const std::array<uint32_t, NUM_OUTPUTS> &outputs_) {
  outputs = outputs_;
}