Combinazione elettronica ad un tasto-Sketch Arduino

Sketch Arduino per realizzare una combinazione elettronica ad un solo tasto

Questa pagina descrive un software capace di trasformare una scheda Arduino in una  combinazione elettronica ad un solo tasto.

Il programma è strutturato in modo da usare le tempificazioni senza ricorrere al comado delay() e questo significa che il programma può essere utilizzato da solo, oppure anche dentro vostri sketch inserendo il richiamo alla routine all’interno del loop principale.
Attenzione ai programmi troppo onerosi in risorse di cpu o disseminati da molti delay. Il programma “Chiave elettronica a combinazione” richiede che la sua routine sia richiamata dal loop diverse volte al secondo (direi di non scendere sotto alle 20 esecuzioni della routine al secondo).

Ma che cosa è una combinazione elettronica ad un tasto

E’ un dispositivo che permette di aprire un cancello o garage elettrico. E’ ideato come come estrema sicurezza che vi permette di entrare in casa (garage – luogo di lavoro ecc.) nel caso che vi siete dimenticati le chiavi o, peggio ancora, le avete lasciate all’interno della zona protetta e non avete altra possibilità se non quella di rompere qualcosa di molto costoso (vedi porta, finestra, vetrate, porta blindata, muro ecc.).
La chiave fisicamente non è altro che una scheda arduino, un relè, un piccolo pulsante e un led. Il pulsante va occultato in un posto nascosto e azionabile senza dare nell’occhio. Il led nascosto lontano in un posto anche distante decine di metri, la cui luce sia visibile dal tasto e che risulti praticamente invisibile a chi non ne conosce l’esitenza.

Come si mette la chiave della combinazione elettronica

Questa combinazione elettronica ad un tasto funziona così: si preme il tasto. Dopo n secondi il led lampeggia per 9 volte. In questa seqenza di lampeggi occorre premere il tasto in corrispondenza al lampeggio numero x dove x è il numero corrispondente alla prima cifra della combinazione da digitare. Poi dopo una piccola pausa ricomincia la seconda sequenza di 9 lampeggi al quale, come sopra, va premuto il tasto in corrispondenza al lampeggio il cui numero corrisponde al secondo numero della combinazione impostata. E il tutto si ripete per tutti i numeri della combinazione.
A questo punto se la combinazione è impostata correttamente, dopo diversi minuti, il programma attiva il relè per aprire in cancelo o un garage. Se si sbaglia la combinazione, volendo si può far attivare una sirena. Quanto descritto è visibile nel seguente video.

Ma quanto tempo ci vuole per inserire la combinazione

Per inserire la combinazione elettronica ci vuole molto tempo. E’ studiato proprio così. Non solo, se sbagliate a digitare i numeri, dovrete aspettare almeno altri 5 minuti prima che il programma accetti una nuova combinazione. Così impiegherete molto ad inserire la combinazione elettronica e dovrete anche aspettare, dopo aver inserito la combinazione esatta, l’apertura del cancello. Questo, perchè l’obiettivo principale del programma è di obbligare chi digita la combinazione a rimanere nei pressi del pulsante il più a lungo possibile al fine di aumentare la probabilità che sia visto dai vicini o passanti occasionali.
In altre parole il programma si fa utilizzare facendovi perdere molto tempo. Ma è proprio quel tempo che fa desistere un malintenzionato dal tentare perchè gli aumenta il rischio di farsi notare e scoprire.

Come utilizzare il programma

In un scheda Arduino dedicata allo scopo.

Collegare i fili come nello schema e caricare il programma nella CPU dell’Arduino per tramite del suo IDE. Aspettate più di 5 minuti, poi premete il tasto una volta per dare inizio alle squenze di lampeggio.

In un scheda Arduino come routine di uno sketch principale.

