On va voir une chose simple : la réalisation d’une alarme fait maison 🙂

• Tu as le bon mot de passe une LED s’allume
• Et si c’est pas bon, une autre LED s’allume et en plus un buzzer pour faire du bruit 🙂

Vous ne passerez pas !

Comme le projet est simple on va complexifier un peu 🙂

On va faire en sorte qu’après 3 tentatives, le système se bloque. On ajoute aussi un bouton afin de réinitialiser le tout pour débloquer le système. Ici c’est un bouton mais « ce bouton » peut prendre d’autres formes : par exemple dans un vrai système d’alarme on pourrait avoir une télécommande qui arrête notre alarme et/ou le faire via un SMS.

Prérequis du projet

• branchement du keypad
• branchement d’une led
• ajout de la librairie
• configuration nano
• configuration uno

Le principe

Il faut réfléchir au projet avant de commencer. Personnellement, je débute par réaliser le projet sur papier et d’écrire ce qu’il doit se passer :

• L’écran doit nous proposer de rentrer le code (dans l’exemple le moniteur série)
• On doit pouvoir taper sur le clavier afin de rentrer le code
• Il faut limiter le nombre de tentative
• Si on dépasse le nombre de tentative : il n’est plus possible de rentrer un code et l’alarme se déclenche (un buzzer dans notre cas) et la led rouge clignote
• Si le code n’est pas correct, une led rouge s’allume et on garde en mémoire la tentative pour pouvoir l’incrémenter
• Si le code est correct, une led verte s’allume et réinitialise le nombre de tentative
• Il faut un bouton permettant de remettre à 0 tout le code (ça permettra de débloquer le système et surtout d’éteindre le buzzer)

Le code

Voici le Sketch entier qui ressemble énormément à celui du premier article sur le keypad. Il est ici pour les retardataires 🙂

#include <Keypad.h>

/**
   On précise le nombre de ligne et de colonne
*/
const byte ROWS = 4;
const byte COLS = 4;

/**
   Il faut créer un tableau afin de représenter notre clavier
*/
char keyboard[ROWS][COLS] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};

/**
   Ici on initilise les PINS de l'ARDUINO
*/
byte rowPins[ROWS] = {9, 8, 7, 6};
byte colPins[COLS] = {5, 4, 3, 2};

/**
   On utilise notre librairie pour déclarer le clavier
   et on lui donne un nom captainKeypad
*/
Keypad captainKeypad = Keypad(makeKeymap(keyboard), rowPins, colPins, ROWS, COLS);


/**
   Maintenant on va préparer les éléments pour le mot de passe
*/

/**
   Le mot de passe et sa longueur
   On utilise des constantes car les 2 valeurs là ne doivent jamais bouger !
*/
const String captainPasswordHigh = "22*"; // Le mot de passe
const int passwordLength = captainPasswordHigh.length(); // La longueur du mot de passe (3 caractères pour notre exemple) la fonction length() donne la taille de la chaîne de caractères

String userPassword; // On prépare la variable qui va conserver ce que l'utilisateur va taper

bool passwordIsGood; // Variable boolean : true ou false pour dire si le mot de passe est bon ou non
char currentKey; // La valeur que l'utilisateur va taper

int testPassword = 0; // Nombre de tentative de l'utilisateur
int limitTest = 3; // Maximum de tentative possible

/**
   on termine en préparant nos 2 leds
*/
int ledSuccess = 13;
int ledError = 11;

/**
   Et on pense au bouton 🙂
*/
const int buttonPin = 12;

/**
  Sans oublier notre buzzer
*/
const int buzzer = 10;

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

  /**
     On initialise les Leds en OUTPUT car on va leur envoyer des valeurs pour les allumer ou non
  */
  pinMode(ledSuccess, OUTPUT);
  pinMode(ledError, OUTPUT);

  /**
     Et le bouton en INPUT car on va lire la donnée
  */
  pinMode(buttonPin, INPUT);

  /**
    Le buzzer est lui aussi un OUTPUT car on donne ou retire du courant
  */
  pinMode(buzzer, OUTPUT);

  // un message pour informer ce qu'on doit faire
  Serial.println("Entrer le mot de passe de Captain Arduino :");
}

