Quand l’Écomusée m’a proposé de créer un dispositif interactif pour l’exposition à la Villa Perrusson, j’ai immédiatement pensé au NFC. Discret, robuste, simple à utiliser, ce petit lecteur sans contact s’est vite imposé comme une solution idéale pour déclencher des contenus numériques dans un cadre patrimonial.
Mais tant qu’à concevoir un lecteur, autant le rendre un peu plus… expressif ! J’ai donc réalisé un effet visuel avec un anneau de LEDs, animé façon radar tournant, qui capte l’attention… jusqu’au moment où un badge valide déclenche une explosion de couleurs.
Dans cet article, je vous propose de revenir sur les choix matériels (et pourquoi j’ai laissé de côté la bibliothèque Adafruit au profit de FastLED), sur le câblage complet, l’impression 3D du support, le code Arduino commenté pas à pas, et les ajustements réalisés pour obtenir un fonctionnement fluide et fiable.
Que vous soyez prof, maker, fabmanager ou simple curieux, ce projet devrait trouver sa place sur votre établi… ou dans votre valise de démo NFC 😉

Au sommaire :

1 Lecteur NFC DIY avec effet radar LED – Quand FastLED fait danser vos badges 🎯
2 Quelques images
3 Connexions
4 Vidéo
5 Conclusion et pistes de réutilisation
6 🔧 Téléchargements

Lecteur NFC DIY avec effet radar LED – Quand FastLED fait danser vos badges 🎯

Introduction

Tout est parti d’une idée simple proposée par l’Écomusée du Creusot : faire découvrir trois plantes au public à travers une petite animation interactive. L’objectif ? Amener les visiteurs à se poser la question suivante : Que ferait-on de cette plante ?
Faut-il la hacher, l’égrener, ou en faire une infusion ? Pour répondre, le visiteur choisit un objet — une planche à découper, un pilon ou une bouilloire — puis le pose sur une surface dépolie associée à la plante.

L’idée est ludique, pédagogique… mais comment savoir si le choix est bon ? Et comment le signaler de manière claire et attrayante ? Le problème a été soumis au FabLab UtoPi du Creusot et c’est là que la technologie entre en jeu.

J’ai imaginé un Tag NFC embarqué dans chaque objet, et un lecteur de badge capable de reconnaître les objets via les badges NFC intégrés, et de réagir avec un jeu de lumière : vert si le choix est juste, rouge sinon. Pour rendre l’attente plus visuelle et attirer l’attention, un effet radar animé précède la détection. Et si le bon badge est présenté, c’est l’explosion multicolore garantie !

Ce projet a évolué jusqu’à devenir une plateforme réutilisable, compacte, robuste et entièrement personnalisable. Dans cet article, je vous emmène dans les coulisses de sa réalisation : étude des composants, choix techniques (et pourquoi j’ai abandonné Adafruit pour FastLED), support imprimable en 3D, câblage, et bien sûr un code commenté et prêt à l’emploi.

Étude et choix des composants

Avant de plonger dans le code ou de chauffer la buse de l’imprimante 3D, il fallait poser les bases : quels composants utiliser pour que le système soit réactif, simple à intégrer et fiable dans le temps ? Les liens Aliexpress sont affiliés si le matériel est éligible.

🧠 Pourquoi un Arduino Nano ?

Si le développement a été fait sur un Arduino Uno, la version finale tourne parfaitement sur un Arduino Nano. Ce choix s’explique par plusieurs raisons pratiques :

le Nano est plus compact, ce qui facilite son intégration dans un support imprimé en 3D ou une installation discrète ;
il conserve la même compatibilité logicielle et matérielle (même broches SPI, même bibliothèque NFC, même code) ;
son connecteur USB-C est souvent plus facile à intégrer que la grosse prise USB-B du Uno ;
et bien sûr, il est très abordable, ce qui permet de dupliquer facilement le projet pour plusieurs postes interactifs.

