tblock.cpp

Go to the documentation of this file.

#include <entity/visitor.h>
#include <proto/main.pb.h>
 
#include <redac/tblock.h>
 
using namespace blocks;
 
TBlock::TBlock(TBlockHAL *hardware) : FunctionBlock("T", hardware), hardware(hardware) { classifier.class_enum = CLASS_; }
 
ConfigResult TBlock::config(const pb_Item &item) {
  if (item.which_kind == pb_Item_switch_config_tag) {
    auto &switch_config = item.kind.switch_config;
    return apply_muxes(switch_config.muxes, switch_config.muxes_count);
  }
 
  // unhandled
  return ConfigResult::ok(false);
}
 
ConfigResult TBlock::apply_muxes(const pb_Mux *muxes, size_t count) {
  for (size_t idx = 0; idx < count; ++idx) {
    auto &mux = muxes[idx];
    auto mux_value = mux.state;
    if (mux_value >= 4)
      return ConfigResult::err("TBlock: Mux must be interval [0, 3]");
    connections[mux.index] = mux_value;
  }
 
  return ConfigResult::ok(true);
}
 
std::array<uint8_t, TBlockHAL::NUM_SWITCHES> TBlock::get_connections() const { return connections; }
 
void TBlock::set_connections(const std::array<uint8_t, TBlockHAL::NUM_SWITCHES> &connections) { this->connections = connections; }
 
void TBlock::extract(entities::ExtractVisitor &collector) {
 
  if (!collector.include_configuration()) return;
  auto &item = collector.create(pb_Item_switch_config_tag);
  auto &switch_config = item.kind.switch_config = pb_SwitchConfig_init_default;
 
  auto &idx = switch_config.muxes_count = 0;
  for (; idx < connections.size(); ++idx) {
    switch_config.muxes[idx] = {
      .state = connections[idx],
      .index = idx
    };
  }
}
 
inline uint32_t mux_idx(TBlock::Sector dst_sector, uint8_t lane_idx) {
  return lane_idx * 4 + dst_sector;
}
 
UnitResult TBlock::connect(Sector src_sector, Sector dst_sector, uint8_t lane_idx) {
  if (lane_idx > 23)
    return UnitResult::err("Invalid lane. Remember that TBlock lanes are allways counted from 0 to 23");
 
  connections[mux_idx(dst_sector, lane_idx)] = src_sector;
  return UnitResult::ok();
}
 
TBlock::Sector TBlock::src_of_signal(Sector dst_sector, uint8_t lane_idx) const {
  if (lane_idx > 23)
    return Sector::BPL;
 
  return static_cast<Sector>(connections[mux_idx(dst_sector, lane_idx)]);
}
 
void TBlock::reset(entities::ResetAction action) {
  Entity::reset(action);
  if (action.has(entities::ResetAction::CIRCUIT_RESET)) {
    reset_connections();
  }
  if (action.has(entities::ResetAction::EVERYTHING))
    enabled = true;
}
 
void TBlock::reset_connections() {
  // Note that the T-block always has connections, unless it is completely disabled (powered-off).
  // The least surprising default connection is to have signals stay in their originating cluster.
  connections = {Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0,
                 Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2,
                 Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0,
                 Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2,
                 Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0,
                 Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2,
                 Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0,
                 Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2,
                 Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0,
                 Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2};
}
 
bool TBlock::write_to_hardware() {
  TRY_TRUE(Entity::write_to_hardware());
  if (!hardware->write_muxes(connections))
    return UnitResult::err("Error writing mux settings to hardware.");
  if (enabled)
    hardware->reset_mux_disable();
  else
    hardware->set_mux_disable();
  return UnitResult::ok();
}
 
bool TBlock::is_enabled() const { return enabled; }
 
void TBlock::set_enabled(bool enabled_) { enabled = enabled_; }
 
