ublock.h

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
 
#pragma once
 
#include <array>
#include <cstdint>
#include <utility>
 
#include "block/base.h"
#include "bus/functions.h"
#include "chips/SR74HCT595.h"
 
namespace platform {
class Cluster;
}
 
namespace utils {
 
void shift_5_left(uint8_t *buffer, size_t size);
 
}
 
namespace functions {
 
class UMatrixFunction : public functions::DataFunction {
public:
  static const SPISettings DEFAULT_SPI_SETTINGS;
 
  using DataFunction::DataFunction;
  explicit UMatrixFunction(bus::addr_t address);
 
  template <size_t num_of_outputs>
  [[nodiscard]] bool transfer(const std::array<int8_t, num_of_outputs> &outputs) const;
};
 
} // namespace functions
 
namespace blocks {
 
class MBlock;
class MMulBlock;
class MIntBlock;
class MIntBlock_V_1_1_X;
 
class UBlockHAL : public FunctionBlockHAL {
public:
  enum class Reference_Magnitude : uint8_t { ONE = 0, ONE_TENTH = 1 };
  enum class Transmission_Mode : uint8_t {
    ANALOG_INPUT = 0b00,
    POS_REF = 0b01,
    NEG_REF = 0b10,
    GROUND = 0b11
  };
 
  virtual bool write_outputs(std::array<int8_t, 32> outputs) = 0;
  virtual bool write_transmission_modes_and_ref(std::pair<Transmission_Mode, Transmission_Mode> modes,
                                                Reference_Magnitude ref) = 0;
  virtual void reset_transmission_modes_and_ref() = 0;
};
 
class UBlockHAL_Dummy : public UBlockHAL {
public:
  bool write_outputs(std::array<int8_t, 32> outputs) override;
  bool write_transmission_modes_and_ref(std::pair<Transmission_Mode, Transmission_Mode> modes,
                                        Reference_Magnitude ref) override;
  void reset_transmission_modes_and_ref() override;
 
  metadata::eui_t get_entity_eui() const override { return {}; }
};
 
class UBlockHAL_Common : public UBlockHAL {
protected:
  const metadata::MetadataEditor f_meta;
  const functions::UMatrixFunction f_umatrix;
  const functions::TriggerFunction f_umatrix_sync;
  // Reset disables all output, but rest of logic is unchanged according to datasheet.
  // But I don't really know what that means. Data is still shifted out after a reset
  // and the enable-bits in the data are still set.
  // The datasheet calls the RESET pin OUTPUT ENABLE, so it probably is simply that.
  // Meaning it is completely useless.
  // const functions::TriggerFunction f_umatrix_reset;
 
  const functions::SR74HCT595 f_transmission_mode_register;
  const functions::TriggerFunction f_transmission_mode_sync;
  const functions::TriggerFunction f_transmission_mode_reset;
 
public:
  explicit UBlockHAL_Common(bus::addr_t block_address, uint8_t f_umatrix_cs, uint8_t f_umatrix_sync_cs,
                            uint8_t f_transmission_mode_register_cs, uint8_t f_transmission_mode_sync_cs,
                            uint8_t f_transmission_mode_reset_cs);
 
  bool write_outputs(std::array<int8_t, 32> outputs) override;
  bool write_transmission_modes_and_ref(std::pair<Transmission_Mode, Transmission_Mode> modes,
                                        Reference_Magnitude ref) override;
  void reset_transmission_modes_and_ref() override;
 
  metadata::eui_t get_entity_eui() const override { return f_meta.read_eui(); }
};
 
class UBlockHAL_V_1_2_X : public UBlockHAL_Common {
public:
  explicit UBlockHAL_V_1_2_X(const bus::addr_t block_address)
      : UBlockHAL_Common(block_address, 5, 6, 2, 3, 4){};
};
 
class UBlock : public FunctionBlock {
public:
  // Entity hardware identifier information.
  static constexpr auto CLASS_ = entities::EntityClass::U_BLOCK;
  static constexpr uint8_t TYPE = 1;
 
