Connexion à Arduino :
Vous devez d’abord installer la bibliothèque RFID pour MFRC522.
Contacts sur le module Le module RFID RC522 doit être connecté à l'Arduino. Pour la connexion, il est pratique d'utiliser des fils père-mère.
Description des contacts sur le module RFID RC522 :
- VCC-Puissance. Besoin de 3,3 V ;
- RST - réinitialiser. Réinitialiser la ligne. Ne vous connectez jamais à la broche RESET du CraftDuino ! Cette broche s'accroche à un port numérique avec PWM ;
- GND - Terre. Terre
- MISO - Master Input Slave Output - données de l'esclave au maître, SPI ;
- MOSI - Master Output Slave Input - données du maître à l'esclave, SPI ;
- SCK - Serial Clock - signal d'horloge, SPI ;
- NSS - Slave Select - sélection d'esclaves, SPI ;
- IRQ - ligne d'interruption ;
| CRFM522 | Arduino Uno | Arduino Méga | Arduino-Nano v3 | Arduino Léonard/Micro | Arduino Pro Micro |
| TVD | 9 | 5 | D9 | RÉINITIALISATION/ICSP-5 | TVD |
| SDA(SS) | 10 | 53 | J10 | 10 | 10 |
| MOSI | 11 (ICSP-4) | 51 | J11 | ICSP-4 | 16 |
| MISO | 12 (ICSP-1) | 50 | J12 | ICSP-1 | 14 |
| SCK | 13 (ICSP-3) | 52 | J13 | ICSP-3 | 15 |
| 3,3 V | 3,3 V | 3,3 V | Stabilisateur 3,3 V | Stabilisateur 3,3 V | Stabilisateur 3,3 V |
| GND | GND | GND | GND | GND | GND |
Le module RFID-RC522 est livré avec deux étiquettes, l'une sous la forme d'une carte en plastique et la seconde sous la forme d'un porte-clés. Si nécessaire, ils peuvent être achetés séparément.
Une fois que tout est connecté, l'indicateur sur le module sera allumé, cela indique que l'alimentation est fournie au RFID . C'est l'heure exécutez un croquis de test qui se trouve dans la bibliothèque que nous avons installée.
Il est nécessaire de vérifier l'exactitude des constantes spécifiées :
#define SS_PIN 10 #define RST_PIN 9 // Ces constantes correspondent
Téléchargez maintenant le croquis sur Arduino et allumez-le Surveillance du port série.
Nous apportons l'étiquette au lecteur et le module lit toutes les données de cette étiquette, par exemple l'identifiant unique de l'étiquette UID.
Vidéo de fonctionnement du RFID-RC522:
Les étiquettes RFID font désormais partie intégrante de nos vies ; les systèmes d'automatisation modernes et les appareils intelligents sont inconcevables sans elles. Arduino nous offre d'excellentes opportunités d'utiliser les technologies modernes même dans les projets initiaux. Dans cet article, nous expliquerons ce qu'est la RFID, passerons en revue les normes, les types de cartes et apprendrons comment connecter les lecteurs RFID populaires RC522 et RDM3600 à Arduino.
La RFID (Radio Frequency Identification) est une méthode de transmission, d'enregistrement et de stockage de données à l'aide de signaux radio. Chaque système RFID comprend un lecteur/lecteur et une étiquette RFID qui stocke les données. Les balises se composent de deux parties : un circuit intégré et une antenne. Un circuit intégré permet de stocker et de traiter des données, une antenne - de recevoir et de transmettre des informations.
Tous les systèmes RFID peuvent être divisés par gamme :
- Identification proche - distance ne dépassant pas 20 cm ;
- Identification moyenne - distance de 20 cm à 5 m ;
- Identification à longue portée - maximum 300 m.
En termes de fréquences, on peut distinguer :
- Systèmes fonctionnant dans la gamme des basses fréquences (125 kHz, 134 kHz) ;
- Fonctionnant dans la gamme des fréquences moyennes (13,56 MHz) ;
- Fonctionnant dans la gamme des hautes fréquences (800 MHz - 2,4 GHz).
La bande la plus populaire est celle du milieu de gamme. Elle est largement utilisée dans les applications de transport et dans d'autres projets nécessitant l'écrasement de la carte. Les principales normes sont ISO 14443, ISO 15693 et EPC. Les cartes à puce sont produites sur la base de la norme ISO 14443. La norme ISO 15693 est utilisée pour réécrire les étiquettes. EPC est un analogue des codes-barres, il a une structure plus simple et plus compréhensible.
La bande HF est récemment utilisée, principalement pour les applications en entrepôt. Cette gamme utilise les normes ISO 18000 et EPC. Les normes ISO 18000 sont les plus intéressantes et sont utilisées dans les applications avec des étiquettes à portée étendue. Pour l'ISO 18000, il existe également plusieurs normes qui diffèrent par leur fréquence :
- ISO 18000-1 (détermination des paramètres qui doivent être standardisés) ;
- ISO 18000-2 (pour les paramètres avec interface de communication sans contact inférieure à 135 kHz) ;
- ISO 18000-3 (pour interface sans contact à 13,56 MHz) ;
- ISO 18000-4 (pour 2,45 GHz) ;
- ISO 18000-6 (pour fréquence 860-930 MHz) ;
- ISO 18000-7 (pour 433 MHz).
Avantages de la RFID
- Aucune ligne de vue requise ;
- Identification du signal presque à 100 % ;
- Possibilité d'application en milieu hostile ;
- Longue durée de vie ;
- L'étiquette RFID est difficile à falsifier ;
- Capacité à stocker et transférer de grandes quantités d’informations.
Domaines d'application de l'identification RFID
La technologie RFID est souvent utilisée dans le commerce de détail, les bibliothèques et les archives, la logistique, les systèmes de contrôle d'accès (ACS), l'approvisionnement des personnes et l'authentification des produits.
Pour l'identification du personnel, les formats les plus populaires sont les cartes plastiques sans contact et les porte-clés sans contact. Avec leur aide, vous pouvez enregistrer l'entrée/sortie d'objets sur le territoire via les points de passage - portes, postes de contrôle. La tâche principale de l'ACS est le contrôle d'accès - par exemple, restreindre l'accès à n'importe quel territoire, identifier les personnes pouvant entrer sur le territoire. Des tâches supplémentaires peuvent également être résolues : contrôle des heures de travail du personnel, maintenance d'une base de données des visiteurs, travail avec les systèmes de sécurité, paie.
Les porte-clés RFID sont également utilisés pour les interphones d'accès. Pour ouvrir les portes, on utilise le plus souvent des porte-clés de proximité, c'est-à-dire des porte-clés à courte portée fonctionnant à une distance de 10 à 15 cm. La proximité est également divisée en plusieurs formats - les plus populaires aujourd'hui sont EM-Marin, HID pour sans contact clés et MIFARE, qui incluent des cartes à puce sans contact.
Brève description des modules Arduino
Module Arduino-RFID RC522
Le module RFID RC522 est basé sur le circuit MFRC522, qui permet une communication sans fil à une fréquence de 13,56 MHz. Vous pouvez connecter le microcircuit via les interfaces SPI, I2c et UART. Norme de protocole NFC Reader ISO 14443.
Spécifications du module RFID RC522 :
- Tension d'alimentation 3,3 V ;
- Consommation de courant maximale 30 mA ;
- Bande de fréquences 13,55-13,57 MHz ;
- Distance de lecture jusqu'à 25 mm ;
- Température de fonctionnement de -20C à 80C.
Le brochage du module est indiqué sur la figure. La broche SDA (SS, CS, NSS) est responsable de la sélection de l'esclave. La sortie SCK est le signal d'horloge SPI. MOSI est responsable du transfert des données du maître à l'esclave, MISO est responsable du transfert des données de l'esclave au maître. IRQ - Effectue une interruption. RST - Effectue une interruption.
RDM6300 est un lecteur de proximité utilisé pour lire à distance le numéro du porte-clés RFID et transmettre le numéro via UART au microcontrôleur qui contrôle le verrouillage dans les systèmes d'accès. L'appareil présente plusieurs avantages : prix bas et facilité d'installation. Il est le plus souvent utilisé dans les systèmes de contrôle d'accès pour les maisons, garages, bureaux, appartements et autres bâtiments équipés d'une serrure électromécanique. Le lecteur permet de lire les cartes EM4100/TK4100. Le RDM6300 peut être monté au mur ou dans une armoire. Arduino est généralement utilisé comme microcontrôleur.
Spécifications du RDM6300 :
- Consommation de courant maximale 50 mA ;
- Tension d'alimentation 5 V ;
- Fréquence de fonctionnement 125 kHz ;
- Températures de fonctionnement de -10C à 70C.
Le brochage est indiqué sur la figure.
Pin TX est responsable de la transmission des données, RX - de la réception. La sortie 3 n'est pas utilisée.
Pour P2, les sorties ANT1 et ANT2 servent à connecter l'antenne.
Connexion du RC522 à Arduino
Pour vous connecter, vous aurez besoin d'une carte Arduino, d'un lecteur RC522, d'un ordinateur, de fils et d'une étiquette RFID sans fil.
Le module RC522 se connecte à l'arduino selon le schéma suivant :
La tension d'alimentation est fournie de 2,5 à 3,3 V. La sortie RST est connectée à la broche D9 de l'arduino, SDA à D10, MOSI à D11, MISO à D12, SCK à D13. Dans ce cas, les cartes Arduino Nano v3 et Arduino Uno sont prises en compte. Une fois que tout est connecté, la LED du RC522 s'allumera.
Dans cette leçon, nous allons apprendre à réaliser un système simple qui permettra de déverrouiller la serrure à l'aide d'une clé électronique (Étiquette).
À l’avenir, vous pourrez affiner et étendre les fonctionnalités. Par exemple, ajoutez la fonction "ajouter de nouvelles clés et les supprimer de la mémoire". Dans le cas de base, considérons un exemple simple, lorsqu'un identifiant de clé unique est pré-spécifié dans le code du programme.
Dans ce tutoriel nous aurons besoin de :
Pour implémenter le projet, nous devons installer les bibliothèques :
2) Vous devez maintenant connecter le buzzer, qui donnera un signal si la clé a fonctionné et que la serrure s'ouvre, et un deuxième signal lorsque la serrure se ferme.
Nous connectons le buzzer dans l'ordre suivant :
| Arduino | Avertisseur sonore |
|---|---|
| 5V | VCC |
| GND | GND |
| broche 5 | IO |
3) Un servo sera utilisé comme mécanisme de déverrouillage. N'importe quel servo peut être choisi, en fonction des dimensions dont vous avez besoin et des forces créées par le servo. Le servo a 3 broches :
Plus clairement, vous pouvez voir comment nous avons connecté tous les modules dans l'image ci-dessous :
Maintenant, si tout est connecté, vous pouvez alors procéder à la programmation.
Esquisser:
#inclure
Analysons le croquis plus en détail :
Afin de connaître l'UID de la carte (Étiquettes), vous devez écrire ce croquis sur arduino, assembler le circuit décrit ci-dessus et ouvrir la console (Surveillance du port série). Lorsque vous apportez le tag à la RFID, un numéro s'affichera dans la console
L'UID résultant doit être saisi dans la ligne suivante :
If (uidDec == 3763966293) // Comparez l'Uid de l'étiquette, s'il est égal à celui spécifié, alors le servo ouvre la vanne.
Pour chaque carte, cet identifiant est unique et ne se répète pas. Ainsi, lorsque vous présentez une carte dont vous avez défini l'identifiant dans le programme, le système ouvrira l'accès à l'aide d'un servo.
Vidéo:
De nos jours, l’utilisation de la technologie d’identification par radiofréquence (RFID) devient très populaire. De nombreuses applications sont introduites dans divers domaines de notre vie et utilisées à diverses fins. La RFID permet la collecte de données sans fil à l'aide de lecteurs d'étiquettes électroniques attachés ou intégrés dans des objets à des fins d'identification et à d'autres fins. Cet article montre comment construire un dispositif de contrôle d'accès RFID simple et fait maison à l'aide d'un Arduino UNO et d'un lecteur RFID (EM-18) pour contrôler une LED et un relais. Le schéma de circuit et le croquis Arduino (code source) sont présentés ci-dessous.
Lorsqu'il est activé, le lecteur transmet un signal RF. Lorsqu'une étiquette RFID est placée à proximité d'un lecteur, elle reçoit un signal RF via une antenne à l'intérieur de l'étiquette. Le signal RF reçu sera converti en énergie électrique, suffisante pour transmettre les données de l'étiquette au lecteur RFID. De plus, le lecteur transmettra l'ID de l'étiquette à un appareil externe via le port de données série. Une large gamme de modèles de lecteurs est actuellement disponible. Le module EM-18 est le plus courant et le plus pratique à utiliser. Ce module lit les balises passives RFID et envoie l'ID de la balise au microcontrôleur Arduino.
En lisantID d'étiquette RFID
Pour commencer, téléchargez le code simple rfid1.ino sur l'Arduino Uno à l'aide de l'outil de développement IDE.
Assemblez maintenant le circuit comme indiqué ci-dessous.
Ouvrez le moniteur série dans l'IDE Arduino, maintenez l'étiquette RFID très près du centre du lecteur RFID et notez l'ID de l'étiquette affiché. Cet identifiant unique sera nécessaire dans le prochain sketch ! (Notre étiquette porte l'ID 51005F46642C)
Contrôle d'accès
À ce stade, le système est configuré pour comparer l'identifiant unique (étiquette utilisée) avec l'identifiant de toute étiquette à lire.
Analysez la connexion existante et téléchargez un nouveau croquis rfid2.ino au microcontrôleur Arduino
Re-câblez les composants matériels (avec quelques modifications) comme indiqué dans la figure ci-dessus. Ici, la broche D12 du microcontrôleur Arduino est utilisée pour piloter une LED standard de 5 mm. La broche D13 est utilisée pour contrôler le relais électromagnétique via le transistor de commande. Chaque fois qu'une marque correspond, un signal de commande haut apparaît sur la broche D13 pendant 5 secondes. Le relais peut être utilisé pour contrôler une charge externe telle qu'un arrêt de porte. Si les valeurs de l'étiquette ne correspondent pas, alors D13 reste bas, mais D12 reste haut pour déclencher la LED d'alarme.
Aujourd'hui, je vais parler du module RFID RC522, basé sur la puce MFRC522. Alimentation 3,3 V, plage de détection jusqu'à 6 cm. Conçu pour lire et écrire des étiquettes RFID avec une fréquence de 13,56 MHz. La fréquence dans ce cas est très importante, puisque les tags RFID existent dans trois gammes de fréquences :
- Marques de bande LF (125-134 kHz)
- Étiquettes de bande HF (13,56 MHz)
- Étiquettes de bande UHF (860-960 MHz)
Concrètement, ce module fonctionne avec les tags de la gamme HF, notamment avec le protocole MIFARE.
Pour travailler avec le module, vous pouvez utiliser la bibliothèque RFID standard incluse dans l'IDE Arduino, mais il existe une autre bibliothèque écrite spécifiquement pour ce module - MFRC522 (1 Mo). Les deux bibliothèques sont très pratiques, mais MFRC522 possède des fonctions plus spéciales qui vous permettent de minimiser le code du programme résultant.
Connexion
Certains rencontreront un problème : le nom des broches dans la plupart des didacticiels et tutoriels peut ne pas correspondre au brochage de votre module. Si la broche SS est indiquée dans les croquis, mais que votre module ne l'a pas, il est fort probable qu'elle soit marquée comme SDA. Ci-dessous, je vais donner un tableau de connexion des modules pour les cartes les plus courantes.
| CRFM522 | Arduino Uno | Arduino Méga | Arduino-Nano v3 | Arduino Léonard/Micro |
Arduino Pro Micro |
| TVD | 9 | 5 | D9 | RÉINITIALISATION/ICSP-5 | TVD |
| SDA(SS) | 10 | 53 | J10 | 10 | 10 |
| MOSI | 11 (ICSP-4) | 51 | J11 | ICSP-4 | 16 |
| MISO | 12 (ICSP-1) | 50 | J12 | ICSP-1 | 14 |
| SCK | 13 (ICSP-3) | 52 | J13 | ICSP-3 | 15 |
| 3,3 V | 3,3 V | 3,3 V | Stabilisateur 3,3 V | Stabilisateur 3,3 V | Stabilisateur 3,3 V |
| GND | GND | GND | GND | GND | GND |
Les broches de contrôle SS(SDA) et RST sont spécifiées dans le croquis, donc si votre carte est différente de celle que j'utiliserai dans mes exemples, et que j'utilise UNO R3, précisez les broches du tableau au début du croquis :
#définir SS_PIN 10 #définir RST_PIN 9
Exemple n°1 : Lecture du numéro de carte
Prenons un exemple de la bibliothèque RFID - cardRead. Il ne fournit pas les données de la carte, mais uniquement son numéro, qui est généralement suffisant pour de nombreuses tâches.
#include #include #define SS_PIN 10 #define RST_PIN 9 RFID rfid(SS_PIN, RST_PIN); // Les données sur le numéro de carte sont stockées dans 5 variables, nous les mémoriserons pour vérifier si nous avons déjà lu une telle carte int serNum0; int serNum1; intserNum2; int serNum3; int serNum4; void setup() ( Serial.begin(9600); SPI.begin(); rfid.init(); ) void loop() ( if (rfid.isCard()) ( if (rfid.readCardSerial()) ( // Comparez le numéro de carte avec le numéro de carte précédent si (rfid.serNum != serNum0 && rfid.serNum != serNum1 && rfid.serNum != serNum2 && rfid.serNum != serNum3 && rfid.serNum != serNum4) ( /* Si la carte est - neuve, puis lisez*/ Serial.println(" "); Serial.println("Card found"); serNum0 = rfid.serNum; serNum1 = rfid.serNum; serNum2 = rfid.serNum; serNum3 = rfid. serNum; serNum4 = rfid.serNum; //Imprimer le numéro de carte Serial.println("Cardnumber:"); Serial.print("Dec: "); Serial.print(rfid.serNum,DEC); Serial.print(" , "); Serial .print(rfid.serNum,DEC); Serial.print(", "); Serial.print(rfid.serNum,DEC); Serial.print(", "); Serial.print(rfid. serNum,DEC); Serial.print(", "); Serial.print(rfid.serNum,DEC); Serial.println(" "); Serial.print("Hex: "); Serial.print(rfid.serNum ,HEX); Serial .print(", "); Serial.print(rfid.serNum,HEX); Serial.print(", "); Serial.print(rfid.serNum,HEX); Série.print(", "); Serial.print(rfid.serNum,HEX); Série.print(", "); Serial.print(rfid.serNum,HEX); Série.println(" "); ) else ( /* Si c'est déjà une carte lue, imprimez simplement le point */ Serial.print("."); ) ) ) rfid.halt(); )
Le croquis téléchargé, la LED d'alimentation du module est allumée, mais le module ne répond pas à la carte ? Ne paniquez pas et ne courez pas chercher les exemples de travail « corrects ». Très probablement, il n'y a tout simplement aucun contact sur l'une des broches - les trous sur la carte sont légèrement plus grands que l'épaisseur du cavalier, cela vaut donc la peine d'essayer de les réorganiser. La LED de la carte n'est pas allumée ? Essayez de changer le cavalier qui mène à 3,3 V et assurez-vous qu'il est connecté à 3,3 V sur la carte, fournir une alimentation à 5 V peut facilement tuer votre carte.
Disons que tout a fonctionné pour vous. Ensuite, en lisant les tags par le module RFID, nous verrons ce qui suit sur le moniteur du port série :
Ici, j'ai lu 3 marques différentes, et comme vous pouvez le voir, il a réussi à lire les 3.
Exemple n°2 : Lecture des données d'une carte
Considérons une option plus développée : elle lira non seulement le numéro de carte, mais également toutes les données disponibles pour la lecture. Cette fois, nous prendrons un exemple de la bibliothèque MFRC522 - DumpInfo.
#include #include #define RST_PIN 9 // #define SS_PIN 10 // MFRC522 mfrc522(SS_PIN, RST_PIN); // Créer une instance MFRC522 void setup() ( Serial.begin(9600); // Initialiser le moniteur du port série pendant (!Serial); // Ne rien faire jusqu'à ce qu'il soit ouvert (pour Arduino sur puce ATMEGA32U4) SPI.begin() ; // Initialisez le bus SPI mfrc522.PCD_Init(); // Initialisez le module RFID ShowReaderDetails(); // Affichez les données sur le module MFRC522 Serial.println(F("Scan PICC pour voir l'UID, le type et les blocs de données.. ." )); ) void loop() ( // Recherche d'une nouvelle carte if (! mfrc522.PICC_IsNewCardPresent()) ( return; ) // Sélection d'une des cartes if (! mfrc522.PICC_ReadCardSerial()) ( return; ) // Impression des données de la carte mfrc522.PICC_DumpToSerial(&(mfrc522.uid)); ) void ShowReaderDetails() ( // Récupère l'octet du numéro de version du module v = mfrc522.PCD_ReadRegister(mfrc522.VersionReg); Serial.print(F( "Version du logiciel MFRC522 : 0x ")); Serial.print(v, HEX); if (v == 0x91) Serial.print(F(" = v1.0")); sinon if (v == 0x92) Serial. .print(F(" = v2.0")); sinon Serial.print(F(" (inconnu)")); Serial.println(""); // Lorsque nous obtenons 0x00 ou 0xFF, la communication a échoué if ((v == 0x00) || (v == 0xFF)) ( Serial. println(F("AVERTISSEMENT : échec de communication, le MFRC522 est-il correctement connecté ?")) ; ) )
Si l’exemple précédent a fonctionné sans erreur, cela ne devrait pas non plus poser de problème. Cependant, le ticket de métro, qui délivrait le numéro de carte sans aucun problème dans l'exemple précédent, s'est avéré avoir un type de données indéfini dans celui-ci, et le module n'a pu lire autre chose que le numéro de carte.
En conséquence, après avoir lu les données de la carte, nous obtenons son type, son identifiant et ses données provenant de 16 secteurs mémoire. Il convient de noter que les cartes MIFARE 1K sont constituées de 16 secteurs, chaque secteur est constitué de 4 blocs et chaque bloc contient 16 octets de données.
Exemple n°3 : écriture d'une nouvelle pièce d'identité sur la carte
Dans cet exemple, nous envisagerons de changer l'identifiant de la carte (UID). Il est important de savoir que toutes les cartes ne prennent pas en charge le changement d’identité. La carte peut être inscriptible, mais cela signifie uniquement que les données sont inscriptibles. Malheureusement, les cartes que j'avais entre les mains ne prenaient pas en charge la réécriture UID, mais je donnerai ici le code du croquis au cas où.
#include #include /* Définissez le nouvel UID ici */ #define NEW_UID (0xDE, 0xAD, 0xBE, 0xEF) #define SS_PIN 10 #define RST_PIN 9 MFRC522 mfrc522(SS_PIN, RST_PIN); MFRC522 :: MIFARE_Key ; void setup() ( Serial.begin(9600); while (!Serial); SPI.begin(); mfrc522.PCD_Init(); Serial.println(F("Attention : cet exemple écrase l'UID de votre carte modifiable UID, à utiliser avec précaution!")); pour (octet i = 0; i< 6; i++) { key.keyByte[i] = 0xFF; } } void loop() { if (! mfrc522.PICC_IsNewCardPresent() || ! mfrc522.PICC_ReadCardSerial()) { delay(50); return; } // Считываем текущий UID Serial.print(F("Card UID:")); for (byte i = 0; i < mfrc522.uid.size; i++) { Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "); Serial.print(mfrc522.uid.uidByte[i], HEX); } Serial.println(); // Записываем новый UID byte newUid = NEW_UID; if (mfrc522.MIFARE_SetUid(newUid, (byte)4, true)) { Serial.println(F("Wrote new UID to card.")); } // Halt PICC and re-select it so DumpToSerial doesn"t get confused mfrc522.PICC_HaltA(); if (! mfrc522.PICC_IsNewCardPresent() || ! mfrc522.PICC_ReadCardSerial()) { return; } // Считываем данные с карты Serial.println(F("New UID and contents:")); mfrc522.PICC_DumpToSerial(&(mfrc522.uid)); delay(2000); }
Exemple n°4 : écriture de données sur une carte
Et enfin, ce à quoi nous parvenons depuis si longtemps : écrire des données sur la carte. La partie la plus agréable du travail avec le module est la possibilité de faire une copie d'une carte existante, d'ajouter ou de modifier quelque chose, c'est bien plus intéressant que de simplement la lire.
Modifions l'un des blocs de données sur la carte :
#include #include #define RST_PIN 9 #define SS_PIN 10 MFRC522 mfrc522(SS_PIN, RST_PIN); MFRC522 :: MIFARE_Key ; void setup() ( Serial.begin(9600); while (!Serial); SPI.begin(); mfrc522.PCD_Init(); // Préparez la clé // utilisez la clé FFFFFFFFFFFFh qui est le standard pour les cartes vides pour ( octet je = 0 je< 6; i++) { key.keyByte[i] = 0xFF; } Serial.println(F("Scan a MIFARE Classic PICC to demonstrate read and write.")); Serial.print(F("Using key (for A and B):")); dump_byte_array(key.keyByte, MFRC522::MF_KEY_SIZE); Serial.println(); Serial.println(F("BEWARE: Data will be written to the PICC, in sector #1")); } void loop() { // Ждем новую карту if (! mfrc522.PICC_IsNewCardPresent()) return; // Выбираем одну из карт if (! mfrc522.PICC_ReadCardSerial()) return; // Показываем подробности карты Serial.print(F("Card UID:")); dump_byte_array(mfrc522.uid.uidByte, mfrc522.uid.size); Serial.println(); Serial.print(F("PICC type: ")); byte piccType = mfrc522.PICC_GetType(mfrc522.uid.sak); Serial.println(mfrc522.PICC_GetTypeName(piccType)); // Проверяем совместимость if (piccType != MFRC522::PICC_TYPE_MIFARE_MINI && piccType != MFRC522::PICC_TYPE_MIFARE_1K && piccType != MFRC522::PICC_TYPE_MIFARE_4K) { Serial.println(F("This sample only works with MIFARE Classic cards.")); return; } // В этом примере мы используем первый сектор данных карты, блок 4 byte sector = 1; byte blockAddr = 4; byte dataBlock = { // Данные, которые мы запишем на карту 0x01, 0x02, 0x03, 0x04, // 1, 2, 3, 4, 0x05, 0x06, 0x07, 0x08, // 5, 6, 7, 8, 0x08, 0x09, 0xff, 0x0b, // 9, 10, 255, 12, 0x0c, 0x0d, 0x0e, 0x0f // 13, 14, 15, 16 }; byte trailerBlock = 7; byte status; byte buffer; byte size = sizeof(buffer); // Аутентификация Serial.println(F("Authenticating using key A...")); status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, trailerBlock, &key, &(mfrc522.uid)); if (status != MFRC522::STATUS_OK) { Serial.print(F("PCD_Authenticate() failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); return; } // Показываем текущие данные сектора Serial.println(F("Current data in sector:")); mfrc522.PICC_DumpMifareClassicSectorToSerial(&(mfrc522.uid), &key, sector); Serial.println(); // Читаем данные из блока Serial.print(F("Reading data from block ")); Serial.print(blockAddr); Serial.println(F(" ...")); status = mfrc522.MIFARE_Read(blockAddr, buffer, &size); if (status != MFRC522::STATUS_OK) { Serial.print(F("MIFARE_Read() failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); } Serial.print(F("Data in block ")); Serial.print(blockAddr); Serial.println(F(":")); dump_byte_array(buffer, 16); Serial.println(); Serial.println(); // Аутентификация Serial.println(F("Authenticating again using key B...")); status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_B, trailerBlock, &key, &(mfrc522.uid)); if (status != MFRC522::STATUS_OK) { Serial.print(F("PCD_Authenticate() failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); return; } // Записываем данные в блок Serial.print(F("Writing data into block ")); Serial.print(blockAddr); Serial.println(F(" ...")); dump_byte_array(dataBlock, 16); Serial.println(); status = mfrc522.MIFARE_Write(blockAddr, dataBlock, 16); if (status != MFRC522::STATUS_OK) { Serial.print(F("MIFARE_Write() failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); } Serial.println(); // Читаем данные снова, чтобы проверить, что запись прошла успешно Serial.print(F("Reading data from block ")); Serial.print(blockAddr); Serial.println(F(" ...")); status = mfrc522.MIFARE_Read(blockAddr, buffer, &size); if (status != MFRC522::STATUS_OK) { Serial.print(F("MIFARE_Read() failed: ")); Serial.println(mfrc522.GetStatusCodeName(status)); } Serial.print(F("Data in block ")); Serial.print(blockAddr); Serial.println(F(":")); dump_byte_array(buffer, 16); Serial.println(); Serial.println(F("Checking result...")); byte count = 0; for (byte i = 0; i < 16; i++) { if (buffer[i] == dataBlock[i]) count++; } Serial.print(F("Number of bytes that match = ")); Serial.println(count); if (count == 16) { Serial.println(F("Success:-)")); } else { Serial.println(F("Failure, no match:-(")); Serial.println(F(" perhaps the write didn"t work properly...")); } Serial.println(); // Выводим данные Serial.println(F("Current data in sector:")); mfrc522.PICC_DumpMifareClassicSectorToSerial(&(mfrc522.uid), &key, sector); Serial.println(); mfrc522.PICC_HaltA(); mfrc522.PCD_StopCrypto1(); } void dump_byte_array(byte *buffer, byte bufferSize) { for (byte i = 0; i < bufferSize; i++) { Serial.print(buffer[i] < 0x10 ? " 0" : " "); Serial.print(buffer[i], HEX); } }
Et en conséquence, nous obtenons une carte avec un bloc de données modifié :
Maintenant que vous avez appris à lire et à écrire des blocs de données de carte, vous pouvez expérimenter avec les balises que vous possédez probablement : laissez-passer, laissez-passer de transports en commun. Essayez de lire et d'écrire des données à partir de ces cartes, quelques passes en double ne font jamais de mal, n'est-ce pas ?)
C'est tout, abonnez-vous et suivez les publications. La prochaine fois, je parlerai et vous montrerai comment ajouter des caractères personnalisés à un affichage standard de 1 602 caractères, en ajoutant efficacement des graphiques à l'affichage.
