functions.hpp

Go to the documentation of this file.

#ifndef IV_SRC_COMMS_MODBUS_FUNCTIONS_HPP_
#define IV_SRC_COMMS_MODBUS_FUNCTIONS_HPP_
 
#include "core/bswapOps.hpp"
#include "core/defines.hpp"
 
#include <algorithm>
#include <fmt/format.h>
#include <optional>
#include <string>
#include <vector>
 
namespace iv::comms::modbus
{
 
inline uint16_t calculateCrcToModbusRTU(const uint8_t *buf, const int32_t length)
{
    uint16_t crc = 0xFFFF;
 
    for (int32_t pos = 0; pos < length; pos++)
    {
        crc ^= static_cast<uint16_t>(buf[pos]);
 
        for (int32_t i = 8; i != 0; i--)
        {
            if ((crc & 0x0001) != 0)
            {
                crc >>= 1;
                crc ^= 0xA001;
            }
            else
            {
                crc >>= 1;
            }
        }
    }
 
    return crc;
}
 
inline uint16_t getRegisterTypeValue(const iv::comms::modbus::eRegisterType registerType)
{
    switch (registerType)
    {
        case iv::comms::modbus::eRegisterType::CoilStatus:
            return 0;
 
        case iv::comms::modbus::eRegisterType::InputStatus:
            return 1;
 
        case iv::comms::modbus::eRegisterType::InputRegister:
            return 3;
 
        case iv::comms::modbus::eRegisterType::HoldingRegister:
            return 4;
 
        default:
            break;
    }
 
    return 0;
}
 
inline std::string getCalculatedDirection(const iv::comms::modbus::eRegisterType registerType,
                                          iv::types::comms::modbus::modbusAddress address, bool isExtended)
{
    const auto registerTypeValue = getRegisterTypeValue(registerType);
 
    if (registerTypeValue == 0)
    {
        return iv::utils::formatNumber(address);
    }
 
    if (isExtended)
    {
        return fmt::format("{}{:05}", registerTypeValue, address);
    }
 
    return fmt::format("{}{:04}", registerTypeValue, address);
}
 
inline std::vector<iv::types::comms::modbus::registerValue>
applyEndianness(const iv::channels::ModbusRegisterInfo &modbusInfo,
                const std::vector<iv::types::comms::modbus::registerValue> &values)
{
    std::vector<iv::types::comms::modbus::registerValue> processedValues;
 
    if (modbusInfo.type == iv::comms::modbus::eRegisterType::CoilStatus ||
        modbusInfo.type == iv::comms::modbus::eRegisterType::InputStatus)
    {
        processedValues = values;
    }
    else if (modbusInfo.registerBitsLength > 16)
    {
        //Aquí se está aplicando un comportamiento diferente debido al funcionamiento de Modbus con datos mayores a un Registro(16bits) o con los Float y Double.
        switch (modbusInfo.endianType)
        {
            case iv::eEndianType::BigEndianByteSwapped:
                for (const auto value: values)
                {
                    processedValues.push_back(iv::bit::reverseBytes(value));
                }
 
                std::ranges::reverse(processedValues);
                break;
 
            case iv::eEndianType::BigEndian:
                processedValues = values;
                std::ranges::reverse(processedValues);
                break;
 
            case iv::eEndianType::LittleEndian:
                for (const auto value: values)
                {
                    processedValues.push_back(iv::bit::reverseBytes(value));
                }
                break;
 
            default:
                processedValues = values;
                break;
        }
    }
    else
    {
        switch (modbusInfo.endianType)
        {
            case iv::eEndianType::LittleEndian:
                for (const auto value: values)
                {
                    processedValues.push_back(iv::bit::reverseBytes(value));
                }
                std::ranges::reverse(processedValues.begin(), processedValues.end());
                break;
 
            case iv::eEndianType::LittleEndianByteSwapped:
                processedValues = values;
                std::ranges::reverse(processedValues.begin(), processedValues.end());
                break;
 
            case iv::eEndianType::BigEndianByteSwapped:
                for (const auto value: values)
                {
                    processedValues.push_back(iv::bit::reverseBytes(value));
                }
                break;
 
            default:
                processedValues = values;
                break;
        }
    }
 
    return processedValues;
}
 
inline int64_t applyMask(const iv::channels::ModbusRegisterInfo &modbusInfo, const std::vector<int64_t> &values)
{
    int64_t channelValue = 0;
 
    // Max Number of registers possible (crear constante)
    //Esto está sin probar
    if (values.size() == 5)
    {
        const int32_t numOfLastRegBits = modbusInfo.registerBitsLength + modbusInfo.bitPosition - 64;
        const auto mask = (static_cast<uint16_t>(1) << numOfLastRegBits) - 1;
 
        for (uint32_t i = 0; i < values.size(); i++)
        {
            channelValue |= values[i] << (i * 16);
        }
 
        const auto lastRegValue = (values[4] & mask) << modbusInfo.registerBitsLength;
 
        if (modbusInfo.bitPosition != 0)
        {
            channelValue >>= modbusInfo.bitPosition;
        }
 
        channelValue |= lastRegValue;
    }
    else
    {
        for (uint32_t i = 0; i < values.size(); i++)
        {
            channelValue |= values[i] << (i * 16);
        }
 
        if (modbusInfo.bitPosition != 0)
        {
            channelValue >>= modbusInfo.bitPosition;
        }
    }
 
    //crear constantes uwu
    uint64_t mask = std::numeric_limits<uint64_t>::max();
 
    if (modbusInfo.registerBitsLength < 64)
    {
        mask = (static_cast<uint64_t>(1) << modbusInfo.registerBitsLength) - 1;
    }
 
    channelValue &= static_cast<int64_t>(mask);
 
    return channelValue;
}
 
inline std::optional<iv::types::channelValue> processValue(const iv::channels::ModbusRegisterInfo &modbusInfo,
                                                           const uint64_t channelValue)
{
    std::optional<iv::types::channelValue> value;
 
    switch (modbusInfo.dataType)
    {
        case iv::eDataType::Bool:
            value = static_cast<bool>(channelValue);
            break;
 
        case iv::eDataType::Int16:
            int16_t valueInt16;
            std::memcpy(&valueInt16, &channelValue, sizeof(int16_t));
            value = valueInt16;
            break;
 
        case iv::eDataType::Uint16:
            uint16_t valueUint16;
            std::memcpy(&valueUint16, &channelValue, sizeof(uint16_t));
            value = valueUint16;
            break;
 
        case iv::eDataType::Int32:
            int32_t valueInt32;
            std::memcpy(&valueInt32, &channelValue, sizeof(int32_t));
            value = valueInt32;
            break;
 
        case iv::eDataType::Uint32:
            uint32_t valueUint32;
            std::memcpy(&valueUint32, &channelValue, sizeof(uint32_t));
            value = valueUint32;
            break;
 
        case iv::eDataType::Float:
            float valueFloat;
            std::memcpy(&valueFloat, &channelValue, sizeof(float));
            value = valueFloat;
            break;
 
        case iv::eDataType::Int64:
            int64_t valueInt64;
            std::memcpy(&valueInt64, &channelValue, sizeof(int64_t));
            value = valueInt64;
            break;
 
        case iv::eDataType::Uint64:
            uint64_t valueUint64;
            std::memcpy(&valueUint64, &channelValue, sizeof(uint64_t));
            value = valueUint64;
            break;
 
        case iv::eDataType::Double:
            double valueDouble;
            std::memcpy(&valueDouble, &channelValue, sizeof(double));
            value = valueDouble;
            break;
    }
 
    return value;
}
 
}// namespace iv::comms::modbus
 
#endif//IV_SRC_COMMS_MODBUS_FUNCTIONS_HPP_