Mirrors/knx
1
0
Fork 0
mirror of https://github.com/thelsing/knx.git synced 2025-05-16 01:16:18 +02:00
Code Issues Packages Projects Releases Wiki Activity

refactor device object, add more const to functions

Browse Source
This commit is contained in:
Thomas Kunze 2019-12-21 17:48:46 +01:00
parent 729c06357a
commit f8e2da00a2
35 changed files with 278 additions and 329 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/knx/address_table_object.cpp
View File

@ -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);

2
src/knx/address_table_object.h
View File

@ -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.

8
src/knx/application_layer.cpp
View File

@ -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];
uint8_t* domainAddress = &data[7];
const uint8_t* knxSerialNumber = &data[1];
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;
}

2
src/knx/association_table_object.cpp
View File

@ -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();

2
src/knx/association_table_object.h
View File

@ -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);

6
src/knx/bau.cpp
View File

@ -247,12 +247,12 @@ void BusAccessUnit::systemNetworkParameterReadIndication(Priority priority, HopC
{
}
void BusAccessUnit::domainAddressSerialNumberWriteIndication(Priority priority, HopCountType hopType, uint8_t* rfDoA,
uint8_t* knxSerialNumber)
void BusAccessUnit::domainAddressSerialNumberWriteIndication(Priority priority, HopCountType hopType, const uint8_t* rfDoA,
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)
{
}

6
src/knx/bau.h
View File

@ -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,
uint8_t* knxSerialNumber);
virtual void domainAddressSerialNumberWriteIndication(Priority priority, HopCountType hopType, const uint8_t* rfDoA,
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,

10
src/knx/bau07B0.cpp
View File

@ -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)

6
src/knx/bau07B0.h
View File

@ -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

11
src/knx/bau27B0.cpp
View File

@ -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

5
src/knx/bau27B0.h
View File

@ -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,

11
src/knx/bau57B0.cpp
View File

@ -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)

6
src/knx/bau57B0.h
View File

@ -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

12
src/knx/bits.cpp
View File

@ -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];
}

12
src/knx/bits.h
View File

@ -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);
uint8_t* popWord(uint16_t& w, uint8_t* data);
uint8_t* popInt(uint32_t& i, uint8_t* data);
uint8_t* popByteArray(uint8_t* dst, uint32_t size, uint8_t* data);
const uint8_t* popByte(uint8_t& b, const uint8_t* data);
const uint8_t* popWord(uint16_t& w, const uint8_t* data);
const uint8_t* popInt(uint32_t& i, const 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);
uint32_t getInt(uint8_t* data);
uint16_t getWord(const uint8_t* data);
uint32_t getInt(const uint8_t* data);
void printHex(const char* suffix, const uint8_t *data, size_t length);

6
src/knx/callback_property.h
View File

@ -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;
};

10
src/knx/cemi_server_object.cpp
View File

@ -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 },

2
src/knx/cemi_server_object.h
View File

@ -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;

17
src/knx/data_property.cpp
View File

@ -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;
}

6
src/knx/data_property.h
View File

@ -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;

348
src/knx/device_object.cpp
View File

