fbpixel
Gérer un Clavier 4×4 Analogique avec Arduino

Gérer un Clavier 4×4 Analogique avec Arduino

Que ce soit une calculatrice ou le digicode d’un immeuble, nous nous servons couramment des claviers numériques. Le clavier numérique 4×4 est une matrice de 16 boutons dont les états peuvent être détectés par un microcontrôleur. Ce module nécessite une seule entrée analogique du microcontrôleur contrairement au Clavier Numérique 4×4 digital.

Matériel

  • Ordinateur
  • Arduino UNO
  • Câble USB A Mâle/B Mâle
  • AnalogKeypad4x4
  • câble Dupont F/M x3

Principe de fonctionnement

Le clavier numérique avec sorite analogique est un ensemble de 16 boutons qui sont montés en matrice avec des résistances de pullup de valeurs différentes. Lorsqu’on appuie sur un bouton le circuit va se fermer avec la résistance et la valeur de tension sur la sortie analogique sera différente pour chaque bouton. L’avantage de ce type de montage est que l’on peut gérer 16 boutons avec seulement 1 entrée analogique du microcontrôleur. Par contre, il n’est pas possible d’appuyer sur deux boutons en même temps.

Schéma

Le clavier numérique utilise une entrée analogique de l’Arduino. Nous branchons donc la sortie du clavier sur la broche A0 du microcontrôleur. Le clavier peut être alimenté par la sortie 5V de l’Arduino.

Code

Pour gérer le clavier numérique, le principe est de lire la valeur de l’entrée analogique qui correspond à un bouton. Pour cela nous allons comparer la valeur de la broche analogique à la valeur donnée à chaque bouton.
Il est important de noter que si on appui sur deux boutons, seul le bouton avec la valeur la plus haute sera retenu.

//Constants
#define nbABtn 16

//Parameters
const int abtnPin = A0;
const int valThresh[nbABtn] = {1000, 900, 820, 750, 660, 620, 585, 540, 500, 475, 455, 425, 370, 300, 260, 200};

void setup() {
  //Init Serial USB
  Serial.begin(9600);
  Serial.println(F("Initialize System"));
}

void loop() {
  readAbtn();
}

void readAbtn() { /* function readAbtn */
  //// Read button states from keypad
  int btnId = getABtn();
  if (btnId) {
    Serial.print("Button pressed : "); Serial.println(btnId);
    delay(200);
  }
}

int getABtn() { /* function getABtn */
  //// Read button states from keypad
  int val = analogRead(abtnPin);
  if (val <= 200) {
    return 0;
  } else {
    for (int i = 0; i < 16; i++) {
      if (val > valThresh[i]) return i + 1;
    }
  }
}

Résultat

Lorsqu’une touche du clavier est pressée, nous observons que la valeur associée s’affiche correctement dans le moniteur série.

Applications

  • Créer une interface avec plusieurs boutons
  • Créer une serrure actionnée par digicode
  • Développer une alarme qui s’active ou se désactive à l’aide d’un mot de passe
  • Développer une interface MIDI

Référence

Retrouvez nos tutoriels et d’autres exemples dans notre générateur automatique de code
La Programmerie

Utilisation du lecteur RFID PN532 avec Arduino

Utilisation du lecteur RFID PN532 avec Arduino

Le module NFC PN532 est un lecteur de carte à puce qui, permet entre autre, d’activer un mécanisme lorsque la bonne carte est présentée au lecteur. On peut le retrouver dans les smartphones, par exemple. Le module RC522 est certainement le module RFID le plus connu dans le monde Arduino mais nous allons voir dans ce tutoriel comment utiliser le lecteur RFID PN532 qui présente certains avantages notamment sur les options de communication. Nous allons voir ici comment utiliser le module en fonction des différentes méthodes de communication UART, SPI, I2C.

Matériel

  • Ordinateur
  • Arduino UNO
  • Câble USB A Mâle/B Mâle
  • Module NFC PN532
  • Câble Dupont M/F

Sélection du mode de communication

Un des gros avantages du module NFC est qu’il peut utiliser différents protocoles pour communiquer avec Arduino, UART, I2C ou SPI. Ces différents protocoles utilisent des broches et des librairies spécifiques du microcontrôleur.

Pour sélectionner le mode de communication, il faut configurer le PN532 à l’aide des interrupteurs DIP (0-Low, 1-High):