🟢 Le lecteur NFC : PN532 version Elechouse

Le module PN532 s’est vite imposé. C’est un classique bien connu des makers, compatible avec différents protocoles (I2C, UART, SPI), et surtout avec la bibliothèque Adafruit_PN532. J’ai choisi ici le mode SPI pour éviter les conflits sur les broches I2C et profiter d’une communication rapide. Le module Elechouse v3 permet de régler le mode via des micro-switches — pratique.

🏷️ Quels tags NFC utiliser ?

Ces Tags mesurent 25,2 mm de diamètre pour 1mm d’épaisseur

Pour ce projet, j’ai utilisé des badges NFC au format MIFARE Classic 1K (ISO14443A). Ils sont largement compatibles avec le module PN532 et reconnus facilement par la bibliothèque Adafruit.
Chaque badge possède un identifiant unique (UID), que le programme compare à une liste prédéfinie. Cela permet d’attribuer un comportement différent selon l’objet posé (bouilloire, pilon, planche à découper…).

Les tags peuvent prendre plusieurs formes :

- cartes format carte bancaire,
- porte-clés/badges ronds,
- ou même stickers à coller sous les accessoires .

🛠️ Pour une détection fiable, il est recommandé de :

- ne pas placer d’objet métallique entre le tag et le lecteur,
- éviter les interférences (autres lecteurs ou sources électromagnétiques proches),
- tester chaque tag une fois fixé à son support.

🌈 L’anneau LED WS2812 : 24 LEDs pour un bel effet radar

Côté éclairage, j’ai utilisé un anneau de 24 LEDs WS2812, parfois appelé NeoPixel. Ces LEDs RGB adressables permettent de créer un effet visuel attractif autour du lecteur : un radar qui tourne lentement, avant de réagir à la détection d’un badge. Le nombre de LEDs permet une animation fluide et bien visible, même en environnement lumineux.

⚡ FastLED vs NeoPixel : un choix de fluidité
Au début, j’ai naturellement utilisé la librairie Adafruit_NeoPixel, fournie en exemple dans bien des tutoriels. Mais très vite, j’ai constaté que les animations LED devenaient saccadées, et que la bibliothèque bloquait parfois la boucle principale. Pour un projet où fluidité et réactivité sont essentielles, ce n’était pas acceptable.

J’ai donc migré vers FastLED, bien plus souple et performante. Elle permet de gérer les LEDs sans ralentir le reste du programme, ce qui a été décisif pour faire tourner le “radar” en continu tout en surveillant les badges NFC.

💡 Le MOSFET : pour illuminer la bonne réponse

Le système ne s’arrête pas à une animation colorée. Lorsqu’un badge correct est présenté, un ruban de LEDs blanches s’allume brièvement pour mettre en valeur la bonne réponse (plante/objet). Pour piloter ce ruban, j’ai ajouté un MOSFET canal N commandé par une broche de l’Arduino. Il permet d’activer ou d’éteindre le ruban de manière franche et fiable, sans tirer trop de courant directement depuis la carte.

🔌 Pourquoi une alimentation à découpage 5V / 12V – 50W ?

Pour ce type de montage, j’ai préféré utiliser une alimentation à découpage (switching) de 50 watts, délivrant à la fois du 5V pour les LEDs WS2812 et du 12V pour d’éventuels modules complémentaires ou futures extensions.
Ce type d’alim présente plusieurs avantages :

rendement élevé, donc peu de chauffe même en fonctionnement continu,
capacité suffisante pour alimenter à la fois l’anneau LED, le ruban blanc via MOSFET, et l’Arduino,
compacité et fixation facile dans un coffret ou sous une table d’exposition,
et surtout une tension stable, indispensable pour éviter les comportements erratiques des WS2812 en cas de chute de tension.

C’est une solution robuste, bien adaptée aux environnements de démonstration ou d’exposition longue durée.

Schéma de câblage

