private/hsb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fixed some major issues with RAM shortage. Also moved the cached storage to a MALLOC design instead of fixed memory usage. Using freertos porteds malloc and free required to move to HEAP4 to make sure memory does not get fragmented.

Browse Source 
Resized nearly all task stacks

Also: 
- Menu fixes for insertion. Almost done, just need to fix the negative voltage insertion for mcp and cathode
- Added Device parameters, must be filled in

git-svn-id: https://svn.vbchaos.nl/svn/hsb/trunk@271 05563f52-14a8-4384-a975-3d1654cca0fa
This commit is contained in:
mmi
2017-11-07 15:50:25 +00:00
parent 27755498e6
commit 17207a3a4b
32 changed files with 1833 additions and 280 deletions
Download Patch File Download Diff File Expand all files Collapse all files

169
S - Software/0 - HSB MRTS Kathode-MCP/3 - Implementation/0 - Code/HAL/src/CachedStorage.c
View File

@@ -60,7 +60,7 @@
// -----------------------------------------------------------------------------
ErrorStatus CachedStorage_construct(struct CachedStorage* self, struct MemoryDevice* memoryDevice, unsigned int pageNumber)
ErrorStatus CachedStorage_construct(struct CachedStorage* self, struct MemoryDevice* memoryDevice, unsigned int pageNumber, size_t cacheSize)
{
ErrorStatus returnValue = SUCCESS;
if (!self->initialized)
@@ -82,10 +82,39 @@ ErrorStatus CachedStorage_construct(struct CachedStorage* self, struct MemoryDev
self->memoryDevice = memoryDevice;
}
if (returnValue == SUCCESS)
{
self->cacheSize = CACHED_STORAGE_PAGESIZE / 4;
MemoryDevice_read(self->memoryDevice, (uint32_t*)self->storage, self->memoryDevice->startAddress + self->memoryDevice->pageSize * self->pageNumber, self->cacheSize);
self->cacheSize = cacheSize;
self->tempBuffer = pvPortMalloc(cacheSize * 4);
if (self->tempBuffer == NULL)
{
returnValue = ERROR;
LOGGER_ERROR(mainLog, "Failed to malloc to tempbuffer");
}
else
{
LOGGER_INFO(mainLog, "Created tempBuffer memory with size %x at address %p", self->cacheSize, self->tempBuffer);
}
}
if (returnValue == SUCCESS)
{
self->storage = pvPortMalloc(cacheSize * 4);
if (self->storage == NULL)
{
returnValue = ERROR;
LOGGER_ERROR(mainLog, "Failed to malloc to storage");
}
else
{
LOGGER_INFO(mainLog, "Created storage memory with size %x at address %p", self->cacheSize, self->storage);
}
}
if (returnValue == SUCCESS)
{
MemoryDevice_read(self->memoryDevice, self->storage, self->memoryDevice->startAddress + self->memoryDevice->pageSize * self->pageNumber, self->cacheSize);
self->initialized = true;
self->dirty = false;
@@ -99,87 +128,22 @@ void CachedStorage_destruct(struct CachedStorage* self)
{
if (self->initialized)
{
vPortFree(self->storage);
vPortFree(self->tempBuffer);
LOGGER_INFO(mainLog, "Free'd buffers");
self->initialized = false;
}
}
void CachedStorage_writeByte(struct CachedStorage* self, int offset, uint8_t value)
{
if (self->initialized)
{
if(offset < CACHED_STORAGE_PAGESIZE)
{
if(value != self->storage[offset])
{
self->storage[offset] = value;
self->dirty = true;
}
}
}
}
void CachedStorage_writeHalfWord(struct CachedStorage* self, int offset, uint16_t _value)
{
if (self->initialized)
{
if(offset < CACHED_STORAGE_PAGESIZE - 1)
{
uint16_t value = _value;
if((value & 0xFF) != self->storage[offset + 1])
{
self->storage[offset + 1] = value & 0xFF;
self->dirty = true;
}
value >>= 8;
if((value & 0xFF) != self->storage[offset])
{
self->storage[offset] = value & 0xFF;
self->dirty = true;
}
}
}
}
void CachedStorage_writeWord(struct CachedStorage* self, int offset, uint32_t _value)
{
if (self->initialized)
{
if(offset < CACHED_STORAGE_PAGESIZE - 3)
if(offset < self->cacheSize)
{
uint32_t value = _value;
if((value & 0xFF) != self->storage[offset + 3])
{
self->storage[offset + 3] = value & 0xFF;
self->dirty = true;
}
value >>= 8;
if((value & 0xFF) != self->storage[offset + 2])
{
self->storage[offset + 2] = value & 0xFF;
self->dirty = true;
}
value >>= 8;
if((value & 0xFF) != self->storage[offset + 1])
{
self->storage[offset + 1] = value & 0xFF;
self->dirty = true;
}
value >>= 8;
if((value & 0xFF) != self->storage[offset])
{
self->storage[offset] = value & 0xFF;
self->dirty = true;
}
self->storage[offset] = _value;
self->dirty = true;
}
}
}
@@ -188,19 +152,23 @@ void CachedStorage_writeBlob(struct CachedStorage* self, int offset, const void*
{
if (self->initialized)
{
if(offset + blobSize <= CACHED_STORAGE_PAGESIZE)
if(offset + blobSize <= self->cacheSize)
{
memcpy(&self->storage[offset], blob, blobSize);
memcpy(&self->storage[offset], blob, blobSize * 4);
self->dirty = true;
}
else
{
LOGGER_ERROR(mainLog, "WriteBlob failed at offset %d, blobsize %d --- %p", offset, blobSize, self->storage[offset]);
}
}
}
uint8_t CachedStorage_readByte(struct CachedStorage* self, int offset)
uint32_t CachedStorage_readWord(struct CachedStorage* self, int offset)
{
if (self->initialized)
{
if(offset < CACHED_STORAGE_PAGESIZE)
if(offset < self->cacheSize)
{
return self->storage[offset];
}
@@ -215,54 +183,19 @@ uint8_t CachedStorage_readByte(struct CachedStorage* self, int offset)
}
}
uint16_t CachedStorage_readHalfWord(struct CachedStorage* self, int offset)
{
if (self->initialized)
{
if(offset < CACHED_STORAGE_PAGESIZE - 1)
{
return self->storage[offset + 1] | (self->storage[offset] << 8);
}
else
{
return 0;
}
}
else
{
return 0;
}
}
uint32_t CachedStorage_readWord(struct CachedStorage* self, int offset)
{
if (self->initialized)
{
if(offset < CACHED_STORAGE_PAGESIZE - 3)
{
return self->storage[offset + 3] | (self->storage[offset + 2] << 8) | (self->storage[offset + 1] << 16) | (self->storage[offset] << 24);
}
else
{
return 0;
}
}
else
{
return 0;
}
}
const void* CachedStorage_readBlob(struct CachedStorage* self, int offset)
{
if (self->initialized)
{
if(offset < CACHED_STORAGE_PAGESIZE)
if(offset < self->cacheSize)
{
return &self->storage[offset];
}
else
{
LOGGER_ERROR(mainLog, "ReadBlob failed at offset %d --- %p", offset, self->storage[offset]);
return NULL;
}
}
@@ -278,16 +211,16 @@ void CachedStorage_commit(struct CachedStorage* self)
{
if(self->dirty)
{
MemoryDevice_read(self->memoryDevice, (uint32_t*)self->tempBuffer, self->memoryDevice->startAddress + self->memoryDevice->pageSize * self->pageNumber, self->cacheSize);
MemoryDevice_read(self->memoryDevice, self->tempBuffer, self->memoryDevice->startAddress + self->memoryDevice->pageSize * self->pageNumber, self->cacheSize);
if(memcmp(self->tempBuffer, self->storage, (sizeof(self->storage) / sizeof(self->storage[0]))) != 0)
if(memcmp(self->tempBuffer, self->storage, (self->cacheSize * 4)) != 0)
{
if (self->memoryDevice->needsEraseBeforeWrite)
{
MemoryDevice_erasePage(self->memoryDevice, self->pageNumber);
}
MemoryDevice_write(self->memoryDevice, (uint32_t*)self->storage, self->memoryDevice->startAddress + self->memoryDevice->pageSize * self->pageNumber, self->cacheSize);
MemoryDevice_write(self->memoryDevice, self->storage, self->memoryDevice->startAddress + self->memoryDevice->pageSize * self->pageNumber, self->cacheSize);
}
else
{