Defines.h

Go to the documentation of this file.

//
// Copyright (c) 2002-2026 WEINZIERL ENGINEERING GmbH
// All rights reserved.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
// SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY,
// WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE
//
 
#ifndef __BAOSLIB_DEFINES_H__
#define __BAOSLIB_DEFINES_H__
 
#include "baos/config.h"
 
#include <cassert>
#include <map>
#include <sstream>
#include <string>
#include <utility>
 
namespace wz::baos::protocol
{
using DatapointValue = wz::baos::Buffer;  
using DatapointValues =
    std::map<std::uint16_t, DatapointValue>;  
 
using ServerItem_StatusFlagType = std::uint16_t;  
 
enum class ServerItem_StatusFlag : ServerItem_StatusFlagType
{
    RUNNING      = 1,  
    LOADED       = 2,  
    TL_CONNECTED = 4,  
    SECURE       = 8   
};
 
enum class DatapointValueFilter : std::uint8_t
{
    ALL,     
    VALID,   
    UPDATED  
};
 
enum class DatapointSetCommand : std::uint8_t
{
    NoCommand               = 0x00,  
    SetNewValue             = 0x01,  
    SendValueOnBus          = 0x02,  
    SetNewValueAndSendOnBus = 0x03,  
    ReadNewValueViaBus =
        0x04,  
    ClearTransmissionState = 0x05  
};
 
enum class TransmitPriority : std::uint8_t
{
    System = 0x00,
    High   = 0x01,
    Alarm  = 0x02,
    Low    = 0x03
};
 
BAOSLIB_EXPORT std::string transmitPriorityToString(
    TransmitPriority transmitPrio);  
 
enum class TransmissionStatus : std::uint8_t
{
    Idle_OK    = 0x00,
    Idle_Error = 0x01,
    InProgress = 0x02,
    Request    = 0x03
};
 
BAOSLIB_EXPORT std::string transmissionStatusToString(
    TransmissionStatus transmissionStatus);  
 
enum class BaosSubServiceTypes : std::uint8_t
{
    MinRequest                     = 0x01,
    GetServerItemRequest           = 0x01,
    SetServerItemRequest           = 0x02,
    GetDatapointDescriptionRequest = 0x03,
    GetDescriptionStringRequest    = 0x04,
    GetDatapointValueRequest       = 0x05,
    SetDatapointValueRequest       = 0x06,
    GetParameterByteRequest        = 0x07,
    MaxRequest                     = 0x0C,
 
    MinResponse                     = 0x81,
    GetServerItemResponse           = 0x81,
    SetServerItemResponse           = 0x82,
    GetDatapointDescriptionResponse = 0x83,
    GetDescriptionStringResponse    = 0x84,
    GetDatapointValueResponse       = 0x85,
    SetDatapointValueResponse       = 0x86,
    GetParameterByteResponse        = 0x87,
    MaxResponse                     = 0x8C,
 
