zcl.h

#ifndef DECONZ_ZCL_H
#define DECONZ_ZCL_H
 
/*
 * Copyright (c) 2012-2023 dresden elektronik ingenieurtechnik gmbh.
 * All rights reserved.
 *
 * The software in this package is published under the terms of the BSD
 * style license a copy of which has been included with this distribution in
 * the LICENSE.txt file.
 *
 */
 
#include <vector>
#include <QDataStream>
#include <QVariant>
#include <QStringList>
#include <deconz/types.h>
#include "deconz/declspec.h"
 
//#define ZCL_LOAD_DBG
//#define ZCL_LOAD_DBG_COMMAND
 
#define ZCL_ENUM 0x00
 
namespace deCONZ
{
class ApsDataIndication;
}
 
namespace deCONZ
{
    enum ZclDataTypeId : unsigned char
    {
        ZclNoData    = 0x00,
        Zcl8BitData  = 0x08,
        Zcl16BitData = 0x09,
        Zcl24BitData = 0x0a,
        Zcl32BitData = 0x0b,
        Zcl40BitData = 0x0c,
        Zcl48BitData = 0x0d,
        Zcl56BitData = 0x0e,
        Zcl64BitData = 0x0f,
        ZclBoolean   = 0x10,
        Zcl8BitBitMap   = 0x18,
        Zcl16BitBitMap  = 0x19,
        Zcl24BitBitMap  = 0x1a,
        Zcl32BitBitMap  = 0x1b,
        Zcl40BitBitMap  = 0x1c,
        Zcl48BitBitMap  = 0x1d,
        Zcl56BitBitMap  = 0x1e,
        Zcl64BitBitMap  = 0x1f,
        Zcl8BitUint  = 0x20,
        Zcl16BitUint = 0x21,
        Zcl24BitUint = 0x22,
        Zcl32BitUint = 0x23,
        Zcl40BitUint = 0x24,
        Zcl48BitUint = 0x25,
        Zcl56BitUint = 0x26,
        Zcl64BitUint = 0x27,
        Zcl8BitInt  = 0x28,
        Zcl16BitInt = 0x29,
        Zcl24BitInt = 0x2a,
        Zcl32BitInt = 0x2b,
        Zcl40BitInt = 0x2c,
        Zcl48BitInt = 0x2d,
        Zcl56BitInt = 0x2e,
        Zcl64BitInt = 0x2f,
        Zcl8BitEnum  = 0x30,
        Zcl16BitEnum = 0x31,
        ZclSemiFloat = 0x38,
        ZclSingleFloat = 0x39,
        ZclDoubleFloat = 0x3a,
        ZclOctedString = 0x41,
        ZclCharacterString     = 0x42,
        ZclLongOctedString     = 0x43,
        ZclLongCharacterString = 0x44,
        ZclArray = 0x48,
        ZclStruct = 0x4c,
        ZclTimeOfDay  = 0xe0,
        ZclDate       = 0xe1,
        ZclUtcTime    = 0xe2,
        ZclClusterId         = 0xe8,
        ZclAttributeId       = 0xe9,
        ZclBACNetOId         = 0xea,
        ZclIeeeAddress       = 0xf0,
        Zcl128BitSecurityKey = 0xf1
    };
 
    enum ZclGeneralCommandId : unsigned char
    {
        ZclReadAttributesId               = 0x00,
        ZclReadAttributesResponseId       = 0x01,
        ZclWriteAttributesId              = 0x02,
        ZclWriteAttributesUndividedId     = 0x03,
        ZclWriteAttributesResponseId      = 0x04,
        ZclWriteAttributesNoResponseId    = 0x05,
        ZclConfigureReportingId           = 0x06,
        ZclConfigureReportingResponseId   = 0x07,
        ZclReadReportingConfigId          = 0x08,
        ZclReadReportingConfigResponseId  = 0x09,
        ZclReportAttributesId             = 0x0a,
        ZclDefaultResponseId              = 0x0b,
        ZclDiscoverAttributesId           = 0x0c,
        ZclDiscoverAttributesResponseId   = 0x0d,
        ZclReadAttributesStructuredId     = 0x0e,
        ZclWriteAttributesStructuredId    = 0x0f,
        ZclWriteAttributesStructuredResponseId  = 0x10
    };
 