SEL0SEL1
UART0 0
SPI01
I2C10

Vérifiez bien que la configuration des interrupteurs DIP correspond aux schéma de cablâge.

Utilisation du module avec la communication Serial

Schéma

Pour la communication série ou UART, Le brochage se fait comme suit (à gauche côté PN532, à droite côté Arduino UNO):

  • Vcc (Alimentation) <-> 5V
  • GND (Masse) <-> GND
  • Rx (Data) <-> Tx
  • Tx (Clock) <-> Rx


Code

Comme il y a différentes options de communication, il faudra utiliser la bonne librairie dans chaque cas. Dans le cas d’un port UART, PN532_HSU.h , pour un port SoftwareSerial , PN532_SWHSU.h . Les fonctions permettant la lecture NFC restent identiques dans chaque cas.

// for Hardware Serial
/*#include <PN532_HSU.h>
  #include <PN532.h>
  PN532_HSU pn532hsu( Serial );
  PN532 nfc( pn532hsu );
*/

// for Software Serial
#include <SoftwareSerial.h>
#include <PN532_SWHSU.h>
#include <PN532.h>
SoftwareSerial SWSerial( 2, 3 ); // RX, TX
PN532_SWHSU pn532swhsu( SWSerial );
PN532 nfc( pn532swhsu );


String tagId = "None", dispTag = "None";
byte nuidPICC[4];

void setup(void) {

  Serial.begin(115200);
  Serial.println("Hello Maker!");
  //  Serial2.begin(115200, SERIAL_8N1, RXD2, TXD2);

  nfc.begin();

  uint32_t versiondata = nfc.getFirmwareVersion();
  if (! versiondata) {
    Serial.print("Didn't Find PN53x Module");
    while (1); // Halt
  }

  // Got valid data, print it out!
  Serial.print("Found chip PN5"); Serial.println((versiondata >> 24) & 0xFF, HEX);
  Serial.print("Firmware ver. "); Serial.print((versiondata >> 16) & 0xFF, DEC);
  Serial.print('.'); Serial.println((versiondata >> 8) & 0xFF, DEC);

  // Configure board to read RFID tags
  nfc.SAMConfig();

  Serial.println("Waiting for an ISO14443A Card ...");

}

void loop() {
  readNFC();
}

void readNFC() {

  boolean success;
  uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 };  // Buffer to store the returned UID
  uint8_t uidLength;                       // Length of the UID (4 or 7 bytes depending on ISO14443A card type)
  success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, &uid[0], &uidLength);

  if (success) {
    Serial.print("UID Length: "); Serial.print(uidLength, DEC); Serial.println(" bytes");
    Serial.print("UID Value: ");

    for (uint8_t i = 0; i < uidLength; i++) {
      nuidPICC[i] = uid[i];
      Serial.print(" "); Serial.print(uid[i], DEC);
    }
    Serial.println();
    tagId = tagToString(nuidPICC);
    dispTag = tagId;
    Serial.print(F("tagId is : "));
    Serial.println(tagId);
    Serial.println("");

    delay(1000);  // 1 second halt

  } else {
    // PN532 probably timed out waiting for a card
    //Serial.println("Timed out! Waiting for a card...");
  }
}

String tagToString(byte id[4]) {
  String tagId = "";
  for (byte i = 0; i < 4; i++) {
    if (i < 3) tagId += String(id[i]) + ".";
    else tagId += String(id[i]);
  }
  return tagId;
}

Utilisation du module avec I2C

Schéma

Pour la communication I2C, Le brochage se fait comme suit :

  • Vcc (Alimentation) <-> 5V
  • GND (Masse) <-> GND
  • SDA (Data) <-> A4
  • SCL (Clock) <-> A5

Code pour la communication I2C

La librairie PN532_I2C.h pour la communication I2C

// for I2C Communication
#include <Wire.h>
#include <PN532_I2C.h>
#include <PN532.h>
#include <NfcAdapter.h>
PN532_I2C pn532_i2c(Wire);
NfcAdapter nfc = NfcAdapter(pn532_i2c);

String tagId = "None";
byte nuidPICC[4];

void setup(void) {
  Serial.begin(115200);
  Serial.println("System initialized");

  nfc.begin();
}

void loop() {
  readNFC();
}

