ParametersDownloadManager.hpp

Go to the documentation of this file.

#ifndef IV_SRC_COMMS_PARAMETERSDOWNLOADMANAGER_HPP_
#define IV_SRC_COMMS_PARAMETERSDOWNLOADMANAGER_HPP_
 
#include "comms/ICommunicationDriver.hpp"
#include "comms/ParametersDownloadFactory.hpp"
#include "comms/can/CMessageCan.hpp"
#include "comms/can/LomCommunicationController.hpp"
#include "logs/DownloadLogger.hpp"
#include "units/model/Unit.hpp"
 
namespace iv::comms
{
 
enum class receptionMode
{
    SDO = 0,
    LSS = 1,
};
 
enum class eDownloadMode
{
    Simultaneous,
    Consecutive
};
 
enum class eDownloadScope
{
    ChannelsAndLogics,
    OnlyChannels,
    OnlyLogics
};
 
class ParametersDownloadManager
{
public:
    ParametersDownloadManager() = delete;
    explicit ParametersDownloadManager(const std::weak_ptr<iv::comms::can::LomCommunicationController> &controller);
 
    iv::comms::eResponse changeUnitId(const std::shared_ptr<iv::units::Unit> &sourceUnit,
                                      const std::shared_ptr<iv::units::Unit> &destUnit,
                                      const std::optional<std::shared_ptr<AbstractProgress>> &progress,
                                      const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger) const;
 
    iv::comms::eResponse downloadSingleChannel(const std::shared_ptr<iv::channels::AbstractChannel> &channel,
                                               const AbstractProgress *progress) const;
    std::set<iv::types::unitId> downloadUnits(const std::set<iv::types::unitId> &unitIds,
                                              const std::optional<std::shared_ptr<AbstractProgress>> &progress,
                                              const std::optional<std::shared_ptr<iv::logs::DownloadLogger>> &logger,
                                              eDownloadMode downloadMode,
                                              eDownloadScope = eDownloadScope::ChannelsAndLogics) const;
    std::set<iv::types::unitId>
    downloadAllUnits(const std::optional<std::shared_ptr<AbstractProgress>> &progress,
                     const std::optional<std::shared_ptr<iv::logs::DownloadLogger>> &logger) const;
    bool downloadUnit(const std::shared_ptr<iv::units::Unit> &unit,
                      const std::optional<std::shared_ptr<AbstractProgress>> &progress,
                      const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger) const;
    bool eraseUnit(const std::shared_ptr<iv::units::Unit> &unit,
                   const std::optional<std::shared_ptr<AbstractProgress>> &progress,
                   const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger) const;
    bool inquireUnitData(const std::shared_ptr<iv::units::Unit> &unit, iv::units::UnitData &unitData,
                         bool fromProject) const;
 
    iv::comms::eResponse uploadLogicInfo(iv::types::unitId unitId, iv::units::UnitLogicInfo &logicInfo) const;
    iv::comms::eResponse eraseUnitEEPROM(const std::shared_ptr<iv::units::Unit> &unit,
                                         const std::optional<std::shared_ptr<AbstractProgress>> &progress,
                                         const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger) const;
 
    iv::comms::eResponse setUnitSpare(iv::types::unitId destId,
                                      const std::optional<std::shared_ptr<AbstractProgress>> &progress,
                                      const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger,
                                      bool isDownloadIdOnly = false) const;
 
    bool downloadUnitOnlyId(const std::shared_ptr<iv::units::Unit> &unit,
                            const std::optional<std::shared_ptr<AbstractProgress>> &progress,
                            const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger) const;
 
    static bool checkChannelsFitInUnit(const std::shared_ptr<iv::units::Unit> &unit);
    static bool checkLogicsFitInUnit(const std::shared_ptr<iv::units::Unit> &unit);
 
    iv::comms::eResponse downloadUnsignedCharParameter(
            iv::types::unitId, uint16_t index, uint8_t subIndex, uint8_t value, bool withConfirmation,
            const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger = std::nullopt,
            std::string_view = "") const;
    iv::comms::eResponse downloadUnsignedShortParameter(
            iv::types::unitId unitId, uint16_t index, uint8_t subIndex, uint16_t value, bool withConfirmation,
            const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger = std::nullopt,
            std::string_view title = "") const;
 
