redac.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 "teensy/redac.h"
 
platform::REDAC *platform::REDAC::from_entity_classifier(entities::EntityClassifier classifier,
                                                         __attribute__((__unused__)) const bus::addr_t block_address) {
  if (!classifier or classifier.type != static_cast<uint8_t>(TYPES::mREDAC))
    return nullptr;
 
  if (classifier.version < entities::Version(1))
    return nullptr;
  if (classifier.version < entities::Version(1, 1)) {
    auto *new_carrier = new REDAC(new REDAC_HAL_V_1_0_X);
    new_carrier->classifier = classifier;
    return new_carrier;
  }
  if (classifier.version < entities::Version(1, 2)) {
    auto *new_carrier = new REDAC_V_1_1_X(new REDAC_HAL_V_1_1_X);
    new_carrier->classifier = classifier;
    return new_carrier;
  }
  return nullptr;
}
 
const SPISettings platform::REDAC_HAL_V_1_0_X::BP_REDAC_ID_SPI_SETTINGS{4'000'000, LSBFIRST,
                                                                        SPI_MODE2 /* Chip expects MODE0, CLK is inverted on the way */};
 
const SPISettings platform::ADCFunction_V_1_0_X::F_ADC_SWITCHER_PRG_SPI_SETTINGS{
    4'000'000, MSBFIRST, SPI_MODE2 /* chip expects SPI MODE0, but CLK is inverted on the way */};
 
platform::REDAC_HAL_V_1_0_X::REDAC_HAL_V_1_0_X()
    : REDAC_HAL_Parent(bus::CARRIER_BADDR, 15),
 
      bp_redac_id(bus::address_from_tuple(bus::BACKPLANE_BADDR, BP_REDAC_ID_FADDR), 3, BP_REDAC_ID_SPI_SETTINGS),
 
      f_set_standby(bus::address_from_tuple(bus::CARRIER_BADDR, STANDBY_SET_FADDR)),
      f_unset_standby(bus::address_from_tuple(bus::CARRIER_BADDR, STANDBY_UNSET_FADDR)),
      adc_functions{ADCFunction_V_1_0_X(0), ADCFunction_V_1_0_X(1), ADCFunction_V_1_0_X(2)} {}
 
uint16_t platform::REDAC_HAL_V_1_0_X::read_backplane_and_slot_id() const { return bp_redac_id.transfer16(0); }
 
bool platform::REDAC_HAL_V_1_0_X::write_adc_bus_mux(const std::array<carrier::ADCChannel, 8> &channels) {
  // Reset previous connections
  // It's easier to do a full reset then to remember all previous connections
  reset_adc_bus_mux();
  delayNanoseconds(420);
 
  // Write data to chip
  for (auto output_idx = 0; output_idx < channels.size(); output_idx++) {
    auto& channel = channels[output_idx];
    if (channel.idx < 0) continue;
    auto cluster_idx = channel.idx / 16;
    auto cluster_channel_idx = channel.idx % 16;
    if (!adc_functions[cluster_idx].write(cluster_channel_idx, output_idx))
      return false;
  }
 
  return true;
}
 
void platform::REDAC_HAL_V_1_0_X::reset_adc_bus_mux() {
  for (auto& adc_function : adc_functions)
    adc_function.trigger();
}
 
void platform::REDAC_HAL_V_1_0_X::set_standby(bool enabled) {
  if (enabled)
    f_set_standby.trigger(10000);
  else
    f_unset_standby.trigger(10000);
}
 
platform::REDAC_HAL_V_1_1_X::REDAC_HAL_V_1_1_X()
    : fp_control(bus::address_from_tuple(bus::CARRIER_BADDR, FP_SR), 15, true),
      fp_control_reset(bus::address_from_tuple(bus::CARRIER_BADDR, FP_SR_CLR)),
      fp_control_sync(bus::address_from_tuple(bus::CARRIER_BADDR, FP_SR_STO)) {}
 
bool platform::REDAC_HAL_V_1_1_X::write_fp_control_register(uint16_t state) {
  bool success = fp_control.transfer16(state);
  fp_control_sync.trigger();
  return success;
}
 
UnitResult platform::REDAC_V_1_1_X::write_to_hardware() {
  TRY(REDAC::write_to_hardware());
  if (!hardware->write_fp_control_register(fp_control_sr_state))
    return UnitResult::err("Failes writing fp control register");
  return UnitResult::ok();
}
 
platform::REDAC_V_1_1_X::REDAC_V_1_1_X(REDAC_HAL_V_1_1_X *hardware) : REDAC(hardware), fp_control_sr_state(0), hardware(hardware) {}
 
bool platform::REDAC_V_1_1_X::set_io_mode(uint8_t io_number, FrontPanelIOMode mode) {
  if (mode == FrontPanelIOMode::DIGITAL_IN && io_number != 0)
    return false;
 
  if (mode == FrontPanelIOMode::DIGITAL_OUT && io_number == 0)
    return false;
 
  fp_control_sr_state &= ~(0b10001 << (3 - io_number));
  fp_control_sr_state |= mode << (3 - io_number);
 
  return true;
}
 
platform::REDAC_V_1_1_X::FrontPanelIOMode platform::REDAC_V_1_1_X::get_io_mode(uint8_t io_number) const {
  return static_cast<FrontPanelIOMode>(fp_control_sr_state & (0b10001 << (3 - io_number)) >> (3 - io_number));
}
 
bool platform::REDAC_V_1_1_X::set_DIO_direction(uint8_t dio_number, bool input_from_ctrl_block) {
  uint8_t bit_number = 0;
  if (dio_number == 12)
    bit_number = 8;
  else if (dio_number == 13)
    bit_number = 9;
  else if (dio_number == 28)
    bit_number = 10;
  else if (dio_number == 7)
    bit_number = 11;
  else
    return false;
 
  fp_control_sr_state &= ~(1 << bit_number);
  fp_control_sr_state |= input_from_ctrl_block << bit_number;
 
  return true;
}
 
bool platform::REDAC_V_1_1_X::get_DIO_direction(uint8_t dio_number) const {
  if (dio_number == 12)
    return fp_control_sr_state & (1 << 8);
  if (dio_number == 13)
    return fp_control_sr_state & (1 << 9);
  if (dio_number == 28)
    return fp_control_sr_state & (1 << 10);
  if (dio_number == 7)
    return fp_control_sr_state & (1 << 11);
  return false;
}