TBlockBackplane::TBlockBackplane(TBlockBackplaneHAL *hardware) : FunctionBlock("T_BPL", hardware), hardware(hardware) {
  classifier.class_enum = CLASS_;
}
 
UnitResult TBlockBackplane::connect(Sector src_sector, Sector dst_sector, uint8_t lane_idx) {
  if (lane_idx > 7)
    return UnitResult::err("lane_idx is invalid! Maximum is 7!");
 
  if (src_sector == dst_sector)
    return UnitResult::err("src_sector is equal to dst_sector! This connection is impossible!");
 
 
  uint8_t switch_setting = src_sector;
  if (src_sector == Sector::EXT0)
    switch_setting = dst_sector;
 
  connections[dst_sector + lane_idx * 9] = switch_setting;
 
  return UnitResult::ok();
}
 
TBlockBackplane::Sector TBlockBackplane::src_of_signal(Sector dst_sector, uint8_t lane_idx) const {
  if (lane_idx > 7)
    return Sector::EXT0;
 
  uint8_t switch_setting = connections[dst_sector + lane_idx * 9];
  if (switch_setting == dst_sector)
    return EXT0;
 
  return static_cast<Sector>(switch_setting);
}
 
void TBlockBackplane::reset(entities::ResetAction action) {
  Entity::reset(action);
  if (action.has(entities::ResetAction::CIRCUIT_RESET)) {
    reset_connections();
  }
  if (action.has(entities::ResetAction::EVERYTHING))
    enabled = true;
}
 
void TBlockBackplane::reset_connections() {
  // Resetting probably doesnt make much sense, because there really is no default way of connecting the redacs on the backplane
  // Because of that and because all connections are always active after a reset the tblock gets a random configuration, to make spotting routing
  // errors easier
  connections.fill(7);
}
 
bool TBlockBackplane::write_to_hardware() {
  TRY_TRUE(Entity::write_to_hardware());
  if (!hardware->write_muxes(connections))
    return UnitResult::err("Error writing mux settings to hardware.");
  if (enabled)
    hardware->reset_mux_disable();
  else
    hardware->set_mux_disable();
  return UnitResult::ok();
}
 
std::array<uint8_t, TBlockBackplaneHAL::NUM_SWITCHES> TBlockBackplane::get_connections() const { return connections; }
 
void TBlockBackplane::set_connections(const std::array<uint8_t, TBlockBackplaneHAL::NUM_SWITCHES> &connections_) { connections = connections_; }
 
bool TBlockBackplane::is_enabled() const { return enabled; }
 
void TBlockBackplane::set_enabled(bool enabled_) { enabled = enabled_; }
 
ConfigResult TBlockBackplane::config(const pb_Item &item) {
  if (item.which_kind == pb_Item_bpl_switch_config_tag) {
    auto &switch_config = item.kind.bpl_switch_config;
    return apply_muxes(switch_config.muxes, switch_config.muxes_count);
  }
 
  return ConfigResult::ok(false);
}
 
ConfigResult TBlockBackplane::apply_muxes(const pb_Mux *muxes, size_t count) {
  for (size_t idx = 0; idx < count; idx++) {
    auto& mux_value = muxes[idx];
    if (mux_value.state > 7)
      return ConfigResult::err_fmt("TBlockBackplane::apply_muxes: mux value is invalid, must be between [0, 7] but is %d!", mux_value.state);
    connections[mux_value.index] = mux_value.state;
  }
 
  return ConfigResult::ok(true);
}
 
void TBlockBackplane::extract(entities::ExtractVisitor &collector) {
  if (!collector.include_configuration()) return;
  auto &item = collector.create(pb_Item_bpl_switch_config_tag);
  auto &switch_config = item.kind.bpl_switch_config = pb_BPLSwitchConfig_init_default;
 
  auto &idx = switch_config.muxes_count = 0;
  for (; idx < connections.size(); ++idx) {
    switch_config.muxes[idx] = {
      .state = connections[idx],
      .index = idx
    };
  }
}