    iv::comms::eResponse
    downloadLongParameter(types::unitId unitId, uint16_t index, uint8_t subIndex, int32_t value, bool withConfirmation,
                          const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger = std::nullopt,
                          std::string_view title = "") const;
 
    iv::comms::eResponse downloadUnsignedLongParameter(
            types::unitId unitId, uint16_t index, uint8_t subIndex, uint32_t value, bool withConfirmation,
            const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger = std::nullopt,
            std::string_view title = "") const;
 
    iv::comms::eResponse
    downloadFloatParameter(types::unitId unitId, uint16_t index, uint8_t subIndex, float value, bool withConfirmation,
                           const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger = std::nullopt,
                           std::string_view title = "") const;
 
    iv::comms::eResponse
    downloadString(iv::types::unitId unitId, uint16_t index, uint8_t subIndex, const std::string &value,
                   bool withConfirmation,
                   const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger = std::nullopt,
                   std::string_view title = "") const;
 
    iv::comms::eResponse
    downloadStringASCII(iv::types::unitId unitId, uint16_t index, uint8_t subIndex, const std::string &value,
                        bool withConfirmation,
                        const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger = std::nullopt,
                        std::string_view title = "") const;
 
    iv::comms::eResponse
    downloadStringASCIIWithLimit(iv::types::unitId unitId, uint16_t index, uint8_t subIndex, std::string value,
                                 uint32_t maxLength, bool withConfirmation,
                                 const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger = std::nullopt,
                                 std::string_view title = "") const;
 
    iv::comms::eResponse downloadUnsignedCharAsUnsignedShortParameter(
            iv::types::unitId unitId, uint16_t index, uint8_t subIndex, uint8_t value, bool withConfirmation,
            const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger = std::nullopt,
            std::string_view title = "") const;
 
    iv::comms::eResponse eraseLogic(const std::shared_ptr<iv::units::Unit> &unit,
                                    const std::optional<std::shared_ptr<AbstractProgress>> &progress,
                                    const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger) const;
    iv::comms::eResponse downloadRestoreAccessForLogics(
            iv::types::unitId unitId, const std::optional<std::shared_ptr<AbstractProgress>> &progress,
            const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger, std::string_view title) const;
    iv::comms::eResponse
    downloadParamsOnline(iv::types::unitId unitId, const std::optional<std::shared_ptr<AbstractProgress>> &progress,
                         const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger) const;
    iv::comms::eResponse
    downloadLogicBlocks(iv::types::unitId unitId, const std::optional<std::shared_ptr<AbstractProgress>> &progress,
                        const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger) const;
    iv::comms::eResponse
    downloadLogicInfo(iv::types::unitId unitId, const std::optional<std::shared_ptr<AbstractProgress>> &progress,
                      const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger) const;
 
    iv::comms::eResponse downloadChannel(iv::units::eUnitType unitType,
                                         const std::shared_ptr<iv::channels::AbstractChannel> &channel,
                                         const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger,
                                         bool withConfirmation) const;
 
    iv::comms::eResponse downloadStringASCIIWithPadding(
            iv::types::unitId unitId, uint16_t index, uint8_t subIndex, const std::string &value, uint32_t size,
            bool withConfirmation,
            const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger = std::nullopt,
            std::string_view title = "") const;
 
    iv::comms::eResponse
    downloadCommonChannelParameters(const std::shared_ptr<iv::channels::AbstractChannel> &channel,
                                    const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger,
                                    const bool withConfirmation) const;
 
    static iv::comms::eResponse
    downloadSerialChannelParameters(const std::shared_ptr<iv::channels::AbstractChannel> &channel,
                                    bool withConfirmation);
 
    iv::comms::eResponse
    downloadVerifyConfig(iv::types::unitId unitId, iv::types::timestamp lastProjectUpdate, bool withConfirmation,
                         const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger) const;
 
    iv::comms::eResponse downloadDateInfo(iv::types::unitId unitId, uint16_t index, uint8_t dateSubIndex,
                                          uint8_t timeSubIndex, iv::types::timestamp lastProjectUpdate,
                                          bool withConfirmation,
                                          const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger,
                                          std::string_view title = "") const;
 
