Arduino Mega lento

Ciao a tutti,mi è successa una cosa strana, ho fatto un progetto che comunica con processing per irrigazzione e varie, ho provato ad utilizzare la funzione write eprom e read eprom che poi aggiungo , per salvare delle int, a questo punto , le variabili non sono riuscito a fare in modo che si memorizzino ma, cosa peggiore sembra che il sistema si sia rallentato, cioè la porta seriale con cui comunico molte volte alla richiesta di invio-ricezione stringa risponde con tempi diversi.
Ho caricato il progetto precedente che non includeva eeprom , ma niente , ho provato a fare un clear eeprom , senza nessun cambiamento.
E’ mai successo a qulacuno qualcosa di simile?
E visto che ci siamo questo modo per salvare e scrivere su eprom una int è corretto?

int rx100; int rx101; int rx102;

leggere

rx100 = (EEPROM.read(0)*256)+(EEPROM.read(0)+1);
rx101 = (EEPROM.read(2)*256)+(EEPROM.read(2)+1);
rx102 = (EEPROM.read(4)*256)+(EEPROM.read(4)+1);

scrivere

EEPROM.write(0,highByte (rx100));
EEPROM.write(0+1,lowByte (rx100));
EEPROM.write(2,highByte (rx101));
EEPROM.write(2+1,lowByte (rx101));
EEPROM.write(4,highByte (rx102));
EEPROM.write(4+1,lowByte (rx102));

ciao grazie

Ciao quante volte hai scritto e letto la eeprom?
Perche' non e' una memoria pensata per essere cancellata e riscritta spesso, ma piuttosto per contenere delle costanti. L' ATmega 328 e' rated 100,000 read/write routines prima che si rompa.

A parte il fatto, che come dice anche @gbm, le Eeprom vanno adoperate con cura, visto che e' facile esaurirne la vita

Ho caricato il progetto precedente che non includeva eeprom , ma niente , ho provato a fare un clear eeprom , senza nessun cambiamento

La Eeprom è una memoria a se, se non la usi è come se non ci fosse, quindi se il problema persiste la causa è un'altra.

La 'int' spazia da -32768 a 32767, devi usare la 'unsigned int' ( valori da 0 a 65535 )

qui

 rx100 = (EEPROM.read(0)*256)+(EEPROM.read(0)+1);

(EEPROM.read (0)*256) ok, leggi la locazione 0 (HighByte) e la moltiplichi
(EEPROM.read(0)+1) errato, perchè non leggi la locazione 1 (LowByte), ma sempre la 0 a cui poi sommi il valore 1
Lo stesso per le due righe successive

Quindi dovrebbe essere:

rx100 = (EEPROM.read(0)*256)+(EEPROM.read(1));

La lettura viene fatta ad ogni ciclo setup mentre la scrittura tramite un bit quando voglio.
La lettura si può fare quante volte si vuole , o rientra nelle 100000 ?

la lettura quante volte vuoi.
e' solo la scrittura che ha un limite

Ma usare EEPROM.put() e .get()? Vi risparmiano fatica e possibili errori!

Ciao , ho provato ad usare Get e Put per salvare su eprom ma c'è qualcosa che non va, salva sempre un byte ..o riscrive sempre un byte , tranne se salve due volte.
Metto solo una parte di sketch, le rx[100] ....ecc sono delle int
Cosa c'è di sbagliato? grazie ancora

//  con questo scrivo  su eprom, il bit rx103b1 e la conferma a salvare

if (rx103b1 == true && b3 == false){ b3 = true;}


if (b3 == true){  
EEPROM.put(0,rx[100]);
EEPROM.put(2,rx[101]);
EEPROM.put(4,rx[102]);
EEPROM.put(6,rx[104]);
EEPROM.put(8,rx[105]);
EEPROM.put(10,rx[106]);
EEPROM.put(12,rx[107]);
EEPROM.put(14,rx[108]);
EEPROM.put(16,rx[109]);
EEPROM.put(18,rx[110]);
EEPROM.put(20,rx[111]);
EEPROM.put(22,rx[112]);
EEPROM.put(24,rx[113]);
EEPROM.put(26,rx[114]);
EEPROM.put(28,rx[115]);
EEPROM.put(30,rx[116]);
EEPROM.put(32,rx[117]);
EEPROM.put(34,rx[118]);
EEPROM.put(36,rx[119]);
EEPROM.put(38,rx[120]);
EEPROM.put(40,rx[121]);

tx103b1 = true;                             // conferma a processing salvataggio ok
b3 = false;
}
else
{tx103b1 = false;}


///////////////////////////////////////////////////////////////////////////////////////////////
// con questo leggo da eprom ( ed è dentro al setup, cosi ad ogni avvio lo fà)

EEPROM.get(0,rx[100]);
EEPROM.get(2,rx[101]);
EEPROM.get(4,rx[102]);
EEPROM.get(6,rx[104]);
EEPROM.get(8,rx[105]);
EEPROM.get(10,rx[106]);
EEPROM.get(12,rx[107]);
EEPROM.get(14,rx[108]);
EEPROM.get(16,rx[109]);
EEPROM.get(18,rx[110]);
EEPROM.get(20,rx[111]);
EEPROM.get(22,rx[112]);
EEPROM.get(24,rx[113]);
EEPROM.get(26,rx[114]);
EEPROM.get(28,rx[115]);
EEPROM.get(30,rx[116]);
EEPROM.get(32,rx[117]);
EEPROM.get(34,rx[118]);
EEPROM.get(36,rx[119]);
EEPROM.get(38,rx[120]);
EEPROM.get(40,rx[121]);

Se rx è dichiarato come:

int rx[200];

A meno della dimensione, ogni EEPROM.put() e .get() dovrebbe salvare entrambi i byte che compongono ogni int.

Comunque nota che invece di tutta quella sbrodolata puoi fare:

for (int i = 0; i <= 20; i++)
  EEPROM.get(i * 2, rx[i + 100]);

(In realtà non proprio, perché tu hai saltato rx[103], ma è voluto?)

Sì perché la uso come bit da processing, posso spostarla e usarne un altra. , resta che non capisco perché non salva tutta la int