Lecteur de badge Arduino compatible Diagral

In: ELECTRONIQUE PRATIQUE AVEC L'ARDUINO On: Comment: 0 Hit: 1673

Nous allons expliquer ici comment réaliser, très simplement, un lecteur de badge, compatible notamment avec les badges Diagral.

Pour réussir, il faut généralement:

  • avoir entre 12 et 72 ans
  • être (ou aspirer à être) bricoleur, curieux, méthodique et inventif
  • ne pas craindre l'ordinateur (au choix, Mac ou PC)
  • ne pas être réfractaire à la programmation, avec ses termes en anglais, et parfois à des documents techniques qui n'existent qu'en anglais également.

Pour ce montage, il vous faudra:

  • une carte ARDUINO MEGA2560
  • un module RFID 125 Khz RDM6300
  • un petit module Buzzer (optionnel)
  • une plaquette d'essai
  • quelques fils de liaison mâle-femelle et mâle-mâle

Le coût de ce montage ? Environ 25 €

Tous les éléments nécessaires (et bien d'autres) sont proposés dans ce Kit

Ce montage n'a pas d'autre ambition que de vous donner un aperçu de ce qu'il est possible de réaliser avec les ressources actuelles. Il y a 30 ans, il aurait fallu beaucoup plus de temps, un fer à souder, un oscilloscope et une grosse poignées de composants électroniques.

Bien-sûr, vous pourrez aller beaucoup plus loin: ajouter d'autres capteurs et variables, d'autres actionneurs (gâche électrique, relais 220V, moteurs), un affichage pour rendre le montage plus convivial, ou même une connexion réseau (câble ou Wifi) pour un accès par internet.

Nous supposons que vous avez déjà installé le logiciel Arduino, sinon vous pourrez les télécharger:

Nous utilisons le module RFID RDM6300, conçu pour lire des badges sur la fréquence de 125 Khz. Module signifie que l'électronique nécessaire est déjà rassemblée et assemblée sur une petite carte. Il nous suffira d'exploiter les informations qu'elle va mettre à notre disposition.

schema de branchement du RDM6300

On y connecte l'antenne accordée (connecteur P2), on l'alimente en +5v (connecteur P3, pin2 et pin3) et, dès qu'un badge est placé à proximité de l'antenne, le RDM6300 va transmettre sur son port série standard (connectez la sortie TX du RDM6300 sur l'entrée RX2 de votre carte MEGA2560, une série de 10 nombres identifiant le badge. Il y ajoute une entête (02), une fin (03) et le CRC (2 nombres) qui correspond au contrôle de parité des 10 données. Vous n'êtes pas obligé d'utiliser, dans votre programme, ces 4 informations de contrôle (la première et les 3 dernières des 14).

Le buzzer va permettre d'émettre un petit son, aigüe si le badge est autorisé (dans notre programme) et grave s'il ne l'est pas. Le petit module Buzzer nécessite du 0 et +5V, ainsi que le signal audio (broche 10 de la carte MEGA2560).

Voici une photo de notre montage d'essai:

le module lecteur RFID est enfiché sur une plaquette d'essais afin de faciliter les raccordements. A gauche l'antenne et à droite le buzzer.

la plaquette d'essai semble tellement vide, qu'on vous proposera, en fin d'article, d'y ajouter un petit afficheur LCD.

lecteur de badges Diagral sur Arduino MEGA2560

Le programme (il y en a même deux, avec deux manières de traiter les données) est en bas de page:

Il y a généralement 3 parties dans un programme Arduino:

L'entête dans laquelle on définit les variables utilisées et les éventuelles bibliothèque à inclure. Les bibliothèques sont des sous-programmes permettant d'assurer des fonctions complexes et qui vont donc mettre à notre disposition des outils supplémentaires;

Nous avons mis en commentaire (la ligne commence par //) notre déclaration de bibliothèque car celle-ci est en fait incluse par défaut.

Nous utilisons des variables de type byte (entiers compris entre 0 et 255)

byte resultat[14] permet de créer une variable de type chaîne de 14 bytes; on y rangera progressivement les nombres émis sur son port série par le RDM6300.

Le sous-programme setup() qui est exécuté au démarrage

Il y a démarrage:

  • dès qu'un programme a été chargé avec Arduino
  • quand on appuie sur le bouton "reset" de la carte MEGA2560
  • A la mise sous tension de la carte

Ici, on définit les caractéristiques des 2 ports série utilisés

Serial.begin() est une instruction qui fait partie de la bibliothèque SoftwareSerial.h. Elle permet de définir la vitesse de communication sur le port série 1, qui correspond en pratique au port Usb de la carte MEGA2560. Pendant l'exécution de notre programme, nous envoyons via ce port Usb-série les données recueillies par notre lecteur de badges, afin de mieux comprendre et suivre ce qui se passe.

Rien ne vous empêche d'augmenter cette vitesse de communication (avec des valeurs standards, comme 19200, 38400, 57000). Par contre, il faudra alors accorder cette vitesse dans le logiciel côté ordinateur (Dans Arduino, lancez le Moniteur série que vous trouverez dans le menu Outil; les vitesses possibles s'affichent dans la partie basse de la fenêtre. Nous avons besoin d'un second port de communication série pour le lecteur RFID RDM6300. Pas d'inquiétude, la carte MEGA2560 en possède 3 autres et nous utilisons ici le port 2, d'où l'instruction  Serial2.begin(9600); les 9600 bauds sont cette-fois ci imposés par le module RDM6300.

Pour émettre un son avec le Buzzer, il nous faut une sortie. La carte MEGA2560 possède X entrées/sorties qui est posible de configurer en entrée (un cas ytès simple de lecture serait un bouton poussoir) ou en sortie.

Nous utiliserons le port 10 de notre carte MEGA2560, à configurer en sortie (pinMode(10, OUTPUT);)

Le programme en lui-même est la fonction loop (une boucle qui se répète en principe à l'infini): void loop()
{...}

Il s'agira essentiellement de récupérer les données reçues sur le port série 2, de les analyser et de vérifier qu'elles correspondent à un badge autorisé.

Une première méthode pourrait être d'utiliser Serial2.available() qui retourne le nombre de données disponibles sur le port série (plus précisément dans sa mémoire tampon où elles vont être stockées), d'attendre qu'il soit égal à 14, de vérifier éventuellement qu'on a bien une chaîne cohérente, c'est-à-dire commençant par 2 et se terminant par 3

Vous pouvez essayer le programme qui suit:

//////////////////////////////////////////////////////////////////////////////////////////////////////////

//#include <SoftwareSerial.h>

  byte resultat[14];
  byte badge1[14]={2,48,52,49,57,65,54,51,48,68,57,53,50,3};
  byte data;
  int autorisation;

//--------------------------------------------------------------------------------
   
void setup() {
 
  Serial.begin(9600);
  Serial2.begin(9600);
  pinMode(10, OUTPUT);
}

//--------------------------------------------------------------------------------

void loop() {

if(Serial2.available()>13) {
 
  for (int i=0; i <= 13; i++){
    
    data=Serial2.read();
   
    Serial.print(data);
     resultat[i]=data;
    
    Serial.print(" ");
    }
 
autorisation=0;
Serial.println();
    
for (int i = 0; i<=13; i=i+1){
if (resultat[i] == badge1[i]){
    Serial.print ("valeur ");  Serial.print (i); Serial.println (" ok");
    autorisation++;
    }
else {
    Serial.print ("valeur ");  Serial.print (i); Serial.println (" refusée");
    }
}

Serial.println();
Serial.print ("autorisation : ");
Serial.print (autorisation);

if (autorisation==14)
    
    {
   tone(10, 500, 200);

   }
   else {
   tone(10, 200, 600);
   }
    
}
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////

Mais (au moins) une autre méthode est possible; quand une donnée est disponible sur un port série, un évènement serialEvent() est généré. On peut donc créer un sous-programme qui sera déclenché automatiquement à chaque réception d'un caractère.

A noter que pour le port série 2, il faudra utiliser serialEvent2()

On va "ranger" la donnée récupérée dans notre variable resultat (chaîne de 14 caractères), en première position si la valeur récupérée est 2, puis à la suite (on utilise la variable pointeur pour déterminer le bon endroit).

Pour ceux qui découvrent le langage Arduino:

pointeur++; permet d'incrémenter la valeur de la variable pointeur (on peu aussi écrire pointeur=pointeur+1;

Serial.println(); est équivalent à Serial.print(); mais ajoute un saut de ligne après l'instruction

//////////////////////////////////////////////////////////////////////////////////////////////////////////

#include <SoftwareSerial.h>

  byte resultat[14];
  byte badge1[14]={2,48,52,49,57,65,54,51,48,68,57,53,50,3};
  byte data;
  int autorisation;
  int pointeur;
 
  void testValiditeBadge(){
   autorisation=0;
   for (int i = 0; i<=13; i=i+1)
     if (resultat[i] == badge1[i]){
      autorisation++;
      }

   if (autorisation==14){
    tone(10, 500, 200);
   }
   else {
    tone(10, 200, 600);
   }
  }
 
//--------------------------------------------------------------------------------
  
void setup() {
 
  Serial.begin(9600);
  Serial2.begin(9600);
  pinMode(10, OUTPUT);
}

//--------------------------------------------------------------------------------

void loop() {

}

void serialEvent2(){

  data=Serial2.read();
    Serial.print(data);
    Serial.print(" ");
    if (data==2) {
      resultat[0]=data;
      pointeur=0;
    }
    else {
      pointeur++;
      resultat[pointeur]=data;
      if (pointeur==13){
        Serial.println();
        testValiditeBadge();
    }
    }
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////

Et maintenant, on va ajouter un afficheur LCD

enfichez l'afficheur sur votre plaquette d'essais et faites les liaisons suivantes:

broche 1 (à gauche, notée VSS sur le module): vers le 0V (GND)

broche 2 vers le +5V

broche 3 sur le curseur (point milieu) d'un potentiomètre 10 KOhms (réglage du contraste de l'afficheur)

les 2 autres broches du potentiomètre au 0V et +5V

broche 4 vers le port 4 de la carte MEGA2560

broche 5 vers le 0V

broche 6 vers le port 5 de la carte MEGA2560

broches 7 à 10 inutilisées

broche 11 (notée D4) vers le port 6 de la carte MEGA2560

broche 12 (notée D5) vers le port 7 de la carte MEGA2560

broche 13 (notée D6) vers le port 8 de la carte MEGA2560

broche 14 (notée D7) vers le port 9 de la carte MEGA2560

broche 15 (notée A) vers le +5V

broche 16 (notée K) vers le 0V

Côté programme, on réutilise la seconde version de notre programme précédent et on y ajoute les quelques lignes supplémentaires en gras.

Notre afficheur est compatible avec la bibliothèque LiquidCrystal.h qui met à notre disposition tous les sous-programmes utiles. Et pour les connaître tous, il suffit de se référer à la documentation que l'on trouvera ici

#include <SoftwareSerial.h>
#include <LiquidCrystal.h>
LiquidCrystal lcd(4,5,6,7,8,9); // on indique quels sont les ports utilisés pour contrôler l'afficheur

  byte resultat[14];
  byte badge1[14]={2,48,52,49,57,65,54,51,48,68,57,53,50,3};
  byte data;
  int autorisation;
  int pointeur;
 
  void testValiditeBadge(){
   autorisation=0;
   for (int i = 0; i<=13; i=i+1)
     if (resultat[i] == badge1[i]){
      autorisation++;
      }

   if (autorisation==14){
    tone(10, 500, 200);
    lcd.clear();
    lcd.print("BONJOUR");
    lcd.setCursor(0,2);
    lcd.print("M LE DIRECTEUR");


   }
   else {
    tone(10, 200, 600);
     lcd.clear();
      lcd.print("ACCES REFUSE");
   }
  }
 
//--------------------------------------------------------------------------------
  
void setup() {
 
  Serial.begin(9600);
  Serial2.begin(9600);
  pinMode(10, OUTPUT);
  lcd.begin(16, 2);
  lcd.print("Lecteur badges");
}

//--------------------------------------------------------------------------------

void loop() {

}

void serialEvent2(){

  data=Serial2.read();
    Serial.print(data);
    Serial.print(" ");
    if (data==2) {
      resultat[0]=data;
      pointeur=0;
    }
    else {
      pointeur=pointeur+1;
      resultat[pointeur]=data;
      if (pointeur==13){
        Serial.println();
        testValiditeBadge();
    }
    }
}

Commentaires

Leave your comment