Version du 2 mai 2019 à 09:22

Présentation générale : Interface Graphique Robotino 2 Upgradé

Etudiants : François BRASSART & Jérome HAON

Encadrants : Vincent COELEN & Thomas DANEL

Description

Lors de notre 2ème année de PEIP, nous avons eu l'occasion d'utiliser des Robotinos lors d'un Bureau d'études afin de découvrir la spécialité IMA. Les Robotinos sont des robots mobiles produits par Festo, à entrainement omnidirectionnel ce qui leur permet de ce déplacer dans toutes les directions et de tourner sur eux-mêmes. Ils sont dotés de différents capteurs (infrarouges, optiques, inductifs...) ainsi que d'une Webcam et d'un gyroscope. Ils peuvent être contrôlés et programmés sur un PC via une connexion Wi-Fi ou directement grâce à l'interface Homme-Machine (IHM) intégrée.

Nous avons constaté durant ce bureau d'étude que les Robotinos, utilisés depuis une dizaine d'années en salle de TP commencaient à vieillir. L'objectif de notre projet est moderniser ces robots afin de les remettre au gout du jour. Les Robotinos bénéficieront d'un nouvel ordinateur embarqué, d'un nouveau logiciel, de nouvelles batteries et d'un écran tactile 7 pouces.

Objectifs

La modernisation des Robotinos à déja été commencée avant le début de notre projet. Les nouveaux composants ont déja été choisis et l'installation est en cours. Le but de notre projet est de concevoir la nouvelle interface Homme-Machine. Il s'agira d'une interface graphique directement accessible via l'écran tactile, programmée grâce au WebTool Kit qui permettra entre autre de :

