lucidac.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 <lucidac/lucidac.h>
#include <utils/mac.h>
 
#include "teensy/lucidac.h"
#include <block/teensy/icmd.h>
#include <chips/SR74HCT595.h>
#include <chips/TMP127Q1.h>
 
carrier::Carrier &carrier::Carrier::get() {
  static carrier::Carrier *instance;
 
  if (!instance) {
    instance = detect();
 
    if (!instance) {
      // Can we continue to work without knowing about the detailed nature of a Carrier? Of course we can: We
      // just assume a LUCIDAC. This is absolutely reasonable makes the code less error prone then just
      // aborting because the Carrier EEPROM does not hold anything meaningful. However, next to this, there is
      // an even more important reason why to create an instance of LUCIDAC here: In early LUCIDACs (until S/N
      // 7) programmers were not aware of the EEPROM on the carrier and just thought there was none. To pay the
      // penalty for their ignorance, this workaround will be here forever ;-)
      LOG_ALWAYS("Warning: Carrier board EEPROM not in use. Falling back to Carrier Type = LUCIDAC.");
      instance = new platform::LUCIDAC(new platform::Teensy_LUCIDAC_HAL);
    }
  }
 
  return *instance;
}
 
platform::LUCIDAC *platform::LUCIDAC::from_entity_classifier(entities::EntityClassifier classifier,
                                                                      __attribute__((__unused__))
                                                                      const bus::addr_t block_address) {
  if (!classifier or classifier.type != static_cast<uint8_t>(TYPES::LUCIDAC))
    return nullptr;
 
  if (classifier.version < entities::Version(1, 1))
    return nullptr;
  if (classifier.version < entities::Version(1, 2)) {
    auto *new_carrier = new LUCIDAC(new Teensy_LUCIDAC_HAL);
    new_carrier->classifier = classifier;
    return new_carrier;
  }
  return nullptr;
}
 
const SPISettings platform::Teensy_LUCIDAC_HAL::F_ADC_SWITCHER_PRG_SPI_SETTINGS{
    4'000'000, MSBFIRST, SPI_MODE2 /* chip expects SPI MODE0, but CLK is inverted on the way */};
 
platform::Teensy_LUCIDAC_HAL::Teensy_LUCIDAC_HAL()
    : LUCIDAC_HAL_Parent(CARRIER_MADDR, 15),
      f_acl_prg(bus::address_from_tuple(CARRIER_MADDR, ACL_PRG_FADDR), 15, true),
      f_acl_upd(bus::address_from_tuple(CARRIER_MADDR, ACL_UPD_FADDR)),
      f_acl_clr(bus::address_from_tuple(CARRIER_MADDR, ACL_CRL_FADDR)),
      f_adc_switcher_prg(bus::address_from_tuple(CARRIER_MADDR, ADC_PRG_FADDR), 15,
                         F_ADC_SWITCHER_PRG_SPI_SETTINGS),
      f_adc_switcher_sync(bus::address_from_tuple(CARRIER_MADDR, ADC_STROBE_FADDR)),
      f_adc_switcher_sr_reset(bus::address_from_tuple(CARRIER_MADDR, ADC_RESET_SR_FADDR)),
      f_adc_switcher_matrix_reset(bus::address_from_tuple(CARRIER_MADDR, ADC_RESET_8816_FADDR)) {}
 
bool platform::Teensy_LUCIDAC_HAL::write_acl(std::array<Teensy_LUCIDAC_HAL::ACL, 8> acl) {
  uint8_t sr = 0;
  for (size_t idx = 0; idx < acl.size(); idx++) {
    if (acl[idx] == ACL::EXTERNAL_) {
      sr |= 1 << idx;
    }
  }
  if (!f_acl_prg.transfer8(sr))
    return false;
  f_acl_upd.trigger();
  return true;
}
 
void platform::Teensy_LUCIDAC_HAL::reset_acl() {
  f_acl_clr.trigger();
  f_acl_upd.trigger();
}
 
bool platform::Teensy_LUCIDAC_HAL::write_adc_bus_mux(const std::array<int8_t, 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 (uint8_t output_idx = 0; output_idx < channels.size(); output_idx++) {
    if (channels[output_idx] >= 0) {
      auto cmd = decltype(f_adc_switcher_prg)::chip_cmd_word(channels[output_idx], output_idx);
      if (!f_adc_switcher_prg.transfer8(cmd))
        return false;
      f_adc_switcher_sync.trigger();
    }
  }
  return true;
}
 
void platform::Teensy_LUCIDAC_HAL::reset_adc_bus_mux() { f_adc_switcher_matrix_reset.trigger(); }