Aller au contenu


Information tutoriel

  • Ajouté le: avril 12 2013 01:10
  • Date Updated: févr. 21 2015 05:30
  • Lectures: 29885
 


* * * * *
0 Notes

R.Cerda, Un robot Raspberry Pi pour 100-120€

Je vous propose un prototype de robot Raspberry Pi aux alentours d'une centaine d'euros (disons jusqu'à 120) tout compris. Ce tutoriel est fait pour que quelqu'un n'ayant aucune base puisse faire son robot, et le faire fonctionner.

Posté par sky99 on avril 12 2013 01:10
Description: Je vous propose un prototype de robot Raspberry Pi aux alentours d'une centaine d'euros (disons jusqu'à 120) tout compris. Ce tutoriel est fait pour que quelqu'un n'ayant aucune base puisse faire son robot, et le faire fonctionner.
Vous pourrez également trouver une version wiki en plusieurs pages distinctes de ce tutoriel, exportable en PDF, à cette adresse : 
http://nagashur.com/...e:r_cerda:start
R.Cerda, un robot Raspberry Pi à conduite différentielle - Partie 1/5 : Introduction et présentation du robot
Bonjour à tous! Dans ce post, je voudrais vous présenter mon second robot "officiel", cad qui a dépassé le niveau de prototype
de tests. Le précédent était basé sur un Arduino Uno, et m'a permis de comprendre les bases. Maintenant, celui ci est basé
sur un Raspberry Pi, et est une base qui permettra de faire bien plus.

Une petite démo du robot :



Ce robot utilise deux moteurs DC (à courant continu) commandés par des L293D interfacés au Pi par un MCP23017. Un MCP3008 permet de lire les entrées d'un capteur ultrasonique Maxbotix LV-EZ4.

Le principe général
Ce robot possède deux roues parallèles, entraînées chacune par un moteur électrique DC. On utilise deux puces L293D en parallèle pour commander individuellement les deux moteurs. Le MCP3008 ajoute un convertisseur analogique au Raspberry pi, et grâce à cela, nous pouvons détecter la distance aux obstacles frontaux en utilisant un capteur ultrasonique ou infrarouge. Il y a un MCP23017 pour ajouter des GPIO.
Un ball caster sert de troisième point de contact, et le robot peut ainsi se déplacer, tout en étant stable, avec un minimum de friction.

Il y a 5 batteries dans un compartiment pouvant en accepter 6. Cela sert à avoir une tension de 5 à 6V, qui alimente directement les moteurs.
Dans le même temps, le courant qui sort des batteries est régulé par un petit composant qui s'assure ainsi de fournir du 5V en sorte, de façon stable.
Cette tension est alors fournie au Raspberry Pi, qui peut alors commander les puces et les moteurs. On pourrait envisager deux sources d'alimentation,
une pour le pi, et l'autre pour les moteurs, mais c'est plus simple avec une seule. Le régulateur de tension que j'ai utilisé est très efficace, et ne gaspille donc que très peu d’énergie.

Le capteur ultrasonique est placé sur la face avant du robot, et indique la distance aux obstacles se situant dans l'arc frontal. Ainsi, le robot peut tourner pour les éviter.


Liste du matériel
  • Raspberry Pi modèle B, 512Mo - environ 30€;
  • Carte SDHC 16Go - environ 10€, une 4Go suffit;
  • Une clé USB Wifi - inutile pour le robot même, je m'en sers pour le programmer à distance 10€;
  • Deux moteurs DC avec rapport réducteur 180:1 - environ 8€;
  • Deux roues -~5€;
  • Un "ball caster" -~1€, mais je vous conseille plutôt celui ci, à 3€;
  • Deux puces L293D ~4€;
  • Un MCP23017 pour ajouter 16 GPIO ~2.5€;
  • Un MCP3008 pour ajouter un convertisseur ADC ~ 3€;
  • Un capteur de distance ultrasonique (Maxbotix LV-EZ4) ~20€, mais on peut aussi utililiser un capteur IR ~12€ ;
  • Un convertisseur de tension produisant du 5V ~4€;
  • Une trappe à batteries ~2-3€ en comptant le jack power;
  • 5 Batteries AA ~10€;
  • Quelques fils ~3€;
  • Des "Jumper Wire ~3€".
En pratique, on s'en sort pour 80 à 120€, selon les options, si l'on a déjà des batteries, etc.
Voici une photo de l'ensemble du robot, le module de commande n'étant pas fixé sur le module de propulsion:
Image IPB


Contrôle des moteurs
Les moteurs sont contrôlés par deux puces L293D. Les deux sont en parallèle, car elles peuvent fournir 600mA au maximum par canal, alors que les moteurs en demandent 800. J'ai donc connecté les deux puces en parallèle, elles peuvent ainsi fournir jusqu'à 1200mA par canal, ce qui est largement suffisant. Le Raspberry Pi est connecté à un MCP23017, qui ajoute 16GPIO, et le MCP23017 est connecté aux L293D. Dans l'absolu, on peut se passer du MCP23017, et connecter directement les L293D aux GPIO du Raspberry, mais j'ai choisi d'utiliser cette puce, car j'en ai au moins une pour chacun de mes Pi, et que cela permet d'envisager des extensions ultérieures, en ajoutant par exemples des boutons sur les coins pour détecter d'éventuels contacts.
On peut voir le montage ci dessous :
Image IPB

Capteurs et détection des obstacles
Le principe du fonctionnement est donc d'éviter les obstacles détectés. Pour cela, j'utilise un Maxbotix LV-EZ4, qui détecte les objets grâce à un faisceau à ultrasons entre 6 pouces (environ 15cm) et 6 mètres. Le Pi est connecté à un convertisseur analogique vers numérique (un MCP3008), qui permettra de récupérer les données analogiques du capteur de distance. Le capteur ayant une sortie linéaire, la mesure est directement proportionnelle à la distance.
La puce de gauche sur la photo du dessus est le MCP3008, et on peut voir le capteur de distance à ultrasons sur la photo suivante, à l'avant du robot:
Image IPB
A noter que le gros oeil rouge ne fait pas partie du robot, c'est simplement un autre Raspberry pi.



Alimentation électrique et autonomie
J'ai testé l'autonomie d'un Raspberry Pi modèle alimenté par 5 batteries AA et un convertisseur de tension efficate, et streamant un flux webcam en wifi. Vous trouverez plus de détails sur ce post sur un autre forum (lien externe). On obtenait 3-4 heures d'autonomie. Ici, si on garde la clé Wifi, la consommation devrait être approximativement la même, environ 800mA. La consommation maximale de chaque moteur est de 800mA, ce qui fait qu'en théorie, si les moteurs forcent au maximum en permanence, nous diviserons l'autonomie par 3, soit environ 1h à 1h20.

En pratique, on peut s'attendre à ce que les moteurs ne forcent pas à fond en permanence, donc en étant conservateurs, disons qu'ils seront à 50%.
Cela signifie que nous aurons donc 800mA de consommation pour les deux moteurs, donc un total de 1600mA. Les batteries étant données pour 2700mAh,
on obtient donc théoriquement 2700/1600=1h36minutes. En pratique, si on divise par 2 l'autonomie du pi tout seul, on obtient 1h30 à 2h d'autonomie théorique, donc ça colle assez bien.

Ici, je parle d'un scénario ou le robot roulerait en permanence... En pratique, on peut également s'attendre à ce qu'il ne se déplace pas tout le temps, s'il fait des tâches diverses. Dans ce cas, on gagnerait encore en autonomie. Mais on a une estimation de l'autonomie minimale
Vous pouvez voir sur les images suivantes (cliquables pour une version HD) les batteries et le convertisseur :

Image IPBImage IPB



Le programme
Le programme du robot est alors assez simple, puisqu'il s'agit de l'algo suivant :
boucle infinie :
distanceObstacle=lireDistanceCapteurUltrasons();
Si (distanceObstacle<8pouces) reculer;
Sinon Si (distanceObstacle<12pouces) tourner à gauche;
Sinon avancer;
Attendre(5ms);

Le code est fait en python, et le robot évalue les données toutes les 5ms.
L’étroitesse du faisceau cause quelques problèmes, il faudra sans doute adapter
les distances, ou monter le détecteur sur un servomoteur pour l'orienter.

Plan du tutoriel
Après cette présentation du robot, voyons le plan du tutoriel.
Nous verrons d'abord en page 2 comment choisir les composants du robot, et nous choisirons une configuration type.
Nous verrons ensuite en page 3 le schéma fonctionnel du robot, ainsi que le schéma de la partie électronique.
En page 4 nous détaillerons les instructions d'assemblage et des idées pour faire un châssis économique et solide.
Enfin, en page 5, nous programmerons notre robot qui sera alors assemblé.








=================================================================================================================
=================================================================================================================
=================================================================================================================

Partie 2 - Faire un robot simple mais extensible avec le Raspberry Pi : le choix du matériel
Dans cette partie, nous étudierons une liste de matériel, pièces, et alternatives possibles. Ce n'est pas le robot ultime, ni un cylon, mais un petit robot sympa, sur lequel
on peut se faire la main, et prévu pour pouvoir beaucoup évoluer. Notez bien qu'ici je vais vous présenter une longue liste de matériel, mais que je retiendrai une configuration pour la suite.
Si vous choisissez d'autres solutions, il y aura nécessairement un peu d'adaptation à faire, mais rien d'extrêmement compliqué.
Pour un robot simple, il faut:
  • un système de propulsion;
  • De quoi transformer la rotation des moteurs en mouvement horizontal;
  • un circuit de commande;
  • un système fournissant l'alimentation électrique;
  • éventuellement des capteurs.
Voyons donc ce qu'il faut en faisant "pas cher" (sachant que tout sera réutilisable).


1-Le système de propulsion : motorisation
On part sur un robot à conduite différentielle, c'est à dire disposant de deux moteurs. Pour avancer, les deux moteurs tournent dans le sens A, pour reculer ils tournent dans le sens B, et pour tourner on fait les deux tourner en sens inverse. On peut ainsi avancer, reculer, tourner à droite, et tourner à gauche.
En bref, il faut donc deux moteurs, ou tout autre système capable de tourner dans un sens ou dans l'autre. On a donc plusieurs solutions :
  • La récupération : les lecteurs CD/DVD possèdent chacun un petit moteur DC qui permet d'ouvrir/fermer le chariot, et ce moteur à une petite boite de vitesse. Mon premier robot, R.Berion, utilisait ce genre de systèmes. Il faut toutefois bidouiller un peu, mais c'est une solution qui permet de faire de la récup.
  • Des moteurs DC avec boite de vitesse : c'est une option durable et économique, ce genre de moteurs vaut environ 5$ pièce, donc on s'en sort pour 10$ sans compter les roues.
  • Des servomoteurs à rotation continue : on peut trouver des servomoteurs pouvant tourner à l'infini dans un sens ou dans l'autre. C'est la solution la plus chère, mais c'est extrêmement facile à contrôler, et on élimine le besoin d'avoir un circuit de commande supplémentaire. En revanche, chaque servo vaut environ 14$ sur Adafruit (soit une dépense nécéssaire de 28$), et ces servos ne peuvent pas servir à des usages classiques de servomoteurs, pour orienter un bidule quelconque, puisqu'on a plus d'informations sur l'angle ou est tourné le servo. Ils sont difficilement recyclables pour d'autres projets. D'autre part, on a finalement peu de contrôle sur chaque moteur, car on peut en gros les faire tourner dans un sens, dans l'autre, ou les stopper, mais pas trop contrôler leur vitesse de rotation (ou alors plus difficilement). En outre, il faut faire attention au sens de branchement, sous peine de les brûler. En revanche, ils ont pas mal de couple.
La solution de la récup est intéressante, le problème est donc de pouvoir fixer des roues dessus. Dans mon cas, j'ai trouvé un bout de plastique sur lequel je pouvais visser les roues de mes servos (dont j'avais grillé un des deux, et du coup avec un seul servo on ne peut pas trop avancer ^^). En revanche, comme c'est de la récup, rien n'interdit de coller un vieux CD sur l'axe de rotation pour faire la roue...
Et on peut ajouter un élastique sur le contour du CD pour faire un pneu et avoir un peu d'adhérence.

La solution des moteurs DC est ma préférée, car elle est économique, et pour le prix d'un servo, on a 3 moteurs DC, ce qui permet d'en avoir un de rechange par exemple, mais on peut facilement décider d'en prendre 4 ou 6 pour faire un véhicule à 4 ou 6 roues motrices. De plus, pour ces moteurs, il existe une très grande variété de roues et chenilles adaptées, et le système fait qu'on peut facilement changer les roues. Ces moteurs intègrent une boite de vitesse réductrice avec un rapport X:1, ce qui signifie que quand le moteur fait X tours, l'axe de la roue en fait 1. C'est très important, car sans cela, le couple serait trop faible,et le robot n'avancerait pas. Plus le rapport réducteur est important, moins les roues tourneront vite (et donc plus le robot sera lent), mais plus il aura de couple, et sera capable
d'emporter une charge importante/de continuer à avancer malgré des obstacles. Il existe des moteurs avec boite de vitesse metallique, mais c'est plus cher, au moins 15$ pour les plus petits (par contre, ils sont fatalement plus solides). Je conseillerais des "pololu plastic gearmotors" On en trouve principalement en 120:1 et 180:1. Prenez ceux qui ont le "3mm D-Shaft", il s'agit de l'axe du rotor, qui fait 3mm de diamètre, en forme de D. Prenez ceux qui ont l'axe en métal, ce sera plus solide. L'intérêt c'est qu'on a besoin de rien d'autre pour fixer les roues, et qu'en plus les roues s'enfoncent sur cet axe sans outil, et restent solidement en place. Et en plus il existe une très grande variété de roues adaptées à ces modèles. Je n'ai pas regardé pour les axes de 2mm, ni ceux en plastique. Et en plus, si plus tard vous décidez d'upgrader avec des "micro metal gearmotors", les roues seront compatibles. Pour moi l'idée c'est d'essayer de faire que tous mes robots puissent partager des éléments, ça rend la logistique plus facile Image IPB/>/>/>
 
Pour le choix du site, pololu a pas mal de bidules "robotique". En revanche, ils n'ont pas beaucoup d'autres catégories. Sur pololu, j'ai commandé uniquement mes moteurs et roues. Toutefois, Alpha-Crucis a les moteurs de pololu, leurs roues, mais également tout plein d'autres items. De plus, c'est un site français, qui vous expédie par colissimo, pour 5€ de FDP, et gratuitement au delà de 250€. Bien sur, pour les DOM, ça n'a rien à voir, mais ça reste modéré, avec 30€ de FDP pour une commande d'environ 250€, et je crois bien qu'ils m'ont décompté la TVA, ce qui revient au même (en Guadeloupe on est pas censés payer la TVA "normale", mais la douane peut prélever une taxe à l'arrivée. Toutefois, par colissimo et sur des montants de cet ordre, il ne le font presque jamais. En plus pour des composants électroniques, ça fait une facture avec des dizaines de références à petit coût, le douanier n'aura pas envie de lire tout ça pour calculer les taxes). Bref, j'ai commandé chez eux hier, et ils m'ont l'air vraiment bien, ça risque d'être mon second site apres Adafruit.Seul défaut, les fiches ne sont pas toujours complètes, mais le catalogue est énorme (ils ont AUSSI des trucs d'Adafruit!). Au passage, Snootlab va bientôt distribuer les produits pololu, donc encore une bonne source d'approvisionnement!

