Informazioni

brunello22:
E come si fa’ a dare qualche piccolo esempio…
Ne vuoi uno, eccolo

#include <EEPROM.h>

int led = { 3, 4, 5, 6, 7, 8 }; // definiamo i pin dei Led
byte cella = 0 ;
#define butt 13
byte led_on = HIGH ; // Valore con cui si accendono i Led (LOW o HIGH )
byte stato ;
int buttonState;             // the current reading from the input pin
int lastButtonState = LOW;   // the previous reading from the input pin
unsigned long lastDebounceTime = 0;  // the last time the output pin was toggled
unsigned long debounceDelay = 50;    // the debounce time; increase if the output flickers

void setup() {
 stato = EEPROM.read( cella );
 pinMode( butt, INPUT );
 // impostiamo i pin dei Led come uscite
 for ( byte a = 0 ; a < 6 ; a++ ) {
   pinMode( led[a], OUTPUT );
 }
 // Ora spegniamo tutti i Led e accendiamo quello memorizzato
 for ( byte a = 0 ; a < 6 ; a++ ) {
   if (a == stato ) {
     digitalWrite( led[a], led_on );
   }
   else {
     digitalWrite( led[a], !led_on ); // Spegniamo i led
   }
 }
} // fine del Setup

void loop() {
 int reading = digitalRead(butt);
 // Facciamo il Debounce
 if (reading != lastButtonState) {
   lastDebounceTime = millis();
 }
 if ((millis() - lastDebounceTime) > debounceDelay) {
   // if the button state has changed:
   if (reading != buttonState) {
     buttonState = reading;
     // cambiamo lo stato quando il pulsante è HIGH
     if (buttonState == HIGH) {
       digitalWrite(led[stato], !led_on);
       stato++;
       if (stato >= 6) stato = 0 ;
       digitalWrite(led[stato], led_on);
       EEPROM.write(cella, stato);
     }
   }
 }
 lastButtonState = reading;
}

Hai perfettamente ragione,è un ca…no,quello che hai scritto tu fa quasi esattamente(meglio, perché se tengo premuto il pulsante i led non scorrono)come quello da me postato e fino li tutto va bene,quello che voglio implementare sono altri due pulsanti che facciano uguale ma con solo due led ciascuno,il mio problema anche leggendo i testi non capisco come inserire nel listato anche questi due pulsanti,per la EEPROM non ho trovato come fare ad adoperare celle diverse,tu hai scritto (byte cella=0)presumo per le successive sia( byte cella=1)e cosi via,nel setup va scritto presumo a parte la quantità dei led uguale pero dentro diverse parentesi graffe??Da conregionale ti ringrazio molto, proverò a modificare il tuo listato per vedere se ci arrivo,ti giuro mi stà fumanto la capa.
Luciano
P.S il 22 stà per età??? cosi fosse, ho voglia che correre per arrivare, nemmeno con la bombola di ossigeno dietro. :confused:

Bulinda provo a risponderti non al tuo problema,ma a questo piccolo battibecco che sta nascendo.

Questo è un forum e ci sono tante persone dietro che dicono la loro,molti sono qui per imparare(tipo me),pochi ne sanno abbastanza per insegnare.

Tutte persone reali di conseguenza ognuno col suo carattere(persone serie,curiose,appassionate,tonte,che vogliono imparare,che voglio fregare il regolamento,che pensano di fare i furbi,che dicono cavolate,che fanno fatica ad esprimersi ECT. ECT.)

Poi ci sono i Moderatori come Guglielmo, che oltre ad essere uno che ne sà abbastanza per insegnare,ha pure il compito di far seguire a tutti il regolamento,in più ha un pessimo carattere(a me mi sgrida sempre),ma ti assicuro che è un buon maestro per molti.

Con Rispetto.

Puso: Bulinda provo a risponderti non al tuo problema,ma a questo piccolo battibecco che sta nascendo.

Questo è un forum e ci sono tante persone dietro che dicono la loro,molti sono qui per imparare(tipo me),pochi ne sanno abbastanza per insegnare.

Tutte persone reali di conseguenza ognuno col suo carattere(persone serie,curiose,appassionate,tonte,che vogliono imparare,che voglio fregare il regolamento,che pensano di fare i furbi,che dicono cavolate,che fanno fatica ad esprimersi ECT. ECT.)

