Aiuto ibutton e memorizzazione in eeprom

International Italiano Software
1

Salve ragazzi sto impazzendo e chiedo aiuto

Partiamo che sto realizzando un sistema per l'eccitamento di un relè in caso si inserisca una chiave ibutton memorizzata

e qui arriviamo

inizialmente le chiavi erano in ram quindi più chiavi più ram usata... quindi crash

le chiavi una volta memorizzate finivano scritte nella eeprom interna

inizialmente all'avvio facevo leggere la eeprom interna e le caricavo in ram ( se volete ho quello sketch ma è superato )

ora faccio diversamente:

memorizzo tutte le chiavi nei 512 kb del arduino mega

quando inserisco una chiave carico il codice ed uno alla volta ciclo per il numero di chiavi inserite finchè non trovo se a qualcuna corrisponde

nel primo codice che allego funziona ma credo non correttamente perchè all'inizio nella definizione delle variabili inserisco

unsigned char G_addr[10][8]; //qui memorizzo fino a 10 indirizzi da 8 bytes (64bit)

quindi consumo 10*8

ora per come voglio io che funzioni qui mi basta 1*8

perchè poi ogni volta ci riscrivo dentro per virificare quello successivo

qui si vede come funziona ma secondo me non è corretto tant'è che se memorizzo più di 10 chiavi non và...