Enfin bref, ça fait 3.77€ par moteur sur Alpha-Crucis, ou 5.49$ par moteur chez Pololu. Il en faut au moins 2, donc ça fait 7.54€ pour les moteurs, ou 10.98$ sur pololu. Prenez en bien deux ayant le même rapport réducteur. Le "droit" ou "coudé", c'est à vous de voir. Le droit est plus long, mais moins large, le coudé c'est le contraire. Dans tous les cas, ça ne change pas grand chose, juste peut être l'organisation de l'espace. Moi j'en ai pris de chaque, mais j'aime bien les droits, parcequ'on peut facilement les coller sur le bord du châssis du robot sans avoir a découper le dit châssis. Mais on peut aussi fixer les coudés sous le châssis, sans faire de découpe... Bref, c'est un choix à faire.

2-Transformer la rotation des moteurs en mouvement du robot : transmettre la puissance à la "route".
Maintenant que nous avons des moteurs, il faut transmettre la puissance à la "route", pour faire bouger le robot. On a deux solutions simples :
  • Deux roues, qui seront accompagnées d'une troisième roue omnidirectionnelle (en fait, une bille dans un logement) qui servira de troisième point de contact -le nom anglais c'est "ball caster"-;
  • Des chenilles, qui sont auto-suffisantes.
