mblock.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 "block/mblock.h"
#include "block/mblock_int.h"
#include "block/mblock_mul.h"
#include "utils/logging.h"
 
#include "carrier/cluster.h"
 
#include <math.h>
 
// This functions clamps an input value but keeps the sign of the input. min and max shall be positive
// Created for the automatic calibration in m blocks. Currently not typed, as there is no real need for it.
int abs_clamp(float in, int min, int max) {
  int sign;
 
  if (in < 0.0f)
    sign = -1;
  else
    sign = 1;
 
  if (abs(in) >= max)
    return sign * max;
  else if (abs(in) <= min)
    return sign * min;
  else
    return in;
}
 
FLASHMEM blocks::MBlock::MBlock(SLOT slot, MBlockHAL *hardware)
    : blocks::FunctionBlock{slot == SLOT::M0 ? "M0" : "M1"}, slot(slot), hardware(hardware) {
  classifier.class_enum = CLASS_;
}
 
FLASHMEM uint8_t blocks::MBlock::slot_to_global_io_index(uint8_t local) const {
  switch (slot) {
  case SLOT::M0:
    return local;
  case SLOT::M1:
    return local + 8;
  }
  // This should never be reached
  return local;
}
 
FLASHMEM
blocks::MBlock *blocks::MBlock::from_entity_classifier(entities::EntityClassifier classifier,
                                                       const bus::addr_t block_address) {
  if (!classifier or classifier.class_enum != entities::EntityClass::M_BLOCK)
    return nullptr;
 
  auto type = classifier.type_as<TYPES>();
  switch (type) {
  case TYPES::UNKNOWN:
    // This is already checked by !classifier above
    return nullptr;
  case TYPES::M_MUL4_BLOCK:
    return MMulBlock::from_entity_classifier(classifier, block_address);
  case TYPES::M_INT8_BLOCK:
    return MIntBlock::from_entity_classifier(classifier, block_address);
  }
  // Any unknown value results in a nullptr here.
  // Adding default case to switch suppresses warnings about missing cases.
  return nullptr;
}
 
FLASHMEM utils::status blocks::EmptyMBlock::write_to_hardware() { return utils::status::success(); }
 
FLASHMEM utils::status blocks::EmptyMBlock::config_self_from_json(JsonObjectConst cfg) {
  return utils::status::success();
}
 
FLASHMEM bool blocks::MBlockHAL::init() {
  if (!FunctionBlockHAL::init())
    return false;
  reset_overload_flags();
  return true;
}
 
FLASHMEM void blocks::MBlock::overload_flags_to_json(JsonArray msg_out) const {
  msg_out.clear();
  if (!hardware)
    return;
  auto flags = hardware->read_overload_flags();
  for (size_t i = 0; i < flags.size(); i++) {
    msg_out.add((bool)flags[i]);
  }
}