Module PN532 NFC RFID - communication en champ proche

LA RFID ? NFC ? Qu'est-ce que c'est ?

Dans cet article, nous souhaitons te faire découvrir la lecture des tags d'identification. L'article se concentre sur le module PN532 NFC RFID. 

Le module est basé sur la puce NXP PN532. Ce jeu de puces est surtout répandu dans le domaine de la NFC (anglais pour "Near Field Communication"). Pour cela, un objet compatible NFC, souvent une carte bancaire avec une puce NFC, est tenu devant un lecteur NFC. L'échange d'informations se fait ainsi en une fraction de seconde. 

Cela semble abstrait ? Si tu as une carte EC récente et que tu l'utilises pour payer sans contact, tu connais même la NFC dans la vie quotidienne. Il suffit de poser la carte sur le terminal de paiement pour déclencher la transaction - c'est rapide et facile.

Nous aimerions examiner de plus près les processus techniques sous-jacents. Le module PN532 est idéal pour cela, car il est compatible avec I2C et SPI. Le type de communication souhaité peut être sélectionné directement sur le circuit imprimé du PN532 en déplaçant les commutateurs qui s'y trouvent. La position des commutateurs nécessaires pour chaque interface se trouve à droite du schéma de commutation, qui se trouve un peu plus bas sur la page.

Le schéma de câblage :

Conseil : tu trouveras une version haute résolution de cette image ici. Tu peux y voir un peu mieux l'affectation des broches.

Le code du programme (version I2C)