    iv::comms::eResponse
    downloadVersionForeverZero(iv::types::unitId unitId, bool withConfirmation,
                               const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger) const;
 
    iv::comms::eResponse
    downloadCommonAlarmParameters(const std::shared_ptr<iv::channels::AbstractChannel> &channel, bool withConfirmation,
                                  const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger) const;
 
    iv::comms::eResponse
    downloadInhibitChannelParameter(iv::types::unitId, uint16_t index, uint8_t subIndex, uint16_t globalId,
                                    unsigned char valueCondition, bool withConfirmation,
                                    const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger,
                                    std::string_view title) const;
 
    iv::comms::eResponse
    downloadDigitalChannelParameters(const std::shared_ptr<iv::channels::AbstractChannel> &channel,
                                     bool withConfirmation,
                                     const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger) const;
 
    iv::comms::eResponse
    downloadAnalogChannelParameters(const std::shared_ptr<iv::channels::AbstractChannel> &channel,
                                    bool withConfirmation,
                                    const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger) const;
 
    iv::comms::eResponse uploadParameter(iv::types::unitId unitId, uint16_t index, uint8_t subIndex,
                                         std::vector<std::byte> &data) const;
 
    iv::comms::eResponse uploadString(iv::types::unitId unitId, uint16_t index, uint8_t subIndex,
                                      std::string &value) const;
 
    iv::comms::eResponse uploadUnsignedChar(iv::types::unitId unitId, uint16_t index, uint8_t subIndex,
                                            uint8_t &value) const;
    iv::comms::eResponse uploadUnsignedShort(iv::types::unitId unitId, uint16_t index, uint8_t subIndex,
                                             uint16_t &value) const;
 
    iv::comms::eResponse uploadUnsignedLong(iv::types::unitId unitId, uint16_t index, uint8_t subIndex,
                                            uint32_t &value) const;
 
    iv::comms::eResponse uploadDateInfo(iv::types::unitId unitId, uint16_t index, uint8_t dateSubIndex,
                                        uint8_t timeSubIndex, iv::types::timestamp &logicDate) const;
 
private:
    bool downloadUnitLogics(const std::shared_ptr<iv::units::Unit> &unit,
                            const std::optional<std::shared_ptr<AbstractProgress>> &progress,
                            const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger) const;
 
    std::set<iv::types::unitId>
    downloadUnitsConsecutive(const std::set<iv::types::unitId> &unitIds,
                             const std::optional<std::shared_ptr<AbstractProgress>> &progress,
                             const std::optional<std::shared_ptr<iv::logs::DownloadLogger>> &logger,
                             eDownloadScope downloadScope) const;
    std::set<iv::types::unitId>
    downloadUnitsSimultaneous(const std::set<iv::types::unitId> &unitIds,
                              const std::optional<std::shared_ptr<AbstractProgress>> &progress,
                              const std::optional<std::shared_ptr<iv::logs::DownloadLogger>> &logger,
                              eDownloadScope downloadScope) const;
    bool programUnit(const std::shared_ptr<iv::units::Unit> &unit,
                     const std::optional<std::shared_ptr<AbstractProgress>> &progress,
                     const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger) const;
 
    [[nodiscard]] iv::comms::eResponse sendMessage(const std::shared_ptr<CMessageCan> &message) const;
 
    iv::comms::eResponse receiveMessage(std::shared_ptr<CMessageCan> &returnMessage,
                                        receptionMode mode = receptionMode::SDO,
                                        std::optional<uint16_t> canMessageId = std::nullopt) const;
 
    static iv::comms::eResponse checkServerResponse(iv::types::unitId unitId, uint16_t index, uint8_t subIndex,
                                                    uint8_t *command, const std::shared_ptr<CMessageCan> &message);
 
    iv::comms::eResponse downloadParameter(iv::types::unitId unitId, uint16_t index, uint8_t subIndex,
                                           std::vector<std::byte> &data, bool withConfirmation, bool saveEEPROM,
                                           const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger,
                                           std::string_view title = "") const;
 
    iv::comms::eResponse
    sendStartDomainDownload(iv::types::unitId unitId, bool expediteTransfer, uint16_t index, uint8_t subIndex,
                            std::vector<std::byte> &data,
                            const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger) const;
    [[nodiscard]] iv::comms::eResponse
    rcvStartDomainDownload(uint32_t idUnit, uint16_t index, uint8_t subIndex, bool expediteTransfer,
                           const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger) const;
 