void readNFC() {
  if (nfc.tagPresent())
  {
    NfcTag tag = nfc.read();
    tag.print();
    tagId = tag.getUidString();
  }
  delay(5000);
}

Utilisation du module avec SPI

Schéma

Pour la communication SPI, Le brochage se fait comme suit:

  • Vcc (Alimentation) <-> 5V/3V3
  • RST (Reset) <-> 9
  • GND (Masse) <-> GND
  • MISO (Master Input Slave Output) <-> 11
  • MOSI (Master Output Slave Input) <-> 12
  • SCK (Serial Clock) <-> 13
  • SS (Slave select) <-> 10

Code pour la communication SPI

PN532_SPI.h pour la communication via le port SPI.

// for SPI Communication
#include <SPI.h>
#include <PN532_SPI.h>
#include <PN532.h>
#include <NfcAdapter.h>
PN532_SPI interface(SPI, 10); // create a PN532 SPI interface with the SPI CS terminal located at digital pin 10
NfcAdapter nfc = NfcAdapter(interface); // create an NFC adapter object


String tagId = "None";

void setup(void) {
  Serial.begin(115200);
  Serial.println("System initialized");

  nfc.begin();
}

void loop() {
  readNFC();
}

void readNFC() {
  if (nfc.tagPresent())
  {
    NfcTag tag = nfc.read();
    tag.print();
    tagId = tag.getUidString();
  }
  delay(5000);
}

Applications

  • Ouverture de serrure par carte magnétique

Sources

Retrouvez nos tutoriels et d’autres exemples dans notre générateur automatique de code
La Programmerie

Mesure de force avec Arduino et le module HX711

Mesure de force avec Arduino et le module HX711

Il existe des capteurs de force assez simple d’utilisation et compatible avec les microcontrôleurs comme Arduino. Ils se composent d’une cellule d’effort et d’un module de conversion. La cellule d’effort est un capteur à jauge de contrainte permettant de mesurer un effort dans une seule direction de l’espace. Il est généralement accompagné d’un module HX711 capable d’amplifier la mesure des efforts appliqués sur la cellule de force.

Matériel

  • Ordinateur
  • Arduino UNO
  • Câble USB A Mâle/B Mâle
  • Module HX711
  • Cellule d’effort

Principe de fonctionnement

Le module HX711 est composé d’un amplificateur et d’un convertisseur analogique numérique HX711. Il permet l’amplification d’un signal envoyé par une cellule d’effort. Le capteur d’effort utilise un pont de Weahstone afin de convertir l’effort qui lui est appliqué en signal analogique.

Schéma

Le module HX711 communique avec le microcontrôleur à l’aide de deux broches digitale (SCK et DOUT) et est alimenté en 5V. Il est relié à la cellule de force par 4 fils dont la couleur reste standard sur les ponts de Wheastone:

  • Excitation+ (E+) or VCC RED
  • Excitation- (E-) or GND BLACK or YELLOW
  • Output+ (O+), Signal+ (S+), or Amplifier+ (A+) WHITE
  • O-, S-, or A- GREEN or BLUE

Code

Pour récupérer une valeur de force du capteur, celui-ci doit-être calibré. Pour réaliser la calibration, il vous faudra lancer le code avec deux masses connues différents afin de calculer le gain et offset du capteur.

//Libraries
#include <HX711.h>//https://github.com/bogde/HX711

//Parameters
const long LOADCELL_OFFSET = 340884;
const float LOADCELL_DIVIDER = 262.5F;
const int numberOfReadings = 10;
const int doutPin = 2;
const int sckPin = 4;

//Variables
HX711 scale = ;
float weight = 0;
float initWeight = 0;

void setup() {
  //Init Serial USB
  Serial.begin(9600);
  Serial.println(F("Initialize System"));
  scale.begin(doutPin, sckPin);
  scale.set_scale(); //remove scale divider
  scale.tare();      // reset the scale to 0

  //find
  Serial.println("Put a known wait and send command");
  while (Serial.available() == 0) {}
  Serial.print("Compute average on 10...");
  Serial.println(scale.get_units(10), 1); //repeat with two different weight to find DIVIDER and OFFSET
  //WEIGHT= (val-OFFSET)/DIVIDER
  scale.set_scale(LOADCELL_DIVIDER);
  scale.tare();
  //scale.set_offset(LOADCELL_OFFSET);
  delay(200);
  initWeight = scale.get_units(numberOfReadings * 10), 10;
}