void loop() {
  /**
     On débute par lire le bouton
     Clique ? ou pas clique ?
     Au clique on reset nos données
  */
  if (digitalRead(buttonPin) == HIGH) {
    Serial.println("Réinitialisation !");
    userPassword = "";
    testPassword = 0;
    digitalWrite(buzzer, LOW); // On éteint ce satané buzzer 😀
    return;
  }

  /**
     Est-ce qu'on a atteint la limite de teste
     Si oui, on affiche un message et on fait clignoter la LED ledError (dans la vidéo : la LED rouge)
  */
  if (testPassword == limitTest) {
    Serial.println("Verrouillage du système, déclenchement de l'alarme !");
    digitalWrite(buzzer, HIGH);
    digitalWrite(ledError, HIGH);
    delay(300);
    digitalWrite(ledError, LOW);
    delay(300);
    return; // Le return sert à bloquer le script, on retourne à chaque fois en haut de la boucle et de ce fait la suite n'est plus exécuté
  }

  /**
     On récupère la valeur du clavier et on l'ajoute à notre variable
     L'ajout dans le Serial est juste là afin de visualiser ce qu'il se passe
  */
  currentKey = captainKeypad.getKey();
  if (currentKey != NO_KEY) {
    userPassword += currentKey;
    Serial.println(userPassword);
  }

  /**
     Si la longueur de mot de passe de l'utilisateur est égale à la longueur de notre mot de passe on rentre dans la boucle
     Sinon, on repart en haut de la boucle
     la fonction length() permet d'avoir la taille du chaîne de caractères
  */
  if (userPassword.length() == passwordLength) {
    /*
       On incrémente la variable : le nombre de fois qu'on a tenté un mot de passe
       Cette syntaxe testPassword++ est identique à celle-ci : testPassword = testPassword + 1;
    */
    testPassword++;

    /**
       La fonction equalsIgnoreCase() permet de savoir si le string qu'on teste (ici le mot de passe de l'utilisateur userPassword) est égale à notre mot de passe
       Cette fonction est insensible à la casse

       Si on est bon, victoire 🙂 LED verte signalant qu'on peut entrer
       On pourrait imaginer que cela désactive l'alarme
    */
    if (captainPasswordHigh.equalsIgnoreCase(userPassword)) {
      Serial.println("Correct");
      digitalWrite(ledSuccess, HIGH);
      delay(2000);
      digitalWrite(ledSuccess, LOW);
      testPassword = 0; // on pense à reset le nombre de test
    }
    else {
      /**
         Si le mot de passe est faux
         On a la LED rouge et on affiche un texte
         Et tant qu'on a pas atteint le nombre maximum de tentative, on affiche un second message
      */
      Serial.println("Incorrect");
      if (testPassword < 3) {
        Serial.println("Entrer le mot de passe de Captain Arduino :");
      }
      digitalWrite(ledError, HIGH);
      delay(2000);
      digitalWrite(ledError, LOW);
    }

    /**
       Après une tentative de mot de passe il faut reset la variable
    */
    userPassword = "";
  }
}

J’ai commenté un maximum le code afin qu’il soit le plus simple possible mais si besoin de complément, n’hésitez pas et laissez une question en commentaire.

Résultat

Améliorations possibles ?

La réponse est OUI 🙂

Pour notre projet, je rajoute des LEDs afin d’avoir quelque chose de visuelle et facilement compréhensible mais elles ne sont pas nécessaires.

• On pourrait par exemple supprimer le bouton et gérer la réinitialisation du système via le WIFI avec un ESP8266 ou via un SMS avec un module GSM (peut-être un article en prévision ?)
• Il serait bon que le bon code arrête le buzzer (dans notre exemple ce n’est pas le cas)
• Il faudrait choisir 2 boutons du clavier pour définir un « OK » et un « ANNULE » afin d’augmenter la sécurité car là dans notre cas : automatiquement dès qu’on a mis le nombre de caractère suffisant cela compare le code. En ajoutant un bouton « OK » la personne ne pourra pas savoir si le code comprend : 2, 10, 20, etc. caractères. Et surtout, le clavier n’a pas de bouton « OK » donc déjà juste avec ceci, un intrus de saura pas que le « A » du clavier (par exemple) signifie « OK » dans votre code
• etc.

Si cet article vous a plu, n’hésitez pas à laisser un commentaire, noter et partager l’article.

Partage :

Facebook

Twitter