Mirrors/knx
1
0
Fork 0
mirror of https://github.com/thelsing/knx.git synced 2025-08-22 13:46:21 +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; return len;
} }
bool Esp32Platform::writeNVMemory(uint32_t addr,uint8_t data) bool Esp32Platform::writeNVMemory(uintptr_t addr,uint8_t data)
{ {
*((uint8_t*)addr) = data; *((uint8_t*)addr) = data;
return true; return true;
} }
uint8_t Esp32Platform::readNVMemory(uint32_t addr) uint8_t Esp32Platform::readNVMemory(uintptr_t addr)
{ {
return *((uint8_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) return (uintptr_t)EEPROM.getDataPtr();
fatalError();
return (uint32_t)EEPROM.getDataPtr();
} }
uint32_t Esp32Platform::reloadNVMemory(uint32_t ID) uintptr_t Esp32Platform::reloadNVMemory(uint32_t ID)
{ {
EEPROM.begin(1024); EEPROM.begin(1024);
return (uint32_t)EEPROM.getDataPtr(); return (uintptr_t)EEPROM.getDataPtr();
} }
void Esp32Platform::finishNVMemory() void Esp32Platform::finishNVMemory()

8
src/esp32_platform.h
View File

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

14
src/esp_platform.cpp
View File

@ -85,28 +85,26 @@ int EspPlatform::readBytes(uint8_t * buffer, uint16_t maxLen)
return len; return len;
} }
bool EspPlatform::writeNVMemory(uint32_t addr,uint8_t data) bool EspPlatform::writeNVMemory(uintptr_t addr,uint8_t data)
{ {
*((uint8_t*)addr) = data; *((uint8_t*)addr) = data;
return true; return true;
} }
uint8_t EspPlatform::readNVMemory(uint32_t addr) uint8_t EspPlatform::readNVMemory(uintptr_t addr)
{ {
return *((uint8_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) return (uintptr_t)EEPROM.getDataPtr();
fatalError();
return (uint32_t)EEPROM.getDataPtr();
} }
uint32_t EspPlatform::reloadNVMemory(uint32_t ID) uintptr_t EspPlatform::reloadNVMemory(uint32_t ID)
{ {
EEPROM.begin(1024); EEPROM.begin(1024);
return (uint32_t)EEPROM.getDataPtr(); return (uintptr_t)EEPROM.getDataPtr();
} }
void EspPlatform::finishNVMemory() 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; int readBytes(uint8_t* buffer, uint16_t maxLen) override;
//memory //memory
bool writeNVMemory(uint32_t addr,uint8_t data); bool writeNVMemory(uintptr_t addr,uint8_t data);
uint8_t readNVMemory(uint32_t addr); uint8_t readNVMemory(uintptr_t addr);
uint32_t allocNVMemory(uint32_t size,uint32_t ID); uintptr_t allocNVMemory(size_t size,uint32_t ID);
uint32_t reloadNVMemory(uint32_t ID); uintptr_t reloadNVMemory(uint32_t ID);
void finishNVMemory(); void finishNVMemory();
void freeNVMemory(uint32_t ID); void freeNVMemory(uint32_t ID);
private: private:

4
src/knx/application_program_object.cpp
View File

@ -85,7 +85,7 @@ uint8_t* ApplicationProgramObject::save()
return NULL; return NULL;
uint8_t* buffer; 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) if(TableObject::_platform.NVMemoryType() == internalFlash)
buffer = new uint8_t[sizeof(_programVersion)]; buffer = new uint8_t[sizeof(_programVersion)];
else else
@ -97,7 +97,7 @@ uint8_t* ApplicationProgramObject::save()
for(uint32_t i=0;i<sizeof(_programVersion);i++) for(uint32_t i=0;i<sizeof(_programVersion);i++)
TableObject::_platform.writeNVMemory(addr+i, buffer[i]); TableObject::_platform.writeNVMemory(addr+i, buffer[i]);
free (buffer); delete[] buffer;
} }
return TableObject::save(); 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){ if(_platform.NVMemoryType() == internalFlash){
for(uint8_t i=0;i<number;i++) 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 else
memcpy(_platform.memoryReference() + memoryAddress, data, number); memcpy(_platform.memoryReference() + memoryAddress, data, number);
@ -158,9 +158,10 @@ void BauSystemB::memoryReadIndication(Priority priority, HopCountType hopType, u
if(_platform.NVMemoryType() == internalFlash){ if(_platform.NVMemoryType() == internalFlash){
uint8_t* buffer = new uint8_t[number]; uint8_t* buffer = new uint8_t[number];
for(uint8_t i=0;i<number;i++) 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); _appLayer.memoryReadResponse(AckRequested, priority, hopType, asap, number, memoryAddress,buffer);
delete[] buffer;
} }
else{ else{
_appLayer.memoryReadResponse(AckRequested, priority, hopType, asap, number, memoryAddress, _appLayer.memoryReadResponse(AckRequested, priority, hopType, asap, number, memoryAddress,
@ -185,8 +186,9 @@ void BauSystemB::userMemoryReadIndication(Priority priority, HopCountType hopTyp
if(_platform.NVMemoryType() == internalFlash){ if(_platform.NVMemoryType() == internalFlash){
uint8_t* buffer = new uint8_t[number]; uint8_t* buffer = new uint8_t[number];
for(uint8_t i=0;i<number;i++) 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); _appLayer.userMemoryReadResponse(AckRequested, priority, hopType, asap, number, memoryAddress,buffer);
delete[] buffer;
} }
else{ else{
_appLayer.userMemoryReadResponse(AckRequested, priority, hopType, asap, number, memoryAddress, _appLayer.userMemoryReadResponse(AckRequested, priority, hopType, asap, number, memoryAddress,
@ -198,7 +200,7 @@ void BauSystemB::userMemoryWriteIndication(Priority priority, HopCountType hopTy
{ {
if(_platform.NVMemoryType() == internalFlash){ if(_platform.NVMemoryType() == internalFlash){
for(uint8_t i=0;i<number;i++) 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{ else{
memcpy(_platform.memoryReference() + memoryAddress, data, number); 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){ if(_platform.NVMemoryType() == internalFlash){
_platform.freeNVMemory(_ID); _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]); _platform.writeNVMemory(addr+i, buffer[i]);
free (buffer); delete[] buffer;
return (uint8_t*)addr; 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){ if(_platform.NVMemoryType() == internalFlash){
_platform.freeNVMemory(_ID); _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]); _platform.writeNVMemory(addr+i, buffer[i]);
free (buffer); delete[] buffer;
return (uint8_t*)addr; 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++) for (int i = 0; i < size; i++)
{ {
buffer = _saveRestores[i]->restore(buffer); 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++) for (int i = 0; i < size; i++)
{ {
buffer = _saveRestores[i]->save(buffer); 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(); _platform.finishNVMemory();
_modified = false; _modified = false;
@ -122,7 +122,7 @@ void Memory::readExternalMemory()
{ {
int size = _saveCount; int size = _saveCount;
volatile uint32_t addr = _platform.reloadNVMemory(BASE_ID); volatile uintptr_t addr = _platform.reloadNVMemory(BASE_ID);
volatile uint32_t bytesToRestore; volatile uint32_t bytesToRestore;
if(addr == 0) if(addr == 0)
@ -164,7 +164,7 @@ void Memory::writeExternalMemory()
bytesToSave += _saveRestores[i]->size() + 4; bytesToSave += _saveRestores[i]->size() + 4;
} }
uint32_t addr = _platform.allocNVMemory(bytesToSave,BASE_ID); uintptr_t addr = _platform.allocNVMemory(bytesToSave,BASE_ID);
//write valid mask //write valid mask
_platform.writeNVMemory(addr++,0x00); _platform.writeNVMemory(addr++,0x00);

8
src/knx/platform.h
View File

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

10
src/knx/table_object.cpp
View File

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

12
src/linux_platform.cpp
View File

@ -200,31 +200,31 @@ int LinuxPlatform::readBytes(uint8_t * buffer, uint16_t maxLen)
return len; return len;
} }
bool LinuxPlatform::writeNVMemory(uint32_t addr,uint8_t data) bool LinuxPlatform::writeNVMemory(uintptr_t addr,uint8_t data)
{ {
*((uint8_t*)addr) = data; *((uint8_t*)addr) = data;
return true; return true;
} }
uint8_t LinuxPlatform::readNVMemory(uint32_t addr) uint8_t LinuxPlatform::readNVMemory(uintptr_t addr)
{ {
return *((uint8_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) if (_fd < 0)
doMemoryMapping(); 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) if (_fd < 0)
doMemoryMapping(); doMemoryMapping();
return (uint32_t)_mappedFile + 2; return (uintptr_t)(_mappedFile + 2);
} }
void LinuxPlatform::finishNVMemory() void LinuxPlatform::finishNVMemory()

8
src/linux_platform.h
View File

@ -44,10 +44,10 @@ public:
size_t readBytesUart(uint8_t *buffer, size_t length) override; size_t readBytesUart(uint8_t *buffer, size_t length) override;
//memory //memory
bool writeNVMemory(uint32_t addr,uint8_t data); bool writeNVMemory(uintptr_t addr,uint8_t data);
uint8_t readNVMemory(uint32_t addr); uint8_t readNVMemory(uintptr_t addr);
uint32_t allocNVMemory(uint32_t size,uint32_t ID); uintptr_t allocNVMemory(size_t size,uint32_t ID);
uint32_t reloadNVMemory(uint32_t ID); uintptr_t reloadNVMemory(uint32_t ID);
void finishNVMemory(); void finishNVMemory();
void freeNVMemory(uint32_t ID); void freeNVMemory(uint32_t ID);
uint8_t* allocMemory(size_t size) override; uint8_t* allocMemory(size_t size) override;

2
src/samd_flash.cpp
View File

@ -1,3 +1,4 @@
#ifdef ARDUINO_ARCH_SAMD
#include <Arduino.h> #include <Arduino.h>
#include "samd_flash.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); copyAndFree(actualBlock, (block_meta_data_t*)newBlockFlashAddr);
return (uint8_t*)(newBlockFlashAddr+sizeof(block_meta_data_t)); 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 #ifndef SAMD_FLASH_H
#define SAMD_FLASH_H #define SAMD_FLASH_H
#ifdef ARDUINO_ARCH_SAMD
#include <Arduino.h> #include <Arduino.h>
#define PAGES_PER_ROW 4 #define PAGES_PER_ROW 4
@ -56,4 +57,5 @@ private:
uint32_t _rowBufferAddr; uint32_t _rowBufferAddr;
volatile info_data_t* _info; volatile info_data_t* _info;
}; };
#endif /* ARDUINO_ARCH_SAMD */
#endif /* SAMD_FLASH_H */ #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) if(Flash.write((uint8_t*)addr, data)==false)
fatalError(); fatalError();
return true; return true;
} }
uint8_t SamdPlatform::readNVMemory(uint32_t addr) uint8_t SamdPlatform::readNVMemory(uintptr_t addr)
{ {
return Flash.read((uint8_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) if(addr == 0)
fatalError(); fatalError();
return addr; return addr;
} }
uint32_t SamdPlatform::reloadNVMemory(uint32_t ID) uintptr_t SamdPlatform::reloadNVMemory(uint32_t ID)
{ {
// Flash.erase(); // Flash.erase();
return (uint32_t)Flash.loadBlock(ID); return (uintptr_t)Flash.loadBlock(ID);
} }
void SamdPlatform::finishNVMemory() void SamdPlatform::finishNVMemory()
@ -71,27 +71,27 @@ uint8_t* SamdPlatform::memoryReference()
/*************_NVMemoryType = internalRam************************* /*************_NVMemoryType = internalRam*************************
bool SamdPlatform::writeNVMemory(uint32_t addr,uint8_t data) bool SamdPlatform::writeNVMemory(uintptr_t addr,uint8_t data)
{ {
*((uint8_t*)addr) = data; *((uint8_t*)addr) = data;
return true; return true;
} }
uint8_t SamdPlatform::readNVMemory(uint32_t addr) uint8_t SamdPlatform::readNVMemory(uintptr_t addr)
{ {
return *((uint8_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) if(size > EEPROM_EMULATION_SIZE)
fatalError(); 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() void SamdPlatform::finishNVMemory()
@ -105,25 +105,25 @@ void SamdPlatform::freeNVMemory(uint32_t ID)
/* /*
/*************_NVMemoryType = external************************* /*************_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); EEPROM.write(addr-1, data);
return true; return true;
} }
uint8_t SamdPlatform::readNVMemory(uint32_t addr) uint8_t SamdPlatform::readNVMemory(uintptr_t addr)
{ {
return EEPROM.read(addr-1); 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) if(size > EEPROM_EMULATION_SIZE)
fatalError(); fatalError();
return 1; return 1;
} }
uint32_t SamdPlatform::reloadNVMemory(uint32_t ID) uintptr_t SamdPlatform::reloadNVMemory(uint32_t ID)
{ {
return 1; return 1;
} }

8
src/samd_platform.h
View File

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