Le module MRF522 est le module de base pour la RFID en DiY

Fonctionne à 3,3 V

distance de détection : de 2 à 3 cm max

Compatibilité des tag  :EM4100

Prix moyen : 1,70 euros pour le module RC522

Arduino UNO

Prix moyen : 4 euros

* Pin layout should be as follows:
     * Signal     Pin              Pin               Pin
     *            Arduino Uno      Arduino Mega      MFRC522 board
     * ------------------------------------------------------------
     * Reset      9                5                 RST
     * SPI SS     10               53                SDA
     * SPI MOSI   11               51                MOSI
     * SPI MISO   12               50                MISO
     * SPI SCK    13               52                SCK

Datasheet

Le Matériel

- un Arduino Uno

- un module Maifaire RC522

- 7 cables

on peut rajouter des Leds pour valider visuellement la lecture d'un Tag

Arduino IDE 1.8.4

Objectifs :

Faire un Dump en hexadécimal du contenu d'un tag

Le programme

j'ai repris le programme de Dump fourni en exemple : Dumpinfo

Disponible apres chargement de la librairie RC522

#include <SPI.h>
#include <MFRC522.h>

#define RST_PIN         9          // Configurable, see typical pin layout above
#define SS_PIN          10         // Configurable, see typical pin layout above

MFRC522 mfrc522(SS_PIN, RST_PIN);  // Create MFRC522 instance

void setup() {
    Serial.begin(9600);        // Initialize serial communications with the PC
    while (!Serial);        // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4)
    SPI.begin();            // Init SPI bus
    mfrc522.PCD_Init();        // Init MFRC522
    mfrc522.PCD_DumpVersionToSerial();    // Show details of PCD - MFRC522 Card Reader details
    Serial.println(F("Scan PICC to see UID, SAK, type, and data blocks..."));
}

void loop() {
    // Look for new cards
    if ( ! mfrc522.PICC_IsNewCardPresent()) {
        return;
    }

    // Select one of the cards
    if ( ! mfrc522.PICC_ReadCardSerial()) {
        return;
    }

    // Dump debug info about the card; PICC_HaltA() is automatically called
    mfrc522.PICC_DumpToSerial(&(mfrc522.uid));
}

Utilisation mémoire de l'arduino

Le croquis utilise 928 octets (2%) de l'espace de stockage de programmes. Le maximum est de 32256 octets.
Les variables globales utilisent 9 octets (0%) de mémoire dynamique, ce qui laisse 2039 octets pour les variables locales. Le maximum est de 2048 octets.

Résultat après lecture d'un TaG

Voir vidéo ci contre, avec le bordel de ma maison en arrière plan

et en pièce jointe le résultat.

Commentaires :

Il faut 2 à 3 secondes pour faire le dump du tag

Le module peut lire 2 tags simultanément

le module est prévu seulement pour les transpondeurs aux normes ISO/IEC 14443 A/MIFAIRE
Il ne gère pas tout ce qui est en 13.56

La distance entre le lecteur et le tag est de 2 centimètres

Les programmes de démo ne détecte pas lorsqu'on enlève le tag.

Programme pour augmenter le gain

 Objectifs :

Vérifier si le type de tag modifie la distance de lecture

Protocole :

- Lecture d'un tag Bleu, type vigitik

-Lecture de la carte blanche

-Lecture du tag sur carte à jouer

Résultats :

carte blanche : 4cm

Tag bleu : 3 cm

carte à jour : 2 cm

Objectifs :

mettre un matériel entre le tag de la carte à jouer et voir si la distance diminue ou pas.

C'est très empirique... un matériel de haute technologie et technicité comme intercalaire..

Protocoles :

-Mesure à vide

-intercaler une feuille de papier

-intercaler un tissu

-intercaler un plastique

Résultats :

- Mesure à vide : 1,5 cm

- Feuille de papier : Pas d'impact

- intercalaire en plastique : Pas d'impact

-intercalaire en tissu : Pas d'impact

objectifs :

Les tags sont collés aux cartes, qui sont mélangés et malmenées

Un jeu est battu 3 fois à chaque main

en table pleine, il y aura 2 tours de tables en 10 minutes, soit 60 battues

Protocoles :

Coller 2 tags dans un jeu de cartes

Vérifier la mesure de référence

Battre les cartes

Tous les 20 battements vérifier la distance de lecture pour voir si l'antenne se détériore

Résultat :

10 mélanges : lecture OK

20 : OK

30 : OK

50 : OK

TEST2

Protocole :

Tester un tag

Le tordre , mais pas le plier en 2

Vérifier si la lecture est possible

Résultat :

Pas de dégradation de la distance de lecture

Objectifs :

Identifier le nombre de carte superposé que peut lire l'algorithme pour RF522

On sait que l'empilement n'a pas

Protocoles :

