"residuati bellici"

no non intendo di cancellare/sovrascrivere per sbaglio,

intendo proprio, voglio mettere a zero tutte le memorie (tutte non solo quelle che usero) anche se l'atmega è nuovo
intendo proprio farlo apposta, (una specie di formattazione) prima di caricare un tipo di sketch

che qualsiasi cella di memoria provo a leggere da zero

c'è un sistema "rapido" o devo cancellare cella per cella :fearful:

Se l'operazione è "una tantum" puoi eseguirla da riga di comando AVRDUDE, mi pare che ti abbia già scritto Leo l'opzione da usare.

EDIT: è l'opzione "-e":

-e Causes a chip erase to be executed. This will reset the contents of the flash ROM
and EEPROM to the value ‘0xff’, and clear all lock bits. Except for ATxmega
devices which can use page erase, it is basically a prerequisite command before
the flash ROM can be reprogrammed again. The only exception would be if the
new contents would exclusively cause bits to be programmed from the value ‘1’
to ‘0’. Note that in order to reprogram EERPOM cells, no explicit prior chip
erase is required since the MCU provides an auto-erase cycle in that case before
programming the cell.

però come vedi resta sempre il solito principio per cui ATMEL dice che 0=programmato e 1=non programmato, quindi per cancellazione totale si intende porre tutto a "1" e non a "0".

Appunto, ma vedo che non vengo letto :stuck_out_tongue_closed_eyes:

ma intendi dire che arduino appena comprato ha le celle della eeprom con dentro il valore 1?

voglio fare una cosa tutto sommato semplice (forse ho sbagliato a spiegare)

non voglio "cancellare nulla"
voglio solo mettere in tutte le celle di memoria eeprom il valore zero

quindi in realtà voglio scriverle tutte con poche righe di codice una volta sola e senza fare danni

@Mike:
il fatto che una cella vuota contenga $FF al posto di $00 dipende da come sono strutturate le memorie non volatile, basate sui MOSFET a doppio gate. Tutte le Flash e le EEPROM "vergini" sono impostate a $FF perché i MOSFET consumano meno corrente a tenere il valore 1 che il valore 0.
Ma questo è un dettaglio, basta adattarsi.

@Gingiardu:
nel Playground ci sono esempi di accesso alla EEPROM.

Prendi quello sketch, modifica il tetto massimo a 1023 e poi metti come byte 0 per la scrittura e farai ciò che desideri

leo72:
@Mike:
il fatto che una cella vuota contenga $FF al posto di $00 dipende da come sono strutturate le memorie non volatile, basate sui MOSFET a doppio gate. Tutte le Flash e le EEPROM "vergini" sono impostate a $FF perché i MOSFET consumano meno corrente a tenere il valore 1 che il valore 0.
Ma questo è un dettaglio, basta adattarsi.

Certamente, io ho solo evidenziato che il comando che suggerivi tu NON mette a 0 le celle, come vuole GING, ma le mette a 1, in base alla "logica ATMEL" di cui abbiamo discusso tante volte, non riesco nemmeno a capire l'ostinazione di GING a mettere tutti questi 0, dopo le abbondanti spiegazioni che ha ricevuto, ma d'altra parte ognuno può fare ciò che vuole delle proprie EEPROM, l'importante è che raggiunga il risultato sperato, credo che con le semplici righe di codice del Playground riuscirà rapidamente.

1

base alla "logica ATMEL" di cui abbiamo discusso tante volte

Tutte le Flash e le EEPROM "vergini" sono impostate a $FF perché i MOSFET consumano meno corrente a tenere il valore 1 che il valore 0.

Mi spiegate, o mi linkate per approfondire? Thanx

Ci sono un sacco di link in rete, il primo che ho trovato in italiano è questo:
http://www.dinoxpc.com/articolo/Dischi+SSD%253A+la+tecnologia_949-3.htm

In pratica funziona così: all'interno del MOSFET è presente un secondo gate che funge da condensatore, capace di mantenere le cariche a lungo. Questo condensatore influisce sul transito della corrente tra source e drain: se contiene cariche, interdice il passaggio di corrente, e la lettura della memoria è "0". Se non le contiene, permette il passaggio della corrente e la lettura è "1". Per accumulare le cariche nel condensatore bisogna applicare una tensione di 12V e iniettare le cariche al suo interno, mentre per toglierle si sfrutta l'effetto tunnel. Capisci che l'assenza di cariche è una condizione di "riposo", quindi la memoria "vuota" è ad 1.

Capisco, grazie delle info.
N.

