void PrNetRomManager::printPage(int page) {
Serial.println(page);
data *p = (data*)ADDRESS_OF_PAGE(page);
for(int i = 0; i < MAX_ROWS; i++) {
printf("%d\n", p->data[i]);
}
}
bool storer_test()
{
storerMode = STORER_INIT;
debug_log("Erasing first page...\r\n");
erasePageOfFlash(FIRST_PAGE);
while (flashWorking);
debug_log("Writing a value to flash...\r\n");
uint32_t* addr = ADDRESS_OF_PAGE(FIRST_PAGE);
uint32_t value = 0x42;
writeBlockToFlash(addr, &value, 1); // write one word to FLASH
while (flashWorking);
uint32_t readVal1 = *addr;
uint32_t readVal2 = *(addr+1);
if (readVal1 != value) {
debug_log("***Read wrong value? Wrote 0x%X, read 0x%X.\r\n",(unsigned int)value,(unsigned int)readVal1);
return false;
}
if (readVal2 != 0xffffffffUL) {
debug_log("***Not erased? Read 0x%X from erased memory.\r\n",(unsigned int)readVal2);
return false;
}
return true;
}
struct prnet_config PrNetRomManager::loadConfig() {
prnet_config *p = (prnet_config*)ADDRESS_OF_PAGE(SETTINGS_FLASH_PAGE);
struct prnet_config a;
a._curflashpage = p->_curflashpage;
a._deviceID = p->_deviceID;
a._pagecounter = p->_pagecounter;
return a;
}
int PrNetRomManager::writePartialPage(int page, struct data values) {
data *p = (data*) ADDRESS_OF_PAGE(page);
int rc = flashWriteBlock(p, &values, sizeof(values));
if( rc == 0) {
return 0;
} else {
return rc;
}
}
int PrNetRomManager::updateConfig(struct prnet_config c) {
data *p = (data*) ADDRESS_OF_PAGE(SETTINGS_FLASH_PAGE);
return flashWriteBlock(p, &c, sizeof(c));
}
void PrNetRomManager::loadPage(int page) {
data *p = (data*)ADDRESS_OF_PAGE(page);
for(int i = 0; i < MAX_ROWS; i++) {
table.data[i] = p->data[i];
}
}
void storer_init()
{
storerMode = STORER_INIT;
store.from = 0;
store.to = 0;
debug_log("-storer initialization-\r\n");
unsigned long lastStoredTime = MODERN_TIME;
for (int c = 0; c <= LAST_FLASH_CHUNK; c++) {
mic_chunk_t* chunkPtr = (mic_chunk_t*)ADDRESS_OF_CHUNK(c);
unsigned long timestamp = chunkPtr->timestamp;
unsigned long check = chunkPtr->check;
//is the timestamp possibly valid?
if (timestamp < FUTURE_TIME && timestamp > MODERN_TIME) {
//is it a completely stored chunk?
if (timestamp == check || check == CHECK_TRUNC) {
//is it later than the latest stored one found so far?
if (timestamp > lastStoredTime) {
store.to = c; //keep track of latest stored chunk
lastStoredTime = timestamp;
}
}
}
}
if (lastStoredTime == MODERN_TIME) { // no valid chunk found
debug_log(" No stored chunks found. Will start from chunk 0.\r\n");
store.to = LAST_FLASH_CHUNK; // will advance to chunk 0 below.
}
else {
debug_log(" Last stored chunk: %d at time: 0x%lX\r\n", store.to, lastStoredTime);
//printStorerChunk(store.to);
}
debug_log(" Initializing FLASH for storage...\r\n");
int newChunk = (store.to < LAST_FLASH_CHUNK) ? store.to+1 : 0; // next chunk in FLASH (first unused chunk)
unsigned char oldPage = PAGE_OF_CHUNK(store.to);
unsigned char newPage = PAGE_OF_CHUNK(newChunk);
// If new chunk is on a new page, we can just erase the whole page.
if (oldPage != newPage) {
debug_log(" erase pg%d.\r\n",(int)newPage);
nrf_delay_ms(20);
erasePageOfFlash(newPage);
while(flashWorking);
}
// If new chunk is on same page as old data, we need to erase while preserving the old data
else {
uint32_t* oldChunkAddr = ADDRESS_OF_CHUNK(store.to); // address of latest stored data
uint32_t* pageAddr = ADDRESS_OF_PAGE(newPage); // address of beginning of current page
int bytesToErase = (int)(oldChunkAddr) - (int)(pageAddr); // how many bytes of current page we need to erase
int chunksToSave = (BYTES_PER_PAGE - bytesToErase)/CHUNK_SIZE; // how many old chunks are in this page
UNUSED_VARIABLE(chunksToSave);
debug_log(" pg%d (%d chunks)-->RAM...", newPage, chunksToSave);
uint32_t temp[WORDS_PER_PAGE]; // temporary buffer for page
memcpy(temp, pageAddr, BYTES_PER_PAGE); // copy old data to buffer
debug_log("clear %dbytes...", bytesToErase);
memset(temp, 0xff, bytesToErase); // clear unused portion of page in buffer
debug_log("erase pg%d...",(int)newPage);
nrf_delay_ms(20);
erasePageOfFlash(newPage); // erase page
while(flashWorking);
debug_log("restore data...\r\n");
nrf_delay_ms(10);
writeBlockToFlash(pageAddr, temp, WORDS_PER_PAGE); // replace data from buffer
while(flashWorking);
}
store.to = newChunk;
debug_log(" Ready to store to chunk %d.\r\n",newChunk);
store.extFrom = 0;
// We need to find the most recent stored chunk, to start storing after it
scan_header_t header;
scan_tail_t tail;
ext_eeprom_wait();
store.extTo = EXT_FIRST_DATA_CHUNK;
unsigned long lastStoredTimestamp = 0;
for (int i = EXT_FIRST_DATA_CHUNK; i <= EXT_LAST_CHUNK; i++) {
unsigned int addr = EXT_ADDRESS_OF_CHUNK(i);
ext_eeprom_read(addr,header.buf,sizeof(header.buf)); // Beginning of the chunk
ext_eeprom_wait();
ext_eeprom_read(addr+EXT_CHUNK_SIZE-4,tail.buf,sizeof(tail.buf)); // End of the chunk
ext_eeprom_wait();
// Print all written chunks
/*if(header.timestamp != 0xFFFFFFFFUL)
{
debug_log("CH: %d,TS: %X\r\n",i,(int)header.timestamp);
nrf_delay_ms(2);
} */
// is it a completely stored scan result chunk?
if (header.timestamp > MODERN_TIME && header.timestamp < FUTURE_TIME) {
if (tail.check == header.timestamp || tail.check == CHECK_TRUNC || tail.check == CHECK_CONTINUE) {
// is it the most recent one found yet?
if (header.timestamp >= lastStoredTimestamp) {
lastStoredTimestamp = header.timestamp;
store.extTo = i;
}
}
}
}
if (lastStoredTimestamp == 0) {
debug_log(" No stored scans found.\r\n");
}
else {
debug_log(" Last stored scan in chunk %d, timestamp %X.\r\n",(int)store.extTo,(int)lastStoredTimestamp);
}
store.extTo = (store.extTo < EXT_LAST_CHUNK) ? store.extTo+1 : EXT_FIRST_DATA_CHUNK;
//store.extFrom = 0;
//store.extTo = EXT_FIRST_DATA_CHUNK;
ext_eeprom_global_unprotect();
ext_eeprom_wait();
storerMode = STORER_IDLE;
}