    enum ZclFrameControl : unsigned char
    {
        ZclFCProfileCommand          = 0x00,
        ZclFCClusterCommand          = 0x01,
        ZclFCManufacturerSpecific    = 0x04,
        ZclFCDirectionServerToClient = 0x08,
        ZclFCDirectionClientToServer = 0x00,
        ZclFCEnableDefaultResponse   = 0x00,
        ZclFCDisableDefaultResponse  = 0x10
    };
 
    class DECONZ_DLLSPEC ZclDataTypeId_t
    {
        ZclDataTypeId m_id = ZclNoData;
 
    public:
        constexpr ZclDataTypeId_t() {}
        constexpr explicit ZclDataTypeId_t(quint8 id) : m_id(static_cast<ZclDataTypeId>(id)) { }
        constexpr ZclDataTypeId_t(ZclDataTypeId id) : m_id(id) { }
 
        template <class T>
        ZclDataTypeId_t(T) = delete;
 
        constexpr bool isValid() const { return m_id > ZclNoData && m_id <= Zcl128BitSecurityKey; }
 
        explicit operator quint8() const { return m_id; }
        explicit operator ZclDataTypeId() const { return m_id; }
 
        constexpr bool operator==(ZclDataTypeId_t other) const { return other.m_id == m_id; }
        constexpr bool operator!=(ZclDataTypeId_t other) const { return other.m_id != m_id; }
        constexpr bool operator==(ZclDataTypeId other) const { return other == m_id; }
        constexpr bool operator!=(ZclDataTypeId other) const { return other != m_id; }
    };
 
    DECONZ_DLLSPEC QDataStream & operator<<(QDataStream &ds, ZclDataTypeId_t id);
    DECONZ_DLLSPEC QDataStream & operator>>(QDataStream &ds, ZclDataTypeId_t &id);
 
    inline namespace literals {
        constexpr ZclDataTypeId_t DECONZ_DLLSPEC operator ""_dtid(unsigned long long id)
        {
            return ZclDataTypeId_t(static_cast<quint8>(id));
        }
    }
 
    class ZclDataTypePrivate;
 
    class DECONZ_DLLSPEC ZclDataType
    {
    public:
        ZclDataType();
        ZclDataType(const ZclDataType &other);
        ZclDataType &operator=(ZclDataType &other);
        ZclDataType(uint8_t id, const QString &name, const QString &shortname, int length, char analogDiscrete);
        ~ZclDataType();
        uint8_t id() const;
        ZclDataTypeId_t id_t() const;
        const QString &name() const;
        const QString &shortname() const;
        int length() const;
        bool isValid() const;
        bool isAnalog() const;
        bool isDiscrete() const;
 
    private:
        ZclDataTypePrivate *d_ptr;
        Q_DECLARE_PRIVATE(ZclDataType)
    };
 
    class DECONZ_DLLSPEC ZclCommandId_t
    {
        quint8 m_id = 0;
 
    public:
        constexpr ZclCommandId_t() {}
        constexpr explicit ZclCommandId_t(quint8 id) : m_id(id) { }
        constexpr explicit operator quint8() const { return m_id; }
 
        template <class T>
        ZclCommandId_t(T) = delete;
 
        constexpr bool operator==(ZclCommandId_t other) const { return other.m_id == m_id; }
        constexpr bool operator!=(ZclCommandId_t other) const { return other.m_id != m_id; }
    };
 
    DECONZ_DLLSPEC QDataStream & operator<<(QDataStream &ds, ZclCommandId_t id);
    DECONZ_DLLSPEC QDataStream & operator>>(QDataStream &ds, ZclCommandId_t &id);
 
    inline namespace literals {
        constexpr ZclCommandId_t DECONZ_DLLSPEC operator ""_cmdid(unsigned long long id)
        {
            return ZclCommandId_t(static_cast<quint8>(id));
        }
    }
 
    enum ZclAccess
    {
        ZclRead = 0x1,
        ZclWrite = 0x2,
        ZclReadWrite = 0x3
    };
 
    class DECONZ_DLLSPEC ZclAttributeId_t
    {
        quint16 m_id = 0;
 
    public:
        constexpr ZclAttributeId_t() {}
        constexpr explicit ZclAttributeId_t(quint16 id) : m_id(id) { }
        constexpr explicit operator quint16() const { return m_id; }
 
        template <class T>
        ZclAttributeId_t(T) = delete;
 
        constexpr bool operator==(ZclAttributeId_t other) const { return other.m_id == m_id; }
        constexpr bool operator!=(ZclAttributeId_t other) const { return other.m_id != m_id; }
    };
 
