Version actuelle datée du 14 juin 2016 à 08:46

Cahier des charges

Encadrant

Blaise Conrard
Pour le projet, nous avons directement pris rendez-vous avec Blaise Conrard afin de discuter de nos idées.

Présentation du projet

Les kits Bioloid sont des kits robotiques programmables qui se basent sur les servomoteurs intelligents Dynamixel. Ces servomoteurs Dynamixel sont reconnus comme les servomoteurs les plus performants pour la robotique personnelle et éducative. Nous avons eu l'opportunité en IMA3 de développer des programmes sur ces robots via le logiciel RoboPlus et son interface type grafcet. Pour ce projet nous avons l'opportunité d'aller plus loin en programmant directement avec une carte Arduino.

Objectif

Le but de notre projet, est de de développer une application permettant à notre robot Bioloid, commandé par Arduino, d'écrire l'heure sur une ardoise magnétique.

Description du projet

Notre robot pourra être utiliser par toutes personnes souhaitant connaître l'heure. Il indiquera l'heure d'une façon originale, puisqu'il l'écrira, chaque minute, sur une ardoise magnétique. L'horloge robotique, rendra donc un service de type informatif. Par soucis de lisibilité et d'esthétique, le robot ainsi que l'ardoise seront fixés sur une surface plane (verticale ou horizontale). De plus, le robot sera positionné à moins de 10 cm en dessous de l'ardoise. Etant donné que la carte arduino devra être alimenté de 12 Volts, il est nécessaire de disposer d'une prise secteur et d'un transfo à proximité du robot.

Pour mener à bien ce projet, nous avons établi plusieurs contraintes, à savoir :

- L'heure est écrite de la même façon que les afficheurs 7 segments
- Le robot possède deux bras, l'un pour écrire et l'autre pour effacer
- Le stylo aimanté est fixé à un bras, tout comme le levier d'effacement

Afin de se faire une image plus représentative du projet, voici un croquis du robot :

Nous avons pu également fixer des limites de temps :

- Toutes les 60 secondes l'ardoise magnétique s'efface
- Le temps pour nettoyer la surface doit être relativement court, de l'ordre de 2 secondes
- Le robot doit écrire l'heure en moins de 50 secondes

Contraintes électroniques :

- Alimenter la carte entre 9-12V
- Utiliser un buffer 3 états afin que la liaison TX/RX ne circule que sur un bus de données vers le servo.

Notre Bioloid, sera donc composés de deux bras commandés par les servos-moteurs AX12, directement programmés par l'Arduino. Dans un premier temps, nous réaliserons des fonctions élémentaires afin de bien comprendre l’interaction entre l'Arduino et les servos, puis nous passerons à la réalisation de l'application.
Nous avons choisi de programmer à l'aide de l'IDE Arduino en C++ afin d'utiliser les éléments de la programmation objet, ceci dans le but d'utiliser les notions étendues du langage au sujet des instances, classes et fonctions.

Matériel nécessaire

Avancement du projet

Définition du sujet

Pour répondre à la problématique énoncé dans le cahier des charges, nous devrons définir une méthode de programmation intuitive pour commander les servos-moteurs en temps réel. Pour cela, nous programmerons directement l'arduino qui contrôlera les servos-moteurs.

Les différentes étapes du projet seront :

1) Adapter électriquement l'arduino aux servos-moteurs (alimentation,commande...)
2) Créer des fonctions pour commander les moteurs
3) Incorporer une gestion du temps
4) Réfléchir à l'application finale (fonctions, contraintes ...)
5) Réaliser cette application

Partie électronique

Pour ce projet, nous devons remplacer le CM5 par une carte arduino, ceci afin d'avoir des possibilités de programmation étendue. Avant toute chose , étudions les caractéristiques électroniques du CM5.

Après avoir étudié ces caractéristiques, nous avons remarqué que l'on pourrait directement passer par les ports RX et TX de l'arduino pour le contrôle des servos-moteurs, il suffirait juste d'ajouter un composant 74HC126D pour les contrôles alternatifs de TX et RX. En effet ce buffer trois états permettrait de faire passer alternativement Rx ou Tx en état d'haute impédance, ceci dans le but de n'avoir qu'une unique information sur le bus data vers le servo.