Poi ci sono i Moderatori come Guglielmo, che oltre ad essere uno che ne sà abbastanza per insegnare,ha pure il compito di far seguire a tutti il regolamento,in più ha un pessimo carattere(a me mi sgrida sempre),ma ti assicuro che è un buon maestro per molti.

Nessun battibecco,ho solo espresso qualche perplessità se è stato preso per battibecco non era la mia intenzione e me ne scuso.Per quello che dici delle persone, frequento qualche forum da qualche anno(sai la mia passione è un poco più vecchia)e anche lì ci sono ,ma è fisiologico.Per queste cose somo molto più imparaticcio di te,ma sarà l età che è altina che si vuole magari un poco le cose più in fretta,tempo ne rimane sempre meno.In quanto a Guglielmo e poi chiudo, non lo conosco e a chi non conosco lungi da me dare giudizi e non metto minimamente in dubbio le sue Qulità. Saluti Luciano.

:) OK BELLA VECCHIO :)

PS: Brunello non ha 22 anni, è del 1922. :)

Per quello che riguarda la tua richiesta, io non sono un programmatore, ma principalmente un tecnico hardware (quindi prendi quello che dico col le molle :D), ma credo che il modo piu semplice, o almeno il piu "comodo", anche se probabilmente ci sono sistemi piu eleganti, sia di aggiungere nel loop altri cicli "if", uno per ogni cosa extra, che controllino anche delle flag aggiuntive (semplici variabili byte usate come segnalini), in modo da essere eseguiti solo se tutte le condizioni sono rispettate ...

Ad esempio, per un pulsante che accenda un led e spenga l'altro in modo ciclico ... la butto li al volo ... prima di tutto, un ciclo if-else (o due cicli if consecutivi) per fare in modo che il pulsante non continui ad accendere e spegnere i led per tutto il tempo che viene tenuto premuto, e qui ti serve una flag che "memorizzi" lo stato precedente cambiandogli stato ... per cui "se" pulsante premuto E flag a zero, metti flag ad uno ed esegui le istruzioni (quindi al successivo giro del loop, non verranno piu eseguite perche' anche se pulsante premuto, adesso flag e' uno) ... subito dopo "se" pulsante rilasciato E flag ad uno, metti flag a zero (in modo che alla successiva pressione possa eseguire le istruzioni di nuovo ... le "istruzioni" in questo caso possono essere anche solo un'inversione di una seconda flag, che userai al di fuori di questi if ... ad esempio, se questa seconda flag e' zero, accendi led uno e spegni led due, altrimenti accendi led due e spegni led uno ... questo per poterla memorizzare in modo che alla riaccensione la ritrovi nella eeprom e rimetti le uscite come erano al momento dello spegnimento ...

Sono sicuro che ci siano anche sistemi piu "eleganti", ma come ho detto, non sono un programmatore, a me al volo e' venuto in mente solo questo, ed e' comunque tutto da provare se funziona ...

Puso: ... in più ha un pessimo carattere(a me mi sgrida sempre) ...

... che "buciardo" che sei ... :D :D :D

Guglielmo

_P.S.: ... e NON si dice "a me mi" ... è da matita blu !!! _ :stuck_out_tongue_closed_eyes: :stuck_out_tongue_closed_eyes: :stuck_out_tongue_closed_eyes:

… meglio, perché se tengo premuto il pulsante i led non scorrono

A questo serve il Debounce , https://www.arduino.cc/en/Tutorial/Debounce
Ed è per questo motivo che lo sketch è così lungo

quello che voglio implementare sono altri due pulsanti che facciano uguale ma con solo due led ciascuno

E non potevi dirlo prima
Comunque anche l’esempio che ti ho messo è modificabile, basta replicare 3 volte quello che c’e’ scritto

#include <EEPROM.h>
int led[] = { 3, 4, 5, 6, 7, 8 }; // definiamo i pin dei Led 1° gruppo
int led_a[] = {9, 10 }; // definiamo i pin dei Led 2° grupppo
int led_b[] = { 11, 12 }; // definiamo i pin dei Led 3° gruppo

byte cella = 0 ;
#define butt 13 // Pulsante 1° gruppo
#define butt_a 2  // Pulsante 2° gruppo
#define butt_b 14  // Pin A0  Pulsante 3° gruppo

