Lezione 8: Utilizziamo il KeyPad con Arduino

In questa ottava puntata su Arduino, introdurremo un nuovo strumento, utile per tanti diversi progetti: il KeyPad.

Il meccanismo di funzionamento è davvero semplice. Esso è formato da 7 cavi, che rappresentano 4 righe e 3 colonne. Attraverso la pressione di un tasto, c’è una variazione di tensione sul Pin collegato ad Arduino e quest’ultimo è in grado di rilevare il relativo valore.

Attraverso questo device è davvero possibile fare tantissimi progetti, come ad esempio una simulazione di un piccolo Bancomat, proteggere una porta d’entrata e tanto altro. Vediamo qualche esempio per Arduino.

Esempi di programmazione del KeyPad

Requisiti Hardware:

• Arduino 
• KeyPad
• LED 
• Relay 
• Servo 

Requisiti Software:

• Libreria keypad

1° Programma: Hello KeyPad

In questo piccolo programma, vedremo come mostrare su seriale il tasto premuto sul KeyPad

/* @file HelloKeypad.pde
|| @version 1.0
|| @author Alexander Brevig
|| @contact [email protected]
||
|| @description
|| | Demonstrates the simplest use of the matrix Keypad library.
|| #
*/
#include <Keypad.h>

const byte ROWS = 4; //four rows
const byte COLS = 3; //three columns
char keys[ROWS][COLS] = {
  {'1','2','3'},
  {'4','5','6'},
  {'7','8','9'},
  {'*','0','#'}
};
byte rowPins[ROWS] = {8,7,6,5}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {4,3,2}; //connect to the column pinouts of the keypad

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

void setup(){
  Serial.begin(9600);
}

void loop(){
  char key = keypad.getKey();

  if (key){
    Serial.println(key);
  }
}

Il funzionamento del programma dal punto di vista hardware è già stato spiegato precedentemente. Dal punto di vista software, la situazione è davvero semplice. Sfruttando le librerie già presenti sul sito di Arduino, il loop() è davvero immediato da capire: una volta che viene premuto qualcosa, si entra in if, che stampa sul seriale il relativo valore, semplice no ? Il collegamento del KeyPad con Arduino è semplice, basta guardare la seguente foto.

In pratica, prendendo il KeyPad dal lato frontale, basta collegare i cavi in modo parallelo, partendo dal Pin 8 fino al Pin 2.

Ecco il video che mostra il KeyPad in azione con Arduino:

 2° Programma: KeyPad che permette di proteggere qualcosa

Questo secondo programma può essere modificato dall’utente. In pratica, questo codice, non fa altro che permette di inserire un codice con il KeyPad, verificarlo tramite Arduino e se tale codice è corretto, accende un LED. In realtà è possibile fare qualsiasi cosa, come ad esempio accendere una lampada, aprire una porta con un servo. Lascio questo codice, in modo che chiunque possa implementarlo a suo piacimento.

/**
Questo programma permette di far inserire da un utente un codice con il KeyPad. Qualora il codice inserito sia corretto, viene accesso un LED.
Per inviare il codice, una volta digitato interamente è necessario premere *. Mentre per spegnere il LED, oppure re-digitare il codice è necessario premere #
Autore Giacomo Bellazzi
Versione 1.0
*/
#include <Keypad.h>
#define LED 13
const byte ROWS = 4; //quattro righe
const byte COLS = 3; //tre colonne
char keyInsert[6];
// Queste variabili servono come verifica del corretto inserimento del codice
int i = 0;
int j = 0;
int s = 0;
int x = 0;
// Codice segreto
char code[7]= "112233";
char keys[ROWS][COLS] = {
  {'1','2','3'},
  {'4','5','6'},
  {'7','8','9'},
  {'*','0','#'}
};
byte rowPins[ROWS] = {8,7,6,5}; //i Pin a cui sono connesse le righe del KeyPad
byte colPins[COLS] = {4,3,2}; // i Pin a cui sono connesse le colonne del KeyPad

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

void setup(){
  Serial.begin(9600);
  pinMode(LED,OUTPUT);
}