    DECONZ_DLLSPEC QDataStream &operator<<(QDataStream &ds, ZclAttributeId_t id);
    DECONZ_DLLSPEC QDataStream & operator>>(QDataStream &ds, ZclAttributeId_t &id);
 
    inline namespace literals {
        constexpr ZclAttributeId_t DECONZ_DLLSPEC operator ""_atid(unsigned long long id)
        {
            return ZclAttributeId_t(static_cast<quint16>(id));
        }
    }
 
    class DECONZ_DLLSPEC ManufacturerCode_t
    {
        quint16 m_id = 0;
 
    public:
        constexpr ManufacturerCode_t() {}
        constexpr explicit ManufacturerCode_t(quint16 id) : m_id(id) { }
        constexpr explicit operator quint16() const { return m_id; }
 
        template <class T>
        ManufacturerCode_t(T) = delete;
 
        constexpr bool operator==(ManufacturerCode_t other) const { return other.m_id == m_id; }
        constexpr bool operator!=(ManufacturerCode_t other) const { return other.m_id != m_id; }
    };
 
    DECONZ_DLLSPEC QDataStream & operator<<(QDataStream &ds, ManufacturerCode_t mfcode);
    DECONZ_DLLSPEC QDataStream & operator>>(QDataStream &ds, ManufacturerCode_t &mfcode);
 
    inline namespace literals {
        constexpr ManufacturerCode_t DECONZ_DLLSPEC operator ""_mfcode(unsigned long long mfcode)
        {
            return ManufacturerCode_t(static_cast<quint16>(mfcode));
        }
    }
 
    class ZclAttributePrivate;
 
    class DECONZ_DLLSPEC ZclAttribute
    {
    public:
        enum FormatHint
        {
            DefaultFormat = 0, 
            Prefix, 
            SliderFormat 
        };
        ZclAttribute();
        ZclAttribute(uint16_t id, uint8_t type, const QString &name, ZclAccess access, bool required);
        ZclAttribute(ZclAttributeId_t id, ZclDataTypeId_t type, const QString &name, ZclAccess access, bool required);
        ZclAttribute(const ZclAttribute &other);
        ZclAttribute(ZclAttribute &&other) noexcept;
        ZclAttribute &operator=(const ZclAttribute &other);
        ZclAttribute &operator=(ZclAttribute &&other) noexcept;
        ~ZclAttribute();
        uint16_t id() const;
        ZclAttributeId_t id_t() const;
        const QString &description() const;
        void setDescription(const QString &description);
        uint8_t dataType() const;
        ZclDataTypeId_t dataType_t() const;
        void setDataType(uint8_t type);
        const QString &name() const;
        /* \cond INTERNAL_SYMBOLS */
        uint8_t subType() const;
        void setSubType(uint8_t subType);
        /* \endcond */
        const NumericUnion &numericValue() const;
        void setNumericValue(const NumericUnion &value);
 
        QString valueNameAt(int bitOrEnum) const;
        QStringList valuesNames() const;
        const std::vector<int> &valueNamePositions() const;
        void setValue(bool value);
        void setValue(quint64 value);
        void setValue(qint64 value);
        void setValue(const QVariant &value);
        /* \cond INTERNAL_SYMBOLS */
        void setLastRead(time_t time);
        uint16_t listSizeAttribute() const;
        void setListSizeAttribute(uint16_t id);
        bool isList() const;
        int listSize() const;
        void setListSize(int listSize);
        /* \endcond */
        int64_t lastRead() const;
        bool isReadonly() const;
        bool isMandatory() const;
        bool isAvailable() const;
        void setAvailable(bool available);
        uint8_t numericBase() const;
        void setNumericBase(uint8_t base);
        uint enumerator() const;
        void setEnumerator(uint value);
        void setBit(uint bit, bool one);
        bool bit(int bit) const;
        int bitCount() const;
        quint64 bitmap() const;
        void setBitmap(quint64 bmp);
        int enumCount() const;
        quint8 enumerationId() const;
        void setEnumerationId(quint8 id);
        bool writeToStream(QDataStream &stream) const;
        bool readFromStream(QDataStream &stream);
        QString toString(FormatHint formatHint = DefaultFormat) const;
        QString toString(const deCONZ::ZclDataType &dataType, FormatHint formatHint = DefaultFormat) const;
        const QVariant &toVariant() const;
        uint16_t minReportInterval() const;
        void setMinReportInterval(uint16_t interval);
        uint16_t maxReportInterval() const;
        void setMaxReportInterval(uint16_t interval);
        uint16_t reportTimeoutPeriod() const;
        void setReportTimeoutPeriod(uint16_t period);
        const NumericUnion &reportableChange() const;
        void setReportableChange(const NumericUnion &reportableChange);
        bool writeReportableChangeToStream(QDataStream &stream) const;
        bool readReportableChangeFromStream(QDataStream &stream);
        void setFormatHint(FormatHint formatHint);
        FormatHint formatHint() const;
        int rangeMin() const;
        void setRangeMin(int rangeMin);
        int rangeMax() const;
        void setRangeMax(int rangeMax);
        quint16 manufacturerCode() const;
        ManufacturerCode_t manufacturerCode_t() const;
        void setManufacturerCode(quint16 mfcode);
        void setManufacturerCode(ManufacturerCode_t mfcode);
        bool isManufacturerSpecific() const;
 