@ -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)
{
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;
}
}
#define LEN_KNX_SERIAL 6
void DeviceObject::writeProperty(PropertyID id, uint16_t start, uint8_t* data, uint8_t& count)
DeviceObject::DeviceObject()
{
switch (id)
{
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;
}
}
//Default to KNXA (0xFA)
uint8_t serialNumber[] = {0x00, 0xFA, 0x00, 0x00, 0x00, 0x00};
uint8_t DeviceObject::propertySize(PropertyID id)
{
switch (id)
Property* properties[] =
{
case PID_DEVICE_CONTROL:
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:
case PID_VERSION:
case PID_DEVICE_DESCRIPTOR:
case PID_MAX_APDU_LENGTH:
return 2;
case PID_IO_LIST:
return 4;
case PID_SERIAL_NUMBER:
case PID_HARDWARE_TYPE:
case PID_RF_DOMAIN_ADDRESS_CEMI_SERVER:
return 6;
case PID_ORDER_INFO:
return 10;
}
return 0;
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
{
if(start == 0)
return 1;
pushByteArray(io->knxSerialNumber(), 2, data);
return 1;
}),
new DataProperty(PID_DEVICE_CONTROL, true, PDT_BITSET8, 1, ReadLv3 | WriteLv3, (uint8_t)0),
new DataProperty(PID_ORDER_INFO, false, PDT_GENERIC_10, 1, ReadLv3 | WriteLv0),
new DataProperty(PID_VERSION, false, PDT_VERSION, 1, ReadLv3 | WriteLv0, (uint16_t)3),
new DataProperty(PID_ROUTING_COUNT, true, PDT_UNSIGNED_CHAR, 1, ReadLv3 | WriteLv3, (uint8_t)0),
new CallbackProperty<DeviceObject>(this, PID_PROG_MODE, true, PDT_BITSET8, 1, ReadLv3 | WriteLv3,
[](DeviceObject* io, uint16_t start, uint8_t count, uint8_t* data) -> uint8_t
{
if(start == 0)
return 1;
*data = io->_prgMode;
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 buffer;
return InterfaceObject::save(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);
_prgMode = 0;
return buffer;
return InterfaceObject::restore(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)
_deviceControl |= VERIFY_MODE;
else
_deviceControl &= ~VERIFY_MODE;
}
Property* prop = property(PID_DEVICE_CONTROL);
uint8_t data;
prop->read(data);
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;
}
void DeviceObject::maxApduLength(uint16_t value)
{
_maxApduLength = value;
Property* prop = property(PID_DEVICE_DESCRIPTOR);
prop->write(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;
}
uint8_t* DeviceObject::rfDomainAddress()
{
return _rfDomainAddress;
DataProperty* prop = (DataProperty*)property(PID_RF_DOMAIN_ADDRESS_CEMI_SERVER);
return prop->data();
}
void DeviceObject::rfDomainAddress(uint8_t* value)
{
pushByteArray(value, 6, _rfDomainAddress);
}
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;
Property* prop = property(PID_RF_DOMAIN_ADDRESS_CEMI_SERVER);
prop->write(value);
}
PropertyDescription* DeviceObject::propertyDescriptions()
{
return _propertyDescriptions;
}
uint16_t DeviceObject::saveSize()
{
return 4;
}

34
src/knx/device_object.h
View File

@ -7,24 +7,17 @@
class DeviceObject: public InterfaceObject
{
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;
DeviceObject();
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();
void orderNumber(const char* value);
const uint8_t* orderNumber();
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();
void ifObj(const uint32_t* value);
uint8_t* rfDomainAddress();
const 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};
};

2
src/knx/group_object_table_object.cpp
View File

@ -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);

2
src/knx/group_object_table_object.h
View File

@ -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;

2
src/knx/interface_object.cpp
View File

@ -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++)
{

2
src/knx/interface_object.h
View File

@ -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:

2
src/knx/ip_parameter_object.cpp
View File

@ -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;

2
src/knx/memory.cpp
View File

@ -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);

23
src/knx/property.cpp
View File

@ -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);
}

10
src/knx/property.h
View File

@ -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(uint16_t& value);
uint8_t write(uint32_t& value);
uint8_t write(uint8_t value);
uint8_t write(uint16_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;

2
src/knx/rf_medium_object.cpp
View File

@ -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;

2
src/knx/rf_medium_object.h
View File

@ -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();

2
src/knx/save_restore.h
View File

@ -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;
}

16
src/knx/table_object.cpp
View File

@ -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;
}),

16
src/knx/table_object.h
View File

@ -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;
virtual uint8_t* restore(uint8_t* buffer) override;
uint8_t* save(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 loadEventUnloaded(uint8_t* data);
void loadEventLoading(uint8_t* data);
void loadEventLoaded(uint8_t* data);
void loadEventError(uint8_t* data);
void additionalLoadControls(uint8_t* data);
void loadEvent(const uint8_t* data);
void loadEventUnloaded(const uint8_t* data);
void loadEventLoading(const uint8_t* data);
void loadEventLoaded(const uint8_t* data);
void loadEventError(const uint8_t* data);
void additionalLoadControls(const uint8_t* data);
/**
* set the ::LoadState of the interface object.
*