void loop() {
  readScale();
}

void readScale() { /* function readScale */
  //// Read button states from keypad
  if (scale.is_ready()) {
    weight = scale.get_units(numberOfReadings), 10;
    Serial.print("weight : ");
    Serial.println(weight);
  } else {
    Serial.println("HX711 not found.");
  }
}


Résultat

Lorsque le capteur de force est calibré, il renvoie la valeur en g ou en kg (ou même N) selon l’unité que vous avez choisit lors du calcul des paramètres du capteurs. Il est possible de lisser la mesure sur plusieurs valeurs en plaçant le nombre de lectures désirées dans la fonction get_units(numberOfReadings). Cela permet d’avoir une mesure plus stable et plus juste de l’effort.

Applications

  • Créer une balance connectée
  • Activer un mécanisme en fonction du poids d’un objet

Sources

Retrouvez nos tutoriels et d’autres exemples dans notre générateur automatique de code
La Programmerie

Réalisation d’une barrière automatique

Réalisation d’une barrière automatique

Dans ce projet, nous allons réaliser un barrière automatique à l’aide d’un capteur infrarouge et d’un servomoteur qui seront gérés par Arduino.

Objectif

A l’aide d’un programme Arduino, nous allons faire en sorte que la barrière automatique se lève au passage d’un objet et se baisse lorsque le passage est dégagé.

Matériel

  • Ordinateur
  • Arduino Nano
  • Nano Expansion Shield
  • Capteur infrarouge GP2Y0A21
  • Câble USB A Mâle/ USB Mini B mâle

Installation du logiciel Arduino

Si ce n’est pas fait, veillez à installer le logiciel Arduino sur votre ordinateur en suivant ce tutoriel. Lorsque le logiciel est installé, vous pouvez vérifier que la carte Arduino est bien reconnue par l’ordinateur.

Téléverser un code dans l’Arduino

Nous allons à présent vérifier que nous pouvons téléverser un code dans l’Arduino Nano.

Pour cela, ouvrez un nouveau fichier Arduino.

void setup() {
  // put your setup code here, to run once:

}

void loop() {
  // put your main code here, to run repeatedly:

}

Dans le menu “Outils”, veuillez sélectionner le type de carte, le processeur et le port correspondant à votre carte.

Dans ce projet, nous utilisons une carte Nano compatible Arduino utilisant le driver CH340 et qui utilise l’ancien Bootloader.

Nous sélectionnons donc “Arduino Nano”, processeur: “Old Bootloader” et le port utilisé. Ici, “COM10”

Vous pouvez ensuite cliquer sur la flèche (->) en haut à gauche ou dans le menu “Croquis>Téléverser” pour charger le code sur la carte. Si le logiciel affiche “Téléversement terminé”, c’est que tout fonctionne correctement.

Schéma

Dans ce projet nous allons brancher le capteur infrarouge sur la broche Analogique A0 et le servomoteur sur la broche 3. Comme nous utilisons un shield d’expansion, le branchage se fait facilement. Vérifier bien le sens des broches pour ne pas endommager le matériel (SVG, S-signal, V- tension 5V, G- masse)

Code pour tester le capteur

Afin de déterminer la distance de l’objet au capteur à laquelle la barrière se lève, nous allons tester le fonctionnement du capteur infrarouge. Chargez le code suivant, puis passez la main devant le capteur afin de définir les valeurs seuils de déclenchement. Modifiez les valeurs DETECT_VAL et CLEAR_VAL pour obtenir le comportement désiré.

//Parameters
#define DETECT_VAL 300
#define CLEAR_VAL 200

//Constants
const int gp2y0a21Pin  = A0;

//Variables
int gp2y0a21Val  = 0;
bool object=false,oldStatus=true;
String comment ="";

void setup() {
  //Init Serial USB
  Serial.begin(9600);
  Serial.println(F("Initialize System"));
  //Init ditance ir
  pinMode(gp2y0a21Pin, INPUT);
}

void loop() {
  readSensor();
  delay(500);
}

