Présentation générale : RFID/NFC

Étudiants : Xinwei Hu et Jean de Dieu NDUWAMUNGU

Encadrants : Thomas DANEL et Vincent COELEN

Description

Le Robotino est un système robotique opérationnel de grande qualité à entraînement omnidirectionnel. Il peut se déplacer dans plusieurs directions. Il est muni d’une webcam et de plusieurs capteurs afin d’assurer son déplacement et différentes opérations qu’on adviendrait à effectuer. Il peut être utilisé directement sans PC.

Pour effectuer sa commande le Robotino dispose d’un ordinateur de bord sur lequel se trouve une carte Compact Flash qui contient plusieurs applications de démonstration ainsi qu’un système d’exploitation. Les démonstrations peuvent être directement lancées à l’aide du clavier de commande du Robotino.

Traditionnellement sa programmation est faite soit depuis un PC à l’aide du logiciel Robotino View via un réseau local sans fil ou en le branchant directement par une connexion filaire.

Dans ce projet nous allons développer une méthode nous permettant de le configurer automatiquement sans devoir passer par un réseau quelconque à l’aide de puces RFID/NFC et aussi en exploitant la technologie NFC disponible sur nos téléphones Android.

Objectifs

Aspect RoboCup

Le but de ce projet est d'avoir des puces RFID/NFC intégrés au niveau des têtes des Robotino ou sur la coque et de pouvoir avoir plusieurs applications possibles. Une des application possibles serait d’avoir des cartes qu’on pourrait aimanter afin de choisir la configuration du robot pour différents aspects. Dans la coupe de robotique, RoboCup, les robots sont de deux couleurs différentes : cyan ou magenta. Au début de la compétition cette configuration est faite manuellement. Le travail que nous allons faire sera de le réaliser automatiquement cette tâche à l’aide de puces RFID/ NFC en leurs affectant un numéro, une couleur. Automatiser la tâche nous permettra de gagner donc du temps et d’éviter les erreurs liées à la configuration des Robotino surtout quand on dispose plusieurs de ces derniers.

Aspect AIP

L'école Polytech Lille reçoit le long de l'année des visites sur le campus lors des journées portes ouvertes ou des événements comme la CREP. Sur les différents robots se trouvent des vidéos de démonstration. L'objectif côté AIP sera de développer une technique permettant de lancer automatiquement une démonstration à l'aide d'un tag préprogrammé qu'on viendrai déposer sur le robot.

Application Smartphone

La technologie NFC s'est étendue sur plusieurs modèles de smartphone. Un autre objectif de ce projet sera d'exploiter cette possibilité en effectuant une configuration automatique des Robotino lorsqu'on approche un smartphone sur ces derniers. Dans notre cas il s'agira dans un premier temps de connecter automatiquement le robot sur le même réseau wifi que le smartphone que l'on approche du Robotino et dans un second temps de piloter le robot ou de visualiser les images vidéos à l'aide du joystick virtuel sur une application Android que nous allons développer.

Analyse du projet

Positionnement par rapport à l'existant

Dans ce projet nous allons travailler sur des Robotino qu'on retrouve à Polytech. Notre solution sera nouvelle dans la mesure où elle va permettre un gain considérable en temps et en nombre de tâches à effectuer lors de la configuration des robots, en automatisant les tâches. Les Robotino disposent des supports NFC le but est d'exploiter cette possibilité en apportant une solution nouvelle.

Analyse du premier concurrent

Wakdev est une société de développement informatique spécialisée dans la conception et la réalisation de solutions Web & Mobile. Il a développé l'application qui s'appelle NFC Tools pour configurer des tags NFC sur la plateforme Android, IOS, PC/MAC. NFC Tools est une application qui permet de lire, écrire ou programmer des tâches sur les tags NFC et autres puces RFID compatibles. NFC Tools peut enregistrer sur les tags NFC des informations standard qui seront compatibles avec l'ensemble des appareils NFC. Il propose aussi de programmer des tâches sur les tags NFC afin d'automatiser des actions qui étaient autrefois répétitives.

Website de cette société : [1]

Analyse du second concurrent

Robotino View est le logiciel d'édition officiel de Robotino avec des fonctionnalités extrêmement puissantes. Il peut réaliser la programmation et la simulation de Robotino.

Scénario d'usage du produit ou du concept envisagé