    MinIndication            = 0xC1,
    DatapointValueIndication = 0xC1,
    ServerItemIndication     = 0xC2,
    MaxIndication            = 0xC2,
};
 
BAOSLIB_EXPORT std::string getBaosSubServiceTypeDescription(
    BaosSubServiceTypes subServiceType);  
 
enum class BaosResponseCode : std::uint8_t
{
    Success             = 0,   
    Internal            = 1,   
    NoItemFound         = 2,   
    BufferTooSmall      = 3,   
    ItemNotWriteable    = 4,   
    ServiceNotSupported = 5,   
    BadServiceParameter = 6,   
    WrongDpId           = 7,   
    BadDpCmd            = 8,   
    BadDpValueLength    = 9,   
    MessageInconsistent = 10,  
    ObjectServerIsBusy  = 11,  
};
 
BAOSLIB_EXPORT std::string baosResponseCodeToString(BaosResponseCode code);  
 
enum class DatapointSize : std::uint8_t
{
    BITS_1   = 0,
    BITS_2   = 1,
    BITS_3   = 2,
    BITS_4   = 3,
    BITS_5   = 4,
    BITS_6   = 5,
    BITS_7   = 6,
    BYTE_1   = 7,
    BYTES_2  = 8,
    BYTES_3  = 9,
    BYTES_4  = 10,
    BYTES_6  = 11,
    BYTES_8  = 12,
    BYTES_10 = 13,
    BYTES_14 = 14
};
 
BAOSLIB_EXPORT std::string dpSizeToString(DatapointSize dpSize);  
 
BAOSLIB_EXPORT std::uint8_t dpSizeInBytes(
    DatapointSize dpSize);  
 
enum class DPT : std::uint8_t
{
    DPT_1  = 1,   
    DPT_2  = 2,   
    DPT_3  = 3,   
    DPT_4  = 4,   
    DPT_5  = 5,   
    DPT_6  = 6,   
    DPT_7  = 7,   
    DPT_8  = 8,   
    DPT_9  = 9,   
    DPT_10 = 10,  
    DPT_11 = 11,  
    DPT_12 = 12,  
    DPT_13 = 13,  
    DPT_14 = 14,  
    DPT_15 = 15,  
    DPT_16 = 16,  
    DPT_17 = 17,  
    DPT_18 = 18,  
};
 
BAOSLIB_EXPORT std::string dptToString(DPT dpt);  
 
 
enum class ServerItemId : std::uint8_t
{
    Invalid                   = 0,   
    HardwareType              = 1,   
    HardwareVersion           = 2,   
    FirmwareVersion           = 3,   
    ManufactureCodeDevice     = 4,   
    ManufactureCodeApp        = 5,   
    ApplicationId             = 6,   
    ApplicationVersion        = 7,   
    SerialNumber              = 8,   
    TimeSinceReset            = 9,   
    BusConnected              = 10,  
    MaxBufferSize             = 11,  
    LengthOfDescriptionString = 12,  
    BaudrateItem              = 13,  
    CurrentBufferSize         = 14,  
    ProgrammingMode           = 15,  
    BinaryProtocolVersion     = 16,  
    IndicationSetting         = 17,  
    WebServicesProtocolVersion =
        18,  
    RestServiceProtocolVersion = 19,  
    IndividualAddress          = 20,  
    MacAddress                 = 21,  
    TunnellingEnabled          = 22,  
    BaosBinaryEnabled          = 23,  
    BaosWebEnabled             = 24,  
    BaosRestEnabled            = 25,  
    HttpFileEnabled            = 26,  
    SearchRequestEnabled       = 27,  
    IsStructured               = 28,  
    MaxManagementClients       = 29,  
    ConnectedManagementClients = 30,  
    MaxTunnellingClients       = 31,  
    ConnectedTunnellingClients = 32,  
    MaxBaosUdpClients          = 33,  
    ConnectedBaosUdpClients    = 34,  
    MaxBaosTcpClients          = 35,  
    ConnectedBaosTcpClients    = 36,  
    DeviceFriendlyName         = 37,  
    MaxDatapoints              = 38,  
    ConfiguredDatapoints       = 39,  
    MaxParameterBytes          = 40,  
    DownloadCounter            = 41,  
    IPAssignment               = 42,  
    IPAddress                  = 43,  
    SubnetMask                 = 44,  
    DefaultGateway             = 45,  
    TimeSinceResetUnit         = 46,  
    SystemTime                 = 47,  
    SystemTimezoneOffset       = 48,  
    MenuEnabled                = 49,  
    SuspendEnabled             = 50,  
    RFDomainAddress            = 51,  
    StatusFlagsSupported       = 52,  
    StatusFlags                = 53   
};
 
BAOSLIB_EXPORT std::string serverItemIdToString(
    ServerItemId sid);  
 
class BAOSLIB_EXPORT StatusFlags
{
public:
    StatusFlags(const ServerItem_StatusFlagType val) : value_{val} {};
    StatusFlags(const Buffer& data)
    {
        assert(data.size() >= 2);
        value_ = data[0] << 8 | data[1];
    }
 
    StatusFlags(bool running, bool loaded, bool tl_connected, bool secure)
    {
        value_ = 0x00;
        if (running)
            value_ |= static_cast<std::underlying_type<ServerItem_StatusFlag>::type>(ServerItem_StatusFlag::RUNNING);
        if (loaded)
            value_ |= static_cast<std::underlying_type<ServerItem_StatusFlag>::type>(ServerItem_StatusFlag::LOADED);
        if (tl_connected)
            value_ |=
                static_cast<std::underlying_type<ServerItem_StatusFlag>::type>(ServerItem_StatusFlag::TL_CONNECTED);
        if (secure)
            value_ |= static_cast<std::underlying_type<ServerItem_StatusFlag>::type>(ServerItem_StatusFlag::SECURE);
    }
 
    bool isRunning() const
    {
        return value_ & static_cast<std::underlying_type<ServerItem_StatusFlag>::type>(ServerItem_StatusFlag::RUNNING);
    }
 
    bool isLoaded() const
    {
        return value_ & static_cast<std::underlying_type<ServerItem_StatusFlag>::type>(ServerItem_StatusFlag::LOADED);
    }
 
