Pilote PN532 : lecture de cartes/tags MiFare / ISO14443A avec MicroPython

Bonjour Amis Maker et MicroPythoniciens,

Peut-être connaissez-vous l'excellent breakout PN532 proposé par Adafruit.
Que nous pouvons aujourd'hui utiliser sous MicroPython avec le pilote pn532-rfid.

breakout PN532

Ce dernier permet de lire tags et cartes MiFare / ISO14443A largement répandu sur le marché.

Exemple de tag ISO144443A (MiFare Classic)

Des Tags très largement utilisés dans le monde de la gestion d'accès et dans tous les projets nécessitant une identification.

Les tags dit "MiFare Classic" dispose également d'une mémoire de 1 à 4Kio (selon les modèles) permettant d'y stocker des informations de façon sécurisée (en utilisant des clés d'authentification).

Brancher un PN532 sur un Pico

La première étape est de brancher le capteur PN532 sur un Raspberry-Pi Pico.

Par chance, ce capteur peu aussi fonctionner sous 3.3V (logique et alimentation).

Le PN532 est capable de communiquer par l'intermédiaire d'une interface UART, I2C ou SPI. C'est l'interface UART (aussi dite série) qui est ici utilisée.

Une bibliothèque MicroPython

Après avoir installée la bibliothèque disponible sur le dépôt GitHub esp8266-upy/pn532-rfid , il sera possible d'utiliser les différents exemples a disposition.

l'utilitaire mip peut être utilisé pour réaliser cette tâche facilement.

Si vous disposez d'une plateforme MicroPython avec accès WiFi

>>> import mip
>>> mip.install("github:mchobby/esp8266-upy/pn532-rfid")

Sinon, mpremote mip install permettra de le réaliser via l'ordinateur surlequel est connecté la plateforme MicroPython,

mpremote mip install github:mchobby/esp8266-upy/pn532-rfid

Du code pour le peuple!

Alors le premier exemple est relativement simple (read_mifare.py), il permet de lire l'UID de la carte et d'afficher le contenu du premier bloc utilisateur (qui commence au numéro #4).

Vous trouverez-ci dessous le script restreint à la lecture de l'identifiant de la carte (dit "UID")

from pn_const import *
from hal_uart import PN_UART
from pn532 import PN532
from binascii import hexlify
import time

# Using PN532 over UART, timeout=1000 ms
uart_hal = PN_UART( 1, 1000 ) 
nfc = PN532( uart_hal )
nfc.begin()
print( nfc.firmware_version )
if( nfc.sam_config() ):
	print( "SAM configured")
else:
	print( "SAM configuration failure!")

print("Waiting for an ISO14443A/MiFare Card ...");
while True:
	uid = nfc.read_passive_targetID( PN532_MIFARE_ISO14443A )

	if uid == 0x00:
		print("Communication Error!")
		continue
	elif uid != None:
		print("Found an ISO14443A card")
		print("  UID Length: %i bytes" % len(uid) )
		print("  UID Value: %s" % hexlify(uid).upper() )
		_l = hexlify( uid ).decode('ASCII').upper()
		# Insérer un espace tous les deux digits Hexa
		_l = ' '.join(_l[i:i+2] for i in range(0, len(_l), 2)) 
		print("  UID      : %s" % _l )
	else:
		continue

	time.sleep(1)

Voici quelques détails concernant le fonctionnement:

Pour commencer, l'appel de nfc.sam_config() configure le module de sécurité du lecteur (SAM signifie Security Access Module).
Il est impératif que cette opération se déroule sans erreur pour être capable de lire des tags/cartes.
La méthode read_passive_targetID() effectue une tentative de lecture de carte ISO14443A. Cette méthode retourne
- None (échec communication),
- 0x00 (pas de tag, timeout) ou
- un bytearray avec l'UID de la carte.
L'UID d'une carte MiFareClassic fait 4 octets.
L'UID d'une carte MiFareUltralight fait 7 octets.
La fonction hexlify() permet de transformer un contenu binaire en représentation hexadécimale plus facile à lire.
La ligne avec le join() permet d'insérer des espaces dans la représentation pour qu'elle soit plus facile à lire.

L'exécution du script ce qui produit le résultat suivant:

{'FIRMWARE': '1.6', 'CHIPSET': 'pn532'}
SAM configured
Waiting for an ISO14443A/MiFare Card ...
Communication Error!
Communication Error!
Communication Error!
Found an ISO14443A card
  UID Length: 4 bytes
  UID Value: b'6A493F0E'
  UID      : 6A 49 3F 0E
...

D'autres exemples

Le code du dépôt contient des exemples plus complets:

read_mifare.py : lecture d'une carte MiFare et accès au bloc #4
write_mifare.py : modification du bloc #4 d'une carte MiFare
dumpmem_mifare.py : dump des 64 blocks memoire (16 octets chacun) d'une carte MiFare.

Ces exemples partent du principe que les clés d'authentification KEYA et KEYB par défaut ne sont pas encore modifiées.