Non vorrei essere polemico, ma... bastava leggere:

PIN compreso tra 00000 e 65535 dalla eeprom

Uh ? Are you saying class definitions and variable declarations are the same thing ?

No, I never said that. I'm asking, if you don't like declaring variables in the header file, how you feel about defining classes in header files.

I'm sorry, that's nonsense. Declaration != definition. Classes are defined in header files. Variables should be declared in .cpp files.

You didn't comment on the EEPROM example.

I'm trying to determine whether to take you seriously.

I will ignore personal attacks.


(edit: typo)

Veniamo alla questione  PIN in formato stringa o intero.

Il numero da indovinare lo scrivi in EEPROM sottoforma di unsigned int (ok, suddiviso in due byte, ma non c'entra) e non come stringa di 5 caratteri.
In ingresso invece leggi il numero da indovinare come sequenza di 5 caratteri.

Devi confrontare questi due dati, un unsigned int e una stringa di 5 caratteri.

Hai due strade:
- trasformare l'unsigned int in una stringa di 5 caratteri con zero-padding sinistro (come hai fatto) e confrontare tale stringa con quella fornita dall'utente, oppure
- trasformare la stringa in un unsigned int e confrontare il risultato di questa operazione con l'unsigned int letto dalla EEPROM.

Io credo che sia più semplice il secondo procedimento. L'unico problema è che una stringa che non codifichi per un numero intero (ad esempio perché contiene non-cifre), se sottoposta a atoi() produce 0. Quindi il PIN 00000 verrebbe "indovinato" da qualunque stringa non valida, oltre che da "00000".

L'esempio funziona così: se invio il carattere 'w' (per "write"), viene scritto un certo valore unsigned in in due locazioni  della EEPROM.
Se invece mando il carattere 'r' (per "read"), viene letto un unsigned int da quelle stesse locazioni.
La riga che legge la EEPROM e ricostruisce 'l'intero può essere scritta sia con che senza cast dei due byte letti ad unsigned int:

Code:

//return (((unsigned int)hiByte) << 8) | ((unsigned int)loByte);
    return EEPROM.read(indirizzo + 1) << 8 | EEPROM.read(indirizzo);

Ho notato che utilizzando l'una o l'altra riga il risultato è lo stesso, e cioè viene stampato correttamente il numero che è stato scritto in precedenza nelle due locazioni della EEPROM.

As for declaring variables in .h files being standard practice, let's look at EEPROM.h/.cpp:

Code:

#ifndef EEPROM_h
#define EEPROM_h

#include <inttypes.h>

class EEPROMClass
{
  public:
    uint8_t read(int);
    void write(int, uint8_t);
};

extern EEPROMClass EEPROM;    // <<< reference to a variable declared elsewhere

#endif

Code:

#include <avr/eeprom.h>
#include "Arduino.h"
#include "EEPROM.h"

uint8_t EEPROMClass::read(int address)
{
return eeprom_read_byte((unsigned char *) address);
}

void EEPROMClass::write(int address, uint8_t value)
{
eeprom_write_byte((unsigned char *) address, value);
}

EEPROMClass EEPROM;   // <<< variable declaration is in .cpp file

Mah, sembra che il cast non serva, comunque io lo metterei per stare tranquillo...

Code:

#include <EEPROM.h>


unsigned int numeroDaScrivere = 65230;
int indirizzoEE = 1000;

void scriviIntero(unsigned int valore, int indirizzo) {
    byte loByte = valore & 0x00FF;
    byte hiByte = valore >> 8;
   
    EEPROM.write(indirizzo, loByte);
    EEPROM.write(indirizzo + 1, hiByte);
}


unsigned int leggiIntero(int indirizzo) {
    byte loByte;
    byte hiByte;
   
    loByte = EEPROM.read(indirizzo);
    hiByte = EEPROM.read(indirizzo + 1);
   
    //return (((unsigned int)hiByte) << 8) | ((unsigned int)loByte);
    return EEPROM.read(indirizzo + 1) << 8 | EEPROM.read(indirizzo);
}
   
   
void setup() {
    Serial.begin(115200);
}


void loop() {
    if (Serial.available() > 0) {
        char ch = Serial.read();
       
        switch(ch) {
            case 'r':
                Serial.println(leggiIntero(indirizzoEE));
                break;
               

            case 'w':
                scriviIntero(numeroDaScrivere, indirizzoEE);
                Serial.println("scritto");
                break;
        }
    }
}

ma soprattutto che significa

Code:

intPIN = ((EEPROM.read(6)) | (EEPROM.read(7)<<8));  //legge il  PIN compreso tra 00000 e 65535 dalla eeprom;

in ogni cella della eeprom ci scrivi un byte, il numero del pin non supera certo il 255, perchè usi l'intero?

Guarda che PIN = Personal Identification Number, cioè sinonimo di password, non pin = piedino del micro.

Forse però rileggendo quell'istruzione mancano un paio di cast a int. Appena metto le mani su una UNO provo...

IMHO you should not declare variables in .h files.

Why not? It is standard practice, recommended everywhere else.

What about class definitions?

Uh ? Are you saying class definitions and variable declarations are the same thing ?

prova a spostare quel delay 1000 in fondo al loop, se non altro almeno prima vede i tasti premuti ed esegue le relative cose, poi aspetta 1 sec.

Un delay di 1 secondo è distruttivo ovunque tu lo metta.

delay() = male

Hi, i wanted know what serve the libraries in arduino?
thank you for reply...

What is you _real_ question ?

IMHO you should not declare variables in .h files.

Usa i code tags (pulsante # nell'editor)

Se i due pin, quello inserito dall'utente e quello memorizzato, sono entrambi numeri senza segno, non faresti prima a confrontarli direttamente come tali ?

Code:

unsigned int enteredPin = atoi(char_DTMF_buffer);
unsigned int  storedPin = ((EEPROM.read(6)) | (EEPROM.read(7)<<8));
passBool = enteredPin == storedPin

String è fortemente sconsigliata per problemi di frammentazione della RAM (se ricordo bene), quindi un po' per questo un po' per abitudine non la uso quasi mai su Arduino. Ma certamente è più intuitivo e "facile" concatenare le stringhe con l'operatore + di String che alambiccarsi con buffer, s(n)printf e compagnia...