4 Juillet 2019, RoboCup 2019

L'équipe de recherche de Polytech'Lille participe à la RoboCup 2019. Elle veut améliorer ses performances en instaurant une technique de configuration automatique des Robotino sans avoir à le faire manuellement pour chaque robot en lui assignant à l'aide d'un tag NFC un numéro ainsi qu'une configuration adéquate. Des Tags Cyan et Magenta pour chaque ont été fabriqués. On a juste à coller le tag sur la tête du Robotino pour le configurer en Cyan ou Magenta.

2 Mai 2019, Journée CREP Polytech Lille

Jean et Xinwei, étudiant en IMA4 et passionné par la robotique, sont chargés de la présentation des Robotino aux élèves venus découvrir ce qui peut être leurs domaines d'études dans quelques années. Afin de rendre interactif la présentation des Robotino Jean et Xinwei ont décidé de développer une application sur leurs téléphones Android qui agit en tant que joystick permettant ainsi une commande à distance du Robotino, ou une vue de ce que la caméra sur le robot filme. Ils pourront saisir une photo qu'ils vont partager avec les élèves visiteurs.

Réponse à la question difficile

Existe-t-il un lecteur intégré NFC au robotino ? Si oui quelle est la difficulté du projet ? Si non, quel lecteur prendre (quelle norme) et comment s'intégre-t-il dans la chaîne de développement ?

Les robotinos ne disposent pas de lecteur intégré NFC. Dans le cadre du projet commun à la coupe Robocup nos encadrants ont effectué une commande de lecteur NFC. Une fois arrivés nôtre tâche sera de les connecter au Robotino et de nous assurer du bon fonctionnement des lecteurs. Dans le Robotino il existe une interface RE232 et celui de LAN sans fil. Nous pouvons utiliser l'une des interfaces pour communiquer.La difficulté du projet réside dans le fait que l'on va devoir apprendre à développer sur un Robotino en utilisant ROS qui est un serveur de paramètre. Nous avons la possibilité de le faire en C++ et en Python. Le robotino dispose en effet d'un fichier de configuration dans lequel se trouve sa configuration complète : nom du robot, couleur, réglages des moteurs, etc. Nous allons donc devoir lire ce fichier et trouver par nous mêmes comment envoyer l'information nécessaire à l'antenne qui sera connecté sur le Robotino. Cette antenne est notre lecteur RFID et sera connecté en série avec le Robotino. De plus une application Android devra être développée dans le langage Java. Nous allons donc apprendre également comment concevoir des applications Android et comment faire marcher la communication téléphone<->Robotino.

Comment réaliser la configuration du smartphone pour la prise de contrôle du Robotino ?

Le téléphone Android ouvre la connexion de données 3G/4G et accède à internet, il communique ensuite avec le robot par l'adresse IP en utilisant une structure client/serveur. Le serveur est toujours en cours d'exécution et attend un accès client. Une fois le programme client ouvert, on saisis ladresse IP du serveur et on se connecte sur ce dernier. On peut par conséquent obtenir la vidéo en temps réel et l'afficher sur l'écran du smartphone ou envoyer les commandes/données pour contrôler les mouvements du robots à l'aide des boutons virtuels.

Préparation du projet

Cahier des charges

S'assurer du bon fonctionnement du kit RFID sur le Robotino. Programmer ce dernier afin qu'il puisse prendre en compte les différents applications dont nous pourrons avoir besoin
Coller des tags RFID/NFC extérieurs pour mettre le robot dans une configuration souhaitée
Côté téléphone : Réaliser la prise de contrôle du Robotino avec le téléphone à l'aide d'une application Android
Reconfigurer le robot avec le téléphone

Choix techniques : matériel et logiciel

Robotino 3

Transpondeur RFID/NFC Grove, référence mouser : 713-113020006

Assortiment de tag RFID/NFC, référence mouser : 485-365

Tag RFID/NFC Sticker, référence mouser : 485-362

Un téléphone/tablette sous Android 0S

Liste des tâches à effectuer

Calendrier prévisionnel

Avant le 13/02/19 - Premier Test d'un programme linux prenant en charge la présence d'un Tag

Avant le 20/02/19 - Finalisation de l'Interface logicielle et intégration des test RFID/NFC. Début du travail sur le Robotino

Répartition du volume de travail (***h):

