Mirrors/knx
1
0
Fork 0
mirror of https://github.com/thelsing/knx.git synced 2025-08-13 13:46:20 +02:00
Code Issues Packages Projects Releases Wiki Activity

-64bit (linux) pointer compatibility

Browse Source
This commit is contained in:
Bernhard 2019-10-09 20:00:36 +02:00
parent afe3ae7936
commit 92e41f3baf
17 changed files with 84 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/esp32_platform.cpp
View File

@ -84,28 +84,26 @@ int Esp32Platform::readBytes(uint8_t * buffer, uint16_t maxLen)
return len;
}
bool Esp32Platform::writeNVMemory(uint32_t addr,uint8_t data)
bool Esp32Platform::writeNVMemory(uintptr_t addr,uint8_t data)
{
*((uint8_t*)addr) = data;
return true;
}
uint8_t Esp32Platform::readNVMemory(uint32_t addr)
uint8_t Esp32Platform::readNVMemory(uintptr_t addr)
{
return *((uint8_t*)addr);
}
uint32_t Esp32Platform::allocNVMemory(uint32_t size,uint32_t ID)
uintptr_t Esp32Platform::allocNVMemory(size_t size,uint32_t ID)
{
if(size > EEPROM_EMULATION_SIZE)
fatalError();
return (uint32_t)EEPROM.getDataPtr();
return (uintptr_t)EEPROM.getDataPtr();
}
uint32_t Esp32Platform::reloadNVMemory(uint32_t ID)
uintptr_t Esp32Platform::reloadNVMemory(uint32_t ID)
{
EEPROM.begin(1024);
return (uint32_t)EEPROM.getDataPtr();
return (uintptr_t)EEPROM.getDataPtr();
}
void Esp32Platform::finishNVMemory()

8
src/esp32_platform.h
View File

@ -28,10 +28,10 @@ public:
int readBytes(uint8_t* buffer, uint16_t maxLen) override;
//memory
bool writeNVMemory(uint32_t addr,uint8_t data);
uint8_t readNVMemory(uint32_t addr);
uint32_t allocNVMemory(uint32_t size,uint32_t ID);
uint32_t reloadNVMemory(uint32_t ID);
bool writeNVMemory(uintptr_t addr,uint8_t data);
uint8_t readNVMemory(uintptr_t addr);
uintptr_t allocNVMemory(size_t size,uint32_t ID);
uintptr_t reloadNVMemory(uint32_t ID);
void finishNVMemory();
void freeNVMemory(uint32_t ID);
private:

14
src/esp_platform.cpp
View File

@ -85,28 +85,26 @@ int EspPlatform::readBytes(uint8_t * buffer, uint16_t maxLen)
return len;
}
bool EspPlatform::writeNVMemory(uint32_t addr,uint8_t data)
bool EspPlatform::writeNVMemory(uintptr_t addr,uint8_t data)
{
*((uint8_t*)addr) = data;
return true;
}
uint8_t EspPlatform::readNVMemory(uint32_t addr)
uint8_t EspPlatform::readNVMemory(uintptr_t addr)
{
return *((uint8_t*)addr);
}
uint32_t EspPlatform::allocNVMemory(uint32_t size,uint32_t ID)
uintptr_t EspPlatform::allocNVMemory(size_t size,uint32_t ID)
{
if(size > EEPROM_EMULATION_SIZE)
fatalError();
return (uint32_t)EEPROM.getDataPtr();
return (uintptr_t)EEPROM.getDataPtr();
}
uint32_t EspPlatform::reloadNVMemory(uint32_t ID)
uintptr_t EspPlatform::reloadNVMemory(uint32_t ID)
{
EEPROM.begin(1024);
return (uint32_t)EEPROM.getDataPtr();
return (uintptr_t)EEPROM.getDataPtr();
}
void EspPlatform::finishNVMemory()

8
src/esp_platform.h
View File

@ -29,10 +29,10 @@ class EspPlatform : public ArduinoPlatform
int readBytes(uint8_t* buffer, uint16_t maxLen) override;
//memory
bool writeNVMemory(uint32_t addr,uint8_t data);
uint8_t readNVMemory(uint32_t addr);
uint32_t allocNVMemory(uint32_t size,uint32_t ID);
uint32_t reloadNVMemory(uint32_t ID);
bool writeNVMemory(uintptr_t addr,uint8_t data);
uint8_t readNVMemory(uintptr_t addr);
uintptr_t allocNVMemory(size_t size,uint32_t ID);
uintptr_t reloadNVMemory(uint32_t ID);
void finishNVMemory();
void freeNVMemory(uint32_t ID);
private:

4
src/knx/application_program_object.cpp
View File

@ -85,7 +85,7 @@ uint8_t* ApplicationProgramObject::save()
return NULL;
uint8_t* buffer;
uint32_t addr =(uint32_t)(TableObject::data() - sizeof(_programVersion) - TableObject::sizeMetadata());
uintptr_t addr =(uintptr_t)(TableObject::data() - sizeof(_programVersion) - TableObject::sizeMetadata());
if(TableObject::_platform.NVMemoryType() == internalFlash)
buffer = new uint8_t[sizeof(_programVersion)];
else
@ -97,7 +97,7 @@ uint8_t* ApplicationProgramObject::save()
for(uint32_t i=0;i<sizeof(_programVersion);i++)
TableObject::_platform.writeNVMemory(addr+i, buffer[i]);
free (buffer);
delete[] buffer;
}
return TableObject::save();

10
src/knx/bau_systemB.cpp
View File

@ -141,7 +141,7 @@ void BauSystemB::memoryWriteIndication(Priority priority, HopCountType hopType,
{
if(_platform.NVMemoryType() == internalFlash){
for(uint8_t i=0;i<number;i++)
_platform.writeNVMemory((uint32_t)_platform.memoryReference() + memoryAddress+i, data[i]);
_platform.writeNVMemory((uintptr_t)_platform.memoryReference() + memoryAddress+i, data[i]);
}
else
memcpy(_platform.memoryReference() + memoryAddress, data, number);
@ -158,9 +158,10 @@ void BauSystemB::memoryReadIndication(Priority priority, HopCountType hopType, u
if(_platform.NVMemoryType() == internalFlash){
uint8_t* buffer = new uint8_t[number];
for(uint8_t i=0;i<number;i++)
buffer[i] = _platform.readNVMemory((uint32_t)_platform.memoryReference() + memoryAddress+i);
buffer[i] = _platform.readNVMemory((uintptr_t)_platform.memoryReference() + memoryAddress+i);
_appLayer.memoryReadResponse(AckRequested, priority, hopType, asap, number, memoryAddress,buffer);
delete[] buffer;
}
else{
_appLayer.memoryReadResponse(AckRequested, priority, hopType, asap, number, memoryAddress,
@ -185,8 +186,9 @@ void BauSystemB::userMemoryReadIndication(Priority priority, HopCountType hopTyp
if(_platform.NVMemoryType() == internalFlash){
uint8_t* buffer = new uint8_t[number];
for(uint8_t i=0;i<number;i++)
buffer[i] = _platform.readNVMemory((uint32_t)_platform.memoryReference() + memoryAddress+i);
buffer[i] = _platform.readNVMemory((uintptr_t)_platform.memoryReference() + memoryAddress+i);
_appLayer.userMemoryReadResponse(AckRequested, priority, hopType, asap, number, memoryAddress,buffer);
delete[] buffer;
}
else{
_appLayer.userMemoryReadResponse(AckRequested, priority, hopType, asap, number, memoryAddress,
@ -198,7 +200,7 @@ void BauSystemB::userMemoryWriteIndication(Priority priority, HopCountType hopTy
{
if(_platform.NVMemoryType() == internalFlash){
for(uint8_t i=0;i<number;i++)
_platform.writeNVMemory((uint32_t)_platform.memoryReference() + memoryAddress+i, data[i]);
_platform.writeNVMemory((uintptr_t)_platform.memoryReference() + memoryAddress+i, data[i]);
}
else{
memcpy(_platform.memoryReference() + memoryAddress, data, number);

6
src/knx/device_object.cpp
View File

@ -130,12 +130,12 @@ uint8_t* DeviceObject::save()
if(_platform.NVMemoryType() == internalFlash){
_platform.freeNVMemory(_ID);
uint32_t addr = _platform.allocNVMemory(METADATA_SIZE, _ID);
uintptr_t addr = _platform.allocNVMemory(METADATA_SIZE, _ID);
for(uint32_t i=0;i<METADATA_SIZE;i++)
for(size_t i=0;i<METADATA_SIZE;i++)
_platform.writeNVMemory(addr+i, buffer[i]);
free (buffer);
delete[] buffer;
return (uint8_t*)addr;
}

6
src/knx/ip_parameter_object.cpp
View File

@ -176,12 +176,12 @@ uint8_t* IpParameterObject::save()
if(_platform.NVMemoryType() == internalFlash){
_platform.freeNVMemory(_ID);
uint32_t addr = _platform.allocNVMemory(METADATA_SIZE, _ID);
uintptr_t addr = _platform.allocNVMemory(METADATA_SIZE, _ID);
for(uint32_t i=0;i<METADATA_SIZE;i++)
for(size_t i=0;i<METADATA_SIZE;i++)
_platform.writeNVMemory(addr+i, buffer[i]);
free (buffer);
delete[] buffer;
return (uint8_t*)addr;
}

8
src/knx/memory.cpp
View File

@ -85,7 +85,7 @@ void Memory::readRamMemory()
for (int i = 0; i < size; i++)
{
buffer = _saveRestores[i]->restore(buffer);
buffer = (uint8_t*)(((uint32_t)buffer + 3) / 4 * 4); //allign to 32bit
buffer = (uint8_t*)(((uintptr_t)buffer + 3) / 4 * 4); //allign to 32bit
}
}
@ -109,7 +109,7 @@ void Memory::writeRamMemory()
for (int i = 0; i < size; i++)
{
buffer = _saveRestores[i]->save(buffer);
buffer = (uint8_t*)(((uint32_t)buffer + 3) / 4 * 4); //allign to 32bit
buffer = (uint8_t*)(((uintptr_t)buffer + 3) / 4 * 4); //allign to 32bit
}
_platform.finishNVMemory();
_modified = false;
@ -122,7 +122,7 @@ void Memory::readExternalMemory()
{
int size = _saveCount;
volatile uint32_t addr = _platform.reloadNVMemory(BASE_ID);
volatile uintptr_t addr = _platform.reloadNVMemory(BASE_ID);
volatile uint32_t bytesToRestore;
if(addr == 0)
@ -164,7 +164,7 @@ void Memory::writeExternalMemory()
bytesToSave += _saveRestores[i]->size() + 4;
}
uint32_t addr = _platform.allocNVMemory(bytesToSave,BASE_ID);
uintptr_t addr = _platform.allocNVMemory(bytesToSave,BASE_ID);
//write valid mask
_platform.writeNVMemory(addr++,0x00);

8
src/knx/platform.h
View File

@ -36,10 +36,10 @@ class Platform
virtual int readUart() = 0;
virtual size_t readBytesUart(uint8_t* buffer, size_t length) = 0;
virtual bool writeNVMemory(uint32_t addr,uint8_t data) = 0;
virtual uint8_t readNVMemory(uint32_t addr) = 0;
virtual uint32_t allocNVMemory(uint32_t size,uint32_t ID) = 0;
virtual uint32_t reloadNVMemory(uint32_t ID) = 0;
virtual bool writeNVMemory(uintptr_t addr,uint8_t data) = 0;
virtual uint8_t readNVMemory(uintptr_t addr) = 0;
virtual uintptr_t allocNVMemory(size_t size,uint32_t ID) = 0;
virtual uintptr_t reloadNVMemory(uint32_t ID) = 0;
virtual void finishNVMemory() = 0;
virtual void freeNVMemory(uint32_t ID) = 0;

12
src/knx/table_object.cpp
View File

@ -99,9 +99,9 @@ uint8_t* TableObject::save()
if(_data == NULL)
return NULL;
uint32_t addr;
uintptr_t addr;
uint8_t* buffer;
addr =(uint32_t)(_data - METADATA_SIZE);
addr =(uintptr_t)(_data - METADATA_SIZE);
if(_platform.NVMemoryType() == internalFlash)
buffer = new uint8_t[METADATA_SIZE];
else
@ -116,7 +116,7 @@ uint8_t* TableObject::save()
for(uint32_t i=0;i<METADATA_SIZE;i++)
_platform.writeNVMemory(addr+i, buffer[i]);
free (buffer);
delete[] buffer;
}
return _dataComplete;
@ -177,8 +177,8 @@ bool TableObject::allocTable(uint32_t size, bool doFill, uint8_t fillByte)
_size = size;
if (doFill){
if(_platform.NVMemoryType() == internalFlash){
uint32_t addr = (uint32_t)_data;
for(uint32_t i=0; i<_size;i++)
uintptr_t addr = (uintptr_t)_data;
for(size_t i=0; i<_size;i++)
_platform.writeNVMemory(addr++, fillByte);
}
else{
@ -332,4 +332,4 @@ uint32_t TableObject::sizeMetadata()
void TableObject::errorCode(ErrorCode errorCode)
{
_errorCode = errorCode;
}
}

14
src/linux_platform.cpp
View File

@ -200,31 +200,31 @@ int LinuxPlatform::readBytes(uint8_t * buffer, uint16_t maxLen)
return len;
}
bool LinuxPlatform::writeNVMemory(uint32_t addr,uint8_t data)
bool LinuxPlatform::writeNVMemory(uintptr_t addr,uint8_t data)
{
*((uint8_t*)addr) = data;
return true;
}
uint8_t LinuxPlatform::readNVMemory(uint32_t addr)
uint8_t LinuxPlatform::readNVMemory(uintptr_t addr)
{
return *((uint8_t*)addr);
}
uint32_t LinuxPlatform::allocNVMemory(uint32_t size,uint32_t ID)
uintptr_t LinuxPlatform::allocNVMemory(size_t size,uint32_t ID)
{
if (_fd < 0)
doMemoryMapping();
return (uint32_t)_mappedFile + 2;
return (uintptr_t)(_mappedFile + 2);
}
uint32_t LinuxPlatform::reloadNVMemory(uint32_t ID)
uintptr_t LinuxPlatform::reloadNVMemory(uint32_t ID)
{
if (_fd < 0)
doMemoryMapping();
return (uint32_t)_mappedFile + 2;
return (uintptr_t)(_mappedFile + 2);
}
void LinuxPlatform::finishNVMemory()
@ -541,4 +541,4 @@ void LinuxPlatform::cmdLineArgs(int argc, char** argv)
memcpy(_args, argv, argc * sizeof(char*));
_args[argc] = 0;
}
#endif
#endif

10
src/linux_platform.h
View File

@ -44,10 +44,10 @@ public:
size_t readBytesUart(uint8_t *buffer, size_t length) override;
//memory
bool writeNVMemory(uint32_t addr,uint8_t data);
uint8_t readNVMemory(uint32_t addr);
uint32_t allocNVMemory(uint32_t size,uint32_t ID);
uint32_t reloadNVMemory(uint32_t ID);
bool writeNVMemory(uintptr_t addr,uint8_t data);
uint8_t readNVMemory(uintptr_t addr);
uintptr_t allocNVMemory(size_t size,uint32_t ID);
uintptr_t reloadNVMemory(uint32_t ID);
void finishNVMemory();
void freeNVMemory(uint32_t ID);
uint8_t* allocMemory(size_t size) override;
@ -66,4 +66,4 @@ public:
char** _args = 0;
};
#endif
#endif

2
src/samd_flash.cpp
View File

@ -1,3 +1,4 @@
#ifdef ARDUINO_ARCH_SAMD
#include <Arduino.h>
#include "samd_flash.h"
@ -414,3 +415,4 @@ uint8_t* SamdFlash::realloc(uint32_t size, uint32_t ID){
copyAndFree(actualBlock, (block_meta_data_t*)newBlockFlashAddr);
return (uint8_t*)(newBlockFlashAddr+sizeof(block_meta_data_t));
}
#endif /* ARDUINO_ARCH_SAMD */

2
src/samd_flash.h
View File

@ -1,6 +1,7 @@
#ifndef SAMD_FLASH_H
#define SAMD_FLASH_H
#ifdef ARDUINO_ARCH_SAMD
#include <Arduino.h>
#define PAGES_PER_ROW 4
@ -56,4 +57,5 @@ private:
uint32_t _rowBufferAddr;
volatile info_data_t* _info;
};
#endif /* ARDUINO_ARCH_SAMD */
#endif /* SAMD_FLASH_H */

32
src/samd_platform.cpp
View File

@ -25,30 +25,30 @@ void SamdPlatform::restart()
}
bool SamdPlatform::writeNVMemory(uint32_t addr,uint8_t data)
bool SamdPlatform::writeNVMemory(uintptr_t addr,uint8_t data)
{
if(Flash.write((uint8_t*)addr, data)==false)
fatalError();
return true;
}
uint8_t SamdPlatform::readNVMemory(uint32_t addr)
uint8_t SamdPlatform::readNVMemory(uintptr_t addr)
{
return Flash.read((uint8_t*)addr);
}
uint32_t SamdPlatform::allocNVMemory(uint32_t size,uint32_t ID)
uintptr_t SamdPlatform::allocNVMemory(size_t size,uint32_t ID)
{
uint32_t addr = (uint32_t)Flash.malloc(size, ID);
uintptr_t addr = (uintptr_t)Flash.malloc(size, ID);
if(addr == 0)
fatalError();
return addr;
}
uint32_t SamdPlatform::reloadNVMemory(uint32_t ID)
uintptr_t SamdPlatform::reloadNVMemory(uint32_t ID)
{
// Flash.erase();
return (uint32_t)Flash.loadBlock(ID);
return (uintptr_t)Flash.loadBlock(ID);
}
void SamdPlatform::finishNVMemory()
@ -71,27 +71,27 @@ uint8_t* SamdPlatform::memoryReference()
/*************_NVMemoryType = internalRam*************************
bool SamdPlatform::writeNVMemory(uint32_t addr,uint8_t data)
bool SamdPlatform::writeNVMemory(uintptr_t addr,uint8_t data)
{
*((uint8_t*)addr) = data;
return true;
}
uint8_t SamdPlatform::readNVMemory(uint32_t addr)
uint8_t SamdPlatform::readNVMemory(uintptr_t addr)
{
return *((uint8_t*)addr);
}
uint32_t SamdPlatform::allocNVMemory(uint32_t size,uint32_t ID)
uintptr_t SamdPlatform::allocNVMemory(size_t size,uint32_t ID)
{
if(size > EEPROM_EMULATION_SIZE)
fatalError();
return (uint32_t)EEPROM.getDataPtr();
return (uintptr_t)EEPROM.getDataPtr();
}
uint32_t SamdPlatform::reloadNVMemory(uint32_t ID)
uintptr_t SamdPlatform::reloadNVMemory(uint32_t ID)
{
return (uint32_t)EEPROM.getDataPtr();
return (uintptr_t)EEPROM.getDataPtr();
}
void SamdPlatform::finishNVMemory()
@ -105,25 +105,25 @@ void SamdPlatform::freeNVMemory(uint32_t ID)
/*
/*************_NVMemoryType = external*************************
bool SamdPlatform::writeNVMemory(uint32_t addr,uint8_t data)
bool SamdPlatform::writeNVMemory(uintptr_t addr,uint8_t data)
{
EEPROM.write(addr-1, data);
return true;
}
uint8_t SamdPlatform::readNVMemory(uint32_t addr)
uint8_t SamdPlatform::readNVMemory(uintptr_t addr)
{
return EEPROM.read(addr-1);
}
uint32_t SamdPlatform::allocNVMemory(uint32_t size,uint32_t ID)
uintptr_t SamdPlatform::allocNVMemory(size_t size,uint32_t ID)
{
if(size > EEPROM_EMULATION_SIZE)
fatalError();
return 1;
}
uint32_t SamdPlatform::reloadNVMemory(uint32_t ID)
uintptr_t SamdPlatform::reloadNVMemory(uint32_t ID)
{
return 1;
}

8
src/samd_platform.h
View File

@ -11,10 +11,10 @@ public:
SamdPlatform( HardwareSerial* s);
void restart();
bool writeNVMemory(uint32_t addr,uint8_t data);
uint8_t readNVMemory(uint32_t addr);
uint32_t allocNVMemory(uint32_t size,uint32_t ID);
uint32_t reloadNVMemory(uint32_t ID);
bool writeNVMemory(uintptr_t addr,uint8_t data);
uint8_t readNVMemory(uintptr_t addr);
uintptr_t allocNVMemory(size_t size,uint32_t ID);
uintptr_t reloadNVMemory(uint32_t ID);
void finishNVMemory();
void freeNVMemory(uint32_t ID);
uint8_t* memoryReference();