void readSensor() { /* function testGP2Y0A21 */
  ////Read distance sensor
  gp2y0a21Val = analogRead(gp2y0a21Pin);

  if (gp2y0a21Val > DETECT_VAL) {
    object=true;
    comment="Obstacle detected";
  } 
  if(gp2y0a21Val < CLEAR_VAL){
    object=false;
    comment="No obstacle";
  }

  if(oldStatus!=object){
    Serial.print(F("Valeur du capteur : "));Serial.print(gp2y0a21Val);
    Serial.print(F(" -> "));Serial.println(comment);
  }
  oldStatus=object;
}

Code pour tester le servomoteur

Afin de connaître les positions haute et basse de la barrière, nous allons tester le servomoteur. Nous allons envoyer deux commandes au servomoteur l’une représentant la position “levé” et l’autre la position “baissé”. Modifiez les valeurs HAUT et BAS en fonction de la position réelle observée.

//Librairie
#include <Servo.h>

//Déclaration des constantes
#define UPDATE_TIME 15
#define HAUT 180
#define BAS 90

//Déclaration des paramètres
int servoPin = 3;
//Déclaration des variables
Servo myServo;  // création d'un objet Servo

int pos=BAS;    // variable contenant la position du servomoteur

void setup() {
  Serial.begin(9600);
  myServo.attach(servoPin); 
}

void loop() {
  for (pos = BAS; pos <= HAUT; pos += 1) { 
    myServo.write(pos);              
    delay(UPDATE_TIME);                       
  }
  Serial.print(F("Servo position HAUT : "));Serial.println(HAUT);
  delay(500);
  for (pos = HAUT; pos >= BAS; pos -= 1) { 
    myServo.write(pos);             
    delay(UPDATE_TIME);                      
  }
  Serial.print(F("Servo position BAS : "));Serial.println(BAS);
  delay(500);
}

Code de la barrière automatique

Nous allons combiner les deux codes et apporter quelques modifications afin d’obtenir le comportement désiré. Nous allons créer deux fonctions fenceDown() et fenceUp(). L’une pour baisser la barrière et l’autre pour la lever. Lorsque la variable “objet” (obstacle détecté) est à true (1-Vrai) nous allons appeler la fonction fenceUp() et lorsqu’elle passe à false(0-Faux) nous allons appeler fenceDown() afin de baisser la barrière.

//Librairie
#include <Servo.h>

//Parameters
#define DETECT_VAL 300
#define CLEAR_VAL 200
#define UPDATE_TIME 15
#define HAUT 180
#define BAS 90

//Constants
const int gp2y0a21Pin  = A0;
const int servoPin = 3;

//Variables
int gp2y0a21Val  = 0;
bool object=false,oldStatus=true;
String comment ="";
int pos=BAS;    // variable contenant la position du servomoteur

Servo myServo;  // création d'un objet Servo

void setup() {
  //Init Serial USB
  Serial.begin(9600);
  Serial.println(F("Initialize System"));
  pinMode(gp2y0a21Pin, INPUT);
  myServo.attach(servoPin); 

}

void loop() {
  readSensor();
}

void readSensor() { /* function testGP2Y0A21 */
  ////Read distance sensor
  gp2y0a21Val = analogRead(gp2y0a21Pin);
  if (gp2y0a21Val > DETECT_VAL) {
    object=true;
    comment="Obstacle detected";
  } 
  if(gp2y0a21Val < CLEAR_VAL){
    object=false;
    comment="No obstacle";
  }

  if(oldStatus!=object){
    Serial.print(F("Valeur du capteur : "));Serial.print(gp2y0a21Val);
    Serial.print(F(" -> "));Serial.println(comment);
    if(object==true){
      fenceUp();
    }else{
      fenceDown();
    }
  }
  oldStatus=object;
}

void fenceUp(){
    for (pos = pos; pos <= HAUT; pos += 1) { 
    myServo.write(pos);              
    delay(UPDATE_TIME);                       
  }
  Serial.print(F("Servo position HAUT : "));Serial.println(HAUT);
}

void fenceDown(){
  for (pos = pos; pos >= BAS; pos -= 1) { 
    myServo.write(pos);             
    delay(UPDATE_TIME);                      
  }
  Serial.print(F("Servo position BAS : "));Serial.println(BAS);
}

Prochaines étapes

  • Ajouter une sécurité afin que la barrière se relève lorsqu’un objet est présent, même si elle n’a pas finit de se baisser
  • Ajouter un feu de circulation à la barrière
  • Ajouter un lecteur de carte RFID afin de n’ouvrir la barrière qu’avec le bon badge

