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 <proto/main.pb.h>
 
#include "block/mblock.h"
#include "block/mblock_int.h"
#include "block/mblock_mdr.h"
#include "block/mblock_mul.h"
#include "utils/logging.h"
 
#include "carrier/cluster.h"
#include "entity/visitor.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;
}
 
blocks::MBlock::MBlock(SLOT slot, MBlockHAL *hardware)
    : blocks::FunctionBlock{slot == SLOT::M0 ? "M0" : "M1", hardware}, slot(slot), hardware(hardware) {
  classifier.class_enum = CLASS_;
}
 
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;
}
 
 
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_MDR4_BLOCK:
    return MMDRBlock::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;
}
 
utils::status blocks::EmptyMBlock::write_to_hardware() { return utils::status::success(); }
 
bool blocks::MBlockHAL::init() {
  if (!entities::EntityHAL::init())
    return false;
  reset_overload_flags();
  return true;
}
 
void blocks::MBlock::collect_overloads(entities::OverloadVisitor& visitor) const {
  if (!hardware)
    return;
  auto flags = hardware->read_overload_flags();
  for (size_t idx = 0; idx < flags.size(); idx++) {
    auto elem = visitor.create();
    elem.idx = idx;
    elem.overload = true;
  }
}