  static UBlock *from_entity_classifier(entities::EntityClassifier classifier, bus::addr_t block_address);
 
public:
  static constexpr uint8_t BLOCK_IDX = bus::U_BLOCK_IDX;
 
  static constexpr uint8_t NUM_OF_INPUTS = 16;
  static constexpr uint8_t NUM_OF_OUTPUTS = 32;
 
  static constexpr std::array<uint8_t, NUM_OF_INPUTS> INPUT_IDX_RANGE() {
    return {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
  };
 
  static constexpr std::array<uint8_t, NUM_OF_OUTPUTS> OUTPUT_IDX_RANGE() {
    return {0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
            16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31};
  };
 
  using Transmission_Mode = UBlockHAL::Transmission_Mode;
  using Reference_Magnitude = UBlockHAL::Reference_Magnitude;
 
protected:
  UBlockHAL *hardware;
 
  std::array<int8_t, NUM_OF_OUTPUTS> output_input_map;
  Reference_Magnitude ref_magnitude = Reference_Magnitude::ONE;
  Transmission_Mode a_side_mode = Transmission_Mode::ANALOG_INPUT;
  Transmission_Mode b_side_mode = Transmission_Mode::ANALOG_INPUT;
 
  // Default sanity checks for input and output indizes
  static bool _i_sanity_check(const uint8_t input);
  static bool _o_sanity_check(const uint8_t output);
  static bool _io_sanity_check(const uint8_t input, const uint8_t output);
 
  void change_a_side_transmission_mode(const Transmission_Mode mode);
  void change_b_side_transmission_mode(const Transmission_Mode mode);
  void change_all_transmission_modes(const Transmission_Mode mode);
  void change_all_transmission_modes(const std::pair<Transmission_Mode, Transmission_Mode> modes);
 
  Reference_Magnitude get_reference_magnitude();
 
  void change_reference_magnitude(Reference_Magnitude ref);
 
  void reset_reference_magnitude();
 
  std::pair<Transmission_Mode, Transmission_Mode> get_all_transmission_modes() const;
  bool _is_connected(const uint8_t input, const uint8_t output) const;
 
  void _connect(const uint8_t input, const uint8_t output);
 
  void _disconnect(const uint8_t output);
 
  bool _is_output_connected(const uint8_t output) const;
 
  bool _is_input_connected(const uint8_t input) const;
 
public:
  UBlock(UBlockHAL *hardware);
 
  UBlock() : UBlock(new UBlockHAL_Dummy()) {}
 
  metadata::eui_t get_entity_eui() const override;
 
  void reset(entities::ResetAction action) override;
 
  void reset_connections();
 
  bool connect(const uint8_t input, const uint8_t output, const bool force = false);
 
  bool connect_alternative(Transmission_Mode signal_type, const uint8_t output, const bool force = false,
                           bool use_a_side = false);
 
  bool disconnect(const uint8_t input, const uint8_t output);
 
  bool disconnect(const uint8_t output);
 
  bool is_connected(const uint8_t input, const uint8_t output) const;
 
  bool is_output_connected(const uint8_t output) const;
 
  bool is_input_connected(const uint8_t input) const;
 
  bool is_anything_connected() const;
 
  [[nodiscard]] utils::status write_to_hardware() override;
 
  utils::status config_self_from_json(JsonObjectConst cfg) override;
 
protected:
  void config_self_to_json(JsonObject &cfg) override;
 
  utils::status _config_outputs_from_json(const JsonVariantConst &cfg);
  utils::status _config_constants_from_json(const JsonVariantConst &cfg);
 
  friend class ::platform::Cluster;
 
  friend class ::blocks::MBlock;
  friend class ::blocks::MMulBlock;
  friend class ::blocks::MIntBlock;
  friend class ::blocks::MIntBlock_V_1_1_X;
};
} // namespace blocks
 
// Include template definitions
#include "ublock.tpl.h"