    iv::comms::eResponse
    sendDownloadSegments(iv::types::unitId unitId, uint16_t index, uint8_t subIndex, std::vector<std::byte> &data,
                         bool withConfirmation,
                         const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger) const;
 
    iv::comms::eResponse
    sendSegmentDomainDownload(iv::types::unitId unitId, bool lastSegment, bool toggle, std::vector<std::byte> &data,
                              const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger) const;
    [[nodiscard]] iv::comms::eResponse
    rcvSegmentDomainDownloadResponse(iv::types::unitId unitId, uint16_t index, uint8_t subIndex,
                                     const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger) const;
    static void readHeaderMsg(const std::shared_ptr<iv::streams::IInputStream> &input, uint8_t *command,
                              uint16_t &index, uint8_t &subIndex);
 
    iv::comms::eResponse saveEEPROM(iv::types::unitId unitId, uint16_t index, uint8_t subIndex, uint32_t value,
                                    bool withConfirmation,
                                    const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger,
                                    std::string_view title = "") const;
 
    iv::comms::eResponse sendStartDomainUpload(iv::types::unitId unitId, uint16_t index, uint8_t subIndex) const;
 
    iv::comms::eResponse rcvStartDomainUpload(iv::types::unitId unitId, uint16_t index, uint8_t subIndex,
                                              std::vector<std::byte> &data, bool &expediteTransfer) const;
 
    iv::comms::eResponse getUploadSegments(iv::types::unitId unitId, uint16_t index, uint8_t subIndex,
                                           std::vector<std::byte> &data) const;
 
    [[nodiscard]] iv::comms::eResponse sendUploadSegment(iv::types::unitId unitId, bool toggle, uint16_t index,
                                                         uint8_t subIndex) const;
 
    iv::comms::eResponse rcvUploadSegment(iv::types::unitId unitId, uint16_t index, uint8_t subIndex, bool &lastSegment,
                                          std::vector<std::byte> &data) const;
 
    static bool isDomainExpediteTransfer(uint8_t command);
 
    static bool hasUnitInfo(iv::units::eUnitType unitType);
 
    iv::comms::eResponse getLssAddress(uint8_t lssCommand, uint32_t &value) const;
 
    iv::comms::eResponse switchParamConfigurationLss(uint8_t lssCommand, uint32_t value) const;
 
    iv::comms::eResponse switchConfigurationOperationModes(const uint32_t &vendor, const uint32_t &product,
                                                           const uint32_t &revision,
                                                           const uint32_t &serialNumber) const;
 
    iv::comms::eResponse setIdNode(iv::types::unitId unitId, uint8_t nodeId, bool withConfirmation) const;
 
    iv::comms::eResponse setStoreConfigDataLss(iv::types::unitId unitId, bool withConfirmation) const;
 
    static bool getInhibitionTagCondition(const std::shared_ptr<iv::channels::AbstractChannel> &channel,
                                          uint16_t &globalId, bool &valueCondition);
 
    bool downloadUnitOnlyLogics(const std::shared_ptr<iv::units::Unit> &unit,
                                const std::optional<std::shared_ptr<AbstractProgress>> &progress,
                                const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger) const;
 
    bool downloadUnitChannels(const std::shared_ptr<iv::units::Unit> &unit,
                              const std::optional<std::shared_ptr<AbstractProgress>> &progress,
                              const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger) const;
 
    bool downloadUnitOnlyChannels(const std::shared_ptr<iv::units::Unit> &unit,
                                  const std::optional<std::shared_ptr<AbstractProgress>> &progress,
                                  const std::optional<std::shared_ptr<iv::logs::IDownloadLogger>> &logger) const;
 
    std::weak_ptr<iv::comms::can::LomCommunicationController> m_controller;
 