void loop(){
  char key = keypad.getKey();
  if (i==0){
    Serial.println("Insert PIN to verify...");
    i++;
  }
  if (key != NO_KEY && j<6){
    Serial.print("*");
    //Serial.println(key);
    keyInsert[j]=key;
    j++;
  }
   if(key == '*') {
      Serial.println();
      Serial.println("Verifyng the code...");
      delay(1000);
      for(s=0; s<6;s++){
        if(keyInsert[s]==code[s]){
          x++;
      }
    } 
      if(x==6){
      Serial.println("The code is correct"); 
      digitalWrite(LED,HIGH); 
      //TODO possibili ulteriori implementazioni
      }else{
         Serial.println("The code is incorrect, please retry");
         delay(2000);
         x=0;
         i=0;
         j=0;
       }

      }  
    if(key == '#'){
        x=0;
        i=0;
        j=0;
        digitalWrite(LED,LOW); 
    }    
}

Il codice risultato essere leggermente un po’ più complesso del primo, tuttavia attraverso i commenti presenti è facile intuire il meccanismo di funzionamento dei vari blocchi di codice. In pratica vengono letti i valori inseriti attraverso il KeyPad. Una volta terminata l’immissione dei 6 caratteri, si preme il comando * e Arduino valuta se il codice inserito è lo stesso di quello presente in memoria. Questo avviene attraverso un ciclo for e un if che verificano se i 6 valori  sono uguali.

Ecco il video che mostra il funzionamento del programma :

3°Programma: Utilizziamo il OTP e il KeyPad

Questo programma è stato realizzato da Luca Dentella, un appassionato di Arduino. Questo programma si basa sull’utilizzo del metodo di sicurezza OTP, che viene usato da chi ha un Online Banking. Per chi non sapesse cosa sia l’OTP, ecco una definizione tratta da Wikiepdia:

Una One-Time Password (password usata una sola volta) è una password che è valida solo per una singola sessione di accesso o una transazione. La OTP evita una serie di carenze associate all’uso della tradizionale password (statica). Il più importante problema che viene risolto da OTP è che, al contrario della password statica, esso non è vulnerabile agli attacchi con replica. Ciò significa che, se un potenziale intruso riesce ad intercettare una OTP che è stata già utilizzata per accedere a un servizio o eseguire una transazione, non sarà in grado di riutilizzarla, in quanto non sarà più valida. D’altra parte, una OTP non può essere memorizzata da una persona. Essa richiede quindi una tecnologia supplementare per poter essere utilizzata.^[1]

Come vengono generate le password OTP ?

Gli algoritmi di generazione delle OTP in genere fanno uso di numeri casuali. Ciò è necessario perché altrimenti sarebbe facile prevedere l’OTP futuro osservando i precedenti. Gli algoritmi OTP che sono stati realizzati sono abbastanza diversi tra loro. I vari approcci per la generazione di OTP sono elencati di seguito.

• Algoritmi basati sulla sincronizzazione temporale tra server di autenticazione e client che fornisce la password (le OTP sono valide solo per un breve periodo di tempo)
• Algoritmi matematici che generano una nuova password in base alla password precedente (le OTP sono, di fatto, una catena di password legate tra loro, e devono essere utilizzate in un ordine predefinito)
• Algoritmi matematici dove la password è basata su una sfida (per esempio, un numero casuale scelto dal server di autenticazione o dai dettagli della transazione) e/o su un contatore.

Ci sono anche diversi modi per rendere note all’utente le successive OTP da usare. Alcuni sistemi elettronici prevedono l’uso di speciali token che l’utente porta con sé, che generano le OTP e le mostrano utilizzando un piccolo display. Altri sistemi sono costituiti da un software che gira sul telefono cellulare dell’utente. Altri sistemi generano le OTP sul lato server e le trasmettono all’utente su un canale fuori banda, come ad esempio un canale di messaggistica SMS. Infine, in alcuni sistemi le OTP sono stampate su carta, che l’utente è tenuto a portare con sé.

In pratica l’OTP si basa su un calcolo di codice, che è formato da una password one time e da un algoritmo che proviene dall’attuale ora.

Per il calcolo del codice, viene incontro una semplice applicazione di Google. Per il download della parte di Arduino, trovato tutto il materiale sul post dell’autore del codice http://www.lucadentella.it/2013/09/14/serratura-otp/2/.