    bool isTLConnected() const
    {
        return value_ &
               static_cast<std::underlying_type<ServerItem_StatusFlag>::type>(ServerItem_StatusFlag::TL_CONNECTED);
    }
 
    bool isSecure() const
    {
        return value_ & static_cast<std::underlying_type<ServerItem_StatusFlag>::type>(ServerItem_StatusFlag::SECURE);
    }
 
    operator ServerItem_StatusFlagType() const
    {
        return value_;
    }
 
private:
    ServerItem_StatusFlagType value_;  
};
 
 
class BAOSLIB_EXPORT StatusFlagsSupported
{
public:
    StatusFlagsSupported(const ServerItem_StatusFlagType val) : value_{val} {};
 
    StatusFlagsSupported(const Buffer& data)
    {
        assert(data.size() >= 2);
        value_ = data[0] << 8 | data[1];
    }
 
    StatusFlagsSupported(bool running, bool loaded, bool tl_connected, bool secure)
    {
        value_ = 0x00;
        if (running)
            value_ |= static_cast<std::underlying_type<ServerItem_StatusFlag>::type>(ServerItem_StatusFlag::RUNNING);
        if (loaded)
            value_ |= static_cast<std::underlying_type<ServerItem_StatusFlag>::type>(ServerItem_StatusFlag::LOADED);
        if (tl_connected)
            value_ |=
                static_cast<std::underlying_type<ServerItem_StatusFlag>::type>(ServerItem_StatusFlag::TL_CONNECTED);
        if (secure)
            value_ |= static_cast<std::underlying_type<ServerItem_StatusFlag>::type>(ServerItem_StatusFlag::SECURE);
    }
 
    bool hasRunning() const
    {
        return value_ & static_cast<std::underlying_type<ServerItem_StatusFlag>::type>(ServerItem_StatusFlag::RUNNING);
    }
 
    bool hasLoaded() const
    {
        return value_ & static_cast<std::underlying_type<ServerItem_StatusFlag>::type>(ServerItem_StatusFlag::LOADED);
    }
 
    bool hasTLConnected() const
    {
        return value_ &
               static_cast<std::underlying_type<ServerItem_StatusFlag>::type>(ServerItem_StatusFlag::TL_CONNECTED);
    }
 
    bool hasSecure() const
    {
        return value_ & static_cast<std::underlying_type<ServerItem_StatusFlag>::type>(ServerItem_StatusFlag::SECURE);
    }
 
    operator ServerItem_StatusFlagType() const
    {
        return value_;
    }
 
private:
    ServerItem_StatusFlagType value_;  
};
 
struct BAOSLIB_EXPORT ServerItem
{
    ServerItem() = default;  // The default constructor
 
    ServerItem(ServerItemId id_, std::uint8_t length_, Buffer&& data_) 
        : id{id_}, 
          length{length_}, 
          data{std::move(data_)}
    {
    }
    
    ServerItem(ServerItemId id_, std::uint8_t length_, const Buffer& data_) 
        : id{id_}, 
          length{length_}, 
          data{data_}
    {
    }
 
    ServerItemId id{ServerItemId::Invalid};  
    std::uint8_t length{0};                  
    Buffer data;                             
};
 
using ServerItems = std::vector<ServerItem>;  
 
struct BAOSLIB_EXPORT DatapointConfigFlags
{
    DatapointConfigFlags()
        : transmitPriority{0},
          communication{0},
          readFromBus{0},
          writeFromBus{0},
          readOnInit{0},
          transmitToBus{0},
          updateResponse{0}
    {
    }
 
    DatapointConfigFlags(std::uint8_t&& value)
    {
        updateResponse   = value >> 7;
        transmitToBus    = value >> 6 & 0x01;
        readOnInit       = value >> 5 & 0x01;
        writeFromBus     = value >> 4 & 0x01;
        readFromBus      = value >> 3 & 0x01;
        communication    = value >> 2 & 0x01;
        transmitPriority = value & 0x03;
    }
 
    DatapointConfigFlags& operator=(std::uint8_t& value)
    {
        updateResponse   = value >> 7;
        transmitToBus    = value >> 6 & 0x01;
        readOnInit       = value >> 5 & 0x01;
        writeFromBus     = value >> 4 & 0x01;
        readFromBus      = value >> 3 & 0x01;
        communication    = value >> 2 & 0x01;
        transmitPriority = value & 0x03;
        return *this;
    }
 
    operator std::uint8_t() const
    {
        std::uint8_t value{0};
        value = updateResponse << 7 | transmitToBus << 6 | readOnInit << 5 | writeFromBus << 4 | readFromBus << 3 |
                communication << 2 | transmitPriority;
        return value;
    }
 
