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

Application Neato: Neato Robotics

Neato Robotics est une application pour connecter et contrôler un robot Neato Botvac, Les fonctions suivantes sont disponibles sur l'application :

Démarrer, arrêter ou mettre en pause le robot, même lorsque le robot est situé très loin.

Recevoir des notifications sur l’état de robot.

Utiliser l’application Neato avec plusieurs appareils.

Utiliser le portable pour localiser le robot.

Analyse du second concurrent

NXP NFC DIN rail demo

Le DIN NFC rail de NXP montre comment la technologie NFC peut être utilisée pour gérer des paramètres complexes sur un écran tactile mobile. Il est basé sur la solution NTAG I2C plus et montre comment la NFC est utilisée pour:

Le paramétrage sans fil et configuration à puissance nulle.

Le diagnostic et le dépannage du produit sans fil.

La mise à jour du micrologiciel sans fil.

Petit example: Ici, il peut contrôler les trois ampoules. Ce module DIN comprend un interrupteur d'alimentation (220 V), une interface NFC et un écran LCD. De plus, une application téléphonique dédiée a été développée pour interagir avec le rail DIN NFC afin de permettre le paramétrage sans fil, le diagnostic sans fil et la mise à jour du micrologiciel sans fil via NFC.

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	Heures S13
Rédaction du cahier de charge	4
Prise en main d'Android Studio	2	4			2			4				1	4	2
Lecture des tags sur un téléphone Android			2	2
Lecture des tags sur un ordinateur Linux			2			4	4		2
Automatisation du programme										4				2
Travail sur l'interface pour le rendu			1	2			1		1					1
Redaction du rapport											2	2	2	4
Commande du Robotino											4	2	2	3
Intégration de la synchronisation Wifi Téléphone/Ordinateur par NFC					2				2		4		1

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 ainsi 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.

Nous avons mis en place les différents stratégies afin de réaliser ce projet et avons décidé de travailler dans un premier sur la réalisation de la configuration automatique du Robotino par les tags NFC.

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.

Les téléphones Android ont simultanément trois modes de fonctionnement concernant la technologie NFC :

Le mode d'écriture/lecture qui permet d'écrire ainsi que de lire les Tags qui sont approchés au téléphone
Le mode P2P(Peer to Peer) permettant d'échanger avec les autres périphériques NFC (par exemple un autre téléphone)
Le mode d'émulation qui donne la possibilité au téléphone de se comporter lui-même comme un Tag

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

Installer la librairie libnfc sur le Robotino
se 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.

Le Robotino dispose d'un fichier de configuration robotConfig.yaml dans le quel se trouvent les informations suivantes :

teamName: PYRO
teamColor: magenta
robotNumber: 1
robotName: R1

cryptoKey: randomkey

Ces attributs correspondent respectivement aux nom de l'équipe, la couleur du Robot, le numéro , le nom ainsi que la clé de sécurité. Ce qui nous intéresse ici c'est de pouvoir écrire sur un Tag l'information de configuration du robot et venir connecter le tag sur le robot afin de modifier automatiquement ces différents champs. Le Robotino 3 sur lequel nous travaillons dispose d'un système d'exploitation Ubuntu. 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.

La librairie libfreefare dispose d'un programme nous permettant de lire et écrire un Tag. Il s'agit des fonctions :

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

La première nous permet de lire ce qui se trouve sur un Tag et recopie les données lues dans un fichier txt. La seconde nous permet d'écrire les données provenant d'un fichier txt. Cependant par rapport à notre application il ne serait pas intéressant d'utiliser un programme qui crée un autre fichier. Pour cela il nous faudrait avoir accès à un écran et lancer le programme de lecture ou d'écriture. Nous avons donc décidé de transformer et d'optimiser le programme de lecture et d'écriture et les incorporer dans une seule fonction en langage C++ de manière à pouvoir les lancer une fois pour toute.

Nous avons effectué un premier programme.c de lecture des tags. Nous avons remarqué que les données écrites sur les tags disposent d'un entête de fichier binaire suivi de la langue dans laquelle le contenu se trouve. Nous avons décidé d'ignorer cet entête par la fonction suivante :

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