void lookUpKeys()
{
byte address[8]; // questo array conterrà l'indirizzo locale delle chiavi

G_Devices = EEPROM.read(0);  // leggo quante chiavi sono state memorizzate

while (ow.search(address)) // loop finchè trova nuovi dispositivi
{
 if (address[0] == 0x01) // identificata chiave 1-wire
 
   digitalWrite( 6, HIGH); // riaccendo la retroilluminazione  
   
 {
  if(CheckSensor(address)==1) //se il crc ok la lettura è corretta
  {
   bool old=false;

// ********



  for (int y = 1; y <= G_Devices; y++)   //  for (int y = 1; y <= G_Devices; y++)
  {
    
     for(int aa=0;aa<8;aa++)
     {
     G_addr[1][aa]=EEPROM.read(1+ ((y*8)-8 + aa));  
        lcd.print(G_addr[1][aa], HEX);
     }

     
      if(CheckAddress(G_addr[1],address))      < ========== ECCO QUI e sopra
      {
        old=true;break;
      }
 
  
   
   if(!old) // se la chiave non è ancora stata usata....

ps sulla posizione 1 della eprom scrivo quante key sono memorizzate escco perchè nel ciclo c'è lo scavallo di 1

ora guardate come ho modificato a logica

void lookUpKeys()
{
byte address[8]; // questo array conterrà l'indirizzo locale delle chiavi

G_Devices = EEPROM.read(0);  // leggo quante chiavi sono state memorizzate

while (ow.search(address)) // loop finchè trova nuovi dispositivi
{
 if (address[0] == 0x01) // identificata chiave 1-wire
 
   digitalWrite( 6, HIGH); // riaccendo la retroilluminazione  
   
 {
  if(CheckSensor(address)==1) //se il crc ok la lettura è corretta
  {
   bool old=false;

// ********



  for (int y = 1; y <= G_Devices; y++)   //  for (int y = 1; y <= G_Devices; y++)
  {
    
     for(int aa=0;aa<8;aa++)
     {
     G_addr[1][aa]=EEPROM.read(1+ ((y*8)-8 + aa));  
        lcd.print(G_addr[1][aa], HEX);
     }

     
      if(CheckAddress(G_addr[1],address)) 
      {
        old=true;break;
      }
 
  
   
   if(!old) // se la chiave non è ancora stata usata....

sto diventando scemo

grazie a chi mi aiuta ad uscirne credo di essere vicino

iButton_veeprom_V4_1_b.ino (21.2 KB)

iButton_veeprom_V4_1_b.ino (21.2 KB)

2

Non credo che siamo un forum di aiuto psicololgico o psicoterapeutico per non farti impazzire.
Se é cosí grave come dici, Ti consiglio vivamente di cercarti aiuto professionale per salvaguardare la Tua salute mentale.

memorizzo tutte le chiavi nei 512 kb del arduino mega

Arduino MEGA non ha cosí tanta memoria, ne RAM, ne EEPROM, ne FLASH.

Ciao Uwe

3

djdanielb:
sto diventando scemo
grazie a chi mi aiuta ad uscirne credo di essere vicino

Io alla fine di tante parole, non ho capito qual'e' il problema, COSA non funziona ? :confused:

Se dalla eeprom leggi una chiave, la metti in un array e la confronti mi pare giusta come logica.
Certo che non serve una matrice. Una matrice dove una delle dimensioni è 1... è un vettore
Quindi:

unsigned char G_addr[8];   // tolto [10]
...
G_addr[aa]=EEPROM.read(1+ ((y*8)-8 + aa));  // tolto [1]

Io preferirei però confrontare il byte già mentre leggi da eeprom, senza memorizzare in vettore. Appena un byte è diverso la chiave non è uguale. Quindi non ti serve più né il vettore né la CheckAddress()

P.S. nel codice, per favore, leva tutte quelle inutili righe vuote, non è un temino dove più è lungo e meglio è !!

4

grazie mille per la dritta nid69ita !!! in effetti quello che mi mancava era questo aiuto !

Stasera proverò a mettere mano di nuovo al codice.

anche io avevo pensato che non era necessario arrivare a leggerla tutta la chiave se già iniziava male...

però ho anche detto visto che mi sembra un po' più complessa la modifica ho detto: visto che al massino sono 64 chiavi che ritardo potrei avere a 16 mhz ?

Grazie ragazzi dopo vi aggiorno

ps 512 kb di eeprom ho capito bene che è come se avessi un foglio a quadretti largo appunto 512 e dentro ognuno di essi posso mettere 1 solo numero o lettera ?

5

La mega non ha 512k di nessuna "cosa". Quindi "rilassati", stai facendo confusione con le unità di misura.

6

Caspita ragazzi !!!

Funziona !!!

Siete troppo forti.

Stasera farò un paio di prove.

Semmai tiro giù il cambio codice per verificare uno alla volta ma ripeto al massimo sono 64 chiavi il codice gira bene i benefici sono minimi

7

Speedyant perdonami ma quando faccio eeprom write dove scrivo allora ? ( non è ram perché non è volatila ma rimane )

8

djdanielb:
ps 512 kb di eeprom ho capito bene che è come se avessi un foglio a quadretti largo appunto 512 e dentro ognuno di essi posso mettere 1 solo numero o lettera ?

Arduino MEGA ha 4 KByte di EEprom. Ogni Byte puó memorizzare un numero da 0 a 255. Poi il significato del numero dipende dalla definizione.

Non so da dove hai preso quel numero

Ciao Uwe

9

djdanielb:
Speedyant perdonami ma quando faccio eeprom write dove scrivo allora ? ( non è ram perché non è volatila ma rimane )

Scrivi nella EEPROM del ATmega2560

10

256 Kb di memoria Flash (dove stà il codice)
8 Kb di memoria SRAM (memoria per le "variabili" diciamo)
4 Kb di EEPROM

11

quindi aiutatemi con il calcolo

K = 1000

quindi 4000 byte

ogni byte può tenere un numero da 0 a 255 ( voi mi dite numero ma la chiave ibutton tiene valori esadecimali quindi ??? )

supponiamo che lo volessi usare tutti per tenerci le chiavi ed ogni chiave è lunga 8 byte ( sbaglio ? )

facendo 4000 / 8 = 500

potrei memorizzarci 500 chiavi ?

se così fosse sarebbe fichissmo

12

Dovrebbero essere potenze di 2. Quindi 1kb=1024b, se ben mi ricordo...

13

Ok quindi 4 * 1024 ( meglio )

Però rimane il quesito

Su un singolo byte ci posso memorizzare il carattere A ? ( esempio )

E poi cone funzionerebbe per gli indirizzi ?
Nel senso il comando EEPROM.Rread ( 2048 );

Funziona così ?

14

con 1 byte puoi memorizzare un numero intero compreso tra 0 e 255. se poi questo valore rappresenta un numero o la codifica ascii di un carattere dipende da te.

15

Gli indirizzi vanno da 0 a 2047.
dicciamo:
valore = EEPROM.read ( 2047 );

Grüße Uwe

16

Grazie.

Mi rimane solo da valutare se verificare byte singoli o tutto il venttore.

Come suggerito qui sopra inutile continuare a leggere se già inizia diversamente...

Cibsarebbe molta differenza di tempo ( me ne accorgerei ?)

Guadagnerei qualcosa in ram? ( arduino gira con 81% di memoria sram occupata

17

Solitamente quando si verifica l'uguaglianza di "cose lunghe", alla prima differenza ci si ferma, visto che ormai l'esito del confronto è deciso.

uwefed:
Gli indirizzi vanno da 0 a 2047.

Se abbiamo 4k vanno fino a 4095.

18

visto che mi piacciono le sfide e a rigor di logica è più giusto verificare singolo carattere alla volta senza continuare a leggere ecco qui i due pezzi di codice incriminati ( li estraggo per meglio capirci qualcosa )

in questo pezzo leggo fisicamente la chiave inserita dentro address e accumulo dentro G_addr quella letta dentro la eeprom

una volta fatto questo la passo alla funzione di controllo

if(CheckSensor(address)==1) //se il crc ok la lettura è corretta
  {
   bool old=false;

  for (int y = 1; y <= G_Devices; y++)   //  for (int y = 1; y <= G_Devices; y++)
  {
    
     for(int aa=0;aa<8;aa++)
     {
     G_addr[aa]=EEPROM.read(1+ ((y*8)-8 + aa));  //((G_Devices-1)*8) +
        lcd.print(G_addr[aa], HEX);
     }

   
   for (int i=0;i<=G_Devices;i++) 
      if(CheckAddress(G_addr,address)) 
      {
        old=true;break;
      }
      }

ecco qui la funzione di controllo alla quale viene dato addres e G_addr per effettuare il controllo

bool CheckAddress(unsigned char *a,unsigned char *b) // controlla se un indirizzo è già memorizzato
{
 bool ck=true;
 for(int i=0;i<8;i++) if(*(a+i)!=*(b+i)) return(false);
 return(true);
}

qui qualche problemino a capirlo lo trovo

intanto questo restituisce "solo" vero o falso e va bene ma questo per me è arabo

if(*(a+i)!=*(b+i))

che diavolo fa ?

l'idea sarebbe quindi

ciclo il seguente

leggo un byte e lo comparo se è = allora continuo altrimenti passo al successivo

però poi al secondo byte devo saltare quelli non corretti al primo controllo

mi sto incartando...