Pourquoi choisir l'un ou l'autre? Les roues ont l'avantage d'être disponibles en de multiples dimensions, de 2-3cm de diamètre à presque 10. On en trouve des larges, des étroites, avec divers designs. Plus la roue sera grande, plus le robot ira vite. En revanche, le couple disponible sera moins important, puisque la distance à l'axe sera supérieure (le couple est exprimé en g-cm. Si votre moteur à un couple de 1kg-cm, il pourra faire tourner une charge de 1kg à 1cm, 500g à 2cm, etc.) Pour ma part, j'ai pris des roues de 4,6 et 9cm. Plus la roue est petite, plus le bas du robot sera proche du sol, et donc plus les obstacles pourront le bloquer. L'avantage de la roue est donc de pouvoir l'adapter au terrain visé, et pouvoir ainsi ajuster la vitesse/le couple du robot. L’inconvénient, c'est qu'il faut un troisième point de contact, le "ball caster". Et le ball caster franchit bien moins facilement les obstacles que les roues. Cependant, plus le Ball caster est gros, plus ça sera facile.
En face, les chenilles sont disponibles souvent en diverses longueurs, mais pas tellement pour des diamètres de roues différents. En revanche, la chenille est "tout terrain", et il ne faut rien d'autre que le kit de chenilles. Donc sur une surface irrégulière, et même avec des obstacles, la chenille pourra mieux se débrouiller. Elle devrait passer sans problème par dessus un gros câble d'alimentation de PC au sol, la ou la bille du ball caster pourrait rester bloquée. Et s'il s'agit d'aller sur du bitume, de la terre, ou autre, le Ball caster ne passera tout simplement pas. En revanche, la chenille sera sans doute plus lente, du fait du faible diamètre des roues d'entrainement de la chenille. De plus le système de chenille provoque une résistance, et réduit le couple disponible/augmente la puissance consommée pour un couple donné. Par contre la stabilité devrait être impeccable, et il n'y a presque aucun risque de se retrouver coincé.
Notez toutefois qu'avec 4 roues motrices, on évite la nécessite du Ball caster et on peut aller un peu partout, et franchir beaucoup d'obstacles avec de grandes roues. On peut également avoir 4 roues, dont deux motrices. Idéalement il faudrait que les roues non motrices puissent tourner, mais ça peut parfaitement fonctionner même si elles sont fixes.

En bref : en appartement, sur des surfaces relativement régulières, les roues et le ball caster seront plus efficaces, iront plus vite, et gaspilleront moins d'énergie que les chenilles. En revanche, celles ci sont plus adaptées au terrains difficiles, et peuvent franchir des obstacles divers facilement. De plus , si on a le kit de chenilles, il n'est pas nécéssaire d'acheter autre chose, et on a une surface de contact importante avec le sol pour transmettre la puissance, mais également une grande stabilité de ce fait. On risque peu de patiner, glisser, déraper... Sans compter le look "cool" des chenilles.

Donc, au choix :   
Des chenilles de 9cm de long, pour 8.91€ , et les mêmes chenilles de 9cm de long sur pololu pour 12.95$;
Des chenilles plus longues (12-15cm peut être) pour 10.28€ , et les mêmes chenilles longues sur pololu pour 14.95$;
 
Sachant qu'un seul kit est nécessaire, et contient les deux chenilles avec tout l'équipement qui va avec (les "roues" de 35mm d'entrainement et libres, les axes, etc), cela fait environ 9 ou 10€ selon la longueur souhaitée. Pour ma part, je pense qu'il faudrait idéalement que la chenille soit aussi longue ou un peu plus longue que le robot. Ainsi, la partie avant de la chenille peut entrer en contact avec l'obstacle, levant le robot, et permettant le franchissement. Si le bord du robot est devant la chenille, le bord pourra se coincer contre l'obstacle, et le robot ne pourra pas avancer.
OU BIEN
  • n'importe quelle paire de roues de cette section (donc pas les "idler sprockets", elles n'ont pas la fixation pour l'axe de moteur. Au mieux, ça peut faire des roues libres, si vous prenez également deux roues du même diamètre avec la fixation moteur, qui seront entrainées par les deux moteurs. Dans ce cas, vous aurez 4 roues dont 2 motrices, inutle de prendre le ball caster) . Les roues sont vendues par paire, inutile d'en acheter 2 fois Image IPB/>/>/>
  • n'importe quel ball caster de cette section (ou n'importe quel bal caster tout court!), sachant que les plus gros franchissent mieux les obstacles. Je penche pour les 1/2 pouce a 1 pouce.
Cela fait donc 7 à 10$ pour les roues selon la taille (une paire), plus 3 a 7$ pour le ball caster, soit 10 a 17$ pour une configuration complète de roues sur pololu.
Chez alpha-crucis, il faudra de la même façon prendre n'importe quel ball caster (roulette, en français, en fait!) de cette section, pour 2 à 6€;
et l'une de ces paires de roues :
 
