Buongiorno a tutti,
da qualche giorno sto battendo la testa su un problema alquanto ambiguo...
Sappiamo tutti che in C le variabili (che siano singole, array ecc.) vengono allocate e deallocate in memoria stack automaticamente, contrariamente a quanto succede in caso di occupazione dinamica della memoria heap (istruzioni: malloc/ free in C e new/delete in C++).
Ho realizzato un software che deve leggere parametri da una SD card, con una directory contenente 12 file di testo, ciascuno contenente un valore decimale in formato carattere (di diversa lunghezza; alcuni contengono solo un numero singolo, altri file contengono numeri formati da più cifre).
So che ci sono metodi sicuramente migliori per effettuare storage di variabili anche su un singolo file di testo ma per ora poco importa poichè sono in fase di test.
Fin qui tutto ok, il problema sorge quando devo leggere i dati dai file di testo.
Quello che faccio io è in sostanza aprire la directory e il file di testo da cui voglio estrarre l'informazione numerica, inserirla carattere per carattere in un vettore STATICO (e qua sottolineo statico perchè è importante da tenere a mente). una volta ottenuto il vettore statico contenente il numero, viene convertito con l'apposita funzioe sscanf(vettore, "%d", &variabile).
In questo modo riesco a recepire un dato numerico sottoforma di stringa di caratteri contenuto sul file di testo carattere per carattere, convertirlo in un vettore di cratatteri, e successivamente convertirlo in un numero intero.
ovviamente, poichè ho 12 file di testo differenti, ciascuno con nome differente, di diversa lunghezza l'uno dall'altro, ho scritto 12 parti di codice molto simili tra loro. (in sostanza 12 if)
Non ho potuto eseguire una funzione con passaggio di variabile e di directory poichè non esattamente tutte quante fanno la stessa cosa e sarei finito per complicarmi parecchio la vita.
Quando il programma esce da un'istruzione if/else, tutte le variabili, array ecc. definite al suo interno dovrebbero essere eliminate.
nel mio programma sembrerebbe non essere così...
mi spiego meglio:
il codice contenuto in uno di questi 12 if, sembrerebbe prendere valori rimasti in memoria dalla lettura precedente.
Nella lettura precedente devo leggere un numero pari a 120000, che assegno ad un vettore di 6 elementi per poi convertirlo in una variabile di tipo intero.
In quella successiva devo leggere un valore pari a 1000, soltanto che quando vado a leggere il valore convertito dall'istruzione sscanf, leggo 100000, cioè come se avesse unito il valore 1000 con i due zeri rimasti in momoria da 120000.
Il dubbio mi è sorto quando, provando a scambiare l'ordine di lettura dei due file di testo (quindi prima il file di testo contenente il valore minore e poi il file di testo contenete il valore maggiore) il risultato era ok.
Qui sotto vi allego una parte del codice:
* -------------------------------------------------- DIRECTORY "CONFIG" EXISTS BUT RELATIVE_ZERO_TIMER.txt FILE DOESN'T: */
if(SD.exists(RELATIVE_ZERO_TIMER_PATH)){
myData = SD.open(RELATIVE_ZERO_TIMER_PATH, FILE_READ);
if(myData){
if(!myData.available()){
myData.close();
myData = SD.open(RELATIVE_ZERO_TIMER_PATH, FILE_WRITE);
myData.write(DEFAULT_RELATIVE_ZERO_TIMER);
myData.close();
}else{
const uint8_t MaxChar = 6;
char CharArray[MaxChar];
uint8_t ArrayIndex = 0;
while(myData.available()){
char incomingChar = myData.read();
if(isDigit(incomingChar)){
CharArray[ArrayIndex] = incomingChar;
ArrayIndex++;
}
}
sscanf(CharArray, "%d", &RELATIVE_ZERO_TIMER);
if(RELATIVE_ZERO_TIMER < 40000 || RELATIVE_ZERO_TIMER > 180000){
RELATIVE_ZERO_TIMER = 120000; // reset to default value if readed value is inconsistent
myData.close();
SD.remove(RELATIVE_ZERO_TIMER_PATH);
myData = SD.open(RELATIVE_ZERO_TIMER_PATH, FILE_WRITE);
myData.write(DEFAULT_RELATIVE_ZERO_TIMER);
myData.close();
error = INCONSISTENT_RELATIVE_ZERO_TIMER_VALUE;
errorHandler();
}
}
}else{
error = EV_POST_PUMP_TIMER_PATH_FAILURE;
errorHandler();
}
}else{
myData = SD.open(EV_POST_PUMP_TIMER_PATH, FILE_WRITE);
myData.write(DEFAULT_EV_POST_PUMP_TIMER);
myData.close();
}
/* -------------------------------------------------- DIRECTORY "CONFIG" EXISTS BUT RED_ALARM_RESPONSIVENESS.txt FILE DOESN'T: */
if(SD.exists(RED_ALARM_RESPONSIVENESS_PATH)){
myData = SD.open(RED_ALARM_RESPONSIVENESS_PATH, FILE_READ);
if(myData){
if(!myData.available()){
myData.close();
myData = SD.open(RED_ALARM_RESPONSIVENESS_PATH, FILE_WRITE);
myData.write(DEFAULT_RED_ALARM_RESPONSIVENESS);
myData.close();
}else{
const uint8_t MaxChar = 4;
char CharArray[MaxChar];
uint8_t ArrayIndex = 0;
while((myData.available())){
char incomingChar = myData.read();
if(isDigit(incomingChar)){
CharArray[ArrayIndex] = incomingChar;
ArrayIndex++;
}
}
sscanf(CharArray, "%d", &RED_ALARM_RESPONSIVENESS);
if(RED_ALARM_RESPONSIVENESS < 500 || RED_ALARM_RESPONSIVENESS > 2000){
RED_ALARM_RESPONSIVENESS = 1000; // reset to default value if readed value is inconsistent
myData.close();
SD.remove(RED_ALARM_RESPONSIVENESS_PATH);
myData = SD.open(RED_ALARM_RESPONSIVENESS_PATH, FILE_WRITE);
myData.write(DEFAULT_RED_ALARM_RESPONSIVENESS);
myData.close();
error = INCONSISTENT_RED_ALARM_RESPONSIVENESS_VALUE;
errorHandler();
}
}
}else{
error = EV_POST_PUMP_TIMER_PATH_FAILURE;
errorHandler();
}
}else{
myData = SD.open(EV_POST_PUMP_TIMER_PATH, FILE_WRITE);
myData.write(DEFAULT_EV_POST_PUMP_TIMER);
myData.close();
}
Sono convinto che il problema sia circoscritto a queste parti di codice, per cui penso non serva altro.
Non riesco a capire come mai sembra che l'array nuovo prenda tutti gli indirizzi di memoria di quello vecchio nonostante gli abbia dato una dimensione diversa e nonostante si trovino localmente in due blocchi di statement differenti.
Ringrazio anticipatamente tutti voi!!
