IMA4 2018/2019 P2 : Différence entre versions
(→Choix techniques : matériel et logiciel) |
(→Semaine 6) |
||
Ligne 339 : | Ligne 339 : | ||
- Librairie [http://www.diymodules.org/eagle-show-object?type=dm&file=diy-modules.lbr&device=ULTRASONIC-HC-SR04 diy-modules] pour le capteur de distance HC SR04 | - Librairie [http://www.diymodules.org/eagle-show-object?type=dm&file=diy-modules.lbr&device=ULTRASONIC-HC-SR04 diy-modules] pour le capteur de distance HC SR04 | ||
− | - Librairie [https://www.snapeda.com/parts/ | + | - Librairie [https://www.snapeda.com/parts/TB6612FNG,C,8,EL/Toshiba/view-part/ TB6612FNG,C,8,EL] pour le contrôleur de moteur TB6612FNG |
- Librairie [https://github.com/chiengineer/Eagle-Libraries/tree/master/Connectors con-headers-jp] pour les headers femelles | - Librairie [https://github.com/chiengineer/Eagle-Libraries/tree/master/Connectors con-headers-jp] pour les headers femelles |
Version du 27 octobre 2018 à 12:12
Sommaire
NumWorks et robot
Présentation générale
Description
Le projet consiste à commander un robot classique par une calculatrice NumWorks avec un programme Python. Après avoir conçu un robot classique à base d'Arduino, moteurs, sonar ultrason et suiveurs de lignes, il faudra modifier le logiciel d'une calculatrice NumWorks afin que cette dernière soit capable de communiquer avec le robot. Une fois la communication établie, nous développerons une API afin de contrôler le robot. Finalement, nous écrirons un programme python utilisant l'API pour transformer le robot en un robot suiveur de ligne avec arrêt en cas d'obstacle et redémarrage automatique lors de la disparition de l'obstacle.
Objectifs
- Conception d'un robot classique
- Modification du logiciel d'une calculatrice NumWorks pour établir une communication entre le robot et la calculatrice
- Développer une API permettant le contrôle du robot
- Développer un programme Python transformant le robot en un robot suiveur de ligne avec arrêt en cas d'obstacle et redémarrage automatique lors de la disparition de l'obstacle
Préparation du projet
Cahier des charges
Robot :
- Concevoir un robot mobile à partir d'un Arduino Uno, capable de détecter des obstacles grâce à un capteur de distance à ultrason et de suivre une ligne grâce à des capteurs suiveurs de ligne
Communication :
- Établir une communication entre le robot et la calculatrice NumWorks en tentant de passer le micro-contrôleur en hôte USB et en utilisant le FTDI de l'Arduino
API :
- Développer une API permettant de contrôler le robot :
- fonctions pour contrôler les moteurs
- fonctions pour lire la distance du sonar
- fonctions pour lire l'information des suiveurs de ligne
Programme Python :
- Développer un programme Python se servant de l'API pour transformer le robot en un suiveur de ligne. Il doit permettre au robot de s'arrêter en cas d'obstacle et redémarrer lorsque l'obstacle disparaît
Choix techniques : matériel et logiciel
- Robot :
- Chassis : Kit à assembler Magician chassis dg007
- Arduino Uno
- Capteur de distance : HC SR04
- Capteur infrarouge suiveur de ligne : Sparkfun ROB-09453
- Contrôleur de moteur : Pololu TB6612FNG
- Shield pour Arduino : Réalisation sur Eagle
- Communication : Modification de l'OS Numworks en C++ / C
- API et programme suivi de ligne : Développés en Python
Liste des tâches à effectuer
- Assembler le robot
- Réaliser un shield pour l'Arduino
- Modifier le logiciel de la calculatrice NumWorks pour établir la communication
- Développer l'API
- Développer le programme Python
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 | Total |
---|---|---|---|---|---|---|---|---|---|---|---|---|
Analyse du projet | 5H | |||||||||||
Recherches / documentation | 12H | 6H | ||||||||||
Conception du robot | 30min | |||||||||||
Réalisation du shield | 12H30 | |||||||||||
Établissement de la communication | 3H | 6H | 6H | 9H | ||||||||
Développement de l'API | ||||||||||||
Développement du programme Python |
Prologue
Semaine 1
- Acquisition du matériel :
Le matériel nécessaire à la conception du robot était déjà disponible. Récupération d'un kit à assembler pour construire un robot à deux roues, d'un Arduino Uno, d'un sonar ultrason, d'un contrôleur de moteur ainsi que de trois suiveurs de ligne.
- Installation du SDK NumWorks :
Ayant à modifier le logiciel de la calculatrice NumWorks afin de transformer la calculatrice en un périphérique USB hôte pour pouvoir contrôler le robot, j'ai installé le SDK fourni par l'éditeur qui offre un simulateur.
On récupère dans un premier temps le code :
git clone https://github.com/numworks/epsilon.git
Avant de pouvoir lancer le simulateur, il faut installer de nombreuses dépendances :
apt-get install bison build-essential dfu-util flex gcc-arm-none-eabi git libfltk1.3-dev libfreetype6-dev libpng12-dev
Une fois les dépendances installées, on peut compiler :
make PLATFORM=simulator clean make PLATFORM=simulator
Puis on lance le simulateur par la commande :
./epsilon.elf
- Recherches / Documentation :
L'USB On-The-Go (OTG) est une spécification qui permet à un périphérique USB de se comporter comme un hôte ou un esclave selon la situation. Par exemple, cela permet à une tablette (qui est de base un périphérique esclave) de pouvoir communiquer avec un autre périphérique USB tel qu'une souris, un clavier en agissant comme périphérique hôte puis d'être esclave lorsque connecté à un ordinateur. Cette spécification OTG introduit un 5ème pin, le pin "ID". Lorsque ce dernier est connecté à la masse, le périphérique est défini comme hôte par défaut. Si le pin n'est pas connecté, le périphérique est esclave par défaut.
Le port USB de la calculatrice NumWorks n'étant censé être utilisé que pour recharger la calculatrice ou la mettre à jour, la calculatrice est un périphérique esclave. Cela est confirmé par le Schematics de la calculatrice sur lequel on voit que le pin ID de l'USB n'est pas connecté :
Le micro-contrôleur STM32F412VGT6 utilisé est cependant compatible avec l'OTG d'après sa Datasheet et l'acronyme "OTG" apparaît à de nombreuses reprises dans le code du logiciel de la calculatrice NumWorks. Il faudra donc creuser dans ce sens pour faire de la calculatrice un hôte USB.
Semaine 2
- Recherches / Documentation :
Recherche et lecture de documentation pouvant aider à l'établissement de la communication entre la calculatrice et le robot. On retiendra trois documents qui pourront nous aider:
- Manuel d'utilisation de la librairie USB host du logiciel de développement des STM32 STM32Cube
- Manuel d'utilisation de la librairie USB On-The-Go des STM32F
- Manuel de référence du STM32F412
- Établissement de la communication entre la calculatrice et le robot :
Début de modification du logiciel de la calculatrice NumWorks afin d'en faire un hôte USB pour pouvoir contrôler le robot. Pour cela, le manuel de référence du STM32F412 est une aide précieuse.
Dans un premier temps, nous modifions les différents registres d'initialisation de l'USB OTG du micro-contrôleur. Cela se passe dans la fonction initOTG() du fichier /ion/src/device/usb.cpp.
Dans ce fichier, on s'aperçoit d'une ligne qui force l'USB à agir en tant qu'esclave :
OTG.GUSBCFG()->setFDMOD(true);
Pour forcer la calculatrice à apparaître comme un hôte USB, on modifie la ligne de la façon suivante :
OTG.GUSBCFG()->setFHMOD(true);
Le manuel de référence du STM32F412 nous propose une démarche pour initialiser l'USB de la calculatrice en tant qu'hôte, nous la suivons donc.
Il faut dans un premier temps initialiser le cœur. On active différents masques et interruptions à travers différents registres ainsi que les modes :
- Host negotiation protocol (HNP) qui permet au cœur de changer dynamiquement son rôle de périphérique A-Host en A-esclave et inversement ou B-host en B-esclave.
- Session request protocol (SRP) qui permet, lorsque la calculatrice est un hôte USB, d'économiser de l'énergie en éteignant le Vbus power si la session USB est suspendue
On procède ensuite à l'initialisation du mode hôte. On active le port de contrôle et le registre de statut, on sélectionne le mode de vitesse supportée. Si un périphérique USB est détecté, on active le processus de reset sur le périphérique, on se règle sur sa vitesse et on configure la taille des queues FIFO pour l'échange des données.
Il faudra ensuite procéder à l'initialisation d'un canal de communication pour que la calculatrice puisse échanger avec le robot.
Semaine 3
- Établissement de la communication entre la calculatrice et le robot :
Initialisation des channels : afin de pouvoir communiquer avec les périphériques connectés à l'hôte, en l’occurrence ici, l'Arduino à la calculatrice, il faut initialiser des canaux de communication. Pour cela, on active les canaux voulus à travers les registres, on active certaines interruptions et masques. Il faut finalement donner une taille au canal en fonction des paquets attendus ainsi que donner les caractéristiques du endpoint que l'Arduino présentera.
Maintenant que l'initialisation a été modifié pour que la calculatrice apparaisse comme un hôte USB, il faut adapter les fonctions de communication. J'ai alors passé pas mal de temps à essayer de comprendre l'architecture du logiciel en terme de communication USB et chercher ce qu'il y a à modifier.
Semaine 4
- Établissement de la communication entre la calculatrice et le robot :
Après avoir passé du temps à essayer de trouver les modifications à apporter aux fonctions de communication USB du logiciel Numworks, j'ai découvert que STMicroelectronics propose des bibliothèques pour aider à la programmation de leurs microcontrôleurs. On trouve dans ces dernières des fonctions toutes faites pour la configuration de l'USB pour un mode hôte ou esclave. En plus de proposer des fonctions réalisant l'initialisation du core, du mode hôte et des canaux de communication comme j'ai pu le faire au cours des deux dernières semaines, ils proposent des fonctions de communication ainsi qu'une interface d'abstraction matérielle permettant de faciliter la portabilité. J'ai donc choisi d'utiliser ces bibliothèques plutôt que de continuer à réaliser les fonctions moi-même et de risquer de faire des erreurs qui seraient sûrement difficiles à trouver au moment des tests. Cela me permettra aussi probablement de gagner du temps.
Après avoir programmé le logiciel Numworks pour utiliser la fonction d'initialisation de l'USB fournie par les bibliothèques STM, je suis confronté à un problème d'intégration au vu des erreurs apparaissant à la compilation.
Semaine 5
- Établissement de la communication entre la calculatrice et le robot :
- Résolution du problème de la semaine 4. La semaine dernière, en voulant intégrer les bibliothèques que propose STMicroelectronics j'ai été confronté à un problème à la compilation. Après avoir utilisé un type défini par les bibliothèques intégrées dans le code du logiciel Numworks afin de faire de la calculatrice un hôte USB, j'avais une erreur à la compilation qui m'indiquait que le type utilisé n'était pas défini bien que le fichier .h était lié. J'ai alors, dans un premier temps, pensé qu'il s'agissait d'un problème au niveau des makefile suite à l'ajout des bibliothèques. Finalement, en examinant le code des .h des bibliothèques STM, je me suis rendu compte qu'ils contenaient presque tous le code suivant :
#if defined(STM32F405xx) || defined(STM32F415xx) || defined(STM32F407xx) || defined(STM32F417xx) || \ defined(STM32F427xx) || defined(STM32F437xx) || defined(STM32F429xx) || defined(STM32F439xx) || \ defined(STM32F401xC) || defined(STM32F401xE) || defined(STM32F411xE) || defined(STM32F446xx) || \ defined(STM32F469xx) || defined(STM32F479xx) || defined(STM32F412Zx) || defined(STM32F412Vx) || \ defined(STM32F412Rx) || defined(STM32F412Cx) || defined(STM32F413xx) || defined(STM32F423xx)
Les bibliothèques proposées par STMicroelectronics sont communes à chacun de leurs microcontrôleurs. Cependant, ces derniers étant tous différents, il existe des différences au niveau des registres. Afin de pouvoir utiliser les bibliothèques, il faut donc définir le modèle de microcontrôleur utilisé dans un .h bien particulier. Sans cela, le if defined étant présent en tête de fichier et ne se fermant qu'à la fin, tout le contenu était ignoré. Après avoir défini l'utilisation du STM32F412VGT6 dans le .h adéquat, le problème de typage non reconnu à la compilation a été résolu.
Après avoir inclus les nombreux .h différents nécessaires pour l'utilisation des fonctions d'initialisation du périphérique USB, j'ai été confronté à un autre problème :
De nombreuses variables sont définies sous le même nom dans le logiciel Numworks et dans les bibliothèques STM mais sont utilisées différemment et dans deux langages (C++ pour Numworks, C pour bibliothèques STM). Des problèmes de collision apparaissent donc parmi d'autres à la compilation. Les variables en question étant utilisées dans de nombreux fichiers différents dont le code n'est pas forcément simple à comprendre sans l'étudier et y passer du temps, réadapter le code des bibliothèques à celui du logiciel demanderait beaucoup de temps. J'ai donc choisi de revenir sur la solution de départ et de réaliser les fonctions nécessaires moi-même en prenant appui sur ces bibliothèques.
- J'ai donc dans un second temps, repris les fonctions d'initialisation créées au cours des semaines dernières pour les réutiliser et je les ai ajusté en fonction de l'implémentation que STMicroelectronics propose dans ses bibliothèques.
Semaine 6
- Conception du robot :
Après avoir passé pas mal de temps sur l'établissement de la communication, j'ai décidé de laisser cela de côté pour cette semaine, j'y reviendrai plus tard. J'ai dans un premier temps assemblé le châssis du robot, chose relativement simple et rapide avec la notice fournie au kit.
- Réalisation du shield :
Afin de réaliser un travail propre et qu'il n'y ait pas de fils dans tous les sens, il a été demandé de réaliser un shield pour l'arduino en y intégrant les différents composants utilisés. On intégrera à ce shield :
- Le contrôleur de moteur TB6612FNG
- Des headers permettant de connecter les deux moteurs au contrôleur
- Le capteur de distance HC SR04
La batterie sera connectée au robot par le shield avec des fils.
Les capteurs optiques suiveurs de lignes devant se trouver sous le robot pour être utiles, nous réaliserons un autre PCB pour ces derniers.
J'ai décidé de réaliser ces cartes électroniques avec le logiciel Eagle, notamment parce qu'il est disponible sous Linux contrairement à Altium. Après avoir procédé à l'installation du logiciel, j'ai recherché des librairies Eagle proposant les composants dont j'ai besoin :
- Librairie SparkFun-Boards pour le template de shield Arduino Uno
- Librairie diy-modules pour le capteur de distance HC SR04
- Librairie TB6612FNG,C,8,EL pour le contrôleur de moteur TB6612FNG
- Librairie con-headers-jp pour les headers femelles
- Librairie SparkFun-PowerSymbols pour le 5V et la masse
J'ai ensuite cherché à savoir comment connecter les différents composants entre eux puis procédé à la réalisation du schematics et du PCB associé :