utils.hpp

Go to the documentation of this file.

#ifndef IV_SRC_CHANNELS_UTILS_HPP_
#define IV_SRC_CHANNELS_UTILS_HPP_
 
#include "channels/AbstractChannel.hpp"
#include "core/strings.hpp"
#include "core/utils.hpp"
#include "model/constants.hpp"
#include "units/model/enums.hpp"
 
namespace iv::channels::utils
{
 
inline void formatTag(iv::types::channelId &id)
{
    iv::strings::trim(id);
    iv::strings::toUpper(id);
}
 
inline std::string formatValue(const iv::types::channelValue &value, const iv::channels::eChannelBaseType type,
                               const std::optional<uint8_t> numberOfDecimals = 0,
                               const std::optional<iv::eMeasurementUnit> measurementUnit = std::nullopt)
{
    switch (type)
    {
        case iv::channels::eChannelBaseType::WiredAnalog:
        case iv::channels::eChannelBaseType::VirtualAnalog:
        {
            return fmt::format("{:.{}f} {}", value, numberOfDecimals.value_or(0),
                               iv::MeasurementUnit::get(measurementUnit.value_or(iv::eMeasurementUnit::NoUnit)).symbol);
        }
        case iv::channels::eChannelBaseType::WiredDigital:
        case iv::channels::eChannelBaseType::VirtualDigital:
        {
            return value == 0 ? "OP" : "CL";
        }
        default:
        {
            return "";
        }
    }
}
 
inline iv::types::Range<uint16_t> stationHeartbeatAndFailureChannelOrderRange()
{
    return {.min = static_cast<iv::types::channelOrder>(1), .max = static_cast<iv::types::channelOrder>(100)};
}
 
inline iv::types::Range<uint16_t> watchcallNodeHearbeatAndFailureChannelOrderRange()
{
    return {.min = static_cast<iv::types::channelOrder>(128 * 100),
            .max = static_cast<iv::types::channelOrder>(129 * 100)};
}
inline iv::types::Range<iv::types::channelOrder>
unitHeartbeatAndCanFailureChannelOrderRange(const iv::types::unitId unitId)
{
    return {.min = static_cast<iv::types::channelOrder>(unitId * 100),
            .max = static_cast<iv::types::channelOrder>(unitId * 100 + 99)};
}
 
inline iv::types::channelOrder networkHeartbeatAndFailureChannelOrder(const iv::types::channelOrder stationOrder,
                                                                      const iv::types::channelOrder commOrder)
{
    return iv::constants::channels::commFailureChannelsOffset + stationOrder * 100 + commOrder;
}
 
inline std::string generateDefaultChannelId(iv::types::unitId unitId, iv::types::channelOrder channelOrder)
{
    return fmt::format("U{:03}_{:03}", unitId, channelOrder);
}
 
inline std::string generateDefaultLomHeartbeatChannelId(iv::types::unitId unitId)
{
    return fmt::format("U{:03}_HB", unitId);
}
 
inline std::string generateDefaultStationHeartbeatChannelId(const iv::types::stationId &stationId)
{
    return fmt::format("{}_HB", stationId);
}
 
inline std::string generateDefaultStationFailChannelId(const iv::types::stationId &stationId)
{
    return fmt::format("{}_FAIL", stationId);
}
 
inline std::string generateDefaultWatchcallNodeFailChannelId(const iv::types::repeaterId &repeaterId)
{
    return fmt::format("{}_RFAIL", repeaterId);
}
 
inline std::string generateDefaultWatchcallNodeHearbeatChannelId(const iv::types::repeaterId &repeaterId)
{
    return fmt::format("{}_RHB", repeaterId);
}
 
inline std::string generateDefaultCanAFailChannelId(iv::types::unitId unitId)
{
    return fmt::format("U{:03}_CANA", unitId);
}
 
inline std::string generateDefaultCanBFailChannelId(iv::types::unitId unitId)
{
    return fmt::format("U{:03}_CANB", unitId);
}
 
inline std::string generateDefaultCanCFailChannelId(iv::types::unitId unitId)
{
    return fmt::format("U{:03}_CANC", unitId);
}
 
inline std::string generateDefaultLomOfflineChannelId(iv::types::unitId unitId)
{
    return fmt::format("U{:03}_OFFLINE", unitId);
}
 
uint32_t getGlobalId(iv::types::channelOrder channelOrder, iv::types::unitId unitId,
                     iv::channels::eChannelSpecificType channelSpecificType);
 
iv::types::indexChannel generateIndexChannel(uint16_t id, iv::channels::eChannelSpecificType type);
 
std::pair<iv::alarms::eAlarmState, iv::alarms::eAlarmType> unpackedStateAlarmAndTypeAlarm(unsigned char stateAndType);
 
bool hasToShowRawValue(iv::channels::eChannelBaseType type);
 
bool isSerialLine(iv::channels::eChannelSpecificType type);
 
std::vector<iv::channels::eAnalogSensorType> sensorTypeByUnitTypeAndChOrder(const iv::units::eUnitType &unitType,
                                                                            const iv::types::channelOrder &chOrder);
 
bool isDefaultChannelId(const iv::types::channelId &chId);
 
bool isChannelWithoutAlarm(iv::channels::eChannelSpecificType channelType);
 
}// namespace iv::channels::utils
 
#endif//IV_SRC_CHANNELS_UTILS_HPP_