shblock.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 "shblock.h"
 
blocks::SHBlockHAL::SHBlockHAL(bus::addr_t block_address)
    : f_meta(block_address), set_track(bus::replace_function_idx(block_address, 2)),
      set_track_at_ic(bus::replace_function_idx(block_address, 3)),
      set_gain(bus::replace_function_idx(block_address, 4)),
      set_gain_channels_zero_to_seven(bus::replace_function_idx(block_address, 5)),
      set_gain_channels_eight_to_fifteen(bus::replace_function_idx(block_address, 6)),
      set_inject(bus::replace_function_idx(block_address, 7)) {}
 
FLASHMEM metadata::eui_t blocks::SHBlock::get_entity_eui() const {
  if (hardware)
    return hardware->get_entity_eui();
  return {};
}
 
FLASHMEM void blocks::SHBlockHAL::compensate_hardware_offsets(uint32_t track_time, uint32_t inject_time) {
  set_track.trigger();
  delayMicroseconds(track_time);
  set_inject.trigger();
  delayMicroseconds(inject_time);
}
 
FLASHMEM void blocks::SHBlockHAL::set_state(SHState state) const {
  switch (state) {
  case SHState::TRACK:
    set_track.trigger();
    break;
  case SHState::TRACK_AT_IC:
    set_track_at_ic.trigger();
    break;
  case SHState::INJECT:
    set_inject.trigger();
    break;
  case SHState::GAIN_ZERO_TO_SEVEN:
    set_gain.trigger();
    set_gain_channels_zero_to_seven.trigger();
    break;
  case SHState::GAIN_EIGHT_TO_FIFTEEN:
    set_gain.trigger();
    set_gain_channels_eight_to_fifteen.trigger();
    break;
  }
}
 
FLASHMEM blocks::SHBlock::SHBlock(SHBlockHAL *hardware) : FunctionBlock("SH"), hardware(hardware) {
  classifier.class_enum = CLASS_;
}
 
FLASHMEM void blocks::SHBlock::set_state(SHState state_) { state = state_; }
 
FLASHMEM blocks::SHState blocks::SHBlock::get_state() const { return state; }
 
FLASHMEM void blocks::SHBlock::reset(entities::ResetAction action) {
  if (action.has(entities::ResetAction::CIRCUIT_RESET))
    state = SHState::INJECT;
}
 
FLASHMEM utils::status blocks::SHBlock::write_to_hardware() {
  hardware->set_state(state);
  return utils::status::success();
}
 
FLASHMEM void blocks::SHBlock::compensate_hardware_offsets(uint32_t track_time, uint32_t inject_time) {
  hardware->compensate_hardware_offsets(track_time, inject_time);
  state = SHState::INJECT;
}
 
FLASHMEM utils::status blocks::SHBlock::config_self_from_json(JsonObjectConst cfg) {
  // return utils::status("SHBlock does not accept configuration");
 
  // FOR TESTING
  if (cfg.containsKey("state")) {
    if (cfg["state"] == "TRACK")
      set_state(blocks::SHState::TRACK);
    else if (cfg["state"] == "TRACK_AT_IC")
      set_state(blocks::SHState::TRACK_AT_IC);
    else if (cfg["state"] == "INJECT")
      set_state(blocks::SHState::INJECT);
    else if (cfg["state"] == "GAIN_ZERO_TO_SEVEN")
      set_state(blocks::SHState::GAIN_ZERO_TO_SEVEN);
    else if (cfg["state"] == "GAIN_EIGHT_TO_FIFTEEN")
      set_state(blocks::SHState::GAIN_EIGHT_TO_FIFTEEN);
    else
      return utils::status("Unknown target state for SH Block");
  }
  return utils::status(0);
}
 
FLASHMEM
blocks::SHBlock *blocks::SHBlock::from_entity_classifier(entities::EntityClassifier classifier,
                                                         bus::addr_t block_address) {
  if (!classifier or classifier.class_enum != CLASS_)
    return nullptr;
 
  // Currently, there are no different variants
  if (classifier.variant != entities::EntityClassifier::DEFAULT_)
    return nullptr;
 
  if (classifier.version < entities::Version(0, 1))
    return nullptr;
  if (classifier.version < entities::Version(0, 2)) {
    auto *new_block = new SHBlock(new SHBlockHAL(block_address));
    new_block->classifier = classifier;
    return new_block;
  }
  return nullptr;
}