Se positionner sous la distance de lecture maximum

Rajouter 1 carte par carte

vérifier la lecture des UID du Tag

Résultat :

Bien que la bibliothèque soit sensé lire plusieurs tags, c'est celui le plus prés du  lecteur qui est lu

Objectifs :

Extraire uniquement l'uid de la carte

Pas de changement de matériel

Ressource mémoire de l'arduino

Le croquis utilise 8240 octets (25%) de l'espace de stockage de programmes. Le maximum est de 32256 octets.
Les variables globales utilisent 293 octets (14%) de mémoire dynamique, ce qui laisse 1755 octets pour les variables locales. Le maximum est de 2048 octets.

comparer régulièrement la valeur d'un tag, si celui est enlevé alors après un compteur, cela signifie que la main est jetée, on peut alors déclencher une action

Objectifs :

Mesurer l'autonomie du dispositif hors secteur

La mesure donnera une autonomie max et permettra de définir le dimensionnement de la batterie ou la viabilité du projet avec ce dispositif

Matériel :

Batterie externe pour téléphone portable neuve

capacité : 1500mA

sortie : 1A

prix : 3,21  euros

c'est un modèle qui semble ne plus se faire, d’où l'absence de lien vers la description du matériel.

Protocoles :

Stabiliser le dispositif matériel ( attention celui-ci ne dispose pas de module d’échange de données sans fil).

Brancher le dispositif sur la batterie

Utiliser le programme de vérification de présence d'un tag