byte led_on = HIGH ; // Valore con cui si accendono i Led (LOW o HIGH )
byte stato , stato_a, stato_b ;
int buttonState ;             // the current reading from the input pin
int buttonState_a ;
int buttonState_b ;
int lastButtonState = LOW;   // the previous reading from the input pin
int lastButtonState_a = LOW;
int lastButtonState_b = LOW;
unsigned long lastDebounceTime = 0;  // the last time the output pin was toggled
unsigned long lastDebounceTime_a = 0;
unsigned long lastDebounceTime_b = 0;
unsigned long debounceDelay = 50;    // the debounce time; increase if the output flickers

void setup() {
  stato = EEPROM.read( cella );
  stato_a = EEPROM.read( cella + 1 );
  stato_b = EEPROM.read( cella + 2 );
  pinMode( butt, INPUT );
  pinMode( butt_a, INPUT );
  pinMode( butt_b, INPUT );
  // impostiamo i pin dei Led come uscite
  for ( byte a = 0 ; a < 6 ; a++ ) {
    pinMode( led[a], OUTPUT );
  }
  // Ora spegniamo tutti i Led e accendiamo quello memorizzato
  for ( byte a = 0 ; a < 6 ; a++ ) {
    if (a == stato ) {
      digitalWrite( led[a], led_on );
    }
    else {
      digitalWrite( led[a], !led_on ); // Spegniamo i led
    }
  }
  // ******************************************
  for ( byte a = 0 ; a < 2 ; a++ ) {
    pinMode( led_a[a], OUTPUT );
  }
  // Ora spegniamo tutti i Led e accendiamo quello memorizzato
  for ( byte a = 0 ; a < 2 ; a++ ) {
    if (a == stato_a ) {
      digitalWrite( led_a[a], led_on );
    }
    else {
      digitalWrite( led_a[a], !led_on ); // Spegniamo i led
    }
  }
  // ******************************************
  for ( byte a = 0 ; a < 2 ; a++ ) {
    pinMode( led_b[a], OUTPUT );
  }
  // Ora spegniamo tutti i Led e accendiamo quello memorizzato
  for ( byte a = 0 ; a < 2 ; a++ ) {
    if (a == stato_b ) {
      digitalWrite( led_b[a], led_on );
    }
    else {
      digitalWrite( led_b[a], !led_on ); // Spegniamo i led
    }
  }

} // fine del Setup

void loop() {
  // ************************** 1° Gruppo
  int reading = digitalRead(butt);
  // Facciamo il Debounce
  if (reading != lastButtonState) {
    lastDebounceTime = millis();
  }
  if ((millis() - lastDebounceTime) > debounceDelay) {
    // if the button state has changed:
    if (reading != buttonState) {
      buttonState = reading;
      // cambiamo lo stato quando il pulsante è HIGH
      if (buttonState == HIGH) {
        digitalWrite(led[stato], !led_on);
        stato++;
        if (stato >= 6) stato = 0 ;
        digitalWrite(led[stato], led_on);
        EEPROM.write(cella, stato);
      }
    }
  }
  lastButtonState = reading;
  // ************************** 2° Gruppo
  reading = digitalRead(butt_a);
  // Facciamo il Debounce
  if (reading != lastButtonState_a) {
    lastDebounceTime_a = millis();
  }
  if ((millis() - lastDebounceTime_a) > debounceDelay) {
    // if the button state has changed:
    if (reading != buttonState_a) {
      buttonState_a = reading;
      // cambiamo lo stato quando il pulsante è HIGH
      if (buttonState_a == HIGH) {
        digitalWrite(led_a[stato_a], !led_on);
        stato_a++;
        if (stato_a >= 2) stato_a = 0 ;
        digitalWrite(led_a[stato_a], led_on);
        EEPROM.write(cella + 1, stato_a);
      }
    }
  }
  lastButtonState_a = reading;
  // ************************** 3° Gruppo
  reading = digitalRead(butt_b);
  // Facciamo il Debounce
  if (reading != lastButtonState_b) {
    lastDebounceTime_b = millis();
  }
  if ((millis() - lastDebounceTime_b) > debounceDelay) {
    // if the button state has changed:
    if (reading != buttonState_b ) {
      buttonState_b = reading;
      // cambiamo lo stato quando il pulsante è HIGH
      if (buttonState_b == HIGH) {
        digitalWrite(led_b[stato_b], !led_on);
        stato_b++;
        if (stato_b >= 2) stato_b = 0 ;
        digitalWrite(led_b[stato_b], led_on);
        EEPROM.write(cella + 2, stato_b);
      }
    }
  }
  lastButtonState_b = reading;
}

P.S il 22 stà per età???

No, stà per un numero a caso che misi quando mi registrai, visto che Brunello era già occupato.
Siamo quasi coetanei

gpb01:
credo che il problema sia in questa tua richiesta

Più o meno, i segnali sono discordanti. Da una parte l’interesse verso la nuova materia, cosa che inevitabilmente richiede i passi necessari col relativo tempo per digerirli, dall’altra la soluzione veloce completa.

La richiesta delle soluzioni complete mi rende creativo :smiling_imp: per cui eccone qua una, perfettamente funzionante, anche se con parecchie licenze goliardiche.

Non c’è da scrivere una sola riga di codice, basta sostituire al posto dei puntini nelle define i pin che si vogliono usare (valgono anche A0…A5), il livello che fa accendere i LED (che varia a seconda di come lo si collega) e quello fornito dal pulsante premuto (anche questo varia a seconda di come si collega).

Le uscite da LED1 a LED6 sono comandate dal pulsante PULS1
Le uscite da LED7 a LED8 sono comandate dal pulsante PULS2
Le uscite da LED9 a LED10 sono comandate dal pulsante PULS3

Nel caso la EEPROM contenga inizialmente dati non validi questi vengono impostati a zero.

#define ON_LEVEL      ...
#define PRESSED_LEVEL ...
#define PULS1         ...
#define PULS2         ...
#define PULS3         ...
#define LED1          ...
#define LED2          ...
#define LED3          ...
#define LED4          ...
#define LED5          ...
#define LED6          ...
#define LED7          ...
#define LED8          ...
#define LED9          ...
#define LED10         ...
//-----------------------------------------------------------------------
#include <EEPROM.h>
byte a1[]={LED1,LED2,LED3,LED4,LED5,LED6};
byte a2[]={LED7,LED8};
byte a3[]={LED9,LED10};
byte x,y,z;

void setup(){
  x=EEPROM.read(0);if(x>5){x=0;EEPROM.write(0,x);}
  y=EEPROM.read(1);if(y>1){y=0;EEPROM.write(1,y);}
  z=EEPROM.read(2);if(z>1){z=0;EEPROM.write(2,z);}
  pinMode(PULS1,0);pinMode(PULS2,0);pinMode(PULS3,0);
  for(byte k=0;k<6;k++){digitalWrite(a1[k],!ON_LEVEL);pinMode(a1[k],1);}
  for(byte k=0;k<2;k++){digitalWrite(a2[k],!ON_LEVEL);pinMode(a2[k],1);}
  for(byte k=0;k<2;k++){digitalWrite(a3[k],!ON_LEVEL);pinMode(a3[k],1);}
  digitalWrite(a1[x],ON_LEVEL);
  digitalWrite(a2[y],ON_LEVEL);
  digitalWrite(a3[z],ON_LEVEL);}

void f(byte p,byte*a,byte*i,byte e,byte l){
  if(digitalRead(p)==PRESSED_LEVEL){
    digitalWrite(a[*i],!ON_LEVEL);
    *i =(*i+1)%l;
    digitalWrite(a[*i],ON_LEVEL);
    EEPROM.write(e,*i);
    delay(50);while(digitalRead(p)==PRESSED_LEVEL)delay(100);}}

void loop(){f(PULS1,a1,&x,0,6);f(PULS2,a2,&y,1,2);f(PULS3,a3,&z,2,2);}
//-----------------------------------------------------------------------

Tralasciamo il discorso usura EEPROM… non credo si facciano centinaia di manovre al giorno per anni tutti i 365 giorni dell’anno. Ma nel caso teniamo conto delle 100mila scritture garantite (che diventerebbero qualche 10milioni facendo un po’ di rotazione delle celle).

Etemenanki:
altri cicli “if”

La prossima volta che scrivi ciclo if… dico a Guglielmo di bannarti :smiley: :smiley:

Puso:
:wink: :smiley: ;D

Comunque sia un 70enne che che come hobby si trova Arduino,merita un applauso

Grazie,l hobby principale sarebbe un altro, ma a lungo andare non è che le pillole blù faccino tanto bene. :astonished:

brunello22:
A questo serve il Debounce , https://www.arduino.cc/en/Tutorial/Debounce
Ed è per questo motivo che lo sketch è così lungo
E non potevi dirlo prima
Comunque anche l’esempio che ti ho messo è modificabile, basta replicare 3 volte quello che c’e’ scritto

#include <EEPROM.h>

int led = { 3, 4, 5, 6, 7, 8 }; // definiamo i pin dei Led 1° gruppo
int led_a = {9, 10 }; // definiamo i pin dei Led 2° grupppo
int led_b = { 11, 12 }; // definiamo i pin dei Led 3° gruppo

byte cella = 0 ;
#define butt 13 // Pulsante 1° gruppo
#define butt_a 2  // Pulsante 2° gruppo
#define butt_b 14  // Pin A0  Pulsante 3° gruppo

byte led_on = HIGH ; // Valore con cui si accendono i Led (LOW o HIGH )
byte stato , stato_a, stato_b ;
int buttonState ;             // the current reading from the input pin
int buttonState_a ;
int buttonState_b ;
int lastButtonState = LOW;   // the previous reading from the input pin
int lastButtonState_a = LOW;
int lastButtonState_b = LOW;
unsigned long lastDebounceTime = 0;  // the last time the output pin was toggled
unsigned long lastDebounceTime_a = 0;
unsigned long lastDebounceTime_b = 0;
unsigned long debounceDelay = 50;    // the debounce time; increase if the output flickers

void setup() {
 stato = EEPROM.read( cella );
 stato_a = EEPROM.read( cella + 1 );
 stato_b = EEPROM.read( cella + 2 );
 pinMode( butt, INPUT );
 pinMode( butt_a, INPUT );
 pinMode( butt_b, INPUT );
 // impostiamo i pin dei Led come uscite
 for ( byte a = 0 ; a < 6 ; a++ ) {
   pinMode( led[a], OUTPUT );
 }
 // Ora spegniamo tutti i Led e accendiamo quello memorizzato
 for ( byte a = 0 ; a < 6 ; a++ ) {
   if (a == stato ) {
     digitalWrite( led[a], led_on );
   }
   else {
     digitalWrite( led[a], !led_on ); // Spegniamo i led
   }
 }
 // ******************************************
 for ( byte a = 0 ; a < 2 ; a++ ) {
   pinMode( led_a[a], OUTPUT );
 }
 // Ora spegniamo tutti i Led e accendiamo quello memorizzato
 for ( byte a = 0 ; a < 2 ; a++ ) {
   if (a == stato_a ) {
     digitalWrite( led_a[a], led_on );
   }
   else {
     digitalWrite( led_a[a], !led_on ); // Spegniamo i led
   }
 }
 // ******************************************
 for ( byte a = 0 ; a < 2 ; a++ ) {
   pinMode( led_b[a], OUTPUT );
 }
 // Ora spegniamo tutti i Led e accendiamo quello memorizzato
 for ( byte a = 0 ; a < 2 ; a++ ) {
   if (a == stato_b ) {
     digitalWrite( led_b[a], led_on );
   }
   else {
     digitalWrite( led_b[a], !led_on ); // Spegniamo i led
   }
 }

} // fine del Setup

void loop() {
 // ************************** 1° Gruppo
 int reading = digitalRead(butt);
 // Facciamo il Debounce
 if (reading != lastButtonState) {
   lastDebounceTime = millis();
 }
 if ((millis() - lastDebounceTime) > debounceDelay) {
   // if the button state has changed:
   if (reading != buttonState) {
     buttonState = reading;
     // cambiamo lo stato quando il pulsante è HIGH
     if (buttonState == HIGH) {
       digitalWrite(led[stato], !led_on);
       stato++;
       if (stato >= 6) stato = 0 ;
       digitalWrite(led[stato], led_on);
       EEPROM.write(cella, stato);
     }
   }
 }
 lastButtonState = reading;
 // ************************** 2° Gruppo
 reading = digitalRead(butt_a);
 // Facciamo il Debounce
 if (reading != lastButtonState_a) {
   lastDebounceTime_a = millis();
 }
 if ((millis() - lastDebounceTime_a) > debounceDelay) {
   // if the button state has changed:
   if (reading != buttonState_a) {
     buttonState_a = reading;
     // cambiamo lo stato quando il pulsante è HIGH
     if (buttonState_a == HIGH) {
       digitalWrite(led_a[stato_a], !led_on);
       stato_a++;
       if (stato_a >= 2) stato_a = 0 ;
       digitalWrite(led_a[stato_a], led_on);
       EEPROM.write(cella + 1, stato_a);
     }
   }
 }
 lastButtonState_a = reading;
 // ************************** 3° Gruppo
 reading = digitalRead(butt_b);
 // Facciamo il Debounce
 if (reading != lastButtonState_b) {
   lastDebounceTime_b = millis();
 }
 if ((millis() - lastDebounceTime_b) > debounceDelay) {
   // if the button state has changed:
   if (reading != buttonState_b ) {
     buttonState_b = reading;
     // cambiamo lo stato quando il pulsante è HIGH
     if (buttonState_b == HIGH) {
       digitalWrite(led_b[stato_b], !led_on);
       stato_b++;
       if (stato_b >= 2) stato_b = 0 ;
       digitalWrite(led_b[stato_b], led_on);
       EEPROM.write(cella + 2, stato_b);
     }
   }
 }
 lastButtonState_b = reading;
}





No, stà per un numero a caso che misi quando mi registrai, visto che Brunello era già occupato.
Siamo quasi coetanei

Grazie tante,complimenti,io purtroppo con il digitale ci faccio abbastanza ai cazzoti,con l analogico non è che sia un guru ma me la cavo abbastanza,come nell atra passione che è la meccanica.
Grazie di nuovo se capiti dalle parti di Pistoia fammi un fischio,che minimo ti offro un caffè(mi scrivi in privato) :wink:

Claudio_FF:
Più o meno, i segnali sono discordanti. Da una parte l’interesse verso la nuova materia, cosa che inevitabilmente richiede i passi necessari col relativo tempo per digerirli, dall’altra la soluzione veloce completa.

La richiesta delle soluzioni complete mi rende creativo :smiling_imp: per cui eccone qua una, perfettamente funzionante, anche se con parecchie licenze goliardiche.

Non c’è da scrivere una sola riga di codice, basta sostituire al posto dei puntini nelle define i pin che si vogliono usare (valgono anche A0…A5), il livello che fa accendere i LED (che varia a seconda di come lo si collega) e quello fornito dal pulsante premuto (anche questo varia a seconda di come si collega).

Le uscite da LED1 a LED6 sono comandate dal pulsante PULS1
Le uscite da LED7 a LED8 sono comandate dal pulsante PULS2
Le uscite da LED9 a LED10 sono comandate dal pulsante PULS3

Nel caso la EEPROM contenga inizialmente dati non validi questi vengono impostati a zero.

#define ON_LEVEL      ...

#define PRESSED_LEVEL …
#define PULS1         …
#define PULS2         …
#define PULS3         …
#define LED1          …
#define LED2          …
#define LED3          …
#define LED4          …
#define LED5          …
#define LED6          …
#define LED7          …
#define LED8          …
#define LED9          …
#define LED10         …
//-----------------------------------------------------------------------
#include <EEPROM.h>
byte a1={LED1,LED2,LED3,LED4,LED5,LED6};
byte a2={LED7,LED8};
byte a3={LED9,LED10};
byte x,y,z;

void setup(){
 x=EEPROM.read(0);if(x>5){x=0;EEPROM.write(0,x);}
 y=EEPROM.read(1);if(y>1){y=0;EEPROM.write(1,y);}
 z=EEPROM.read(2);if(z>1){z=0;EEPROM.write(2,z);}
 pinMode(PULS1,0);pinMode(PULS2,0);pinMode(PULS3,0);
 for(byte k=0;k<6;k++){digitalWrite(a1[k],!ON_LEVEL);pinMode(a1[k],1);}
 for(byte k=0;k<2;k++){digitalWrite(a2[k],!ON_LEVEL);pinMode(a2[k],1);}
 for(byte k=0;k<2;k++){digitalWrite(a3[k],!ON_LEVEL);pinMode(a3[k],1);}
 digitalWrite(a1,ON_LEVEL);
 digitalWrite(a2[y],ON_LEVEL);
 digitalWrite(a3[z],ON_LEVEL);}

void f(byte p,bytea,bytei,byte e,byte l){
 if(digitalRead(p)==PRESSED_LEVEL){
   digitalWrite(a[*i],!ON_LEVEL);
   *i =(*i+1)%l;
   digitalWrite(a[*i],ON_LEVEL);
   EEPROM.write(e,*i);
   delay(50);while(digitalRead(p)==PRESSED_LEVEL)delay(100);}}

void loop(){f(PULS1,a1,&x,0,6);f(PULS2,a2,&y,1,2);f(PULS3,a3,&z,2,2);}
//-----------------------------------------------------------------------




Tralasciamo il discorso usura EEPROM... non credo si facciano centinaia di manovre al giorno per anni tutti i 365 giorni dell'anno. Ma nel caso teniamo conto delle 100mila scritture garantite (che diventerebbero qualche 10milioni facendo un po' di rotazione delle celle).
La prossima volta che scrivi *ciclo if*.... dico a Guglielmo di bannarti :D :D

Grazie tante anche a te,tu e Brunello per arrivare alla soluzione ho notato che avete scritto due cose diverse,le provo sensaltro tutte e due,confrontandole spero di riuscire a capire i diversi tipi di programmazione e capire un poco di più su Arduino.Per la EEPROM non c è problema una volta sistemato il tutto i pulsanti saranno mossi si è no 10 volte l anno.
Saluti Luciano
P.S per il caffè l invito è valido anche per tè. :wink:

Salve a tutti,vorrei ringraziare tutti quelli che sono intervenuti,sia per consigli sia per aiuti.Sinceramente ero rimasto un poco deluso, ma non avevo calcolato(sbagliando)che essendo nuovo del Forum e cominciare a chiedere quello che ho chiesto qualche sospetto sia nato.Una volta chiarito tutto dò ragione in pieno a chi dice che la comunità di Arduino da veramente mano,mi scuso anche con il moderatore Gugliemo ,lui è lì per fare il suo lavoro.Ora comincia il lavoro per finire il progetto come lo volevo, anche grazie a voi.Per me inizia quasi il divertimento,disegnare al CAD il frontale dove inserire pulsati e led,disegnare il PCB nuovo per togliere i componenti elettromeccanici ed inserire quello digitale con tuti gli annessi,un passatempo da pensionato per tenermi in allenamento.Di nuovo grazie a tutti. Saluti Luciano P.S Non è che non verrò più a rompere anzi,più ci prenderò mano più domanderò. ;D ;D

Claudio_FF: ... La prossima volta che scrivi ciclo if.... dico a Guglielmo di bannarti :D :D

... "istruzioni if" era troppo banale ... :P :D :D :D

Prova questo:

#include <EEPROM.h>
#define cella1 0
#define cella2 1
#define cella3 2

#define butt1 13
#define butt2 14
#define butt3 15

#define led1 3
#define led2 4
#define led3 5
#define led4 6
#define led5 7
#define led6 8
#define led7 9
#define led8 10
#define led9 11
#define led10 12

int l1;
int l2;
int l3;

void setup() 
{
 // -------------------------------- progressivo da led1 a led6
 pinMode(butt1, INPUT);
 pinMode(led1, OUTPUT);
 pinMode(led2, OUTPUT);
 pinMode(led3, OUTPUT);
 pinMode(led4, OUTPUT);
 pinMode(led5, OUTPUT);
 pinMode(led6, OUTPUT);
 digitalWrite(led1, LOW);
 digitalWrite(led2, LOW);
 digitalWrite(led3, LOW);
 digitalWrite(led4, LOW);
 digitalWrite(led5, LOW);
 digitalWrite(led6, LOW);
 l1 = EEPROM.read(cella1);
 if (l1 > led6 || l1 < led1) l1 = led1;
 digitalWrite(l1, HIGH);

 // -------------------------------- bistabile led7 e led8
 pinMode(butt2, INPUT);
 pinMode(led7, OUTPUT);
 pinMode(led8, OUTPUT);
 digitalWrite(led7, LOW);
 digitalWrite(led8, LOW);
 l2 = EEPROM.read(cella2);
 if (l2 > led8 || l2 < led7) l2 = led7;
 digitalWrite(l2, HIGH);

 // -------------------------------- bistabile led9 e led10
 pinMode(butt3, INPUT);
 pinMode(led9, OUTPUT);
 pinMode(led10, OUTPUT);
 digitalWrite(led9, LOW);
 digitalWrite(led10, LOW);
 l3 = EEPROM.read(cella3);
 if (l3 > led10 || l3 < led9) l3 = led9;
 digitalWrite(l3, HIGH); 
}