Dans ce projet, le câblage est soigneusement organisé pour assurer une communication fiable entre les différents modules tout en facilitant le dépannage et l’évolution du montage. Voici un aperçu des connexions principales, telles que représentées dans le schéma Fritzing .

Ce sont les bornes Vin et GND du module MOSFET qui me servent d’arrivée d’alimentation 5v et c ‘est à partir de là que je redistribue le 5v en étoile comme il se doit. Cela réduit ou élimine les problèmes de masses, de boucles…

Module PN532 en mode SPI

Alimentation et Masse :
Le module PN532 est alimenté en 5V et relié à la masse commune, garantissant ainsi une alimentation stable pour toute la chaîne.
Connexion SPI : Les lignes de communication SPI sont connectées aux broches standards de l’Arduino :

SCK (horloge) sur la broche D13
MISO (données vers l’Arduino) sur la broche D12
MOSI (données depuis l’Arduino) sur la broche D11
SS (chip select) sur la broche D10

Ces connexions assurent une communication rapide et sans interférences, critique pour la détection NFC.

Anneau LED WS2812 (24 LEDs)

Alimentation et Masse :
L’anneau de 24 LEDs est alimenté en 5V. Pour des performances optimales, une alimentation externe est recommandée, surtout si l’anneau est utilisé en environnement lumineux.
Signal de données :
La ligne de données, pilotée via la librairie FastLED, est reliée à la broche D6 de l’Arduino, permettant ainsi la création de l’effet radar animé qui capte l’attention dès le démarrage.
Ruban de LEDs blanches piloté par MOSFET
Fonction dédiée :
Le ruban de LEDs blanches est utilisé pour illuminer la bonne réponse lorsque le badge correct est détecté.

Pilotage par MOSFET

Un MOSFET canal N (par exemple de type IRF520) est intégré pour commuter l’alimentation du ruban. La commande se fait via une broche dédiée de l’Arduino (broche D4), permettant d’activer ou de désactiver le ruban en fonction du résultat de la détection.
Alimentation et mise en commun :
Comme pour les autres modules, le ruban se branche sur une alimentation en 5V dédiée, avec la masse commune assurant la stabilité du montage.

Ce schéma de câblage clair permet d’isoler aisément chaque fonction : la détection NFC via le module PN532, l’animation visuelle de l’anneau LED pour l’effet radar, et enfin le signal lumineux du ruban blanc piloté par le MOSFET pour confirmer la bonne réponse. Il offre également la flexibilité nécessaire pour tester ou modifier chaque section de façon indépendante.

Support imprimé en 3D

Pour intégrer proprement le lecteur NFC et son anneau LED dans le dispositif de l’exposition, j’ai conçu un support imprimé en 3D compact, robuste et simple à monter. L’objectif : rendre le système facilement posable sur un meuble, tout en protégeant les composants et en assurant une bonne diffusion de la lumière.

🧱 Conception

Le support a été modélisé sous [préciser le logiciel utilisé, ex. FreeCAD, Fusion 360, Tinkercad]. Il est constitué de plusieurs éléments imbriqués :

une base qui accueille l’Arduino, le PN532 et le câblage,
un socle circulaire pour fixer l’anneau de 24 LEDs,
un capot ou une plaque diffuseur pour masquer les composants et guider visuellement l’utilisateur.
Le tout est pensé pour être imprimé sans support (ou avec très peu), en PLA classique.

🪛 Assemblage

L’assemblage se fait en quelques étapes :

On fixe l’Arduino et le PN532 dans leur logement avec des vis et une traverse pour l arduino.
L’anneau de LEDs se colle a la néoprène dans son emplacement circulaire.
Le ruban de LEDs blanches peut être collé sous la plaque translucide si l’on souhaite qu’il illumine directement la surface où est posée la plante ou l’objet.
Le passage des câbles est prévu pour rester discret. Une ouverture sous la base permet de faire sortir les fils vers l’alimentation 5V externe, tout en conservant une apparence soignée.