Sources

Utilisation d’un module RFID avec un ESP32

Utilisation d’un module RFID avec un ESP32

Le module RFID RC522 est un lecteur de carte à puce qui, permet entre autre, d’activer un mécanisme lorsque la bonne carte est présenté au lecteur. Nous allons voir, dans ce tutoriel, la gestion d’un module RFID RC522 avec une carte NodeMCU ESP32.

Prérequis : Programmez votre NodeMCU avec Arduino

Matériel

  • Ordinateur
  • Carte NodeMCU ESP32
  • Câble USB A male à Micro B male
  • 1x module RFID RC522

Schéma

Le module RFID RC522 utilise la protocole SPI pour communiquer avec l’ESP32. La communication SPI utilise des boches spécifiques sur ce type de microcontrôleur.

Le brochage se fait comme suit (à gauche côté RC522, à droite côté ESP32):

  • Vcc <-> 3V3 (ou Vin(5V) selon la version du module)
  • RST (Reset) <-> D0
  • GND (Masse) <-> GND
  • MISO (Master Input Slave Output) <-> 19
  • MOSI (Master Output Slave Input) <-> 23
  • SCK (Serial Clock) <-> 18
  • SS/SDA (Slave select) <-> 5

Attention: Selon la version du module RFID, la tension d’alimentation peut être différentes (3.3V ou 5V). Vérifiez bien la tension d’alimentation de votre module.

Pour rappel, voici le schéma de brochage de la carte ESP32.

Code pour lire une carte RFID

Pour utiliser le module RFID RC522 nous utilisons la librairie SPI.h qui va nous permettre d’établir la communication entre la carte ESP32 et le module; et la librairie MFRC522.h qui va nous permettre de dialoguer avec le module.

//Libraries
#include <SPI.h>//https://www.arduino.cc/en/reference/SPI
#include <MFRC522.h>//https://github.com/miguelbalboa/rfid

//Constants
#define SS_PIN 5
#define RST_PIN 0

//Parameters
const int ipaddress[4] = {103, 97, 67, 25};

//Variables
byte nuidPICC[4] = {0, 0, 0, 0};
MFRC522::MIFARE_Key key;
MFRC522 rfid = MFRC522(SS_PIN, RST_PIN);

void setup() {
  //Init Serial USB
  Serial.begin(115200);
  Serial.println(F("Initialize System"));
  //init rfid D8,D5,D6,D7
  SPI.begin();
  rfid.PCD_Init();

  Serial.print(F("Reader :"));
  rfid.PCD_DumpVersionToSerial();
}

void loop() {
  readRFID();
}

void readRFID(void ) { /* function readRFID */
  ////Read RFID card

  for (byte i = 0; i < 6; i++) {
    key.keyByte[i] = 0xFF;
  }
  // Look for new 1 cards
  if ( ! rfid.PICC_IsNewCardPresent())
    return;

  // Verify if the NUID has been readed
  if (  !rfid.PICC_ReadCardSerial())
    return;

  // Store NUID into nuidPICC array
  for (byte i = 0; i < 4; i++) {
    nuidPICC[i] = rfid.uid.uidByte[i];
  }

  Serial.print(F("RFID In dec: "));
  printDec(rfid.uid.uidByte, rfid.uid.size);
  Serial.println();

  // Halt PICC
  rfid.PICC_HaltA();

  // Stop encryption on PCD
  rfid.PCD_StopCrypto1();

}


/**
   Helper routine to dump a byte array as hex values to Serial.
*/
void printHex(byte *buffer, byte bufferSize) {
  for (byte i = 0; i < bufferSize; i++) {
    Serial.print(buffer[i] < 0x10 ? " 0" : " ");
    Serial.print(buffer[i], HEX);
  }
}

/**
   Helper routine to dump a byte array as dec values to Serial.
*/
void printDec(byte *buffer, byte bufferSize) {
  for (byte i = 0; i < bufferSize; i++) {
    Serial.print(buffer[i] < 0x10 ? " 0" : " ");
    Serial.print(buffer[i], DEC);
  }
}

Résultat

Lorsqu’on passe une carte, un badge ou une puce RFID devant le module, l’adresse d’identification du badge s’affiche sur le moniteur série.

Applications

  • Développer une interface Web qui ne s’active que lorsque le bon badge est passé devant le module

Sources