Configurer le Robotino au réseau : pouvoir modifier facilement la configuration réseau du robot (interface filaire ou choix d'un réseau sans fil).
Afficher l’état et les données des différents capteurs (camera, laser, sharps, bumper) afin de faciliter la programmation et le débogage des programmes.
Lancer des programmes de démonstration que nous aurons préalablement programmé.

Cette interface graphique devra évidemment être fonctionnelle et agréable à utiliser.

Analyse du projet

Positionnement par rapport à l'existant

Les Robotinos utilisés depuis 10 ans en salle de TP sont des Robotinos de génération 2. Il existe actuellement des Robotinos de génération 3. Nos 2 concurrents sont donc le Robotino 2 et le Robotino 3.

Notre Robotino "amélioré" sera équipé d'un ordinateur embarqué Intel NUC, avec l'OS Ubuntu 18.04. Il disposera d'une IHM intégrée notamment grâce à un écran tactile 7 pouces que nous allons créer.

Analyse du premier concurrent : Robotino 2

Le Robotino 2 est équipé d'un ordinateur embarqué AMD Geode, avec l'OS Ubuntu 9.04.

Il dispose également d'une IHM sur son chassis composé d'un petit écran et de plusieurs boutons. Elle permet de :

Selectionner la langue,
Afficher l'état des batteries
Sélectionner les adresses du réseau
Sélectionner des programmes de démonstrations pré-enregistrés.

Configuration Hardware Robotino 2

IHM Robotino 2

Analyse du second concurrent : Robotino 3

Le Robotino 3 est équipé d'un ordinateur embarqué Intel Core i5 ou Intel Atom, avec l'OS Ubuntu 12.04.

Il ne dispose pas d'IHM intégrée, il doit être contrôlé à distance par un PC.

Configuration Hardware Robotino 3

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

Samedi 2 février 2019, Journée Portes Ouvertes à Polytech Lille.

Pierre, étudiant en IMA est chargé de faire la démonstration de l'utilisation des Robotinos sur le terrain de Hockey/Football de la salle C305. Dès que tous les futurs étudiants et leur parents sont rentrés dans la salle, il n'a qu'à choisir en cliquant sur l'écran tactile d'un Robotino le programme qu'il désire dans l'onglet "programme". Il peut ainsi commencer sa présentation pendant que le robot suivra une ligne, contournera un obstacle ou fera demi-tour quand il rencontrera un mur.

Vendredi 25 Janvier 2019, Bureau d'études IMA

Léna et Clément, étudiants en PEIP2, ont choisi le bureau d'études IMA afin de découvrir cette spécialité et finaliser leur orientation. Il consiste en la commande d'un Robotino. La première mission est de le faire suivre une ligne. Léna et Clément ont beaucoup de mal à comprendre le fonctionnement de ce Robot. Clément à mis des sur-chaussures pour pouvoir marcher sur le terrain pendant que Lina commande manuellement le robot depuis le PC. En cliquant sur l'onglet "états des capteurs", Clément peut directement voir sur l'écran du robot l'état des capteurs, et ainsi comprendre leur fonctionnement en fonction de la position du robot et de son environnement.

Réponse à la question difficile

Question : Positionnement de Web Tool Kit WT par rapport à d’autres systèmes (ROS par exemple) mériterait d’être explicité. De même la difficulté (ou pas) de prise en main de Web Tool Kit WT n’est pas abordée.

Réponse :

Robot Operating System (ROS), est un ensemble d'outils informatiques open source permettant de développer des logiciels pour la robotique. Il s'agit d'un méta-système d'exploitation qui peut fonctionner sur un ou plusieurs ordinateurs et qui fournit plusieurs fonctionnalités : abstraction du matériel, contrôle des périphériques de bas niveau, mise en œuvre de fonctionnalités couramment utilisées, transmission de messages entre les processus et gestions des packages installés.

Un Web Toolkit est une interface web qui est met à disposition des fonctions pour le contrôle, la configuration et la maintenance du système de robot. WT est une bibliothèque d'interface graphique Web en C ++.

Notre objectif étant de concevoir une interface graphique sur l'écran tactile des Robotinos, WT semble plus adapté que ROS, qui est principalement axé sur la programmation des robots. De plus, connaissant déjà très bien le langage C, il nous parait plus réaliste d'utiliser un Web Toolkit.

Préparation du projet

Cahier des charges

Nous devrons répondre aux différents besoins des différents utilisateur. D'abord, l'interface graphique devra permettre de configurer le Robotino au réseau. En effet, différents modes de configuration du robot sont possibles : filaires ou réseau sans fil. Il faudra avoir le choix entre ses 2 modes et pouvoir régler les paramètres. Ensuite, pour faciliter la programmation, l'interface pourra afficher les états et les données des différents capteurs. Enfin, une interface de lancement des programmes de démonstration que nous aurons préalablement programmé devra être programmée. Cette interface graphique devra évidemment être fonctionnelle et agréable à utiliser.

Ce cahier des charges est susceptible d'évoluer en fonction de l'avancée de notre projet. En effet, nous pouvons envisager d'ajouter des fonctionnalités à notre interface graphique.

Choix techniques : matériel et logiciel

Comme indiqué dans la réponse à la question difficile, nous avons choisi d'utiliser le Web Toolkit WT. Les choix matériels ont déjà été réalisés par nos encadrants :

PC embarqué INTEL NUC,
écran tactile 7 pouces,
le choix des nouvelles batteries est en cours de réflexion.

Liste des tâches à effectuer

La liste des tâches à effectuer est pour le moment floue, nous allons programmer une rencontre avec nos encadrants pour les préciser. Nous estimons qu'il nous faudra d'abord apprendre à connaitre les nouveaux composants (mais également les anciens), puis apprivoiser le Web Toolkit pour finalement créer l'interface graphique finale.

Réalisation du Projet

Prologue

Lors du semestre 7, nous avons commencé par une analyse détaillée de notre projet, en effectuant dans un premier temps la présentation de notre projet, ensuite nous avons positionner notre projet par rapport à l'existant et nous avons défini un scénario d'usage, enfin nous avons déterminé notre cahier des charges.

Egalement nous avons rencontré à plusieurs reprises nos encadrants afin d’approfondir au fur et à mesure les objectifs de notre projet. Les rencontres avec nos encadrants étaient aussi un moyen pour nous de voir l'avancement de la construction des robotinos qui aiguisait notre curiosité.

Planning prévisionnel

Janvier

Apprentissage du langage C++ en autonomie a travers des cours et vidéos tutoriels sur internet et des livres empruntés à la bibliothèque universitaire.
Alimenter notre wiki.

Février

Téléchargement de la librairie Web Toolkit sur le site internet de Wt.
Autoformation sur Web Toolkit a travers des vidéos internet et des exemples d'application donnés lors du téléchargement de Web Toolkit.
Se renseigner sur la méthode de récupération des données des capteurs et des acteurs de Robotino dans l'API2.
Faire une première esquisse sur papier de notre interface graphique en pensant aux différentes fonctionnalités que nous voudrions implémenter.
Alimenter notre wiki.

Mars (début de mois)

Commencer la programmation de notre interface graphique.
Télécharger la librairie API2 sur wiki.openrobotino.
Alimenter notre wiki.

Mars (fin de mois)

L'interface graphique est terminée ou en cours d'être terminée.
Commencer à récupérer les données des capteurs du Robotino et les intégrer à notre interface graphique.
Alimenter notre wiki.

Avril (début de mois)

Finir l'interface graphique si elle n'est pas tout a fait terminée.
Continuer la récupération des données de l'API2.
Commencer à configurer la connexion réseau du robotino.
Alimenter notre wiki.

Avril (fin de mois)

Finir la récupération des données.
Commencer à importer les démonstration sur le nouveau Robotino.
Finaliser la connexion réseau.
Alimenter notre wiki.

Mai

Finir d'importer les nouvelles démonstrations dans le Robotino upgradé.
Alimenter notre wiki.
Soutenance de fin de projet.

Feuille d'heures

Tâche	Prélude	Heures S1	Heures S2	Heures S3	Heures S4	Heures S5	Heures S6	Heures S8	Heures S10	Total
Analyse du projet	3									3
Organisation, Brainstorming		2		2						2
RDV avec encadrants			1		1		1	1	1	5
Autoformation C++, WebToolkit		6	6	2						14
Montée en connaissance sur Robotino, API2			3							3
Programmation du bandeau et menu principal				4	4	3	3			11
Récupération de l'état des capteurs, intégration à l'interface						2	3
Gestion de la connexion réseau
Programmes de démonstrations
Tests
Préparation Soutenance

Semaine 1

Objectifs : organisation, approche de C++ & WT.

Lors de cette première semaine, nous avons commencé par organiser un planning de travail pour les mois à venir, en nous imposant des objectifs afin de se repartir au mieux la charge de travail.

Nous avons installé une Machine Virtuelle sur notre ordinateur afin de pouvoir travailler en dehors des séances de projets. De plus nous avons téléchargé le paquetage Web ToolKit avec les différents exemples d'utilisation, et effectué des recherches sur son fonctionnement avant de commencer à programmer notre interface graphique.

Enfin, nous avons pris rendez-vous avec nos encadrants de projet afin nous renseigner sur l’avancement de l'assemblage du Robotino, leur expliquer l'organisation des tâches que nous nous sommes donnée et de vérifier que notre cahier des charges est complet.

Semaine 2

Objectifs : Documentation sur C++ & WT.

Nous avons commencé cette deuxième séance avec un rendez-vous avec nos 2 tuteurs : Vincent Coelen et Thomas Danel. Ils nous ont rassuré sur l'avancée du prototype du robotino. L'écran a été commandé et devrait arriver rapidement. Il sera également monté au plus vite, pour avoir le premier prototype prêt à fonctionner dans minimum 2 semaines. Nous avons convenu de faire une réunion toutes les 2 semaines avec nos encadrants. Cela leur permettra de se tenir au courant de l'avancée de notre travail et nous permettra également de leur poser des questions et de faire un point sur l'avancée de la "construction" du robotino amélioré.

Le nouvel ordinateur embarqué est relié au micro-contrôleur du robotino via une liaison série RS232. Lorsqu'un programme de démonstration est lancé (directement depuis l'ordinateur embarqué ou via lelogiciel RobotinoView depuis un ordinateur), les commandes sont envoyées en TCP au RPCd., qui est chargé d'envoyer les commandes au bon destinataire. La Webcam ou le laser sont reliés à l'ordinateur embarqué. Les autres capteurs et actionneurs (moteurs, roues...) sont reliés au microcontrolleur du robotino.