        /* \cond INTERNAL_SYMBOLS */
        void setAttributeSet(quint16 attrSetId, quint16 mfcode);
        quint16 attributeSet() const;
        quint16 attributeSetManufacturerCode() const;
        /* \endcond */
 
    private:
        friend class ZclDataBase;
        ZclAttributePrivate *d_ptr = nullptr;
        Q_DECLARE_PRIVATE(ZclAttribute)
    };
 
    class ZclAttributeSetPrivate;
 
    class DECONZ_DLLSPEC ZclAttributeSet
    {
    public:
        ZclAttributeSet();
        ZclAttributeSet(const ZclAttributeSet &other);
        ZclAttributeSet &operator= (const ZclAttributeSet &other);
        ZclAttributeSet(uint16_t id, const QString &description);
        ~ZclAttributeSet();
        uint16_t id() const;
        const QString &description() const;
        const std::vector<int> &attributes() const;
        void addAttribute(int idx);
        quint16 manufacturerCode() const;
        void setManufacturerCode(quint16 mfcode);
 
    private:
        ZclAttributeSetPrivate *d_ptr = nullptr;
        Q_DECLARE_PRIVATE(ZclAttributeSet)
    };
 
    enum ZclClusterSide
    {
        ClientCluster = 0,
        ServerCluster = 1
    };
 
    class ZclFramePrivate;
 
    class DECONZ_DLLSPEC ZclFrame
    {
    public:
        ZclFrame();
        ZclFrame(const ZclFrame &other);
        ZclFrame &operator=(const ZclFrame &other);
        virtual ~ZclFrame();
        uint8_t frameControl() const;
        void setFrameControl(uint8_t frameControl);
        uint16_t manufacturerCode() const;
        ManufacturerCode_t manufacturerCode_t() const;
        void setManufacturerCode(uint16_t code);
        void setManufacturerCode(ManufacturerCode_t code);
        uint8_t sequenceNumber() const;
        void setSequenceNumber(uint8_t seqNumber);
        uint8_t commandId() const;
        ZclCommandId_t commandId_t() const;
        void setCommandId(uint8_t commandId);
        void setCommandId(ZclCommandId_t commandId);
        unsigned char payloadAt(int index) const;
        const QByteArray &payload() const;
        QByteArray &payload();
        void setPayload(const QByteArray &payload);
        void writeToStream(QDataStream &stream);
        void readFromStream(QDataStream &stream);
        bool isClusterCommand() const;
        bool isProfileWideCommand() const;
        bool isDefaultResponse() const;
        bool isValid() const;
        uint8_t defaultResponseCommandId() const;
        ZclCommandId_t defaultResponseCommandId_t() const;
        ZclStatus defaultResponseStatus() const;
        void reset();
 
    private:
        ZclFramePrivate *d_ptr = nullptr;
        Q_DECLARE_PRIVATE(ZclFrame)
    };
 
    class ZclCommandPrivate;
 
