CanMessageFactory.hpp

Go to the documentation of this file.

#ifndef IV_COMMS_CAN_CANMESSAGEFACTORY_HPP
#define IV_COMMS_CAN_CANMESSAGEFACTORY_HPP
 
#include "comms/can/CMessageCan.hpp"
 
namespace iv::comms::can
{
 
class CanMessageFactory
{
public:
    static CMessageCan *readMessageCAN(const std::shared_ptr<iv::streams::IInputStream> &inputStream,
                                       const std::string &sourceId = "FILE");
    static void readMessageCAN(const std::shared_ptr<iv::streams::IInputStream> &inputMessage,
                               iv::types::timestamp *timestamp, uint32_t *msgId, uint8_t bytes[8],
                               uint32_t *lengthMessage, bool *isRTR, iv::types::subnetwork *idSubnetwork,
                               uint32_t *lengthMessageExtra, uint8_t **bytesExtra, bool *isExtended);
    static void writeMessageCAN(const std::shared_ptr<iv::streams::IOutputStream> &output, uint32_t timestamp,
                                uint32_t msgId, const uint8_t bytes[8], uint32_t lengthMessage, bool isRTR,
                                iv::types::subnetwork idSubnetwork, uint32_t lengthMessageExtra,
                                const uint8_t *bytesExtra);
 
    static CMessageCan *createMessage(const std::string &source, uint64_t msgIdAndUnitLocal, const uint8_t bytes[8],
                                      uint64_t timeStamp, uint64_t lengthData, bool isRTR, uint16_t idSubnetwork,
                                      uint64_t lengthDataExtra, uint8_t **bytesDataExtra, bool isExtended);
    static CMessageCan *createMessageQuerySdoClient(iv::types::unitId idUnit, const uint8_t bytes[8],
                                                    uint64_t lengthData);
 
    static CMessageCan *createMasterCommandLss(uint8_t cmdLSS);
    static CMessageCan *createMasterCommandLssData(uint8_t cmdLSS, uint8_t data);
 
    static CMessageCan *createNmtSetPreOperationalUnit(iv::types::unitId idUnit);
    static CMessageCan *createNmtStartAllUnit();
    static CMessageCan *createNmtStartUnit(uint32_t idUnit);
    static CMessageCan *createNmtStopAllUnit();
    static CMessageCan *createNmtStopUnit(uint16_t idUnit);
 
    static CMessageCan *createCallAll(iv::types::unitId idStation, uint16_t zoneRepeaters, bool isCalling);
    static CMessageCan *createCommandWatchCall(iv::types::unitId stationUnitId, uint16_t idRepeater, uint8_t command,
                                               uint8_t value);
    static CMessageCan *createOnDuty(iv::types::unitId idStation, uint16_t idRepeater, bool isOnDuty);
    static CMessageCan *createUpdateWatchCall(iv::types::unitId idStation, uint16_t zoneRepeaters,
                                              uint64_t watchCallState);
 
    static CMessageCan *createHistorySynchronize(iv::types::unitId idUnit, iv::types::stationId idStation,
                                                 uint16_t indexChannel, uint8_t typeAlarmAndStatus, uint64_t time,
                                                 float valueAlarm);
    static CMessageCan *createHistoryAckSynchronize(iv::types::unitId idUnit, iv::types::stationId idStation,
                                                    uint16_t indexChannel, uint8_t typeAlarmAndStatus, uint64_t time,
                                                    float valueAlarm);
 
    static CMessageCan *createValueAnalogFloat(uint16_t idUnit, uint16_t indexChannel, float value);
    static CMessageCan *createValueAnalogULong(uint16_t idUnit, uint16_t indexChannel, uint32_t value);
    static CMessageCan *createValueAnalogULongReversed(uint16_t idUnit, uint16_t indexChannel, uint32_t value);
 
    static CMessageCan *createSegmentString(uint16_t idUnit, uint16_t indexChannel, const char *value,
                                            uint64_t sizeValue, uint8_t segmentPosition, bool isLastSegment);
 
    static std::shared_ptr<CMessageCan> createAck(uint16_t idUnit, uint16_t indexChannel);
    static CMessageCan *createCommand(uint16_t idUnitSource, uint16_t idUnitDest, uint16_t indexChannel,
                                      uint8_t command, uint64_t value);
    static CMessageCan *createCommandCtrl(uint32_t idUnit, uint16_t indexChannel, uint64_t value);
    static CMessageCan *createCommandSetAnalogOutput(uint16_t idUnit, uint16_t indexChannel, uint64_t value);
    static CMessageCan *createTimeStamp(uint16_t numDaysSince1984, uint32_t numMilliseconds1984);
 
    static CMessageCan *createUpdateGroupsInAlarm(iv::types::unitId idStation, const void *buffer, uint64_t numBytes);
 
    static CMessageCan *createBroadcastAck(iv::model::eShipArea areaStation);
    static CMessageCan *createBroadcastNewAlarm(iv::model::eShipArea areaStation);
    static std::shared_ptr<CMessageCan> createSoundOff(iv::model::eShipArea areaStation);
 
    static CMessageCan *createAlarm(iv::types::unitId idUnit, uint16_t idChannelIndex,
                                    const iv::types::groupId &idGroup, uint8_t typeAlarm, float valueEventAlarm);
    static CMessageCan *createTimestampAlarm(iv::types::unitId idUnit, uint16_t indexChannel,
                                             const iv::types::groupId &idGroup, uint16_t numDaysSince1984,
                                             uint64_t milliseconds);
 
