Comment afficher les données lues par le MFRC522 via l’écran LCD avec un Arduino
Pour des raisons personnelles, je me suis intéressé à l’Arduino durant deux semaines et j’ai trouvé qu’Arduino était pratique et facile d’accès. Je voudrai donc faire une démonstration simple avec un Arduino. J’ai un module MFRC522 à la maison, que j’ai utilisé quand j’étais à l’université, à ce moment-là j’avais utilisé un STM32 pour communiquer avec lui , donc je dois écrire le pilote du module MFRC522 moi-même, ce qui est assez compliqué.
Mais je me suis aperçu qu’Arduino possédait sa propre bibliothèque MFRC522, je n’ai donc pas besoin d’écrire le fichier du pilote moi-même, ce qui sera très pratique à utiliser.
Contenus de l'article
Fonction
Je dois faire une démo qui puisse lire les données de la carte MI et afficher les données lues sur l’écran LCD. Selon cette exigence, j’ai besoin du matériel suivant :
- Un logiciel de développement Arduino UNO.
- Un module MFRC522.
- Un afficheur LCD.
- Une carte MI.
En raison de la communication série dans le programme de démonstration Arduino, il est préférable de faire fonctionner l’écran par le biais de ports série. Et je n’ai qu’un écran LCD série à la maison, qui est également très pratique et facile à utiliser, qui sera présenté plus tard.
Le matériel
Le projet comporte trois modules électroniques, que je vais les présenter un à un.
Le MFRC522
Le MFRC522 est la petite puce d’une carte de lecture-écriture sans contact, à faible tension et à faible coût, lancée par NXP, qui est le choix pour le développement de compteurs intelligents et d’appareils portables.
Utilisant des concepts de modulation et de démodulation avancés, le MFRC522 intègre entièrement tous les types de modes et de protocoles de communication passifs sans contact tournant à 13,56 MHz. Elle supporte l’application multicouche de la norme ISO14443A. La section interne de l’émetteur pilote l’antenne du lecteur pour communiquer avec la carte ISO14443A/MIFARE et le transpondeur sans avoir besoin de circuits supplémentaires. La partie réceptrice fournit un circuit de démodulation et de décodage robuste et efficace pour le traitement des signaux du transpondeur conformes à la norme ISO14443A. La partie numérique gère les trames ISO14443A et la détection des erreurs (parité et CRC). MFRC522 prend en charge la communication sans contact MIFARE à plus grande vitesse, avec un taux de transmission de données bidirectionnel allant jusqu’à 424kbit/s.
Vous pouvez en acheter à cette adresse : https://detail.tmall.com
Ses caractéristiques sont :
- Circuit de modulation et de démodulation à haute intégration ;
- Supporte le protocole de communication ISO/IEC 14443 TypeA et MIFARE ;
- La distance de communication avec ISO 14443A/MIFARE en mode lecteur est de 50 mm maximum, selon la longueur de l’antenne.
- Prend en charge des débits de transmission plus élevés de 212kbit/s et 424kbit/s de la norme ISO 14443.
- Interface SPI pour 10Mbit/s
- Mémoire tampon FIFO de 64 octets pour l’envoi et la réception ;
- Capteur de température intégré pour arrêter automatiquement l’émission RF lorsque la température de la puce est trop élevée ;
- Adoption d’une alimentation électrique indépendante multi groupe pour éviter les interférences entre les modules et améliorer la stabilité du travail.
- CRC et fonction de contrôle de parité.
- Oscillateur interne connecté à un cristal de 27,12mhz ;
- Conception à faible tension et faible consommation d’énergie de 2,5-3,3 V ;
- Plage de température de fonctionnement : -30 ~ +85℃ ;
- Dimensions très réduites : 5 mm x 5 mm x 0,85 mm.
Ses application
Le MFRC522 est adapté à une variété d’applications basées sur la norme ISO/IEC 14443A et nécessitant une communication sans contact à faible coût, de petite taille, à haute performance et à alimentation unique.
- Terminal de transport public
- Appareil portable à main
- Téléphone public sans contact
- Serrure de porte
Module d’affichage LCD-TFT
Commandez le à cette adresse STONE STVCO50WT-01
Dans ce projet, j’ai l’intention d’utiliser l’écran d’affichage STONE STVC050WT pour afficher les données de la carte lue par le mfrc522.
La puce du conducteur a été intégrée à l’intérieur de l’écran d’affichage et il existe un logiciel de développement qui peut être utilisé par les utilisateurs. Il suffit aux utilisateurs d’ajouter des boutons et des zones de texte aux images de l’interface utilisateur conçues par le PC, puis de générer des fichiers de configuration et de les télécharger dans le module d’affichage.
Le STVC050WT-01 communique avec le MCU via un signal uart-ttl.
Les étapes du développement
Trois étapes du développement de l’écran d’affichage :
- Concevoir la logique d’affichage et la logique des boutons avec le logiciel STONE TOOL, et télécharger le fichier de conception dans le module d’affichage.
- L’unité MCU communique avec le module d’affichage LCD STONE par le biais du port série.
- Avec les données obtenues à l’étape 2, la MCU effectue d’autres actions.
Les outils de STONE
Retrouvez les à cette adresse ICI
Téléchargez la dernière version du logiciel STONE TOOL (actuellement TOOL2019) sur le site web, et installez-le.
Après l’installation du logiciel, l’interface suivante s’ouvrira :
Cliquez sur le bouton « Files » dans le coin supérieur gauche pour créer un nouveau projet, dont nous parlerons plus tard.
L’Arduino
Les développeurs n’ont pas besoin de se soucier des détails fastidieux de la programmation mono puce, en vous fournissant un kit facile à utiliser. L’Arduino simplifie également le processus de travail du microcontrôleur, mais comparé à d’autres systèmes, l’Arduino est plus avantageux dans de nombreux endroits, particulièrement adapté aux enseignants, aux étudiants et aux amateurs.
- La version la moins chère d’Arduino peut être fabriquée de vos propres mains, et même un produit assemblé ne coûte pas plus de 25 €.
- L’environnement de programmation est simple — L’environnement de programmation Arduino est facile à apprendre pour les débutants, et il peut fournir suffisamment d’applications avancées pour les utilisateurs évolués.
- Le logiciel Arduino est open-source et peut être étendu par des programmeurs expérimentés grâce à la bibliothèque C++
- La carte Arduino est basée sur le microcontrôleur ATMEGA8 et atmega168/328 d’Atmel. L’Arduino est basé sur la licence « Creative Commons » de sorte que les concepteurs expérimentés peuvent concevoir leurs propres modules pour étendre ou améliorer les exigences. Même pour certains utilisateurs relativement inexpérimentés, vous pouvez fabriquer des cartes de test pour comprendre le fonctionnement d’un Arduino, ce qui permet de gagner du temps et de l’argent.
L’Arduino, basé sur la plate-forme AVR, compile et encapsule deux fois les bibliothèques AVR. Les ports sont empaquetés et les registres, les pointeurs d’adresse et autres choses ne sont pas nécessaires. Cela réduit considérablement la difficulté du développement de logiciels, ce qui convient aux amateurs non professionnels.
L’environnement du développement
Arduino IDE est très facile à apprendre pour les débutants et possède une grande flexibilité. Le langage Arduino est développé sur la base du langage de câblage, qui est un second packaging de la bibliothèque AVR-GCC. Il n’a pas besoin de trop de bases de SCM ou de programmation, donc vous pouvez le développer rapidement après un simple apprentissage.
L’environnement de développement Arduino est l’IDE Arduino, qui peut être téléchargé sur Internet.
Après l’installation de l’EDI Arduino, l’interface suivante apparaîtra lorsque vous ouvrirez le logiciel :
L’IDE Arduino crée deux fonctions par défaut : la fonction de configuration et la fonction de boucle.
Si vous ne comprenez pas, vous pouvez aller sur Internet pour rechercher des documents.
Processus de mise en œuvre du projet Arduino LCD
Connexion matérielle
Pour que la prochaine étape de l’écriture du code se déroule sans heurts, nous devons d’abord déterminer la fiabilité de la connexion matérielle.
Seuls trois éléments matériels ont été utilisés dans ce projet :
- Le logiciel de développement Arduino UNO.
- L’afficheur TFT-LCD STONE STVC050WT
- Le module MFRC522
La carte de développement Arduino UNO et l’écran d’affichage STVC050WT tft-lcd sont connectés par UART, et la carte de développement Arduino UNO est connectée au module MFRC522 par l’interface SPI :
Conception de l’interface utilisateur LCD-TFT
Tout d’abord, nous devons concevoir une image, qui peut être conçue par PhotoShop ou d’autres outils de conception d’images. Après avoir conçu l’image, il faut l’enregistrer au format JPG.
Ouvrez le le logiciel STONE TOOL2019 et créez un nouveau projet :
Supprimez l’image qui a été chargée par défaut dans le nouveau projet, et ajoutez l’image d’interface utilisateur que nous avons conçue.
Ajouter le composant d’affichage de texte, concevoir le chiffre et la virgule d’affichage, obtenir l’emplacement de stockage du composant d’affichage de texte dans l’écran d’affichage.
L’effet est le suivant :
Générer un fichier de configuration
Une fois la conception de l’interface utilisateur terminée, le fichier de configuration peut être généré et téléchargé sur l’écran STVC050WT, qui est décrit dans les documents de développement de STONE
Effectuez d’abord l’étape 1, puis insérez la clé USB dans l’ordinateur, et le symbole du disque s’affichera. Cliquez ensuite sur « Download » pour télécharger le fichier de configuration sur la clé USB, puis insérez la clé USB dans le STVC050WT pour terminer la mise à niveau.
MFRC522
Nous n’avons pas besoin de programmer le module MFRC522. Nous devons juste nous assurer que le matériel est connecté de manière fiable.
Arduino
Ouvrez l’IDE Arduino et trouvez les lignes suivantes :
Recherchez « RC522 » pour trouver le fichier de la bibliothèque RC522, puis cliquez sur « Télécharger et installer ».
Vous pouvez également le télécharger directement sur Internet : https://github.com/miguelbalboa/rfid
Après l’installation, vous pouvez trouver la démo du mfrc522 dans le dossier de la bibliothèque LIB d’Arduino :
Cette démo peut être testée directement. Après avoir compilé et téléchargé le code dans la carte de développement Arduibo, les données de MFRC522 peuvent être vues dans l’outil de débogage série s’il n’y a pas de problèmes avec la connexion matérielle.
Le code complet est le suivant :
/*
* ——————————————————————————————————————–
* Example sketch/program showing how to read new NUID from a PICC to serial.
* ——————————————————————————————————————–
* This is a MFRC522 library example; for further details and other examples see: https://github.com/miguelbalboa/rfid
*
* Example sketch/program showing how to the read data from a PICC (that is: a RFID Tag or Card) using a MFRC522 based RFID
* Reader on the Arduino SPI interface.
*
* When the Arduino and the MFRC522 module are connected (see the pin layout below), load this sketch into Arduino IDE
* then verify/compile and upload it. To see the output: use Tools, Serial Monitor of the IDE (hit Ctrl+Shft+M). When
* you present a PICC (that is: a RFID Tag or Card) at reading distance of the MFRC522 Reader/PCD, the serial output
* will show the type, and the NUID if a new card has been detected. Note: you may see « Timeout in communication » messages
* when removing the PICC from reading distance too early.
*
* @license Released into the public domain.
*
*/
#include <SPI.h>
#include <MFRC522.h>
#define SS_PIN 10
#define RST_PIN 9
MFRC522 rfid(SS_PIN, RST_PIN); // Instance of the class
MFRC522::MIFARE_Key key;
// Init array that will store new NUID
byte nuidPICC[4];
void setup() {
Serial.begin(9600);
SPI.begin(); // Init SPI bus
rfid.PCD_Init(); // Init MFRC522
for (byte i = 0; i < 6; i++) {
key.keyByte[i] = 0xFF;
}
Serial.println(F(« This code scan the MIFARE Classsic NUID. »));
Serial.print(F(« Using the following key: »));
printHex(key.keyByte, MFRC522::MF_KEY_SIZE);
}
void loop() {
// Reset the loop if no new card present on the sensor/reader. This saves the entire process when idle.
if ( ! rfid.PICC_IsNewCardPresent())
return;
// Verify if the NUID has been readed
if ( ! rfid.PICC_ReadCardSerial())
return;
Serial.print(F(« PICC type: « ));
MFRC522::PICC_Type piccType = rfid.PICC_GetType(rfid.uid.sak);
Serial.println(rfid.PICC_GetTypeName(piccType));
// Check is the PICC of Classic MIFARE type
if (piccType != MFRC522::PICC_TYPE_MIFARE_MINI &&
piccType != MFRC522::PICC_TYPE_MIFARE_1K &&
piccType != MFRC522::PICC_TYPE_MIFARE_4K) {
Serial.println(F(« Your tag is not of type MIFARE Classic. »));
return;
}
if (rfid.uid.uidByte[0] != nuidPICC[0] ||
rfid.uid.uidByte[1] != nuidPICC[1] ||
rfid.uid.uidByte[2] != nuidPICC[2] ||
rfid.uid.uidByte[3] != nuidPICC[3] ) {
Serial.println(F(« A new card has been detected. »));
// Store NUID into nuidPICC array
for (byte i = 0; i < 4; i++) {
nuidPICC[i] = rfid.uid.uidByte[i];
}
Serial.println(F(« The NUID tag is: »));
Serial.print(F(« In hex: « ));
printHex(rfid.uid.uidByte, rfid.uid.size);
Serial.println();
Serial.print(F(« In dec: « ));
printDec(rfid.uid.uidByte, rfid.uid.size);
Serial.println();
}
else Serial.println(F(« Card read previously. »));
// 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);
}
}
Ouvrez le compilateur série Arduino, et vous pouvez voir la sortie suivante :
Ce code est très simple, je crois que vous pouvez le comprendre d’un seul coup d’œil. Je dois dire que la programmation modulaire d’Arduino est très pratique, et je n’ai même pas besoin de comprendre comment le code du pilote d’Uart et de SPI est mis en œuvre.
Bien sûr, le code ci-dessus est une démo officielle, et je dois encore apporter quelques modifications pour afficher les données sur l’écran de STONE.
Afficher les données sur l’écran d’affichage de STONE via Arduino
Tout d’abord, nous devons obtenir l’adresse de la composante qui affiche les données du mfrc522 sur l’écran de STONE. Dans mon projet, l’adresse est la suivante :
- Adresse de sortie du résultat de la détection du MFRC522 : 0x0001
- Adresse de sortie des résultats de la carte MFRC522 : 0x0004
Si vous avez besoin de modifier le contenu de l’écran dans l’espace correspondant, vous pouvez modifier le contenu de l’écran en envoyant des données à l’adresse correspondante de l’écran par le port série d’Arduino.
Le code modifié est le suivant :
/*
* ——————————————————————————————————————–
* Example sketch/program showing how to read new NUID from a PICC to serial.
* ——————————————————————————————————————–
* This is a MFRC522 library example; for further details and other examples see: https://github.com/miguelbalboa/rfid
*
* Example sketch/program showing how to the read data from a PICC (that is: a RFID Tag or Card) using a MFRC522 based RFID
* Reader on the Arduino SPI interface.
*
* When the Arduino and the MFRC522 module are connected (see the pin layout below), load this sketch into Arduino IDE
* then verify/compile and upload it. To see the output: use Tools, Serial Monitor of the IDE (hit Ctrl+Shft+M). When
* you present a PICC (that is: a RFID Tag or Card) at reading distance of the MFRC522 Reader/PCD, the serial output
* will show the type, and the NUID if a new card has been detected. Note: you may see « Timeout in communication » messages
* when removing the PICC from reading distance too early.
*
* @license Released into the public domain.
*
*/
#include <SPI.h>
#include <MFRC522.h>
#define read_card_addr 0x01
#define read_num_addr 0x04
unsigned char read_card_status[8]= {0xA5, 0x5A, 0x05, 0x82,\
0x00, read_card_addr, 0x00, 0x00};
unsigned char read_card_num[10]= {0xA5, 0x5A, 0x07, 0x82, 0x00, \
read_num_addr, 0x00, 0x00,0x00,0x00};
#define SS_PIN 10
#define RST_PIN 9
MFRC522 rfid(SS_PIN, RST_PIN); // Instance of the class
MFRC522::MIFARE_Key key;
// Init array that will store new NUID
byte nuidPICC[4];
void setup() {
Serial.begin(115200);
SPI.begin(); // Init SPI bus
rfid.PCD_Init(); // Init MFRC522
for (byte i = 0; i < 6; i++) {
key.keyByte[i] = 0xFF;
}
// Serial.println(F(« This code scan the MIFARE Classsic NUID. »));
// Serial.print(F(« Using the following key: »));
// printHex(key.keyByte, MFRC522::MF_KEY_SIZE);
}
void loop() {
// Reset the loop if no new card present on the sensor/reader. This saves the entire process when idle.
if ( ! rfid.PICC_IsNewCardPresent())
return;
// Verify if the NUID has been readed
if ( ! rfid.PICC_ReadCardSerial())
return;
// Serial.print(F(« PICC type: « ));
MFRC522::PICC_Type piccType = rfid.PICC_GetType(rfid.uid.sak);
// Serial.println(rfid.PICC_GetTypeName(piccType));
// Check is the PICC of Classic MIFARE type
if (piccType != MFRC522::PICC_TYPE_MIFARE_MINI &&
piccType != MFRC522::PICC_TYPE_MIFARE_1K &&
piccType != MFRC522::PICC_TYPE_MIFARE_4K) {
// Serial.println(F(« Your tag is not of type MIFARE Classic. »));
return;
}
if (rfid.uid.uidByte[0] != nuidPICC[0] ||
rfid.uid.uidByte[1] != nuidPICC[1] ||
rfid.uid.uidByte[2] != nuidPICC[2] ||
rfid.uid.uidByte[3] != nuidPICC[3] ) {
// Serial.println(F(« A new card has been detected. »));
read_card_status[7]=0x01;
Serial.write(read_card_status,8);
// Store NUID into nuidPICC array
for (byte i = 0; i < 4; i++) {
nuidPICC[i] = rfid.uid.uidByte[i];
}
read_card_num[6]=rfid.uid.uidByte[0];
read_card_num[7]=rfid.uid.uidByte[1];
read_card_num[8]=rfid.uid.uidByte[2];
read_card_num[9]=rfid.uid.uidByte[3];
Serial.write(read_card_num,10);
// Serial.println(F(« The NUID tag is: »));
// Serial.print(F(« In hex: « ));
// printHex(rfid.uid.uidByte, rfid.uid.size);
// Serial.println();
//Serial.print(F(« In dec: « ));
//printDec(rfid.uid.uidByte, rfid.uid.size);
//Serial.println();
}
//else Serial.println(F(« Card read previously. »));
// 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);
}
}
Compilez le code, téléchargez-le sur la carte de développement Arduino, et vous êtes prêt à commencer les tests. Placez la carte M1 sur le collecteur MFRC522 pour voir le numéro de la carte MI.
L’effet est visible sur l’image suivante :
[Article rédigé par Grey de STONE Tech : stoneitech.com@gmail.com ]