Recherche sur les technologies à utiliser
Formation Java, Android Studio et langage Go
Réalisation de l'interface logicielle (Application)
Intégration des différentes parties
Test et débuggage
Test du projet lors de la Robocup

Réalisation du Projet

Feuille d'heures

Tâche	Prélude	Heures S1	Heures S2	Heures S3	Heures S4	Heures S5	Heures S6	Heures S7	Heures S8	Heures S9	Heures S10	Heures S11	Heures S12	Total
Rédaction du cahier de charge	4
Prise en main d'Android Studio	2
Lecture et ecriture des tags sur un téléphone Android
Lecture des tags sur un ordinateur Linux
Automatisation du programme
Travail sur l'interface pour le rendu
Redaction du rapport
Redaction du rapport
Intégration de la synchronisation Wifi Téléphone/Ordinateur par NFC
Wiki

Prologue

Nous avons effectué une première rencontre avec nos encadrants qui nous a permis d'en savoir plus sur notre sujet :

Nous allons réaliser une application qui aura plusieurs fonctions. L'application devra nous permettre de pouvoir lire le contenu d'une carte RFID sur laquelle on aura préalablement écrit certaines commandes. Ainsi elle pourrait lancer une fonction souhaitée dès la détection d'une puce NFC/RFID en lançant une commande qui déclencherait notre application ou demanderait à l'utilisateur d'installer l'application. Elle devra également nous permettre de contrôler un Robotino grâce à un joystick sur l'application, le téléphone étant en communication par wifi.

Voici ci-dessous le logo de notre application

Les cartes NFC que nous utilisons sont des cartes Mifare Classic 1K. Ils disposent d'une capacité de 1024 bytes.( Notes ajouter la photo de leurs memory card)

Les 1024 bytes sont organisés en blocs et en secteurs. Au total 16 secteurs et chacun formé de 4 blocs. Chaque bloc a 16 bytes. Sur les 4 blocs on ne peut stocker les données que sur 3. Le dernier correspond au sector trailer où figurent les droits d'accès des données ainsi que la manière dont les données sont lues.

Semaine 1

Un compte Git a été créé afin de pouvoir gérer nos codes sources en suivant leurs évolutions et en travaillant séparément nous partageant les tâches. Dépôt Git nfcrobotino

Nous avons en suite effectué une recherche sur la manière la plus efficace de réaliser notre application Android. Le logiciel sur lequel nous allons travailler est Android Studio. Il s'agit de l'environnement de développement officiel de Google. Nous l'avons choisi pour sa simplicité et son efficacité et la possibilité de relier directement nos comptes Git au logiciel.

Nous avons ensuite effectué un schéma de principe de notre application comme le montre la figure ci-après.

Semaine 2

Travail sur la structure de l'application que l'on prévoit de coder.

Notre application aura un menu d'accueil qui nous permettra d'accéder à différentes fonctionnalités.

Nous avons également effectué une recherche bibliographique sur le NFC des téléphones mobiles en particulier les Android afin de comprendre le protocole utilisé. Les messages échangés seront sous format NDEF. Nous nous sommes renseigné sur la manière dont un Tag peut déclencher l'ouverture d'une application ou d'un site web automatiquement dès qu'elle est détectée par un téléphone et comment écrire sur une carte RFID/NFC et la configurer.

Afin de réaliser la communication Robotino<->Téléphone nous aurons besoin de :

Installer libnfc sur le Robotino

Semaine 3

Prise en main du Robotino. Nous avons analysé la structure des fichiers du Robotino. Le Robotino 3 sur lequel nous travaillons dispose d'un système d'exploitation Ubuntu et est doté d'un fichier config écrit en yaml dans lequel nous retrouvons le nom du robot, le numéro ainsi que la couleur. Nous pouvons donc commencer à effectuer des test avec un programme Linux qui pourra modifier un fichier une fois que l'antenne connectée préalablement en usb sur un ordinateur détectera un tag.

Nous nous sommes également partagé les tâches l'un travaillera sur l'application et l'autre sur le Robotino dans un premier temps

Semaine 4

L'application Android est capable de vérifier si le téléphone sur lequel elle est installée dispose de la configuration NFC ou non. Elle peut être également lancée dès qu'un tag sur lequel est écrit un texte est approché du téléphone. Nous comptons finaliser l'interface en y intégrant les fonctionnalités prévues, l'objectif étant celui de pouvoir lire et exploiter les données sur le tag d'ici la semaine prochaine.