    static CMessageCan *createMessageSynchronizeTimeUtc(const iv::types::unitId &idStation, int16_t offsetGMT,
                                                        uint64_t timeUTC);
 
    static CMessageCan *createUpdateAlarmSignal(uint16_t idUnit);
    static CMessageCan *createUpdateAnalogSignal(uint16_t idUnit);
    static CMessageCan *createUpdateStationDigitalSignal(uint16_t idUnit);
 
    static CMessageCan *createUpdateGroupAlarmStates(iv::types::unitId stationUnitId, uint64_t groupAlarmStates);
 
    static void writeValuesDataMessageAlarm(const std::shared_ptr<iv::streams::OutputStreamMemory> &output,
                                            uint16_t indexChannel, uint8_t idGroupForLoms, uint8_t typeAlarm,
                                            float valueAlarm);
    static void writeValuesDataMessageAlarmTimestamp(const std::shared_ptr<iv::streams::OutputStreamMemory> &output,
                                                     uint16_t indexChannel, uint16_t numDaysSince1984,
                                                     uint32_t milliseconds);
    static void writeValuesDataMessageTimestamp(const std::shared_ptr<iv::streams::OutputStreamMemory> &output,
                                                uint16_t numDaysSince1984, uint32_t numMilliseconds1984);
    static void writeValuesDataMessageAnalogInput(const std::shared_ptr<iv::streams::OutputStreamMemory> &output,
                                                  iv::types::unitId idUnit, uint16_t indexChannel, uint8_t typeData,
                                                  uint32_t value);
    static void writeValuesDataMessageText(const std::shared_ptr<iv::streams::OutputStreamMemory> &output,
                                           uint8_t idUnit, uint16_t indexChannel, const char *value, uint64_t sizeValue,
                                           uint8_t segmentPosition, bool isLastSegment);
    static void writeValuesDataMessageCommand(const std::shared_ptr<iv::streams::OutputStreamMemory> &output,
                                              uint8_t idUnitLocalDest, uint16_t indexChannel, uint8_t command,
                                              uint32_t value);
    static void writeValuesDataMessageCommandBool(const std::shared_ptr<iv::streams::OutputStreamMemory> &output,
                                                  uint8_t idUnitLocalDest, uint16_t indexChannel, uint8_t command,
                                                  bool value);
    static void writeValuesDataMessageCommandChar(const std::shared_ptr<iv::streams::OutputStreamMemory> &output,
                                                  uint8_t idUnitLocalDest, uint16_t indexChannel, uint8_t command,
                                                  uint8_t value);
    static void writeValuesDataMessageGmtSync(const std::shared_ptr<iv::streams::OutputStreamMemory> &output,
                                              uint8_t idUnitStation, int8_t offsetGMT, uint32_t timeUTC);
    static void writeValuesDataMessageHeartbeat(const std::shared_ptr<iv::streams::OutputStreamMemory> &output,
                                                iv::comms::eHeartbeatState heartbeatState, uint8_t heartbeatType);
    static void writeValuesDataMessageHistorySync(const std::shared_ptr<iv::streams::OutputStreamMemory> &output,
                                                  const iv::types::stationId &idStation, uint16_t indexChannel,
                                                  uint8_t typeAlarmAndStatus, iv::types::timestamp time,
                                                  float valueAlarm);
 
    static CMessageCan *createStationHeartbeat(types::unitId stationUnitId);
 
private:
    static CMessageCan *prvCreateBroadcast(iv::model::eShipArea areaStation, uint16_t typeBroadcast);
    static CMessageCan *prvCreateCommand(iv::types::unitId idUnit, iv::types::unitId idUnitDest, uint16_t indexChannel,
                                         uint8_t command, uint64_t value);
    static CMessageCan *prvCreateHistorySynchronize(uint64_t msgId, iv::types::unitId idUnit,
                                                    const iv::types::stationId &idStation, uint16_t indexChannel,
                                                    uint8_t typeAlarmAndStatus, uint64_t time, float valueAlarm);
    static CMessageCan *prvCreateMessageDefault(std::string_view source, uint32_t msgId, iv::types::unitId idUnitLocal,
                                                const uint8_t bytes[8], iv::types::timestamp timeStamp,
                                                uint32_t lengthData, bool isRTR, iv::types::subnetwork idSubnetwork);
    static CMessageCan *prvCreateMessageDefault2(uint64_t cobId, iv::types::unitId idUnitLocal,
                                                 const std::shared_ptr<iv::streams::OutputStreamMemory> &output,
                                                 uint64_t sizeMessage, iv::types::subnetwork idSubnetwork);
    static CMessageCan *prvCreateMessageWithBytesExtra(std::string_view source, uint64_t msgId,
                                                       iv::types::unitId idUnitLocal, const uint8_t *bytes,
                                                       iv::types::timestamp timeStamp, uint64_t lengthData,
                                                       iv::types::subnetwork idSubnetwork);
    static CMessageCan *prvCreateMsgNmt(iv::types::unitId idUnitInSubnetwork, iv::types::subnetwork idSubnetwork,
                                        uint8_t commandSpec);
    static CMessageCan *prvCreateValueAnalogULong(uint32_t idUnit, uint16_t indexChannel, uint32_t value);
};
 
}// namespace iv::comms::can
 
#endif//IV_COMMS_CAN_CANMESSAGEFACTORY_HPP