Buongiorno a chi mi legge
Con questo codice
scritto con Arduino IDE 2.3.6 e caricato su un Arduino Nano Clone old bootloader
mi succede che se salvo sulla Eeprom fino a 32 records di 8 bytes tutto funziona
correttamente, se provo a salvare 33 o più records i dati dei successivi ai 32 vanno a sovrascrivere quelli precedenti partendo dai primi (come se fosse un page overflow ma non mi pare che sia questo il caso)
allego il codice che uso per scrivere e quello che uso per leggere i dati sulla Eeprom
#include <Wire.h>
#include <AT24C256.h>
AT24C256 eeprom(0x50);
const long intervalSensor = 25; // intervallo di lettura del sensore di pressione (millisecondi)
uint32_t currentMillis = 0;
uint32_t previousMillisSensor = 0;
uint16_t recordsCount = 0;
uint16_t maxRecordsCount = 32;
uint32_t myMillis = 0; //|'
uint16_t pressione = 0; //| valori di processo
float millimetri = 0; //|,
bool finito = false;
//-----------------------------------------------------------------------------------
void setup() {
Serial.begin(9600);
delay(100);
Serial.println();
Serial.println("READY");
}
//----------------------------------------------------------------------------------
void loop() {
if (recordsCount < maxRecordsCount) {
currentMillis = millis();
if (currentMillis - previousMillisSensor >= intervalSensor) {
previousMillisSensor = currentMillis;
myMillis = recordsCount * 100;
pressione = recordsCount * 10;
millimetri = millimetri + 0.25;
recordRec(recordsCount, pressione, myMillis, millimetri);
recordsCount++;
}
} else if (recordsCount >= maxRecordsCount) {
if (!finito) {
Serial.println("finito");
finito = true;
}
}
}
void recordRec(uint16_t recordNumber, uint16_t pressione, uint32_t myMillis, float millimetri) {
// questa parte è poco elegante ma con bitshift non sono pratico
uint8_t bytePressione[2]; // 2 byte per memorizzare il valore ADC del sensore di pressione 1 = MSB/0=LSB
for (uint8_t i = 0; i < 8; i++) {
bitWrite(bytePressione[0], i, bitRead(pressione, i));
}
for (uint8_t i = 0; i < 8; i++) {
bitWrite(bytePressione[1], i, bitRead(pressione, i + 8));
}
uint8_t byteMillis[4]; // 4 byte per memorizzare i millisecondi 3=MSB /2/1/ 0=LSB
for (uint8_t x = 0; x < 4; x++) {
for (uint8_t i = 0; i < 8; i++) {
bitWrite(byteMillis[x], i, bitRead(myMillis, i + (x * 8)));
}
}
uint8_t mmInt = (uint8_t)millimetri; // tronca la parte decimale PARTE INTERA
float mmDec = millimetri - mmInt; // ricava la sola parte decimale PARTE DECIMALE
mmDec = mmDec * 100.0; // la moltiplica per 100 (rende interi due decimali)
uint8_t mmDecX100 = round(mmDec); // toglie eventuali decimali oltre i due
uint8_t memArray[8];
memArray[0] = byteMillis[0];
memArray[1] = byteMillis[1];
memArray[2] = byteMillis[2];
memArray[3] = byteMillis[3];
memArray[4] = bytePressione[0];
memArray[5] = bytePressione[1];
memArray[6] = mmDecX100;
memArray[7] = mmInt;
uint16_t moltiplicatore = 8; // cosi mi assicuro di passare un numero a 2 byte
uint16_t memoryAddr = recordNumber * moltiplicatore; // 1 record = 8 byte
eeprom.write(memoryAddr, (uint8_t*)memArray, sizeof(memArray));
delay(5);
}
e leggo con questo
#include <AT24C256.h>
AT24C256 eeprom(0x50);
uint8_t message[8];
uint16_t indirizzoEeprom = 0;
uint16_t howManyRecords = 33; // 8 byte per record
uint16_t moltiplicatore = 8;
void setup() {
Serial.begin(9600);
delay(500);
Serial.println("READY !!");
Serial.println("reading eeprom");
for (uint16_t i = 0; i < howManyRecords; i++) {
indirizzoEeprom = i * moltiplicatore;
eeprom.read(indirizzoEeprom, (uint8_t*)message, sizeof(message));
Serial.print("Indirizzo di partenza : ");
Serial.print(indirizzoEeprom);
for (uint8_t i = 0; i < 8; i++) {
Serial.print(" - ");
Serial.print(message[i]);
}
Serial.println();
}
}
void loop() {}
Sicuramente ho preso cipolla per ampolla da qualche parte, ma non riesco a venirne a capo ed avrei bisogno di registrare un migliaio di records in questa maniera.
p.s. : allegherei gli output del monitor seriale ma non so come si fa
