EEPROM inizializzazione

Buonasera, sto creando il mio primo progetto che coinvolge la EEPROM di Arduino.
Ho la necessità di salvare al suo interno dei valori durante il funzionamento in modo tale che all'accensione successiva tutto possa ripartire da un valore noto.
Ho studiato la semplice libreria EEPROM.h presente nelle refernces di arduino :

Ho due dati che salverò in due locazioni di memoria ad esempio **Address_1= 1 e Address_2=2 ** in modo tale che alla accensione successiva leggendo Address_1 e Address_2 otterrò gli ultimi valori.
Il mio dubbio è sulla primissima accensione, in cui tali indirizzi non sono inizializzati e al loro interno i valori di default della EEPROM sono casuali.
Devo far distinguere ad arduino che sono alla primissima accensione in modo da immettere dei valori da cui partire attraverso una funzione Inizializza , allora ho pensato di creare una ulteriore locazione di memoria Address_0 = 0 in cui inserisco un valore target, ad esempio il numero 35 in modo tale che nelle successive accensioni vado ad analizzare il valore presente in Address_0 e se è uguale a 35 non faccio girare la funzione inizializza, ma carico gli ultimi dati salvati.
Questo approccio non mi sembra il migliore, anche perché essendo casuali i valori all'interno delle celle EEPROM alla primissima accensione non sono sicuro che Address_0 non contenga il 35, visto che ho una possibilità su 256 che questo accada, è molto bassa ma probabile. Esiste un modo migliore per svolgere questa operazione?

Spero di essere stato chiaro, ringrazio chiunque voglia aiutarmi.

Invece di una cella, controllane 5. Così sei più tranquillo.

Comunque mi pare che le celle nuove abbiano il valore FF.

Grazie per la risposta PaoloP, stavo cercando su internet se ci fossero devi valori di default ma non sono riuscito a trovare niente di utile cosi ho fatto una scansione della EEPROM ed ho ottenuto :

47	0	5
1	2
2	81
3	85
4	66
5	255
6	84
7	85
8	66
9	0
10	0
11	122
12	67
13	0
14	10
15	0
16	0
17	122
18	67
19	0
20	0
21	250
22	67
23	192
24	205
25	204
26	204
27	61
28	0
29	200
30	175
31	72
32	205
33	204
34	76
35	61
36	2
37	0
38	0
39	0
40	200
41	65
42	0
43	0
44	122
45	67
46	100
47	0
48	0
49	0
50	128
51	63
52	25
53	3
54	25
55	26
56	255
57	255
58	255
59	255
60	255
61	255
62	255
63	255
64	255
65	255
66	255
67	255
68	255
69	255
70	255
71	255
72	255
73	255
74	255
75	255
76	255
77	255
78	255
79	255
80	255
81	255
82	255
83	255
84	255
85	255
86	255
87	255
88	255
89	255
90	255
91	255
92	255
93	255
94	255
95	255
96	255
97	255
98	255
99	255
100	255
101	255
102	255
103	255
104	255
105	255
106	255
107	255
108	255
109	255
110	255
111	255
112	255
113	255
114	255
115	255
116	255
117	255
118	255
119	255
120	255
121	255
122	255
123	255
124	255
125	255
126	255
127	255
128	255
129	255
130	255
131	255
132	255
133	255
134	255
135	255
136	255
137	255
138	255
139	255
140	255
141	255
142	255
143	255
144	255
145	255
146	255
147	255
148	255
149	255
150	255
151	255
152	255
153	255
154	255
155	255
156	255
157	255
158	255
159	255
160	255
161	255
162	255
163	255
164	255
165	255
166	255
167	255
168	255
169	255
170	255
171	255
172	255
173	255
174	255
175	255
176	255
177	255
178	255
179	255
180	255
181	255
182	255
183	255
184	255
185	255
186	255
187	255
188	255
189	255
190	255
191	255
192	255
193	255
194	255
195	255
196	255
197	255
198	255
199	255
200	255
201	255
202	255
203	255
204	255
205	255
206	255
207	255
208	255
209	255
210	255
211	255
212	255
213	255
214	255
215	255
216	255
217	255
218	255
219	255
220	255
221	255
222	255
223	255
224	255
225	255
226	255
227	255
228	255
229	255
230	255
231	255
232	255
233	255
234	255
235	255
236	255
237	255
238	255
239	255
240	255
241	255
242	255
243	255
244	255
245	255
246	255
247	255
248	255
249	255
250	255
251	255
252	255
253	255
254	255
255	255

Molti valori sono a 255 ma altri sono random.
In base al tuo consiglio dovrei riservare 5 locazioni di memoria ad esempio Address 0,1,2,3,4 come locazioni tipo "Fusibile" e salvare al loro interno un codice target come il numero 35 e ad ogni accensione leggere queste cinque locazioni e vedere se sono gia codificate 35 oppure no?
Un'altra domanda è: ma quando carico un nuovo sketch su arduino la EEPROM viene cancellata? Perchè un'altra idea era quella di creare uno sketch apposito che scrive solo nelle locazioni 0,1,2 il numero 0 e poi caricare lo sketch che utilizzerò per il progetto che troverà gia le locazioni pronte. E' fattibile?

