Hack-micropython-Robot2Wheel-Code

MCHobby investit du temps et de l'argent dans la réalisation de traduction et/ou documentation. C'est un travail long et fastidieux réalisé dans l'esprit Open-Source... donc gratuit et librement accessible.
SI vous aimez nos traductions et documentations ALORS aidez nous à en produire plus en achetant vos produits chez MCHobby.

Installer

Vous pouvez télécharger la bibliothèque et les codes d'exemples directement depuis le dépôt GitHub du PyBoard-a-roulette

Télécharger PyBoard-a-Roulette.zip

Vous aurez besoin d'installer/copier les fichiers sur votre PyBoard:

hbridge.py
r2wheel.py

Copiez les fichiers hbridge.py et r2wheel.py dans le répertoire racine de votre PyBoard.

Maintenant que hbridge.py et r2wheel.py sont installés sur votre PyBoard, nous allons pouvoir passer à la suite.

Avant de tester

Assurez-vous d'avoir suivit les instructions de montages proposées ici.
Placez vos piles dans le bloc pile pour disposer de puissance moteur.
N'alimentez pas le votre PyBoard via le bloc pile (le switch).
Assurez-vous d'avoir branché votre PyBoard sur votre ordinateur (et installé les fichiers hbridge.py et r2wheel.py ).
Démarrer une session REPL avec votre PyBoard pour tester notre montage.

Tester les pont-H

Avant de nous lancer dans les choses vraiment intéressantes, nous allons commencer par commander directement nos pont-H avec la classe HBridge. C'est une bonne façon de tester nos raccordements.

Souvenez-vous, nous avons branché l'un de nos pont-H sur les sorties X6 et X5 (input 1 et 2). Nous utilisons aussi la broche X3 pour le contrôle de l'entrée Enable du pont-H (pour moduler la vitesse).

Petit rappel avec le schéma des broches, si nous utilisons la sortie X3, nous devons choisir le Timer et Channel approprié pour pouvoir créer un signal PWM.

from hbridge import HBridge
MOT1_PINS = ( pyb.Pin.board.X6, pyb.Pin.board.X5 )
MOT1_PWM = {'pin' : pyb.Pin.board.X3, 'timer' : 2, 'channel' : 3 }

Voila, nous avons défini nos broches de commandes dans le tuple MOT1_PINS et les informations de la broche PWM dans MOT1_PWM pour le contrôle de la vitesse.

Nous allons pouvoir créer l'objet Pont-H pour le commander.

h = HBridge( MOT1_PINS, MOT1_PWM )

Nous allons pouvoir tester les méthodes de base:

forward() pour la marche avant
backward() pour la marche arrière
halt() pour tout arrêter.

Laissez un peu de temps entre chacune des commandes pour pouvoir constater les effets sur votre mobile.

h.forward()
h.backward()
h.halt()

Vous pouvez maintenant tester votre deuxieme pont-H avec les commandes suivantes:

MOT2_PINS = ( pyb.Pin.board.X7, pyb.Pin.board.X8 )
MOT2_PWM = {'pin' : pyb.Pin.board.X4, 'timer' : 5, 'channel' : 4 }        
h2 = HBridge( MOT2_PINS, MOT2_PWM )
h2.forward()
h2.backward()
h2.halt()

Contrôle de vitesse

Le contrôle de la vitesse est relativement simple. Nous utilisons une signal PWM (par exemple, la broche X4 sur le deuxième pont-H).

Comme le signal PWM est branché sur la broche enable du pont-h, le pont-H sera activé/désactivé en même temps que le signal PWM.

Crédit: AdaFruit Industries www.adafruit.com

En modulant le cycle utile entre 0 et 100% du signal PWM, on module aussi puissance délivré au moteur par le pont-H :-)

Nous allons donc revoir notre programme de commande du deuxième pont-h pour contrôler la vitesse moteur.

from hbridge import HBridge
from pyb import delay
MOT2_PINS = ( pyb.Pin.board.X7, pyb.Pin.board.X8 )
MOT2_PWM = {'pin' : pyb.Pin.board.X4, 'timer' : 5, 'channel' : 4 }        
h2 = HBridge( MOT2_PINS, MOT2_PWM )
for speed in range( 0, 100, 10 ):
    h2.backward( 100-speed )
    delay( 1000 )
    h2.halt()

L'instruction for speed in range( 0, 100, 10 ) permet de faire varier la vitesse entre 0 et 100 par pas de 10.

Ensuite l'instruction h2.backward( 100-speed ) active la marche arrière et passant graduellement de la vitesse maximale à la vitesse minimale.

Tester la plateforme avec Robot2Wheel

Les mouvements en image

Faire avancer le robot

Nous allons maintenant utiliser la classe Robot2Wheel pour contrôler le Robot deux roues avec les raccordements mentionnés dans ce tutoriel, les broches à utiliser étant déjà mentionnées dans la classe.