Enfin, pour ce qui concerne l'alimentation, nous avons remarqué en lisant les caractéristiques de l'AX12 qu'il était nécessaire d'avoir environ 9V pour une alimentation correcte. Nous avons donc conclu qu'il serait nécessaire d'utiliser un transformateur 9V pour alimenter l'arduino, celui-ci pourra ainsi délivrer 9V par l'intermédiaire du pin VIN.

Après étude des caractéristiques du buffer 74HC126, et par soucis de matériel, nous avons choisi de remplacer ce composant par un buffer non inverseur SN74LS241N. Nous avons réalisé les branchements entre l'arduino et les servos via ce composant en nous aidant de la datasheet du CM5. De cette façon, il sera possible de se substituer du CM5 et de commander directement les servos via l'arduino.

Nous avons effectué quelques tests en connectant les ports TX et RX de l'arduino sur les différentes entrées du buffer 3 états. Nous avons finalement choisi de brancher TX sur la partie non inverseuse et RX sur la partie inverseuse du composant.

Ce qui donne pour notre circuit, la figure ci-dessous :

Premières fonctions de commande

Une fois la communication entre l'arduino et les servos rendu possible, nous allons désormais chercher à créer des fonctions dans le but de commander les servos moteurs en position et en vitesse. La première étape consiste à créer un fichier header dans lequel nous définirons les adresses des servos-moteurs.
Nous créerons également une classe Dynamixel dans laquelle nous spécifierons les différentes variables et méthodes nécessaires au contrôle des servos.

Une fois les prototypes et classes déclarés, nous pouvons désormais passer à la programmation des fonctions de commande. Pour cela nous nous sommes d'abord renseignés sur la manière de commander le servo-moteur via notre code (sans passer par le logiciel Bioloid). Nous avons trouvé des informations très intéressantes sur un site dédié à l'Eurocop 2012 où quelques exemples d'utilisation des moteurs sont présentés. On y trouve notamment des informations sur la gestion du pin de contrôle de buffer en fonction des actions désirées et des fonctions utilisées.
Nous avons donc appliqués ces méthodes pour coder nos fonctions, celles-ci nous permettront de contrôler directement les servos en position et en vitesse.

De cette façon nous avons pu effectuer notre premier test. Nous avons choisi d'effectuer une rotation de 90 degres en aller/retour. Pour cela, étant donné que le moteur reçoit des consignes entre 0~1023 correspondant à 0~90°, on étalonne d'abord nos instructions via la fonction map. On choisit ensuite des délais d'attente de 3 secondes pour bien voir les rotations. Le test s'est avéré opérationnel, nous pouvons désormais réfléchir à la conception de l'horloge robotique.

Gestion du temps

L'un des points essentiels à la réalisation de notre projet, est la gestion du temps. Vous avez pu constater dans nos codes précédents, que nous utilisions la fonction delay() pour contrôler le temps. Or, cette approche n'est pas concevable pour notre horloge robotique, car la fonction suspend tout le programme pendant une durée définie, ce qui risquerait de décaler l'heure.

Pour pallier ce problème, nous avons 3 solutions:
- Le module RTC (Real Time Clock)
- Les interruptions
- La fonction millis()

Tout d'abord, l'une des solutions évidentes, est la mise en place d'un module RTC. Ce circuit intégré, qui se branche directement sur l'arduino, permet de connaître l'heure et la date à chaque instant. Cependant, ce matériel n'était pas disponible à Polytech Lille et relevait d'un prix assez élevé. C'est donc dans un soucis de rentabilité et d'économie, que nous avons décidé d'explorer d'autres méthodes.

Etant donné que nous souhaitions envoyer des tâches périodiques, l'utilisation des interruptions s'est proposée naturellement. Toutefois, pour le côté pratique, nous avons préféré écarter cette solution.

Il nous restait donc la fonction millis(). Cette fonction permet de connaître le nombre de millisecondes depuis que la carte à exécuter son programme. En jouant sur les sommes et les soustractions, nous avons réussi à compter chaque seconde. Cependant, au bout d'un certain temps, la fonction millis() ne s'incrémente plus. En effet, elle supporte une durée de 50 jours. Pour pallier ce problème, nous avons décidé d’implémenter une interruption qui permet, tous les 40 jours, de réinitialiser le programme via un reset logiciel.

Construction du robot

