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 <proto/main.pb.h>
 
#include <block/shblock.h>
#include <entity/visitor.h>
 
namespace blocks {
 
void SHBlockHAL::compensate_hardware_offsets(uint32_t track_time, uint32_t inject_time) {
  // This is uncheckable + allowed on all SH blocks so we can ignore the return value
  (void)set_state(SHState::TRACK);
  delayMicroseconds(track_time);
  (void)set_state(SHState::INJECT);
  delayMicroseconds(inject_time);
}
 
metadata::eui_t blocks::SHBlock::get_entity_eui() const {
  if (hardware)
    return hardware->get_entity_eui();
  return {};
}
 
blocks::SHBlock::SHBlock(SHBlockHAL *hardware) : FunctionBlock("SH", hardware), hardware(hardware) {
  classifier.class_enum = CLASS_;
}
 
void blocks::SHBlock::set_state(SHState state_) { state = state_; }
 
blocks::SHState blocks::SHBlock::get_state() const { return state; }
 
void blocks::SHBlock::reset(entities::ResetAction action) {
  if (action.has(entities::ResetAction::CIRCUIT_RESET))
    state = SHState::INJECT;
}
 
utils::status blocks::SHBlock::write_to_hardware() { return hardware->set_state(state); }
 
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;
}
 
void SHBlock::extract(entities::ExtractVisitor &collector) {
  Entity::extract(collector);
  auto& cfg = collector.create(pb_Config_shift_hold_config_tag);
  auto& sh_cfg = cfg.kind.shift_hold_config;
 
  switch (state) {
  case SHState::TRACK :
    sh_cfg.state = pb_ShiftHoldConfig_State_TRACK;
    break;
  case SHState::TRACK_AT_IC:
    sh_cfg.state = pb_ShiftHoldConfig_State_TRACK_AT_IC;
    break;
  case SHState::INJECT:
    sh_cfg.state = pb_ShiftHoldConfig_State_INJECT;
    break;
  case SHState::GAIN_ZERO_TO_SEVEN:
    sh_cfg.state = pb_ShiftHoldConfig_State_GAIN_ZERO_TO_SEVEN;
    break;
  case SHState::GAIN_EIGHT_TO_FIFTEEN:
    sh_cfg.state = pb_ShiftHoldConfig_State_GAIN_EIGHT_TO_FIFTEEN;
    break;
  //default:
    //return utils::status("Unknown target state for SH Block");
  }
}
 
ConfigResult blocks::SHBlock::config(const pb_Config &cfg) {
  if (cfg.which_kind != pb_Config_shift_hold_config_tag)
    return ConfigResult::err("expected shift hold config");
 
  auto& sh_cfg = cfg.kind.shift_hold_config;
 
  // FOR TESTING
  switch (sh_cfg.state) {
    case pb_ShiftHoldConfig_State_TRACK:
      set_state(blocks::SHState::TRACK);
      break;
    case pb_ShiftHoldConfig_State_TRACK_AT_IC:
      set_state(blocks::SHState::TRACK_AT_IC);
      break;
    case pb_ShiftHoldConfig_State_INJECT:
      set_state(blocks::SHState::INJECT);
      break;
    case pb_ShiftHoldConfig_State_GAIN_ZERO_TO_SEVEN:
      set_state(blocks::SHState::GAIN_ZERO_TO_SEVEN);
    break;
    case pb_ShiftHoldConfig_State_GAIN_EIGHT_TO_FIFTEEN:
      set_state(blocks::SHState::GAIN_EIGHT_TO_FIFTEEN);
    break;
    case pb_ShiftHoldConfig_State_PASSTHROUGH:
      set_state(blocks::SHState::PASSTHROUGH);
      break;
    default:
      return ConfigResult::err("Unknown target state for SH Block");
  }
 
  return ConfigResult::ok(true);
}
} // namespace blocks