utils.hpp

Go to the documentation of this file.

#ifndef IV_COMMS_CAN_UTILS_HPP
#define IV_COMMS_CAN_UTILS_HPP
 
#include "comms/can/defines.hpp"
#include "comms/can/enums.hpp"
#include "comms/can/structs.hpp"
#include "containers/utils.hpp"
#include "core/CStringTools.hpp"
#include "core/defines.hpp"
#include "core/enums.hpp"
#include "core/parsers.hpp"
#include "model/enums.hpp"
#include "utils/Calendar.hpp"
 
namespace iv::comms::can
{
 
constexpr uint32_t kPrvUnitIdMask = 0x07F;
 
constexpr uint16_t kPrvAllSubnetwork = 0xFFFF;
constexpr uint8_t kPrvFirstStation = 119;
constexpr uint16_t kPrvMaxModulesForSubnetwork = 1000;
constexpr uint16_t kPrvMaxNumberModulesInSubnetwork = 127;
 
constexpr uint8_t kPrvAllNode = 0;
 
constexpr uint8_t kPrvCommandStopNode = 2;
constexpr uint8_t kPrvCommandPreOperationalNode = 0x80;// 128
constexpr uint8_t kPrvCommandResetNode = 0x81;         // 129
constexpr uint8_t kPrvCommandACK = 0x80;               // 128
constexpr uint8_t kPrvCommandCtrl = 0x81;              // 129
constexpr uint8_t kPrvTypeRealValue = 0x90;            // 144
 
constexpr uint8_t kPrvTypeTextPositionMask = 0x3F;
constexpr uint8_t kPrvTypeTextStateMask = 0xC0;
constexpr uint8_t kPrvTypeTextConcat = 0x00;
constexpr uint8_t kPrvTypeTextInit = 0x40;
constexpr uint8_t kPrvTypeTextFinish = 0x80;
 
constexpr uint8_t kPrvCommandOnDutyWatchCall = 0x01;
constexpr uint8_t kPrvCommandCallAllWatchCallEcr = 1;
constexpr uint8_t kPrvCommandCallAllOff = 0;
constexpr uint8_t kPrvCommandCallAllWatchCallBridge = 2;
constexpr uint16_t kPrvIndexWatchCall = 0x6000;
constexpr uint32_t kPrvLengthMessageWatchCall = 8;
 
constexpr uint16_t kPrvBroadcastNewAlarm = 0;
constexpr uint16_t kPrvBroadcastSoundOff = 1;
constexpr uint16_t kPrvBroadcastACK = 2;
constexpr uint16_t kPrvBroadcastStartArea = 4;
constexpr uint16_t kPrvIndexCommandChannelOffset = 0x3800;
constexpr uint16_t kPrvOffsetCmd = 400;
constexpr uint16_t kPrvOffsetInternMemory = 500;
constexpr uint32_t kPrvLengthMessageBroadCastSoundOff = 8;
 
constexpr uint16_t MAX_ANALOG_INPUT_INDEX = 0x363;
 
constexpr std::string_view kPrvStrSend = "TO_SEND";
 
inline void prvGetIdLocalUnitAndSubnetwork(iv::types::unitId idUnit, iv::types::unitId *idLocalUnit,
                                           iv::types::subnetwork *idSubnetwork)
{
    IV_ASSERT_NULL_POINTER(idLocalUnit);
    IV_ASSERT_NULL_POINTER(idSubnetwork);
 
    *idLocalUnit = idUnit % kPrvMaxModulesForSubnetwork;
    *idSubnetwork = idUnit / kPrvMaxModulesForSubnetwork;
}
 
inline bool isInSdoResponseCanIdRange(const uint32_t canId)
{
    return (canId >= iv::comms::can::canMessageIds::sdoServer && canId < 0x700);
}
 
inline bool isInHeartbeatCanIdRange(const uint32_t canId)
{
    return (canId >= iv::comms::can::canMessageIds::heartbeat &&
            canId < iv::comms::can::canMessageIds::updateHistorySync);
}
 
inline bool isHeartbeatOk(const iv::comms::eHeartbeatState heartbeatState)
{
    switch (heartbeatState)
    {
        case iv::comms::eHeartbeatState::BootUp:
        case iv::comms::eHeartbeatState::Stopped:
        case iv::comms::eHeartbeatState::Operational:
        case iv::comms::eHeartbeatState::PreOperational:
            return true;
 
        default:
            break;
    }
 
    return false;
}
 
inline uint8_t prvIdUnitStation(iv::types::unitId idStation)
{
    return static_cast<uint8_t>(idStation + kPrvFirstStation);
}
 
inline uint16_t prvIndexChannelBroadCast(iv::model::eShipArea areaStation, uint16_t typeBroadcast)
{
    uint16_t indexChannel;
    uint16_t broadcastArea;
 
    broadcastArea = static_cast<uint16_t>(kPrvBroadcastStartArea * static_cast<int32_t>(areaStation));
    indexChannel = static_cast<uint16_t>(kPrvIndexCommandChannelOffset + typeBroadcast + broadcastArea);
 
    return indexChannel;
}
 
inline bool isWatchCall(uint16_t indexChannel, uint16_t *areaRepeater)
{
    bool isWatchCall {false};
 
    IV_ASSERT_NULL_POINTER(areaRepeater);
 
    if (indexChannel >= kPrvIndexWatchCall && indexChannel <= kPrvIndexWatchCall + 0xFF)
    {
        *areaRepeater = indexChannel - kPrvIndexWatchCall;
        isWatchCall = true;
    }
 
    return isWatchCall;
}
 
inline bool isBroadCastCommand(uint16_t indexChannel, iv::comms::can::eBroadcastType *typeBroadCast,
                               uint16_t *typeZoneRepeaters)
{
    bool isBroadCast {false};
 
    IV_ASSERT_NULL_POINTER(typeBroadCast);
    IV_ASSERT_NULL_POINTER(typeZoneRepeaters);
 
    if (indexChannel >= kPrvIndexCommandChannelOffset &&
        indexChannel <= kPrvIndexCommandChannelOffset + kPrvOffsetInternMemory)
    {
        uint16_t idChannel;
 
        idChannel = indexChannel - kPrvIndexCommandChannelOffset;
 
        if (idChannel < kPrvOffsetCmd)
        {
            uint16_t idBroadCast;
 
            idBroadCast = idChannel % kPrvBroadcastStartArea;
            *typeZoneRepeaters = idChannel / kPrvBroadcastStartArea;
            *typeBroadCast = (iv::comms::can::eBroadcastType) idBroadCast;
 
            isBroadCast = true;
        }
    }
 
    return isBroadCast;
}
 
inline uint16_t indexChannelBroadcastNewAlarm(iv::model::eShipArea stationArea)
{
    return iv::comms::can::prvIndexChannelBroadCast(stationArea, kPrvBroadcastNewAlarm);
}
 
inline uint16_t indexChannelBroadcastSoundOff(iv::model::eShipArea stationArea)
{
    return iv::comms::can::prvIndexChannelBroadCast(stationArea, kPrvBroadcastSoundOff);
}
 
inline void getIdUnitLocalAndSubnetwork(iv::types::unitId idUnit, iv::types::unitId *idUnitLocal,
                                        iv::types::subnetwork *idSubnetwork)
{
    iv::comms::can::prvGetIdLocalUnitAndSubnetwork(idUnit, idUnitLocal, idSubnetwork);
}
 
inline void getNumDaysAndMillisecondsSinceLOMBaseDate(iv::types::timestamp now, uint16_t &daysSince1984,
                                                      uint32_t &milliseconds)
{
    iv::time::Timestamp(now).getLomsTime(daysSince1984, milliseconds);
}
 
inline uint16_t getIdUnitGlobal(uint16_t idUnitLocal, uint16_t idSubnetwork)
{
    uint32_t idGlobal;
 
    if (idSubnetwork != kPrvAllSubnetwork)
    {
        uint16_t idFirstUnitSubnetwork;
 
        idFirstUnitSubnetwork = idSubnetwork * kPrvMaxModulesForSubnetwork;
        idGlobal = idFirstUnitSubnetwork + idUnitLocal;
    }
    else
    {
        idGlobal = idUnitLocal;
    }
 
    return static_cast<uint16_t>(idGlobal);
}
 
inline uint16_t idUnitStation(uint16_t idStation)
{
    return idStation + kPrvFirstStation;
}
 
inline bool isEqualMessageCAN(const iv::comms::can::CanDataMessage *message1,
                              const iv::comms::can::CanDataMessage *message2)
{
    IV_ASSERT_NULL_POINTER(message1);
    IV_ASSERT_NULL_POINTER(message2);
 
    return message1->m_msgId == message2->m_msgId && message1->m_lengthData == message2->m_lengthData &&
           iv::utils::compareSubstring((const char *) message1->m_bytes, (const char *) message2->m_bytes,
                                       message1->m_lengthData) == 0;
}
 
inline iv::comms::can::eMessageType getMessageType(const uint64_t msgId)
{
    iv::comms::can::eMessageType messageType {iv::comms::can::eMessageType::Undefined};
 
    if (msgId == iv::comms::can::canMessageIds::lssMaster)
    {
        messageType = iv::comms::can::eMessageType::LssMaster;
    }
    else if (msgId == iv::comms::can::canMessageIds::lssSlave)
    {
        messageType = iv::comms::can::eMessageType::LssSlave;
    }
    else if (msgId == iv::comms::can::canMessageIds::nmtService)
    {
        messageType = iv::comms::can::eMessageType::NmtService;
    }
    else if (msgId == iv::comms::can::canMessageIds::gmtSync)
    {
        messageType = iv::comms::can::eMessageType::GmtSync;
    }
    else if (msgId == iv::comms::can::canMessageIds::timestampSync)
    {
        messageType = iv::comms::can::eMessageType::TimestampSync;
    }
    else if ((msgId & iv::comms::can::canMessageIds::text) == iv::comms::can::canMessageIds::text)
    {
        messageType = iv::comms::can::eMessageType::Text;
    }
    else if ((msgId & iv::comms::can::canMessageIds::ackHistorySync) == iv::comms::can::canMessageIds::ackHistorySync)
    {
        messageType = iv::comms::can::eMessageType::HistoryAckSync;
    }
    else if ((msgId & iv::comms::can::canMessageIds::updateHistorySync) ==
             iv::comms::can::canMessageIds::updateHistorySync)
    {
        messageType = iv::comms::can::eMessageType::HistorySync;
    }
    else if ((msgId & iv::comms::can::canMessageIds::heartbeat) == iv::comms::can::canMessageIds::heartbeat)
    {
        messageType = iv::comms::can::eMessageType::Heartbeat;
    }
    else if ((msgId & iv::comms::can::canMessageIds::digitalInput128_191) ==
             iv::comms::can::canMessageIds::digitalInput128_191)
    {
        messageType = iv::comms::can::eMessageType::DigitalInput_128_191;
    }
    else if ((msgId & iv::comms::can::canMessageIds::sdoClient) == iv::comms::can::canMessageIds::sdoClient)
    {
        messageType = iv::comms::can::eMessageType::SdoRequestFromClient;
    }
    else if ((msgId & iv::comms::can::canMessageIds::sdoServer) == iv::comms::can::canMessageIds::sdoServer)
    {
        messageType = iv::comms::can::eMessageType::SdoResponseFromServer;
    }
    else if ((msgId & iv::comms::can::canMessageIds::alarmTimestamp) == iv::comms::can::canMessageIds::alarmTimestamp)
    {
        messageType = iv::comms::can::eMessageType::AlarmTimestamp;
    }
    else if ((msgId & iv::comms::can::canMessageIds::digitalInput64_127) ==
             iv::comms::can::canMessageIds::digitalInput64_127)
    {
        messageType = iv::comms::can::eMessageType::DigitalInput_64_127;
    }
    else if ((msgId & iv::comms::can::canMessageIds::alarm) == iv::comms::can::canMessageIds::alarm)
    {
        messageType = iv::comms::can::eMessageType::Alarm;
    }
    else if ((msgId & iv::comms::can::canMessageIds::analogInput) == iv::comms::can::canMessageIds::analogInput)
    {
        if (msgId <= MAX_ANALOG_INPUT_INDEX)
        {
            messageType = iv::comms::can::eMessageType::AnalogInput;
        }
        else
        {
            messageType = iv::comms::can::eMessageType::SlimStatusUpdate;
        }
    }
    else if ((msgId & iv::comms::can::canMessageIds::command) == iv::comms::can::canMessageIds::command)
    {
        messageType = iv::comms::can::eMessageType::Command;
    }
    else if ((msgId & iv::comms::can::canMessageIds::digitalInput0_63) ==
             iv::comms::can::canMessageIds::digitalInput0_63)
    {
        messageType = iv::comms::can::eMessageType::DigitalInput_0_63;
    }
    else if ((msgId & iv::comms::can::canMessageIds::alarmGroups) == iv::comms::can::canMessageIds::alarmGroups)
    {
        messageType = iv::comms::can::eMessageType::AlarmGroupsStatus;
    }
    else
    {
        IV_ASSERT_MSG("[prvMessageType] Unknown message type.");
    }
 
    return messageType;
}
 
inline unsigned char idTypeRepeaterByArea(iv::model::eShipArea eAreaShip)
{
    constexpr uint16_t PRV_INDEX_AREA_ECR = 0;
    constexpr uint16_t PRV_INDEX_AREA_BRIDGE = 7;
    unsigned char idTypeRepeater {PRV_INDEX_AREA_ECR};
 
    switch (eAreaShip)
    {
        case iv::model::eShipArea::Ecr:
            idTypeRepeater = PRV_INDEX_AREA_ECR;
            break;
 
        case iv::model::eShipArea::Bridge:
            idTypeRepeater = PRV_INDEX_AREA_BRIDGE;
            break;
 
        case iv::model::eShipArea::Accommodation:
        default:
            IV_MISSING_CASE_CHECK(eAreaShip);
            break;
    }
 
    return idTypeRepeater;
}
 
}// namespace iv::comms::can
 
#endif//IV_COMMS_CAN_UTILS_HPP