Après ce RDV, nous avons suivi un tutoriel pour apprendre le langage C++. tuto C++. En effet, pour utiliser Wt, nous allons coder en C++. Connaissant déja très bien le C et ayant des bases de Java, le langage C++ n'est pas très compliqué à comprendre et à assimiler. nous avons également commencé à suivre des tutos sur Wt. tuto 1 tuto 2

Nous avons ainsi étudié quelques exemples d'applications Web réalisés avec WebToolkit. Nous avons pu découvrir le fonctionnement de WT : la possibilité d'ajouter des Widgets prédéfinis sur une interface. Ces tutoriels et exemples seront une bonne base pour le début de la programmation de notre interface graphique. Chaque Widget peut émettre un signal lorsque l'on clique dessus par exemple (permettant la communication déclenchée par un événement entre les objets du programme).

Semaine 3

Objectifs : Documentation sur WT, brainstorming sur le design de l'interface.

Lors de cette troisième semaine, nous avons continué à nous perfectionner, en analysant les exemples donnés via la plateforme Web Toolkit.

Ensuite il est venu le temps d'imaginer à quoi pourrait ressembler notre interface graphique, avec les différentes fonctionnalités que nous pourrions implémenter (voir schéma ci-dessous).

MENU PRINCIPAL

Aide