🧾 Fichiers disponibles

Tous les fichiers .3mf sont disponibles (voir en fin d’article). Ils peuvent bien sûr être modifiés selon vos contraintes d’intégration (épaisseur du support, orientation, diffusion, etc.).

Le programme Arduino en détail

Le cœur du projet repose sur un code Arduino soigneusement structuré pour assurer à la fois fluidité de l’animation, réactivité à la détection NFC et clarté du fonctionnement. Le sketch est commenté ligne à ligne pour être facilement modifiable, même par un utilisateur non expert.

📌 Organisation générale

Le programme commence par une section de paramètres réglables (nombre de LEDs, broches, durées…), suivie de l’initialisation des bibliothèques et de la configuration du matériel. La boucle principale (loop()) est divisée clairement en trois temps :

affichage radar tournant
détection d’un badge NFC
affichage de la réaction (animation + LEDs blanches si bonne réponse)

Aucune instruction bloquante de type delay() longue n’est utilisée dans la boucle normale, ce qui assure une exécution continue et réactive.

🌈 Animation LED avec FastLED

L’anneau de 24 LEDs WS2812 est connecté à la broche 6. Le choix de la bibliothèque FastLED permet de piloter l’animation en mode non bloquant, ce qui est indispensable ici. L’effet de radar est généré par une traînée lumineuse tournante, simulée par un fondu de gris dégressif.

En cas de badge valide, une explosion multicolore s’affiche brièvement, suivie d’un vert fixe. Si le badge est incorrect, l’anneau passe au rouge. Pour un badge de test (optionnel), un affichage en trois tiers RGB est également prévu.

🧠 Lecture NFC rapide et non bloquante

Le module PN532 est utilisé en mode SPI (chip select sur la broche 10), avec la bibliothèque Adafruit_PN532. L’appel à readPassiveTargetID() est fait avec un timeout court (20 ms), ce qui permet de vérifier la présence d’un badge sans bloquer la boucle principale :

bool success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength, 20);

Cette technique garantit que l’effet radar reste fluide, même en attente de badge — un point essentiel qui a permis de corriger les ralentissements rencontrés dans les versions antérieures (voir cet article pour les détails). (voir cet article pour les détails)

💡 Activation du ruban LED blanc avec MOSFET (broche 4)

Le ruban de LEDs blanches, utilisé pour illuminer la zone de la bonne réponse, est commandé par un MOSFET canal N, dont la gate est reliée à la broche 4 de l’Arduino. Lorsqu’un badge correct est détecté :

LED colorées affichées, puis affichage en vert
la broche 4 passe à HIGH, ce qui active le ruban blanc pour une durée réglable (DUREE_MOSFET, ici 5 secondes),
puis le ruban est éteint par un retour à LOW.

Extrait du code :

digitalWrite(BROCHE_MOSFET, HIGH); // Active le ruban blanc

digitalWrite(BROCHE_MOSFET, LOW); // Extinction après temporisation

Ce système est simple, efficace, et séparable du reste de la logique LED, ce qui permet de faire évoluer l’éclairage indépendamment.

#include 
#include 
#include 

// === Paramètres ===
#define NOMBRE_LEDS         24
#define BROCHE_DATA         6
#define LONGUEUR_TRAINEE    4
#define LUMIERE_MAX         200
#define LUMIERE_MIN         30
#define DELAI_ESCARGOT      300      // radar lent = temps pour NFC
#define NFC_SS_PIN          10
#define DUREE_EXPLOSION     1500
#define DUREE_AFFICHAGE     5000
#define BROCHE_MOSFET       4
#define DUREE_MOSFET        5000     // Durée d’activation du MOSFET (en ms)

CRGB leds[NOMBRE_LEDS];
Adafruit_PN532 nfc(NFC_SS_PIN);

