refactor device object, add more const to functions

src/knx/address_table_object.cpp

@@ -44,7 +44,7 @@ uint16_t AddressTableObject::getTsap(uint16_t addr)
 
 #pragma region SaveRestore
 
-uint8_t* AddressTableObject::restore(uint8_t* buffer)
+const uint8_t* AddressTableObject::restore(const uint8_t* buffer)
 {
     buffer = TableObject::restore(buffer);
 

src/knx/address_table_object.h

@@ -18,7 +18,7 @@ class AddressTableObject : public TableObject
      * @param memory This parameter is only passed to the custructor of TableObject an not used by this class.
      */
     AddressTableObject(Memory& memory);
-    uint8_t* restore(uint8_t* buffer) override;
+    const uint8_t* restore(const uint8_t* buffer) override;
 
     /**
      * returns the number of group addresses of the object.

src/knx/application_layer.cpp

@@ -154,7 +154,7 @@ void ApplicationLayer::dataBroadcastConfirm(AckType ack, HopCountType hopType, P
 
 void ApplicationLayer::dataSystemBroadcastIndication(HopCountType hopType, Priority priority, uint16_t source, APDU& apdu)
 {
-    uint8_t* data = apdu.data();
+    const uint8_t* data = apdu.data();
     switch (apdu.type())
     {
         // TODO: testInfo could be of any length
@@ -174,14 +174,14 @@ void ApplicationLayer::dataSystemBroadcastIndication(HopCountType hopType, Prior
         }
         case DomainAddressSerialNumberWrite:
         {
-            uint8_t* knxSerialNumber = &data[1];
+            const uint8_t* knxSerialNumber = &data[1];
-            uint8_t* domainAddress = &data[7];
+            const uint8_t* domainAddress = &data[7];
             _bau.domainAddressSerialNumberWriteIndication(priority, hopType, domainAddress, knxSerialNumber);
             break;
         }
         case DomainAddressSerialNumberRead:
         {
-            uint8_t* knxSerialNumber = &data[1];
+            const uint8_t* knxSerialNumber = &data[1];
             _bau.domainAddressSerialNumberReadIndication(priority, hopType, knxSerialNumber);
             break;
         }

src/knx/association_table_object.cpp

@@ -39,7 +39,7 @@ uint16_t AssociationTableObject::getASAP(uint16_t idx)
     return ntohs(_tableData[2 * idx + 2]);
 }
 
-uint8_t* AssociationTableObject::restore(uint8_t* buffer)
+const uint8_t* AssociationTableObject::restore(const uint8_t* buffer)
 {
     buffer = TableObject::restore(buffer);
     _tableData = (uint16_t*)data();

src/knx/association_table_object.h

@@ -7,7 +7,7 @@ class AssociationTableObject : public TableObject
   public:
     AssociationTableObject(Memory& memory);
 
-    uint8_t* restore(uint8_t* buffer) override;
+    const uint8_t* restore(const uint8_t* buffer) override;
 
     int32_t translateAsap(uint16_t asap);
     int32_t nextAsap(uint16_t tsap, uint16_t& startIdx);

src/knx/bau.cpp

@@ -247,12 +247,12 @@ void BusAccessUnit::systemNetworkParameterReadIndication(Priority priority, HopC
 {
 }
 
-void BusAccessUnit::domainAddressSerialNumberWriteIndication(Priority priority, HopCountType hopType, uint8_t* rfDoA,
+void BusAccessUnit::domainAddressSerialNumberWriteIndication(Priority priority, HopCountType hopType, const uint8_t* rfDoA,
-                                                             uint8_t* knxSerialNumber)
+                                                             const uint8_t* knxSerialNumber)
 {
 }
 
-void BusAccessUnit::domainAddressSerialNumberReadIndication(Priority priority, HopCountType hopType, uint8_t* knxSerialNumber)
+void BusAccessUnit::domainAddressSerialNumberReadIndication(Priority priority, HopCountType hopType, const uint8_t* knxSerialNumber)
 {
 }
 

src/knx/bau.h

@@ -114,10 +114,10 @@ class BusAccessUnit
     virtual void systemNetworkParameterReadIndication(Priority priority, HopCountType hopType, uint16_t objectType,
                                                       uint16_t propertyId, uint8_t* testInfo, uint16_t testInfoLength);
 
-    virtual void domainAddressSerialNumberWriteIndication(Priority priority, HopCountType hopType, uint8_t* rfDoA,
+    virtual void domainAddressSerialNumberWriteIndication(Priority priority, HopCountType hopType, const uint8_t* rfDoA,
-                                                          uint8_t* knxSerialNumber);
+                                                          const uint8_t* knxSerialNumber);
 
-    virtual void domainAddressSerialNumberReadIndication(Priority priority, HopCountType hopType, uint8_t* knxSerialNumber);
+    virtual void domainAddressSerialNumberReadIndication(Priority priority, HopCountType hopType, const uint8_t* knxSerialNumber);
 
     virtual void propertyValueRead(ObjectType objectType, uint8_t objectInstance, uint8_t propertyId,
                                    uint8_t& numberOfElements, uint16_t startIndex,

src/knx/bau07B0.cpp

@@ -27,7 +27,15 @@ Bau07B0::Bau07B0(Platform& platform)
     // Set which interface objects are available in the device object
     // This differs from BAU to BAU with different medium types.
     // See PID_IO_LIST
-    _deviceObj.ifObj(_ifObjs);
+    Property* prop = _deviceObj.property(PID_IO_LIST);
+    prop->write(1, OT_DEVICE);
+    prop->write(2, OT_ADDR_TABLE);
+    prop->write(3, OT_ASSOC_TABLE);
+    prop->write(4, OT_GRP_OBJ_TABLE);
+    prop->write(5, OT_APPLICATION_PROG);
+#ifdef USE_CEMI_SERVER
+    prop->write(6, OT_CEMI_SERVER);
+#endif
 }
 
 InterfaceObject* Bau07B0::getInterfaceObject(uint8_t idx)

src/knx/bau07B0.h

@@ -24,12 +24,6 @@ class Bau07B0 : public BauSystemB
 #ifdef USE_CEMI_SERVER
     CemiServer _cemiServer;
     CemiServerObject _cemiServerObject;
-
-    const uint32_t _ifObjs[7] = { 6, // length
-                                  OT_DEVICE, OT_ADDR_TABLE, OT_ASSOC_TABLE, OT_GRP_OBJ_TABLE, OT_APPLICATION_PROG, OT_CEMI_SERVER};
-#else    
-    const uint32_t _ifObjs[6] = { 5, // length
-                                  OT_DEVICE, OT_ADDR_TABLE, OT_ASSOC_TABLE, OT_GRP_OBJ_TABLE, OT_APPLICATION_PROG};
 #endif                                  
 };
 #endif

src/knx/bau27B0.cpp

@@ -34,7 +34,16 @@ Bau27B0::Bau27B0(Platform& platform)
     // Set which interface objects are available in the device object
     // This differs from BAU to BAU with different medium types.
     // See PID_IO_LIST
-    _deviceObj.ifObj(_ifObjs);
+    Property* prop = _deviceObj.property(PID_IO_LIST);
+    prop->write(1, OT_DEVICE);
+    prop->write(2, OT_ADDR_TABLE);
+    prop->write(3, OT_ASSOC_TABLE);
+    prop->write(4, OT_GRP_OBJ_TABLE);
+    prop->write(5, OT_APPLICATION_PROG);
+    prop->write(6, OT_RF_MEDIUM);
+#ifdef USE_CEMI_SERVER
+    prop->write(7, OT_CEMI_SERVER);
+#endif
 }
 
 // see KNX AN160 p.74 for mask 27B0

src/knx/bau27B0.h

@@ -26,11 +26,6 @@ class Bau27B0 : public BauSystemB
 #ifdef USE_CEMI_SERVER
     CemiServer _cemiServer;
     CemiServerObject _cemiServerObject;
-    const uint32_t _ifObjs[8] = { 7, // length
-                                  OT_DEVICE, OT_ADDR_TABLE, OT_ASSOC_TABLE, OT_GRP_OBJ_TABLE, OT_APPLICATION_PROG, OT_RF_MEDIUM, OT_CEMI_SERVER};
-#else    
-    const uint32_t _ifObjs[7] = { 6, // length
-                                  OT_DEVICE, OT_ADDR_TABLE, OT_ASSOC_TABLE, OT_GRP_OBJ_TABLE, OT_APPLICATION_PROG, OT_RF_MEDIUM};
 #endif                                  
 
     void domainAddressSerialNumberWriteIndication(Priority priority, HopCountType hopType, uint8_t* rfDoA,

src/knx/bau57B0.cpp

@@ -31,7 +31,16 @@ Bau57B0::Bau57B0(Platform& platform)
     // Set which interface objects are available in the device object
     // This differs from BAU to BAU with different medium types.
     // See PID_IO_LIST
-    _deviceObj.ifObj(_ifObjs);
+    Property* prop = _deviceObj.property(PID_IO_LIST);
+    prop->write(1, OT_DEVICE);
+    prop->write(2, OT_ADDR_TABLE);
+    prop->write(3, OT_ASSOC_TABLE);
+    prop->write(4, OT_GRP_OBJ_TABLE);
+    prop->write(5, OT_APPLICATION_PROG);
+    prop->write(6, OT_IP_PARAMETER);
+#ifdef USE_CEMI_SERVER
+    prop->write(7, OT_CEMI_SERVER);
+#endif
 }
 
 InterfaceObject* Bau57B0::getInterfaceObject(uint8_t idx)

src/knx/bau57B0.h

@@ -23,12 +23,6 @@ class Bau57B0 : public BauSystemB
 #ifdef USE_CEMI_SERVER
     CemiServer _cemiServer;
     CemiServerObject _cemiServerObject;
-
-    const uint32_t _ifObjs[8] = { 8, // length
-                                 OT_DEVICE, OT_ADDR_TABLE, OT_ASSOC_TABLE, OT_GRP_OBJ_TABLE, OT_APPLICATION_PROG, OT_IP_PARAMETER, OT_CEMI_SERVER};
-#else
-    const uint32_t _ifObjs[7] = {7, // length
-                                 OT_DEVICE, OT_ADDR_TABLE, OT_ASSOC_TABLE, OT_GRP_OBJ_TABLE, OT_APPLICATION_PROG, OT_IP_PARAMETER};
 #endif
 };
 #endif

src/knx/bits.cpp

@@ -1,6 +1,6 @@
 #include "bits.h"
 
-uint8_t* popByte(uint8_t& b, uint8_t* data)
+const uint8_t* popByte(uint8_t& b, const uint8_t* data)
 {
     b = *data;
     data += 1;
@@ -18,21 +18,21 @@ void printHex(const char* suffix, const uint8_t *data, size_t length)
     println();
 }
 
-uint8_t* popWord(uint16_t& w, uint8_t* data)
+const uint8_t* popWord(uint16_t& w, const uint8_t* data)
 {
     w = getWord(data);
     data += 2;
     return data;
 }
 
-uint8_t* popInt(uint32_t& i, uint8_t* data)
+const uint8_t* popInt(uint32_t& i, const uint8_t* data)
 {
     i = getInt(data);
     data += 4;
     return data;
 }
 
-uint8_t* popByteArray(uint8_t* dst, uint32_t size, uint8_t* data)
+const uint8_t* popByteArray(uint8_t* dst, uint32_t size, const uint8_t* data)
 {
     for (uint32_t i = 0; i < size; i++)
         dst[i] = data[i];
@@ -75,12 +75,12 @@ uint8_t* pushByteArray(const uint8_t* src, uint32_t size, uint8_t* data)
     return data;
 }
 
-uint16_t getWord(uint8_t* data)
+uint16_t getWord(const uint8_t* data)
 {
     return (data[0] << 8) + data[1];
 }
 
-uint32_t getInt(uint8_t * data)
+uint32_t getInt(const uint8_t * data)
 {
     return (data[0] << 24) + (data[1] << 16) + (data[2] << 8) + data[3];
 }

src/knx/bits.h

@@ -74,14 +74,14 @@ void println(void);
 
 void printHex(const char* suffix, const uint8_t *data, size_t length);
 
-uint8_t* popByte(uint8_t& b, uint8_t* data);
+const uint8_t* popByte(uint8_t& b, const uint8_t* data);
-uint8_t* popWord(uint16_t& w, uint8_t* data);
+const uint8_t* popWord(uint16_t& w, const uint8_t* data);
-uint8_t* popInt(uint32_t& i, uint8_t* data);
+const uint8_t* popInt(uint32_t& i, const uint8_t* data);
-uint8_t* popByteArray(uint8_t* dst, uint32_t size, uint8_t* data);
+const uint8_t* popByteArray(uint8_t* dst, uint32_t size, const uint8_t* data);
 uint8_t* pushByte(uint8_t b, uint8_t* data);
 uint8_t* pushWord(uint16_t w, uint8_t* data);
 uint8_t* pushInt(uint32_t i, uint8_t* data);
 uint8_t* pushByteArray(const uint8_t* src, uint32_t size, uint8_t* data);
-uint16_t getWord(uint8_t* data);
+uint16_t getWord(const uint8_t* data);
-uint32_t getInt(uint8_t* data);
+uint32_t getInt(const uint8_t* data);
 void printHex(const char* suffix, const uint8_t *data, size_t length);

src/knx/callback_property.h

@@ -9,7 +9,7 @@ template <class T> class CallbackProperty : public Property
   public:
     CallbackProperty(T* io, PropertyID id, bool writeEnable, PropertyDataType type, uint16_t maxElements,
                      uint8_t access, uint8_t (*readCallback)(T*, uint16_t, uint8_t, uint8_t*),
-                     uint8_t (*writeCallback)(T*, uint16_t, uint8_t, uint8_t*))
+                     uint8_t (*writeCallback)(T*, uint16_t, uint8_t, const uint8_t*))
         : Property(id, writeEnable, type, maxElements, access),
           _interfaceObject(io), _readCallback(readCallback), _writeCallback(writeCallback)
     {}
@@ -25,7 +25,7 @@ template <class T> class CallbackProperty : public Property
 
         return _readCallback(_interfaceObject, start, count, data);
     }
-    virtual uint8_t write(uint16_t start, uint8_t count, uint8_t* data) override
+    virtual uint8_t write(uint16_t start, uint8_t count, const uint8_t* data) override
     {
         if (count == 0 || start > _maxElements || start + count > _maxElements + 1 || _writeCallback == nullptr)
             return 0;
@@ -34,5 +34,5 @@ template <class T> class CallbackProperty : public Property
   private:
     T* _interfaceObject = nullptr;
     uint8_t (*_readCallback)(T*, uint16_t, uint8_t, uint8_t*) = nullptr;
-    uint8_t (*_writeCallback)(T*, uint16_t, uint8_t, uint8_t*) = nullptr;
+    uint8_t (*_writeCallback)(T*, uint16_t, uint8_t, const uint8_t*) = nullptr;
 };

src/knx/cemi_server_object.cpp

@@ -82,16 +82,6 @@ uint8_t CemiServerObject::propertySize(PropertyID id)
     return 0;
 }
 
-uint8_t* CemiServerObject::save(uint8_t* buffer)
-{
-    return buffer;
-}
-
-uint8_t* CemiServerObject::restore(uint8_t* buffer)
-{
-    return buffer;
-}
-
 static PropertyDescription _propertyDescriptions[] = 
 {
     { PID_OBJECT_TYPE, false, PDT_UNSIGNED_INT, 1, ReadLv3 | WriteLv0 },

src/knx/cemi_server_object.h

@@ -11,8 +11,6 @@ public:
     void readProperty(PropertyID id, uint16_t start, uint8_t& count, uint8_t* data) override;
     void writeProperty(PropertyID id, uint16_t start, uint8_t* data, uint8_t& count) override;
     uint8_t propertySize(PropertyID id) override;
-    uint8_t* save(uint8_t* buffer) override;
-    uint8_t* restore(uint8_t* buffer) override;
 
 protected:
   uint8_t propertyDescriptionCount() override;

src/knx/data_property.cpp

@@ -23,7 +23,7 @@ uint8_t DataProperty::read(uint16_t start, uint8_t count, uint8_t* data) const
     return count;
 }
 
-uint8_t DataProperty::write(uint16_t start, uint8_t count, uint8_t* data)
+uint8_t DataProperty::write(uint16_t start, uint8_t count, const uint8_t* data)
 {
     if (count == 0 || start > _maxElements || start + count > _maxElements + 1)
         return 0;
@@ -103,13 +103,20 @@ DataProperty::DataProperty(PropertyID id, bool writeEnable, PropertyDataType typ
     Property::write(value);
 }
 
+DataProperty::DataProperty(PropertyID id, bool writeEnable, PropertyDataType type,
+                           uint16_t maxElements, uint8_t access, const uint8_t* value)
+    : Property(id, writeEnable, type, maxElements, access)
+{
+    Property::write(value);
+}
+
 uint16_t DataProperty::saveSize()
 {
     return sizeof(_currentElements) + _maxElements * ElementSize();
 }
 
 
-uint8_t* DataProperty::restore(uint8_t* buffer)
+const uint8_t* DataProperty::restore(const uint8_t* buffer)
 {
     uint16_t elements = 0;
     buffer = popWord(elements, buffer);
@@ -138,3 +145,9 @@ uint8_t* DataProperty::save(uint8_t* buffer)
 
     return buffer;
 }
+
+
+const uint8_t* DataProperty::data()
+{
+    return _data;
+}

src/knx/data_property.h

@@ -9,12 +9,14 @@ class DataProperty : public Property
     DataProperty(PropertyID id, bool writeEnable, PropertyDataType type, uint16_t maxElements, uint8_t access, uint8_t value);
     DataProperty(PropertyID id, bool writeEnable, PropertyDataType type, uint16_t maxElements, uint8_t access, uint16_t value);
     DataProperty(PropertyID id, bool writeEnable, PropertyDataType type, uint16_t maxElements, uint8_t access, uint32_t value);
+    DataProperty(PropertyID id, bool writeEnable, PropertyDataType type, uint16_t maxElements, uint8_t access, const uint8_t* value);
     virtual ~DataProperty() override;
     virtual uint8_t read(uint16_t start, uint8_t count, uint8_t* data) const override;
-    virtual uint8_t write(uint16_t start, uint8_t count, uint8_t* data) override;
+    virtual uint8_t write(uint16_t start, uint8_t count, const uint8_t* data) override;
     virtual uint8_t* save(uint8_t* buffer) override;
-    virtual uint8_t* restore(uint8_t* buffer) override;
+    virtual const uint8_t* restore(const uint8_t* buffer) override;
     virtual uint16_t saveSize() override;
+    const uint8_t* data();
 
   private:
     uint16_t _currentElements = 0;

src/knx/device_object.cpp

@@ -1,137 +1,97 @@
 #include <cstring>
 #include "device_object.h"
 #include "bits.h"
+#include "data_property.h"
+#include "callback_property.h"
+#include "config.h"
 
-void DeviceObject::readProperty(PropertyID propertyId, uint16_t start, uint8_t& count, uint8_t* data)
+#define LEN_KNX_SERIAL 6
-{
-    switch (propertyId)
-    {
-        case PID_OBJECT_TYPE:
-            pushWord(OT_DEVICE, data);
-            break;
-        case PID_SERIAL_NUMBER:
-            pushByteArray((uint8_t*)_knxSerialNumber, 6, data);
-            break;
-        case PID_MANUFACTURER_ID:
-            pushByteArray(&_knxSerialNumber[0], 2, data);
-            break;
-        case PID_DEVICE_CONTROL:
-            *data = _deviceControl;
-            break;
-        case PID_ORDER_INFO:
-            pushByteArray((uint8_t*)_orderNumber, 10, data);
-            break;
-        case PID_HARDWARE_TYPE:
-            pushByteArray((uint8_t*)_hardwareType, LEN_HARDWARE_TYPE, data);
-            break;
-        case PID_VERSION:
-            pushWord(_version, data);
-            break;
-        case PID_ROUTING_COUNT:
-            *data = _routingCount;
-            break;
-        case PID_PROG_MODE:
-            *data = _prgMode;
-            break;
-        case PID_MAX_APDU_LENGTH:
-            pushWord(_maxApduLength, data);
-            break;
-        case PID_SUBNET_ADDR:
-            *data = ((_ownAddress >> 8) & 0xff);
-            break;
-        case PID_DEVICE_ADDR:
-            *data = (_ownAddress & 0xff);
-            break;
-        case PID_IO_LIST:
-        {
-            for (uint32_t i = start; i < (_ifObjs[0] + 1) && i < count; i++)
-                pushInt(_ifObjs[i], data);
-            break;
-        }
-        case PID_DEVICE_DESCRIPTOR:
-            pushWord(_maskVersion, data);
-            break;
-        case PID_RF_DOMAIN_ADDRESS_CEMI_SERVER:
-            pushByteArray((uint8_t*)_rfDomainAddress, 6, data);
-            break;
-        default:
-            count = 0;
-    }
-}
 
-void DeviceObject::writeProperty(PropertyID id, uint16_t start, uint8_t* data, uint8_t& count)
+DeviceObject::DeviceObject()
 {
-    switch (id)
+    //Default to KNXA (0xFA)
-    {
+    uint8_t serialNumber[] = {0x00, 0xFA, 0x00, 0x00, 0x00, 0x00};
-        case PID_DEVICE_CONTROL:
-            _deviceControl = data[0];
-            break;
-        case PID_ROUTING_COUNT:
-            _routingCount = data[0];
-            break;
-        case PID_PROG_MODE:
-            _prgMode = data[0];
-            break;
-        case PID_RF_DOMAIN_ADDRESS_CEMI_SERVER:
-            memcpy(_rfDomainAddress, data, propertySize(PID_RF_DOMAIN_ADDRESS_CEMI_SERVER));
-            break;
-        case PID_SUBNET_ADDR:
-            _ownAddress = (data[0] << 8) | (_ownAddress & 0xff);
-            break;
-        case PID_DEVICE_ADDR:
-            _ownAddress = data[0] | (_ownAddress & 0xff00);
-            break;
-        default:
-            count = 0;
-            break;
-    }
-}
 
-uint8_t DeviceObject::propertySize(PropertyID id)
+    Property* properties[] =
     {
-    switch (id)
+        new DataProperty(PID_OBJECT_TYPE, false, PDT_UNSIGNED_INT, 1, ReadLv3 | WriteLv0, (uint16_t)OT_DEVICE),
+        new DataProperty(PID_SERIAL_NUMBER, false, PDT_GENERIC_06, 1, ReadLv3 | WriteLv0, serialNumber), 
+        new CallbackProperty<DeviceObject>(this, PID_MANUFACTURER_ID, false, PDT_UNSIGNED_INT, 1, ReadLv3 | WriteLv0,
+            [](DeviceObject* io, uint16_t start, uint8_t count, uint8_t* data) -> uint8_t 
             { 
-    case PID_DEVICE_CONTROL:
+                if(start == 0)
-    case PID_ROUTING_COUNT:
-    case PID_PROG_MODE:
-    case PID_SUBNET_ADDR:
-    case PID_DEVICE_ADDR:
                     return 1;
-    case PID_OBJECT_TYPE:
+                
-    case PID_MANUFACTURER_ID:
+                pushByteArray(io->knxSerialNumber(), 2, data);
-    case PID_VERSION:
+                return 1;
-    case PID_DEVICE_DESCRIPTOR:
+            }),
-    case PID_MAX_APDU_LENGTH:
+        new DataProperty(PID_DEVICE_CONTROL, true, PDT_BITSET8, 1, ReadLv3 | WriteLv3, (uint8_t)0),
-        return 2;
+        new DataProperty(PID_ORDER_INFO, false, PDT_GENERIC_10, 1, ReadLv3 | WriteLv0),
-    case PID_IO_LIST:
+        new DataProperty(PID_VERSION, false, PDT_VERSION, 1, ReadLv3 | WriteLv0, (uint16_t)3),
-        return 4;
+        new DataProperty(PID_ROUTING_COUNT, true, PDT_UNSIGNED_CHAR, 1, ReadLv3 | WriteLv3, (uint8_t)0),
-    case PID_SERIAL_NUMBER:
+        new CallbackProperty<DeviceObject>(this, PID_PROG_MODE, true, PDT_BITSET8, 1, ReadLv3 | WriteLv3, 
-    case PID_HARDWARE_TYPE:
+            [](DeviceObject* io, uint16_t start, uint8_t count, uint8_t* data) -> uint8_t 
-    case PID_RF_DOMAIN_ADDRESS_CEMI_SERVER:
+            { 
-        return 6;
+                if(start == 0)
-    case PID_ORDER_INFO:
+                    return 1;
-        return 10;
+                
-    }
+                *data = io->_prgMode;
-    return 0;
+                return 1;
+            },
+            [](DeviceObject* io, uint16_t start, uint8_t count, const uint8_t* data) -> uint8_t 
+            { 
+                if(start == 0)
+                    return 1;
+
+                io->_prgMode = *data;
+                return 1;
+            }),
+        new DataProperty(PID_MAX_APDU_LENGTH, false, PDT_UNSIGNED_INT, 1, ReadLv3 | WriteLv0, (uint16_t)254),
+        new CallbackProperty<DeviceObject>(this, PID_SUBNET_ADDR, false, PDT_UNSIGNED_CHAR, 1, ReadLv3 | WriteLv0,
+            [](DeviceObject* io, uint16_t start, uint8_t count, uint8_t* data) -> uint8_t 
+            { 
+                if(start == 0)
+                    return 1;
+
+                *data = ((io->_ownAddress >> 8) & 0xff);
+
+                return 1;
+            }),
+        new CallbackProperty<DeviceObject>(this, PID_DEVICE_ADDR, false, PDT_UNSIGNED_CHAR, 1, ReadLv3 | WriteLv0,
+            [](DeviceObject* io, uint16_t start, uint8_t count, uint8_t* data) -> uint8_t 
+            { 
+                if(start == 0)
+                    return 1;
+
+                *data = (io->_ownAddress & 0xff);
+                return 1;
+            }),
+        new DataProperty(PID_IO_LIST, false, PDT_UNSIGNED_INT, 1, ReadLv3 | WriteLv0, (uint8_t)0),
+        new DataProperty(PID_HARDWARE_TYPE, true, PDT_GENERIC_06, 1, ReadLv3 | WriteLv3, (uint8_t)0),
+        new DataProperty(PID_DEVICE_DESCRIPTOR, false, PDT_GENERIC_02, 1, ReadLv3 | WriteLv0, (uint8_t)0),
+#ifdef USE_RF
+        new DataProperty(PID_RF_DOMAIN_ADDRESS_CEMI_SERVER, true, PDT_GENERIC_06, 1, ReadLv3 | WriteLv3),
+#endif
+
+    };
+    initializeProperties(sizeof(properties), properties);
 }
 
 uint8_t* DeviceObject::save(uint8_t* buffer)
 {
-    buffer = pushByte(_deviceControl, buffer);
-    buffer = pushByte(_routingCount, buffer);
     buffer = pushWord(_ownAddress, buffer);
-    buffer = pushByteArray((uint8_t*)_rfDomainAddress, 6, buffer);
+    return InterfaceObject::save(buffer);
-    return buffer;
 }
 
-uint8_t* DeviceObject::restore(uint8_t* buffer)
+const uint8_t* DeviceObject::restore(const uint8_t* buffer)
 {
-    buffer = popByte(_deviceControl, buffer);
-    buffer = popByte(_routingCount, buffer);
     buffer = popWord(_ownAddress, buffer);
-    buffer = popByteArray((uint8_t*)_rfDomainAddress, 6, buffer);
+    return InterfaceObject::restore(buffer);
-    _prgMode = 0;
+}
-    return buffer;
+
+uint16_t DeviceObject::saveSize()
+{
+    return 2 + InterfaceObject::saveSize();
 }
 
 uint16_t DeviceObject::induvidualAddress()
@@ -150,56 +110,38 @@ void DeviceObject::induvidualAddress(uint16_t value)
 #define SAFE_STATE    0x8
 
 
-bool DeviceObject::userStopped()
-{
-    return (_deviceControl & USER_STOPPED) > 0;
-}
-
-void DeviceObject::userStopped(bool value)
-{
-    if (value)
-        _deviceControl |= USER_STOPPED;
-    else
-        _deviceControl &= ~USER_STOPPED;
-}
-
-bool DeviceObject::induvidualAddressDuplication()
-{
-    return (_deviceControl & OWN_ADDR_DUPL) > 0;
-}
-
 void DeviceObject::induvidualAddressDuplication(bool value)
 {
+    Property* prop = property(PID_DEVICE_CONTROL);
+    uint8_t data;
+    prop->read(data);
+    
     if (value)
-        _deviceControl |= OWN_ADDR_DUPL;
+        data |= OWN_ADDR_DUPL;
     else
-        _deviceControl &= ~OWN_ADDR_DUPL;
+        data &= ~OWN_ADDR_DUPL;
+    prop->write(data);
 }
 
 bool DeviceObject::verifyMode()
 {
-    return (_deviceControl & VERIFY_MODE) > 0;
+    Property* prop = property(PID_DEVICE_CONTROL);
+    uint8_t data;
+    prop->read(data);
+    return (data & VERIFY_MODE) > 0;
 }
 
 void DeviceObject::verifyMode(bool value)
 {
-    if (value)
+    Property* prop = property(PID_DEVICE_CONTROL);
-        _deviceControl |= VERIFY_MODE;
+    uint8_t data;
-    else
+    prop->read(data);
-        _deviceControl &= ~VERIFY_MODE;
-}
 
-bool DeviceObject::safeState()
-{
-    return (_deviceControl & SAFE_STATE) > 0;
-}
-
-void DeviceObject::safeState(bool value)
-{
     if (value)
-        _deviceControl |= SAFE_STATE;
+        data |= VERIFY_MODE;
     else
-        _deviceControl &= ~SAFE_STATE;
+        data &= ~VERIFY_MODE;
+    prop->write(data);
 }
 
 bool DeviceObject::progMode()
@@ -218,126 +160,124 @@ void DeviceObject::progMode(bool value)
 uint16_t DeviceObject::manufacturerId()
 {
     uint16_t manufacturerId;
-    popWord(manufacturerId, &_knxSerialNumber[0]);
+    popWord(manufacturerId, knxSerialNumber());
     return manufacturerId;
 }
 
 void DeviceObject::manufacturerId(uint16_t value)
 {
-   pushWord(value, &_knxSerialNumber[0]);
+    uint8_t data[LEN_KNX_SERIAL];
+    memcpy(data, knxSerialNumber(), LEN_KNX_SERIAL);
+    pushWord(value, data);
+    knxSerialNumber(data);
 }
 
 uint32_t DeviceObject::bauNumber()
 {
     uint32_t bauNumber;
-    popInt(bauNumber, &_knxSerialNumber[2]);
+    popInt(bauNumber, knxSerialNumber() + 2);
     return bauNumber;
 }
 
 void DeviceObject::bauNumber(uint32_t value)
 {
-   pushInt(value, &_knxSerialNumber[2]);
+    uint8_t data[LEN_KNX_SERIAL];
+    memcpy(data, knxSerialNumber(), LEN_KNX_SERIAL);
+    pushInt(value, data + 2);
+    knxSerialNumber(data);
 }
 
 const uint8_t* DeviceObject::knxSerialNumber()
 {
-    return _knxSerialNumber;
+    DataProperty* prop = (DataProperty*)property(PID_SERIAL_NUMBER);
+    return prop->data();
 }
 
 void DeviceObject::knxSerialNumber(const uint8_t* value)
 {
-    pushByteArray(value, 6, _knxSerialNumber);
+    Property* prop = property(PID_SERIAL_NUMBER);
+    prop->write(value);
 }
 
-const char* DeviceObject::orderNumber()
+const uint8_t* DeviceObject::orderNumber()
 {
-    return _orderNumber;
+    DataProperty* prop = (DataProperty*)property(PID_ORDER_INFO);
+    return prop->data();
 }
 
-void DeviceObject::orderNumber(const char* value)
+void DeviceObject::orderNumber(const uint8_t* value)
 {
-    strncpy(_orderNumber, value, 10);
+    Property* prop = property(PID_ORDER_INFO);
+    prop->write(value);
 }
 
 const uint8_t* DeviceObject::hardwareType()
 {
-    return _hardwareType;
+    DataProperty* prop = (DataProperty*)property(PID_HARDWARE_TYPE);
+    return prop->data();
 }
 
 void DeviceObject::hardwareType(const uint8_t* value)
 {
-    pushByteArray(value, 6, _hardwareType);
+    Property* prop = property(PID_HARDWARE_TYPE);
+    prop->write(value);
 }
 
 uint16_t DeviceObject::version()
 {
-    return _version;
+    Property* prop = property(PID_HARDWARE_TYPE);
+    uint16_t value;
+    prop->read(value);
+    return value;
 }
 
 void DeviceObject::version(uint16_t value)
 {
-    _version = value;
+    Property* prop = property(PID_HARDWARE_TYPE);
+    prop->write(value);
 }
 
 uint16_t DeviceObject::maskVersion()
 {
-    return _maskVersion;
+    Property* prop = property(PID_DEVICE_DESCRIPTOR);
+    uint16_t value;
+    prop->read(value);
+    return value;
 }
 
 void DeviceObject::maskVersion(uint16_t value)
 {
-    _maskVersion = value;
+    Property* prop = property(PID_DEVICE_DESCRIPTOR);
-}
+    prop->write(value);
-
-void DeviceObject::maxApduLength(uint16_t value)
-{
-    _maxApduLength = value;
 }
 
 uint16_t DeviceObject::maxApduLength()
 {
-    return _maxApduLength;
+    Property* prop = property(PID_MAX_APDU_LENGTH);
+    uint16_t value;
+    prop->read(value);
+    return value;
 }
 
-const uint32_t* DeviceObject::ifObj()
+void DeviceObject::maxApduLength(uint16_t value)
 {
-    return _ifObjs;
+    Property* prop = property(PID_MAX_APDU_LENGTH);
+    prop->write(value);
 }
 
-void DeviceObject::ifObj(const uint32_t* value)
+const uint8_t* DeviceObject::rfDomainAddress()
 {
-    _ifObjs = value;
+    DataProperty* prop = (DataProperty*)property(PID_RF_DOMAIN_ADDRESS_CEMI_SERVER);
-}
+    return prop->data();
-
-uint8_t* DeviceObject::rfDomainAddress()
-{
-    return _rfDomainAddress;
 }
 
 void DeviceObject::rfDomainAddress(uint8_t* value)
 {
-    pushByteArray(value, 6, _rfDomainAddress);
+    Property* prop = property(PID_RF_DOMAIN_ADDRESS_CEMI_SERVER);
-}
+    prop->write(value);
-
-static PropertyDescription _propertyDescriptions[] = 
-{
-    { PID_OBJECT_TYPE, false, PDT_UNSIGNED_INT, 1, ReadLv3 | WriteLv0 },
-    { PID_SERIAL_NUMBER, false, PDT_GENERIC_06, 1, ReadLv3 | WriteLv0 }
-};
-static uint8_t _propertyDescriptionCount = sizeof(_propertyDescriptions) / sizeof(PropertyDescription);
-
-uint8_t DeviceObject::propertyDescriptionCount()
-{
-    return _propertyDescriptionCount;
 }
 
 
-PropertyDescription* DeviceObject::propertyDescriptions()
-{
-    return _propertyDescriptions;
-}
 
-uint16_t DeviceObject::saveSize()
+
-{
+
-    return 4;
-}

src/knx/device_object.h

@@ -7,24 +7,17 @@
 class DeviceObject: public InterfaceObject
 {
 public:
-    void readProperty(PropertyID id, uint16_t start, uint8_t& count, uint8_t* data) override;
+    DeviceObject();
-    void writeProperty(PropertyID id, uint16_t start, uint8_t* data, uint8_t& count) override;
-    uint8_t propertySize(PropertyID id) override;
     uint8_t* save(uint8_t* buffer) override;
-    uint8_t* restore(uint8_t* buffer) override;
+    const uint8_t* restore(const uint8_t* buffer) override;
     uint16_t saveSize() override;
-    void readPropertyDescription(uint8_t propertyId, uint8_t& propertyIndex, bool& writeEnable, uint8_t& type, uint16_t& numberOfElements, uint8_t& access);
 
     uint16_t induvidualAddress();
     void induvidualAddress(uint16_t value);
-    bool userStopped();
+
-    void userStopped(bool value);
-    bool induvidualAddressDuplication();
     void induvidualAddressDuplication(bool value);
     bool verifyMode();
     void verifyMode(bool value);
-    bool safeState();
-    void safeState(bool value);
     bool progMode();
     void progMode(bool value);
     uint16_t manufacturerId();
@@ -33,8 +26,8 @@ public:
     void bauNumber(uint32_t value);
     const uint8_t* knxSerialNumber();
     void knxSerialNumber(const uint8_t* value);
-    const char* orderNumber();
+    const uint8_t* orderNumber();
-    void orderNumber(const char* value);
+    void orderNumber(const uint8_t* value);
     const uint8_t* hardwareType();
     void hardwareType(const uint8_t* value);
     uint16_t version();
@@ -43,24 +36,9 @@ public:
     void maskVersion(uint16_t value);
     uint16_t maxApduLength();
     void maxApduLength(uint16_t value);
-    const uint32_t* ifObj();
+    const uint8_t* rfDomainAddress();
-    void ifObj(const uint32_t* value);
-    uint8_t* rfDomainAddress();
     void rfDomainAddress(uint8_t* value);
-protected:
-    uint8_t propertyDescriptionCount() override;
-    PropertyDescription* propertyDescriptions() override;
 private:
-    uint8_t _deviceControl = 0;
-    uint8_t _routingCount = 0;
     uint8_t _prgMode = 0;
     uint16_t _ownAddress = 0;
-    uint8_t _knxSerialNumber[6] = { 0x00, 0xFA, 0x00, 0x00, 0x00, 0x00 };  //Default to KNXA (0xFA)
-    char _orderNumber[10] = "";
-    uint8_t _hardwareType[6] = { 0, 0, 0, 0, 0, 0};
-    uint16_t _version = 2;
-    uint16_t _maskVersion = 0x0000;
-    uint16_t _maxApduLength = 254;
-    const uint32_t* _ifObjs;
-    uint8_t _rfDomainAddress[6] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
 };

src/knx/group_object_table_object.cpp

@@ -33,7 +33,7 @@ GroupObject& GroupObjectTableObject::get(uint16_t asap)
     return _groupObjects[asap - 1];
 }
 
-uint8_t* GroupObjectTableObject::restore(uint8_t* buffer)
+const uint8_t* GroupObjectTableObject::restore(const uint8_t* buffer)
 {
     buffer = TableObject::restore(buffer);
 

src/knx/group_object_table_object.h

@@ -15,7 +15,7 @@ class GroupObjectTableObject : public TableObject
     GroupObject& nextUpdatedObject(bool& valid);
     void groupObjects(GroupObject* objs, uint16_t size);
 
-    uint8_t* restore(uint8_t* buffer) override;
+    const uint8_t* restore(const uint8_t* buffer) override;
 
   protected:
     void beforeStateChange(LoadState& newState) override;

src/knx/interface_object.cpp

@@ -179,7 +179,7 @@ uint8_t* InterfaceObject::save(uint8_t* buffer)
 }
 
 
-uint8_t* InterfaceObject::restore(uint8_t* buffer)
+const uint8_t* InterfaceObject::restore(const uint8_t* buffer)
 {
     for (int i = 0; i < _propertyCount; i++)
     {

src/knx/interface_object.h

@@ -131,7 +131,7 @@ class InterfaceObject : public SaveRestore
     const Property* property(PropertyID id) const;
 
     virtual uint8_t* save(uint8_t* buffer) override;
-    virtual uint8_t* restore(uint8_t* buffer) override;
+    virtual const uint8_t* restore(const uint8_t* buffer) override;
     virtual uint16_t saveSize() override;
 
   protected:

src/knx/ip_parameter_object.cpp

@@ -25,7 +25,7 @@ IpParameterObject::IpParameterObject(DeviceObject& deviceObject, Platform& platf
                 pushWord(io->_deviceObject.induvidualAddress(), data);
                 return 1;
             },
-            [](IpParameterObject* io, uint16_t start, uint8_t count, uint8_t* data) -> uint8_t 
+            [](IpParameterObject* io, uint16_t start, uint8_t count, const uint8_t* data) -> uint8_t 
             { 
                 io->_deviceObject.induvidualAddress(getWord(data));
                 return 1; 

src/knx/memory.cpp

@@ -20,7 +20,7 @@ void Memory::readMemory()
     _freeList = new MemoryBlock(_data + metadataBlockSize, flashSize - metadataBlockSize);
 
     uint16_t manufacturerId = 0;
-    uint8_t* buffer = popWord(manufacturerId, _data);
+    const uint8_t* buffer = popWord(manufacturerId, _data);
 
     uint8_t hardwareType[LEN_HARDWARE_TYPE] = {0};
     buffer = popByteArray(hardwareType, LEN_HARDWARE_TYPE, buffer);

src/knx/property.cpp

@@ -152,7 +152,7 @@ uint8_t Property::read(uint32_t& value) const
 }
 
 
-uint8_t Property::write(uint8_t& value)
+uint8_t Property::write(uint8_t value)
 {
     if (ElementSize() != 1)
         return 0;
@@ -161,7 +161,7 @@ uint8_t Property::write(uint8_t& value)
 }
 
 
-uint8_t Property::write(uint16_t& value)
+uint8_t Property::write(uint16_t value)
 {
     if (ElementSize() != 2)
         return 0;
@@ -172,7 +172,7 @@ uint8_t Property::write(uint16_t& value)
 }
 
 
-uint8_t Property::write(uint32_t& value)
+uint8_t Property::write(uint32_t value)
 {
     if (ElementSize() != 4)
         return 0;
@@ -181,3 +181,20 @@ uint8_t Property::write(uint32_t& value)
     pushInt(value, data);
     return write(1, 1, data);
 }
+
+
+uint8_t Property::write(const uint8_t* value)
+{
+    return write(1, 1, value);
+}
+
+
+uint8_t Property::write(uint16_t position, uint16_t value)
+{
+    if (ElementSize() != 2)
+        return 0;
+
+    uint8_t data[2];
+    pushWord(value, data);
+    return write(position, 1, data);
+}

src/knx/property.h

@@ -237,13 +237,15 @@ class Property : public SaveRestore
     uint8_t Access() const;
     uint8_t ElementSize() const;
     virtual uint8_t read(uint16_t start, uint8_t count, uint8_t* data) const = 0;
-    virtual uint8_t write(uint16_t start, uint8_t count, uint8_t* data) = 0;
+    virtual uint8_t write(uint16_t start, uint8_t count, const uint8_t* data) = 0;
     uint8_t read(uint8_t& value) const;
     uint8_t read(uint16_t& value) const;
     uint8_t read(uint32_t& value) const;
-    uint8_t write(uint8_t& value);
+    uint8_t write(uint8_t value);
-    uint8_t write(uint16_t& value);
+    uint8_t write(uint16_t value);
-    uint8_t write(uint32_t& value);
+    uint8_t write(uint16_t position, uint16_t value);
+    uint8_t write(uint32_t value);
+    uint8_t write(const uint8_t* value);
   protected:
     PropertyID _id;
     bool _writeEnable;

src/knx/rf_medium_object.cpp

@@ -99,7 +99,7 @@ uint8_t* RfMediumObject::save(uint8_t* buffer)
     return buffer;
 }
 
-uint8_t* RfMediumObject::restore(uint8_t* buffer)
+const uint8_t* RfMediumObject::restore(const uint8_t* buffer)
 {
     buffer = popByteArray((uint8_t*)_rfDomainAddress, 6, buffer);
     return buffer;

src/knx/rf_medium_object.h

@@ -11,7 +11,7 @@ public:
     void writeProperty(PropertyID id, uint16_t start, uint8_t* data, uint8_t& count) override;
     uint8_t propertySize(PropertyID id) override;
     uint8_t* save(uint8_t* buffer) override;
-    uint8_t* restore(uint8_t* buffer) override;
+    const uint8_t* restore(const uint8_t* buffer) override;
     uint16_t saveSize() override;
 
     uint8_t* rfDomainAddress();

src/knx/save_restore.h

@@ -28,7 +28,7 @@ class SaveRestore
      * @return The buffer plus the size of the object state. The next object will use this value as 
      * the start of its buffer.
      */
-    virtual uint8_t* restore(uint8_t* buffer)
+    virtual const uint8_t* restore(const uint8_t* buffer)
     {
         return buffer;
     }

src/knx/table_object.cpp

@@ -40,7 +40,7 @@ uint8_t* TableObject::save(uint8_t* buffer)
 }
 
 
