Un robot arduino de base

Dans le premier article de cette série, Un robot arduino, je racontais pourquoi je veux faire un robot de base, avec juste des roues, deux moteurs, des piles rechargeables et un arduino. Nous allons maintenant voir comment créer cette base. 

Mon objectif

Faire un robot ultra simple, qui exécutera un programme téléversé dans l’arduino, sans interactions avec l’utilisateur. Cette base évoluera ensuite vers des fonctionnalités plus avancées.

Le matériel

La structure

Pour la structure, j’ai utilisé des plaques, et des roues, d’un kit robotique Multiplo. On peut tout à fait imaginer une autre structure, éventuellement avec du bois découpé à la maison. Les seules contraintes sont :

• pouvoir fixer les moteurs associées aux deux grandes roues ;
• mettre une petite roue sur la face « arrière » pour que le robot tienne tout seul « debout » ;
• avoir du poids sur la petite roue pour que le robot ne tombe pas à la première accélération ;
• pouvoir accéder facilement au breadboard et à l’arduino.

Les composants du robot

Pour avoir des livraisons gratuites et simplifier ces livraisons, j’essaie de tout prendre sur la boutique Universal colors d’Amazon.fr.

• un arduino uno R3 ;
• une puce L293D (1.03 € sur amazon.fr)
• 2 condensateurs 1000uF 25V (50 pour 3.53 € sur amazon.fr)
• un « breadboard » (carte d’expérimentation) à 1.81 € sur amazon.fr
• connecteurs male – male arduino à breadboard (400 pour 1.67 € sur amazon.fr)
• connecteurs femelle – femelle arduino à breadboard (400 pour 1.37 € sur amazon.fr)
• 2 moteurs à courant continu (DC) ressemblant beaucoup à celui-ci, soir 5.16 € x 2.

Le coût total est donc de l’ordre de 22 € hors arduino et son cable USB.

Le circuit

Pour simplifier les schémas, j’ai fait d’une part un schéma montrant les alimentations des composants, d’autre part toute la partie commandes des moteurs. Evidemment, il n’y a qu’un seul arduino et un seul L293D !

Dans les deux schémas, le L293D est positionné avec sa petite encoche sur la gauche. Le pin 16 est donc en haut à gauche, comme dans le schéma ci-dessous :

schéma de montage

Une image statique :

La création sur 123d.circuits.io est beaucoup plus précise. Elle permet de voir directement sur le schéma les numéros de patte, sur arduino ou sur le L293D. Et lorsqu’on clique sur la simulation, on peut même voir les moteurs tourner comme ça se passe sur le robot !

Explication du circuit

explications branchements L293D

Le composant L293D est un driver de moteur à très faible coût. Il accepte des alimentations de 4.5 à 36V et peut envoyer 600 mA à chaque moteur. On peut l’utiliser avec des moteurs à courant continu comme ici ou avec des moteurs pas à pas.

On utilise ces drivers pour des moteurs trop puissants pour être branchés directement sur l’arduino. Le pont H permet de bien séparer le courant utilisé pour faire fonctionner les moteurs du courant utilisé pour transmettre les informations.

Le L293D a 16 pattes de connexion :

Dans mon montage, j’ai fait les connexions suivantes :

Wikipedia explique, en anglais, le fonctionnement d’un L293D.

Deux autres sources, en anglais (solar4schools en pdf et hardwarefun) , expliquent ce qui se passe selon les valeurs qu’on donne aux pattes input (2, 7, 10 et 15 du L293D) et aux pattes enable ( 1 et 9 du L293D).

Pour le moteur de gauche, on obtient le tableau logique suivant :

Notion de découplage et condensateurs

Dans le schéma électrique, partie alimentation, j’ai dû ajouter de condensateurs de découplage. Au départ il n’y en avait pas et le robot ne fonctionnait pas. L’arduino s’éteignait et redémarrait, les roues tournaient mais sans respecter le programme défini.

Au hasard d’une conversation, j’ai parlé de ce projet à un physicien retraité. Il m’a dit « découplage ! » et m’a parlé d’impédance interne aux alimentations, de condensateurs, de découplage. Je n’ai pas tout compris, loin de là. Mais en faisant des recherches sur internet (ici en anglais et là, aussi en anglais), j’ai compris que même si mon alimentation est stable, les changements rapides d’état dans mon montage provoquent des chutes de tension. Les condensateurs (capacitors en anglais) permettent d’accumuler de l’énergie et de la libérer pour compenser les chutes. J’ai donc mis deux condensateurs de 25V, 1000 micro farads (je les avais déjà et ça fonctionne, ne demandez pas pourquoi cette impédance…) entre le + et le – des piles d’une part, le + et le – en provenance de l’arduino d’autre part.