Allons y:

from r2wheel import Robot2Wheel
r2 = Robot2Wheel()
r2.forward( 80 )
r2.halt()

Dans cet exemple, nous avons demandé à la plateforme d'avancer à la vitesse de 80% avec r2.forward(80) .

Vous l'aurez compris, pour passer la marche arrière, il suffit de...

r2.backward()

Un moteur tourne dans le mauvais sens!

Si vous avez l'un ou l'autre de vos moteurs qui ne dans le mauvais sens... c'est que celui-ci est branché à l'envers sur le pont-H.

Solution:

Inverser le raccordement sur le moteur pour qu'il tourne dans le bon sens
Faire la même chose mais de façon logicielle.

Vous pouvez inverser la commande de l'un OU l'autre OU des deux pont-H durant la création de l'objet Robot2Wheel... voici les différentes syntaxes à votre disposition.

r2 = Robot2Wheel( reverse_mot2 = True )
r2 = Robot2Wheel( reverse_mot1 = True )
r2 = Robot2Wheel( reverse_mot1 = True, reverse_mot2 = True )

Dans le cadre de mes tests, j'ai utilisé r2 = Robot2Wheel( reverse_mot2 = True ) pour corriger la rotation de l'un de mes moteurs.

Tourner à droite

Pour tourner à droite, il y a la méthode turn(), cette méthode peut prendre plusieurs paramètres.

Nous allons commencer simplement, nous allons faire tourner la plateforme 2 roues sur place... en faisant tourner un moteur dans un sens et l'autre dans l'autre sens.

r2 = Robot2Wheel( reverse_mot2 = True ) # inverser la commande du moteur moteur
r2.turn( Robot2Wheel.RIGHT_ROTATE )
r2.halt()

Vous pouvez également indiquer une vitesse moteur durant la rotation.

r2.turn( Robot2Wheel.RIGHT_ROTATE, speed=60 )

La plateforme tourne dans le mauvais sens!

Vous avez demandé au robot de tourner à droite... et il tourne à gauche?!?!?

C'est parce que les deux moteurs sont montés à l'envers.

Il y a plusieurs options pour corriger cela:

Démonter les deux moteurs pour placer le moteur de gauche à droite (et vice-versa).
Echanger les raccordements des deux moteurs sur les pont-H (passer un moteur d'un pont-h à l'autre, et vice-versa).
Faire la même chose mais de façon logicielle.

Nous avons prévu un paramètre supplémentaire lors de la création de Robot2Wheel pour échanger le moteur1 et moteur2 de façon logiciel.

r2 = Robot2Wheel( fix_rotate = True )

Après cela, la plateforme tournera dans le bon sens.

Tourner dans tous les sens

Nous avons prévu deux façons de tourner... histoire de pouvoir:

Soit tourner sur place : idéal pour les déplacements dans les labyrinthes
Soit négocier un virage : plus important pour les suivi de tracés... ou négocier des parcours avec la meilleure optimisation possible

Tourner sur place

Plus approprié dans le déplacement dans les labyrinthes, ce type de virage permet de tourner dans un espace minimum.

C'est aussi le plus simple à appeler. La méthode standard est turn() avec soit le paramètre Robot2Wheel.LEFT_ROTATE Robot2Wheel.RIGHT_ROTATE.

Comme pour la marche avant/arrière, vous avez la possibilité d'indiquer une vitesse (par défaut c'est 100%).

from r2wheel import Robot2Wheel
from pyb import delay
r2 = Robot2Wheel( reverse_mot2 = True ) # inverser la commande du moteur moteur
r2.turn( Robot2Wheel.RIGHT_ROTATE )
delay( 1500 ) # pendant 1.5 secondes
r2.forward()
delay( 5000 )
r2.turn( Robot2Wheel.LEFT_ROTATE, speed=80 )
r2.forward()
delay( 5000 )
r2.halt()

Vous pourriez obtenir le même résultat avec les méthodes right() et left().

from r2wheel import Robot2Wheel
from pyb import delay
r2 = Robot2Wheel( reverse_mot2 = True ) # inverser la commande du moteur moteur
r2.right()
delay( 1500 ) # pendant 1.5 secondes
r2.forward()
delay( 5000 )
r2.left( speed=80 )
r2.forward()
delay( 5000 )
r2.halt()

Les virages

Il est également possible de négocier un virage, technique plus appropriée pour le suivi de tracé... ou négocier des parcours avec la meilleure optimisation possible.

La technique est simple, il suffit de ralentir le moteur du côté où l'on désire prendre le virage... l'autre moteur restant à vitesse plus élevée, le trajectoire du mobile va inévitable suivre un arc de cercle.