-uint8_t* TableObject::restore(uint8_t* buffer)
+const uint8_t* TableObject::restore(const uint8_t* buffer)
 {
     uint8_t state = 0;
     buffer = popByte(state, buffer);
@@ -83,7 +83,7 @@ bool TableObject::allocTable(uint32_t size, bool doFill, uint8_t fillByte)
     return true;
 }
 
-void TableObject::loadEvent(uint8_t* data)
+void TableObject::loadEvent(const uint8_t* data)
 {
     switch (_state)
     {
@@ -105,7 +105,7 @@ void TableObject::loadEvent(uint8_t* data)
     }
 }
 
-void TableObject::loadEventUnloaded(uint8_t* data)
+void TableObject::loadEventUnloaded(const uint8_t* data)
 {
     uint8_t event = data[0];
     switch (event)
@@ -124,7 +124,7 @@ void TableObject::loadEventUnloaded(uint8_t* data)
     }
 }
 
-void TableObject::loadEventLoading(uint8_t* data)
+void TableObject::loadEventLoading(const uint8_t* data)
 {
     uint8_t event = data[0];
     switch (event)
@@ -147,7 +147,7 @@ void TableObject::loadEventLoading(uint8_t* data)
     }
 }
 
-void TableObject::loadEventLoaded(uint8_t* data)
+void TableObject::loadEventLoaded(const uint8_t* data)
 {
     uint8_t event = data[0];
     switch (event)
@@ -177,7 +177,7 @@ void TableObject::loadEventLoaded(uint8_t* data)
     }
 }
 