(scan toutes les x secondes de la présence d'une carte)

Laisser la carte sur le lecteur

Noter l'heure de début

Lorsque la LED s’éteindra, la batterie ne délivrera plus assez d'energie

Noter l'heure de fin et définir l'autonomie

Résultat :

 8 à 10 heures de fonctionnement

La LED témoin clignotait plusieurs fois par seconde au démarrage du test

Après 7 heures, le clignotement était à 1 fois par seconde

Pour les besoins du projet, je dois connecter entre 2 et 5 lecteurs RFID à l'arduino.

le module utilise les ports MISO, MOSI,SS et SCK et RST

Or l'arduino ne dispose que d'un seul voir 2 de ces ports.

Comment faire ?

Les ports en communs :

- MOSI

-MISO

-SCK

ensuite il faut declarer pour chaque module, un port SS et RST dédié.

le principe du SPI : quand tu t'adresses à un module, tu passes son pin CS ou SS à l'état bas. C'est comme ça que tu décides "à qui tu parles". Donc il faut un pin digital par SS de chaque module

- mettre le pin 53 (10 pour le Arduino Uno) en OUTPUT
- passer tous mes SS pin en HIGH
- les passer en LOW dans la boucle

Introduction

lorsque l'on lit le Datasheet, 5 adresses pour le port I2C sont disponibles.

Sur plusieurs forum, l'accès en I2C semble ne pas fonctionner, mais je vais quand meme tester.

Extrait de la datasheet :

8.1.1 Automatic microcontroller interface detection

The MFRC522 supports direct interfacing of hosts using SPI, I2C-bus or serial UART interfaces. The MFRC522 resets its interface and checks the current host interface type automatically after performing a power-on or hard reset. The MFRC522 identifies the host interface by sensing the logic levels on the control pins after the reset phase. This is done using a combination of fixed pin connections. Table 5 shows the different connection

configurations.

5 adresses semblent disponibles, ce qui signifie qu'on pourrait mettre 5 lecteurs sur le même bus, avec un mécanisme d'attribution des adresses à chaque module.

mais 

On the printed circuit board, pin 1 is connected directly to GND and pin 32 to 3.3V.
So unless you are able to reconnect those pins (by resoldering the board) or if there is a way to override this behaviour (which I am unaware of), you should be stuck to using SPI.

et donc il faut jouer du fer à souder comme indiqué ci contre, donc NO WAY...

bibliotheque specifique I2C ??

https://github.com/arozcan/MFRC522-I2C-Library

Conclusion :

sans soudure, on ne peut pas utiliser le port I2C

La question peut paraître absurde au vue de tout les schémas de montage ci dessus, mais j'avoue quelle mérite 5 minutes de recherches.

il ne s'agit pas de la tension d'alimentation VCC, le sujet est clair sur ce point, mais de l'alimentation des pinouts, et donc de l'ajout d'un abaisseur de tension entre l'arduino qui a des pinouts en 5v et les pinouts du module et donc un cout financier supplémentaire pour la solution( achat et montage)

Quick reference data

Table 1. Quick reference data

Symbol Parameter Conditions Min Typ Max Unit

VDDA analog supply voltage VDD(PVDD)  VDDA = VDDD = VDD(TVDD);

VSSA = VSSD = VSS(PVSS) = VSS(TVSS) = 0 V

[1][2] 2.5 3.3 3.6 V

VDDD digital supply voltage 2.5 3.3 3.6 V

VDD(TVDD) TVDD supply voltage 2.5 3.3 3.6 V

VDD(PVDD) PVDD supply voltage [3] 1.6 1.8 3.6 V

VDD(SVDD) SVDD supply voltage VSSA = VSSD = VSS(PVSS) = VSS(TVSS) = 0 V 1.6 - 3.6 V

Conclusion :

C'est un paradoxe, mais les ports pinouts fonctionnent en 5v sur la 99% des tutoriels sur internet, mais l'utilisation d'un abaisseur de tension semble nécessaire pour le fonctionnement nominal du module selon le datasheet.

Donc la réponse est 3v sur les pinouts.

Ce point est assez récurrent dans le forum.

La question est : comment détecter qu'un TAG est enlevé.

A question simple, réponse....matricielle.

Mais avant d'en arriver là, je me suis cogné la tête contre les murs.

Il est inutile de tester la valeur de uid.size() car celle ci ne repasse jamais a 0 après la première lecture d'un tag

De même, la zone mémoire du MFRC522 ne se vide pas, elle conserve en permanence les informations du dernier tag.

Il est inutile de vouloir flusher la mémoire avec les lignes du fichier MFRC522.h, en tout cas sur un ESP32, le buffer n'a pas bougé malgré toute la bonne volonté que j'y ai mis.

Ma modeste tentative ci dessous  :

Passons donc au choses serieuses...

il faut tester les valeurs en retour de IsNewCard et ReadCardSerial

Avec le petit bout de code suivant :

    Serial.print("IsNew : ");
    Serial.println(mfrc522[m].PICC_IsNewCardPresent());
    Serial.print("ReadSer : ");
    Serial.println(mfrc522[m].PICC_ReadCardSerial());

Le resultat :

A l'initialisation  et au retrait d'un tag

Isnew=0

ReadCard=0

A la lecture d'un tag

Isnew=1

ReadCard=1

Au changement d'un tag :

Là ca se complique, en fonction de la frequence des lectures de tag, les 2 variables peuvent continuer a retourner 1 et 1, seul l'uid changera.

Faut il tester que l'un des 2 ou les 2, la matrice a identifié que 2 cas, donc normalement un test sur une seule des valeurs suffit.

ReadCarSerial doit etre là pour indiquer que le dump memoire est terminé.

Cool..easy ?? que neni.......

 Comment appelle t'on une situation ou le résultat varie en fonction de l'heure de la journée...vous pensez que je rigole...

En fait j'ai eu plusieurs combinaisons...par exemple 1,1 tant qu'un tag etait présent, j'ai eu aussi  1,1 puis 0,0 a la lecture suivante bien que le badge soit toujours là.

Je suis tombé par hasard sur une cause possible.

En fonction de l'utilisation et de la position de ces 2 lignes de codes, le résultat va varier. Donc faites bien attention à l'endroit ou vous les placez dans votre programme ! et tester les valeurs Isnew et CardRead en affichage console systématiquement.

// Halt PICC
//mfrc522[m].PICC_HaltA();
// Stop encryption on PCD
//mfrc522[m].PCD_StopCrypto1();

Le but de ce test est de vérifier que l'on peut changer les ports RST et SS.

Dans le code exemple, il est indiqué ceci pour le câblage

Avec la déclaration :

#define SS_PIN 10
#define RST_PIN 9

je vais donc mettre SS_pin en 39

et RST en 35 et tester

-> TEST OK

09/06/2019

Code source avec toutes les ecritures series pour la log ci contre.

La lecture se fait toutes les 3 secondes (variable interval)

j'ai utilisé un systeme de compteur par lecteur

quand il n'y a pas de carte, cpt [reader] ne change pas

En cas de carte, cpt[reader] s'incremente.

je verifie donc si cpt[reader] a changé

quand la carte est enlevé, je reinitialise le cpt[reader]=0 pour eviter les depassements de pile.

je redeclenche une lecture avec : mfrc522[reader].PCD_Init();

attention à bien le positionner, et ne pas reinitaliser les 2 lecteurs en meme temps.

programme : ReadUidMultiReader_et_carte_enlevee.ino

#include <SPI.h>
#include <MFRC522.h>

#define RST_PIN         47          // Configurable, see typical pin layout above
#define SS_1_PIN        43         // Configurable, take a unused pin, only HIGH/LOW required, must be diffrent to SS 2
#define SS_2_PIN        41        // Configurable, take a unused pin, only HIGH/LOW required, must be diffrent to SS 1

#define NR_OF_READERS   2

byte ssPins[] = {SS_1_PIN, SS_2_PIN};

MFRC522 mfrc522[NR_OF_READERS];   // Create MFRC522 instance.
String datafromarduino="";
String cmdfromarduino="";
String tag="";

unsigned long previousMillis=0 ;
unsigned long interval = 5000; ///lecture de la carte toutes les 5 secondes

uint8_t reader;

unsigned long oldcpt[NR_OF_READERS];
unsigned long cpt[NR_OF_READERS];
String tag2[NR_OF_READERS];

/**
 * Initialize.
 */
void setup() {

  Serial.begin(9600); // Initialize serial communications with the PC
  while (!Serial);    // Do nothing if no serial port is opened (added for Arduinos based on ATMEGA32U4)

  SPI.begin();        // Init SPI bus
  for (reader = 0; reader < NR_OF_READERS; reader++) {
    mfrc522[reader].PCD_Init(ssPins[reader], RST_PIN); // Init each MFRC522 card
    Serial.print(F("Reader "));
    Serial.print(reader);
    mfrc522[reader].PCD_DumpVersionToSerial();

   //permet de verifier que mes 2 lecteurs sont up-

  // reponse attendue : Firmware Version: 0x92 = v2.0
  }
}

/**
 * Main loop.
 */
void loop()
{

  // boucle de detection des cartes enlevées
  // test tous les max_test=5000ms ou 5 se condes
   
if( millis() - previousMillis >= interval)
 {     
         previousMillis = millis();       
  for (reader = 0; reader < NR_OF_READERS; reader++)
  {
   cmdfromarduino="";
   datafromarduino="";
   mfrc522[reader].PCD_Init();
    // Look for new cards
      //mfrc522[reader].PCD_Init(ssPins[reader], RST_PIN);
    if (mfrc522[reader].PICC_IsNewCardPresent() && mfrc522[reader].PICC_ReadCardSerial())
    {
       //detection d'un nouveau tag
       cpt[reader]++;    
       datafromarduino="?data="+String(reader);
       Serial.print("Dump 1 : datadfromarduino");
       Serial.println(datafromarduino);
       cmdfromarduino=getCode(mfrc522[reader].uid.uidByte, mfrc522[reader].uid.size);
       cmdfromarduino.toUpperCase();
       cmdfromarduino.trim();
       tag=cmdfromarduino;
       cmdfromarduino="Tag="+cmdfromarduino+datafromarduino;

       //sauvegarde du tag pour comparaison avec prochaine lecture
       tag2[reader]=tag;
             
       Serial.print("Dump 2 : command - ");
       Serial.println(cmdfromarduino);
       Serial.print("Dump 4 : tag - ");
       Serial.println(tag);
      // Halt PICC
      mfrc522[reader].PICC_HaltA();
      // Stop encryption on PCD
      mfrc522[reader].PCD_StopCrypto1();
    } //end if    
  } //for(uint8_t reader

         Serial.println("Dump : reader 0 - Mise à jour previousMillis");
         Serial.print("debug cpt0 - ");
         Serial.println(cpt[0]);
         Serial.print("debug oldcpt0 - ");
         Serial.println(oldcpt[0]);
         Serial.print("debug tag2[reader] - ");
         Serial.println(tag2[0]);
         if (oldcpt[0]!=cpt[0] && tag2[0]=="")
         {
                Serial.print("Lecteur ");
                Serial.println(reader); 
                Serial.println(" - carte enlevée");
                oldcpt[0]=0;
                cpt[0]=0;  
          }
          tag[0]=""; tag2[0]="";
         Serial.println("----------------");
         Serial.println("Dump : reader 1 - Mise à jour previousMillis");
         Serial.print("debug cpt1 - ");
         Serial.println(cpt[1]);
         Serial.print("debug oldcpt1 - ");
         Serial.println(oldcpt[1]);
         Serial.print("debug tag2[reader} - ");
         Serial.println(tag2[1]);
         if (oldcpt[1]!=cpt[1] && tag2[1]=="")
         {
                Serial.print("Lecteur ");
                Serial.println(reader); 
                Serial.println(" - carte enlevée");
                oldcpt[1]=0;
                cpt[1]=0;  
          }
          tag[1]=""; tag2[1]="";
        Serial.println("**********************"); 
 } //end if millis
 
}//end loop
 

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

String getCode(byte *buffer, byte bufferSize) {
  String code = "";
  for (byte i = 0; i < bufferSize; i++) code = code + String(buffer[i], HEX);
  return (code);

}

Au cours des tests ci dessus, j'ai souhaité rajouter un module ultrason SR-HC04 afin d'avoir une mesure plus précise de la distance entre le reader et le tag.

Ce module fonctionne en 5v.

Il s'est avéré que l'arduino ne pouvait pas délivrer assez d'intensité pour faire fonctionner les 2 modules en même temps.

Or, la maquette actuelle ne dispose pas d'une solution d'échange de données pour communiquer avec le serveur.

Point dur levé avec le passage sous Arduino MEGA