Plus la différence de vitesse est grande et plus le rayon de courbure est petit (donc virage plus serré). Ce parcours en arc de cercle signifie que l'on circule sur le périmètre d'un cercle... si le mobile poursuit son parcours suffisamment longtemps... il dessinera un cercle.

Ce cercle à un centre et il y a donc un rayon entre le centre et votre plateforme robot.

Dans l'exemple suivant, nous allons entamer un virage à droite Robot2Wheel.RIGHT_BEND. Pour cela, nous allons ralentir le moteur droit de 40% (speed=40) par rapport au moteur gauche.

Lorsqu'il n'y a qu'un seul paramètre de vitesse, ce paramètre speed mentionne la différence de vitesse entre les deux moteurs.

from r2wheel import Robot2Wheel
from pyb import delay
r2 = Robot2Wheel()
r2 = Robot2Wheel( reverse_mot2 = True ) # inverser la commande du moteur moteur
r2.turn(Robot2Wheel.RIGHT_BEND, speed=40)
delay( 15000 )
r2.forward()
delay( 5000 )
r2.halt()

Il est également possible de contrôler la vitesse du mobile durant un virage en précisant 2 vitesses. Lorsqu'il y a deux vitesses mentionnées: la vitesse globale du mobile est précisée avec speed, puis la différence de vitesse entre les deux moteurs dans speed2.

from r2wheel import Robot2Wheel
from pyb import delay
r2 = Robot2Wheel()
r2 = Robot2Wheel( reverse_mot2 = True ) # inverser la commande du moteur moteur
r2.turn(Robot2Wheel.LEFT_BEND, speed=70, speed2=40)
delay( 15000 )
r2.forward()
delay( 5000 )
r2.halt()

Dans l'exemple ci-dessus, nous tournons à gauche avec une vitesse globale du mobile de 70% et une différence de vitesse de 40%. Le moteur droit fonctionne donc à 70% et le moteur gauche à 70%-40%, soit 30%.

Voila!

Corriger la dérive

Qu'est-ce que la dérive

Deux moteurs d'un même fabricant et d'un même modèle ne sont jamais totalement identiques.

La raison? d'infimes différences provoqués par les processus de fabrication, les jeux (différents d'un moteur à l'autre) mais aussi l'alignement des moteurs sur votre plateforme robotique. Dans le même ordre d'idée, un pneu plus usé que l'autre aura un diamètre légèrement inférieur... et parcourra une distance légèrement inférieur à chaque tour de roue. Les moteurs sont donc identiques mais pas tout à fait!

Dans la vie réelle, les deux moteurs ne tournent pas exactement à la même vitesse... il y en a toujours un qui est un poil plus lent. De même, les deux roues n'étant pas rigoureusement identiques, elles ne parcourent pas exactement la même distance à chaque tour de roue. Même si cette distance est inférieur à 1/10mm, au bout de 500 tours, cela fait quand même une différence de 50mm (5 cm)... par rapport à l'autre moteur.

Voila, vous venez de découvrir la cause de la dérive... et comme vous pouvez le constater, son effet ne se fait ressentir que sur des distances relativement importante.

Comment corriger la dérive

La solution consiste à ralentir le moteur qui est trop rapide (ou parcours trop de distance), c'est pour cela que nous avons besoin du contrôle PWM... pour pouvoir contrôler la dérive.

En pratique, vous mentionnerez une valeur entre -10 et +10 pour la dérive (en fait, vous pouvez mentionner une valeur de -100 à +100 mais cela à peu de sens).

La valeur numérique absolue (rien que les chiffres) indique le pourcentage dont il faut ralentir le moteur trop rapide... le "+" agit l'un des moteurs... tandis que le "-" (valeur négative) agira sur le moteur opposé.

Lorsque vous commanderez les moteurs, par exemple avec forward(), l'un des moteurs sera à la vitesse maximale (ou mentionnée) et l'autre sera légèrement ralenti avec la valeur de dérive.

Il vous faudra donc procéder par essai/erreur, en ajustant la valeur de la dérive jusqu'à ce que votre plateforme parcours une ligne droite relativement importante comme attendu.

Voici deux exemple avec corrige de dérive, l'un appliquée sur un moteur... et l'autre sur l'autre moteur:

robot = Robot2Wheel( reverse_mot2 = True, derivative_fix = 5 )
robot.forward()
delay( 15000 )
robot.halt()

robot = Robot2Wheel( reverse_mot2 = True, derivative_fix = -3 )
robot.forward()
delay( 15000 )
robot.halt()

D'autres options

Il est possible de contrôler partiellement la dérive en utilisant des moteurs avec encodeur. L'encodeur sert à compter précisément la rotation des moteurs... il est donc possible de savoir exactement quand chaque moteur à fait rotation de 360°. Cela permet de contrôler la dérive au niveau moteur... mais pas celle issue des roues, de l'alignement des moteurs, des forces de glissement (des pneu sur le sol).