Les problèmes ont disparus. Je suis donc satisfaite du résultat obtenu avec ces condensateurs.

Pour info, un condensateur electrolytique a deux pattes de taille différentes. La patte la plus longue se branche au +, comme indiqué dans la photo à droite.

On notera que certains recommandent de mettre aussi des condensateurs entre les deux pattes de chaque moteur afin de prolonger leur durée de vie. Je ne le fais pas ici.

Programmation du robot

Pour le programme de départ, et une partie du montage, je suis partie de ce tutoriel en anglais, sur instructable amélioré par ce tutoriel, en anglais aussi.

J’ai fait les premiers tests en connectant directement les pattes enable du L293D au 5V. Mais dans ce cas, on ne dispose pas de variation de vitesse possible. J’ai donc préféré utiliser des trains d’onde (PWM) envoyer sous forme analogue aux entrées analogiques (~indiqué sur l’arduino) 10 et 11.

Le programme ci-dessous (dont on peut voir le fonctionnement en mode simulation sur 123d.circuits.io fait tourner le robot sur lui-même, dans le sens des aiguilles d’une montre puis à l’inverse.

Il n’a pas grand intérêt en tant que tel, autre que valider le montage et le principe de notre plate-forme robotique.

// moteur de gauche
int motorG_enable = 11; //pwm
int motorG_forward = 13;
int motorG_backward = 12;

// moteur de droite 
int motorD_enable = 10; //pwm
int motorD_forward = 8;
int motorD_backward = 9;
 
void setup()
{
 //on initialise les pins du moteur 1
 pinMode(motorG_forward, OUTPUT);
 pinMode(motorG_backward, OUTPUT);
 pinMode(motorG_enable, OUTPUT);
 
 //on initialise les pins du moteur 2
 pinMode(motorD_forward, OUTPUT);
 pinMode(motorD_backward, OUTPUT);
 pinMode(motorD_enable, OUTPUT);
 
}
 
void loop()
{
 
 SetMotorD(175, true); // 0 to 255, true marche avant, false marche arrière
 SetMotorG(255, false); // 0 to 255, true marche avant, false marche arrière

 delay(2500) ;
 
 StopMotors(200) ;

 // recommence dans l'autre direction
 SetMotorD(255, false); // 0 to 255, true marche avant, false marche arrière
 SetMotorG(175, true); // 0 to 255, true marche avant, false marche arrière 

 delay(2500) ;
 
 StopMotors(200) ;
}
 
//Fonction qui set le moteur de gauche
void SetMotorG(int speed, boolean reverse)
{
 analogWrite(motorG_enable, speed);
 digitalWrite(motorG_forward, ! reverse);
 digitalWrite(motorG_backward, reverse);
}
 
//Fonction qui set le moteur de droite
void SetMotorD(int speed, boolean reverse)
{
 analogWrite(motorD_enable, speed);
 digitalWrite(motorD_forward, ! reverse);
 digitalWrite(motorD_backward, reverse);
}

//Fonction qui arrête les 2 moteurs pendant une certaine durée
void StopMotors(int duree)
{
 // stoppe les moteurs
 digitalWrite(motorG_enable, LOW);
 digitalWrite(motorD_enable, LOW); 
 delay(duree) ;
}

Téléchargement de ce programme : programme du robot de base (ino) ou sur GitHub ici.

Notez que pour un programme plus élégant et plus efficace, on devrait s’inspirer de https://github.com/sudar/DCMotorBot après avoir lu l’article de l’auteur ici.

quelques précisions sur les PWM

Lorsque les pattes enable du L293D sont connectées directement au 5V de l’arduino, on ne peut pas ajuster la vitesse des moteurs, simplement leur direction (avant, arrière). Le train d’ondes PWM permet de moduler la vitesse du moteur. Ces ondes sont carrées. Pour plus de précisions, voir cet article sur le site d’arduino.

Dans mon programme, lorsque je régle le moteur à une vitesse de 255, c’est comme si j’envoyais du 5V en continu. Par contre, avec le réglage à 175, j’envoie des ondes carré qui sont à 1 pendant 175/255 % du temps et à 0 le reste du temps.

Conclusion

Ce qui m’importait, c’était simplement de vérifier que mon robot de base fonctionne. Et c’est le cas.

Et voilà, mon robot tourne sur lui même sans jamais s’arrêter !

Et le voici en vidéo :

Ma prochaine étape dans cette série d’articles Un robot arduino  sera de commander le robot par un téléphone android, en liaison bluetooth.