    class DECONZ_DLLSPEC ZclCommand
    {
    public:
        ZclCommand();
        ZclCommand(const ZclCommand &other);
        ZclCommand(ZclCommand &&other) noexcept;
        ZclCommand&operator=(const ZclCommand &other);
        ZclCommand&operator=(ZclCommand &&other) noexcept;
        ZclCommand(uint8_t id, const QString &name, bool required, bool recv, const QString &description = QString());
        ~ZclCommand();
        uint8_t id() const;
        ZclCommandId_t id_t() const;
        void setId(uint8_t id);
        uint16_t manufacturerId() const;
        void setManufacturerId(uint16_t id);
        bool isValid() const;
        uint8_t responseId() const;
        void setResponseId(uint8_t id);
        bool hasResponse() const;
        bool directionReceived() const;
        bool directionSend() const;
        const QString &name() const;
        const QString &description() const;
        void setDescription(const QString &description);
        bool isProfileWide() const;
        void setIsProfileWide(bool profileWide);
        bool disableDefaultResponse() const;
        void setDisableDefaultResponse(bool disable);
        const std::vector<ZclAttribute> &parameters() const;
        std::vector<ZclAttribute> &parameters();
        bool readFromStream(QDataStream &stream);
        bool writeToStream(QDataStream &stream) const;
 
    private:
        ZclCommandPrivate *d_ptr = nullptr;
        Q_DECLARE_PRIVATE(ZclCommand)
    };
 
    class DECONZ_DLLSPEC ZclClusterId_t
    {
        quint16 m_id = 0;
 
    public:
        constexpr ZclClusterId_t() {}
        constexpr explicit ZclClusterId_t(quint16 id) : m_id(id) { }
        constexpr explicit operator quint16() const { return m_id; }
 
        template <class T>
        ZclClusterId_t(T) = delete;
 
        constexpr bool operator==(ZclClusterId_t other) const { return other.m_id == m_id; }
        constexpr bool operator!=(ZclClusterId_t other) const { return other.m_id != m_id; }
    };
 
    DECONZ_DLLSPEC QDataStream &operator<<(QDataStream &ds, ZclClusterId_t id);
    DECONZ_DLLSPEC QDataStream &operator>>(QDataStream &ds, ZclClusterId_t &id);
 
    inline namespace literals {
        constexpr ZclClusterId_t DECONZ_DLLSPEC operator ""_clid(unsigned long long id)
        {
            return ZclClusterId_t(static_cast<quint16>(id));
        }
    }
 
    class ZclClusterPrivate;
 
    class DECONZ_DLLSPEC ZclCluster
    {
    public:
        ZclCluster();
        ZclCluster(const ZclCluster &other);
        ZclCluster(uint16_t id, const QString &name, const QString &description = QString());
        ZclCluster &operator=(const ZclCluster &other);
        ~ZclCluster();
        uint16_t id() const;
        ZclClusterId_t id_t() const;
        void setId(uint16_t id);
        uint16_t oppositeId() const;
        void setOppositeId(uint16_t id);
        uint16_t manufacturerCode() const;
        ManufacturerCode_t manufacturerCode_t() const;
        void setManufacturerCode(uint16_t manufacturerCode);
        void setManufacturerCode(ManufacturerCode_t manufacturerCode);
        const QString &name() const;
        const QString &description() const;
        void setDescription(const QString &description);
        bool isValid() const;
        bool isZcl() const;
        void setIsZcl(bool isZcl);
        bool isServer() const;
        bool isClient() const;
        void setIsServer(bool isServer);
        std::vector<ZclAttribute> &attributes();
        const std::vector<ZclAttribute> &attributes() const;
        std::vector<ZclAttributeSet> &attributeSets();
        const std::vector<ZclAttributeSet> &attributeSets() const;
        bool readCommand(const ZclFrame &zclFrame);
        bool readCommand(const ApsDataIndication &ind);
        std::vector<ZclCommand> &commands();
        const std::vector<ZclCommand> &commands() const;
 
    private:
        ZclClusterPrivate *d_ptr = nullptr;
        Q_DECLARE_PRIVATE(ZclCluster)
    };
 
 
    class ZclMemoryPrivate;
 
    class DECONZ_DLLSPEC ZclMemory
    {
    public:
        ZclMemory();
        ~ZclMemory();
 
        /* \cond INTERNAL_SYMBOLS */
        ZclMemoryPrivate *d = nullptr; // opaque pointer only used internally
        /* \endcond */
    };
 
    DECONZ_DLLSPEC ZclCluster ZCL_InCluster(uint16_t profileId, uint16_t clusterId, uint16_t mfcode);
    DECONZ_DLLSPEC ZclCluster ZCL_OutCluster(uint16_t profileId, uint16_t clusterId, uint16_t mfcode);
    DECONZ_DLLSPEC ZclDataType ZCL_DataType(uint8_t id);
    DECONZ_DLLSPEC ZclDataType ZCL_DataType(const QString &name);
 
} // namespace deCONZ
 
#endif // DECONZ_ZCL_H