Expliquer les différentes fonctionnalités de notre interface comme par exemple comment connecter le robot au wifi, comment lire l'état des capteur ou alors lancer un programme de démonstration.

Quitter interface

Configuration réseau

Modifier facilement la configuration réseau du robot (interface filaire ou choix d'un réseau sans fil).

Visualisation état capteurs

Afficher les données des différents capteurs du robotino directement sur l'interface graphique, par exemple lors de la suivi d'un mur nous pourrions voir en temps réels quel capteur de distance est utilisé ainsi que la valeur qu'il renvoie.

Lancement programme de démonstration

Exécuter un programme de démonstration directement enregistré dans le robotino parmi une liste prédéfinie.

En parallèle nous avons commencé à nous documenter sur wiki.openrobotino pour avoir un accès complet aux capteurs et aux actionneurs du robotino via l'API2. Une API (interface de programmation applicative) est est un ensemble normalisé de classes, de méthodes ou de fonctions qui sert de façade par laquelle un logiciel offre des services à d'autres logiciels. Dans notre cas, l'API2 du robotino est une API permettant de d’accéder aux différents éléments du robotino. Cela nous permettra de récupérer les données et de les afficher sur notre interface graphique plus tard. api2

Semaine 4

Objectifs : Finaliser le design de l'interface, commencer la programmation avec Wt.

Nous avons commencé cette semaine avec un rendez vous avec nos 2 tuteurs afin de faire un compte rendu de notre avancement sur le projet. Cela a été l'occasion pour nous de leur présenter l'ébauche de visuel de l'interface que nous avons réalisé précédemment. Nos encadrants nous ont aidé et ont soulevé quelques points manquants et améliorations possibles.

Nous allons donc rajouter un "bandeau" en haut de notre interface, qui sera toujours visible et qui affichera en continu les informations importantes telles que :

l'adresse IP
le programme en cours
l'adresse Wifi
l'état de la batterie

Egalement, pour des questions de praticité, il est plus judicieux, lors du choix des programmes de démonstration, de faire un menu déroulant plutôt que des boutons. Cela sera plus pratique pour l'utilisateur. De plus, il sera plus simple dans le futur d'ajouter des nouveaux programmes de démonstration pour les personnes n'ayant pas implémenté l'interface.

Nous avons donc fait un nouveau visuel pour l'interface graphique :

Pour nous faciliter la tâche de programmation de l'interface, nous avons pensé utiliser le logiciel WtDesigner, qui permet de créer une interface graphique avec Wt facilement. Cependant, après plusieurs tests, nous n'avons pas été en mesure de récupérer le code source de l'interface ainsi créée (nous avons uniquement accès au fichier .h). Cela n'est donc pas compatible avec l'utilisation de l'interface que nous souhaitons. Sans le code source, nous ne pouvons utiliser l'API2 et ajouter des fonctions pour récupérer l'état des capteurs et actionneurs du robotino. Ceci a donc été une perte de temps dans notre projet.

Semaine 5

Objectifs : programmation du premier menu Wt.

Suite à l'échec de l'utilisation du logiciel WtDesigner, nous avons commencé à coder nous même l'interface en C++.

Nous nous penchons d'abord sur le menu principal, composé du bandeau et des 3 boutons permettant de sélectionner les 3 fonctions principales de notre interface : la configuration réseau, l'état des capteurs et les programmes de démonstration. Nous partons sur la base de l'exemple Hello World de Wt, qui contient principalement un texte et un bouton.

Nous choisissons de créer 2 WContainerWidget dans chaque partie de l'interface. Un WContainerWidget permet de séparer l'écran et d'ajouter des widgets dans chaque container. Ainsi, nous allons créer un WContainerWidget pour le bandeau et un pour le "corps". Le WContainerWidget du bandeau sera présent sur chaque page de notre interface. Pour le moment, nous avons ajouté du texte "statique", mais plus tard, le contenu sera modifié en fonction du robot (adresse IP, batterie, programme en cours...). Nous avons également ajouté les 3 boutons permettant de lancer les 3 fonctionnalités principales de notre interface.

Malgré de nombreux tests, nous n'arrivons pour le moment pas à intégrer une feuille de style CSS. Cela est très problématique car, comme le montre la capture ci-dessous, le rendu n'est pas du tout esthétique. Nous pouvons cependant modifier la taille, la couleur... des Widgets grâce à des fonctions de Wt. Cependant, il n'existe pas de fonctions de Wt permettant de centrer et d'espacer le texte, d'adapter la taille des boutons en fonction de l'écran (taille en pourcentage de l'écran)... L'utilisation d'un fichier CSS parait donc être obligatoire pour mener à bien notre projet et nous devons trouver une solution.

Semaine 6

Objectifs : Git, ajout du CSS, finaliser le menu principal, création des "sous-menus".

Cette semaine a débuté avec un rendez-vous avec Vincent Coelen. Lors de cet entretien nous avons commencé par présenter l'avancement de notre projet que nous avons effectué pendant les vacances et il a pu répondre à nos questions et nous apporter des solutions pour le futur. Egalement le montage des nouveaux composants du Robotino est terminé, il nous a fait une démonstration pour l'allumer et l'éteindre ainsi que les différentes fonctionnalités de l'écran tactile et de l'écran embarqué.

De plus pour faciliter la communication entre nous et aussi avec notre tuteur, sur les lignes de code que nous pouvons effectuer et de garder dans le futur ce que nous avons fait, un GIT a été mis en place : Lien vers le GIT

Nous avons continué la programmation de notre interface. Nous avons réussi à utiliser une feuille de style CSS. il faut pour cela utiliser la fonction

useStyleSheet("stylesheet.css")

Nous avions déjà essayé d'utiliser cette fonction auparavant, mais sans succès. Cela ne fonctionnait pas car, lors de la compilation, il faut ajouter une option permettant d'indiquer ou se trouve les fichiers nécessaires à notre interface : feuilles de styles, images... Ainsi pour compiler, il faut utiliser la commande

./main --docroot ./ressources --http-address 0.0.0.0 --http-port 8080

--docroot ./ressources permet d'indiquer les ressources se trouvent dans le dossier courant

--http-address 0.0.0.0 permet d'indiquer l'adresse sur laquelle nous voulons accéder à notre interface. Pour le moment, nous choisissons l'adresse locale 0.0.0.0

--http-port 8080 permet d'indiquer le port que nous souhaitons utiliser. Nous utilisons 8080 car cela correspond à un port qui n'est pas réservé.

Nous avons organisé notre projet dans des fichiers et dossiers différents, afin de mieux s'y retrouver.

dossier ressources : contient les images, feuilles de style CSS...
dossier bandeau : contient la classe qui crée le bandeau, qui est présent sur tous les menus.
dossier corps : contient la classe qui crée le "corps" de notre interface, c'est à dire le contenu principal de l'interface

Le fichier main.c est le programme principal qui initialisera la connexion avec le robotino, et qui créera des instances de bandeau et de corps.

Enfin cette semaine nous avons fini de programmer le menu principal de l'interface graphique. Pour le bandeau, nous n'avons finalement pas utilisé un WContainerWidget mais avons opté pour un WHBoxLayout. Ce type de widget permet d'organiser horizontalement des widgets, dans notre cas du texte et des images. Cela nous a permis de régler correctement l'espacement et le centrage des informations contenues dans le bandeau.

Nous avons ensuite commencé à créer les "sous-menus" suivants et les avons liés au menu principal, après un clic sur le bouton correspondant. Pour cela, nous créons pour chaque sous-menu un WContainerWidget qui contiendra les informations nécessaires.

Pour naviguer entre les menus, nous avons décidé que lors d'un clic sur un bouton du menu principal, l'adresse URL est modifiée. par exemple, lors d'un clic sur le bouton "Etat des Capteurs", l'url devient localhost:8080/capteurs.

Lors d'un changement dans l'url, un signal est provoqué. Nous avons implémenté une fonction qui reconnait ce signal, et qui change le container affiché à l'écran en fonction de l'url. Dans notre exemple, quand l'adresse url devient, localhost:8080/capteurs, le container de menu principal est effacé et remplacé par le container de l'état des capteurs.

Semaine 7

Objectifs : ajustement de l'interface graphique sur le robotino, connexion au robotino, récupération état capteurs

Nous avons désormais accès au robotino qui est dans une salle en AIP afin que nous puissions travailler dessus quand nous le souhaitons. Nous testons alors l'interface sur le robotino que nous avions réalisé sur oridinateur. Au début de ce projet nous avions téléchargé une machine virtuel de type debian, or avec debian la dernière version disponible de WT était la version 3.3.6. Lorsque nous avons voulu afficher l'interface graphique sur le robotino, un problème est survenu. Enfet le robotino embarque une machine virtuel Ubuntu, qui lui permet d'avoir la dernière version de WT (4.0.3). Lors de la compilation nous avons eu de nombreuses erreurs de syntaxe du fait de la mise à jour. Pour coller au mieux avec le processus embarqué par le robotino nous avons donc choisi de telecharger une nouvelle machine virtuelle Ubuntu (celle utilisée par le robotino) et de télécharger la même version de WT, pour ne plus avoir de problème dans l'avenir. Nous avons réussi en très peu de temps à corriger les erreurs de compilation du à la nouvelle mise à jour et nous pouvons commencer à récupérer les données des capteurs et des actionneurs du robotino.

Avant de pouvoir commencer à retourner l'état des capteurs et des actionneurs, nous devons connecter le robotino à notre programme. Afin d'y parvenir nous avons analysé les exemples donnés lors du téléchargement de l'API2. Nous avons testé l'exemple circle sur le robotino et analysé son fonctionnement. Ce programme commence par créer une communication avec le robotino. Une fonction init créée une instance de la classe com et appelle plusieurs de ses méthodes afin de se connecter au robotino :

setAddress pour donner l'adresse IP du robotino
connectToServer pour s'y connecter.

Ensuite, il crée une instance de la classe Omnidrive, afin de pouvoir contrôler la trajectoire du robot.

Nous allons ainsi utiliser une fonction similaire à init pour nous connecter au robotino, et allons créer des instances de classes de chaque capteurs pour utiliser leurs méthodes permettant de récupérer leur état.

Ensuite nous avons choisi de récupérer la donnée du Bumper du robotino. Le bumper est un capteur de collision, quand il subit une une pression, il renvoie un signal, cela permet au robotino de se stopper. Avec la fonction bool rec::robotino::api2::Bumper::value on obtient :

True quand le robotino heurte quelquechose (un mur par exemple)
False sinon

Nous créons donc dans le main une variable globale correspondant au bumper, que nous utilisons dans le programme du corps de l'interface. Il nous suffit donc d'afficher dans le menu de l'état du bumper : bumper.value() afin d'afficher True ou False.

A la fin de cette séance nous avons réussi à connecter le robotino à notre programme et à récuperer l'etat du bumper, mais à l'instant t, il ne se met pas à jour si nous n'actualisons pas la page. Nous avons essayer de mettre une boucle while(1), mais sans grand succès, car nous supposons que la boucle qui est une boucle infinie empêche notre interface graphique de fonctionner en même temps que le programme du bumper. Pour la séance suivante nous réfléchissons à un moyen d'afficher la valeur du bumper en instantané.

Avant de terminer la semaine, nous voulons désormais que l'état du bumper s'actualise en instantané, sans que nous ayons besoin de rafraîchir la page. Pour cela, nous utilisons un timer. WT nous permet d'utiliser un Widget WTimer qui crée un signal à intervalle de temps régulier. Nous choisissons d'utiliser un timer de 10ms. Dans notre programme, nous exécutons la fonction bumper.value() et actualisons l'affichage à chaque fois que ce signal est émis.

 mytimer->timeout().connect([=] {
 if(bumper.value()==true)
 	state->setText("True");
 else if (bumper.value()==false)
 	state->setText("False");
 });

Semaine 8

Objectifs : Récupération état des capteurs, mise a jour de l'interface en conséquence.

Nous commençons cette séance en récupérant, l'état de l'odométrie. L'odométrie fournit la position momentanée par rapport à la position de départ. Les codeurs des moteurs permettent de savoir combien de tours le moteur a effectué et donc de calculer, à l’aide du diamètre de la roue, la distance parcourue. Cette méthode fournit localement des résultats relativement précis mais l’erreur croît fortement sur de longues distances.

Avec la fonction : void rec::robotino::api2::Odometry::readings(double *x, double *y, double *phi, unsigned int *sequence = 0)const on obtient :

la position x
la position y
l’orientation phi

Mais nous n'arrivons pas à actualiser l’état de l'odométrie en instantané avec le timer. En effet la fonction qui renvoie les valeurs de l'odométrie est une fonction const(), déclarer une méthode const() c'est indiquer au compilateur qu'à l’intérieur de cette méthode on ne doit pas modifier l'état de l'objet. Pour réussir à modifier l’état des variables, nous avons alors déclaré à nouveau les variables à l’intérieur de la boucle du timer.

METTRE CODE AVEC FONCTION CONST()

De la même manière que le bumper, nous créons donc dans le main une variable globale correspondant à l'odométrie, que nous utilisons dans le programme du corps de l'interface, pour afficher l'état du capteur odométrique dans le menu.

Ensuite nous nous sommes occupés du capteur gyroscopique du robotino, qui est utilisé pour augmenter la précision de détermination des positions. Le gyroscope détermine la variation de l’orientation du robotino. Dés que le système d’exploitation du robotino détecte le gyroscope, il utilise son signal pour corriger les positions sur la base du système odométrique. L’odométrie est considérablement améliorée par le capteur gyroscopique.

Comme précédemment nous créons dans le main une variable globale correspondant au gyroscope, que nous utilisons dans le programme du corps de l'interface. Il nous suffit donc d'afficher dans le menu de l'état du gyroscope avec la fonction suivante :

float rec::robotino::api2::Gyroscope::angle ()const on obtient la valeur actuelle de l'angle.

De la même manière que l'odométrie, fonction const(), nous actualisons l'affichage du gyroscope à chaque fois que le timer émet un signal.

Semaine 9

Objectifs : Récupération état des capteurs, mise a jour de l'interface en conséquence

Ensuite nous, nous sommes passés au capteur de distance du robotino, ce capteur mesure la distance précise ou relative d'un objet entre 4 cm et 30 cm. Il est constitué d'un signal de sortie analogique.

Également nous avons récupéré l'état du gyroscope sur le robotino, il est utilisé pour augmenter la précision de détermination des positions, il détermine la variation de l'orientation.

Nous avons terminé par le capteur d'odometrie, mais n'avons pas réussi à l'actualiser avec le timer.

Semaine 10

Objectifs : Récupération état des derniers capteurs, renseignements sur la configuration réseau

En début de semaine nous avons réussi à obtenir les données odométriques en temps réel, en effet la fonction odmétrie est une fonction const(), et déclarer une méthode const() c'est indiquer au compilateur qu'à l’intérieur de cette méthode on ne doit pas modifier l'état de l'objet. Pour réussir à modifier l’état des variables, nous avons redéclaré les variables à l’intérieur de la boucle du timer.

Ensuite nous nous sommes occupé de transmettre la vitesse des roues en temps réel, la fonction utilisée pour transmettre cette vitesse est également une fonction const(), pour obtenir la vitesse en temps réel, nous avons utilisé la même méthode que précédemment. Il faut savoir que la vitesse des roues est renvoyée en rpm qui correspond à des tours par minute.

Enfin nous avons réussi à retourner les valeurs des entrées analogiques et digitales du robotino.

Par exemple :

Les capteurs optiques gauche et droit permettent de détecter diverses surfaces et couleurs sur la base des différences de coefficient de réflexion. Ils s'exploitent par l'intermédiaire des entrées digitales. Il y a aussi le capteur inductif qui permet de détecter des objets métalliques, quand a lui il s'exploite par l’intermédiaire des entrées analogiques.

Enfin nous avons terminer la semaine avec un rendez-vous avec nos tuteurs, nous lui avons montré l’agencement sur la récupération des données des capteurs et des actionneurs, et nous voulions savoir si nous devions en rajouter des nouveaux.

Il nous faudra donc par la suite récuperer les données :

de la caméra
du laser

Mais également envoyer des données avec les sorties digitales.

De plus nous souhaitions connaitre ce qu'il attendais de nous pour le menu configuration réseau, afin de nous pencher dessus. Il nous faudra donc dans une première partie lister tous les réseaux WiFi et dans une seconde partie pour enregistrer un réseau sur le robotino en rentrant son identifiant, le mot de passe, le type ainsi que si l'on veut se connecter de manière manuel ou en DHCP.

Semaine 11

Objectifs : Configuration réseau, programme de démonstration

Nous avons rajouté les sorties analogiques dans les capteurs qui peuvent être gérés par notre interface. Nous avons ainsi la possibilité de voir quelles sorties sont actives et nous pouvons également les activer. Nous avons terminé d'ajouter tous les capteurs.

Nous nous lançons dans la partie configuration réseau qui permet de configurer la connexion au robotino.

Semaine 12

Objectifs avant semaine 12 (pendant les vacances) : avoir fini la partie configuration réseau, et lancement des programmes de démonstration. Il ne nous restera ainsi à finaliser l'esthétique de notre interface et créer notre programme de démonstrations avant de faire les test finaux.

Notre carte réseau sans fil est nommée wlp1s0.

ifconfig wlp1s0 up
iwlist wlp1s0 scan // permet de récuperer les réseaux WiFi disponibles, leur qualité...

sudo service network-manager stop/start //permet de désactiver ou activer Network manager

wpa_passphrase nom_reseau_wifi > ~/wpa.conf
wpa_supplicant -B -c ~/wpa.conf -i wlp1s0

//si marche pas

killall wpa_supplicant

dhclient wlp1s0

Semaine 13

Objectifs : préparation de la soutenance

Semaine 14

Programme de démonstration s'exécute en tache de fond pour pouvoir lire les données de l'interface graphique en même temps.

Capteur laser fait

Documents Rendus

Fichier:2018-11-26 Présentation du projet.pdf

Version du 2 mai 2019 à 09:22 (voir la source) Jhaon (discussion \| contributions) (→‎Semaine 8) ← Modification précédente		Version du 2 mai 2019 à 09:22 (voir la source) Jhaon (discussion \| contributions) (→‎Semaine 8) Modification suivante →
Ligne 528 :		Ligne 528 :

	float rec::robotino::api2::Gyroscope::angle ()const on obtient la valeur actuelle de l'angle.		float rec::robotino::api2::Gyroscope::angle ()const on obtient la valeur actuelle de l'angle.
		+
	De la même manière que l'odométrie, fonction const(), nous actualisons l'affichage du gyroscope à chaque fois que le timer émet un signal.		De la même manière que l'odométrie, fonction const(), nous actualisons l'affichage du gyroscope à chaque fois que le timer émet un signal.

IMA4 2018/2019 P38 : Différence entre versions