// === UID badges ===
uint8_t uid_valide[] = {0x04, 0x57, 0xFD, 0x8D, 0x74, 0x00, 0x00};
uint8_t uid_test[]   = {0xB5, 0x4F, 0x44, 0x05};

// === Radar ===
int position_actuelle = 0;
unsigned long dernier_tick = 0;

// === Badge / affichage
bool badgeActif = false;
bool explosionFaite = false;
int typeBadge = 0; // 0 = aucun, 1 = test, 2 = valide, 3 = autre
unsigned long tBadge = 0;

void radarLED() {
  FastLED.clear();
  for (int i = 0; i &lt; LONGUEUR_TRAINEE; i++) {
    int pos = (position_actuelle - i + NOMBRE_LEDS) % NOMBRE_LEDS;
    int intensite = map(i, 0, LONGUEUR_TRAINEE - 1, LUMIERE_MAX, LUMIERE_MIN);
    leds[pos] = CRGB(intensite, intensite, intensite);
  }
  FastLED.show();
  position_actuelle = (position_actuelle + 1) % NOMBRE_LEDS;
}

void allumerCouleur(CRGB couleur) {
  fill_solid(leds, NOMBRE_LEDS, couleur);
  FastLED.show();
}

void explosionCouleurs() {
  for (int i = 0; i &lt; NOMBRE_LEDS; i++) {
    leds[i] = CHSV(random(0, 255), 255, 255);
  }
  FastLED.show();
}

void effetTestRVBTiers() {
  int tier = NOMBRE_LEDS / 3;
  for (int i = 0; i &lt; NOMBRE_LEDS; i++) {
    if (i &lt; tier) leds[i] = CRGB::Red;
    else if (i &lt; 2 * tier) leds[i] = CRGB::Green;
    else leds[i] = CRGB::Blue;
  }
  FastLED.show();
}

bool comparerUID(uint8_t *a, uint8_t *b, uint8_t taille) {
  for (uint8_t i = 0; i &lt; taille; i++) {
    if (a[i] != b[i]) return false;
  }
  return true;
}

void traiterBadge(uint8_t *uid, uint8_t uidLength) {
  if (uidLength == sizeof(uid_valide) &amp;&amp; comparerUID(uid, uid_valide, uidLength)) {
    typeBadge = 2;
    explosionFaite = false;
    explosionCouleurs();
    tBadge = millis();
    badgeActif = true;
    digitalWrite(BROCHE_MOSFET, HIGH); // Activer MOSFET
  }
  else if (uidLength == sizeof(uid_test) &amp;&amp; comparerUID(uid, uid_test, uidLength)) {
    typeBadge = 1;
    effetTestRVBTiers();
    tBadge = millis();
    badgeActif = true;
  }
  else {
    typeBadge = 3;
    allumerCouleur(CRGB::Red);
    tBadge = millis();
    badgeActif = true;
  }
}

void setup() {
  FastLED.addLeds&lt;NEOPIXEL, BROCHE_DATA&gt;(leds, NOMBRE_LEDS);
  FastLED.clear(); FastLED.show();

  pinMode(BROCHE_MOSFET, OUTPUT);
  digitalWrite(BROCHE_MOSFET, LOW); // Désactivé au démarrage

  nfc.begin();
  nfc.setPassiveActivationRetries(0x01); // lecture rapide
  nfc.SAMConfig();
}