Une autre façon de contrôler la dérive est d'utiliser une centrale inertielle (IMU)... et donc de savoir si l'on s'écarte de la trajectoire voulue... et de corriger au besoin :-)

Bibliothèque r2wheel et hbridge

Le code permettant de faire fonctionner cette plateforme est disponible sur GitHub dans le projet PyBoard-a-Roulette.

Pour les détails, vous pouvez explorer le dépôt ici: https://github.com/mchobby/pyboard-a-roulette

HBridge & DualHBridge

Le fonctionnement de la plateforme robotique repose sur deux classes de base (bibliothèque hbridge.py):

La classe HBridge pour le contrôle d'un simple pont-H (donc un moteur dans les deux sens)
- Cette première classe permet de contrôler la marche avant forward(), arrière backward() et l'arrêt halt() d'un moteur.
- Elle permet également de configurer un signal PWM pour contrôler la vitesse d'un moteur entre 0 et 100% (de cycle utile)
La classe DualHBridge pour le contrôle des deux pont-H du L293D (donc deux moteur dans les deux sens)
- Cette seconde classe prend le contrôle de deux moteurs pour faire avancer forward(), reculer backward() et arrêter halt() les deux moteurs en une seule fois.
- Comme pour HBridge, il est possible de préciser la vitesse des moteurs (entre 0 et 100%). Si une seule vitesse est précisée alors deux moteurs sont utilise la même vitesse.
- Cerise sur le gâteau, cette classe permet de gérer la dérive de la plateforme en ralentissant volontairement l'un ou l'autre des moteurs d'un certain pourcentage. Voyez DualHBridge.__init__()

Robot2Wheel

La plateforme Robotique 2 Wheel utilise la classe Robot2Wheel (bibliothèque r2wheel.py.

Robot2Wheel étend la classe DualHBridge et offre des fonctionnalités supplémentaires bien pratique:

Utilise la définition des broches tel que décrit dans le plan de raccordement
Permet d'inverser la commande de marche-avant/marche-arrière du moteur 1 / moteur 2 au moment de la création de l'objet avec reverse_mot1 = True / reverse_mot2 = True.
Il n'est donc pas nécessaire de modifier votre câblage moteur si l'un des moteurs devait tourner à l'envers lors de l'exécution de forward()
L'option fix_rotate = True lors de la création de l'objet permet également d'inverser moteur 1 et moteur 2 sur la plateforme sans devoir démonter votre plateforme.
Bigrement pratique si votre robot tourne à gauche lorsque vous lui demandez de tourner à droite avec turn( Robot2Wheel.RIGHT_ROTATE ).

Les méthodes héritées de la classe DualHBridge restent disponibles:

forward( speed = 100, speed_2 = None )
Passe les deux moteurs en marche avant (100% de régime). Spécifier une valeur pour speed entre 0 et 100 pour modifier la vitesse des deux moteurs. Spécifier speed_2 pour avoir une vitesse différente pour le deuxième moteur.
backward( speed = 100, speed_2 = None )
Passe les deux moteurs en marche arrière (100% de régime). Spécifier une valeur pour speed entre 0 et 100 pour modifier la vitesse des deux moteurs. Spécifier speed_2 pour avoir une vitesse différente pour le deuxième moteur.
halt( self )
Arrête mes deux moteurs.

Robot2Wheel offre une méthode complémentaire pour permettre au robot de tourner (la façon de tourner est spécifique au nombre de roue du robot ;-) ).

turn( direction, speed=100 )
Indique de quel côté et speed indique la vitesse moteur (0-100%) à laquelle la doit tourner.
Voici les différentes valeurs pour direction:
- DualHBridge.RIGHT_ROTATE - Rotation à droite, sur place.
- DualHBridge.LEFT_ROTATE - Rotation à gauche, sur place.
- DualHBridge.RIGHT_BEND - Rotation en négociant un tournant sur la droite. Speed indique de combien il faut ralentir le moteur (0-100%) droit pour entamer le virage sur la droite.
- DualHBridge.LEFT_BEND - Rotation en négociant un tournant sur la gauche. Speed indique de combien il faut ralentir le moteur (0-100%) gauche pour entamer le virage sur la gauche.

Projet original réalisé par Meurisse D. pour MC Hobby SPRL

Toute référence, mention ou extrait de cette traduction doit être explicitement accompagné du texte suivant : « Traduction par MCHobby (www.MCHobby.be) - Vente de kit et composants » avec un lien vers la source (donc cette page) et ce quelque soit le média utilisé.

L'utilisation commercial de la traduction (texte) et/ou réalisation, même partielle, pourrait être soumis à redevance. Dans tous les cas de figures, vous devez également obtenir l'accord du(des) détenteur initial des droits. Celui de MC Hobby s'arrêtant au travail de traduction proprement dit.