//*******************************************************************************************************
//** Exemple de chaîne pour la lecture des tags ID. Si l'ID correspond, PIN 13 est activé pendant 2 secondes **
//** allume (LED). En cas de mauvaise ID, un son est émis sur la broche 12. (Buzzer / Piezzo PASSIF) **
//** utiliser. Au lieu d'une LED, il est également possible d'activer une serrure de porte (via l'amplificateur de commutation TIP120 **)
//*******************************************************************************************************
#include <Wire .h> // bibliothèque pour le protocole I2C
#include <Adafruit_PN532 .h> // bibliothèque pour le module NFC/RFID!  A charger via Arduino IDE !
#define PN532_IRQ (2) // Définir le port IRQ
#define PN532_RESET (3) // Définir le port de réinitialisation
const int AlarmPin = 12; // sortie Pin 12 pour le haut-parleur piézoélectrique
const int OutputPin = 13; // Pin 13 sortie pour LED ou via TIP120 vers une serrure magnétique
unsigned long cardid ; // variable pour le TAG-ID lu
unsigned long TAGid1 = 1702536620; // Les ID à accepter peuvent être saisis ici
unsigned long TAGid2 = 4070796058; // Sinon, laisser libre. L'ID d'un TAG peut être modifié avec
unsigned long TAGid3 ; // le moniteur série est lu (régler 115200 baud)
Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET) ; // créer une instance avec le protocole I2C
void setup() { // Début de la fonction setup
pinMode(AlarmPin, OUTPUT) ; // définir le PIN comme sortie
pinMode(OutputPin, OUTPUT) ; // définir le PIN comme sortie
Serial.begin(115200) ; // ouvrir la transmission série à 115200 bauds (moniteur ser même réglage de bauds !)
Serial.println("Bonjour !") ; // Envoie le texte "Bonjour !" sur le moniteur série
nfc.begin() // Démarre la communication avec le lecteur RFID
unsigned long versiondata = nfc.getFirmwareVersion() ; // lire le numéro de version du firmware
if ( ! versiondata) {                                   // Wenn keine Antwort kommt
Serial.print("Kann kein Board finden !");            // Sende Text "Kann kein..." an seriellen Monitor
while (1);                                           // so lange Stopp
}
Serial.print("Puce PN5 trouvée") ; Serial.println((versiondata >> 24) & 0xFF, HEX) ; // Envoie le texte et les infos de version à la ligne série
Serial.print("Firmware ver. ") ; Serial.print((versiondata >> 16) & 0xFF, DEC) ; // Moniteur quand la réponse vient de la carte
Serial.print('.') ; Serial.println((versiondata >> 8) & 0xFF, DEC) ; // 
nfc.SAMConfig() ; // Configurer la carte pour lire les tags RFID
Serial.println("En attente d'une puce ISO14443A ...") ; // Envoie le texte d'attente au moniteur série
}
void loop() { // Démarrer la fonction de boucle
uint8_t success ; // créer une variable
uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 }; // tampon pour stocker l'UID
uint8_t uidLength ; // longueur de l'UID (4 ou 7 octets selon le type de carte/puce ISO14443A)
// Attendre une puce ISO14443A. Si une telle puce est détectée, la variable
// remplit avec l'UID. En fonction de la longueur (4 octets (Mifare Classic) ou
// 7 octets (Mifare Ultralight), le type de carte est détecté.
success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength) ;
if (success) { // Si détecté, travaille...
Serial.println("Found an ISO14443A card") ;
Serial.print(" UID Length : ") ; Serial.print(uidLength, DEC) ; Serial.println(" bytes") ;
Serial.print(" UID Value : ") ;
nfc.PrintHex(uid, uidLength) ; // donne des informations sur le moniteur en série
if (uidLength == 4) {                                  // Hat die Karte/der Chip 4 byte Länge...
// Mifare Classic Karte
cardid = uid[0];                                     //
cardid <<= 8;                                        // Setze die 4 byte Blöcke
cardid |= uid[1];                                    //
cardid <<= 8;                                        // zu einem einzigen Block
cardid |= uid[2];                                    //
cardid <<= 8;                                        // zusammen
cardid |= uid[3];                                    //
Serial.print("Scheint eine Mifare Classic zu sein #");  //
Serial.println(cardid);                                 // Gib die Informationen aus
Serial.println("");                                     // 
Serial.println("");                                     // 
}
if ((cardid) == (TAGid1)||(cardid) == (TAGid2)||(cardid) == (TAGid3)) // demande si les TAGs 1..2..3 sont compatibles avec leur
{digitalWrite(OutputPin,HIGH);                                                // überein stimmt. Dann schalte je nach dem
delay(2000);
digitalWrite(OutputPin,LOW);}                                               // On ou Off
else
{tone(AlarmPin, 1000);                                                        // Und gib ggf. einen Ton/Frequenz aus
delay(4000);
noTone(AlarmPin);}
} // Fin de la requête IF/boucle
} // Fin de la boucle

Le code du programme (version SPI)