[quote author=Michele Menniti link=topic=124894.msg939363#msg939363 date=1348955896]

leo72:
@Mike:

Ma questo è un dettaglio, basta adattarsi.

non riesco nemmeno a capire l'ostinazione di GING a mettere tutti questi 0, dopo le abbondanti spiegazioni che ha ricevuto,[/quote]

mettiamo che "publico un software" prima o poi lo faro per un qualcosa :slight_smile:

che contenga nel set up questo

regolazione1complm = ((unsigned long)(EEPROM.read(11)) << 24) |
((unsigned long)(EEPROM.read(12)) << 16) | ((unsigned long)(EEPROM.read(13)) << 8) | (unsigned long)(EEPROM.read(14));

ovviamente regolazione1complm prendere il numero che sta nelle momorie,

ora (mettendosi nei panni di chi carica il programma la prima volta) se ha le memorie che sono gia "sporche" non riuscira mai scriverle con i valori giusti che poi si ritrovera sempre ogni volta che riavvia l'arduino,
non posso mettere il comando nel set up di cancellare le memorie perche se no cancellerebbe anche le regolazioni corrette una volta effettuate, e le nuove regolazioni che si andra a memorizzare sono influenzate dalle regolazioni precedenti purtroppo

certo una soluzione potrebbe essere un pulsante che se premuto cancella le memorie usate
ma questo significa perdere un pin, mettere un pulsante in piu ecc

e solo una specie di sicurezza per evitare che chi userà quel codice non gli si blocchera tutto,
solo perche nelle sue memorie aveva gia memorizzato 3.567.432.611

magari quando diventerò piu pratico risolvero in altro modo senza impegnare pin e pulsanti

leo72:
Ci sono un sacco di link in rete, il primo che ho trovato in italiano è questo:
http://www.dinoxpc.com/articolo/Dischi+SSD%253A+la+tecnologia_949-3.htm

In pratica funziona così: all'interno del MOSFET è presente un secondo gate che funge da condensatore, capace di mantenere le cariche a lungo. Questo condensatore influisce sul transito della corrente tra source e drain: se contiene cariche, interdice il passaggio di corrente, e la lettura della memoria è "0". Se non le contiene, permette il passaggio della corrente e la lettura è "1". Per accumulare le cariche nel condensatore bisogna applicare una tensione di 12V e iniettare le cariche al suo interno, mentre per toglierle si sfrutta l'effetto tunnel. Capisci che l'assenza di cariche è una condizione di "riposo", quindi la memoria "vuota" è ad 1.

+1 ma di volt dovrebbero bastarne anche 1,8÷5 altrimenti ogni micro dovrebbe contenere uno step-up

@Gingardu:
la soluzione te l'ho già data con tanto di codice. Metti un valore di controllo in una cella, se quel valore c'è significa che i valori sono già stati salvati e basta leggerli; se non c'è significa che è il primo avvio e devi salvarli.
Opzionalmente puoi mettere nel codice una procedura per salvare i dati su richiesta dell'utente, in modo che egli possa sovrascrivere quelli di fabbrica, così da esser sicuro di partire con i valori desiderati.
Altri problemi non ne vedo.

@Mike:
i 12V sono usati per creare l'effetto tunnel o per iniettare la carica, la normale lettura avviene a tensioni più basse. Credo comunque che ci sarà uno step-up microscopico nella circuiteria per fornire quella tensione solo quando effettivamente serve. Ma le mie sono solo illazioni. Non conosco l'HW in oggetto molto a fondo.

alla fine ho assemblato questo scketc lo metto qui se a qualcuno puo servire

basta caricarlo aprire il seria monitor e mettere il codice 12345 pochi secondi mette a zero tutte le memorie e da anche il messaggio di ok per operazione avvenuta
ho verificato e funziona correttamente sull'arduino uno

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                   USARE IN QUESTO MODO:  CARICARE QUESTO  SKETCH 
//                   APRIRE IL MONITOR SERIALE ASSICURARSI CHE SIA IMPOSTATO A 9600baud  
//                   IMMETTERE IL CODICE 12345  NELLA RIGA DI COMANDO, PREMERE INVIO
//                   ATTENDERE QUALCHE SECONDO
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                  QUESTO PROGRAMMA SERVE PER METTERE TUTTE LE EEPROM DELL'ARDUINO UNO  A "ZERO"
//                  LE MEMORIE EEPROM POTREBBERO AVERE "DATI" MEMORIZZATI IN PRECEDENZA
//                  CARICARE UN NUOVO SKETCH NON PULISCE AUTOMATICAMENTE LA EEPPROM 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////





















/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
long vet[9] = {
  -2, -2, -2, -2, -2, -2, -2, -2, -2 };  //numero arbitrario, usato per vedere se è stato inserito un numero o  tre cifre, 
//il -2 non centra niente con la dimensione dell'array)
//non ho usato -1 perchè significa che non ci sono dati da leggere (secondo la serial available) quindi si poteva fare confusione
long cont = 0;
long x = 0;
#include <EEPROM.h>
byte ciliegia=1;
byte mela=1;
byte pera=1;
int numem=0;
void setup()
{
  // start serial port at 9600 bps:
  Serial.begin(9600);



}

void loop()
{
  while (Serial.available() > 0)
  {
    vet[cont] = Serial.read()-48; 
    cont++;
    delay(60); 
   
  }

  if (vet[0] < -2 || vet[1] < -2 || vet[2] < -2 || vet[3] < -2 || vet[4] < -2 || vet[5] < -2 || vet[6] < -2 || vet[7] < -2 || vet[8] < -2) 
    Serial.println(" ATTENZIONE DEVI  INSERIRE SOLO IL NUMERO 12345 ");

  if (vet[0] > 9 || vet[1] > 9 || vet[2] > 9 || vet[3] > 9 || vet[4] > 9 || vet[5] > 9 || vet[6] > 9 || vet[7] > 9 || vet[8] > 9) 
    Serial.println(" ATTENZIONE DEVI  INSERIRE SOLO IL NUMERO 12345 ");



  if(cont > 0)
  {
    cont = 0;


    if (vet[8] == -2 && vet[7] == -2 && vet[6] == -2 &&  vet[5] ==  -2  && vet[4] ==  -2  && vet[3] ==  -2  && vet[2] ==  -2  && vet[1] ==  -2 ) 
   
    {                                                                         
        x = vet[0];                                                           
    }
    else

        if (vet[8] == -2 && vet[7] == -2 && vet[6] == -2 && vet[5] ==  -2  && vet[4] ==  -2  && vet[3] ==  -2  && vet[2] ==  -2 ) //  
      {
        x = (vet[0]* 10 +   vet[1]    );
      }
      else
        if  (vet[8] == -2 && vet[7] == -2 && vet[6] == -2 &&  vet[5] ==  -2  && vet[4] ==  -2  && vet[3] ==  -2 ) //
        {
          x = (vet[0] * 100 + vet[1]* 10+ vet[2]);
        } 
        else
          if  (vet[8] == -2 && vet[7] == -2 && vet[6] == -2 && vet[5] ==  -2  && vet[4] ==  -2  )
          {
            x = (vet[0] * 1000 + vet[1] * 100 + vet[2]* 10 + vet[3]);  
          } 
          else
            if  (vet[8] == -2 && vet[7] == -2 && vet[6] == -2 && vet[5] ==  -2   )
            {
              x = (vet[0] * 10000 + vet[1] * 1000 + vet[2]* 100 + vet[3]* 10 + vet[4]);  

            } 
            else
              if  (vet[8] == -2 && vet[7] == -2 && vet[6] == -2 )
              {
                x = (vet[0] * 100000 + vet[1] * 10000 + vet[2]* 1000 + vet[3]* 100 + vet[4]* 10 + vet[5]);  

              } 
              else 

                if  (vet[8] == -2 && vet[7] == -2 )
              {
                x = (vet[0] * 1000000 + vet[1] * 100000 + vet[2]* 10000 + vet[3]* 1000 + vet[4]* 100 + vet[5]* 10+ vet[6]);  

              } 
              else  

                if  (vet[8] == -2 )
              {
                x = (vet[0] * 10000000 + vet[1] * 1000000 + vet[2]* 100000 + vet[3]* 10000 + vet[4]* 1000 + vet[5]* 100 + vet[6]* 10+ vet[6]);  

              } 
              else 



                x = (vet[0] * 100000000 + vet[1] * 10000000 + vet[2]* 1000000 + vet[3]* 100000 + vet[4]* 10000 + vet[5]* 1000 + vet[6]* 100 + vet[7] * 10 + vet[8]); 


    if (vet[0] < -2 || vet[1] < -2 || vet[2] < -2 || vet[3] < -2 || vet[4] < -2 || vet[5] < -2 || vet[6] < -2 || vet[7] < -2 || vet[8] < -2 ) x = 0;
    if (vet[0] > 9 || vet[1] > 9 || vet[2] > 9 || vet[3] > 9 || vet[4] > 9 || vet[5] > 9 || vet[6] > 9 || vet[7] > 9 || vet[8] > 9)  x = 0;

    if (x == -2 || x== -1) x=0;


    if (vet[0] >= -2 && vet[1]  >= -2 &&  vet[2]  >= -2 &&  vet[3] >= -2 && vet[4] >= -2 && vet[5] >= -2 && vet[6] >= -2 && vet[7] >= -2 && vet[8] >= -2 &&
      vet[0] <= 9 && vet[1] <= 9 &&  vet[2] <= 9 &&  vet[3] <= 9 &&  vet[4] <= 9 &&  vet[5] <= 9 &&  vet[6] <= 9 &&  vet[7] <= 9 &&  vet[8] <= 9 ) 
      Serial.println(" NUMERO INSERITO  "),   Serial.println(x);

    if (x > 12345 ) Serial.println(" INSERISCI 12345  E  ATTENDI ")  ;
    if (x < 12345 ) Serial.println(" INSERISCI 12345  E  ATTENDI ")  ;

    vet[0] = -2;  
    vet[1] = -2;
    vet[2] = -2;
    vet[3] = -2;
    vet[4] = -2; 
    vet[5] = -2; 
    vet[6] = -2; 
    vet[7] = -2;
    vet[8] = -2;       
  }
  
  
    if ( x==12345  && ciliegia ==1)  EEPROM.write(1023, 3 ),ciliegia =0;

 
  if ( mela==1 && x==12345 && EEPROM.read (1023) == 3)   Serial.println("ATTENDI QUALCHE SECONDO"), mela=0;

  if ( pera==1 && x==12345 )  EEPROM.write(numem, 0 ); 
  if ( pera==1 && x==12345 )  numem ++ ;
  if (numem>1022 && pera==1) Serial.println(" "); 
  if (numem>1022 && pera==1) Serial.println(" OK MEMORIA RIPULITA"),pera=0;


 }

azz che lavoro! :slight_smile:
ma tutta la parte iniziale riguarda il controllo della password (possiamo chiamarla così?), in effetti il lavoro di azzeramento sono solo quei 5-6 If... finali?

:astonished: ufficio complicazioni affari semplici?! :astonished:
ti consiglio di dare un'occhiata all'uso dei cicli for..

:fearful:

Dai un'occhiata qui:

E qui:

#include <EEPROM.h>


const int BUFSIZE = 10;
char buffer[BUFSIZE];
int bufIndex = 0;

const char* PASSWORD = "12345";


void fillEeprom(int startAddr, int endAddr, byte value) {
    if (startAddr < 0) {
        return;
    }

    if (endAddr < 0) {
        return;
    }

    if (startAddr > endAddr) {
        return;
    }

    for (int i = startAddr; i <= endAddr; i++) {
        EEPROM.write(i, value);
    }
}


void clearEeprom() {
    fillEeprom(0, 1023, 0xFF);    // ci dovrebbe essere una costante predefinita che indica la fine della EEPROM...
}


void processBuffer(const char* buf) {
    if (strcmp(buf, PASSWORD) == 0) {
        clearEeprom();
        Serial.println("Eeprom cancellata.");
    }
    else {
        Serial.println("Password errata.");
    }
}


void setup() {
    Serial.begin(9600);
}


void loop() {
    char ch;

    while(Serial.available() > 0) {
        ch = Serial.read();

        switch(ch) {
        case 0x0A:
        case 0x0D:
            if (bufIndex > 0) {
                buffer[bufIndex] = 0;
                processBuffer(buffer);
                bufIndex = 0;
            }
            break;

        default:
            if (bufIndex < (BUFSIZE - 1)) {
                buffer[bufIndex];
                bufIndex++;
            }
            else {
                // carattere perso per mancanza di spazio nel buffer
            }
        }
    }
}

L'ho soltanto compilato, ma non provato su una scheda reale. Se ho scritto qualche castroneria, vi prego di segnalarlo, grazie!

:slight_smile:

GINGARDU se vuoi scrivi esattamente cosa fa il tuo sketch....(non ho voglia di leggermelo tutto)..se ho tempo,te ne scrivo uno più leggero..

Ciao,
sono sicuro che la eeprom non viene cancellata quando si carica lo sketch, durante lo sviluppo dell'Ardupower ho ricaricato decine di volte il programma, ma i parametri tcp e la password salvate nella eeprom rimanevano sempre invariati.

Alberto

@bigjohnson:
lo si era già detto fin dalla 1a pagina :wink: