accesso a funzioni tramite tastiera 3x3

Ciao a tutti sono pinocchio1,sono nuovo e sono alle prese con la realizzazione del mio primo sketch.
L' intento è di digitare un codice e se corretto avere la possibilità di attivare all'interno di un arco temporale (diciamo 30 secondi) ed in modo monostabile, a seconda della necessità una o più uscite che faranno capo ad altrettanti relè.
Ad esempio col tasto 1 si potrebbe volere accendere una luce, con il tasto due aprire il sezionale di un garage e con il tre magari attivare l'antifurto, evitando ogni volta di ridigitare il codice o digitarne uno diverso.
Dopo il tempo impostato il codice si deve resettare così non si dimentica di farlo manualmente.
Fino al riconoscimento del codice non ho avuto problemi, avvalendomi di esempi trovati online.
Da qui in avanti pur avendo tentato in vari modi, combinando istruzioni "if" "millis" e "for" ma forse per errori di sintassi o forse per poca dimestichezza nell uso delle stesse non sono riuscito a trovare una soluzione soddisfacente e soprattutto funzionale.
Posto di seguito il codice e se qualcuno mi da una dritta lo ringrazio fin d'ora. :slight_smile:

// Tastira 3X3 per la digitazione di un codice segreto che abilita la selezione di
// 5 comandi abbinati ad altrettante uscite

// dichiarazione delle librerie,variabili,costanti,codici delle routine
// e degli oggetti usati display, servomotori ecc.

#include <Keypad.h>

const byte ROWS = 3; //tre righe
const byte COLS = 3; //tre colonne

char keys[ROWS][COLS] = {
  {'1', '2', '3'},
  {'4', '5', '6'},
  {'*', '8', '#'},
};
byte rowPins[ROWS] = {22, 24, 26};  // i Pin a cui sono connesse le righe del KeyPad
byte colPins[COLS] = {23, 25, 27};  // i Pin a cui sono connesse le colonne del KeyPad

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );


char psw[5] ="1234";  // PASSWORD
char inputCode[5];    // CODICE INSERIMENTO
int inputCode_idx;    //CONTATORE PER CODICE INSERITO

int rel1 = 30;
int rel2 = 31;
int rel3 = 32;
int rel4 = 33;
int rel5 = 34;
int buzz = 35;
int led1 = 36;

void routine(void){

  Serial.println();
  Serial.println(inputCode);
  
 char key = keypad.getKey();

  if(key=="1")
   {digitalWrite(rel1,HIGH);
   Serial.println("ANTIFURTO");
      delay(1000);   
      digitalWrite(rel1,LOW);}
  if(key== "2")
   {digitalWrite(rel2,HIGH);
   Serial.println("BATTENTE SX");
      delay(1000);   
      digitalWrite(rel2,LOW);}
  if(key== "3")
   {digitalWrite(rel3,HIGH);
   Serial.println("BATTENTE DX");
      delay(1000);   
      digitalWrite(rel3,LOW);}
  if(key== "4")
   {digitalWrite(rel4,HIGH);
   Serial.println("BATTENTE DX");
      delay(1000);   
      digitalWrite(rel4,LOW);}
  if(key== "5")
   {digitalWrite(rel5,HIGH);
   Serial.println("LUCE PORTICO");
      delay(1000);   
      digitalWrite(rel5,LOW);}
}
      

// inizio setup: dichiarazione delle porte in e out
// istruzioni da eseguire all'avvio del programma

void setup() {

  Serial.begin(9600);
  keypad.setDebounceTime(150);
  pinMode(rel1, OUTPUT);
  pinMode(rel2, OUTPUT);
  pinMode(rel3, OUTPUT);
  pinMode(rel4, OUTPUT);
  pinMode(rel5, OUTPUT);
  pinMode(buzz, OUTPUT);
  pinMode(led1, OUTPUT);
  inputCode_idx = 0;    //RESETTA IL CONTATORE DEL CODICE
  Serial.println("inserire password");
}

  void loop(){

  // esecuzione del codice
  
  char key = keypad.getKey();

  //Serial.print("inserire password");

  if(key !=NO_KEY){ 
    if(key== '#'){
      inputCode_idx = 0;  // RESETTA IL CODICE
      Serial.println("CODICE RESETTATO");
      delay(1000);   
    }else{
      inputCode[inputCode_idx++] = key;
      Serial.print(key);
      if(inputCode_idx == 4){
        inputCode[inputCode_idx] = '\0';
        inputCode_idx = 0;
        Serial.println();
        Serial.println(inputCode);
        if(strcmp(inputCode,psw) != 0){
          digitalWrite(buzz,HIGH);
          delay(1000);
          digitalWrite(buzz,LOW);
        }
      }

   
    }    
  }
      if(strcmp(inputCode,psw) == 0){  // fin qui sembra tutto bene,da qui in aventi mi sono arenato
        
        routine();
        
        //digitalWrite(rel1,HIGH); 
        //Serial.println("APERTO");        
        //delay(2000);
        //Serial.println("CHIUSO");
        
        for(int i= 0;i<4;i++){
         inputCode[i] = '\0';  
         
          }   
      }
      
      
      //digitalWrite(rel1,LOW);
  
   
  
}
if(key=="1")

"1" è una c string literal, in altre parole è un array di caratteri, l'array è composto da 2 caratteri uno è sempre aggiunto dal compilatore come terminatore di stringa '\0'.

Mentre key è una variabile di tipo incompatibile con l'array e non è paragonabile.

In breve usa '1' al posto di "1" ecc, cioè:

if(key=='1')

Altra cosa da rivedere riguardo l'uso di delay, per la tua applicazione dovresti proprio eliminarlo totalmente e in sua sostituzione usare la funzione millis(). Ma facciamo un passo per volta, correggi il codice e ripostalo.

Ciao e benvenuto.

Provvedo immediatamente.
Ciao

// Tastira 3X3 per la digitazione di un codice segreto che abilita la selezione di
// 5 comandi abbinati ad altrettante uscite

// dichiarazione delle librerie,variabili,costanti,codici delle routine
// e degli oggetti usati display, servomotori ecc.

#include <Keypad.h>

const byte ROWS = 3; //tre righe
const byte COLS = 3; //tre colonne

char keys[ROWS][COLS] = {
  {'1', '2', '3'},
  {'4', '5', '6'},
  {'*', '8', '#'},
};
byte rowPins[ROWS] = {22, 24, 26};  // i Pin a cui sono connesse le righe del KeyPad
byte colPins[COLS] = {23, 25, 27};  // i Pin a cui sono connesse le colonne del KeyPad

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );


char psw[5] ="1234";  // PASSWORD
char inputCode[5];    // CODICE INSERIMENTO
int inputCode_idx;    //CONTATORE PER CODICE INSERITO

int rel1 = 30;
int rel2 = 31;
int rel3 = 32;
int rel4 = 33;
int rel5 = 34;
int buzz = 35;
int led1 = 36;

void routine(void){

  Serial.println();
  Serial.println(inputCode);
  
 char key = keypad.getKey();

  if(key=='1')
   {digitalWrite(rel1,HIGH);
   Serial.println("ANTIFURTO");
      delay(1000);   
      digitalWrite(rel1,LOW);}
  if(key== '2')
   {digitalWrite(rel2,HIGH);
   Serial.println("BATTENTE SX");
      delay(1000);   
      digitalWrite(rel2,LOW);}
  if(key== '3')
   {digitalWrite(rel3,HIGH);
   Serial.println("BATTENTE DX");
      delay(1000);   
      digitalWrite(rel3,LOW);}
  if(key== '4')
   {digitalWrite(rel4,HIGH);
   Serial.println("BATTENTE DX");
      delay(1000);   
      digitalWrite(rel4,LOW);}
  if(key== '5')
   {digitalWrite(rel5,HIGH);
   Serial.println("LUCE PORTICO");
      delay(1000);   
      digitalWrite(rel5,LOW);}
}
      

// inizio setup: dichiarazione delle porte in e out
// istruzioni da eseguire all'avvio del programma

void setup() {

  Serial.begin(9600);
  keypad.setDebounceTime(150);
  pinMode(rel1, OUTPUT);
  pinMode(rel2, OUTPUT);
  pinMode(rel3, OUTPUT);
  pinMode(rel4, OUTPUT);
  pinMode(rel5, OUTPUT);
  pinMode(buzz, OUTPUT);
  pinMode(led1, OUTPUT);
  inputCode_idx = 0;    //RESETTA IL CONTATORE DEL CODICE
  Serial.println("inserire password");
}

  void loop(){

  // esecuzione del codice
  
  char key = keypad.getKey();

  //Serial.print("inserire password");

  if(key !=NO_KEY){ 
    if(key== '#'){
      inputCode_idx = 0;  // RESETTA IL CODICE
      Serial.println("CODICE RESETTATO");
      delay(1000);   
    }else{
      inputCode[inputCode_idx++] = key;
      Serial.print(key);
      if(inputCode_idx == 4){
        inputCode[inputCode_idx] = '\0';
        inputCode_idx = 0;
        Serial.println();
        Serial.println(inputCode);
        if(strcmp(inputCode,psw) != 0){
          digitalWrite(buzz,HIGH);
          delay(1000);
          digitalWrite(buzz,LOW);
        }
      }

   
    }    
  }
      if(strcmp(inputCode,psw) == 0){   // fin qui sembra tutto bene,da qui in avanti mi sono arenato
        
        routine();
        
        //digitalWrite(rel1,HIGH); 
        //Serial.println("APERTO");        
        //delay(2000);
        //Serial.println("CHIUSO");
        for(int i= 0;i<4;i++){
         inputCode[i] = '\0';  
         
          }   
      }
      
      
  //digitalWrite(rel1,LOW);
  
   
  
}

Non risulta chiaro cosa vuoi ottenere con questo codice:

  if(key=='1') {
    digitalWrite(rel1,HIGH);
    Serial.println("ANTIFURTO");
    delay(1000);   
    digitalWrite(rel1,LOW);
  }

Quando key=='1' accendi rel1, stampi "ANTIFURTO", poi impegni la CPU in modo esclusivo per 1 secondo e ovviamente scaduto questo tempo viene eseguita la digitalWrite dopo il delay, digitalWrite che spegne rel1.
Per il tempo di 1 secondo la keypad non accetta altri tasti.
Secondo me c'è troppa carne al fuoco, semplifichiamo e concentriamoci sul solo tasto '1'.
Per la password intuisco che dopo averla inserita accetta comandi per almeno 30 secondi poi le credenziali scadono e deve richiedere la password, ho intuito correttamente?
Ciao.

Si, è come hai pensato: la procedura prevede di eseguire la sequenza che hai intuito.
I ritardi che ho inserito hanno lo scopo di dare un tempo minimo di esecuzione del comando perchè venga accettato dall'hardware.
Forse anche qui non ho trovato il modo migliore di farlo.
Avevo immaginato che creare una sequenza con arduino non fosse così dissimile da farlo su un plc, ma nonostante questo non intendo desistere.
Con probabilità a confondere le cose è il fatto di aver immediatamente predisposto una routine che comprende tutti i comandi previsti.

Ciao

pinocchio1:
Si, è come hai pensato: la procedura prevede di eseguire la sequenza che hai intuito.

All'inserimento del codice corretto fai 2 cose:

  • imposta una variabile bool enable = true
  • salva in una variabile unsigned long il valore di millis(); uint32_t timeStart = millis();
    Nella funzione "routine" (che brutto nome!) vai a controllare lo stato di abilitazione prima di eseguire qualsiasi azione.
    Nel loop vai invece a controllare se è passato il tempo massimo di timeout con la solita millis()
if(millis() - timeStart > 30000){
  enable = false;
}

Ciao cotestatnt.
Mio malgrado devo dirti che mi affidi un compito arduo se proporzionato alla mia preparazione.
Mi dovresti indicare in quale punto del codice vanno inserite le varie istruzioni che hai scritto.
Questo è il primo sketch le cui fasi userò come esempio per i miei seguenti ma al momento mi riesce difficile fare quello che mi chiedi.
Grazie

Senza offesa, ma se vuoi imparare come sembrerebbe, secondo me la cosa più saggia è che tu faccia qualche passo indietro e riparta da un buon libro sulla programmazione e non di quelli con solo esempi da copiaincollare.
Se devo dirti metti questa istruzione li e quella la tanto vale che ti scrivo tutto lo sketch, che sarebbe anche legittimo per carità. Io ci perdo 5 minuti del mio tempo libero (che in questi tempi di covid è più che abbondante), ma tu un'occasione per imparare

cotestatnt:
... Se devo dirti metti questa istruzione li e quella la tanto vale che ti scrivo tutto lo sketch, che sarebbe anche legittimo per carità. ...

Emmm ... non proprio ... punto 16.1 e 16.13 del REGOLAMENTO :smiley: :grin: :smiley:

Guglielmo

gpb01:
Emmm ... non proprio ... punto 16.1 e 16.13 del REGOLAMENTO :smiley: :grin: :smiley:

Hai ragione Guglielmo.
In realtà parlavo solo del "concetto generale", non era un'offerta.
Ma è sicuramente poco chiaro per come l'ho scritto, pardon :confused:

Ringraziandovi per l'attenzione preciso che approvo in pieno le osservazioni che avete palesato ritenendo che la forma e la correttezza nel rapporto interpersonale tra gli iscritti debbano essere insite nel forum.
Aggiungo che in fatto hardware ho buona dimestichezza ma per quanto riguarda imparare ad usare il linguaggio wired in tutti i suoi aspetti ho trovato molte difficoltà, essendo stato completamente digiuno di nozioni che riguardassero la programmazione non solo in wired ma nemmeno in C.
Ho acquistato due libri che affrontano l'argomento Arduino partendo da impostazioni diverse ma purtroppo nessuno dei due poteva considerarsi esaustivo.
Per ovvi motivi non cito i titoli.
Quindi ho girovagato online cercando informazioni più mirate.
Il mio obbiettivo è quello di essere autonomo nella stesura di uno sketch e quindi di imparare, non copiare.
Forse la mia richiesta è stata fraintesa dal momento che ho capito il senso delle istruzioni ma non come andassero legate al ciclo che ho postato.
Per una persona competente può essere sottinteso ma non necessariamente per un newbie.
In sostanza non chiedo che mi venga scritto il codice, mi basta che mi venga detto con quale logica debba essere usato.
Grazie :slight_smile:

In sostanza non chiedo che mi venga scritto il codice, mi basta che mi venga detto con quale logica debba essere usato.

Quindi ti sta bene procedere passo passo?
La tua applicazione richiede le credenziali di accesso (login). Quando il login ha avuto successo una variabile dallo stato iniziali false viene impostata a true, ad esempio la variabile isLoggin testata con if(isLoggin == true) ci dice o meno se le credenziali sono valide.

if (isLoggin == true) {
   // qui il codice funzionale per accendere/spegnere pin 

} else {
   // qui il codice che chiede la password
   // sarebbe vantaggioso chiamare la funzione getPassword()

}

// 1) qui il codice che valuta quando sono passati 30 secondi e se sono passati imposta isLoggin = false;

Un variante vuole che i 30 secondi si inizia a contarli dal momento in cui è stato eseguito il comando.

Per il codice che hai scritto deduco che dovresti essere capace a creare una funzione di nome getPassword, se non è così ehmmm sarà dura.

Ciao.

pinocchio1:
In sostanza non chiedo che mi venga scritto il codice, mi basta che mi venga detto con quale logica debba essere usato.

Ricapitolando: tu inserisci il codice di sblocco con il tastierino 3x3, se il codice è corretto allora alla successiva pressione di uno dei tasti esegui una determinata azione. Tutto questo entro un timeout di 30 secondi scaduto il quale il sistema torna nello stato iniziale.
Quindi in sostanza hai tre situazioni principali che devi discriminare

  • è necessario inserire il codice con il tastierino
  • il codice inserito negli ultimi 30 secondi è corretto -> esegui azioni alla pressione dei tasti
  • sono passati 30 secondi, reset del codice inserito.
    Hai bisogno di una variabile che ti indichi se le funzioni sono abilitate oppure no e di una variabile che memorizza il momento in cui abiliti le funzioni cosi da poter valutare se sono trascorsi i 30 secondi (usando millis() ).
    Quindi se la variabile "enable" è false, allora controlli la validità del codice inserito;
    Quando il codice è giusto, questa variabile deve diventare true; in questo modo il blocco di codice per l'inserimento del codice viene disattivato e abiliti il blocco di codice che esegue le funzioni (operatore condizionale if / else)
    Oltre a questo, quando il codice è giusto memorizzi anche il valore di millis() nella seconda variabile in questione e nel loop controlli se sono passati 30 secondi (il come lo trovi più su ed in decine di post in questo forum).

Mi sono sovrapposto a Maurotec

Evidentemente continuo a ripetere lo stesso errore che non riesco a vedere.
In sostanza dopo la verifica del codice imposto enable=true, scrivo le istruzioni per millis, controllo lo stato di enable e di seguito eseguo il codice corrispondente (che ho semplificato per non aggiungere altri problemi con la routine, che per altro avevo rinominato "select" per riguardo! )
ma il ciclo continua a girare nel gruppo di istruzioni attivate da enable=true.
Il display continua a scrivere le righe di Serial.print queste istruzioni non mi servono realmente, le ho inserite solo per vedere in che punto il ciclo si pianta.
La istruzioni che seguono else hanno lo scopo di azzerare il codice per terminare la procedura e riprendere dall'inizio ma come detto li non ci arriva.
Credo di avere impostato male millis visto che non influisce nel cambiare lo stato di enable ma non vedo il modo di correggerlo.
Riposto il codice anche se col rischio di farmi tirare di nuovo le orecchie.
Ciao