De manière générale, les "Pololu wheels". Vérifiez qu'il y a le trou en "D" pour l'axe du moteur, de 3mm.
ça revient donc de 7 à 13.5€ pour les roues et la roulette. Les roues sont également vendues par paire. Pour le choix de la couleur, une couleur claire peut servir
à réfléchir un faisceau, ce qui pourra servir à faire un détecteur permettant de mesurer la rotation de la roue. Toutefois on peut aussi utiliser un faisceau de part
et d'autre qui sera interrompu par les montants de la roue s'il y en a... En pratique, on peut sans doute adapter n'importe quoi à n'importe quel système.
La couleur des roues peut également servir à reconnaitre les robots, ou si on a des roues de couleur différentes, à déterminer de quel coté on voit le robot
(dans une optique "computer vision", ou un algo analyserait avec openCV le flux d'une webcam, et pourrait identifier le sens dans lequel le robot se trouve par ex.
Mais on peut aussi mettre un autocollant différent de chaque coté, ou n'importe quoi d'autre.)

Si vous optez pour les servomoteurs à rotation continue, il faudra donc également prendre une roulette (n'importe laquelle ira), ou alors des roues libres.

3-Le circuit de commande, et des puces additionnelles facultatives
Nous avons des moteurs, des roues/chenilles adaptées, maintenant il faut commander tout cela. Pour appliquer l'algorithme de conduite différentielle, il faut un circuit capable
de faire tourner les moteurs dans un sens ou dans l'autre à volonté. Nous allons utiliser pour cela des circuits implémentant des ponts en H. On utilisera donc deux puces L293D
pour commander nos moteurs. Pourquoi deux? chaque puce L293D est donnée pour 600mA par canal. Les moteurs que nous avons sélectionné consomment jusqu'à 800mA
s'ils sont bloqués. En mettant les deux L293D en parallèle, on double la puissance disponible, avec du coup 1200mA par canal. On peut aussi prendre un seul L293D, et espérer
qu'il tienne le coup en cas de blocage des moteurs. ça devrait marcher, mais ce n'est pas un comportement garanti. Notez qu'en refroidissant les puces (un petit rad sur la puce)
on peut augmenter la puissance disponible, donc on peut également se contenter d'une puce mieux refroidie. Pour ma part, j'ai pris 2 puces pour avoir plus de puissance disponible,
et les puces étant peu chères, j'ai trouvé plus simple d'en prendre 2.

Il y a déjà un tutoriel sur l'utilisation de la puce L293D pour commander un ou deux moteurs avec le Raspberry Pi sur PCInpact (je le porterai sur ce forum plus tard). La seule différence est qu'ici nous mettrons les deux puces en parallèle. En pratique, le câblage sera le même, sauf qu'on ajoutera une seconde puce en connectant les pattes correspondantes des deux puces entre elles. Mais on verra cet aspect plus tard.

Si vous avez choisi les servomoteurs, ces puces ne sont pas nécessaires.
En pratique, il faudra donc :
  • Deux L293D pour 2.3€ pièce soit 4.6€ au total;
Il existe aussi les puces SN754410, qui sont compatibles broche à broche avec les LM293D (on peut donc utiliser exactement le même câblage d'après pololu). Dans la doc, je lis 1A de courant en sortie. Cependant, je ne parviens toujours pas à comprendre si c'est 1A au total, ou 1A par canal. Si c’est 1A par canal, alors cette puce permet de remplacer les deux L293D dans notre montage, si c'est 1A au total, elle n'a aucun intérêt par rapport aux L293D. J'en ai pris 3, mais je ne les ai pas encore testées. Vous pouvez tenter, si vous comprenez mieux la doc que moi, faites moi signe. j'écrirai à Pololu pour leur demander. Sinon dans le doute, les L293D, je peux vous confirmer qu'elles fonctionneront pour le circuit, pour les avoir testées sur 3 prototypes de robots. Mais si vous commandez chez pololu, seule la SN754410 est disponible, et du coup je vous conseille d'en prendre au moins 2 pour être sur (deux en parallèle, et pourquoi pas une troisième au cas ou, en stock).
Dans tous les cas, le schéma de câblage sera le même.

Ajouter des GPIO au Raspberry Pi (optionnel, mais pratique, facile, et peu coûteux)
Sur le schéma que je vous fournirai dans un premier temps il y aura également une puce MCP23017, qui permet d'ajouter 16GPIO (je ferai un second schéma simplifié sans cette puce). Il est possible de se passer de cette puce, le souci c'est que les puces de contrôle des moteurs utilisent 5 à 6 GPIO sur les 17 du Pi. Avec le MCP23017, on utilise 2GPIO spécifiques, qui restent de plus utilisables par d'autres puces, et on ajoute ainsi 16GPIO protégés, pouvant qui plus est fournir plus de courant que les GPIO normaux. Cette puce ne coûte pas très cher, puisque le MCP23017 est à 2.88€ sur Alpha-Crucis. Si cette puce est trop grosse,
mais que vous voulez quand même utiliser ce principe (ajouter des GPIO protégés), il est possible d'utiliser un MCP3008, qui coute 1.95$ sur Adafruit et ajoute 8GPIO et moins de pattes.

J'ai fait un tutoriel sur le forum de PCInpact sur l'ajout de GPIO au Raspberry Pi en utilisant le MCP23017 ou le MCP23008.

Ajouter un circuit convertisseur analogique-numérique pour lire des capteurs analogiques (optionnel, mais très pratique, simple et économique)
De même, sur le schéma d'un robot de base, je vais utiliser une puce MCP3008, qui permet d'ajouter 8 entrées analogiques au Raspberry Pi. Cette puce n'est pas nécessaire,
et on peut faire un robot télécommandé/contrôlé à distance/utilisant une webcam pour se déplacer, de sorte que le robot n'aura pas de capteurs analogiques à lire.
Toutefois, je recommande fortement cette puce, car le MCP3008 est à 3.22€ sur Alpha-Crucis, et pourrait permettre d'ajouter une grande variété de systèmes extrêmement utiles. Par exemple,
un capteur de distance pour détecter automatiquement les obstacles, mais aussi un capteur infrarouge orienté vers le sol devant le robot, qui permettrait de détecter les trous
pour éviter de tomber dedans, ce qui peut être utile même en contrôle manuel. On peut imaginer toutes sortes de capteurs qui permettraient au robot de s'adapter automatiquement
à diverses situations, ou même tout simplement un capteur de courant pour que le robot puisse mesurer sa consommation, on peut utiliser la puce pour mesurer la tension
des batteries et estimer l'autonomie restante, ou encore utiliser des capteurs divers pour mesurer le nombre de rotations des roues, un accéléromètre, gyroscope ou autres
pour avoir des infos sur le déplacement du robot... Bref, une puce très utile, rajoutant donc 8 entrées analogiques, en échange de 4GPIO.

Il y a un tutoriel sur la façon de connecter un MCP3008 au Raspberry pi pour lire des valeurs analogiques sur le forum de PCinpact, et d'autres tutoriels montrant comment connecter des capteurs dessus (luminosité (lien externe), température (lien externe), distance (lien externe), ...)

4-L'alimentation électrique de l'ensemble
Maintenant, il faut alimenter le Raspberry Pi, mais également les moteurs. Pour cela, il faudra une source électrique de 5V, stable, pour le Raspberry Pi, et
une source de 5 ou 6V non régulée pour les moteurs. On aura besoin d'une puissance de 700mA au minimum pour le Pi, et 800mA au maximum par moteur,
soit 1600mA au maximum pour les moteurs. Il nous faut donc une source capable de débiter 2300mA ou plus. Avec des piles AA rechargeables, il nous en faudrait 5
de 2300mAh ou plus. avec des piles non rechargeables, 4 suffiront. Si on alimente tout avec des piles rechargeables, il faudra un régulateur de tension pour le Raspberry Pi.
La meilleure option que j'ai pu trouver jusqu'ici, c'est le régulateur S7V7F5 de chez pololu, qui vaut 4.95$, et est une petite merveille. Il peut fournir du 5V à partir de tensions allant de 2.7 à 11.8V. Si il fournit une tension supérieure à la tension d'entrée, il peut fournir 500mA. Si il baisse la tension, il fournit 1000mA. Il est réellement minuscule, et ne consomme rien (0.1mA) quand il ne fait rien. Son efficacité énergétique est de 90%, ce qui veut dire qu'il ne gaspille que 10% de l’énergie fournie pour la conversion.Dans le même style, chez Alpha-Crucis, il n'y a malheureusement que le D15V35F5S3, pour 10€. Il est bien plus cher, et ne peut réguler la tension qu'à la baisse, mais a toujours une
efficacité de 90%. Il est un peu plus gros, mais en échange peut fournir jusqu'à 3.5A. On peut donc imaginer s'en servir pour réguler une batterie plus grosse et plus puissante,
et fournir 5V au pi, aux moteurs et à tout autre système 5V.

Une autre solution, très économique, mais peu efficace, est d'utiliser un simple régulateur linéaire, comme le 7805, à 1.2€ sur Alpha-Curcis, très simple a utiliser, mais nécessitant une tension d'entrée plus importante (7V au moins) et gaspillant une partie plus importante de l'énergie, puisque la différence de tension entre l'entrée et la sortie est consommée avec le même courant que ce celui qui est consommé en sortie. Donc à 1A, pour une entrée de 7V, on consomme 2W pour la régulation, et cette énergie est gaspillée en chaleur. La puissance utile disponible est donc de 5W, ce qui fait qu'on gaspille 40% de l'énergie.

On peut également utiliser une source 5V et se passer des régulateurs, comme nous le verrons plus bas.

Il faudra alors un endroit ou mettre les batteries, par exemple:

    Un compartiment pour 6 batteriesAA, qu'on modifiera un peu pour n'en utiliser que 5, pour 4€
    Un compartiment pour 2 batteries AA en série avec un compartiment pour 3 Batteries AA, pour un peu moins de 3€ au total.

Il existe une dernière solution, c'est d'avoir une batterie régulée 5V, telle que celle ci sur Alpha-Crucis, pour 22€. Elle peut fournir 5V avec 2A en sortie, ce qui sera assez pour à la fois
alimenter le pi et les moteurs dans la plupart des cas. Il manque 10% de puissance, mais ça devrait passer. J'en ai commandé 2, je ferai l'essai. Toujours en utilisant cette batterie, il est
également possible d'ajouter une trappe de 4 Batteries AA pour l'alimentation des moteurs (non régulée), et d'alimenter le Pi avec la batterie 5V régulée. Dans les deux cas, on se passe
du régulateur de tension. L'utilisation d'un pack de 4 Batteries AA permet de séparer les deux sources d'alimentations, et c'est en théorie mieux. L'intérêt de la batterie régulée, c'est
qu'elle utilise des batteries au lithium qui sont plus légères à capacité égale. On gagne donc sur la masse du robot, et on peut sans doute démonter la batterie pour enlever le panneau solaire, et
la coque pour réduire la taille si on veut. Attention toutefois au batteries, celles au Lithium étant fragiles et dangereuses quand on les malmène.

Il y a un post décrivant un montage utilisant des batteries AA et un régulateur de tension pour alimenter un Raspberry Pi autonome, ainsi que des tests d'autonomie (lien externe).

5-Les capteurs
On peut se passer de capteurs, et télécommander le robot. On peut également utiliser une webcam pour analyser les images et se déplacer ainsi (plus complexe, il faut maitriser openCV ou autres librairies de vision informatique)
Il est cependant possible d'ajouter des capteurs simples, tels que des capteurs de distance en infrarouge, ou à ultrasons, pour détecter les obstacles Le cout sera de 10 ou 20€.
On peut également utiliser des poutons poussoirs pour faire des capteurs de contact. n'importe quel bouton poussoir fera l'affaire, mais certains sont plus adaptés, tels que ceux ci :
 
    Microswitch avec levier long, pour environ 1.25€
    Microswitch avec levier à roulette, pour 1.6€.
 
Avec deux de ces switches, on peut détecter de quel coté se trouve l'obstacle, et ainsi éviter les obstacles. Pour ces switches, on a pas besoin d'utiliser le convertisseur analogique, uniquement des entrées numériques.
On peut ensuite ajouter de nombreux autres capteurs, par exemple pour détecter les trous, avec un capteur infrarouge à faible portée, un accéléromètre, un gyroscope pour le guidage inertiel, etc...

On peut également trouver des capteurs purement numériques, dont certains utilisent par exemple le protocole I2C pour communiquer. Dans ce cas, on utilisera pas le MCP3008.

Voici au passage un petit récapitulatif sur les divers capteurs les plus courants.
Il y a également un tutoriel sur la lecture d'un bouton poussoir (pour les microswitches), et un autre tutoriel sur l'utilisation d'un capteur de distance ultrasonique ou infrarouge.

Récapitulatif
En fin de compte, voici des "packs" mis a jour, récapitulant le matériel nécéssaire.
Il nous faut bien sur un Raspberry Pi, des jumper wire, une breadboard, une carte SD avec Raspbian (ou autre) dessus, et le câble d'alimentation. Je ne reviendrai pas
la dessus, si vous en êtes à faire un robot, c'est que vous avez déjà probablement ces composants et sans doute déjà essayé divers montages. Passons donc maintenant
aux éléments spécifiques au robot.

Robot de base, avec moteurs DC et chenilles
Il nous faudra donc :
 
    Deux puces L293D - 4,5€
    Deux moteurs DC 120:1 ou 180:1 - 7.5€
    Un kit de chenilles - 10€
    Un circuit à d'alimentation 1-10€
    Une boite à batteries AA - 2€
    5 Piles AA rechargeables - 10€
 
Ces composants sont les composants minimaux pour faire ce robot à chenille. En l'état, il n'aura pas de capteurs, et ne pourra donc être que télécommandé.
On a donc un total de 44€ au maximum si l'on compte les batteries AA. Une autre solution est de remplacer le circuit d'alimentation, la boite à batteries et
les piles rechargeables par une batterie portable USB, ce qui revient à 22€, soit un total d'exactement 44€.

Robot de base, avec moteurs DC et roues+roulette
On conserve le même matériel que pour le précédent, sauf qu'on remplace les chenilles par des roues et une roulette :

    petites roues larges 42*19mm - 5€
    roulette d'un demi pouce, en plastique - 3€

Du coup on passe a 42€.
On peut utiliser de plus grandes roues :

    grandes roues 90*10mm - 7€
    roulette de 0.75 pouces en métal - 3.3€

Pour cette variante, le prix reste à 44€.

Options
Voyons maintenant quelques options intéressantes, qui seront utilisées pour le prochain tutoriel :

    Le MCP3008 pour lire les valeurs de capteurs analogiques, +3.22€
    Le MCP23017 pour ajouter 16GPIO protégés, + 2.88€

Ces deux puces extrêmement utiles augmenteront la facture de 6.1€, ce qui nous fait un total de 50€.
On peut enfin ajouter des capteurs :

    deux Microswitch avec levier long, pour un total de +2.5€
    Un capteur de distance Ultrasonique +20€ ou à infrarouges, +10€
On ajoute donc 22.5€ ou 12.5€ pour un grand total de 72.5€ au maximum (62.5€ en infrarouge, 52.5€ avec juste les capteurs de contact).

A partir de là, vous avez tout le matériel nécessaire à la construction d'un robot (plus ou moins autonome selon les capteurs), et pour chaque élément utilisé, il y a un tutoriel dans (ce fil de discussion (lien externe)). Je vais toutefois faire d'autres tutoriels, spécifiques, reprenant dans les grandes lignes ce qu'il faut faire pour monter ce robot, le programmer, et l'améliorer.


La partie suivante sera consacrée au schéma de principe du robot, et au schéma de montage électronique.




=================================================================================================================
=================================================================================================================
=================================================================================================================
Partie 3/5 : schéma de principe et montage électronique du robot.
Nous allons maintenant détailler le principe général du robot, avant de voir le schéma électronique.
Nous reprenons donc les pièces dont nous avons parlé juste avant, dans la seconde partie.

Pour ce modèle, nous partons sur un robot à deux moteurs (roues ou chenilles, le montage électronique est le même!
Pour cet exemple, le robot sera représenté avec des chenilles, mais le principe est valable pour 2 roues motrices et deux roues libres,
deux roues motrices et une roulette, ou des chenilles. L'important est que les roues motrices doivent être entraînées par des moteurs DC.)

Principe de fonctionnement
Voyons maintenant le principe de fonctionnement général. Pour cela, voici un schéma fonctionnel :
Image IPB

Le Raspberry et l'alimentation
Nous avons donc un Raspberry Pi, modèle A ou B. L'alimentation électrique provient d'une source 5V régulée depuis 5 Batteries AA. Cela nous permet d'avoir entre 5 et 6V (selon la charge des batteries) pour le moteur, et 5V pour le Raspberry Pi. Il est bien sur possible d'utiliser deux sources séparées, ou toute autre configuration compatible avec vos moteurs.

Le MCP23017 : plus de GPIO.
Le Raspberry Pi est connecté à un MCP23017 via le bus I2C, et rajoute 16GPIO. Cela nous permet de prévoir large, et de pouvoir étendre les capacités du robot.
On pourra ainsi, par exemple, ajouter des bumpers (boutons poussoirs) pour détecter les collisions. Comme nous avons 16 GPIO, on peut donc en mettre une bonne quantité, d'autant que ces capteurs sont peu chers.

La commande des moteurs : les L293D
Deux puces L293D sont branchées en parallèle, et connectées à 5 ou 6 broches du MCP23017 (dans le schéma, je connecterai à 6 broches. Cela permet de pouvoir faire fonctionner séparément un moteur ou l'autre. De base, ce n'est pas utile, et on peut commander l'activation des deux moteurs avec un seul GPIO, et simplifier légèrement la programmation. Toutefois, utiliser deux GPIO nous permettra de programmer plus précisément les déplacements, la rotation, et par exemple ajuster la vitesse de chaque roue indépendamment).
Les L293D sont connectés via 4 fils aux deux moteurs, et les commanderont par ce biais. Au passage, les batteries sont connectées directement aux L293D (sans régulation donc) pour fournir le +Vmotor, la tension qui sera appliquée aux moteurs.

Lecture de capteurs analogiques : MCP3008.
Le MCP3008 est connecté au Raspberry par le bus SPI, et permet d'ajouter 8 entrées analogiques. Nous pourrons donc lire les valeurs de 8 capteurs analogiques de cette façon. En pratique, pour ce modèle, nous utiliserons un capteur ultrasonique Maxbotix (cela fonctionne avec d'autres capteurs ultrasoniques), mais il est possible d'utiliser un capteur de distance infrarouge avec le même montage, et un code source sensiblement similaire. Le capteur de distance sera utilisé pour détecter les obstacles. Si toutefois vous décidez d'utiliser uniquement des switchs pour la détection de contact, le MCP3008 n'est plus nécessaire.

Schéma électronique du robot
Voyons maintenant le schéma électronique du robot, décrivant le câblage à réaliser pour faire fonctionner notre robot:
Image IPB
Si vous suivez ce câblage, vous disposerez d'un robot fonctionnel. Une seule chose n'est pas présente sur ce schéma : la méthode utilisée pour mettre les deux L293D en parallèle. Pour cela, il suffit de connecter la patte 1 de la puce A avec la patte 1 de la puce B, et ainsi de suite pour les 15 autres pattes. C'est assez simple à faire avec du jumper wire. Cela permet de cumuler la puissance disponible pour les deux puces.

Il est à noter qu'il s'agit d'UN schéma de câblage possible, mais on peut utiliser n'importe lesquels des GPIO du MCP23017. J'ai utilisé ceux que vous voyez sur le schéma afin de faire en sorte que celui ci soit le plus lisible possible, en minimisant les croisements.

Je ne détaillerai pas outre mesure les câblages, car il s'agit simplement d'une synthèse de tutoriels (liens externes): =================================================================================================================
=================================================================================================================
=================================================================================================================
Partie 4/5 : montage pratique du robot : construction d'un châssis, fixation des roues, etc.
Matériel et matériaux nécessaire
Poursuivons donc sur la configuration précédente. Dans cet exemple, on utilisera deux roues et une roulette.
Avant tout résumons le matériel :
  • Un Raspberry Pi;
  • Une grande breadboard ;
  • Deux L293D;
  • Un MCP23017;
  • Un MCP3008;
  • Un Maxbotix LV-EZ0, 1, 2, 3, ou 4 , ou bien un capteur infrarouge, ou tout autre capteur de distance (facultatif, si vous utilisez uniquement les capteurs de contact);
  • Du fil électrique (pour électronique, pas du gros câble);
  • Une trappe pour 6 batteries AA;
  • Deux roues;
  • Une roulette;
  • Une carte SD;
  • Du jumper wire;
  • un convertisseur DC-DC fournissant du 5V
  • Une planche de bois d'environ 20cm*15-20cm;
  • Une petite planchette pour visser la roulette (récupérez une chute, par ex un bout de 5*5cm);
  • Des vis à bois de 3mm de diametre, et de 12-20mm de long;
  • Deux petites plaques de plexi, plastique, ou n'importe quel matériau que vous pourrez coller sur les moteurs;
  • un câble micro-USB;
  • Un adaptateur power jack-USB (on peut s'en passer si on couple le câble USB pour accéder directement aux fils +5v et à la masse);
  • Un power Jack (on peut également s'en passer dans le même contexte);
  • Deux switches pour les capteurs de contact (facultatif, si vous n'utilisez que le détecteur à distance).
Pour les outils, il nous faudra :
  • Un tournevis;
  • Des ciseaux ou une pince à dénuder/pince coupante;
  • Potentiellement un fer à souder et de l'etain, mais on peut faire sans en torsadant les fils entre eux;
  • De la colle adaptée pour coller les moteurs à leurs supports (j'ai utilisé de la super glu, pour coller le corps en plastique du moteur au plexi).
  • Éventuellement une perceuse si vous prenez des plaquettes de plexi, en bois on peut visser sans percer.
Nous avons maintenant tout ce dont nous pouvons avoir besoin, on peut commencer le montage.

Installation des roues et de la roulette.
La première étape sera de coller les petites plaques sur le corps des moteurs, comme sur ces photos :
Image IPB Image IPB
Vous pouvez voir que dans mon cas, j'ai utilisé du plexiglas, et il y a deux trous qui permettront de fixer le moteur sur le châssis.

Pour le châssis, j'ai simplement pris une planche de bois. On peut voir sur l'image ci dessous que j'ai tracé un trait permettant de
placer les deux moteurs au même niveau, et également un trait perpendiculaire au milieu pour centrer la roulette.
Image IPB
On peut alors visser les moteurs sur le châssis :
http://nagashur.com/...537-300x194.jpg

Pour la roulette, nous allons d'abord visser le support de la roulette sur une planchette, avant de mettre la bille de la roulette en place et de visser la planchette sur le châssis:
http://nagashur.com/...538-150x150.jpg http://nagashur.com/...539-150x150.jpg http://nagashur.com/...540-150x150.jpg http://nagashur.com/...541-150x150.jpg

L'installation des roues sur les moteurs est très simple, car l'axe des moteurs à un profil en D, et il y a un trou de la forme correspondante au centre de la roue.
Il suffit donc d'enficher la roue sur l'axe. On peut donc facilement installer et changer les roues facilement:
http://nagashur.com/...542-300x300.jpg http://nagashur.com/...543-300x221.jpg http://nagashur.com/...553-300x188.jpg
Le moteur est soudé à des fils, avec au bout un connecteur femelle de "jumper wire". J'ai simplement pris deux câbles femelle-femelle, et je les
ai coupés en 2. Il suffit de dénuder le bout coupé, et de le fixer sur le moteur, idéalement, en le soudant.




Partie électronique
Passons maintenant à l'installation des divers éléments électroniques sur l'autre face du châssis.
La breadboard principale contient le régulateur de tension, avec les fils partant vers les batteries, et le jack de sortie,
le MCP23017, le MCP3008, et les deux L293D. Des câbles partent également vers les moteurs, les capteurs, et le Raspberry Pi.
Image IPBImage IPB
Sur l'image de gauche, on voit l'ensemble de la breadboard, et sur celle de droite, on peut voir la méthode utilisée pour
mettre en parallèle les deux L293D : des fils rigides connectent les pattes d'une puce à celle de l'autre. J'ai utilisé une bobine
de fil de fer gaîné pour réaliser ces connections.

Pour fixer la plaque, j'ai utilisé 4 vis à bois, vissées directement dans le bois du châssis. Elles sont vissées de part et d'autre des ergots sur le haut
de la breadboard, de façon à la caler horizontalement. Deux vis en bas bloquent la breadboard dans le sens vertical, de sorte que maintenant celle ci
ne bouge plus :
Image IPBImage IPBImage IPB

On fixe maintenant le Raspberry Pi lui même sur le châssis, en vissant celui ci avec deux vis, en passant par les deux trous prévus à cet effet sur le Raspberry Pi:
Image IPB
On peut maintenant fixer le logement des batteries AA sur le châssis. On notera que sur les 6 emplacements, l'un d'entre eux ne contient pas de batterie,
mais un fil à la place, ce qui permet d'obtenir du 6V au lieu d'avoir du 7.2V. Le logement est vissé au châssis par deux vis, par les trous prévus à cet
effet:
Image IPBImage IPB
Il nous faudra également un câble jack vers USB et un câble micro-USB:
Image IPB
Cependant, il est également possible de couper le câble USB, et d'accéder directement aux fils +5V et masse. Dans ce cas, l'adaptateur USB-PowerJack et le jack power mâle sont superflus.


Les capteurs
Passons maintenant à l'installation des capteurs.
Le capteur à ultrasons est simplement vissé sur la face avant du châssis, et les capteurs de contact sont vissés sous le châssis.
Les boutons poussoirs qui servent de détecteurs de contact possèdent des trous par lesquelles peuvent passer les vis servant à les fixer :
Image IPBImage IPBImage IPB

Le tout en place
On peut voir sur les images ci dessous la disposition des éléments lorsque l'ensemble est en place:
Image IPBImage IPBImage IPB
On note sur la photo de droite que les diodes d'état, et la diode de la clé wifi sont visibles depuis le dessus du robot.

Option Webcam
On peut également ajouter une webcam, sur l'un des ports USB. Pour cela j'utilise une petite équerre en acier, vissée sur
le châssis, sur laquelle la webcam s'accroche :
Image IPBImage IPB













=================================================================================================================
=================================================================================================================
=================================================================================================================
Partie 5/5 : Programmation d'un robot Raspberry Pi R.Cerda pour une exploration automatique avec évitement d'obstacles.
Il est maintenant temps de transformer cet assemblage de matériel en un vrai Robot. Pour cela, nous allons maintenant voir l'ultime étape : la programmation. Nous verrons trois algorithmes, du plus simple au plus avancé. Cela devrait vous permettre d'avoir une base pour programmer votre robot comme vous le souhaitez, et pourquoi pas quelques idées Image IPB/>

Commençons tout de suite, en rentrant dans le vif du sujet. Ce robot utilise le MCP23017 pour commander les L293D qui à leur tour commandent les moteurs. J'ai donc choisi python pour écrire le programme des robots, puisque c'est sur cette base que nous avons vu l'utilisation du MCP23017.
En premier lieu, voici le lien vers le GitHub ou je met les divers fichiers relatifs au code du robot Cerda.

Dans ce dépot, vous trouverez divers fichiers, donc la classe I2C d'Adafruit, et la classe permettant de gérer le MCP23017.
Assurez vous d'avoir ces deux fichiers dans le répertoire contenant les fichiers de votre robot, ils sont nécéssaires pour son fonctionnement,
et doivent être importés dans le script du programme de votre robot.
Vous noterez également un script robotStop.py, qui sert simplement à arrêter les moteurs du robot. Sur mon raspberry pi, j'ai fait un alias de ce script vers la commande stop, ce qui fait que je peux arrêter le déplacement du robot en tapant stop dans un terminal, n'importe ou.

Divers scripts sont présents, pour tester divers éléments : N'hésitez pas à tester vos capteurs avant de lancer le robot, pour vérifier si tout va bien. J'intégrerai également ultérieurement des scripts pour tester les moteurs.

Passons maintenant au programme principal du robot lui même. Voyons d'abord vite fait l'algorithme :
dans une boucle infinie, on répète les instructions suivantes :
Lire la distance mesurée devant le robot par le capteur à ultrasons.
Si cette distance est inférieure à 8 pouces, on recule.
Sinon, si cette distance est inférieure à 16 pouces, on tourne,
Sinon, on avance.

Et c'est tout! Ce simple algorithme suffit déjà à permettre au robot d'éviter des obstacles!
Cet algorithme est implémenté dans le programme r1.py, dont la source se trouve sur le GitHub.

Je vais détailler un peu le code. Au début, vous verrez tous les "import", qui récupèrent les fonctions nécéssaires.
En dessous, vous retrouverez notre fonction "readadc", que nous avons vue avec le MCP3008 (le tuto sur cette puce est disponible ici), qui nous permet de lire une entrée analogique (ici le capteur à ultrasons) sur les 8 que propose le MCP3008. Voyez donc ces deux liens pour plus de détails sur le sujet. En dessous viennent les variables définissant les broches utilisées pour le SPI; je vous renvoie encore aux précédents tutoriels pour plus d'explications. SI vous avez suivi les schémas de montage de R.Cerda, il n'y a rien à changer ici.

Vient ensuite le corps du programme à proprement parler. Vous verrez alors une série de fonctions, dont la fonction "readDistanceInch", qui permet de récupérer la distance en pouces plutot que la valeur brute. SI vous utilisez un autre capteur, il faudra adapter (ou bien utiliser la valeur brute, en faisant des essais). Les fonctions suivantes servent à commander directement le robot :
def moveForward(m1a,m1b,m1e,m2a,m2b,m2e):    
mcp.output(m1a, 1)    
mcp.output(m1b, 0)    
mcp.output(m1e, 1)    
mcp.output(m2a, 1)    
mcp.output(m2b, 0)    
mcp.output(m2e, 1)
Cette fonction par exemple permet mettre les broches de commande du moteur 1 à 1 et 0, la broche enable à 1 pour activer ce moteur, et idem pour le moteur 2. J'ai fait ces fonctions, car si le câblage change, il suffira de modifier les valeurs dans ces fonctions plutot que dans le main. De la même manière, on a une fonction pour reculer, arrêter les moteurs, tourner à gauche, et à droite.
Cette fonction ne définit pas la durée pendant laquelle vous voulez faire une action. Une fois que vous appelerez l'une de ces fonctions, le robot continuera à exécuter cet ordre jusqu'à ce que vous l'arrêtiez. Ce qui veut dire que si vous souhaitez avancer d'une petite distance, vous devrez faire:
moveforward(...)
time.sleep(X)
stopMotors(...)


Plus bas, je définis les broches sur lesquelles sont connectés les détecteurs de contact, et deux fonctions pour lire leur valeur. En pratique, ces fonctions retournent 0 si le contact n'est pas pressé, et 1 si il est pressé, au lieu de 0 si le contact est pressé, et une valeur non nulle dans le cas contraire.

Les broches du MCP23017 qui commandent les deux moteurs sont définies juste en dessous, et on peut alors mettre les broches en sortie pour les moteurs, ou en entrée pour les détecteurs de contact.[/left]
Passons maintenant au corps du programme en lui même :
try:
#boucle principale et infinie du moteur
while (True):
#lecture de la distance de l'obstacle le plus proche
d=readDistanceInch(0, SPICLK, SPIMOSI, SPIMISO, SPICS)
#en dessous de 8 pouces, le robot recule pendant au moins 0.2s
if(d< 8):
    moveBackward(m1a,m1b,m1e,m2a,m2b,m2e)
    #time.sleep(0.2)
#entre 8 et 16 pouces, le robot tourne pendant au moins 0.2s
elif(d<16) :    turnLeft(m1a,m1b,m1e,m2a,m2b,m2e)
    time.sleep(0.2)
#le reste du temps le robot avance pendant 0.05s
else :
    moveForward(m1a,m1b,m1e,m2a,m2b,m2e)
time.sleep(0.05)
    except KeyboardInterrupt:
print "" print "stopping motors"
stopMotors(m1a,m1b,m1e,m2a,m2b,m2e)
print "motors stopped, exiting."
sys.exit(0)
Vous noterez un bloc try et un bloc except. La partie dans "try" est le code du robot à proprement parler.
Il s'agit de l'implémentation de l'algorithme décrit plus haut. On notera toutefois que j'ai introduit un délai quand le robot tourne, pour l'obliger à tourner au moins d'un certain angle. Comme mon robot est large et avec des angles proéminents, ça lui évite de coincer ses coins sur les bords de l'obstacle. La durée d'attente dépend de votre robot, à vous de tester!
Dans tous les cas, avant de recommencer, j'ai mis un temps d'attente de 50ms, à vous de voir si ça vous convient également. C'est une attente que j'ai mise qui correspond à la fréquence de rafraîchissement du capteur de distance que j'utilise.

Le bloc "except KeyboardInterrupt" sert à gérer le CTRL+C qu'on utilise pour quitter le programme. Dans la précédente version, il n'y avait pas ce bloc, et du coup, quand on faisait CTRL+C pour arrêter l'exécution de l'algorithme, le robot restait bloqué sur la denrière instruction, par exemple, avancer, jusqu'à ce qu'on lance la commande robotStop.py.

Ici, il arrêtera les moteurs avant de quitter le programme.

Voici en pratique ce que donne cet algorithme sur mon R.Cerda, sur youtube[/url].


La seconde version de ce code, r2.py, cette fois, tient compte des capteurs de contact, qui sont prioritaires sur le capteur à ultrasons (si un contact est détecté, alors le robot recule, puis tourne dans la direction opposée, quoi que dise le capteur à ultrasons).
Le reste du code est le même qu'avant.

Voici maintenant d'abord le second algorithme tel que décrit ici[/url].[/left]


Nous avons également une troisième version, r3.py, qui introduit le fait qu'au lieu de toujours tourner à droite, le robot tourne un certain nombre de fois du même coté, puis commence à tourner dans l'autre sens pour éviter les obstacles. Il compte comme "tourner d'un coté" comme l'action continue entre le moment ou il commence à tourner et le moment ou il arrête de tourner. Cela évite qu'il fasse des allers retours de gauche à droite.
Mais également la version qui change de coté au bout d'un moment : .




Enfin, la dernière version du robot, r4.py est la plus évoluée. On intègre tout ce qui a été fait avant, mais cette fois ci, quand le robot détecte un obstacle avec le capteur à ultrasons entre 8 et 16 pouces, il tourne à gauche, mesure la distance de ce coté, tourne à droite, mesure la distance de ce coté égalment, et choisit de tourner du coté ou la distance est la plus grande. Pour éviter face à des obstacles équidistants de tourner à gauche puis à droite en boucle, le robot tourne dans la direction qu'il à choisie jusqu'à ce que l'obstacle soit au delà de la distance de 16 pouces. Encore une fois, cela donne de bons résultats, car sur un obstacle rectiligne, le robot tournera du coté ou le mur "s'éloigne", donc choisira le coté ou il a le moins à tourner. Pour certains obstacles, il peut ne pas prendre la décision optimale (obstacle semi circulaire par exemple), mais ne se retrouvera pas bloqué.
Voici une vidéo illustrant le fonctionnement de cet algorithme :


Je ne l'ai pas encore uploadée, manifestement, mais ça sera bientôt fait. Dans une prochaine mise à jour, j'intégrerai le code.
Si des versions plus avancées sont développées, je ne les décrirai pas forcément, mais je les enverrai sur le GitHub. en général j'essaie de faire du code commenté, et clair.

N'hésitez pas à me faire part de vos remarques et questions dans les commentaires, ou en MP Image IPB