void loop() 
{
 // -------------------------------- progressivo da led1 a led6
 if (digitalRead(butt1) == HIGH) 
 {
   digitalWrite(l1, LOW);
   l1++;
   if (l1 > led6) l1 = led1;
   digitalWrite(l1, HIGH);
   EEPROM.write(cella1, l1);
   delay(300);
 }

 // -------------------------------- bistabile led7 e led8
 if (digitalRead(butt2) == HIGH) 
 {
   digitalWrite(l2, LOW);
   l2++;
   if (l2 > led8) l2 = led7;
   digitalWrite(l2, HIGH);
   EEPROM.write(cella2, l2);
   delay(300);
 } 

 // -------------------------------- bistabile led9 e led10
 if (digitalRead(butt3) == HIGH) 
 {
   digitalWrite(l3, LOW);
   l3++;
   if (l3 > led10) l3 = led9;
   digitalWrite(l3, HIGH);
   EEPROM.write(cella3, l3);
   delay(300);
 } 

}

Ci sarebbero anche modi più concisi di scriverlo, ma ho preferito non discostarmi troppo dal tuo modo di pensare. Così puoi capirlo meglio e all’occorrenza modificarlo.

Se non fa quello che vorresti, scrivimi specificando cosa fa di sbagliato.

>theremino: ti ricordo che in conformità al regolamento, punto 7, devi editare il tuo post qui sopra (quindi NON scrivendo un nuovo post, ma utilizzando il bottone More → Modify che si trova in basso a destra del tuo post) e racchiudere il codice all’interno dei tag CODE (… sono quelli che in edit inserisce il bottone con icona fatta così: </>, tutto a sinistra). Grazie,

Guglielmo

P.S.: … e sarebbe comunque il caso di rilettura del REGOLAMENTO … magari con attenzione hai punti 16.1 e 16.13. Grazie.

Ho tentato di editarlo ma c'è una attesa obbligatoria di 5 minuti prima di poterlo postare di nuovo. E il tuo post è arrivato immediatamente, prima ancora che io riuscissi ad editarlo.

In pratica, se ho capito bene, il primo post non ha la barra superiore con i comandi tra cui il tag "code". Quindi devi riaprirlo con "Modifica" e aggiungere il "Code" Poi devi aspettare cinque minuti altrimenti non riesci a pubblicarlo.

Il giro è questo o sono io che ho capito male qualcosa?


Ho fatto un po' di prove e ho scoperto cosa sbagliavo, partivo con il Quick Replay al posto del Replay.


Riguardo al regolamento 16.13, il mio intento non era di fornire "la pappa fatta" ma di spiegare con l'esempio. Oltretutto utilizzando le stesse strutture mentali usate dal richiedente, in modo da essere più istruttivo possibile.

Comunque terrò conto di questi consigli e in futuro starò più attento.

theremino: Ho tentato di editarlo ma c'è una attesa obbligatoria di 5 minuti prima di poterlo postare di nuovo. E il tuo post è arrivato immediatamente, prima ancora che io riuscissi ad editarlo.

... lo so, sono sempre in "agguato" :smiling_imp: :smiling_imp: :smiling_imp:

A parte scherzi, SI, fino al raggiungimento del centesimo post c'è un tempo di 5 minuti tra un post e l'altro. Personalmente non so quanto sia da deterrente per chi fa "SPAM", però, lo scopo è quello ... ::)

Guglielmo

theremino: In pratica, se ho capito bene, il primo post non ha la barra superiore con i comandi tra cui il tag "code". Quindi devi riaprirlo con "Modifica" e aggiungere il "Code" Poi devi aspettare cinque minuti altrimenti non riesci a pubblicarlo.

No, no, hai due possibilità ...

  1. il bottone "REPLY" che è sotto ogni post (... che NON è il bottone "Quote"), ti apre direttamente la finestra con i bottoni

  2. il "Quick Replay", che è la finestrella vuota che si trova in basso e che NON ha i bottoni. In tal caso, usa il "Preview" e ti viene aperta la finestra con i bottoni e puoi continuare ad editare da li.

Guglielmo

Come terza alternativa scrivi direttamente i tag apri quadra code chiudi quadra Testo Apri quadra barra code chiudi quadra Esempio: [ c o d e ] testo [ / c o d e ]

ti fa vedere:

testo

e non devi fare preview

Capito, grazie!