tlv_data correspond aux données lues (voir code complet dans les documents annexes).

De la même manière nous avons écris un code nous permettant d'écrire sur les Tags.

Semaine 4

Dans notre application Android nous souhaitons développer les fonctionnalités suivantes :

Pouvoir lire et écrire les Tags NFC.
Pouvoir commander le robotino
Pouvoir acquérir un flux vidéo provenant du robotino

Nous voulons faciliter au maximum l'expérience utilisateur de celui qui utilise notre application. Nous avons pensé à intégrer une possibilité de lancer l'application dès qu'un Tag sera approché du téléphone. Afin de réaliser cela nous sommes parti de ce schéma de principe :

Lorsque un Tag NFC est approché du téléphone, le téléphone donne priorité à la recherche d'une application prête à prendre son contrôle et la lance si les données sont au bon format c'est à dire les données NDEF. Pour cela nous avons besoin de le déclarer dans notre application. Si les données ne sont pas sous format standard NDEF c'est à nous de programmer un protocole nous permettant de lire ces données. Cependant dans notre projet nous utiliserons que les données NDEF. C'est grâce à ce mécanisme que nous pourrons donner la priorité à notre application afin qu'elle s'ouvre dès qu'un Tag sera approché.

Dans le fichier AndroidManifest.xml nous avons ajouté les lignes suivantes afin de réaliser ce qui est décrit ci-dessus :

   <uses-permission android:name="android.permission.NFC" />

   <uses-feature
       android:name="android.hardware.nfc"
       android:required="false" />

  <intent-filter>
               <action android:name="android.nfc.action.TECH_DISCOVERED" />
           </intent-filter>

           <meta-data
               android:name="android.nfc.action.TECH_DISCOVERED"
               android:resource="@xml/tech_filter" />

   <tech>android.nfc.tech.NdefFormatable</tech>
       <tech>android.nfc.tech.MifareClassic</tech>

Un message qui nous prévient que le téléphone utilisé dispose de la NFC activiée ou pas a été ajouté :

if(nfcAdapter!=null && nfcAdapter.isEnabled()){
           Toast.makeText(this, "Votre appareil dispose de la tech NFC !", Toast.LENGTH_LONG).show();
       }else{
           Toast.makeText(this, "NFC pas disponible :( ", Toast.LENGTH_LONG).show();
       }

Nous avons travaillé sur notre interface d'accueil comme le montre la figure ci-après

Nous avons trois différentes activités que nous voulons programmer : une activité pour lire et écrire des tags, une autre pour prendre le contrôle du robot et une autre pour avoir le flux vidéo du robot.

Cette semaine nous nous sommes concentré sur la première activité celle de pouvoir lire et écrire des tags sur notre téléphone.

Semaine 5

Cette semaine nous nous intéressons à la deuxième activité qui nous permet de prendre en contrôle le Robotino.

L'intérêt du RFID/NFC est non seulement de pouvoir configurer le Robotino en plaçant un Tag sur l'antenne relié au robot mais aussi de pouvoir prendre le contrôle du robot. Une Web Interface est déjà disponible sur le Robotino nous permettant de le contrôler via un smartphone à travers un navigateur. Utilisant une application que nous développons nous-même nous ne pouvons pas utiliser un navigateur. Nous allons donc établir la connexion Smartphone <=> Robotino en utilisant le protocole les sockets. Nous allons introduire un client et un serveur. Le client va correspondre au Smartphone et le serveur le Robotino. Les deux seront lié sur le même port que nous allons choisir.

L'utilité de la NFC sera de pouvoir transférer l'adresse IP du Robotino ainsi que le port d'écoute se trouvant dans le logiciel où le serveur sera exécuté.

Voici le principe de fonctionnement : 
Un utilisateur approche son téléphone de l'antenne RFID/NFC branché sur le robot; celui-ci transfert l'adresse IP et le port du robot.

Nous avons testé dans un premier temps le client sur le téléphone.

Les 4 boutons vont envoyer des paquets TCP formant les chaînes de caractères Avancer, Reculer, Droite ou Gauche. Afin d'obtenir un client TCP qui marche nous avons importé la classe ServerSocket nous permettant d'écouter et d'accepter les différents connexions de clients. Ces données seront reçues par le serveur qui va les utiliser.

