Salve ragazzi,
premetto che uso da appena 1 settimana Arduino e di programmazione sono una capra. Sono pratico di elettronica ma mai usato questo tipo di board. Giusto per iniziare a capire come funziona mi sono scontrato con la lettura e scrittura di eeprom di cui avevo un progetto in pending con il 16f84. Visto che con il PIC non ci ero mai riuscito mi sono messo alla ricerca di qualche libreria di arduino che mi permettesse di leggere e scrivere eeprom della famiglia 24LCXX. Ho letto tantissimo, ho visto tanti metodi, con librerire i2c esterne, con la libreria wire e così via, ma quando sono andato a fare dei test ho sempre avuto problemi.
L’unica con cui ho avuto successo (grazie anche alla supervisione di un amico che mi ha indirizzato sulla giusta strada) è stata la librerira EEPROM24 di cui però non c’è assolutamente documentazione ne esempi. Vi linko la pagina di riferimento: http://rweather.github.io/arduinolibs/classEEPROM24.html#details
Per me che non ho mai messo mano ad arduino e che non ci capisco tantissimo di programmazione è stato un pò complicato iniziare a capire come usare tale libreria, ma sono riuscito nel mio intento. Questa mio post non vuole essere presuntuoso ne vuole insegnare nulla a voi che siete sicuramente molto più esperti di me. Semplicemente esporre come ho implementato tale libreria e alcune righe di codice sull’uso della stessa. Ripeto, uso da 1 settimana arduino, di programmazione non ci capisco quasi nulla, scrivo esattamente ciò che mi avrebbe fatto comodo trovare in rete quando ho iniziato a cercare informazioni, quindi se c’è qualcosa di sbagliato sarei molto felice di essere corretto.
Partiamo (ho usato una board compatibile simile all’Arduino Nano):
il collegamento della memoria è avvenuto così come da schema sulla pagina della libreria:
Dopodichè ho implementato le librerire, inizializzato il collegamento con arduino, letto e successivamente scritto dei dati in eeprom (io avevo disponibile una 24c02).
Le librerire le ho implementate in questo modo:
#include <EEPROM24.h>
#include <I2CMaster.h>
#include <SoftI2C.h>
Immediatamente dopo ho “configurato” i PIN di Arduino e configurato il tipo di eeprom secondo la tabella che si trova nella pagina della libreria:
SoftI2C i2c(SDA, SCL);
EEPROM24 eeprom(i2c, EEPROM_24LC02,0x50);
Fatto ciò ho dichiarato qualche variabile che ho usato nel programma ed inserito nel loop le mie operazioni:
Controllo se è collegata la memoria al mio arduino:
presente = eeprom.available();
questo restituisce “1” se la memoria è presente, “0” se la memoria non è presente. Dopo aver “sentito” la momoria collegata, ho semplicemente letto la memoria in un indirizzo noto:
ret = eeprom.read(indirizzo1, valore, 4);
dove “indirizzo1” è l’indirizzo da cui voglio iniziare a leggere, “valore” è il valore da scrivere, “4” la lunghezza
ret = eeprom.write(indirizzo2, valore2, 4);
come per la lettura, “indirizzo2” è l’indirizzo iniziale in cui voglio iniziare a scrivere, “valore2” il valore da scrivere e “4” la lunghezza del dato da scrivere.
Nel caso in cui si vuole leggere o scrivere solo 1 bit si può usare direttamente eeprom.read ed eeprom. write senza indicare la lunghezza dei dati da scrivere (il mio “4”),
Altre 2 funzioni che ho solo testato ma non usato sono la:
eeprom.size(); ed eeprom.pageSize();
Con eeprom.size(); mi ricavo la dimensione della mia eeprom che nel mio caso specifico è di 256 bytes, mentre con eeprom.pageSize(); non ho ben capito che parametro si ricava. Facendo una prova sulla mia 24c02 ho avuto un valore di pageSize() = 8
Tutto funziona perfettamente e sono riuscito a fare ciò che mi serviva. Se qualcuno vuole approfondire o aggiungere altro mi farebbe molto piacere. Di seguito un esempio completo (perdonatemi se ho fatto qualche grossolano errore per inesperienza, correggetemi pure). A tal proposito, dopo aver fatto tutte le operazioni nell’IF, per fermare il loop uso un accrocchio trovato in rete inserendo un while, come può essere migliorato o corretto questo codice?
Grazie mille
Luc@
//includo le librerire
#include <EEPROM24.h>
#include <I2CMaster.h>
#include <SoftI2C.h>
SoftI2C i2c(SDA, SCL); //inizializzo i pin A4 ed A5 come SDA e SCL
EEPROM24 eeprom(i2c, EEPROM_24LC02,0x50); //configuro il tipo di eeprom usata
byte valore[4]; //definisco la variabile "valore"
byte valore1[4]={
1,2,3,4}; //definisco la variabile "valore1"
int indirizzo1 = 1; //definisco la variabile "indirizzo1"
int led = 13; //definisco la variabile led
int ret;
int presente;
void setup() {
Serial.begin(9600); //inizializzo la velocità della seriale
pinMode(led, OUTPUT); //setto il pin "led" come output
}
void loop() {
presente = eeprom.available(); //controllo se la eeprom è presente
if (presente == 1){
Serial.println("eeprom presente!");
delay(350);
Serial.println("Eseguo operazione!");
Serial.println("inizio lettura");
ret = eeprom.read(indirizzo1, valore, 4);
Serial.print(valore[0], HEX); //stampo il valore
Serial.print(valore[1], HEX); //stampo il valore
Serial.print(valore[2], HEX); //stampo il valore
Serial.print(valore[3], HEX); //stampo il valore
delay(350);
ret = eeprom.write(indirizzo1, valore1, 4); //scrivo il valore dichiarato prima
Serial.println("Valori scritti, ripeto la lettura");
ret = eeprom.read(indirizzo1, valore, 4);
Serial.print(valore[0], HEX); //stampo il valore
Serial.print(valore[1], HEX); //stampo il valore
Serial.print(valore[2], HEX); //stampo il valore
Serial.print(valore[3], HEX); //stampo il valore
digitalWrite(led, HIGH); //accendo il led*/
while(1){
} //mi fermo...funziona ma implementato in modo scorretto
}
else{
Serial.println("eeprom non presente!");
delay(350);
}
}
ho capito che da solo non posso farcela.