/*

--------------------------------------------------------------
Controllo Accessi con Master, Add Card, Remove e Pass Card
--------------------------------------------------------------
Si usa una Master Card per programmare le Add Card e le Remove Card
Queste permettono di registrare quali utenti di card possono accedere o no
Si memorizzano i risultati nella EEPROM di capacità 1kBytes
*/
#include <EEPROM.h>// Libreria di gestione EEPROM
#include <SPI.h> // Protocollo SPI
#include <MFRC522.h> // Libreria per il dispositivo Mifare RC522
constexpr uint8_t Led_Rosso = 4;
constexpr uint8_t Led_Verde = 3;
constexpr uint8_t Cancella = 2;// Tasto di cancellazione programmazione
constexpr uint8_t Consenso = 7;// Pin di consenso
boolean match = false;// initializza card match a falso
boolean programMode = false;// initializza programming mode a falso
boolean userCardSelect = false;// initializza userCardSelect a falso
boolean replaceMaster = false;
uint8_t successRead;// Variabile in caso di Lettura corretta dal Lettore RFID
byte storedCard[4];// ID letto dalla EEPROM
byte readCard[4];// ID letto dal Modulo RFID
byte masterCard[4];// ID della Master Card letto dalla EEPROM posizione 0 (2-5)
byte addCard[4];// ID della Add Card letto dalla EEPROM posizione 1 (6-9)
byte deleteCard[4];// ID della Add Card letto dalla EEPROM posizione 2 (10-13)
byte passCard[4];// ID della Pass Card letto dalla EEPROM posizione 3 (14-17)
byte userCard[4];// ID utente
// La lista delle ID Utenti registrati a partire dalla locazione 18
// Inizializza il Lettore RFID MFRC522
MFRC522 mfrc522(10, 9);
//////////// INIZIALIZZAZIONE ////////////
void setup() {
//Configurazione del microcontrollore
pinMode(Led_Rosso, OUTPUT);
pinMode(Led_Verde, OUTPUT);
pinMode(Cancella, INPUT_PULLUP);// Abilita il pull-up
pinMode(Consenso, OUTPUT);
// Configurazione dei Pin al Reset
digitalWrite(Consenso, LOW);// Serratura bloccata
digitalWrite(Led_Rosso, HIGH);// Led Rosso spento
digitalWrite(Led_Verde, HIGH);// Led Verde spento
//Configurazione Protocolli
Serial.begin(9600); // Initializza la comunicazione seriale
SPI.begin(); // Protocollo SPI per dialogo con RFID MFRC522
mfrc522.PCD_Init(); // Initializza il lettore RFID MFRC522
//Guadagno Antenna al massimo aumenta la distanza di lettura
mfrc522.PCD_SetAntennaGain(mfrc522.RxGain_max);
Serial.println(F("Controllo Accessi: Versione 1.0"));
//Se è premuto il Tasto Cancellazione si cancella la EEPROM
if (digitalRead(Cancella) == LOW) {
// inizio della procedura di cancellazione
digitalWrite(Led_Rosso, LOW);
Serial.println(F("Premuto Tasto cancellazione dati memorizzati"));
Serial.println(F("Per confermare tenere il tasto premuto per 10 secondi"));
Serial.println(F("Questo rimuoverà tutti i dati in modo irreversibile"));
bool buttonState = monitorCancella(5000); // Attesa di 5 secondi
// Se dopo 5 secondi il tasto è ancora premuto cancella la EEPROM
if (buttonState == true && digitalRead(Cancella) == LOW) {
Serial.println(F("Inizio cancellazione dati memorizzati"));
// Loop di controllo fine EEPROM
for (uint16_t x = 0; x < EEPROM.length(); x = x + 1) {
if (EEPROM.read(x) == 0) {
//Se fine EEPROM è zero, la EEPROM è vuota
// non fare nulla, la EPPROM è vuota, esci per risparmiare tempo
// e cicli di scrittura della EEPROM
}
else {
// in questo caso scrivi zero per cancellare, impiegando 3.3mS
EEPROM.write(x, 0);
}
}
Serial.println(F("Dati correttamente cancellati"));
// Lampeggio del Led Rosso di conferma cancellazione
digitalWrite(Led_Rosso, HIGH); // spegni il Led Rosso
delay(200);
digitalWrite(Led_Rosso, LOW); // accendi il Led Rosso
delay(200);
digitalWrite(Led_Rosso, HIGH); // spegni il led Rosso
delay(200);
digitalWrite(Led_Rosso, LOW); // accendi il Led Rosso
delay(200);
digitalWrite(Led_Rosso, HIGH); // spegni il Led Rosso
}
else {
// Non si è atteso abbastanza tempo con il tasto premuto
Serial.println(F("Cancellazione annullata"));
digitalWrite(Led_Rosso, HIGH);
}
}
// Controlla che le Program Cards siano definite,
// se no permetti all'utente di definirle
// Oppure si entra qui per ridefinire le Program Cards
// Si possono mantenere tutti gli altri dati registrati nella EEPROM
// scrivendo 170 nella EEPROM all'indirizzo 1.
// L'indirizzo 1 della EEPROM contiene il flag '170'
if (EEPROM.read(1) != 170) {
Serial.println(F("Program Cards non definite"));
Serial.print(F("Per registrare le Program Cards avvicinare "));
Serial.println(F("le card al lettore adesso"));
// Master Card
Serial.println(F("In attesa della Master Card..."));
do {
// se la lettura è avvenuta correttamente successRead = 1 altrimenti = 0
successRead = getID();
// Lampeggio del Led Rosso in attesa della lettura della Master Card
digitalWrite(Led_Rosso, LOW); // accendi il Led Rosso
delay(200);
digitalWrite(Led_Rosso, HIGH); // spegni il Led Rosso
delay(200);
}
// il programma non va avanti fino a che non viene letta la Master Card correttamente
while (!successRead);
// Memorizzazione della Master Card ID nella EEPROM a partire dall'indirizzo 2
for ( uint8_t j = 0; j < 4; j++ ) {
EEPROM.write( 2 + j, readCard[j] );
}
// Add Card
Serial.println(F("In attesa della Add Card..."));
do {
// se la lettura è avvenuta correttamente successRead = 1 altrimenti = 0
successRead = getID();
// Lampeggio del Led Verde in attesa della lettura della Add Card
digitalWrite(Led_Verde, LOW); // accendi il Led Verde
delay(200);
digitalWrite(Led_Verde, HIGH); // spegni il Led Verde
delay(200);
}
// il programma non va avanti fino a che non viene letta la Add Card correttamente
while (!successRead);
// Memorizzazione della Add Card ID nella EEPROM a partire dall'indirizzo 6
for ( uint8_t j = 0; j < 4; j++ ) {
EEPROM.write( 6 + j, readCard[j] );
}
// Delete Card
Serial.println(F("In attesa della Delete Card..."));
do {
// se la lettura è avvenuta correttamente successRead = 1 altrimenti = 0
successRead = getID();
// Lampeggio del Led Rosso in attesa della lettura della Delete Card
digitalWrite(Led_Rosso, LOW); // accendi il Led Rosso
delay(200);
digitalWrite(Led_Rosso, HIGH); // spegni il Led Rosso
delay(200);
}
// il programma non va avanti fino a che non viene letta la Delete Card correttamente
while (!successRead);
// Memorizzazione della Delete Card ID nella EEPROM a partire dall'indirizzo 10
for ( uint8_t j = 0; j < 4; j++ ) {
EEPROM.write( 10 + j, readCard[j] );
}
// Pass Card
Serial.println(F("In attesa della Pass Card..."));
do {
// se la lettura è avvenuta correttamente successRead = 1 altrimenti = 0
successRead = getID();
// Lampeggio del Led Verde in attesa della lettura della Pass Card
digitalWrite(Led_Verde, LOW); // accendi il Led Verde
delay(200);
digitalWrite(Led_Verde, HIGH); // spegni il Led Verde
delay(200);
}
// il programma non va avanti fino a che non viene letta la Pass Card correttamente
while (!successRead);
// Memorizzazione della Pass Card ID nella EEPROM a partire dall'indirizzo 14
for ( uint8_t j = 0; j < 4; j++ ) {
EEPROM.write( 14 + j, readCard[j] );
}
// Scrive nella EEPROM che le Program Cards sono state definite
EEPROM.write(1, 170);
Serial.println(F("Program Cards definite correttamente"));
}
Serial.println(F("-------------------"));
Serial.println(F("Master Card ID"));
for ( uint8_t i = 0; i < 4; i++ ) { // Leggi la Master Card dalla EEPROM
masterCard[i] = EEPROM.read(2 + i); // salva l'ID nel vettore masterCard
Serial.print(masterCard[i], HEX);
}
Serial.println();
Serial.println(F("-------------------"));
Serial.println(F("Add Card ID"));
for ( uint8_t i = 0; i < 4; i++ ) { // Leggi la Add Card dalla EEPROM
addCard[i] = EEPROM.read(6 + i); // salva l'ID nel vettore addCard
Serial.print(addCard[i], HEX);
}
Serial.println();
Serial.println(F("-------------------"));
Serial.println(F("Delete Card ID"));
for ( uint8_t i = 0; i < 4; i++ ) { // Leggi la Delete Card dalla EEPROM
deleteCard[i] = EEPROM.read(10 + i); // salva l'ID nel vettore deleteCard
Serial.print(deleteCard[i], HEX);
}
Serial.println();
Serial.println(F("-------------------"));
Serial.println(F("Pass Card ID"));
for ( uint8_t i = 0; i < 4; i++ ) {// Leggi la Delete Card dalla EEPROM
passCard[i] = EEPROM.read(14 + i);// salva l'ID nel vettore passCard
Serial.print(passCard[i], HEX);
}
Serial.println(); // solo per debug
Serial.println(F("-------------------"));
Serial.println(F("Sistema di Controllo Accessi pronto"));
Serial.println(F("In attesa di leggere una card"));
cycleLeds(); // Segnala l'attesa con un lampeggio in sequenza dei Led Rosso, Verde
}
///////////// FINE INIZIALIZZAZIONE /////////////
///////////// PROGRAMMA PRINCIPALE /////////////
void loop () {
do {
// mette successRead = 1 se si arriva una lettura dal lettore altrimenti = 0
successRead = getID();
// Se adesso viene premuto il Tasto Cancellazione per più di 10 secondi
// si comanda la cancellazione del solo ID di Master Card
// Controlla che il Tasto Cancellazione sia premuto
if (digitalRead(Cancella) == LOW) {
// In caso di Tasto premuto
// interruzione delle operazioni per cancellare la Master Card
digitalWrite(Led_Rosso, LOW);
digitalWrite(Led_Verde, HIGH); // spegne il Led Verde
Serial.println(F("Premuto il Tasto Cancellazione"));
Serial.print(F("Gli ID delle Programs Cards saranno "));
Serial.println(F("cancellati fra dieci secondi!"));
bool buttonState = monitorCancella(5000); // Attesa dei 5 secondi
// se il Tasto è ancora premuto, cancella gli ID delle Program Cards
if (buttonState == true && digitalRead(Cancella) == LOW) {
// Cancella il flag di Program Cards definito all'indirizzo 1 della EEPROM
EEPROM.write(1, 0);
Serial.println(F("Gli ID di Program Cards cancellati dal dispositivo"));
Serial.print(F("Eseguire il Reset per riprogrammare "));
Serial.println(F("gli ID delle Program Cards"));
do {
// Lampeggio del Led Rosso in attesa del Reset
digitalWrite(Led_Rosso, HIGH); // spegni il Led Rosso
delay(200);
digitalWrite(Led_Rosso, LOW); // accendi il Led Rosso
delay(200);
}
while (1);
}
// Non si è atteso abbastanza tempo con il tasto premuto
Serial.println(F("Cancellazione ID di Program Cards annullata"));
}
if (programMode) {
// Lampeggio in sequenza dei Led per segnalare la condizione di Modo Programmazione
cycleLeds();
}
else {
// Nel Modo Operativo Normale i Led sono spenti
normalModeOn();
}
}
// il programma non va avanti se non ottiene una lettura corretta dal Lettore RFID
while (!successRead);
if (programMode) {
// Modo Programmazione attivo
//Se card letta è la Master Card, esce dal Modo Programmazione
if (isMaster(readCard) ) {
// La card letta è la Master Card
Serial.println(F("Letta la Master Card"));
Serial.println(F("Fine Modo Programmazione"));
Serial.println(F("-----------------------------"));
programMode = false;
return;
}
else if(checkTwo(readCard, addCard)) {
if(userCardSelect) {
if(findID(userCard)) {
// Carta già presente
Serial.println(F("Card già presente"));
}
else {
// Carta non presente da aggiungere
writeID(userCard); // aggiunge l'ID nella lista
}
userCardSelect = false;
}
Serial.print(F("Avvicina al lettore la card Utente "));
Serial.println(F("da aggiungere o rimuovere"));
Serial.print(F("Successivamente avvicina al lettore la Add Card "));
Serial.println(F("per aggiungere o la Delete Card per rimuovere la user Card"));
}
else if(checkTwo(readCard, deleteCard)) {
if(userCardSelect) {
if(findID(userCard)) {
// Carta presente da rimuovere
Serial.println(F("Card presente in lista da rimuovere..."));
deleteID(userCard); // cancella l'ID dalla lista
}
else {
// Carta non presente
Serial.println(F("Card non presente"));
}
userCardSelect = false;
}
Serial.print(F("Avvicina al lettore una card Utente "));
Serial.println(F("da aggiungere o rimuovere"));
Serial.print(F("Successivamente avvicina al lettore la Add Card "));
Serial.println(F("per aggiungere o la Delete Card per rimuovere la user Card"));
}
else if(checkTwo(readCard, passCard)) {
// La card letta è la Passpartout;
Serial.println(F("Card Passpartout non necessario memorizzarla"));
Serial.print(F("Avvicina al lettore una card Utente "));
Serial.println(F("da aggiungere o rimuovere"));
Serial.print(F("Successivamente avvicina al lettore la Add Card "));
Serial.println(F("per aggiungere o la Delete Card per rimuovere la user Card"));
}
else {
// La card letta è una userCard
Serial.println(F("letta userCard "));
for ( uint8_t i = 0; i < 4; i++ ) {
userCard[i] = readCard[i]; // salva i valori letti nel vettore userCard
}
userCardSelect = true;
Serial.print(F("Avvicina al lettore la Add Card "));
Serial.println(F("per aggiungere o la Delete Card per rimuovere la user Card"));
}
Serial.print(F("Avvicina al lettore la Master Card "));
Serial.println(F("di nuovo per uscire dal Modo Programmazione"));
Serial.println(F("-----------------------------"));
}
else {
// Modo Programmazione non attivo
// Se la card letta è la Master Card, entra in Modo Programmazione
if ( isMaster(readCard)) {
// La card letta è la Master Card
programMode = true;
userCardSelect = false; // initializza userCardSelect a falso
Serial.println(F("Benvenuto in Modo Programmazione"));
uint8_t count = EEPROM.read(0); // contatore count di lista
Serial.print(F("Ci sono ")); // indica il numero di ID memorizzati
Serial.print(count);
Serial.print(F(" ID(s) memorizzati"));
Serial.println();
Serial.print(F("Avvicina al lettore la card Utente "));
Serial.println(F("da aggiungere o rimuovere"));
Serial.print(F("Successivamente avvicina al lettore la Add Card "));
Serial.println(F("per aggiungere o la Delete Card per rimuovere la user Card"));
Serial.print(F("Avvicina al lettore la Master Card di nuovo "));
Serial.println(F("per uscire dal Modo Programmazione"));
Serial.println(F("-----------------------------"));
}
else {
// La card letta NON è la Master Card
if(checkTwo(readCard, passCard)) {
// La card letta è la Passpartout
Serial.println(F("Card Passpartout, porta sbloccata"));
granted(1000); // dà il consenso all'apertura per 1 secondo
}
// Controlla se la card letta è nella lista memorizzata
else if (findID(readCard)) {
// La card letta è nella lista memorizzata
Serial.println(F("Card autorizzata, porta sbloccata"));
granted(1000); // dà il consenso all'apertura per 1 secondo
}
else {
// La card letta NON è nella lista memorizzata
Serial.println(F("Card non autorizzata"));
denied();
}
}
}
}
/////////// Accesso concesso ///////////
void granted ( uint16_t setDelay) {
digitalWrite(Led_Rosso, HIGH); //spegni il Led Rosso
digitalWrite(Led_Verde, LOW); // Accendi il Led Verde
digitalWrite(Consenso, HIGH); // Sblocca la porta
delay(setDelay); // Tieni il consenso per il tempo selezionato
digitalWrite(Consenso, LOW); // Blocca la porta
delay(1000); // aspetta un secondo
}
/////////// Accesso negato ///////////
void denied() {
digitalWrite(Led_Verde, HIGH); // spegni il Led Verde
digitalWrite(Led_Rosso, LOW); // accendi il Led Rosso
delay(1000); // aspetta un secondo
}
/////////// Acquisisci l'ID di una card ///////////
uint8_t getID() {
// Prepara la lettura di un ID
if ( ! mfrc522.PICC_IsNewCardPresent()) { // se non c'è una card esci
return 0; // segnala lettura non eseguita
}
//fino a che la lettura non è terminata correttamente esci
if ( ! mfrc522.PICC_ReadCardSerial()) {
return 0; // segnala lettura non esguita
}
// Si legge la card a 4 bytes
// Non supporta la lettura della card a 7 bytes
Serial.println(F(" Card ID letto:"));
for ( uint8_t i = 0; i < 4; i++) {
readCard[i] = mfrc522.uid.uidByte[i];
Serial.print(readCard[i], HEX);
}
Serial.println();
mfrc522.PICC_HaltA(); // termina lettura
return 1;
}
/////////// Lampeggio in sequenza (Modo Programmazione) ///////////
void cycleLeds() {
digitalWrite(Led_Rosso, HIGH); // spegni il Led Rosso
digitalWrite(Led_Verde, LOW); // accendi il Led Verde
delay(200);
digitalWrite(Led_Rosso, LOW); // accendi il Led Rosso
digitalWrite(Led_Verde, HIGH); // spegni il Led Verde
delay(200);
}
/////////// Led in Modo Normale ///////////
void normalModeOn () {
digitalWrite(Led_Rosso, HIGH); // spegni il Led Rosso
digitalWrite(Led_Verde, HIGH); // spegni il Led Verde
digitalWrite(Consenso, LOW); // porta bloccata
}
/////////// Read an ID from EEPROM ///////////
void readID( uint8_t number ) {
// Posizione di partenza start = posizione nella lista * 4 a partire dall'indirizzo 2
uint8_t start = (number * 4 ) + 14;
for ( uint8_t i = 0; i < 4; i++ ) {
// Salva i valori letti al vettore storedCard
storedCard[i] = EEPROM.read(start + i);
}
}
/////////// Aggiungi un ID alla EEPROM ///////////
void writeID( byte a[] ) {
// Prima di scrivere l'ID nella EEPROM si controlla che non ci sia già!
if (!findID(a)) {
// Metti in num il numero di elementi memorizzati nella lista,
// considerato che nella posizione 0 è memorizzato l'ID della Master Card
uint8_t num = EEPROM.read(0);
uint8_t start = ( num * 4 ) + 18; // Calcola la prima locazione libera
num++; // Incrementa il contatore di una locazione
if(num<250) {
EEPROM.write( 0, num ); // Aggiorna il valore del contatore nell'indirizzo 0
for ( uint8_t j = 0; j < 4; j++ ) {
// scrivi i valori nella giusta locazione della EEPROM
EEPROM.write( start + j, a[j] );
}
successWrite();
Serial.println(F("ID della card letta aggiunto correttamente"));
}
else {
failedWrite();
Serial.println(F("Memoria piena"));
}
}
else {
failedWrite();
Serial.println(F("Memorizzazione ID card letta fallita"));
}
}