Semaine 6

Afin d'obtenir la configuration complète du Robotino notre lecteur NFC doit être capable de simuler ou de se comporter comme un tag NFC. De cette manière lorsque le téléphone sera relié à l'antenne du lecteur il pourra l'identifier en tant que tag NFC et pourra lire le contenu que l'on souhaite envoyer.

Pour réaliser cela nous avons écrit un programme capable de récupérer l'adresse IP ainsi que le nom l'interface de la configuration réseau. Une fonction vient lire ce résultat et l'envoi sur l'antenne RFID. Le format des données envoyées sera le NDEF. Le Tag émulé sera le Tag Mifare Classic Tag4.

Nous détaillons dans les lignes suivantes la construction du message NDEF qui nous permettra de configurer notre lecteur NFC.

Comme entête du fichier nous avons le Capability Container : Pour que le périphérique NFC puisse écrire les données du tag émulé il parcours en premier lieu cet entête dans laquelle on retrouve les identifiants du Tag, les droits de lecture ou d'écriture du Tag, la taille des données se trouvant sur le Tag. Voici notre configuration de l'entête :

 0x00, 0x0F, /* Notre fichier d'entête sera sur 15 bytes */
 0x20,       /* Mapping version 2.0 */
 0x00, 0xFB, /* MLe Maximum R-ADPU taille */

 0x00, 0xF9, /* MLc Maximum C-ADPU taille */
 0x04,       /* T field of the NDEF File-Control TLV */
 0x06,       /* L field of the NDEF File-Control TLV */
 /* V field of the NDEF File-Control TLV */
 0xE1, 0x04, /* File identifier */
 0xFF, 0xFE, /* Taille maximale du message NDEF */
 0x00,       /* Droit de lecture NDEF  */
 0x00,       /* Droit d'écriture NDEF */

Ce fichier sera écrit sur le périphérique NFC et il pourra ainsi simuler un tag nfc-forum-tag4.

Semaine 7

Nous nous sommes concentrés sur la finalisation du transfert de données Robot Téléphone. L'un des objectifs du projet est celui de pouvoir afficher sur le téléphone la configuration réseau du Robotino. Nous envoyons sur le téléphone comme information :

L'adresse IP du Robotino
Le nom du WiFi sur lequel le robot est connecté
Le mot de Passe de ce WiFi
Par la suite on pourra ajouter le niveau de batterie ainsi que d'autres données de capteurs

Afin d'afficher le Hostname (nom d'hôte) nous utilisons la fonction suivante :

char hostbuffer[256]; 
int hostname = gethostname(hostbuffer, sizeof(hostbuffer)); //Nous récupérons le Hostname
struct hostent *host_entry;
host_entry = gethostbyname(hostbuffer); //Nous récupérons l'information associée

Quand à l'adresse IP nous la récupérons grâce à la commande suivante :

char *IPbuffer; 
IPbuffer = inet_ntoa(*((struct in_addr*) 
                          host_entry->h_addr_list[0]));

Pour ce qui est de l'interface réseau sur lequel nous sommes connecté ou le mot de passe du WiFi, les systèmes Linux sauvegardent dans le dossier suivant les mots de passes des WiFi sur lesquels ils sont connectés :

/etc/NetworkManager/system-connections/

Il s'agit d'un fichier protégé qui demande des autorisations particulières (être administrateur) afin de l'accéder. Nôtre programme en langage C pourra lire les fichiers contenus dans ce dossier.

Pour savoir quel fichier ouvrir, il faut que le Robotino sache le nom du WiFi sur lequel il est connecté. Cela est réalisable grâce à la commande

iwconfig [interface]

Il s'agit d'une commande similaire à ifconfig mais reliée aux interfaces réseaux. Le champ ESSID correspondant au nom du réseau où l'on est connecté que l'on retrouve dans le résultat nous sera utile lorsque l'on va chercher le mot de passe.

Le but était d'automatiser ces tâches à travers un seul programme. Nous avons testé notre fonction et voici ce que l'on observe sur le téléphone