#include <Keypad.h>

const byte ROWS = 3; //tre righe
const byte COLS = 3; //tre colonne

char keys[ROWS][COLS] = {
  {'1', '2', '3'},
  {'4', '5', '6'},
  {'*', '8', '#'},
};
byte rowPins[ROWS] = {22, 24, 26};  // i Pin a cui sono connesse le righe del KeyPad
byte colPins[COLS] = {23, 25, 27};  // i Pin a cui sono connesse le colonne del KeyPad

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );


char psw[5] ="1234";  // PASSWORD
char inputCode[5];    // CODICE INSERIMENTO
int inputCode_idx;    //CONTATORE PER CODICE INSERITO

int rel1 = 30;
int rel2 = 31;
int rel3 = 32;
int rel4 = 33;
int rel5 = 34;
int buzz = 35;
int led1 = 36;

  

// inizio setup: dichiarazione delle porte in e out
// istruzioni da eseguire all'avvio del programma

void setup() {

  Serial.begin(9600);
  keypad.setDebounceTime(150);
  pinMode(rel1, OUTPUT);
  pinMode(rel2, OUTPUT);
  pinMode(rel3, OUTPUT);
  pinMode(rel4, OUTPUT);
  pinMode(rel5, OUTPUT);
  pinMode(buzz, OUTPUT);
  pinMode(led1, OUTPUT);
  inputCode_idx = 0;    //RESETTA IL CONTATORE DEL CODICE
  Serial.println("inserire password");
 }

 void loop(){

  // esecuzione del codice
  
 char key = keypad.getKey();

  //Serial.print("inserire password");

  if(key !=NO_KEY){ 
    if(key== '#'){
      inputCode_idx = 0;  // RESETTA IL CODICE
      Serial.println("CODICE RESETTATO");
      delay(1000);   
    }else{
      inputCode[inputCode_idx++] = key;
      Serial.print(key);
      if(inputCode_idx == 4){
        inputCode[inputCode_idx] = '\0';
        inputCode_idx = 0;
        Serial.println();
        Serial.println(inputCode);
        if(strcmp(inputCode,psw) != 0){
          digitalWrite(buzz,HIGH);
          delay(1000);
          digitalWrite(buzz,LOW);
        }
      }

   
    }    
  }
      bool enable=false;
      if(strcmp(inputCode,psw) == 0){
      
        enable=true;
        
       uint32_t timeStart = millis (); 
       if (millis() - timeStart > 10000){
          enable=false;
       }
          
       if(enable=true){
         Serial.println("enable"); 
         digitalWrite(rel1,HIGH); 
         Serial.println("APERTO");        
         //delay(1000);
         Serial.println("CHIUSO");
         digitalWrite(rel1,LOW); 
       }
        else{
        for(int i= 0;i<4;i++){
         inputCode[i] = '\0'; 
         
          }
           
             
         }
        }   
       }

Devi documentarti sulla differenza tra variabili globali e locali. Sintetizzando le variabili globali esistono per tutta la durata del programma, mentre quelle locali vengono create e distrutte ad ogni ciclo del loop.
Aggiungo che le variabili locali non mantengono il loro valore per tutta la durata del programma.

   bool enable=false;
      if(strcmp(inputCode,psw) == 0){
     
        enable=true;

La variabile enable è locale; e non va bene dovrebbe essere definita all'inizio dello sketch al di fuori di ogni funzione

Il codice che scriverò in altro post a seguire da per scontato che il tuo codice per la immissione e valutazione della password sia corretto. Scriverò io la funzione getPassword().

Ciao.

#include <Keypad.h>

const byte ROWS = 3; //tre righe
const byte COLS = 3; //tre colonne

char keys[ROWS][COLS] = {
  {'1', '2', '3'},
  {'4', '5', '6'},
  {'*', '8', '#'},
};
byte rowPins[ROWS] = {22, 24, 26};  // i Pin a cui sono connesse le righe del KeyPad
byte colPins[COLS] = {23, 25, 27};  // i Pin a cui sono connesse le colonne del KeyPad

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );


char psw[5] ="1234";  // PASSWORD
char inputCode[5];    // CODICE INSERIMENTO
byte inputCode_idx;    //CONTATORE PER CODICE INSERITO