Les parties électroniques et informatiques étant opérationnelles, il nous faut désormais passer à la construction du robot. Pour cela, nous avons d'abord réfléchi à l'assemblage des servos et du matériel bioloid afin d'avoir un robot ayant une liberté de mouvement la plus complète. Après divers essais, nous avons finalement réussi à construire le bras en nous équipant de quatre servos_moteurs : un servo de base qui permettra de gérer horizontalement le bras et trois servos permettant une synchronisation horizontale. Enfin nous avons fixé le stylo au dernier servo pour pouvoir écrire sur l'ardoise.

De plus, nous avons trouvé une solution pour l'effacement des informations inscrites sur l'ardoise. Pour cela, nous nous sommes servis de deux servos moteurs situés de part et d'autre de l'ardoise. A l'aide d'une ficelle, nous avons fixés le levier d'effacement sur les servos qui par, des mouvements circulaires, seront capables d'effacer correctement l'heure toutes les 60 secondes.

Enfin nous nous sommes rendu compte que notre bras n'était pas stable lors de mouvements complexes, nous avons résolu le problème en modélisant une planche aux dimensions de notre robot à l'aide de la découpeuse laser au FabLab. Cette planche servira de support au bras et à l'ardoise.

Un aperçu de notre bras robotique une fois construit :

Application : horloge robotique

Et maintenant il est temps de passer à l'application finale, nous allons pour cela créer des fonctions de contrôle de servos permettant d'écrire sur l'ardoise. Ces fonctions seront gérés en temps réel via la gestion du temps conçu précédemment. Il suffira ensuite de gérer l'effacement toutes les minutes.

La première étape fût de choisir une position initiale,neutre au robot afin que celui-ci puisse ensuite se déplacer correctement. Nous avons ainsi fait en sorte qu'il soit placé au milieu juste au-dessus de l'ardoise.

Une fois cette position réalisée, nous avons, à partir des fonctions créés précédemment, créer quatre mouvement à partir du servo-moteurs de base, soit quatre différentes rotations. Ces rotations permettront au robot de pouvoir écrire sur les quatres différents quadrants de l'horloge à chaque nouvelle minute.

Ensuite, il a fallu développer une solution afin d'écrire toutes les heures possibles. Nous avons dû permettre au robot d'écrire les chiffres de 1 à 9 (leurs positions étant contrôlés par la fonction précédente).

Pour cela, nous avons créer des fonctions permettant de définir l'ensemble des mouvements possibles sur un 7-seg à partir d'une position fixe que nous avons choisi de placer en bas à gauche. De par ces différentes fonctions, il nous a été possible de créer les chiffres très simplement. Par exemple pour écrire 0, on utilise l'association d'un tiret_droite, de deux tirets vers le haut, d'un tiret à gauche et de deux traits descendants. Ce qui donne au niveau du robot : un placement en bas à droite puis une écriture sur les bons digits de notre 7-seg ainsi créé.

Par la suite, nous avons créer une fonction permettant d'écrire les deux points en synchronisant correctement les servos en position.

On obtient le rendu suivant après trois minutes écoulées :

Puis nous avons placé les deux servos dédiés à l'effacement de part et d'autre de l'ardoise en les fixant sur la planche en bois.

Enfin nous avons dû géré la fin de l'effacement des deux moteurs correspondants. Nous avions initialement eu comme idée de placer deux fins de courses de part et d'autre de l'ardoise afin qu'il détecte la fin de l'effacement. Malheureusement, ces composants étant indisponibles, nous avons placé deux boutons poussoirs. Ces boutons envoient une information à l'arduino dès que l'effacement est terminé, celui-ci peut ainsi stopper le mouvement des servos correspondants.

Fin du projet

Rapport

Le rapport est disponible ici : Fichier:Rapport P27.pdf

Le code-source est disponible ici : Fichier:Projet fonctions.zip

Conclusion

Bien que notre application ne soit pas parfaitement optimale, nous sommes tout de même satisfait de notre travail.
Nous avons parfaitement répondu au cahier des charges en adaptant une méthode de programmation par Arduino sur les servos-moteur bioloid.
Enfin, notre application fonctionne très bien malgré quelques petits défauts : absence de RTC, pas de fin de courses. Nous avons commis quelques erreurs sur la gestion du matériel de notre projet, ce qui n'est qu'expérience pour la suite.
Du point de vue pédagogique, ce projet nous a permis de mettre en pratique les connaissances que nous avions en électronique/informatique (gestion de micro-contrôleur, circuits électroniques) mais également de découvrir de nouvelles choses (C++,comportement de l'arduino).