Version du 3 avril 2019 à 22:39

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

1. 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
2. Coller des tags RFID/NFC extérieurs pour mettre le robot dans une configuration souhaitée
3. 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
4. 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

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. Deux branches ont été créées une où l'on va ajouter les programmes de notre application et une autre les codes que l'ont va installer sur le Robotino.

Nous avons ensuite effectué une recherche sur la manière la plus efficace de réaliser notre application Android. Le logiciel avec 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 la possibilité d'écrire notre programme en Kotlin ou en Java mais notre choix s'est tourné vers ce dernier.

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 téléphones Android afin de comprendre le protocole utilisé : les messages échangés seront sous format NDEF : NFC Data Exchange Format. Il s'agit d'un format standard d'échange de données entre deux périphériques NFC ou un périphérique NFC et un tag. Les données enregistrées sont sous forme NDEF Messages ou sous formes de NDEF Records. Il est utilisé pour effectuer l'échange d'URL, de texte ainsi que plusieurs autres possibilité.

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 la librairie libnfc sur le Robotino
• ses rendre dans le fichier de configuration de la librairie et l'adapter suivant le port où notre antenne RFID est reliée
• installer la librairie libfreefare qui va nous permettre de lire et écrire les différents Tags

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.

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 étapes afin de modifier le fichier yaml : Premièrement nous chargeons le fichier, ensuite nous modifions les données à l'intérieur 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. Ci dessus se trouve la structure de données qui va être utilisée pour modifier le fichier YAML.

 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;   
 }

Côté application Android nous avons pensé à utiliser un transfert de données via des requêtes TCP/IP. Pour cela

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;       // NULL ou avoir des informations
   uint16_t tlv_data_len;  // la longueur d'un TLV bloc
   uint8_t *tlv_data;      // Pointez sur les données
   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)
 }

Semaine 10

Nous avons optimisé la manière d'obtenir les données. Nous avons plutôt assigné les données obtenues du pointeur à la chaîne et écrit directement dans le fichier yaml.

 char data[5][30];
 int i=0,j=0,k=0;
 k=7;  // Pour éliminer le contenu inutile au début
 while(k<tlv_data_len){                
    if(tlv_data[k]=='\n') {
      i++; j=0;  k++;}
    else {
      data[i][j]=tlv_data[k]; j++;  k++; }

Documents Rendus