Per prima cosa, è necessario inserire hmackey all’interno del codice di Arduino; questo valore di ricava inserendo la password di default, all’interno di questo script, realizzato sempre da Luca Dentella http://www.lucadentella.it/OTP

Una volta copiato il codice nello Sketch per Arduino, basterà compilare e per quanto riguarda la parte legata ad Arduino, abbiamo finito. Ora è necessario installare il programma per il calcolo del codice OTP sul nostro Smartphone: Google Authenticator.

Ora che abbiamo installato il programma lo apriamo e attraverso la fotocamera, puntiamo lo smartphone sul codice QR che è stato generato in precedenza. Ora abbiamo finito e possiamo testare il programma, attraverso il seriale con Arduino.

Ecco un video che mostra l’utilizzo del programma:

KeyPad 4×4

Sul web è possibile trovare una versione del KeyPad con 16 caratteri, cioè con i numeri dallo zero al nove e le lettere AB,C,D. Il meccanismo di funzionamento è lo stesso, il codice varia leggermente. Ecco due esempi come mostrano l’utilizzo del KeyPad nella sua versione “più grande”:

4° Programma con KeyPad 4×4: HelloKeyPad 4×4

/*Questo programma mostra come usare la tastiera KeyPad 4x4 con Arduino Uno.
Il testo che viene premuto sulla KeyPad viene mostrato nel seriale
*/
#include <Keypad.h>

const byte ROWS = 4; //quattro righe
const byte COLS = 4; //quattro colonne
byte colPins[4] = {5,4,3,2}; // Pin a cui sono connesse le colonne
byte rowPins[4] = {9,8,7,6}; // Pin a cui sono connesse le righe
char Keys[4][4]= //creo la matrice dei tasti della tastiera.
{
{'1','2','3','A'} ,
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};
Keypad keyp = Keypad(makeKeymap(Keys), rowPins, colPins,4,4);

void setup(){
  Serial.begin(9600);
}

void loop(){
  char key = keyp.getKey();
  if (key){
    Serial.println(key);
  }
}

5°Programma con KeyPad 4×4: Codice Segreto con lettere

/**
Questo programma permette di far inserire da un utente un codice con il KeyPad. Qualora il codice inserito sia corretto, viene accesso un LED.
Per inviare il codice, una volta digitato interamente è necessario premere *. Mentre per spegnere il LED, oppure re-digitare il codice è necessario premere #
Autore Giacomo Bellazzi
Versione 1.0
*/
#include <Keypad.h>
#define LED 13
const byte ROWS = 4; //quattro righe
const byte COLS = 4; //quattro colonne
char keyInsert[6];
// Queste variabili servono come verifica del corretto inserimento del codice
int i = 0;
int j = 0;
int s = 0;
int x = 0;
// Codice segreto
char code[7]= "11ABCD";
char Keys[ROWS][COLS]= //creo la matrice dei tasti della tastiera.
{
{'1','2','3','A'} ,
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};
byte colPins[4] = {5,4,3,2}; // Pin a cui sono connesse le colonne
byte rowPins[4] = {9,8,7,6}; // Pin a cui sono connesse le righe

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

void setup(){
  Serial.begin(9600);
  pinMode(LED,OUTPUT);
}

void loop(){
  char key = keypad.getKey();
  if (i==0){
    Serial.println("Insert PIN to verify...");
    i++;
  }
  if (key != NO_KEY && j<6){
    Serial.print("*");
    //Serial.println(key);
    keyInsert[j]=key;
    j++;
  }
   if(key == '*') {
      Serial.println();
      Serial.println("Verifyng the code...");
      delay(1000);
      for(s=0; s<6;s++){
        if(keyInsert[s]==code[s]){
          x++;
      }
    } 
      if(x==6){
        Serial.println("The code is correct"); 
        digitalWrite(LED,HIGH); 
      //TODO possibili ulteriori implementazioni
      }else{
        Serial.println("The code is incorrect, please retry");
        delay(2000);
        x=0;
        i=0;
        j=0;
       }
      }  
    if(key == '#'){
        x=0;
        i=0;
        j=0;
        digitalWrite(LED,LOW); 
    }    
}

Conclusione

Spero che i programmi presentati in questo post, siano di facile lettura e sopratutto, siano possibili di ulteriori implementazioni.