IMA4 2017/2018 P25 : Essaim de Robots
Sommaire
- 1 Présentation générale
- 2 Analyse du projet
- 3 Préparation du projet
- 4 Résumé du projet
- 5 Déroulement du projet
- 6 Déroulement du projet
- 6.1 Semaine 2 : communication et moteurs, les débuts
- 6.2 Semaine 3 : communication et PCB, ça continue
- 6.3 Semaine 4 : Analyse et premiers problèmes
- 6.4 Semaine 5(6,7) : On avance
- 6.5 Semaine 8 : Début de la fin ou fin du début ?
- 6.6 Semaine 9 : On atteint vraiment la pratique
- 6.7 Semaine 10
- 6.8 Semaine 11
- 6.9 Semaine 12, 13
- 6.10 Semaines supplémentaires
- 7 Documents Rendus
Présentation générale
Projet réalisé par : Benjamin Canu et Ganix Etcheguibel.
Description
Dans ce projet nous devons concevoir des mini-robots qui se comportent comme un essaim. Le principe de l'essaim se base sur les règles d'autonomie et de faible intelligence de chaque individu, ainsi que sur un faible de cout de production à l'individu et une robustesse à la variation de ceux-ci dans le groupe :
- Autonomie énergétique, sensorimotrice et décisionnelle.
- Faible intelligence : Aucune (ou très peu de communication), aucune connaissance de l'environnement global ou de l'ensemble du groupe, interactions uniquement avec l'environnement local.
Pour notre projet, nous prendrons comme but de réaliser la cartographie d'une pièce intérieure (sol plat et lisse, pas de perturbation).
Objectifs
- Adaptation du châssis et de la carte électronique fournie à partir d'anciens projets.
- Mise en place, sur ce châssis, de capteurs et LEDs.
- Programmation des algorithmes de calcul des robots pour le maintient de la distance dans l'essaim, et l'évitement des obstacles.
- Ajout des dispositifs nécessaires à la prise de mesure pour la cartographie.
Analyse du projet
Analyse du premier concurrent
Projet de robots vibrants développé à l’Université d’Harvard, est un ensemble de 1024 robots montés sur des tiges vibrantes, se plaçant sur le sol selon la forme donnée en image-ordre.
Ce groupe de robots permet la réalisation de figures complexes au sol, cependant leur moyen de mobilité fixe une vitesse fortement réduite (11h/forme) et donc n’est pas vraiment adaptée à l’analyse d’une pièce.
https://theconversation.com/thousand-robot-swarm-assembles-itself-into-shapes-30548
Analyse du second concurrent
Projet de drones volants, par GRASP Lab à l’Université de Pennsylvanie est un essaim de drones volants pouvant réaliser des figures, mouvements et organisations complexes.
Les drones permettent, si munis de caméra, de visualiser la pièce grâce à une vue de dessus rapide à mettre en place. Cependant cette vision de la cartographie n’est pas identique, car elle ne donne pas les même informations que les drones roulants (e.g.: un table vue de dessous est quatre pieds, vue de dessus elle est un rectangle). De plus, les drones peuvent cartographier en présence de personnes, si un traitement poussé est effectué en suite, mais il ne peuvent opérer dans une salle où l’air n’est pas stable.
http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.423.203&rep=rep1&type=pdf
Scénario d'usage du produit ou du concept envisagé
Ces robots pourront être utilisés pour la cartographie de salles en intérieur.
Leur déploiement permettra ainsi, lors de l’évitement, d’enregistrer la position et la forme des obstacles et différents objets entreposés sans en connaître au préalable les paramètres.
Réponse à la question difficile
Aucune question difficile n'a été abordée lors de la présentation.
Préparation du projet
Choix techniques : matériel et logiciel (Ici pour deux robots)
Résumé du projet
Carte Électronique
L’étude de la carte électronique s’est réalisée péniblement, du fait qu’aucun de nous deux n’étions à l’aise avec la conception de circuits électroniques. Cependant avec l’aide de M. Redon, nous avons pu avoir accès à un modèle déjà réalisé pour d'anciens projets. Cette carte contenant alors la plupart des composants nécessaires n'était pas optimisée pour la fonction d’un robot en essaim. Nous avons alors du la retravailler en enlevant ou ajoutant certaines parties.
D’abord nous avons remarqué la présence de moteurs électriques. Désirant utiliser des servomoteurs, nous avons remplacé cette partie ainsi que le routage sur le microprocesseur.
De plus, le traitement des récepteurs infrarouges se faisait par alternance d’alimentation et par lecture sur une seule pin de l’Atmega. Avec la suppression des moteurs, nous avons pu utiliser deux pins de plus afin d’alimenter les TSOPs en continu et donc les lire sur trois pins différentes.
Le châssis du robot permettant la mise en place des capteurs à distance de la carte, il a aussi fallu revoir les empreintes afin de permettre l’accès au travers de connecteurs externes, autant sur la face supérieures pour les capteurs infrarouges ou ultrasons, que sur la face intérieure pour les moteurs ou la pile.
Enfin il a fallu travailler le routage pour éviter toute erreur de RDC telles que des câbles se chevauchant (ou trop proches) tout en évitant les angles droits ou de trop nombreuses connections entre les deux faces de la carte.
La mise en place de la liaison USB à travers la puce FTDI et le connecteur USB-C n’a pas été à refaire, cependant son étude à été inévitable afin de vérifier les connections aux différentes pins. L'intégration d’un programmeur AVR ISP à aussi été nécessaire afin de permettre la programmation du robot monté.
Afin de réaliser les fonctions désirées, la carte électronique se compose donc :
- d'un microprocesseur Atmega328p et de son environnement.
- de 3 capteurs Infra-rouge (TSOP) ainsi que d'un capteur à effet Hall et d'un émetteur-récepteur ultrason afin de repérer les autres robots ainsi que les obstacles.
- d'une LED infra-rouge afin d'être visible des autres robots.
- de deux servomoteurs pour assurer les déplacements.
- d'une alimentation par une pile 9V.
- d'une puce FTDI et de son environnement, gérant la partie USB.
Microprocesseur
Le microprocesseur étant la "tête pensante" de notre futur robot, nous avons d’abord hésité entre une Raspberry Pi et une Atmega 328p (Arduino). Comme notre projet est orienté vers du matériel bas niveau (capteurs, actionneurs..), l’Arduino s’est révélé plus optimal que la Raspberry, elle orientée haut niveau (flux vidéo, wifi, etc)
Nos robots devant faire plusieurs tâches en “simultané”, il fallait implanter un ordonnanceur dans le microprocesseur. Pour cela, nous avons choisi FreeRTOS, un mini OS pour Arduino. Cela s'est révélé être une erreur en fin de projet.
Ce microprocesseur choisi, nous pouvions alors passer à sa programmation en AVR ainsi qu'à quelques tests avec des composants. Nous avons d’abord décidé de nous attarder sur l’émission de l’identifiant du robot au travers d’une LED infrarouge, puis nous avons tenté de programmer la modulation et la transmission du signal contenant l’identifiant.
Composants
Servomoteurs : Pour réaliser la fonction du mouvement, nous avons choisi des servomoteurs afin de permettre un déplacement précis ainsi qu’une économie d’électronique car ceux-ci ne nécessitent qu'une seule sortie du microprocesseur pour commander le sens et la vitesse de rotation.
Capteurs : Nous souhaitons réaliser une fonction de détection des autres robots, ainsi que de l’environnement proche. Pour le premier nous avons décidé de placer une LED infrarouge sur l’arrière du châssis ainsi que des détecteurs sur les trois autres côtés. A travers cette communication, nous pourrons ainsi communiquer l’identifiant propre au robot et, par exemple, décider des placements pour un train de véhicule.
Nous avons aussi imaginé un dispositif de capteur à effet Hall lié à un aimant permanent accroché au châssis afin de détecter l’approche à très faible distance d’un robot sans pour autant avoir à lire son identifiant.
Pour la détection de l’environnement, la mise en place d'émetteur-récepteurs ultrasons à l’avant permettra sa réalisation pour des obstacles proches.
Infrarouge
Pour la transmission en infra-rouge, chaque robot enverra son identifiant à intervalle aléatoire. Pour assurer au maximum l'intégrité du message reçu, on y intègre des bits de stuffing (une inversion de bits tous les n bits similaires de suite), ainsi qu'un bit de parité en fin.
Au fur et à mesure du codage de l’émission de l’infrarouge, nous nous sommes rendus compte qu’on allait se confronter à plusieurs problèmes, tel que la corruption du signal infrarouge par l’émission d’autres robots. Pour palier à cela, nous avons décidé d’utiliser des bits de stuffing: Tous les n bits similaires on ajouter un bit contraire afin de vérifier de la non corruption du message. Ainsi, si il y a n+1 bits à l’état haut à la suite, cela signifie qu’on reçoit deux signaux en même temps. Donc on arrête de lire le message en cours, corrompu. Comme les robots émettent régulièrement leurs identifiants, on peut se permettre d’en rater quelques-uns. Un second problème serait de commencer à lire un message au milieu de l'émission. On se retrouverait alors avec des identifiants faux. On a ainsi ajouté n+1 bits de start de sorte à être sûr que l'on est au début du message.
L’identifiant à l’émission paramétré, il faut à présent coder la réception. Pour cela on vérifie que l'on reçoit bien les n+1 bits de start. Puis à chaque bits similaires on incrémente un compteur, on vérifie qu’à chaque fois que l'on a n bits similaires le bit suivant soit inversé. Si c’est le cas, on passe le bit de stuffing puis on continue à lire le message, sinon on arrête la lecture.
Pour la réception, il nous faut utiliser un capteur IR TSOP, modulé à 38kHz. Cela occasionne une contrainte : moduler notre signal pour qu’il soit lu par le capteur. Au début, nous avons voulu utiliser la fonction _delay_ms d’AVR pour pouvoir effectuer une modulation. Cependant il s’est avéré que cette fonction n’avait pas une résolution assez fine. Nous avons donc choisis de passer par les TIMERS de l’Arduino.
On utilise l'émission et la réception simultanément grâce à l'ordonnanceur. Lors de la réception, on vérifie que la trame reçue correspond bien au format de trame standard, et qu'il n'y a pas d'erreur par rapport aux bits de stuffing et de parité. Une fois vérifiée, on sauvegarde l'identifiant.
Aujourd'hui, on utilise 3 capteurs IR, un sur chaque côté du robot (avant et latéraux). Chaque capteur aura une tâche de l'ordonnanceur qui lui est propre, afin qu'il puisse recevoir le même signal.
Modélisation 3D
Afin de réaliser ce robot, nous avons eu l’idée de concevoir un châssis réalisable en impression 3D. Pour cela nous avons utilisé le logiciel en ligne Onshape très utilisé dans ce domaine. Nous avons alors laissé parler notre imagination ainsi que la praticité de conception afin de créer une coque permettant de maintenir en place les moteurs par vissage, ainsi que les différents capteurs, sans oublier la carte électronique. Le modèle a donc d’abord été réalisée sans dimensions précises, nous n’avions que des approximations sur les précédents modèles de mini-robots, et ne pouvions qu’estimer les emplacements des différents trous et poteaux, ainsi que la forme concrète. Cependant nous voulions valider certains points :
Tout d’abord la mise en place de la pile à l’opposé des moteurs, donc au dessus de la roue de balance, afin que le robot ne se renverse pas lors d'accélération brèves, pour cela nous avons donc définit que les moteurs soient à l’avant, et la roue folle ainsi que la pile à l’arrière pour permettre à la compensation du couple réalisé par l’avance ou le recul du robot.
De plus, nous souhaitions réaliser un robot disposant de plusieurs étages. Cela offre un confort de lisibilité (et une classe non négligeable), ainsi qu’un espace libre aux capteurs, autant pour l’activité réalisée que pour les tests. Malgré ces avantages, nous avons pu intuiter la réduction de la facilité de montage ainsi que d’accès à la carte électronique. Nous avons cependant préféré continuer dans cette lancée, les dimensions du robot n’étant pas critiquement grandes, laissant ainsi la possibilité d’augmenter l’espace entre les étages.
Déroulement du projet
Liste des tâches à effectuer
- Étude Électronique
- Étude de la communication infrarouge
- Évaluation de la faisabilité.
- Étude de la modulation/démodulation.
- Détermination du circuit électronique correspondant.
- Création de la carte Électronique.
- Étude de la communication infrarouge
- Étude informatique : programmation en C
- Communication infrarouge
- Émission des trames d’identification.
- Réception des trames et analyse.
- Programmation en C
- Implémentation de FreeRTOS dans l'Arduino.
- Contrôle des moteurs.
- Algorithmie primaire (suivre, s'orienter..).
- Programmation sur un moteur de jeu pour simulation (Unity3D : C#, ou Godot).
- Communication infrarouge
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 | Semaines de Fin | Total |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Analyse du projet | 6 | 4 | / | / | / | / | / | / | / | / | / | / | / | / | / | 10 |
| Étude de la communication infrarouge et des moteurs | / | 6 | / | 1 | / | / | / | / | / | / | / | / | / | / | / | 7 |
| Implémentation de FreeRTOS dans l'Arduino | / | / | 2 | / | 3 | / | / | / | / | / | / | / | / | / | / | 5 |
| Développement en C de la communication infrarouge | / | 3 | 2 | 4 | 1 | 4 | 4 | 8 | 8 | / | / | / | / | / | / | 34 |
| Programmation du contrôle des moteurs | / | / | 3 | / | / | / | / | / | / | / | 4 | 4 | 4 | / | / | 15 |
| Programmation de l'algorithmie des robots | / | / | 3 | / | / | / | / | / | / | / | / | 4 | / | 20 | 8 | 35 |
| Étude et Conception de la carte électronique | / | / | / | 1 | 5 | 4 | 6 | 3 | 4 | / | / | / | / | / | / | 23 |
| Soudage et tests de la carte électronique | / | / | / | / | / | / | / | / | / | / | / | 1 | 3 | 6 | 22 | 32 |
| Modélisation 3D du robot en CAD | / | / | 5 | 2 | 2 | 1 | 1 | 1 | 4 | 4 | 3 | 2 | 1 | / | / | 26 |
| Tests et montage du robot | / | / | / | / | / | / | / | / | / | 2 | 4 | 4 | 2 | 2 | 12 | 26 |
| Programmation pour simulation | / | 1 | 6 | / | / | / | / | / | / | / | / | / | / | / | / | 7 |
| Total | 6 | 14 | 21 | 8 | 11 | 9 | 11 | 12 | 16 | 6 | 11 | 15 | 10 | 28 | 42 | 220 |
Déroulement du projet
Semaine 2 : communication et moteurs, les débuts
Lors de cette première partie du projet, nous avons choisis de débuter avec la programmation du robot, ainsi que la modélisation du châssis destiné à l'impression 3D et la simulation de l'algorithmie sur Unity3D. De plus, nous avons débuté le développement de l’émission infrarouge et de l’algorithmie, ainsi que du contrôle des servomoteurs.
Arduino
La communication étant une partie importante du Projet, la programmation de l'envoi en série de l'identifiant du robot nous a paru prioritaire. Ici, nous avons testé en émettant bit par bit sur la LED L de la carte Arduino.
L'implantation d'un OS pour l'Atmega était aussi important afin de traiter les différentes tâches que le robot devra réaliser. Pour cela nous avons choisit FreeRTOS.
Moteurs et Algorithmie
Nous voulions aussi débuter la mise en place du programme de contrôle des moteurs et d'une base de programmation pour les robots, cependant peu de temps y a été accordé car nous avons vite réalisé qu'il faudrait se concentrer sur la partie électronique afin de fixer les paramètres liés aux différents composants.
Modélisation 3D
La conception du châssis du robot s'est fait sur le logiciel de CAD Onshape.
Cette semaine nous avons réalisé une ébauche afin de définir certaines règles de montage telles que la mise en place d'étages fonctionnels :
Le premier permettra le montage des moteurs et de la roue folle ainsi que de la pile.
Le deuxième accueillera la carte électronique.
Le dernier maintiendra les différents capteurs.
Nous avons alors réalisé l’augmentation de la difficulté de montage ainsi que de la fragilité du robot par rapport à un modèle composé d'un seul bloc. Cependant nous avons préféré continuer et le vérifier par les tests, au risque de modifications ultérieures.
Simulation
Le développement d'une simulation des robots et de leur comportement afin de les modéliser sous Unity3D est une idée qui nous a beaucoup plu a première vue.
Cependant nous nous sommes rendus compte rapidement que cela n'apporterait qu'une visibilité virtuelle, et peu d'avantages en pratique, le but final étant de réaliser les robots et non de les modéliser.
L'idée a donc été mise à l'écart.
Semaine 3 : communication et PCB, ça continue
La semaine 3 a été dans la continuité de la semaine 2. Nous avons ainsi avancé sur la programmation de la communication, mettant en place les bases de la création de la carte électronique.
Arduino
Une fois que l’émission a été réalisée, la programmation de la réception en série de l'identifiant semblait nécessaire.
L'ajout de bits de stuffing dans le message envoyé a aussi été choisi afin d'améliorer la lecture.
PCB
Afin de bien débuter la création de la PCB, nous avons d'abord récupérer le fichier existant pour pouvoir l'analyser et l'optimiser dans le cadre de notre projet. Pour cela nous avons donc dans un premier temps mis en place et pris en main l'environnement logiciel Fritzing.
Semaine 4 : Analyse et premiers problèmes
Arduino
La semaine 4 à montré les premiers vrais problèmes liés à l'Atmega et son OS, il a donc fallu corriger l'implémentation de FreeRTOS afin que le microcontrôleur puisse fonctionner correctement.
PCB
Une fois que l'étude de la carte électronique a été mise en place, la semaine 4 s'est révélé être le début des réelles modifications. Pour cela une analyse plus poussée afin de comprendre sa configuration pour ensuite la comparer à nos besoin avant de la modifier petit à petit.
Semaine 5(6,7) : On avance
Arduino
Retour sur le développement de la transmission par infrarouge avec la synchronisation de l'émission et de la réception des trames de données au travers des sémaphores.
PCB
Les prochaines semaines se sont déroulées dans la continuité de la semaine 5.
Semaine 8 : Début de la fin ou fin du début ?
La semaine 8 s'est révélée être la semaine des premières finalisations. En effet, autant la carte électronique que la modélisation 3D du châssis on pu être validées sous leur première forme et nous avons lancé les tests de création. Côté programmation il était aussi temps de passer à la pratique avec des tests sur les futurs composants du robot.
Arduino
On teste la transmission du signal Infrarouge :
Pour la réception, d'abord , il nous faut utiliser un capteur IR TSOP. Le capteur étant limité à 38kHz, nous avons donc la contrainte de modulation du signal afin qu’il puisse être reçu et lu. La fonction _delay_ms d’AVR a d'abord été choisie pour effectuer la modulation. Cependant il s’est avéré qu'elle avait une résolution trop faible pour pouvoir atteindre les 38kHz. Nous sommes donc passés par les TIMERS de l’Arduino. Sachant que le TIMER 1 est utilisé par FreeRTOS, nous avons donc utilisé le TIMER 0.
Pour pouvoir visualiser le signal émis, nous avons choisi de placer des LEDs classique en série avec les LEDs infrarouges. A l’émission, on observe bien un signal modulé mais il est impossible de savoir si il est à 38kHz, d’autant plus que la LED reliée au capteur ne semble pas s’allumer. Nous avons donc supposé que la fréquence du signal n’est pas bonne. Pour cela, nous allons donc utiliser un oscilloscope afin de visualiser le signal émis et reçu et ainsi savoir d'où vient le problème.
PCB
Au cours des dernières semaines, la modification de la carte a été une étape importante. Cette semaine marque la fin de l'étude PCB et sa validation. Le but ayant été d'optimiser la carte au fonctionnement d'un robot en essaim, nous avons retravaillé certaines parties telles que, par exemple, la séparation du câblage des TSOP, afin d’accéder à leur valeur en continu ainsi que de réduire les différenciations d'alimentation. Nous avons aussi supprimé la partie moteur afin d'obtenir un gain de place et de ne garder que les servomoteurs. Nous obtenons ainsi la version finale de la carte.
Dans les semaines à venir, nous pourrons donc réaliser des tests afin de savoir si cette validation est définitive.
Modélisation 3D
Au niveau du châssis, la première "version finale" a aussi été validée. Les cours de Mécatronique (filière SA) étant basés sur la modélisation 3D sur Onshape, le projet à été retravaillé intégralement afin d'offrir plus de possibilité. L'impression au FabLab sera réalisée au cours de la prochaine semaine afin de vérifier la solidité et la bonne conception de la pièce, ainsi que la facilité de montage, par exemple au travers des dimensions.
Sur cette image, nous pouvons donc observer la présence des trois étages, avec en bas les trous de vis afin de fixer les moteurs et la roue folle, ainsi que les maintiens de la pile 9V (à gauche), et de l'aimant (à droite). Au deuxième étage la forme de la plaque à été adaptée à la taille de la carte PCB et arrondie afin de permettre aux broches placées sur la face intérieure d'être accessibles. Sur la haut du robot, des emplacements ont été réalisés afin de maintenant les 3 TSOP, à l'avant (sur la droite de l'image) et sur les deux cotés, ainsi qu'un bloc de fixation pour le sonar (surélevé pour qu'il ne soit pas gêné par le capteur infrarouge à l'avant). Enfin un mur à été érigé à l'arrière afin de dirigé le flux de la LED infrarouge uniquement vers l'arrière.
La taille du robot est ainsi d'environ 80x80x80cm. Nous devons ainsi vérifier que cela ne pose pas de problème de montage, mais aussi d'équilibre. La pile étant à l'arrière et les moteurs à l'avant, le robot ne devrait pas se renverser, mais nous devons nous en assurer par l’expérience.
Semaine 9 : On atteint vraiment la pratique
La semaine 9 a été basée sur les tests. En effet, ayant pu imprimer en 3D la première version du robot, les dimensions de montage ont pu être vérifiées, et une deuxième version a pu être développée. De plus, nous avons pu réaliser de plus amples expériences sur la communication infrarouge.
Modélisation 3D et premiers tests de montage
La première version du châssis du robot ayant été imprimée en semaine 8, le nettoyage des plastiques de support a été réalisé durant la semaine 9, permettant ainsi une vision claire de la pièce créée sur Onshape. Cela fait, nous avons pu vérifier certaines dimensions et fonctions du châssis.
Par exemple l'emplacement de la pile ou la netteté de la fabrication approximative à cause des supports ainsi que l'emplacement des vis pour la PCB. Originellement prévue avec deux poteaux la maintenant en largeur, et deux barres fines en longueur (voir image semaine 8). Cependant cette configuration permettait une fixation parfaite de la pile, mais ne laissait aucune place pour son montage... Nous avons donc réalisé la difficulté de création d'une pièce aussi petite. Nous avons aussi pu vérifier la solidité de la pièce, qui paraissait fragile. Celle-ci montre une grande résistance pour un poids faible malgré sa composition de plastique non plein. Nous avons donc pu valider cette méthode de réalisation par rapport à des montages en pléxiglass, souvent peut solide du fait des nombreuses vis et liaisons pas réellement fixe, créant beaucoup de point sensibles sur la structure.
Afin de corriger le problème de montage de la pile, le "poteau" arrière (coté gauche sur la photo) à été remplacé par une barre fine de même type que les latérales, et l'emplacement de la pile à été légèrement creusé afin de la maintenir.
Les problèmes de support ont été réglés suite à une réévaluation complète de la pièce et de sa modélisation. Les parties nécessitant du support ont donc été retravaillées.
Par exemple, le premier étage a subi une réduction drastique de matière superflue de sorte à ne pas encombrer le dessous et réduire le poids total. Les structures de fixation verticales ont aussi été pensées afin de supporter cet étage au travers de demi-arches de maximum 20° d'orientation (angle à partir duquel l'imprimante 3D pose du support afin de maintenir la structure en place).
De plus, nous avons aussi choisi de fabriquer le deuxième étage à part afin de le monter plus tard grâce à des vis en l'encrant dans une empreinte spécialement creusé dans les poteaux de structure.
Les vis de maintient de la carte PCB ont été replacés par des tiges coupées afin de permettre une modularité accrue. Une empreinte creusée a aussi été réalisée pour bloquer la carte de façon plus précise et propre.
Transmission Infrarouge
Nous avons donc effectué les tests avec l'oscilloscope afin de visualiser le signal de la LED infrarouge, et plus précisément la fréquence de la porteuse.
Nous observons que la LED émet bien le bon signal. Donc nous en avons en déduit que le problème venait du récepteur. D'après la documentation technique, nous devions imposer un courant de 0,35 mA dans le récepteur. Le soumettant à une tension de 5V, il nous fallait donc placer une résistance de 14kΩ. Cependant après une étude du circuit interne du composant, il s'est avéré qu'une résistance était déjà installée. Nous avons donc enlever notre résistance qui limitait trop le courant dans le récepteur. De plus, la résistance interne étant montée en pull-up, on devait s'attendre à avoir '1' en sortie quand le capteur ne captait pas de signal et '0' quand il en percevait un.
Après réglage du capteur, nous obtenions finalement une réception du message. Il a fallu inverser la lecture des bits afin de les faire correspondre au comportement prévu préalablement. Nous avons ensuite rajouté les bits de stop et de stuffing dans le message envoyé. Nous avons également essayer d'évaluer la fréquence de la tâche d'envoi de message ainsi que celle de réception. Finalement, on obtient un identifiant correct toutes les 5 secondes environs.
Nous avions pensé utiliser l'intensité du signal reçu par le capteur afin de déterminer approximativement la distance du robot émetteur. Cependant, le capteur étant tout ou rien, nous ne pouvions l'utiliser comme capteur analogique.
Semaine 10
La semaine 10 s'est résumé en la continuation des tests sur le châssis imprimé en 3D ainsi que sur la carte électronique afin de se rapprocher de la finalisation du matériel. De plus,
Modélisation 3D et tests de montage
Les différents tests sur le châssis ont montrés quelques derniers détails importants à modifier sur le modèle 3D. Par exemple, un détail qui peut avoir son importance est la façon de fixer les moteurs et la roue folle sur le châssis. En effet, seules des trous de vis avaient été alors prévus sur la base de la pièce, mais aucune vérification de correspondance des orientations n'avait été réalisée. De ce fait, les vis-moteurs étant dans l'axe de rotation de la roue, celle-ci aurait été face au sol, ce qui est une méthode de déplacement peu conventionnelle et non choisie.
Nous nous sommes aussi rendus compte que les empreintes des vis sur la carte électronique ne correspondaient pas aux empreintes des fixations sur le robot, il a donc fallu réduire les écarts. Cependant, vu la disposition des poteaux de support pour la carte électronique, il a fallu aussi resserrer leur base, et donc empiéter sur l'espace de maintient de la pile et de son cache-câble. Pour palier à ce problème, nous avons donc du augmenter légèrement les dimensions du robot en largeur et en hauteur (la longueur à aussi été harmonisée). De plus, une couche à été ajoutée sous le robot au niveau e la fixation de la bille pour permettre au robot d'être à plat sur les trois appuis : roues et bille.
Nous avons aussi rajouté entre autre des maintiens sur la plaque supérieure afin de garder son empreinte sur les poteaux de la base.
Suite à cela, nous avons pu finaliser et imprimer en 3D la 2eme version du robot que nous allons tester dans les prochaines semaines en parallèle du soudage des composants sur la carte électronique.
Test des servomoteurs
Afin de déplacer le robot, nous utilisons des servomoteurs à rotation continue, donc asservis en vitesse. On les commande en modulation de largeur d'impulsion (PWM), avec une impulsion de 1 à 2 ms toutes les 20 ms. Nous avons ainsi programmé cette tache avec FreeRTOS. Avec vTaskDelay, nous attendions un temps t avec la sortie à 1 puis un second temps t2 avec la sortie à 0.
Vidéo des moteurs en marche Avant
Vidéo des moteurs en marche Arrière
Nous arrivions à avoir la rotation des moteurs. Cependant, nous n'arrivions pas à les contrôler en vitesse, ils étaient toujours à vitesse maximale. Après des études du code utilisé par FreeRTOS, il s'est avéré que la résolution définie par l'OS était de 1 ms. Il était donc impossible d'avoir une impulsion de 1 à 2 ms pour contrôler les moteurs en vitesse. Nous pouvions seulement mettre 1 ms ou 2 ms, ce qui correspondait à la vitesse maximale dans un sens ou l'autre.
Nous devions alors utiliser un autre timer de l'ATMega328p. Cependant, celui-ci n'en contentant que 3, deux de 8 bits et un de 16 bits, nous devions utiliser le dernier timer pour contrôler les 2 servomoteurs et le capteur à ultrason (on utilise déjà un timer de 8 bits pour la modulation infra-rouge et un de 16 bits pour FreeRTOS)
Semaine 11
Soudage des composants : l'apprentissage
Le début du routage des composants sur la carte électronique a été une phase d'apprentissage des techniques de soudage et d'utilisation des différents outils mis à disposition.
Tout d'abord, nous avons choisi, selon les conseil de M. Redon, de placer l’environnement du microprocesseur afin de réaliser la soudure au four.
Une fois la chauffe terminée, nous avons vérifié le bon fonctionnement du microprocesseur et de sa programmation au travers de broches externes ICSP.
Programmation des moteurs
Comme indiqué dans la semaine 10, on a dû utiliser un timer de l'ATMega pour contrôler les 2 servomoteurs. Les serveurs sont commandés en PWM, d'une pulsion comprise entre 1 et 2 ms, sur une échelle de 20ms.
Le timer étant de 8 bits, en divisant au maximum la fréquence du compteur, cela ne suffisait pas pour contenir 20 ms. Pour palier ce problème, on utilise une échelle de 10 ms ainsi qu'un booléen pour savoir si on est sur les 10 premières millisecondes ou sur les 10 dernières.
Si on est dans les 10 premières, on doit allumer les sorties correspondant aux moteurs. Puis on les éteint toujours dans ce cycle, l'un après l'autre. Pour savoir lequel éteindre, on utilise une liste dans laquelle on insère dans l'ordre d'extinction les pins à éteindre et l'instant moment.
Ainsi, on lit la 1ère cellule de la liste, si le compteur est supérieur ou égal à la valeur d'extinction, on éteint les pins associées, puis on supprime la cellule pour lire la prochaine extinction.
Avec ce système, on peut ainsi contrôler les moteurs en vitesse, mais aussi à les faire fonctionner à des vitesses différentes. Ce qui permet de faire tourner le robot.
Vidéo des moteurs à vitesses différentes
Semaine 12, 13
Les dernières semaines de travail ont été principalement axées sur le soudage de la carte électronique ainsi que de nombreuses impressions du châssis, non terminé suite à de nombreux bugs des imprimantes 3D.
De plus nous avons pu avancer sur la programmation du contrôle du robot.
Soudage des composants
Une fois l'environnement du microprocesseur routé au four, nous avons pu souder
à la main les composants manquant, toujours fonctions par fonctions
afin de limiter les risques de loupés.
Algorithmie des robots
A présent que l'on peut transmettre et recevoir des trames infrarouges, et faire tourner les moteurs comme on veut, il nous faut regrouper le tout.
1ère étape : Faire fonctionner la transmission infrarouge et les moteurs en même temps. Cela n'a pas posé de problème.
2nde étape : Faire fonctionner les 3 capteurs en même temps et faire se mouvoir le robot en conséquence.
Cette étape est celle qui nous a posé le plus de problèmes.
Faire fonctionner les 3 capteurs en même temps s'est déroulé sans encombre. Chaque capteur arrivait à recevoir les trames conjointement.
Ensuite, nous avons cherché à stocker les identifiants des robots captés et le numéro du capteur en question.
Dans un premier temps, on a mis en œuvre les fonctions permettant de gérer la liste des robots captés et une autre dans cette dernière qui regroupait les capteurs les ayant captés. C'est ici que les problèmes se sont posés. On obtenait des résultats incohérents avec suppression de diverses données. Même après une analyse approfondie, nous ne trouvions pas la cause du problème.
Il s'est avéré que cela pouvait être produit par un manque de mémoire. L'ATMega n'ayant aucune protection sur l'écriture des données, celui-ci écrasait des cellules mémoires quand elle était pleine. Après l'édition du code pour minimiser les données, nous n'avions plus de problèmes. Nous avons alors décommenté certaines lignes de codes. Mais nous n'arrivions pas à stocker l'identifiant capté.
En envoyant par le terminal "minicom" l'adresse de la cellule stockant l'identifiant, il s'est avéré que celle-ci était nulle, alors que l'on l'affichait juste après le "Malloc" correspondant. Cette fonction renvoie une valeur nulle quand la mémoire de l'ATMega est pleine ou quand la taille de la cellule est supérieure à la capacité de la mémoire.
En utilisant avr-size sur l'exécutable, on remarque que 85% de la RAM (1.7ko / 2ko) est déjà occupé avant même l'exécution du programme. Ceci est alors dû aux variables statiques du programme. Cependant nos programmes n'utilisent qu'une ou deux variables statiques. Ceci nous a permis de déceler que le problème est dû au FreeRTOS qui utilise énormément de variables statiques dont la plupart ne nous sont pas utiles dans notre cas.
Après avoir fait des recherches, nous n'avons pas réussi à réduire la taille consommée par FreeRTOS. Si nous avions eu plus de temps, nous aurions programmé notre propre ordonnanceur, ce qui aurait pu permettre de réduire de 70% la taille consommée.
Semaines supplémentaires
Montage du robot et tests finaux
Lors des dernières semaines de travail, nous avons assemblé les différentes parties du robot afin d'obtenir la version finale que l'on a pu présenter lors de la vidéo ainsi que lors de la soutenance.
De nombreux tests sur les différentes parties nous ont permis de vérifier la bonne fonctionnalité des capteurs ou actionneurs, et nous ont aussi confirmé quelques problèmes dévoilés lors de la programmation tels qu'un manque de mémoire flagrant de l'ATMega bloquant toute avancée algorithmique.
Les différentes informations récoltées nous ont permis de déterminer que la plus grande partie de la mémoire utilisée (85%) était destinée à l'OS implantée au début du projet, soit FreeRTOS.
Suite à cela, nous avons pensé à programmé un ordonnanceur afin de remplacer FreeRTOS au sein du microprocesseur et ainsi conserver de la mémoire pour le programme fonctionnel.
Cette solution s'est révélée satisfaisante, cependant le temps restant pour la finalisation du projet ne permettait pas une étude plus approfondie, de fait la vidéo, les rapports et une finalisation nécessaire du système demandaient eux-aussi un temps non négligeable a fournir.
Cependant cette solution serait à prendre en compte comme une option à courts termes pour l'avancée du projet. Elle permet un gain de mémoire conséquent pour une algorithmie simple, mais ne permet pas une extension assez grande sur un aspect longs termes de telle sorte à respecter au maximum le cahier des charges (mapping d'une salle, par exemple).
Documents Rendus
Fichier Fritzing de la carte électronique : Fichier:RobotPCB.zip
Fichiers STL du châssis : Fichier:STL.zip
Programmation du Robot : Programmation.zip
Rapport de Projet : Fichier:Rapport Etcheguibel Canu.pdf
