ublock.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 <algorithm>
 
#include <block/ublock.h>
#include <entity/meta.h>
#include <utils/logging.h>
 
#include "teensy/ublock.h"
#include <chips/SR74HCT595.h>
 
FLASHMEM
blocks::UBlock *blocks::UBlock::from_entity_classifier(entities::EntityClassifier classifier,
                                                       bus::addr_t block_address) {
  if (!classifier or classifier.class_enum != CLASS_ or classifier.type != TYPE)
    return nullptr;
 
  if (classifier.version < entities::Version(1, 2))
    return nullptr;
  if (classifier.version < entities::Version(1, 3)) {
    auto *new_block = new UBlock(new UBlockHAL_V_1_2_X(block_address));
    new_block->classifier = classifier;
    return new_block;
  }
  return nullptr;
}
 
const SPISettings functions::UMatrixFunction::DEFAULT_SPI_SETTINGS{4'000'000, MSBFIRST, SPI_MODE2};
 
FLASHMEM functions::UMatrixFunction::UMatrixFunction(bus::addr_t address)
    : functions::DataFunction(address, DEFAULT_SPI_SETTINGS) {}
 
FLASHMEM blocks::UBlockHAL_Common::UBlockHAL_Common(bus::addr_t block_address, const uint8_t f_umatrix_cs,
                                                    const uint8_t f_umatrix_sync_cs,
                                                    const uint8_t f_transmission_mode_register_cs,
                                                    const uint8_t f_transmission_mode_sync_cs,
                                                    const uint8_t f_transmission_mode_reset_cs)
    : UBlockHAL_Parent(block_address),
      f_umatrix(bus::replace_function_idx(block_address, f_umatrix_cs)),
      f_umatrix_sync(bus::replace_function_idx(block_address, f_umatrix_sync_cs)),
      f_transmission_mode_register(bus::replace_function_idx(block_address, f_transmission_mode_register_cs),
                                   true),
      f_transmission_mode_sync(bus::replace_function_idx(block_address, f_transmission_mode_sync_cs)),
      f_transmission_mode_reset(bus::replace_function_idx(block_address, f_transmission_mode_reset_cs)) {}
 
FLASHMEM bool blocks::UBlockHAL_Common::write_outputs(std::array<int8_t, 32> outputs) {
  if (!f_umatrix.transfer(outputs))
    return false;
  f_umatrix_sync.trigger();
  return true;
}
 
FLASHMEM bool blocks::UBlockHAL_Common::write_transmission_modes_and_ref(
    std::pair<Transmission_Mode, Transmission_Mode> modes, Reference_Magnitude ref) {
  // Reference magnitude is defined by lowest bit
  // Group "A" mode is defined by the next two bits
  // Group "B" mode is defined by the next two bits
  // Remaining bits are not used
  uint8_t data = 0b000'00'00'0;
  data |= static_cast<uint8_t>(ref);
  data |= (static_cast<uint8_t>(modes.first) << 1);
  data |= (static_cast<uint8_t>(modes.second) << 3);
 
  if (!f_transmission_mode_register.transfer8(data))
    return false;
  f_transmission_mode_sync.trigger();
  return true;
}
 
FLASHMEM void blocks::UBlockHAL_Common::reset_transmission_modes_and_ref() {
  f_transmission_mode_reset.trigger();
}