Nous avons commencé à écrire les programmes pour modifier le fichier yaml et nous avons planifier l’architecture générale. Cependant, les de fonctions spécifique ont besoin d'être amélioré.

Semaine 5

Le fichier de configuration du Robotino est un fichier avec une extension .yaml de la forme suivante :

Nom équipe : constant
Numéro Robot: 3
Couleur Robot : Cyan ou Magenta
Nom Robot : R3
Encryption : Constant

Nous avons écrit un fichier yaml qui nous permet de lire ainsi que de modifier ce fichier. Nous utilisons le langage C++ pour réaliser le programme. Il y a trois étape de modifier le fichier yaml, d’abord on charge le fichier, puis modifie les données dedans et enfin, on transmet les données au fichier yaml. Afin de ne pas créer de confusion, nous utilisons le structure pour stocker ces données. Nous assignons actuellement des valeurs à ces données pour les tester, mais nous les obtiendrons en lisant les tags nfc.

 typedef struct config_robot
 {
    std::string   teamName;
    std::string   teamColor;
    int 	  robotNumber;
    std::string   robotName;
 }config_robot;

 config_robot   w_data;	// sauvgarder les datas pour écrire

 // lire et modifier yaml
 void yaml_read_write()
 {
   // Load file
   YAML::Node yaml_data = YAML::LoadFile("robotConfig.yaml");
   // read data
   r_data.teamName = yaml_data["teamName"].as<std::string>();
   // change data
   yaml_data["teamName"] = w_data.teamName;
   // emit
   std::ofstream fout("robotConfig.yaml");
   fout << yaml_data;   
 }

Le travail que nous allons effectuer dans les prochaines séances sera celui de pouvoir le modifier directement en servant des tags NFC.

Semaine 6

L'application que nous développons est capable d'écrire et lire les différents tags. Nous sommes également capable d'identifier sur un ordinateur Linux le type de tag RFID qui lui est relié.

Semaine 7

Nous pouvons lire et écrire sur les différents tags côté ordinateur grâce aux fonctions suivantes :

mifare-classic-read-ndef -y -o fichier.txt
mifare-classic-write-ndef -y -i fichier.txt

Semaine 8

Nous avons réalisé la première partie avec le script shell. Après avoir exécuté le fichier script shell, il exécutera la commande mifare-classic-read-ndef pour lire le contenu de tag nfc et le sauvgardera dans readdata.txt. Puis le programme cpp ouvrira ce fichier, obtiendra les données et modifiera le fichier yaml. Mais cette méthode n’est pas bonne, nous allons continuer à améliorer la programme de lecture.

 #! /bin/sh
 mifare-classic-read-ndef -y -o readdata.txt
 g++ -o test config_robot.cpp -lyaml-cpp
 ./test

Semaine 9

Nous analysons le programme original de la commande:mifare-classic-read-ndef -y -o fichier.txt. Nous comprenons toutes les fonctions appelées et essayons de les appliquer à nos propres programmes.

Afin de lire le contenu de tag nfc, nous recherchons d’abord l’interface USB correspondante et le tag, puis on dois obtenir le MAD(Accès au secteur) et le TLV bloc qui contient les informations. Après avoir obtenu la longueur d'un bloc, nous analysons tous les blocs un par un jusqu'à avoir les données. Nous plaçons un pointeur avant ces informations et les écrivons dans le fichier .txt.

 nfc_device *device = NULL;
 MifareTag *tags = NULL;
 Mad mad;
 nfc_context *context;

 nfc_init(&context);
 device = nfc_open(context, devices);
 tags = freefare_get_tags(device);
 char *tag_uid = freefare_get_tag_uid(tags[i]);
 mifare_classic_connect(tags[i])    // avoir le MAD
 if ((mad = mad_read(tags[i]))) {
   uint8_t tlv_type;
   uint16_t tlv_data_len;
   uint8_t *tlv_data;
   uint8_t *pbuffer = buffer;
   tlv_data = tlv_decode(pbuffer, &tlv_type, &tlv_data_len); // mettre un pointeur
   switch (tlv_type) {     // chercher les messages dans tlv bloc
   ...  }
   fwrite(tlv_data, 1, tlv_data_len, ndef_stream)
 }

IMA4 2018/2019 P40

Sommaire