No, rimane.
E infatti é il sistema corretto.
Crei uno sketch per salvare i dati di default, mentre in quello definitivo li leggi .

Puoi scrivere anche un Sketch che Ti mette dei valori a Tuo piacimento nelle alocazioni che vuoi. Quello lo lanci 1 volta e poi lo soprascrivi con l’altro definitivo.
L’ eeprom inizia con la cella di memori con indirizzo 0

Ciao Uwe

Un sistema molto semplice che adotto io per inizializzare la EEPROM è quello di usare una specie di "firma" digitale, ossia un particolare valore che metto in una determinata cella della EEPROM.

Quindi, all'avvio, faccio così:

  1. leggo una cella
  2. confronto questa cella con un valore prefissato
  3. se è diverso, inizializzo le celle dei dati con dei valori di default
  4. altrimenti leggo i valori dalle celle dei dati

Esempio:

if (EEPROM.read(0) != 0xA8) { //primo avvio
    EEPROM.write(0, 0xA8); //codice di controllo
    EEPROM.write(1, 100);
    EEPROM.write(2, 200);
} else { //EEPROM già inizializzata
    var1 = EEPROM.read(1);
    var2 = EEPROM.read(2);
}

Grazie a tutti per l'aituo, siete una risorsa importantissima per la comunità DIY.
Grazie PaoloP e uwefed, penso che adotterò questa tecnica di inizializzare le celle ad un valore di default 0 con uno sketch e successivamente caricare quello definitivo che comincerà già andando a leggere i dati senza contatore per verificare che è la primissima operazione.

Ciao Leo72 inizialmente avevo optato per la soluzione simile alla tua, creando una funzione Check() che sostanzialmente faceva il lavoro del codice da te riportato, leggeva una locazione "Fusibile" e se questa era vuota la scriveva e impostava dei valori. Se invece tale locazione fosse gia scritta voleva significare che era gia tutto inizializzato e leggeva solamente.
Il mio dubbio sorgeva in questa fase :

if (EEPROM.read(0) != 0xA8) { //primo avvio

Non avevo mai utilizzato la EEPROM prima di ieri e quindi pensavo fossero present valori di default tipo 0 o FF o comunque tutti uguali, per questo la tua soluzione mi sembrava opportuna, ma poi ad una lettura dei valori ho ottenuto dei dati non omogenei che ho riportato nel post precedente.
Perchè ho notato che la mia EEPROM ha dei valori random al suo interno e quindi hai 1/256 di probabilità che il valore 0xA8 sia gia presente nella posizione 0 anche se non è stato scritto da me, questo mi ha fatto cambiare idea sul tipo di inizializzazione.

Personalmente non ho mai avuto problemi di inizializzazione con il codice che ti ho riportato. La EEPROM vuota generalmente contiene tutti $FF, tranne gli ultimi byte dove è presente una specie di "firma" di Arduino ed un contatore delle riscritture della Flash del chip (a meno che tu non abbia scritto $00 su di esse).

Se comunque vuoi essere sicuro al 100%, puoi optare per 2 soluzioni "definitive":

  1. formatti la EEPROM in precedenza, scrivendo $00 su tutte le celle
  2. opti per l'uso di un pulsantino esterno collegato con un interrupt INT o un PCINT alla cui pressione fai partire la relativa ISR che ti erasa le celle che poi userari

salvare al suo interno dei valori durante il funzionamento in modo tale che all’accensione successiva tutto possa ripartire da un valore noto.

Ma nessuno ha chiesto ogni quanto tempo scrive su queste celle? … usa la eeprom come backup in tempo reale o quasi … pare di capire … :sweat_smile:

Rebel, la eeprom non è fatta per salvare su di essa in modo continuato . Scrivendo una volta al secondo ti dura +/- 2 mesi poi dovrai rinunciare a quelle celle e cambiare indirizzo.
ciao

pablos:
Rebel, la eeprom non è fatta per salvare su di essa in modo continuato . Scrivendo una volta al secondo ti dura +/- 2 mesi poi dovrai rinunciare a quelle celle e cambiare indirizzo.

Ho idea che dura moooolto meno ... :grin:

... viene data per 100'000 scritture, 1 ora = 60 minuti = 3600 secondi che per 24 ore = 86'400 secondi ... se scrivi una volta al secondo ... in un giorno e qualche ora l'hai fatta fuori :roll_eyes:

Guglielmo

si ho dimenticato un diviso 60 ... ero un po' turbato dal risultato, mi pareva un po' troppo 2 mesi :slight_smile: ... vabbè il concetto è quello XD