-void TableObject::loadEventError(uint8_t* data)
+void TableObject::loadEventError(const uint8_t* data)
 {
     uint8_t event = data[0];
     switch (event)
@@ -196,7 +196,7 @@ void TableObject::loadEventError(uint8_t* data)
     }
 }
 
-void TableObject::additionalLoadControls(uint8_t* data)
+void TableObject::additionalLoadControls(const uint8_t* data)
 {
     if (data[1] != 0x0B) // Data Relative Allocation
     {
@@ -244,7 +244,7 @@ void TableObject::initializeProperties(size_t propertiesSize, Property** propert
                 data[0] = obj->_state;
                 return 1;
             },
-            [](TableObject* obj, uint16_t start, uint8_t count, uint8_t* data) -> uint8_t {
+            [](TableObject* obj, uint16_t start, uint8_t count, const uint8_t* data) -> uint8_t {
                 obj->loadEvent(data);
                 return 1;
             }),

src/knx/table_object.h

@@ -25,8 +25,8 @@ class TableObject: public InterfaceObject
      * This method returns the ::LoadState of the interface object.
      */
     LoadState loadState();
-    virtual uint8_t* save(uint8_t* buffer) override;
+    uint8_t* save(uint8_t* buffer) override;
-    virtual uint8_t* restore(uint8_t* buffer) override;
+    const uint8_t* restore(const uint8_t* buffer) override;
     uint16_t saveSize() override;
 protected:
     /**
@@ -51,12 +51,12 @@ protected:
   private:
     uint32_t tableReference();
     bool allocTable(uint32_t size, bool doFill, uint8_t fillByte);
-    void loadEvent(uint8_t* data);
+    void loadEvent(const uint8_t* data);
-    void loadEventUnloaded(uint8_t* data);
+    void loadEventUnloaded(const uint8_t* data);
-    void loadEventLoading(uint8_t* data);
+    void loadEventLoading(const uint8_t* data);
-    void loadEventLoaded(uint8_t* data);
+    void loadEventLoaded(const uint8_t* data);
-    void loadEventError(uint8_t* data);
+    void loadEventError(const uint8_t* data);
-    void additionalLoadControls(uint8_t* data);
+    void additionalLoadControls(const uint8_t* data);
     /**
      * set the ::LoadState of the interface object.
      *