//*******************************************************************************************************
//** Exemple de chaîne pour la lecture des tags ID. Si l'ID correspond, PIN 13 est activé pendant 2 secondes **
//** allume (LED). En cas de mauvaise ID, un son est émis sur la broche 12. (Buzzer / Piezzo PASSIF) **
//** utiliser. Au lieu d'une LED, il est également possible d'activer une serrure de porte (via l'amplificateur de commutation TIP120 **)
//*******************************************************************************************************
#include <Wire .h> // bibliothèque pour le protocole I2C
#include <SPI .h> // bibliothèque pour le protocole SPI
#include <Adafruit_PN532 .h> // bibliothèque pour le module NFC/RFID!  A charger via Arduino IDE !
const byte PN532_SCK = 2; //
const byte PN532_MOSI =3; // définir les connexions pour 
const byte PN532_SS = 4; // la connexion SPI au RFID 
const byte PN532_MISO =5; // carte
const int AlarmPin = 12; // définir les connexions pour 
const int OutputPin = 13; // les sorties (de commutation)
unsigned long cardid ; // variable pour le TAG-ID lu
unsigned long TAGid1 = 1702536620; // tu peux saisir ici les ID à accepter
unsigned long TAGid2 = 4070796058; // Sinon, laisser libre. L'ID d'un TAG peut être modifié avec
unsigned long TAGid3 ; // le moniteur série est lu (régler 115200 baud)
Adafruit_PN532 nfc(PN532_SCK, PN532_MISO, PN532_MOSI, PN532_SS) ; // créer une instance avec le protocole SPI
void setup() { // Début de la fonction setup
pinMode(AlarmPin, OUTPUT) ; // définir le PIN comme sortie
pinMode(OutputPin, OUTPUT) ; // définir le PIN comme sortie
Serial.begin(115200) ; // ouvrir la transmission sérielle à 115200 bauds (moniteur ser même réglage de bauds !)
Serial.println("Bonjour !") ; // Envoie le texte "Bonjour !" sur le moniteur série
nfc.begin() // Démarre la communication avec le lecteur RFID
unsigned long versiondata = nfc.getFirmwareVersion() ; // lire le numéro de version du firmware
if ( ! versiondata) {                                   // Wenn keine Antwort kommt
Serial.print("Kann kein Board finden !");            // Sende Text "Kann kein..." an seriellen Monitor
while (1);                                           // so lange Stopp
}
Serial.print("Found chip PN5") ; Serial.println((versiondata >> 24) & 0xFF, HEX) ; // envoie le texte et les infos de version au port série
Serial.print("Firmware ver. ") ; Serial.print((versiondata >> 16) & 0xFF, DEC) ; // Moniteur quand la réponse vient de la carte
Serial.print('.') ; Serial.println((versiondata >> 8) & 0xFF, DEC) ; // 
nfc.SAMConfig() ; // Configurer la carte pour lire les tags RFID
Serial.println("En attente d'une puce ISO14443A ...") ; // Envoie le texte d'attente au moniteur série
}
void loop() { // Démarrer la fonction de boucle
uint8_t success ; // créer une variable
uint8_t uid[] = { 0, 0, 0, 0, 0, 0, 0 }; // tampon pour stocker l'UID
uint8_t uidLength ; // longueur de l'UID (4 ou 7 octets selon le type de carte/puce ISO14443A)
// Attendre une puce ISO14443A. Si une telle puce est détectée, la variable
// remplit avec l'UID. En fonction de la longueur (4 octets (Mifare Classic) ou
// 7 octets (Mifare Ultralight), le type de carte est détecté.
success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength) ;
if (success) { // Si détecté, travaille...
Serial.println("Found an ISO14443A card") ;
Serial.print(" UID Length : ") ; Serial.print(uidLength, DEC) ; Serial.println(" bytes") ;
Serial.print(" UID Value : ") ;
nfc.PrintHex(uid, uidLength) ; // donne des informations sur le moniteur en série
if (uidLength == 4) {                                  // Hat die Karte/der Chip 4 byte Länge...
// Mifare Classic Karte
cardid = uid[0];                                     //
cardid <<= 8;                                        // Setze die 4 byte Blöcke
cardid |= uid[1];                                    //
cardid <<= 8;                                        // zu einem einzigen Block
cardid |= uid[2];                                    //
cardid <<= 8;                                        // zusammen
cardid |= uid[3];                                    //
Serial.print("Scheint eine Mifare Classic zu sein #");  //
Serial.println(cardid);                                 // Gib die Informationen aus
Serial.println("");                                     // 
Serial.println("");                                     // 
}
if ((cardid) == (TAGid1)||(cardid) == (TAGid2)||(cardid) == (TAGid3)) // demande si les TAGs 1..2..3 sont compatibles avec leur
{digitalWrite(OutputPin,HIGH);                                                // überein stimmt. Dann schalte je nach dem
delay(2000);
digitalWrite(OutputPin,LOW);}                                               // On ou Off
else
{tone(AlarmPin, 1000);                                                        // Und gib ggf. einen Ton/Frequenz aus
delay(4000);
noTone(AlarmPin);}
} // Fin de la requête IF/boucle
} // Fin de la boucle