Collegare i fili come nello schema. Controllate che i nomi variabili non siano già state usate nel vostro sketch. Inserire le due routine combinazionesetup() e combinazione() in coda al vostro sketch e richiamate la prima all’interno del setup e la seconda all’interno del Loop. Ricordatevi che la routine all’interno del loop deve essere lanciata continuamente, almeno diverse decine di volte al secondo, per poter lavorare parallelamente al vostro sketch. In altre parole assicuratevi di non aver comandi delay(), cicli FOR o WHILE che che fermano l’escuzione del loop per lungo tempo. Ovviamente ogni caso è differente ma in generale se avete i delay, metteteli all’interno di un ciclo FOR, insieme al richiamo alla routine combinazione(), dopo aver diviso il tempo del delay per il numero di iiterazioni (es. Delay(2000) diventa for (int i=0;100;i++) {delay(20); combinazione();}. Se avete cicli For o While mettete al loro interno anche il richiamo a conbinazione().

I parametri principali del programma

I parametri principali necessari per il funzionamento della Combinazione elettronica sono i seguenti:

Questi parametri si possono modificare a secondo delle vostre esigenze.

Il programma/sketch Combinazione elettronica ad un tasto

Il programma può essere usato liberamente, vi chiedo solo l’obbligo morale di lasciare il nome dell’autore all’interno delle routine e di soddisfare la curiosità di sapere che lo state utilizzando (magari con una cartolina illustrata della vostra parte del mondo o alla peggio con una email).
Potete scaricarlo al seguente link:

Chiave_elettronica_a_combinazione_ad_un_solo_tasto-Versione_1_0_1.ino

o visualizzato direttamente qui sotto.

//** *************************************************************************
//** Chiave elettronica a combinazione ad un solo tasto – Ver. 1.0.1  ITALIANO
//** *************************************************************************
//**
//** Autore Corrado Bevilacqua
//**
//** Il programma-Sketch e’ liberamente utilizzabile con seguenti condizioni:
//** 1) obbligo di mantenere il nome dell’autore all’interno delle routine.
//** 2) Invio di una cartolina illustrata della vostra citta’.
//** 3) non per uso commerciale
//**
//** ————————————————————————-
//**
//** Come funziona:
//**
//** Impostare la combinazione nella variabile:
//**     int Cor_combimpostata[] = {1, 2, 3, 4, 5};
//**
//** Caricare lo sketch e quindi inserire la combinazione in questo modo:
//** 1) premere il tasto.
//** 2) Contare i lampeggi
//** 3) Quando numero dei lampeggi contati coincide con la prima cifra
//**    del vostro codice premere il tasto (mentre il led e’ acceso).
//** 4) Aspettare la pausa di 5 secondi alla fine del ciclo di 9 lampeggi
//** 5) Ricontare la nuova serie di lampeggi
//** 6) Quando numero dei lampeggi contati coincide con la seconda cifra
//**    del vostro codice premere il tasto (mentre il led e’ acceso).
//** 7) Aspettare la pausa di 5 secondi alla fine del ciclo di 9 lampeggi
//**    …e continuare cosi’ fino all’inserimento di tutte le cifre.
//** Se il codice cosi’ inserito e’ esatto si accendera’ il pin 10.
//** Se il codice e’ sbagliato si accende il pin 9, eventualmente da
//** collegare a trombe sonore tramite rele’.
//**
//** Per maggiore sicurezza non si puo’ ritentare ad inserire un nuovo
//** codice prima di 5 minuti.
//**
//** Schema collegamenti
//** Collegare una resistenza da 22k tra massa e pin 7 e un pulsante
//** normalmente aperto tra pin 7 e il positivo del 5 Volt.
//** Collegare una resistenza da 1K in serie ad un led e collegare gli
//** estremi tra Pin 11 e la massa. Stessa cosa per il pin 10 e pin 9
//**
//**                 Un programma di Corrado Bevilacqua  2013
//**                  http://myelectronichome.altervista.org
//**
//**
//**
//** *************************************************************************

//** **********************
//** Variabili Modificabili
//** **********************
int Cor_PeriodoImpostato=1000;              //Durata Lampeggio
int Cor_indice = 4;                         //Numero di cifre del codice segreto (da 0 a 4, quindi 5 cifre)
int Cor_combimpostata[] = {1, 2, 3, 4, 5};  //Codice segreto
int Cor_OKTempoacceso = 800;                //tempo in cui il led rimane acceso per l’elettroserratura
int Cor_NONOKTempoacceso = 3000;            //tempo in cui il led non ok rimane acceso per le trombe sonore.
long Cor_TempoStandby = 300000;             //tempo di attesa prima di riprovare ad inserire nuovo codice

//** ********************** **
//** Altre Variabili        **
//** ********************** **
int Cor_CombFatta[] = {0, 0, 0, 0, 0};
int Cor_PrimaVolta;
int Cor_LedAcceso;
int Cor_Conta;
int Cor_Tasto;
int Cor_periodo;
boolean Cor_Pin9;
boolean Cor_Pin10;
double Cor_KeyUltimoTentativo;
double Cor_OldMillis;
double Cor_OkOldMillis;
double Cor_NonOkOldMillis;

void setup()
{
combinazioneSetup();
}

void loop()
{
combinazione();
delay(50);
}

void combinazioneSetup()
{
//** *********************************************** **/
//**    Written by Corrado Bevilacqua 2013 Italy     **/
//** Found on http://myelectronichome.altervista.org **/
//** *********************************************** **/
Cor_PrimaVolta = 0;
Cor_indice = 9;
Cor_KeyUltimoTentativo = 0;

pinMode(11, OUTPUT);   //led lampeggiante
pinMode(10, OUTPUT);   //Led OK
pinMode(9, OUTPUT);    //Led Non OK
pinMode(7, INPUT);

Serial.begin(19200);
Serial.println(“Start- Testpulsanti08_convariabili_modificate”);
Cor_OkOldMillis=-99999;
Cor_NonOkOldMillis=-99999;
Cor_periodo=5000;
}

void combinazione()
{
//** *********************************************** **/
//**    Written by Corrado Bevilacqua 2013 Italy     **/
//** Found on http://myelectronichome.altervista.org **/
//** *********************************************** **/

if (Cor_Pin10==1 && millis() – Cor_OkOldMillis >  Cor_OKTempoacceso )
{
digitalWrite(10, LOW);
Cor_Pin10=0;
}

if (Cor_Pin9==1 && millis() – Cor_NonOkOldMillis >  Cor_NONOKTempoacceso )
{
digitalWrite(9, LOW);
Cor_Pin9=0;
}

if (digitalRead(7) == HIGH && Cor_PrimaVolta == 0)
{
Cor_Tasto = 0;

if (millis() – Cor_KeyUltimoTentativo > Cor_TempoStandby)
{
Cor_indice = 0;
Cor_PrimaVolta = 1;
Cor_Conta = 1;
Cor_OldMillis = millis();
Cor_CombFatta[0] = 0;
Cor_CombFatta[1] = 0;
Cor_CombFatta[2] = 0;
Cor_CombFatta[3] = 0;
Cor_CombFatta[4] = 0;
}
}

if (Cor_indice <= 4)
{
if (digitalRead(7) == HIGH)
{
Cor_Tasto=1;
}

if (millis() – Cor_OldMillis > Cor_periodo)
{
Cor_OldMillis = millis();
//cambia lo stato del led
if (Cor_LedAcceso == 0)
{
digitalWrite(11, HIGH);
Cor_Tasto=0;
Cor_LedAcceso = 1;
Cor_OldMillis = millis();
if (Cor_Conta >= 10)
{
digitalWrite(11, LOW);
Cor_LedAcceso = 0;
Cor_periodo = 5000;
Cor_Conta = 1;
Cor_indice = Cor_indice + 1;
}
else
{
Cor_periodo = Cor_PeriodoImpostato;
}
}
else
{
digitalWrite(11, LOW);
Cor_LedAcceso = 0;
Cor_periodo = Cor_PeriodoImpostato;
if (Cor_Tasto==1)
{
Cor_CombFatta[Cor_indice] = Cor_Conta;
Cor_Tasto = 0;
}
Cor_Conta = Cor_Conta + 1;
}

if (Cor_Conta == 10 && Cor_indice == 4 )
{
Cor_KeyUltimoTentativo = millis();
digitalWrite(11, LOW);
Cor_LedAcceso = 0;
int Cor_Sommali;
Cor_Sommali = 0;
for (int Cor_i=0; Cor_i <= 4; Cor_i++)
{
if (Cor_combimpostata[Cor_i] == Cor_CombFatta[Cor_i])
{
Cor_Sommali = Cor_Sommali + 1;
}
}

if (Cor_Sommali == 5 )
{
Serial.println(“ok”);
digitalWrite(10, HIGH);
Cor_OkOldMillis=millis();
Cor_Pin10=1;
}
else
{
Serial.println(“non ok”);
digitalWrite(9, HIGH);
Cor_NonOkOldMillis=millis();   //tempo di partenza per far rimanere il led acceso
Cor_Pin9=1;
}

Cor_PrimaVolta=0;
}
}
}
}
//** ************************************************************************* **
//**                                                                           **
//**                 Un programma di Corrado Bevilacqua  2013                  **
//**                  http://myelectronichome.altervista.org                   **
//**                                                                           **
//** ************************************************************************* **