iblock.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 <bitset>
#include <cstdint>
 
#include "block/base.h"
#include "bus/functions.h"
#include "chips/SR74HCT595.h"
#include "utils/is_number.h"
 
namespace functions {
 
class ICommandRegisterFunction : public SR74HCT595 {
public:
  static const SPISettings DEFAULT_SPI_SETTINGS;
 
  using SR74HCT595::SR74HCT595;
  explicit ICommandRegisterFunction(bus::addr_t address);
 
  static uint8_t chip_cmd_word(uint8_t chip_input_idx, uint8_t chip_output_idx, bool connect = true);
};
 
} // namespace functions
 
namespace blocks {
 
class IBlockHAL : public FunctionBlockHAL {
public:
  static constexpr uint8_t NUM_INPUTS = 32;
  static constexpr uint8_t NUM_OUTPUTS = 16;
 
  static constexpr uint32_t INPUT_BITMASK(uint8_t input_idx) { return static_cast<uint32_t>(1) << input_idx; }
 
  virtual bool write_outputs(const std::array<uint32_t, 16> &outputs) = 0;
  virtual bool write_upscaling(std::bitset<32> upscaling) = 0;
};
 
class IBlockHALDummy : public IBlockHAL {
public:
  bool write_outputs(const std::array<uint32_t, 16> &outputs) override { return true; }
 
  bool write_upscaling(std::bitset<32> upscaling) override { return true; }
 
  explicit IBlockHALDummy(bus::addr_t) : IBlockHAL() {}
 
  std::array<uint8_t, 8> get_entity_eui() const override { return {}; }
};
 
class IBlockHAL_V_1_2_X : public IBlockHAL {
protected:
  const metadata::MetadataEditor f_meta;
  const functions::ICommandRegisterFunction f_cmd;
  const functions::TriggerFunction f_imatrix_reset;
  const functions::TriggerFunction f_imatrix_sync;
 
  const functions::SR74HCT595 scaling_register;
  const functions::TriggerFunction scaling_register_sync;
 
public:
  explicit IBlockHAL_V_1_2_X(bus::addr_t block_address);
 
  bool write_outputs(const std::array<uint32_t, 16> &outputs) override;
 
  bool write_upscaling(std::bitset<32> upscaling) override;
 
  metadata::eui_t get_entity_eui() const override { return f_meta.read_eui(); }
};
 
class IBlock : public FunctionBlock {
public:
  // Entity hardware identifier information.
  static constexpr auto CLASS_ = entities::EntityClass::I_BLOCK;
 
  static IBlock *from_entity_classifier(entities::EntityClassifier classifier, bus::addr_t block_address);
 
public:
  static constexpr uint8_t BLOCK_IDX = bus::I_BLOCK_IDX;
 
  static constexpr uint32_t INPUT_BITMASK(uint8_t input_idx) { return IBlockHAL::INPUT_BITMASK(input_idx); }
 
  static constexpr uint8_t NUM_INPUTS = IBlockHAL::NUM_INPUTS;
  static constexpr uint8_t NUM_OUTPUTS = IBlockHAL::NUM_OUTPUTS;
 
  static constexpr std::array<uint8_t, NUM_INPUTS> INPUT_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};
  };
 
  static constexpr std::array<uint8_t, NUM_OUTPUTS> OUTPUT_IDX_RANGE() {
    return {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
  };
 
protected:
  utils::status _connect_from_json(const JsonVariantConst &input_spec, uint8_t output);
 
  utils::status _config_outputs_from_json(const JsonVariantConst &cfg);
  utils::status _config_upscaling_from_json(const JsonVariantConst &cfg);
 
  void config_self_to_json(JsonObject &cfg) override;
 
  bool _is_connected(uint8_t input, uint8_t output) const;
  bool _is_output_connected(uint8_t output) const;
 
  IBlockHAL *hardware;
 
  std::array<uint32_t, NUM_OUTPUTS> outputs;
  std::bitset<NUM_INPUTS> scaling_factors = 0;
 
public:
  explicit IBlock(IBlockHAL *hardware);
  IBlock();
 
  metadata::eui_t get_entity_eui() const override;
 
  [[nodiscard]] utils::status write_to_hardware() override;
 
  bool init() override;
 
  void reset_outputs();
 
  void reset(entities::ResetAction action) override;
 
  const std::array<uint32_t, NUM_OUTPUTS> &get_outputs() const;
 
  void set_outputs(const std::array<uint32_t, NUM_OUTPUTS> &outputs_);
 
  bool connect(uint8_t input, uint8_t output, bool exclusive = false, bool allow_input_splitting = false);
 
  bool is_connected(uint8_t input, uint8_t output) const;
 
  bool is_anything_connected() const;
 
  bool disconnect(uint8_t input, uint8_t output);
 
  bool disconnect(uint8_t output);
 
  bool set_upscaling(uint8_t input, bool upscale);
 
  void set_upscaling(std::bitset<NUM_INPUTS> scales);
 
  void reset_upscaling();
 
  bool get_upscaling(uint8_t output) const;
 
  const std::bitset<NUM_INPUTS> &get_upscales() const { return scaling_factors; }
 
  utils::status config_self_from_json(JsonObjectConst cfg) override;
};
 
} // namespace blocks