    struct LogTitles
    {
        static constexpr std::string_view downloadingUnits = "Downloading Units";
        static constexpr std::string_view unit = "Unit {}";
        static constexpr std::string_view unitChannels = "Channels of Unit {}";
        static constexpr std::string_view unitLogics = "Logics of Unit {}";
        static constexpr std::string_view unitLogicInfo = "Logic Info of Unit {}";
        static constexpr std::string prepUnit = "Prep. Unit {}";
        static constexpr std::string_view eraseUnit = "Ers. Unit {}";
        static constexpr std::string_view eraseUnitLogics = "Erasing Logics of Unit {}";
        static constexpr std::string_view verifyConfig = "Verifying Config. of Unit {}";
        static constexpr std::string_view verifyConfigDate = "Verifying Config. Date of Unit {}";
        static constexpr std::string_view parameterVersionDate = "Parameter Version Date of Unit {}";
        static constexpr std::string_view channel = "Channel {}";
        static constexpr std::string_view date = "Date";
        static constexpr std::string_view time = "Time";
        static constexpr std::string_view versionForEverZero = "Version Forever Zero";
        static constexpr std::string_view commonChannel = "Common params. channel {}";
        static constexpr std::string_view alarmChannel = "Alarm params. channel {}";
        static constexpr std::string_view funcChannel = "Channel func.";
        static constexpr std::string_view tagChannel = "Channel tag";
        static constexpr std::string_view descChannel = "Channel desc.";
        static constexpr std::string_view areaChannel = "Channel area";
        static constexpr std::string_view mimicIdChannel = "Channel mimic id";
        static constexpr std::string_view alarmDelayOn = "Alarm delay on";
        static constexpr std::string_view alarmDelayOff = "Alarm delay off";
        static constexpr std::string_view alarmOffscan = "Alarm offscan";
        static constexpr std::string_view groupIdForLoms = "Group ID for loms";
        static constexpr std::string_view inhibitChannel = "Inhibit channel";
        static constexpr std::string_view digitalParams = "Digital params. channel {}";
        static constexpr std::string_view analogParams = "Analog params channel {}";
        static constexpr std::string_view channelInverted = "Channel Inverted";
        static constexpr std::string_view channelDelayOn = "Channel delay on";
        static constexpr std::string_view channelDelayOff = "Channel delay off";
        static constexpr std::string_view alarmEnabled = "Alarm enabled";
        static constexpr std::string_view digitalAlarmLimit = "Digital alarm limit";
        static constexpr std::string_view analogType = "Analog type";
        static constexpr std::string_view engUnits = "Engineering units";
        static constexpr std::string_view sensorLow = "Sensor low";
        static constexpr std::string_view sensorHigh = "Sensor high";
        static constexpr std::string_view engLimitLow = "Low engineering limit";
        static constexpr std::string_view engLimitHigh = "High engineering limit";
        static constexpr std::string_view deadBand = "Dead band";
        static constexpr std::string_view filterTime = "Filter time";
        static constexpr std::string_view lowAlarmLimit = "Low alarm limit";
        static constexpr std::string_view lowLowAlarmLimit = "Low low alarm limit";
        static constexpr std::string_view highAlarmLimit = "High alarm limit";
        static constexpr std::string_view highHighAlarmLimit = "High high alarm limit";
        static constexpr std::string_view inhibitSensorFailureLow = "Inhibit sensor failure low";
        static constexpr std::string_view inhibitSensorFailureHigh = "Inhibit sensor failure high";
        static constexpr std::string_view fileNameLogic = "Logic file name";
        static constexpr std::string_view nameLogic = "Logic name";
        static constexpr std::string_view versionLogic = "Logic version";
        static constexpr std::string_view authorLogic = "Logic author";
        static constexpr std::string_view dateLogic = "Logic date";
        static constexpr std::string_view timeLogic = "Logic time";
        static constexpr std::string_view saveEEPROM = "Save EEPROM";
        static constexpr std::string_view descriptionLogic = "Logic description";
        static constexpr std::string_view longDownload = "Long Download";
        static constexpr std::string_view numberOfDecimals = "Number of decimals";
        static constexpr std::string_view unsignedCharDownload = "UChar download";
        static constexpr std::string_view unsignedCharAsUnsignedShortDownload = "UChar as UShort download";
        static constexpr std::string_view unsignedShortDownload = "UShort download";
        static constexpr std::string_view stringDownload = "String download";
        static constexpr std::string_view stringASCIIDownload = "String ASCII download";
        static constexpr std::string_view stringAsciiWithPaddingDownload = "String ASCII with padding download";
        static constexpr std::string_view floatDownload = "Float download";
        static constexpr std::string_view unsignedLongDownload = "ULong download";
        static constexpr std::string_view downloadIndexSubindex = "Downloading index:{:X} sub:{:X}";
        static constexpr std::string_view sdoSegments = "SDO Segments";
        static constexpr std::string_view restoringWriteAccessSignature = "Write access signature";
        static constexpr std::string_view restoringDefaultParameters = "Restoring default parameters";
        static constexpr std::string_view storingDefaultParameters = "Storing default parameters";
        static constexpr std::string_view numBlocksInUnit = "Number of blocks in unit";
        static constexpr std::string_view sizeOfLogicBlock = "Size of logic block";
        static constexpr std::string_view logicBlocksOfUnit = "Logic blocks of unit {}";
        static constexpr std::string_view logicBlock = "Logic block {}";
        static constexpr std::string_view logicBlockParameters = "Logic Block Parameters";
        static constexpr std::string_view logicBlockParameter = "Logic Block Parameter";
        static constexpr std::string_view crc = "CRC";
        static constexpr std::string_view savingLogicEEPROM = "Saving logic EEPROM";
        static constexpr std::string_view parameterOnline = "Parameter online";
        static constexpr std::string_view parameterOnlineData = "Parameter online data";
        static constexpr std::string_view parameterOnlineTag = "Parameter Online Tag";
        static constexpr std::string_view parameterOnlineValue = "Parameter Online Value";
        static constexpr std::string_view automataMode = "Automata mode";
        static constexpr std::string_view lomId = "Lom ID";
    };
 
