Par le passé, il est arrivé plusieurs fois qu'on nous demande s'il était possible de construire un système de gestion de clefs basé sur des modules Yoctopuce. On parle bien sûr de clefs pour ouvrir les serrures, pas de cryptographie. On a bien proposé un modeste projet il y a quelques années, mais avec l'arrivée du Yocto-RFID-15693, on peut essayer de voir les choses en plus grand.
On cherche donc à construire une sorte de tableau capable de gérer un ensemble de clefs, c'est-à-dire répertorier les clefs accrochées sur le tableau et indiquer à tout moment quelles sont les clefs manquantes et à quel moment elle ont été empruntées.
On aimerait améliorer un peu le concept
L'idée de base est bien évidemment de munir chaque clef d'un tag RFID et de mettre à profit la capacité du Yocto-RFID-15693 à identifier plusieurs tags RFID en même temps. A priori, le sujet est trivial, et ne mérite pas forcément d'en faire un article, mais la réalisation exige de tenir compte de quelques subtilités.
Où mettre les tags?
On ne peut pas coller les tags directement sur les clefs: le métal de ces dernières les empêchera de fonctionner. On a cherché s'il existe des porte-clefs basés sur des tag ISO 15693, mais on a pas trouvé grand chose. Par contre, rien de nous empêche de coller des étiquettes RFID sur des porte-clefs classiques.
Quelle taille de tags?
La taille des tags a une grosse importance. Rappelez-vous que les tags sont alimentés par l'énergie irradiée par l'antenne, ce qui oblige à trouver un compromis entre la taille de l'antenne et la taille des tags. La puissance d'émission du Yocto-RFID-15693 étant fixe, plus l'antenne est grande, moins l'énergie irradiée est "dense". Plus un tag est grand, plus il peut capturer facilement l'énergie nécessaire à son fonctionnement. Par contre plus un tag est grand, moins on pourra en présenter physiquement en même temps devant l'antenne.
Par exemple, on a essayé avec des petits tags ICODE SLIX 2 de 30x15mm, qui avaient l'avantage de tenir dans ces petits porte-clefs bon marché qu'on trouve partout. Pas de chance, ils ne sont pas détectés par le Yocto-RFID-15693 équipé de la grande antenne qu'on a prévu d'utiliser. Ils n'arrivent probablement pas à capter assez d'énergie pour fonctionner correctement.
Ces tags sont trop petits pour fonctionner avec une grande antenne, dommage
On finalement a jeté notre dévolu sur des tags autocollants ICODE SLIX de 38x25mm qu'on peut facilement coller dans des porte-clefs transparents qu'on a acheté sur une boutique en ligne locale.
Ces tags-là marchent et on a trouvé des porte clefs juste de la bonne taille
Architecture
Au niveau matériel, rien de bien extraordinaire, on a utilisé:
- Un YoctoHub-Ethernet pour pouvoir piloter le tableau à distance et profiter de l'alimentation PoE
- Un Yocto-RFID-15693 pour la gestion des tags RFID
- Une antenne RFID METRATEC de 25x25cm
- Un Yocto-MaxiDisplay pour un feedback local
La partie électronique, notez que le tableau est alimenté par PoE
On a réussi à caser 14 porte-clefs sur de notre tableau ce qui correspondront plus au moins au nombre maximal de tags que le Yocto-RFID-15693 peut alimenter en même temps.
En serrant un peu, on peut gérer 14 porte clefs
Par curiosité, on a vérifié si ça pouvait aussi marcher avec le tableau à l'horizontale et les clefs posées en vrac dessus. Et ça marche... moins bien. Si plusieurs tags se retrouvent superposés, ceux qui sont le plus loin de l'antenne ont du mal à être détectés.
Fonctionnement
Le script Python qui pilote le tableau tourne sur un ordinateur distant et détecte les arrivées et départs de tags. Il se construit automatiquement un inventaire de clefs au fur à mesure qu'une nouvelle clef arrive et lit les descriptions de chaque clef. A chaque changement, la configuration du système est sauvée dans un fichier qui permettra d’arrêter l'application et de la relancer sans perdre la liste complète de clefs. Si le code complet vous intéresse, vous pourrez le trouver ici.
A propos de la description des clefs
La description de chaque clef est stockée dans chaque tag sous la forme d'une chaîne de caractères. En fonction du langage de programmation utilisé, stocker et relire une chaîne de caractères est un peu compliqué, parce que les fonctions rfidreader→tagWriteStr() et rfidreader.tagReadStr() ne font que stocker et relire une séquence de caractère sans gérer implicitement la longueur de la chaîne.
Une solution consiste à terminer la chaîne enregistrée par un caractère spécial, typiquement le caractère zéro, comme illustré dans l'exemple en Python ci-dessous.
if len(str)>=maxlen :
str = str[:maxlen]
else:
str=str+'\x00'
options = YRfidOptions() # default option
return reader.tagWriteStr(rfidUID,block,str,options,status) == YAPI.SUCCESS
def readStringFromRfidTag(reader, rfidUID, block, maxlen,status):
options = YRfidOptions() # default option
str = reader.tagReadStr(rfidUID, block, maxlen, options, status)
if (status.get_errorCode() != YAPI.SUCCESS): return ""
n = str.find('\x00')
if n >= 0: str = str[0:n]
return str
Et ça marche?
Ça marche pas trop mal, les porte-clefs sont détectés sans difficulté, la présence de clefs métalliques ne semble pas être un gros problème même quand elles se retrouvent entre l'antenne et le tag. Par contre, de temps en temps, le système voit une clef disparaître pour réapparaître aussitôt. On a fait une petite vidéo pour vous montrer ça.
Limitations
Évidement, même si ce système constitue une nette amélioration par rapport à un bête rack à clef passif, il y a encore pas mal de limitations.
- Il n'est pas possible de connaître la position d'une clef spécifique le tableau, il faut donc toujours coller des étiquettes lisibles par un humain sur les porte-clefs.
- Lorsque qu'il y a beaucoup de tags sur le tableau, de temps en temps une clef peut brièvement disparaître de l'inventaire, cela est probablement dû à des interférences radio entre tags. Ce petit glitch peut facilement être masqué par programmation.
- Si on sait quand une clef a été empruntée, mais on ne peut pas savoir qui l'a empruntée.
Conclusion
Ce bricolage n'est qu'un simple proof-of-concept, mais il montre qu'il est possible d'utiliser le Yocto-RFID-15693 pour gérer en temps réel un inventaire limité de petits objets. La taille réduite du code de gestion, moins de 200 lignes en tout et pour tout, prouve à quel point l'API Yoctopuce du lecteur Yocto-RFID-15693 est simple et facile à utiliser.