/////////// Rimuovi un ID dalla EEPROM ///////////
void deleteID( byte a[] ) {
// Prima di cancellarlo, verifica che sia in lista!
if ( !findID( a ) ) {
failedWrite(); // se non c'è
Serial.println(F("Cancellazione ID card letta fallita"));
}
else {
// Metti in num il numero di elementi memorizzati nella lista,
// considerato che nella posizione 0 è memorizzato l'ID della Master Card
uint8_t num = EEPROM.read(0);
uint8_t slot; // posizione della card da rimuovere
uint8_t start; // = ( num * 4 ) + 6; // Calcola la prima locazione libera
uint8_t looping; // numero ripetizioni
uint8_t j;
uint8_t count = EEPROM.read(0); // contatore di card memorizzate
slot = findIDSLOT(a); // calcola la posizione della card da rimuovere
start = (slot * 4) + 14;
looping = ((num - slot) * 4);
num--; // Decrement the counter by one
EEPROM.write( 0, num ); // aggiorna il contatore all'indirizzo 0
for ( j = 0; j < looping; j++ ) {
// sposta in su di 4 posizioni gli elementi di lista successivi a quello da rimuovere
EEPROM.write( start + j, EEPROM.read(start + 4 + j));
}
for ( uint8_t k = 0; k < 4; k++ ) {
EEPROM.write( start + j + k, 0);
}
successDelete();
Serial.println(F("ID rimosso correttamente dalla lista memorizzata"));
}
}

/////////// Controlla i bytes di due vettori ///////////
boolean checkTwo ( byte a[], byte b[] ) {
if ( a[0] != 0 ) // verifica che a non sia nullo
match = true; // Assumi che siano uguali
for ( uint8_t k = 0; k < 4; k++ ) {
if ( a[k] != b[k] ) // a != b match = false
match = false;
}
if (match) {
return true;
}
else {
return false;
}
}
/////////// Trova la Posizione di un ID nella lista ///////////
uint8_t findIDSLOT( byte find[] ) {
uint8_t count = EEPROM.read(0); // contatore di ID
for ( uint8_t i = 1; i <= count; i++ ) { // esamina la lista memorizzata in EEPROM
readID(i); // metti in storedCard l'ID corrente della lista
if ( checkTwo( find, storedCard ) ) { // confronta ciascun elelmento della lista con l'ID da trovare
// trovato!
return i; // restituisci la posizione
break; // fermati
}
}
}
/////////// Trova l'ID nella EEPROM ///////////
boolean findID( byte find[] ) {
uint8_t count = EEPROM.read(0); // contatore di ID
for (uint8_t i = 1; i<= count; i++) { // esamina la lista memorizzata in EEPROM
readID(i);
// Confronta ciascun elelmento della lista con l'ID da trovare
if (checkTwo(find, storedCard)){
return true;
break; // trovato
}
else{ // non trovato
}
}
return false;
}
/////////// Lampeggio di conferma scrittura nella EEPROM ///////////
// Lampeggio di tre volte per il Led Verde
void successWrite() {
digitalWrite(Led_Rosso, HIGH); // spegni il Led Rosso
digitalWrite(Led_Verde, HIGH); // spegni il Led Verde
delay(200);
digitalWrite(Led_Verde, LOW); //accendi il Led Verde
delay(200);
digitalWrite(Led_Verde, HIGH); // spegni il Led Verde
delay(200);
digitalWrite(Led_Verde, LOW); // accendi il Led Verde
delay(200);
digitalWrite(Led_Verde, HIGH); // spegni il Led Verde
delay(200);
digitalWrite(Led_Verde, LOW); // accendi il Led Verde
delay(3000);
}
/////////// Lampeggio di fallimento scrittura nella EEPROM ///////////
// Lampeggio di tre volte per il Led Giallo
void failedWrite() {
digitalWrite(Led_Rosso, LOW); // accendi il Led Rosso
delay(200);
digitalWrite(Led_Rosso, HIGH); // spegni il Led Rosso
delay(200);
digitalWrite(Led_Rosso, LOW); // accendi il Led Rosso
delay(200);
digitalWrite(Led_Rosso, HIGH); // spegni il Led Red
delay(200);
digitalWrite(Led_Rosso, LOW); // accendi il Led Red
delay(3000);
}
/////////// Lampeggio di conferma rimozione ID dalla EEPROM ///////////
// Lampeggio di tre volte per il Led Rosso
void successDelete() {
digitalWrite(Led_Rosso, HIGH); // spegni il Led Rosso
digitalWrite(Led_Verde, HIGH); // spegni il Led Verde
delay(200);
digitalWrite(Led_Rosso, LOW); // accendi il Led Rosso
delay(200);
digitalWrite(Led_Rosso, HIGH); // spegni il Led Rosso
delay(200);
digitalWrite(Led_Rosso, LOW); // accendi il Led Rosso
delay(200);
digitalWrite(Led_Rosso, HIGH); // spegni il Led Rosso
delay(200);
digitalWrite(Led_Rosso, LOW); // accendi il Led Rosso
delay(3000);
}
/////////// Controlla che la readCard sia masterCard ///////////
boolean isMaster( byte test[] ) {
if ( checkTwo( test, masterCard ) )
return true;
else
return false;
}
/////////// Test del Tasto di Cancellazione ///////////
bool monitorCancella(uint32_t interval) {
uint32_t now = (uint32_t)millis();
while ((uint32_t)millis() - now < interval) {
// check on every half a second
if (((uint32_t)millis() % 500) == 0) {
if (digitalRead(Cancella) != LOW)
return false;
}
}
return true;
}