bool isPasswordPrinted = false; // permette di stampare "Inserisci password: " una sola volta.
bool isLogged          = false; // isLogged diventa true quando la password inserita è corretta

byte rel1 = 30;
byte rel2 = 31;
byte rel3 = 32;
byte rel4 = 33;
byte rel5 = 34;
byte buzz = 35;
byte led1 = 36;

// funzione che chiede e verifica la password
void getPassword(byte key) {
  if(key == '#') {
  
    inputCode_idx = 0;  // RESETTA IL CODICE
    Serial.println("CODICE RESETTATO");
    //delay(1000); 
    
    return; // punto di uscita prematuro
  } 
  
  inputCode[inputCode_idx++] = key;
  Serial.print(key);
  
  if(inputCode_idx == 4) {
  
    inputCode[inputCode_idx] = '\0';
    inputCode_idx = 0;
    Serial.println();
    Serial.println(inputCode);
    
    if(strcmp(inputCode,psw) != 0) {
      
      isLogged = true;
      isPasswordPrinted = false;
    
      digitalWrite(buzz,HIGH);
      delay(1000);
      digitalWrite(buzz,LOW);
      
    }
    
  } // end if(inputCode_idx == 4) 
   
}
 
void goFunctions(byte key) {
  if (key != NO_KEY) {
    Serial.print(key);
    
    // premere # esegue il logout
    if (key == '#') {  
      isLogged = isPasswordPrinted = false;  
    }
  }
  
}

// inizio setup: dichiarazione delle porte in e out
// istruzioni da eseguire all'avvio del programma

void setup() {

  Serial.begin(9600);
  keypad.setDebounceTime(150);
  pinMode(rel1, OUTPUT);
  pinMode(rel2, OUTPUT);
  pinMode(rel3, OUTPUT);
  pinMode(rel4, OUTPUT);
  pinMode(rel5, OUTPUT);
  pinMode(buzz, OUTPUT);
  pinMode(led1, OUTPUT);
  inputCode_idx = 0;    //RESETTA IL CONTATORE DEL CODICE
  //Serial.println("inserire password");
 }
 
void loop() {

  char key = keypad.getKey();
  
  if (isLogged == true) {
  
    goFunctions(key);
    
  } else {
  
    // chiede e verifica la password
    if (isPasswordPrinted == false) { // utile quando si usa un display
       Serial.println("Inserisci password: ");
       isPasswordPrinted = true;
    }
    getPassword(key);
    //Note: getPassword non dovrebbe verificare la validità.
    //      La verifica andrebbe fatta richiamando una funzione es: bool verifyPassword()
    // isLogged = verifyPassword();
    
  } // end if (isLogged == true)
 
 
} // end loop()

Il codice non è testato e potrebbe non compilare affatto.
Manca la scadenza delle credenziali tramite millis(), ma il codice te lo hanno già suggerito.

Le variabili bool andrebbe nominate come un punto di domanda es: isLogged?

Il programma si divide in un numero di funzioni, al codice postato andrebbero aggiunte altre funzioni, mi sono
limitato per mantenerlo semplice (vedi commento su verifyPassword())

Ciao.

Bene ci perderò ancora qualche ora dispiace ma lo faccio volentieri.
Evidentemente in modo erroneo pensavo che dichiarando la variabile all'inizio ed attribuendole un valore definito sarebbe servito ad inizializzarla.
Poi in loop cambiarne il valore anche più volte non credevo potesse fare danno visto che dove si trova non sarebbe più stata letta.
Per quanto riguarda millis variabile a parte, come avevo scritto le istruzioni che lo compongono sarebbe stato corretto?
Ciao

Ciao Maurotec, oggi ho potuto solo ora rimettermi alla tastiera ( impegni ).
Il codice si compila ma mi devi chiarire un particolare: la pressione di ogni tasto produce la scrittura di un numero a due cifre.
Ad esempio il tasto 1 scrive 49 e via di seguito.
Grazie

pinocchio1:
Ad esempio il tasto 1 scrive 49 e via di seguito.

... e non ti è venuto il dubbio che ... sia semplicemente il valore decimale del carattere ASCII '1' (in hex 0x31)? :smiley:


E' ovvio che se dichiari key come byte, la Serial.print() ti stampa un numero decimale, se dichiari key come char probabilmente ti stampa il carattere corrispondente ...

Guglielmo

Si l'ho pensato ed ho pensato e sono andato a cercarmi la tabella di conversione.
Ho sostituito in alcune righe il valore byte con char ma evidentemente non quello giusto.
Riprovo
Ciao