Semaine 8

Nous avons travaillé sur le client TCP côté téléphone. Pour cela nous avons créé une nouvelle fenêtre (activité) qui va s'ouvrir lorsque l'utilisateur va cliquer sur le bouton commander le Robotino. Nous nous connectons au serveur qui reçoit en boucle les messages qu'on lui envoie. Nous avons testé avec des chaînes de caractères personnalisées.

Semaine 9

Afin d'écrire les messages dans le tag nfc par l'ordinateur, il y a 6 étapes.

1. Obtenir l'adresse et la longueur du message

2. Initialiser et chercher l'appareil NFC et le Tag NFC

3. Ouvrir le Tag et obtenir les informations (type de Tag)

4. Si le tag dispose déjà d'un MAD, charger le MAD et le réécrire. Si le Tag n'a pas de MAD, créer un nouveau.

5. Marker le TLV bloc et écrire les informations.

6. Libérer et fermer

Semaine 10

Nous avons trouvé un moyen pour robotino d'envoyer des informations directement au portable via le périphérique NFC et de les afficher à l'écran, au lieu de les relayer via le tag nfc. Ce méthode est plus éfficace.

Pour échanger les data nfc, il y a un certain forme. Nous créons une matrice pour sauvgarder les data dans ce forme et le transférer au portable. Dans cette matrice, au début les places de message sont vides, puis on utilise une boucle pour modifier.

 uint8_t ndef_file[0xfffe] = {
     0x00, 0xFE,
     0xD1,0x01, 0xFA,
     0x54, 0x02, 0x65,0x6E, 0x2d, 0x2d, 0x48, 0x6f, 0x6e, 0x65, 0x79, 0x77, 0x65, 0x6c, 0x6c, 0x2d, 0x2d,
     0x00, 0x00, 0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,
     ...
     0x00, 0x00, 0x00,0x00, 0x00,0x00
 }; 
 for (int z=0; z<strlen(entree); z++) 
       ndef_file[z+9]=entree[z];

Semaine 11

Le portable peut se connecter à l'adresse IP du robotino et envoyer des informations via le protocole TCP.

Le processus de connexion:

Nous fournissons l'adresse IP et le numéro du port sur lequel nous souhaitons nous connecter

InetAddress serverAddr = InetAddress.getByName(SERVER_IP);

Nous créons la socket pour établir une connexion avec le serveur

Socket socket = new Socket(serverAddr, SERVERPORT);

Nous envoyons le message

 out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true);

Traiter les demandes de connexion des clients

 client = accept( sock, (sockaddr *)&peer, &plen );

Si il a réussi, nous pouvons lire les informations auprès des clients.

 read( client, &ch, 1 );
 write( client, &ch, 1 );

Nous utilisons également des Threads afin de lancer le programme de réception des paquets TCP et en même temps bouger le robot. Nous nous sommes servi des fonctions lanceThreads que nous avons utilisé dans le cadre du projet PSR.

void *threads_function(void* arguments)
{
struct Threads_arguments *myArgs=arguments;
myArgs->fonction(myArgs->parametre);
free(myArgs->parametre);
free(myArgs);
return NULL;
}

int lanceThread(void (*fonction)(void *), void *param, int size)
{
struct Threads_arguments* myArgs=malloc(sizeof(struct Threads_arguments));
myArgs->fonction=fonction;
myArgs->parametre=malloc(size);
memcpy(myArgs->parametre,param,size);
   
pthread_t tid;
if((pthread_create(&tid,NULL,threads_function,(void*)myArgs)!=0)){
return -1;}
pthread_detach(tid);
return 0;
}

Semaine 12

Nous avons écrit un programme pour réaliser le mouvement de robotino après avoir reçu un message de portable. L'action de robotino sont différents selon les différents messages. Quatre actions sont possibles: avancer, reculer, tourner à gauche et à droite.

Semaine 13

Nous importons les programmes précédents dans robotino et les testons.

Documents Rendus

Rapport : Fichier:RAPPORT P40 HU NDUWAMUNGU.pdf
Code Source : https://framagit.org/PyroTeam/nfcrobotino

IMA4 2018/2019 P40

Sommaire