<divclass="col-main cell cell--auto"><!-- start custom main top snippet --><divid="results-container"class="search-result js-search-result"></div><!-- end custom main top snippet -->
<articleitemscopeitemtype="http://schema.org/Article"><divclass="article__header"><header><h1style="color:Tomato;">Lecteur USB RFID/NFC SCL3711 + RFID/Raspberry PI + RFID/Arduino</h1></header></div><metaitemprop="headline"content="Lecteur USB RFID/NFC SCL3711 + RFID/Raspberry PI + RFID/Arduino"><divclass="article__info clearfix"><ulclass="left-col menu"><li>
<p>La Radio Identification, ou RFID (en anglais Radio Frequency Identification) est une technologie permettant d’identifier et caractériser un objet grâce à une étiquette émettant des ondes radio.</p>
<p>La RFID fait partie des technologies de localisation en temps réel (RTLS : Real Time Localisation System) et est utilisée principalement dans le cadre du traçage de marchandises dans de nombreux secteurs : retail, santé, transport et logistique, militaire et automobile.</p>
<p>Ainsi, le NFC est un dérivé de la technologie RFID mais présente quelques spécificités. La différence principale entre la RFID et le NFC réside dans le fait que la technologie NFC permet un transfert de données limité. Enfin, la technologie NFC fonctionne à très faible distance, quelques centimètres seulement contre plusieurs mètres pour la RFID.</p>
<p>Qu’est-ce que la technologie RFID et comment fonctionne-t-elle?</p>
<p>Le système d’ identification par radiofréquence comprend deux composants principaux: un transpondeur/étiquette attaché à un objet à identifier et un émetteur-récepteur également appelé interrogateur/lecteur.</p>
<p>Un lecteur se compose d’un module radiofréquence et d’une antenne générant un champ électromagnétique haute fréquence. D’autre part, l’étiquette est généralement un périphérique passif, ce qui signifie qu’elle ne contient pas de batterie. Au lieu de cela, il contient une puce qui stocke et traite les informations, ainsi qu’une antenne pour recevoir et transmettre un signal.</p>
<p>Pour lire les informations encodées sur une étiquette, celle-ci est placée à proximité du lecteur (il n’est pas nécessaire que celle-ci se trouve dans la ligne de vue directe du lecteur). Un lecteur génère un champ électromagnétique qui fait que les électrons se déplacent à travers l’antenne de l’étiquette et alimentent ensuite la puce.</p>
<p>La puce alimentée à l’intérieur de l’étiquette répond ensuite en renvoyant ses informations stockées au lecteur sous la forme d’un autre signal radio. Ceci s’appelle la rétrodiffusion. La rétrodiffusion, ou la modification de l’onde électromagnétique / RF, est détectée et interprétée par le lecteur qui envoie ensuite les données à un ordinateur ou à un microcontrôleur.</p>
<h2id="liens">Liens</h2>
<ul>
<li><ahref="http://blogmotion.fr/internet/securite/gen1-gen2-gen3-nfc-mifare-1k-18004">Présentation des générations de tags Mifare (NFC 13,56 MHz)</a></li>
<li><ahref="https://www.latelierdugeek.fr/tag/mfoc/">mfoc – L’Atelier du Geek</a></li>
<li><ahref="https://blandais.github.io/mifare/fr">Cloner un tag Mifare avec un PN532</a></li>
<li><ahref="https://www.unicoda.com/?p=3350">Clone parfait d’une puce RFID</a></li>
<divclass="language-plaintext highlighter-rouge"><divclass="highlight"><preclass="highlight"><code>[ 5115.395318] usb 2-1: new full-speed USB device number 3 using xhci_hcd
[ 5115.576126] usb 2-1: New USB device found, idVendor=04e6, idProduct=5591, bcdDevice= 2.07
[ 5115.576132] usb 2-1: New USB device strings: Mfr=1, Product=2, SerialNumber=0
[ 5115.576135] usb 2-1: Product: SCL3711-NFC&RW
[ 5115.576137] usb 2-1: Manufacturer: SCM Micro
[ 5115.635559] nfc: nfc_init: NFC Core ver 0.1
[ 5115.635587] NET: Registered protocol family 39
[ 5115.644154] usb 2-1: NFC: NXP PN533 firmware ver 2.7 now attached
[ 5115.646729] usbcore: registered new interface driver pn533_usb
[ 7314.588412] usb 2-1: USB disconnect, device number 3
<h3id="vérifier-le-fonctionnement-du-lecteur">Vérifier le fonctionnement du lecteur</h3>
<p>Pour être sûr que le lecteur fonctionne correctement avec les <strong>NFC Tools</strong>, poser un tag RFID sur le lecteur et lancer la commande suivante</p>
<h3id="extraire-les-clés-de-chiffrement-de-la-puce-rfid-vierge-dans-un-fichier">Extraire les clés de chiffrement de la puce RFID vierge dans un fichier</h3>
<p>Pour pouvoir écrire sur une puce RFID, il faut en posséder les clés de chiffrement. Une sorte de mot de passe qui permet d’encoder et de décoder les informations de la puce. Ces clés de chiffrements vont être stockées avec le contenu de la clé, dans un fichier. Ce fichier nous servira lors de l’étape finale pour copier les données de la puce originale sur la puce chinoise.</p>
<p>Pour lancer l’extraction des clés de chiffrement, placez votre puce sur le lecteur et saisissez dans un terminal la commande suivante.</p>
<p>Les clés de chiffrement seront stockées dans le fichier « carte-vierge.dmp ».</p>
<h3id="copiez-le-contenu-de-la-puce-rfid-dorigine-dans-un-fichier">Copiez le contenu de la puce RFID d’origine dans un fichier</h3>
<p>Maintenant que les clés de chiffrement de la puce chinoise sont extraites, il va falloir faire de même avec la puce originale. Cette opération va copier les clés de chiffrement et le contenu de la puce d’origine dans un fichier. Ce fichier contiendra toutes les données de la puce, ainsi que son UID. C’est en quelques sorte une « sauvegarde » de votre puce RFID. N’hésitez pas à la conserver en lieu sûr, ainsi si vous perdez votre puce RFID vous pourrez en créer de nouvelles à l’identique à partir de ce fichier de sauvegarde.</p>
<p>Pour ce faire, placez la puce originale sur votre lecteur, et entrez la commande suivante :</p>
<p>Vous l’aurez surement compris, cette commande va créer un fichier « carte-originale.dmp » c’est le fameux fichier de sauvegarde de votre puce originale.</p>
<h3id="ecrire-le-contenu-de-la-puce-originale-sur-la-puce-vierge">Ecrire le contenu de la puce originale sur la puce vierge</h3>
<p>On arrive au bout ! Vous n’êtes plus qu’à une dernière commande de la victoire ! Maintenant que l’on possède une copie du contenu de la puce originale, ainsi que les clés de chiffrement de la puce chinoise, nous allons pouvoir transférer le contenu et l’UID de la puce originale sur la puce chinoise.</p>
<p>Pour se faire, et toujours dans le terminal, saisissez la commande suivante.</p>
<divclass="language-plaintext highlighter-rouge"><divclass="highlight"><preclass="highlight"><code>sudo nfc-mfclassic W a carte-originale.dmp carte-vierge.dmp
</code></pre></div></div>
<p><imgsrc="/images/nfc-write.png"alt=""/><br/>
L’opération devrait prendre 1 grosse seconde avant d’aboutir sur un message de succès. Si vous êtes attentifs, vous remarquerez que la seule différence par rapport au précédent article est le fait que le « W » est écrit en capital. ça n’est pas une erreur, cela demande au lecteur de transférer le contenu de la puce ainsi que le bloc 0 qui contient l’UID. En cas de succès, un message devrait vous confirmer l’écriture de 64 secteurs sur 64</p>
<h3id="nfc-tools--gui">NFC Tools GUI</h3>
<p><ahref="https://www.wakdev.com/apps/nfc-tools-pc-mac.html">NFC Tools GUI</a> est un logiciel multiplate-forme: il fonctionne sur Mac, Windows et Linux.
Vous pouvez lire et écrire vos puces NFC grâce à une interface utilisateur simple et lisible.</p>
<p><strong>Prérequis</strong></p>
<ul>
<li>Un lecteur NFC compatible, avec pilotes associés et bibliothèque PC/SC.
<h2id="lecteur--rfid-rc522raspberry-pi">Lecteur RFID RC522/Raspberry Pi</h2>
<p><ahref="https://pimylifeup.com/raspberry-pi-rfid-rc522/">How to setup a Raspberry Pi RFID RC522 Chip</a></p>
<p>Les puces RFID sont de plus en plus utilisées pour des systèmes d’identification, de gestion d’inventaire, de paiement, ou pour de la domotique,</p>
<p>Comment lire des cartes RFID avec la Raspberry Pi et un lecteur RFID RC522 ?</p>
<p>À la fin du tutoriel, vous serez capable de lire un badge RFID, vérifier si c’est bien celui attendu, et allumer une LED verte ou rouge, selon le résultat. Il ne vous restera plus qu’à adapter cet exemple de base pour le projet de votre choix !</p>
<li><strong><em>VCC</em></strong> alimente le module. Cela peut être n’importe où de 2,5 à 3,3 volts. Vous pouvez le connecter à la sortie 3.3V de votre Arduino. N’oubliez pas que le connecter à une broche 5V détruira probablement votre module!</li>
<li><strong><em>RST</em></strong> est une entrée pour la réinitialisation et la mise hors tension. Lorsque cette broche devient faible, la mise hors tension matérielle est activée. Cela désactive tous les récepteurs de courant internes, y compris l’oscillateur et les broches d’entrée, sont déconnectés du monde extérieur. Sur le front montant, le module est réinitialisé.</li>
<li><strong><em>GND</em></strong> est la broche de terre et doit être connecté à la broche GND de l’Arduino.</li>
<li><strong><em>IRQ</em></strong> est une broche d’interruption pouvant alerter le microcontrôleur lorsque l’étiquette RFID se trouve à proximité.</li>
<li>La broche <strong><em>MISO/SCL/Tx</em></strong> fait office de sortie maître-esclave lorsque l’interface SPI est activée, agit comme horloge série lorsque l’interface I2C est activée et agit comme sortie de données série lorsque l’interface UART est activée.</li>
<li><strong><em>MOSI (Master Out Slave In)</em></strong> est l’entrée SPI du module RC522.</li>
<li><strong><em>SCK (Serial Clock)</em></strong> accepte les impulsions d’horloge fournies par le bus maître SPI, c’est-à-dire Arduino.</li>
<li>La broche <strong><em>SS/SDA/Rx</em></strong> agit comme entrée de signal lorsque l’interface SPI est activée, agit comme données série lorsque l’interface I2C est activée et agit comme entrée de données série lorsque l’interface UART est activée. Cette broche est généralement marquée en la recouvrant d’un carré afin de pouvoir être utilisée comme référence pour identifier les autres broches.</li>
</ul>
<h3id="les-ports-gpio-du-rasberry-pi">Les ports GPIO du Rasberry Pi</h3>
<p>Un port GPIO transmet un signal relativement binaire (pas de courant ou du courant). Dans le cas de la Raspberry Pi, les ports GPIO travaillent en 3.3 V et environ 20 mA.<br/>
Les ports GPIO sont donc un moyen simple de communiquer ou de contrôler des éléments physiques.</p>
<p>Les modèles les plus récents de la Raspberry Pi disposent de 40 connectiques GPIO, qui se divisent en différentes catégories avec des usages spécifiques.</p>
<h3id="branchement-des-leds">Branchement des leds</h3>
<p>Connecter la résistance de 1.2k entre la masse (GND) et les 2 cathodes des leds.<br/>
L’anode de la led rouge sur GPIO02 Pin 3 du raspberry pi
L’anode de la led verte sur GPIO03 Pin 5 du raspberry pi</p>
<h3id="activer-le-protocole-spi-de-la-raspberry-pi">Activer le protocole SPI de la Raspberry Pi</h3>
<p>Avant d’écrire le programme, activons le protocole SPI sur notre Raspberry Pi afin de pouvoir utiliser le module RFID. Lancer la commande <codeclass="language-plaintext highlighter-rouge">sudo raspi-config</code>, sur votre raspberry, puis de choisir <strong>Interfacing Options, SPI, Yes</strong> et enfin <strong>Finish</strong>.</p>
<h3id="installer-la-librairie-pi-rc522">Installer la librairie pi-rc522</h3>
<p>La librairie Python3 pi-rc522 permet de contrôler le lecteur RC522.</p>
<h3id="programme-de-lecture-identifiant-badge-rfid">Programme de lecture identifiant badge RFID</h3>
<p>Chaque badge RFID possède un identifiant unique. C’est en lisant cet identifiant et en le comparant à une liste d’identifiants autorisés que l’on peut savoir si un badge est autorisé.<br/>
Ecrire un programme dans le dossier <strong>/home/pi/electronic</strong> pour lire l’identifiant unique d’un badge RFID. <br/>
Création fichier <strong>read_rfid_uid.py</strong></p>
<spanclass="kn">import</span><spanclass="n">RPi.GPIO</span><spanclass="k">as</span><spanclass="n">GPIO</span><spanclass="c1">#Importe la bibliothèque pour contrôler les GPIOs
<spanclass="n">GPIO</span><spanclass="p">.</span><spanclass="nf">setmode</span><spanclass="p">(</span><spanclass="n">GPIO</span><spanclass="p">.</span><spanclass="n">BOARD</span><spanclass="p">)</span><spanclass="c1">#Définit le mode de numérotation (Board)
</span><spanclass="n">GPIO</span><spanclass="p">.</span><spanclass="nf">setwarnings</span><spanclass="p">(</span><spanclass="bp">False</span><spanclass="p">)</span><spanclass="c1">#On désactive les messages d'alerte
</span>
<spanclass="n">rc522</span><spanclass="o">=</span><spanclass="nc">RFID</span><spanclass="p">()</span><spanclass="c1">#On instancie la lib
</span>
<spanclass="nf">print</span><spanclass="p">(</span><spanclass="sh">'</span><spanclass="s">En attente d</span><spanclass="se">\'</span><spanclass="s">un badge (pour quitter, Ctrl + c): </span><spanclass="sh">'</span><spanclass="p">)</span><spanclass="c1">#On affiche un message demandant à l'utilisateur de passer son badge
</span>
<spanclass="c1">#On va faire une boucle infinie pour lire en boucle
<spanclass="n">rc522</span><spanclass="p">.</span><spanclass="nf">wait_for_tag</span><spanclass="p">()</span><spanclass="c1">#On attnd qu'une puce RFID passe à portée
</span><spanclass="p">(</span><spanclass="n">error</span><spanclass="p">,</span><spanclass="n">tag_type</span><spanclass="p">)</span><spanclass="o">=</span><spanclass="n">rc522</span><spanclass="p">.</span><spanclass="nf">request</span><spanclass="p">()</span><spanclass="c1">#Quand une puce a été lue, on récupère ses infos
</span>
<spanclass="k">if</span><spanclass="ow">not</span><spanclass="n">error</span><spanclass="p">:</span><spanclass="c1">#Si on a pas d'erreur
</span><spanclass="p">(</span><spanclass="n">error</span><spanclass="p">,</span><spanclass="n">uid</span><spanclass="p">)</span><spanclass="o">=</span><spanclass="n">rc522</span><spanclass="p">.</span><spanclass="nf">anticoll</span><spanclass="p">()</span><spanclass="c1">#On nettoie les possibles collisions, ça arrive si plusieurs cartes passent en même temps
</span>
<spanclass="k">if</span><spanclass="ow">not</span><spanclass="n">error</span><spanclass="p">:</span><spanclass="c1">#Si on a réussi à nettoyer
</span><spanclass="nf">print</span><spanclass="p">(</span><spanclass="sh">'</span><spanclass="s">Vous avez passé le badge avec l</span><spanclass="se">\'</span><spanclass="s">id : {}</span><spanclass="sh">'</span><spanclass="p">.</span><spanclass="nf">format</span><spanclass="p">(</span><spanclass="n">uid</span><spanclass="p">))</span><spanclass="c1">#On affiche l'identifiant unique du badge RFID
</span><spanclass="n">time</span><spanclass="p">.</span><spanclass="nf">sleep</span><spanclass="p">(</span><spanclass="mi">1</span><spanclass="p">)</span><spanclass="c1">#On attend 1 seconde pour ne pas lire le tag des centaines de fois en quelques milli-secondes
</span></code></pre></div></div>
<p>Une fois le fichier enregistré, on en autorise l’exécution avec la commande :</p>
<p>À chaque fois que vous passerez un badge RFID devant le lecteur, son identifiant unique sera affiché !</p>
<h3id="afficher-si-un-badge-est-valide-ou-non">afficher si un badge est valide ou non</h3>
<p>Maintenant que nous pouvons lire l’identifiant unique d’un badge, il ne nous reste plus qu’à adapter le code précédent pour comparer l’identifiant lu à un identifiant écrit dans le programme.<br/>
Nous allons donc modifier un peu le programme précédent pour qu’il compare l’uid lu à celui écris dans le programme, et allumer la led rouge ou verte selon le résultat.<br/>
Copiez donc le fichier précédent, dans un nouveau fichier <strong>verify_rfid.py</strong> et modifier le pour le code ci-dessous</p>
<spanclass="kn">import</span><spanclass="n">RPi.GPIO</span><spanclass="k">as</span><spanclass="n">GPIO</span><spanclass="c1">#Importe la bibliothèque pour contrôler les GPIOs
<spanclass="n">GPIO</span><spanclass="p">.</span><spanclass="nf">setmode</span><spanclass="p">(</span><spanclass="n">GPIO</span><spanclass="p">.</span><spanclass="n">BOARD</span><spanclass="p">)</span><spanclass="c1">#Définit le mode de numérotation (Board)
</span><spanclass="n">GPIO</span><spanclass="p">.</span><spanclass="nf">setwarnings</span><spanclass="p">(</span><spanclass="bp">False</span><spanclass="p">)</span><spanclass="c1">#On désactive les messages d'alerte
</span>
<spanclass="n">LED_RED</span><spanclass="o">=</span><spanclass="mi">3</span><spanclass="c1">#Définit le numéro du port GPIO qui alimente la led rouge
</span><spanclass="n">LED_GREEN</span><spanclass="o">=</span><spanclass="mi">5</span><spanclass="c1">#Définit le numéro du port GPIO qui alimente la led verte
</span><spanclass="n">RFID_UID</span><spanclass="o">=</span><spanclass="p">[</span><spanclass="mi">21</span><spanclass="p">,</span><spanclass="mi">35</span><spanclass="p">,</span><spanclass="mi">5</span><spanclass="p">,</span><spanclass="mi">43</span><spanclass="p">,</span><spanclass="mi">57</span><spanclass="p">]</span><spanclass="c1">#Définit l'UID du badge RFID
</span>
<spanclass="c1">#Définit la fonction permettant d'allumer une led
<spanclass="n">GPIO</span><spanclass="p">.</span><spanclass="nf">setup</span><spanclass="p">(</span><spanclass="n">led</span><spanclass="p">,</span><spanclass="n">GPIO</span><spanclass="p">.</span><spanclass="n">OUT</span><spanclass="p">)</span><spanclass="c1">#Active le contrôle du GPIO
</span><spanclass="n">GPIO</span><spanclass="p">.</span><spanclass="nf">output</span><spanclass="p">(</span><spanclass="n">led</span><spanclass="p">,</span><spanclass="n">GPIO</span><spanclass="p">.</span><spanclass="n">HIGH</span><spanclass="p">)</span><spanclass="c1">#Allume la led
</span>
<spanclass="c1">#Définit la fonction permettant d'éteindre une led
<spanclass="n">GPIO</span><spanclass="p">.</span><spanclass="nf">setup</span><spanclass="p">(</span><spanclass="n">led</span><spanclass="p">,</span><spanclass="n">GPIO</span><spanclass="p">.</span><spanclass="n">OUT</span><spanclass="p">)</span><spanclass="c1">#Active le contrôle du GPIO
</span><spanclass="n">GPIO</span><spanclass="p">.</span><spanclass="nf">output</span><spanclass="p">(</span><spanclass="n">led</span><spanclass="p">,</span><spanclass="n">GPIO</span><spanclass="p">.</span><spanclass="n">LOW</span><spanclass="p">)</span><spanclass="c1">#Eteind la led
</span>
<spanclass="c1">#Définit la fonction permettant d'allumer la rouge et éteindre la verte
<spanclass="nf">turn_led_off</span><spanclass="p">(</span><spanclass="n">LED_GREEN</span><spanclass="p">)</span><spanclass="c1">#Eteind la led verte
</span><spanclass="nf">turn_led_on</span><spanclass="p">(</span><spanclass="n">LED_RED</span><spanclass="p">)</span><spanclass="c1">#Allume la led rouge
</span>
<spanclass="c1">#Définit la fonction permettant d'allumer la verte et éteindre la rouge
<spanclass="nf">turn_led_off</span><spanclass="p">(</span><spanclass="n">LED_RED</span><spanclass="p">)</span><spanclass="c1">#Eteind la led rouge
</span><spanclass="nf">turn_led_on</span><spanclass="p">(</span><spanclass="n">LED_GREEN</span><spanclass="p">)</span><spanclass="c1">#Allume la led verte
</span>
<spanclass="n">rc522</span><spanclass="o">=</span><spanclass="nc">RFID</span><spanclass="p">()</span><spanclass="c1">#On instancie la lib
</span>
<spanclass="nf">print</span><spanclass="p">(</span><spanclass="sh">'</span><spanclass="s">En attente d</span><spanclass="se">\'</span><spanclass="s">un badge (pour quitter, Ctrl + c): </span><spanclass="sh">'</span><spanclass="p">)</span><spanclass="c1">#On affiche un message demandant à l'utilisateur de passer son badge
</span>
<spanclass="c1">#On va faire une boucle infinie pour lire en boucle
<spanclass="n">rc522</span><spanclass="p">.</span><spanclass="nf">wait_for_tag</span><spanclass="p">()</span><spanclass="c1">#On attnd qu'une puce RFID passe à portée
</span><spanclass="p">(</span><spanclass="n">error</span><spanclass="p">,</span><spanclass="n">tag_type</span><spanclass="p">)</span><spanclass="o">=</span><spanclass="n">rc522</span><spanclass="p">.</span><spanclass="nf">request</span><spanclass="p">()</span><spanclass="c1">#Quand une puce a été lue, on récupère ses infos
</span>
<spanclass="k">if</span><spanclass="ow">not</span><spanclass="n">error</span><spanclass="p">:</span><spanclass="c1">#Si on a pas d'erreur
</span><spanclass="p">(</span><spanclass="n">error</span><spanclass="p">,</span><spanclass="n">uid</span><spanclass="p">)</span><spanclass="o">=</span><spanclass="n">rc522</span><spanclass="p">.</span><spanclass="nf">anticoll</span><spanclass="p">()</span><spanclass="c1">#On nettoie les possibles collisions, ça arrive si plusieurs cartes passent en même temps
</span>
<spanclass="k">if</span><spanclass="ow">not</span><spanclass="n">error</span><spanclass="p">:</span><spanclass="c1">#Si on a réussi à nettoyer
<spanclass="n">time</span><spanclass="p">.</span><spanclass="nf">sleep</span><spanclass="p">(</span><spanclass="mi">1</span><spanclass="p">)</span><spanclass="c1">#On attend 1 seconde pour ne pas lire le tag des centaines de fois en quelques milli-secondes
</span></code></pre></div></div>
<p>Il ne vous reste plus qu’à lancer le programme et tester !<br/>
Vous pouvez ensuite adapter le code pour vos propres projets, comme créer un serrure connectée, ou encore un jukebox utilisant des tags RFID !<br/>
Pour info, vous pouvez récupérer l’ensemble du code de ce tutoriel sur le <ahref="https://github.com/RaspbianFrance/rfid">Github de Raspberry Pi FR</a>.</p>
<h2id="lecteur-rfid-rc522arduino">Lecteur RFID RC522/Arduino</h2>
<ul>
<li><ahref="https://ouiaremakers.com/posts/tutoriel-diy-arduino-rfid-rc522">Arduino RFID RC522</a></li>
<li><ahref="https://lastminuteengineers.com/how-rfid-works-rc522-arduino-tutorial/">What is RFID? How It Works? Interface RC522 RFID Module with Arduino</a></li>
</ul>
<h3id="interfacer-le-module-rfid-rc522-avec-arduino">Interfacer le module RFID RC522 avec Arduino</h3>
<p>Pour commencer, connectez la broche VCC du module à 3,3 V sur l’Arduino et la broche GND à la terre. La broche RST peut être connectée à n’importe quelle broche numérique sur l’Arduino. Dans notre cas, il est connecté à la broche numérique n ° 5. La broche IRQ n’est pas connectée car la bibliothèque Arduino que nous allons utiliser ne la prend pas en charge.<br/>
Nous en sommes maintenant aux broches utilisées pour la communication SPI. Comme le module RC522 nécessite beaucoup de transfert de données, il donnera les meilleures performances lorsqu’il est connecté aux broches SPI matérielles d’un microcontrôleur. Les broches SPI matérielles sont beaucoup plus rapides que le “bit-bang” du code d’interface à l’aide d’un autre ensemble de broches.</p>
<blockquote>
<p>Notez que chaque carte Arduino a différentes broches SPI qui doivent être connectées en conséquence. Pour les cartes Arduino telles que UNO / Nano V3.0, ces broches sont numériques 13 (SCK), 12 (MISO), 11 (MOSI) et 10 (SS).</p>
</blockquote>
<p>Si vous avez un Mega, les pins sont différents! Vous voudrez utiliser les technologies numériques 50 (MISO), 51 (MOSI), 52 (SCK) et 53 (SS). Reportez-vous au tableau ci-dessous pour une compréhension rapide.</p>
<table>
<thead>
<tr>
<th>_</th>
<th>MOSI</th>
<th>MISO</th>
<th>SCK</th>
<th>CS</th>
</tr>
</thead>
<tbody>
<tr>
<td>Arduino Uno</td>
<td>11</td>
<td>12</td>
<td>13</td>
<td>10</td>
</tr>
<tr>
<td>Arduino Nano</td>
<td>11</td>
<td>12</td>
<td>13</td>
<td>10</td>
</tr>
<tr>
<td>Arduino Mega</td>
<td>51</td>
<td>50</td>
<td>52</td>
<td>53</td>
</tr>
</tbody>
</table>
<p>Si vous utilisez une carte Arduino différente de celle mentionnée ci-dessus, il est conseillé de vérifier la <ahref="https://www.arduino.cc/en/Reference/SPI">documentation officielle</a> d’Arduino avant de poursuivre.</p>
<h3id="code-arduino---lecture-dune-étiquette-rfid">Code Arduino - Lecture d’une étiquette RFID</h3>
<p>Communiquer avec le module RFID RC522 est un travail fastidieux, mais heureusement pour nous, il existe une bibliothèque appelée bibliothèque MFRC522 qui simplifie la lecture et l’écriture sur les étiquettes RFID. Merci à Miguel Balboa. Commencez par télécharger la bibliothèque en visitant le <ahref="https://github.com/miguelbalboa/rfid">dépôt GitHub</a> ou <ahref="https://lastminuteengineers.com/libraries/rfid-master.zip">télécharger le zip</a>:</p>
<p>Pour l’installer, ouvrez l’EDI Arduino, accédez à Esquisse> Inclure la bibliothèque> Ajouter une bibliothèque .ZIP, puis sélectionnez le fichier rfid-master.zip que vous venez de télécharger. Si vous avez besoin de plus de détails sur l’installation d’une bibliothèque, consultez ce tutoriel sur l’installation d’une bibliothèque Arduino .</p>
<p>Une fois la bibliothèque installée, ouvrez le sous-menu Exemples et sélectionnez MFRC522> DumpInfo, exemple d’esquisse.<br/>
Cette esquisse n’écrira aucune donnée sur la balise. Il vous indique simplement s’il a réussi à lire la balise et affiche des informations à ce sujet. Cela peut être très utile avant d’essayer un nouveau tag!</p>
<p>Allez au début de l’esquisse et assurez-vous que le RST_PIN est correctement initialisé. Dans notre cas, nous utilisons la broche numérique 5 alors changez-le en 5!<br/>
OK, chargez maintenant le croquis et ouvrez le moniteur de série. Dès que vous rapprochez le tag du module, vous obtiendrez probablement le résultat suivant. Ne déplacez pas le tag tant que toutes les informations ne sont pas affichées.<br/>
Il affiche toutes les informations utiles sur la balise, y compris son identifiant unique (UID), sa taille et 1K de mémoire.</p>
<h3id="disposition-de-la-mémoire-mifare-classic-1k">Disposition de la mémoire MIFARE Classic 1K</h3>
<p>La mémoire 1K de la balise est organisée en <strong>16 secteurs</strong> (de 0 à 15) Chaque secteur est divisé en <strong>4 blocs</strong> (blocs 0 à 3). Chaque bloc peut stocker 16 octets de données (de 0 à 15).</p>
<p>Cela nous dit sûrement que nous avons<br/>
16 secteurs x 4 blocs x 16 octets de données = 1024 octets = 1K de mémoire</p>
<p>L’ensemble de la mémoire 1K avec les secteurs, les blocs et les données est mis en évidence ci-dessous.<br/>
<em>Représentation 3D de la disposition de la carte mémoire MIFARE Classic 1K</em></p>
<p>Le bloc 3 de chaque secteur est appelé <strong>secteur</strong> et contient des informations appelées <strong>bits d’accès</strong> permettant d’accorder un <strong>accès</strong> en lecture et en écriture aux blocs restants d’un secteur. Cela signifie que seuls les 3 derniers blocs (blocs 0, 1 et 2) de chaque secteur sont réellement disponibles pour le stockage de données, ce qui signifie que nous avons 48 octets par secteur de 64 octets disponibles pour notre propre usage.</p>
<p>De plus, le bloc 0 du secteur 0 est connu sous le nom de fabricant. Le fabricant contient les données du fabricant du circuit intégré, ainsi que l’<strong>identificateur unique (UID)</strong>. Le bloc fabricant est surligné en rouge ci-dessous.<br/>
<p><strong>ATTENTION Il est très risqué d’écraser le bloc du fabricant (Manufacturer Block), cela pourrait verrouiller définitivement la carte.</strong></p>
</blockquote>
<h3id="code-arduino---écrire-une-étiquette-rfid">Code Arduino - Écrire une étiquette RFID</h3>
<p>Considérant que vous avez lu avec succès l’étiquette RFID, nous allons passer à notre prochain test. L’esquisse suivante fera une démonstration de base de l’écriture de données personnalisées sur une étiquette RFID. Essayez le croquis avant de commencer sa ventilation détaillée.</p>
<divclass="language-c highlighter-rouge"><divclass="highlight"><preclass="highlight"><code><spanclass="cp">#include</span><spanclass="cpf"><SPI.h></span><spanclass="c1"> //include the SPI bus library</span><spanclass="cp">
#include</span><spanclass="cpf"><MFRC522.h></span><spanclass="c1"> //include the RFID reader library</span><spanclass="cp">
<spanclass="n">MFRC522</span><spanclass="nf">mfrc522</span><spanclass="p">(</span><spanclass="n">SS_PIN</span><spanclass="p">,</span><spanclass="n">RST_PIN</span><spanclass="p">);</span><spanclass="c1">// instatiate a MFRC522 reader object.</span>
<spanclass="n">MFRC522</span><spanclass="o">::</span><spanclass="n">MIFARE_Key</span><spanclass="n">key</span><spanclass="p">;</span><spanclass="c1">//create a MIFARE_Key struct named 'key', which will hold the card information</span>
<spanclass="c1">//this is the block number we will write into and then read.</span>
<spanclass="n">byte</span><spanclass="n">blockcontent</span><spanclass="p">[</span><spanclass="mi">16</span><spanclass="p">]</span><spanclass="o">=</span><spanclass="p">{</span><spanclass="s">"Last-Minute-Engg"</span><spanclass="p">};</span><spanclass="c1">//an array with 16 bytes to be written into one of the 64 card blocks is defined</span>
<spanclass="c1">//byte blockcontent[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; //all zeros. This can be used to delete a block.</span>
<spanclass="c1">//This array is used for reading out a block.</span>
<spanclass="n">Serial</span><spanclass="p">.</span><spanclass="n">begin</span><spanclass="p">(</span><spanclass="mi">9600</span><spanclass="p">);</span><spanclass="c1">// Initialize serial communications with the PC</span>
<spanclass="n">mfrc522</span><spanclass="p">.</span><spanclass="n">PCD_Init</span><spanclass="p">();</span><spanclass="c1">// Init MFRC522 card (in case you wonder what PCD means: proximity coupling device)</span>
<spanclass="n">Serial</span><spanclass="p">.</span><spanclass="n">println</span><spanclass="p">(</span><spanclass="s">"Scan a MIFARE Classic card"</span><spanclass="p">);</span>
<spanclass="c1">// Prepare the security key for the read and write functions.</span>
<spanclass="n">key</span><spanclass="p">.</span><spanclass="n">keyByte</span><spanclass="p">[</span><spanclass="n">i</span><spanclass="p">]</span><spanclass="o">=</span><spanclass="mh">0xFF</span><spanclass="p">;</span><spanclass="c1">//keyByte is defined in the "MIFARE_Key" 'struct' definition in the .h file of the library</span>
<spanclass="kt">int</span><spanclass="n">trailerBlock</span><spanclass="o">=</span><spanclass="n">largestModulo4Number</span><spanclass="o">+</span><spanclass="mi">3</span><spanclass="p">;</span><spanclass="c1">//determine trailer block for the sector</span>
<spanclass="k">if</span><spanclass="p">(</span><spanclass="n">blockNumber</span><spanclass="o">></span><spanclass="mi">2</span><spanclass="o">&&</span><spanclass="p">(</span><spanclass="n">blockNumber</span><spanclass="o">+</span><spanclass="mi">1</span><spanclass="p">)</span><spanclass="o">%</span><spanclass="mi">4</span><spanclass="o">==</span><spanclass="mi">0</span><spanclass="p">){</span><spanclass="n">Serial</span><spanclass="p">.</span><spanclass="n">print</span><spanclass="p">(</span><spanclass="n">blockNumber</span><spanclass="p">);</span><spanclass="n">Serial</span><spanclass="p">.</span><spanclass="n">println</span><spanclass="p">(</span><spanclass="s">" is a trailer block:"</span><spanclass="p">);</span><spanclass="k">return</span><spanclass="mi">2</span><spanclass="p">;}</span>
<spanclass="n">Serial</span><spanclass="p">.</span><spanclass="n">println</span><spanclass="p">(</span><spanclass="s">" is a data block:"</span><spanclass="p">);</span>
<spanclass="c1">//authentication of the desired block for access</span>
<spanclass="k">return</span><spanclass="mi">4</span><spanclass="p">;</span><spanclass="c1">//return "4" as error message</span>
<spanclass="p">}</span>
<spanclass="n">Serial</span><spanclass="p">.</span><spanclass="n">println</span><spanclass="p">(</span><spanclass="s">"block was written"</span><spanclass="p">);</span>
<spanclass="kt">int</span><spanclass="n">trailerBlock</span><spanclass="o">=</span><spanclass="n">largestModulo4Number</span><spanclass="o">+</span><spanclass="mi">3</span><spanclass="p">;</span><spanclass="c1">//determine trailer block for the sector</span>
<spanclass="c1">//authentication of the desired block for access</span>
<spanclass="k">return</span><spanclass="mi">3</span><spanclass="p">;</span><spanclass="c1">//return "3" as error message</span>
<spanclass="p">}</span>
<spanclass="c1">//reading a block</span>
<spanclass="n">byte</span><spanclass="n">buffersize</span><spanclass="o">=</span><spanclass="mi">18</span><spanclass="p">;</span><spanclass="c1">//we need to define a variable with the read buffer size, since the MIFARE_Read method below needs a pointer to the variable that contains the size... </span>
<spanclass="n">status</span><spanclass="o">=</span><spanclass="n">mfrc522</span><spanclass="p">.</span><spanclass="n">MIFARE_Read</span><spanclass="p">(</span><spanclass="n">blockNumber</span><spanclass="p">,</span><spanclass="n">arrayAddress</span><spanclass="p">,</span><spanclass="o">&</span><spanclass="n">buffersize</span><spanclass="p">);</span><spanclass="c1">//&buffersize is a pointer to the buffersize variable; MIFARE_Read requires a pointer instead of just a number</span>
<spanclass="k">return</span><spanclass="mi">4</span><spanclass="p">;</span><spanclass="c1">//return "4" as error message</span>
<spanclass="p">}</span>
<spanclass="n">Serial</span><spanclass="p">.</span><spanclass="n">println</span><spanclass="p">(</span><spanclass="s">"block was read"</span><spanclass="p">);</span>
<spanclass="p">}</span>
</code></pre></div></div>
<p>L’esquisse commence par inclure les bibliothèques MFRC522 et SPI, définissant les broches Arduino auxquelles le RC522 est connecté et instanciant un objet lecteur MFRC522.</p>
<divclass="language-plaintext highlighter-rouge"><divclass="highlight"><preclass="highlight"><code>#include <SPI.h>//include the SPI bus library
#include <MFRC522.h>//include the RFID reader library
#define SS_PIN 10 //slave select pin
#define RST_PIN 5 //reset pin
MFRC522 mfrc522(SS_PIN, RST_PIN); // instatiate a MFRC522 reader object.
MFRC522::MIFARE_Key key;//create a MIFARE_Key struct named 'key', which will hold the card information
</code></pre></div></div>
<p>Ensuite, nous devons définir un bloc dans lequel nous allons stocker nos données. Ici le secteur 0 bloc 2 est sélectionné. N’oubliez pas de ne jamais sélectionner le bloc 3 d’un secteur. L’écriture dans un bloc ‘segment de secteur’ peut rendre le bloc inutilisable.</p>
<divclass="language-plaintext highlighter-rouge"><divclass="highlight"><preclass="highlight"><code>//this is the block number we will write into and then read.
int block=2;
</code></pre></div></div>
<p>Ensuite, nous définissons un tableau de 16 octets nommé blockcontent[16] qui contient le message que nous voulons écrire dans le bloc. Vous pouvez supprimer n’importe quel bloc en écrivant des zéros.</p>
<divclass="language-plaintext highlighter-rouge"><divclass="highlight"><preclass="highlight"><code>byte blockcontent[16] = {"Last-Minute-Engg"}; //an array with 16 bytes to be written into one of the 64 card blocks is defined
//byte blockcontent[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; //all zeros. This can be used to delete a block.
</code></pre></div></div>
<p>Ensuite, nous devons définir un tableau de 18 octets nommé readbackblock [18] . Ceci peut être utilisé pour lire le contenu écrit. Attendez… 18 octets? Cela ne devrait-il pas être 16 octets? La réponse est non. La méthode MIFARE_Read de la bibliothèque MFRC522 nécessite un tampon d’au moins 18 octets pour contenir les 16 octets d’un bloc.</p>
<divclass="language-plaintext highlighter-rouge"><divclass="highlight"><preclass="highlight"><code>//This array is used for reading out a block.
byte readbackblock[18];
</code></pre></div></div>
<p>Dans la fonction Setup: nous initialisons les communications série avec le PC, la bibliothèque SPI et l’objet MFRC522. Nous devons également préparer la clé de sécurité pour les fonctions de lecture et d’écriture. Ici, les six octets de clé sont définis sur 0xFF. Comme les cartes du kit sont neuves et que les clés n’ont jamais été définies, elles sont 0xFF. Si nous avions une carte programmée par quelqu’un d’autre, nous aurions besoin de connaître la clé pour pouvoir y accéder. Cette clé devrait alors être stockée dans «clé» à la place.</p>
<divclass="language-plaintext highlighter-rouge"><divclass="highlight"><preclass="highlight"><code>Serial.begin(9600); // Initialize serial communications with the PC
SPI.begin(); // Init SPI bus
mfrc522.PCD_Init(); // Init MFRC522 card (in case you wonder what PCD means: proximity coupling device)
Serial.println("Scan a MIFARE Classic card");
// Prepare the security key for the read and write functions.
for (byte i = 0; i < 6; i++) {
key.keyByte[i] = 0xFF; //keyByte is defined in the "MIFARE_Key" 'struct' definition in the .h file of the library
}
</code></pre></div></div>
<p>En boucle: nous recherchons d’abord si une carte est en vue. Si oui, cette carte est sélectionnée pour les besoins de l’écriture et de la lecture.</p>
<divclass="language-plaintext highlighter-rouge"><divclass="highlight"><preclass="highlight"><code>// Look for new cards
if ( ! mfrc522.PICC_IsNewCardPresent()) {
return;
}
// Select one of the cards
if ( ! mfrc522.PICC_ReadCardSerial())
{
return;
}
Serial.println("card selected");
</code></pre></div></div>
<p>Il est maintenant très facile d’écrire le bloc, il suffit d’appeler une fonction personnalisée appelée writeBlock() qui prend deux paramètres - l’un est le numéro de bloc sur lequel nous souhaitons écrire les données et les données elles-mêmes.</p>
<divclass="language-plaintext highlighter-rouge"><divclass="highlight"><preclass="highlight"><code>//the blockcontent array is written into the card block
writeBlock(block, blockcontent);
</code></pre></div></div>
<p>Pour vérifier si l’opération d’écriture a réussi, nous devons relire le contenu du bloc. Cela peut être fait en utilisant la fonction personnalisée appelée readBlock() qui prend à nouveau deux paramètres: l’un est le numéro de bloc et l’autre est array pour stocker le contenu du bloc. Vous pouvez utiliser la fonction PICC_DumpToSerial() si vous souhaitez voir la totalité de la mémoire 1k avec le bloc écrit dans celle-ci.</p>
<divclass="language-plaintext highlighter-rouge"><divclass="highlight"><preclass="highlight"><code>//read the block back
readBlock(block, readbackblock);
//uncomment below line if you want to see the entire 1k memory with the block written into it.
//mfrc522.PICC_DumpToSerial(&(mfrc522.uid));
</code></pre></div></div>
<p>Enfin, nous imprimons le contenu du tableau readbackblock en utilisant une boucle for et affichons le contenu sur le moniteur série.</p>
<divclass="language-plaintext highlighter-rouge"><divclass="highlight"><preclass="highlight"><code>//print the block contents
Serial.print("read block: ");
for (int j=0 ; j<16 ; j++)
{
Serial.write (readbackblock[j]);
}
Serial.println("");
</code></pre></div></div>
<p>La sortie sur le moniteur série ressemblera à ceci.<br/>
<h3id="autre-exemple-lectureécriture">Autre exemple lecture/écriture</h3>
<p>On prend l’exemple nommé <strong>ReadAndWrite.ino</strong> joint avec la bibliothèque MFR522</p>
<blockquote>
<p>ATTENTION : Les données seront inscrites dans le tag, dans le secteur #1 (blocs #4 à #7).</p>
</blockquote>
<p>Résultat sur la console</p>
<divclass="language-plaintext highlighter-rouge"><divclass="highlight"><preclass="highlight"><code>Scan a MIFARE Classic PICC to demonstrate read and write.
Using key (for A and B): FF FF FF FF FF FF
BEWARE: Data will be written to the PICC, in sector #1
<h3id="système-de-contrôle-daccès-serrure-porte-avec-rfid">Système de contrôle d’accès serrure porte avec RFID</h3>
<p>Créons un projet Arduino rapide pour montrer comment un simple module de lecteur RFID RC522 peut être utilisé pour créer un système de contrôle d’accès par serrure de porte RFID . Notre programme analysera l’identifiant unique de chaque étiquette RFID lorsqu’il sera suffisamment proche pour être alimenté par le lecteur RC522. Si l’UID de la balise correspond à une valeur prédéfinie (balise principale) stockée dans la mémoire Arduino, l’accès sera accordé. Et si nous analysons toute balise inconnue, l’accès sera refusé.<br/>
<em>Sortie du projet Arduino de contrôle d’accès de serrure de porte</em></p>
<p>Bien entendu, ce projet pourrait être interfacé pour ouvrir des portes, allumer un relais, allumer une LED ou toute autre chose à laquelle vous pouvez penser.</p>
<p>Si vous n’êtes pas familier avec les écrans LCD 16 × 2 caractères, envisagez de lire le didacticiel <ahref="https://lastminuteengineers.com/arduino-1602-character-lcd-tutorial/">Interfacing 16×2 Character LCD Module with Arduino</a>.</p>
<p>Avant de télécharger du code et de balayer des balises, examinons le schéma de circuit du projet.</p>
<spanclass="n">String</span><spanclass="n">MasterTag</span><spanclass="o">=</span><spanclass="s">"20C3935E"</span><spanclass="p">;</span><spanclass="c1">// REPLACE this Tag ID with your Tag ID!!!</span>
<spanclass="n">lcd</span><spanclass="p">.</span><spanclass="n">print</span><spanclass="p">(</span><spanclass="s">" Access Control "</span><spanclass="p">);</span>
<spanclass="n">lcd</span><spanclass="p">.</span><spanclass="n">print</span><spanclass="p">(</span><spanclass="s">"Scan Your Card>>"</span><spanclass="p">);</span>
<spanclass="n">lcd</span><spanclass="p">.</span><spanclass="n">print</span><spanclass="p">(</span><spanclass="s">" ID : "</span><spanclass="p">);</span>
<spanclass="n">lcd</span><spanclass="p">.</span><spanclass="n">print</span><spanclass="p">(</span><spanclass="s">" Access Control "</span><spanclass="p">);</span>
<spanclass="n">lcd</span><spanclass="p">.</span><spanclass="n">print</span><spanclass="p">(</span><spanclass="s">"Scan Your Card>>"</span><spanclass="p">);</span>
<spanclass="p">}</span>
<spanclass="p">}</span>
<spanclass="c1">//Read new tag if available</span>
<spanclass="c1">// Getting ready for Reading PICCs</span>
<spanclass="k">if</span><spanclass="p">(</span><spanclass="o">!</span><spanclass="n">mfrc522</span><spanclass="p">.</span><spanclass="n">PICC_IsNewCardPresent</span><spanclass="p">())</span><spanclass="p">{</span><spanclass="c1">//If a new PICC placed to RFID reader continue</span>
<spanclass="k">if</span><spanclass="p">(</span><spanclass="o">!</span><spanclass="n">mfrc522</span><spanclass="p">.</span><spanclass="n">PICC_ReadCardSerial</span><spanclass="p">())</span><spanclass="p">{</span><spanclass="c1">//Since a PICC placed get Serial and continue</span>
<spanclass="k">for</span><spanclass="p">(</span><spanclass="kt">uint8_t</span><spanclass="n">i</span><spanclass="o">=</span><spanclass="mi">0</span><spanclass="p">;</span><spanclass="n">i</span><spanclass="o"><</span><spanclass="mi">4</span><spanclass="p">;</span><spanclass="n">i</span><spanclass="o">++</span><spanclass="p">)</span><spanclass="p">{</span><spanclass="c1">// The MIFARE PICCs that we use have 4 byte UID</span>
<spanclass="n">tagID</span><spanclass="p">.</span><spanclass="n">concat</span><spanclass="p">(</span><spanclass="n">String</span><spanclass="p">(</span><spanclass="n">mfrc522</span><spanclass="p">.</span><spanclass="n">uid</span><spanclass="p">.</span><spanclass="n">uidByte</span><spanclass="p">[</span><spanclass="n">i</span><spanclass="p">],</span><spanclass="n">HEX</span><spanclass="p">));</span><spanclass="c1">// Adds the 4 bytes in a single String variable</span>
<p>Le programme est assez simple. Au début, nous incluons les bibliothèques nécessaires, définissons des broches Arduino, créons des instances d’objets LCD et MFRC522 et définissons une balise principale.</p>
<p>Dans la fonction de configuration, nous initialisons l’interface SPI, l’objet MFRC522 et le LCD. Ensuite, nous imprimons le message de bienvenue sur l’écran LCD.</p>
<p>En boucle, nous attendons que la nouvelle balise soit scannée. Une fois que cela est fait, nous comparons la balise inconnue avec la balise principale définie avant la fonction de configuration. C’est tout! Si son identifiant correspond à l’identifiant principal, l’accès est accordé sinon refusé.</p>
// You can write any code here like opening doors, switching on a relay, lighting up an LED, or anything else you can think of.
}
else
{
lcd.print(" Access Denied!");
}
lcd.setCursor(0, 1);
lcd.print(" ID : ");
lcd.print(tagID);
delay(2000);
lcd.clear();
lcd.print(" Access Control ");
lcd.setCursor(0, 1);
lcd.print("Scan Your Card>>");
}
}
</code></pre></div></div>
<p>L’essentiel dans le projet est une fonction personnalisée appelée <codeclass="language-plaintext highlighter-rouge">getID()</code> . Une fois la nouvelle carte recherchée, à l’intérieur d’une boucle for (<codeclass="language-plaintext highlighter-rouge">for loop</code>), il convertit 4 octets d’UID en chaîne et se concatène pour créer une seule chaîne.</p>