void loop() {
  unsigned long maintenant = millis();

  // === Affichage badge actif
  if (badgeActif) {
    if (typeBadge == 2 &amp;&amp; !explosionFaite &amp;&amp; maintenant - tBadge &gt; DUREE_EXPLOSION) {
      allumerCouleur(CRGB::Green);
      explosionFaite = true;
      tBadge = maintenant;
    }

    if ((typeBadge != 2 &amp;&amp; maintenant - tBadge &gt; DUREE_AFFICHAGE) ||
        (typeBadge == 2 &amp;&amp; explosionFaite &amp;&amp; maintenant - tBadge &gt; DUREE_MOSFET)) {
      badgeActif = false;
      typeBadge = 0;
      FastLED.clear(); FastLED.show();
      digitalWrite(BROCHE_MOSFET, LOW); // Désactiver MOSFET
    }
    return; // on n'affiche pas le radar pendant l'effet
  }

  // === Radar escargot
  if (maintenant - dernier_tick &gt;= DELAI_ESCARGOT) {
    dernier_tick = maintenant;
    radarLED();
  }

  // === NFC non bloquant (timeout court)
  uint8_t uid[7];
  uint8_t uidLength;
  bool success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &amp;uidLength, 20); // 20 ms timeout

  if (success) {
    traiterBadge(uid, uidLength);
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

#include

// === Paramètres ===

#define NOMBRE_LEDS 24

#define BROCHE_DATA 6

#define LONGUEUR_TRAINEE 4

#define LUMIERE_MAX 200

#define LUMIERE_MIN 30

#define DELAI_ESCARGOT 300 // radar lent = temps pour NFC

#define NFC_SS_PIN 10

#define DUREE_EXPLOSION 1500

#define DUREE_AFFICHAGE 5000

#define BROCHE_MOSFET 4

#define DUREE_MOSFET 5000 // Durée d’activation du MOSFET (en ms)

CRGB leds[NOMBRE_LEDS];

Adafruit_PN532 nfc(NFC_SS_PIN);

// === UID badges ===

uint8_t uid_valide[] = {0x04, 0x57, 0xFD, 0x8D, 0x74, 0x00, 0x00};

uint8_t uid_test[] = {0xB5, 0x4F, 0x44, 0x05};

// === Radar ===

int position_actuelle = 0;

unsigned long dernier_tick = 0;

// === Badge / affichage

bool badgeActif = false;

bool explosionFaite = false;

int typeBadge = 0; // 0 = aucun, 1 = test, 2 = valide, 3 = autre

unsigned long tBadge = 0;

void radarLED() {

FastLED.clear();

for (int i = 0; i < LONGUEUR_TRAINEE; i++) {

int pos = (position_actuelle - i + NOMBRE_LEDS) % NOMBRE_LEDS;

int intensite = map(i, 0, LONGUEUR_TRAINEE - 1, LUMIERE_MAX, LUMIERE_MIN);

leds[pos] = CRGB(intensite, intensite, intensite);

}

FastLED.show();

position_actuelle = (position_actuelle + 1) % NOMBRE_LEDS;

}

void allumerCouleur(CRGB couleur) {

fill_solid(leds, NOMBRE_LEDS, couleur);

FastLED.show();

}

void explosionCouleurs() {

for (int i = 0; i < NOMBRE_LEDS; i++) {

leds[i] = CHSV(random(0, 255), 255, 255);

}

FastLED.show();

}

void effetTestRVBTiers() {

int tier = NOMBRE_LEDS / 3;

for (int i = 0; i < NOMBRE_LEDS; i++) {

if (i < tier) leds[i] = CRGB::Red;

else if (i < 2 * tier) leds[i] = CRGB::Green;

else leds[i] = CRGB::Blue;

}

FastLED.show();

}

bool comparerUID(uint8_t *a, uint8_t *b, uint8_t taille) {

for (uint8_t i = 0; i < taille; i++) {

if (a[i] != b[i]) return false;

}

return true;

}

void traiterBadge(uint8_t *uid, uint8_t uidLength) {

if (uidLength == sizeof(uid_valide) && comparerUID(uid, uid_valide, uidLength)) {

typeBadge = 2;

explosionFaite = false;

explosionCouleurs();

tBadge = millis();

badgeActif = true;

digitalWrite(BROCHE_MOSFET, HIGH); // Activer MOSFET

}

else if (uidLength == sizeof(uid_test) && comparerUID(uid, uid_test, uidLength)) {

typeBadge = 1;

effetTestRVBTiers();

tBadge = millis();

badgeActif = true;

}

else {

typeBadge = 3;

allumerCouleur(CRGB::Red);

tBadge = millis();

badgeActif = true;

}

void setup() {

FastLED.addLeds<NEOPIXEL, BROCHE_DATA>(leds, NOMBRE_LEDS);

FastLED.clear(); FastLED.show();

pinMode(BROCHE_MOSFET, OUTPUT);

digitalWrite(BROCHE_MOSFET, LOW); // Désactivé au démarrage

nfc.begin();

nfc.setPassiveActivationRetries(0x01); // lecture rapide

nfc.SAMConfig();

}

void loop() {

unsigned long maintenant = millis();

// === Affichage badge actif

if (badgeActif) {

if (typeBadge == 2 && !explosionFaite && maintenant - tBadge > DUREE_EXPLOSION) {

allumerCouleur(CRGB::Green);

explosionFaite = true;

tBadge = maintenant;

}

if ((typeBadge != 2 && maintenant - tBadge > DUREE_AFFICHAGE) ||

(typeBadge == 2 && explosionFaite && maintenant - tBadge > DUREE_MOSFET)) {

badgeActif = false;

typeBadge = 0;

FastLED.clear(); FastLED.show();

digitalWrite(BROCHE_MOSFET, LOW); // Désactiver MOSFET

}

return; // on n'affiche pas le radar pendant l'effet

}

// === Radar escargot

if (maintenant - dernier_tick >= DELAI_ESCARGOT) {

dernier_tick = maintenant;

radarLED();

}

// === NFC non bloquant (timeout court)

uint8_t uid[7];

uint8_t uidLength;

bool success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &uidLength, 20); // 20 ms timeout

if (success) {

traiterBadge(uid, uidLength);

}

Tests et ajustements

Comme souvent, entre l’idée sur le papier et le comportement réel du montage… il y a eu quelques surprises. Cette section revient brièvement sur les essais réalisés, les problèmes rencontrés, et les solutions mises en place pour aboutir à un fonctionnement fluide.

⚙️ Premiers tests : quand tout ne se passe pas comme prévu…

Le premier prototype fonctionnait, mais avec un défaut majeur : l’appel à readPassiveTargetID() bloquait la boucle loop(), empêchant l’effet radar LED de tourner tant qu’aucun badge n’était détecté. Résultat : un radar qui se fige… et un visiteur qui croit que ça ne marche pas.

Il a fallu investiguer, tester différents délais, et finalement adopter un timeout court (20 ms) sur la lecture NFC pour retrouver une boucle fluide. Autre enseignement : il faut éviter les delay() prolongés dans la logique principale, sous peine de geler tout le système.

🐌 Les effets “escargot” et le mode SPI

Ces ajustements ont été l’objet d’un petit feuilleton technique que j’ai raconté ici :
👉 Quand le radar LED ne veut pas tourner – NFC, delays et escargots de Bourgogne

Ce retour d’expérience détaille les problèmes de timing, les limites de certaines bibliothèques, et les essais pas toujours concluants avant d’arriver à la version stable présentée ici.

✅ Résultat final

Au final, le système fonctionne de façon fluide :
radar LED tournant en continu,
détection NFC rapide, même en boucle,
effet visuel déclenché immédiatement après présentation du badge,
ruban blanc activé uniquement pour les bonnes réponses.

Le tout tient sur un Arduino Uno (ou Nano), est reproductible, et peut être intégré dans d’autres projets de médiation ou de démonstration.

Quelques images

Badge TAG NFC style porte clé, utilisé souvent pour ouvrir les portes sur les digicodes. Mauvais identifiant => lumière rouge
Badge TAG NFC style carte bancaire, utilisé souvent pour ouvrir les portes dans les hôtels, les salles informatiques… C’est mon badge de test, il fonctionne sur tous les lecteurs de cette série, en plus de leur badge dédié. Permet un test rapide le matin par exemple au démarrage du système. => lumière RVB
Le tag correspondant à ce lecteur est collé sous la bouilloire => lumière verteLe lecteur et la bouilloire
Le Tag NFC est collé sous la bouilloire imprimée en 3D
Les LEDs qui éclaireront la bonne réponseLes LEDs blanches sont commandées par un module MOSFET
Les badges pour les prochains lecteurs

Connexions

Composant	Broche Module PN532 / LEDs / MOSFET	Broche Arduino (UNO ou équivalent)	Remarques
PN532 (SPI)	VCC	5V	Alim 5V stable
	GND	GND	Masse commune obligatoire
	SCK	D13	SPI Clock
	MISO	D12	SPI Data vers Arduino
	MOSI	D11	SPI Data depuis Arduino
	SS / SSEL	D10	Chip Select
	Mode (switch)	—	SPI : OFF-ON
LEDs WS2812	Data IN	D6	Défini par `#define PIN_LED 6`
	VCC	5V externe	Ne pas alimenter depuis Arduino si > 8 LEDs
	GND	GND commun	Masse partagée avec Arduino et MOSFET
MOSFET	Gate (G)	D4	Défini par `#define PIN_MOSFET 4`
	Drain (D)	GND LEDs	Couper le – des LEDs
	Source (S)	GND commun	Relié à GND Arduino et alim
	V+ (si module type IRF520)	5V alim LED	Entrée positive vers LEDs

Vidéo

Conclusion et pistes de réutilisation

Ce petit lecteur NFC à effet radar n’est pas qu’un simple gadget lumineux : c’est une interface interactive robuste, adaptable et pédagogique, pensée pour les musées, les expos, les stands… ou tout simplement pour expérimenter chez soi.

Le fait d’associer un badge NFC à une réponse visuelle immédiate — colorée, claire, et renforcée par une lumière physique — en fait un excellent outil de médiation. Il peut aussi servir dans des projets éducatifs : quiz interactif, borne de sélection, système de vote discret, ou contrôle d’accès ludique.

Le code est open source, commenté, et pensé pour être modifié facilement. L’ensemble fonctionne sur un Arduino Uno ou équivalent, avec des composants simples à trouver : un PN532, un anneau de LEDs WS2812, un ruban blanc et un MOSFET.

Une vidéo de démonstration est vivible un peu plus haut et montre le système en action 🎥
À vous de jouer maintenant ! Si vous réalisez une version de ce montage ou si vous l’adaptez à votre sauce, n’hésitez pas à me le faire savoir — je me ferai un plaisir de partager vos créations sur le blog.

Framboise 314, le Raspberry Pi à la sauce française….

La référence du Raspberry Pi en France – Par l'auteur du livre "Raspberry Pi 4" paru aux Edts. ENI

Lecteur NFC DIY avec effet radar LED – Quand FastLED fait danser vos badges

Lecteur NFC DIY avec effet radar LED – Quand FastLED fait danser vos badges 🎯

Introduction

Étude et choix des composants

🧠 Pourquoi un Arduino Nano ?

🏷️ Quels tags NFC utiliser ?

🔌 Pourquoi une alimentation à découpage 5V / 12V – 50W ?

Schéma de câblage

Module PN532 en mode SPI

Anneau LED WS2812 (24 LEDs)

Pilotage par MOSFET

Support imprimé en 3D

🧱 Conception

🪛 Assemblage

🧾 Fichiers disponibles

Le programme Arduino en détail

📌 Organisation générale

🌈 Animation LED avec FastLED

🧠 Lecture NFC rapide et non bloquante

💡 Activation du ruban LED blanc avec MOSFET (broche 4)

Tests et ajustements

⚙️ Premiers tests : quand tout ne se passe pas comme prévu…

🐌 Les effets “escargot” et le mode SPI

Quelques images

Connexions

Vidéo

Conclusion et pistes de réutilisation

🔧 Téléchargements

À propos François MOCQ

Laisser un commentaire Annuler la réponse