    struct LogMessages
    {
        static constexpr std::string_view settingUnitPreoperational = "Setting unit preoperational";
        static constexpr std::string_view unitInIncorrectMode = "Error unit {} is in an incorrect mode";
        static constexpr std::string_view settingUnitInProgramMode = "Setting unit in program mode";
        static constexpr std::string_view downloadingChannels = "Downloading channels";
        static constexpr std::string_view errorDownloadingChannel = "Error downloading channel {}";
        static constexpr std::string_view verifyingConfiguration = "Verifying configuration";
        static constexpr std::string_view errorVerifyingConfiguration = "Error verifying configuration";
        static constexpr std::string_view downloadingLogics = "Downloading logics";
        static constexpr std::string_view restoringDefaultParametersForLogics =
                "Restoring default parameters for logics";
        static constexpr std::string_view downloadingParametersOnline = "Downloading parameters online";
        static constexpr std::string_view errorDownloadingParametersOnline = "Error downloading parameters online";
        static constexpr std::string_view downloadingLogicBlocks = "Downloading logic blocks";
        static constexpr std::string_view errorDownloadingLogicBlocks = "Error downloading logic blocks";
        static constexpr std::string_view savingLogicEEPROM = "Saving logic in EEPROM";
        static constexpr std::string_view errorSavingLogicEEPROM = "Error saving logic in EEPROM";
        static constexpr std::string_view downloadingLogicInfo = "Downloading logic info";
        static constexpr std::string_view errorDownloadingLogicInfo = "Error downloading logic info";
        static constexpr std::string_view resettingUnit = "Resetting unit";
        static constexpr std::string_view errorResettingUnit = "Error resetting unit";
        static constexpr std::string_view erasingUnit = "Erasing Unit: {}";
        static constexpr std::string_view errorSettingUnitPreoperational = "Error setting unit preoperational";
        static constexpr std::string_view restoringDefaultParameters = "Restoring default parameters";
        static constexpr std::string_view errorRestoringDefaultParameters = "Error restoring default parameters";
        static constexpr std::string_view storingDefaultParameters = "Storing default parameters";
        static constexpr std::string_view errorStoringDefaultParameters = "Error storing default parameters";
        static constexpr std::string_view erasingLogic = "Starting erasing logic in Unit : {}";
        static constexpr std::string_view errorRestoringAccess = "Error restoring access";
        static constexpr std::string_view checkingParametersOnline = "Checking parameters online";
        static constexpr std::string_view sendingNumberOfLogicBlocksInUnit =
                "Sending number of logic blocks in unit {}";
        static constexpr std::string_view sendingSizeOfLogicBlock = "Sending size of logic block in unit {}";
        static constexpr std::string_view checkingLogicInfo = "Checking logic info";
        static constexpr std::string_view erasingEEPROM = "Erasing EEPROM in Unit {}";
        static constexpr std::string_view unitsLogicsProgrammedSuccessfully = "Units logics programmed successfully";
        static constexpr std::string_view unitProgrammedSuccessfully = "Unit {} programmed successfully";
        static constexpr std::string_view changeUnitId = "Changing unit id from {} to {}";
        static constexpr std::string_view preparingUnit = "Preparing unit {} for download";
        static constexpr std::string_view restoringAccessForLogics = "Restoring access for logics";
        static constexpr std::string_view unitProgramming = "Programming unit {}";
        static constexpr std::string_view unitChannelsDownloading = "Downloading channels for unit {}";
        static constexpr std::string_view unitLogicsDownloading = "Downloading logics for unit {}";
        static constexpr std::string_view downloadingChannel = "Downloading channel {}";
        static constexpr std::string_view downloadingChannelFunc = "Downloading channel function";
        static constexpr std::string_view downloadingCommonChannelParameters =
                "Downloading channel {} common parameters";
        static constexpr std::string_view downloadingUnsignedLongParameter = "Downloading unsigned long parameter: {}";
        static constexpr std::string_view downloadingUnsignedCharParameter = "Downloading unsigned char parameter: {}";
        static constexpr std::string_view downloadingLongParameter = "Downloading long parameter: {}";
        static constexpr std::string_view downloadingStringParameter = "Downloading string parameter: \"{}\"";
        static constexpr std::string_view downloadingAsciiStringParameter =
                "Downloading ASCII string parameter: \"{}\"";
        static constexpr std::string_view downloadingAsciiStringWithLimitParameter =
                "Downloading ASCII string parameter: \"{}\" with limit {}";
        static constexpr std::string_view downloadingUnsignedCharAsUnsignedShortParameter =
                "Downloading unsigned char as unsigned short parameter: {}";
        static constexpr std::string_view downloadingUnsignedShortParameter =
                "Downloading unsigned short parameter: {}";
        static constexpr std::string_view savingEEPROM = "Saving EEPROM :{}";
        static constexpr std::string_view downloadingFloatParameter = "Downloading float parameter: {}";
        static constexpr std::string_view sdoParameterDownload = "Downloading SDO parameter index: {:X} subIndex: {:X}";
        static constexpr std::string_view sendBeginDomainDownload = "Sending domain start, command: {:X} data: {}";
        static constexpr std::string_view receiveBeginDomainDownload = "Received domain start, command: {:X}";
        static constexpr std::string_view errorReceivingBeginDomainDownload = "Error receiving begin domain download";
        static constexpr std::string_view downloadingSegments = "Downloading segments";
        static constexpr std::string_view sendDomainSegment = "Sending segment, command: {:X} data: {}";
        static constexpr std::string_view receiveDomainSegment = "Received segment, command: {:X}";
        static constexpr std::string_view errorReceivingDomainSegment = "Error receiving domain segment";
        static constexpr std::string_view downloadingChannelTag = "Downloading channel tag";
        static constexpr std::string_view downloadingChannelDescription = "Downloading channel description";
        static constexpr std::string_view downloadingChannelArea = "Downloading channel area";
        static constexpr std::string_view downloadingChannelMimicId = "Downloading channel mimic id";
        static constexpr std::string_view downloadingChannelAlarmParams = "Downloading channel alarm parameters";
        static constexpr std::string_view downloadingAlarmDelayOn = "Downloading alarm delay on";
        static constexpr std::string_view downloadingAlarmDelayOff = "Downloading alarm delay off";
        static constexpr std::string_view downloadingOffscan = "Downloading offscan";
        static constexpr std::string_view downloadingGroupIdForLoms = "Downloading group id for LOMs";
        static constexpr std::string_view downloadingInhibitChannel = "Downloading inhibit channel";
        static constexpr std::string_view downloadingDigitalParams = "Downloading digital parameters";
        static constexpr std::string_view downloadingChannelInverted = "Downloading channel inverted";
        static constexpr std::string_view downloadingChannelDelayOn = "Downloading channel delay on";
        static constexpr std::string_view downloadingChannelDelayOff = "Downloading channel delay off";
        static constexpr std::string_view downloadingAlarmEnabled = "Downloading alarm enabled";
        static constexpr std::string_view downloadingDigitalAlarmLimit = "Downloading digital alarm limit";
        static constexpr std::string_view downloadingAnalogParams = "Downloading analog parameters";
        static constexpr std::string_view downloadingAnalogType = "Downloading analog type";
        static constexpr std::string_view downloadingEngUnits = "Downloading engineering units";
        static constexpr std::string_view downloadingSensorLow = "Downloading sensor low";
        static constexpr std::string_view downloadingSensorHigh = "Downloading sensor high";
        static constexpr std::string_view downloadingLowEngLimit = "Downloading low engineering limit";
        static constexpr std::string_view downloadingHighEngLimit = "Downloading high engineering limit";
        static constexpr std::string_view downloadingDeadBand = "Downloading dead band";
        static constexpr std::string_view downloadingFilterTime = "Downloading filter time";
        static constexpr std::string_view downloadingNumberOfDecimals = "Downloading number of decimals";
        static constexpr std::string_view downloadingLowAlarmLimit = "Downloading low alarm limit";
        static constexpr std::string_view downloadingLowLowAlarmLimit = "Downloading low low alarm limit";
        static constexpr std::string_view downloadingHighAlarmLimit = "Downloading high alarm limit";
        static constexpr std::string_view downloadingHighHighAlarmLimit = "Downloading high high alarm limit";
        static constexpr std::string_view downloadingInhibitSensorFailureLow =
                "Downloading inhibit instrument failure low";
        static constexpr std::string_view downloadingInhibitSensorFailureHigh =
                "Downloading inhibit instrument failure high";
        static constexpr std::string_view downloadingLogicFileName = "Downloading logic file name";
        static constexpr std::string_view downloadingLogicName = "Downloading logic name";
        static constexpr std::string_view downloadingLogicVersion = "Downloading logic version";
        static constexpr std::string_view downloadingLogicAuthor = "Downloading logic author";
        static constexpr std::string_view downloadingLogicDate = "Downloading logic date";
        static constexpr std::string_view downloadingLogicTime = "Downloading logic time";
        static constexpr std::string_view downloadingLogicDescription = "Downloading logic description";
        static constexpr std::string_view downloadingVerifyConfigDate = "Downloading verify config date";
        static constexpr std::string_view downloadingParamVersionDate = "Downloading parameter version date";
        static constexpr std::string_view downloadingVersionForeverZero = "Downloading version for ever zero";
        static constexpr std::string_view downloadingDate = "Downloading date";
        static constexpr std::string_view downloadingTime = "Downloading time";
        static constexpr std::string_view writingLogicBlocksInUnit = "Writing logic blocks in unit {}";
        static constexpr std::string_view writingLogicBlock = "Writing logic block {}";
        static constexpr std::string_view writingLogicBlockParams =
                "Writing logic block params: Type {}, subType {}, numParams {}, size {}";
        static constexpr std::string_view downloadingLogicBlockParameters = "Downloading logic block parameters";
        static constexpr std::string_view downloadingLogicBlockParameter = "Downloading logic block parameter: {}";
        static constexpr std::string_view downloadingLogicCrc = "Downloading logic CRC";
        static constexpr std::string_view downloadingLogicOnlineParameterData =
                "Downloading online parameter data: block order {}, order in block {}, external tag \"{}\"";
        static constexpr std::string_view downloadingLogicOnlineParameter = "Downloading online parameter";
        static constexpr std::string_view downloadingTag1 = "Downloading tag1";
        static constexpr std::string_view downloadingTag2 = "Downloading tag2";
        static constexpr std::string_view downloadingOnlineParameterValue = "Downloading online parameter value";
        static constexpr std::string_view downloadingAutomataMode = "Downloading automata mode";
        static constexpr std::string_view restoringWriteAccessSignature = "Restoring write access signature";
        static constexpr std::string_view downloadingLomId = "Downloading LOM ID";
        static constexpr std::string_view errorDownloadingParameter = "ERROR: couldn't download parameter";
        static constexpr std::string_view errorChannelsDontFit = "ERROR: Channels don't fit in unit";
        static constexpr std::string_view errorLogicsDontFit = "ERROR: Logics don't fit in unit";
    };
};
 
}// namespace iv::comms
 
#endif//IV_SRC_COMMS_PARAMETERSDOWNLOADMANAGER_HPP_