mblock.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 <bitset>
#include <cstdint>
 
#include "block/base.h"
#include "chips/AD840X.h"
#include "chips/DAC60508.h"
#include "chips/SR74HC16X.h"
#include "chips/SR74HCT595.h"
#include "daq/base.h"
 
namespace platform {
class Cluster;
}
 
namespace carrier {
class Carrier;
}
 
namespace blocks {
 
class MBlockHAL : public FunctionBlockHAL {
public:
  virtual std::bitset<8> read_overload_flags() = 0;
  virtual void reset_overload_flags() = 0;
 
  bool init() override;
};
 
class MBlock : public FunctionBlock {
public:
  // Entity hardware identifier information.
  static constexpr auto CLASS_ = entities::EntityClass::M_BLOCK;
 
  enum class TYPES : uint8_t { UNKNOWN = 0, M_INT8_BLOCK = 1, M_MUL4_BLOCK = 2 };
 
  static MBlock *from_entity_classifier(entities::EntityClassifier classifier, bus::addr_t block_address);
 
  bool is_entity_type(TYPES type_) { return entities::Entity::is_entity_type(static_cast<uint8_t>(type_)); }
 
public:
  static constexpr uint8_t M0_IDX = bus::M0_BLOCK_IDX;
  static constexpr uint8_t M1_IDX = bus::M1_BLOCK_IDX;
 
  enum class SLOT : uint8_t { M0 = 0, M1 = 1 };
 
  static constexpr std::array<uint8_t, 8> SLOT_INPUT_IDX_RANGE() { return {0, 1, 2, 3, 4, 5, 6, 7}; };
 
  static constexpr std::array<uint8_t, 8> SLOT_OUTPUT_IDX_RANGE() { return {0, 1, 2, 3, 4, 5, 6, 7}; };
 
  template <int n> static constexpr uint8_t M0_INPUT() {
    static_assert(n < 8, "MBlock input must be less than 8.");
    return n + 8;
  }
 
  static constexpr uint8_t M0_INPUT(uint8_t idx) { return idx + 8; }
 
  template <int n> static constexpr uint8_t M0_OUTPUT() {
    static_assert(n < 8, "MBlock output must be less than 8.");
    return n + 8;
  }
 
  static constexpr uint8_t M0_OUTPUT(uint8_t idx) { return idx + 8; }
 
  template <int n> static constexpr uint8_t M1_INPUT() {
    static_assert(n < 8, "MBlock input must be less than 8.");
    return n;
  }
 
  static constexpr uint8_t M1_INPUT(uint8_t idx) { return idx; }
 
  template <int n> static constexpr uint8_t M1_OUTPUT() {
    static_assert(n < 8, "MBlock output must be less than 8.");
    return n;
  }
 
  static constexpr uint8_t M1_OUTPUT(uint8_t idx) { return idx; }
 
public:
  const SLOT slot;
  MBlockHAL *hardware;
 
public:
  explicit MBlock(SLOT slot, MBlockHAL *hardware);
 
  uint8_t slot_to_global_io_index(uint8_t local) const;
 
  // M Blocks generaly can't calibrate themselfs on their own, so they need the cluster and carrier they are
  // installed in.
  virtual bool calibrate(platform::Cluster *cluster, carrier::Carrier *carrier) { return true; }
 
  void overload_flags_to_json(JsonArray msg_out) const;
};
 
class EmptyMBlock : public MBlock {
public:
  utils::status write_to_hardware() override;
 
  using MBlock::MBlock;
 
protected:
  utils::status config_self_from_json(JsonObjectConst cfg) override;
};
 
} // namespace blocks