    std::string toString() const
    {
        std::ostringstream oss;
        std::string flags{"______"};
        if (communication) flags[0] = 'C';
        if (readFromBus) flags[1] = 'R';
        if (writeFromBus) flags[2] = 'W';
        if (transmitToBus) flags[3] = 'T';
        if (updateResponse) flags[4] = 'U';
        if (readOnInit) flags[5] = 'I';
 
        oss << transmitPriorityToString(static_cast<TransmitPriority>(transmitPriority)) << " " << flags;
        return oss.str();
    }
 
    std::uint8_t transmitPriority : 2,  
        communication : 1,   
        readFromBus : 1,     
        writeFromBus : 1,    
        readOnInit : 1,      
        transmitToBus : 1,   
        updateResponse : 1;  
};
 
struct BAOSLIB_EXPORT DatapointStatus
{
    DatapointStatus()
        : transmitStatus{0},
          readRequest{0},
          updated{0},
          valid{0},
          reserved_1{0},
          reserved_2{0},
          reserved_3{0}
    {
    }
 
    DatapointStatus(std::uint8_t&& value)
    {
        reserved_3     = value >> 7;
        reserved_2     = value >> 6 & 0x01;
        reserved_1     = value >> 5 & 0x01;
        valid          = value >> 4 & 0x01;
        updated        = value >> 3 & 0x01;
        readRequest    = value >> 2 & 0x01;
        transmitStatus = value & 0x03;
    }
 
    DatapointStatus& operator=(std::uint8_t& value)
    {
        reserved_3     = value >> 7;
        reserved_2     = value >> 6 & 0x01;
        reserved_1     = value >> 5 & 0x01;
        valid          = value >> 4 & 0x01;
        updated        = value >> 3 & 0x01;
        readRequest    = value >> 2 & 0x01;
        transmitStatus = value & 0x03;
        return *this;
    }
 
    operator std::uint8_t() const
    {
        std::uint8_t value{0};
        value = reserved_3 << 7 | reserved_2 << 6 | reserved_1 << 5 | valid << 4 | updated << 3 | readRequest << 2 |
                transmitStatus;
        return value;
    }
 
    std::string toString() const
    {
        std::ostringstream oss;
        valid ? oss << "V" : oss << "_";
        updated ? oss << "U" : oss << "_";
        readRequest ? oss << "R" : oss << "W";
        oss << " ";
        oss << transmissionStatusToString(static_cast<TransmissionStatus>(transmitStatus));
        return oss.str();
    }
 
 
    std::uint8_t transmitStatus : 2,  
        readRequest : 1,              
        updated : 1,  
        valid : 1,    
        reserved_1 : 1,  
        reserved_2 : 1,  
        reserved_3 : 1;  
};
 
struct BAOSLIB_EXPORT DatapointValueState
{
    DatapointValue value;    
    DatapointStatus status;  
};
 
using DatapointValueStates = std::map<std::uint16_t, DatapointValueState>;  
 
struct BAOSLIB_EXPORT DatapointChangeValue
{
    DatapointValue value;         
    DatapointSetCommand command;  
};
 
using DatapointChangeValues = std::map<std::uint16_t, DatapointChangeValue>;  
 
struct BAOSLIB_EXPORT DatapointDescription
{
    DatapointSize size;          
    DatapointConfigFlags flags;  
    DPT dpt;  
};
 
using DatapointDescriptions =
    std::map<std::uint16_t, DatapointDescription>;  
using DatapointDescriptionString = std::string;     
using DatapointDescriptionStrings =
    std::map<std::uint16_t, DatapointDescriptionString>;  
 
using ParameterBytes = std::vector<std::uint8_t>;  
 
enum class TimeSinceResetUnit
{
    milliseconds,
    seconds,
    minutes,
    hours
};
 
BAOSLIB_EXPORT std::string timeSinceResetUnitToString(
    TimeSinceResetUnit unit);  
 
enum class IpAssigmentMethod
{
    manual = 0x1,  
    bootp  = 0x2,  
    dhcp   = 0x4,  
    autoIp = 0x8   
};
 
 
constexpr std::uint8_t BAOS_MAIN_SERVICE = 0xF0;  
constexpr std::size_t POS_MAIN_SERVICE   = 0;     
constexpr std::size_t POS_SUB_SERVICE    = 1;     
constexpr std::size_t POS_START =
    2;  
constexpr std::size_t POS_NUMBER_OF_ELEMENTS = 4;  
constexpr std::size_t POS_ERRORCODE          = 6;  
constexpr std::size_t POS_PAYLOAD_BEGIN      = 6;  
 
}  // namespace wz::baos::protocol
 
#endif