Bureaucrates, Administrateurs, widgeteditor
704
modifications
Modifications
Sauter à la navigation
Sauter à la recherche
Ligne 1 :
Ligne 1 : − + Ligne 24 :
Ligne 24 : − + Ligne 31 :
Ligne 31 : − <nowiki>>>> 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 } </nowiki>+ + + Ligne 39 :
Ligne 41 : − <nowiki>>>> h = HBridge( MOT1_PINS, MOT1_PWM )</nowiki>+ + + Ligne 48 :
Ligne 52 : − <nowiki>>>> h.forward()+ − >>> h.backward()+ − >>> h.halt()</nowiki>+ + + − <nowiki>>>> 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()</nowiki>+ + + Ligne 71 :
Ligne 79 : − <nowiki>>>> 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()</nowiki>+ + + Ligne 85 :
Ligne 95 : − + − + Ligne 97 :
Ligne 107 : − <nowiki>>>> from r2wheel import Robot2Wheel+ − >>> r2 = Robot2Wheel()+ − >>> r2.forward( 80 )+ − >>> r2.halt()</nowiki>+ + + Ligne 106 :
Ligne 118 : − <nowiki>>>> r2.backward()</nowiki>+ + + Ligne 117 :
Ligne 131 : − <nowiki>r2 = Robot2Wheel( reverse_mot2 = True )+ + − + + Ligne 128 :
Ligne 144 : − <nowiki>>>> r2 = Robot2Wheel( reverse_mot2 = True ) # inverser la commande du moteur moteur+ − >>> r2.turn( Robot2Wheel.RIGHT_ROTATE )+ − >>> r2.halt()</nowiki>+ + + − + − <nowiki>>>> r2.turn( Robot2Wheel.RIGHT_ROTATE, speed=60 )</nowiki>+ + Ligne 148 :
Ligne 167 : − <nowiki>>>> r2 = Robot2Wheel( fix_rotate = True )</nowiki> + + + − + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + − {{traduction}}+ − + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + − {{traduction}}+ Ligne 196 :
Ligne 343 : − + − +
Hack-micropython-Robot2Wheel-Code (voir la source)
Version du 25 juillet 2016 à 16:16
, 25 juillet 2016 à 16:16→Tourner à droite
{{Hack-micropython-Robot2Wheel-NAV}}
{{Hack-micropython-Robot2Wheel-NAV}}
== Installer ==
== 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
Vous pouvez télécharger la bibliothèque et les codes d'exemples directement depuis le [https://github.com/mchobby/pyboard-a-roulette dépôt GitHub du PyBoard-a-roulette]
{{download-box|Télécharger PyBoard-a-Roulette.zip|https://github.com/mchobby/pyboard-a-roulette/archive/master.zip}}
{{download-box|Télécharger PyBoard-a-Roulette.zip|https://github.com/mchobby/pyboard-a-roulette/archive/master.zip}}
== Tester les pont-H ==
== Tester les pont-H ==
Avant de nous lancer dans les choses vraiment intéressante, nous allons commencer par commander directement nos pont-H avec la classe HBridge.
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).
Souvenez-vous, nous avons branché l'un de nos pont-H sur les sorties X6 et X5 (input 1 et 2).
Petit rappel avec [[MicroPython.brochage.pyboard#Le_brochage|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.
Petit rappel avec [[MicroPython.brochage.pyboard#Le_brochage|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.
<syntaxhighlight lang="python">
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 }
</syntaxhighlight>
Voila, nous avons défini nos broches de commandes dans le tuple {{fname|MOT1_PINS}} et les informations de la broche PWM dans {{fname|MOT1_PWM}} pour le contrôle de la vitesse.
Voila, nous avons défini nos broches de commandes dans le tuple {{fname|MOT1_PINS}} et les informations de la broche PWM dans {{fname|MOT1_PWM}} pour le contrôle de la vitesse.
Nous allons pouvoir créer l'objet Pont-H pour le commander.
Nous allons pouvoir créer l'objet Pont-H pour le commander.
<syntaxhighlight lang="python">
h = HBridge( MOT1_PINS, MOT1_PWM )
</syntaxhighlight>
Nous allons pouvoir tester les méthodes de base:
Nous allons pouvoir tester les méthodes de base:
Laissez un peu de temps entre chacune des commandes pour pouvoir constater les effets sur votre mobile.
Laissez un peu de temps entre chacune des commandes pour pouvoir constater les effets sur votre mobile.
<syntaxhighlight lang="python">
h.forward()
h.backward()
h.halt()
</syntaxhighlight>
Vous pouvez maintenant tester votre deuxieme pont-H avec les commandes suivantes:
Vous pouvez maintenant tester votre deuxieme pont-H avec les commandes suivantes:
<syntaxhighlight lang="python">
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()
</syntaxhighlight>
=== Contrôle de vitesse ===
=== Contrôle de vitesse ===
Nous allons donc revoir notre programme de commande du deuxième pont-h pour contrôler la vitesse moteur.
Nous allons donc revoir notre programme de commande du deuxième pont-h pour contrôler la vitesse moteur.
<syntaxhighlight lang="python">
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()
</syntaxhighlight>
L'instruction {{fname|for speed in range( 0, 100, 10 )}} permet de faire varier la vitesse entre 0 et 100 par pas de 10.
L'instruction {{fname|for speed in range( 0, 100, 10 )}} permet de faire varier la vitesse entre 0 et 100 par pas de 10.
Ensuite l'instruction {{fname|h2.backward( 100-speed )}} active la marche arrière et passant graduellement de la vitesse maximale à la vitesse minimale.
Ensuite l'instruction {{fname|h2.backward( 100-speed )}} active la marche arrière et passant graduellement de la vitesse maximale à la vitesse minimale.
{{ambox-stop|text=En dessous d'un certain pourcentage de cycle utile (un valeur de la variable {{fname|speed}}), la puissance envoyé au moteur ne insuffisante et ce dernier ne tournera pas... par contre, vous entendrez le bourdonnement du signal PWM dans le bobinage.<br /><br />Un truc pratique est de démarrer à puissance suffisante pour vaincre l'inertie et les force de friction avant de passer en PWM à plus faible pourcentage.}}
{{ambox-stop|text=En dessous d'un certain pourcentage de cycle utile (un valeur de la variable {{fname|speed}}), la puissance envoyé au moteur ne insuffisante et ce dernier ne tournera pas... par contre, vous entendrez le bourdonnement du signal PWM dans le bobinage.<br /><br />Un truc pratique est de démarrer à puissance suffisante pour vaincre l'inertie et les force de friction avant de passer en PWM à plus faible pourcentage.}}
== Tester la plateforme avec Robot2Wheel ==
== Tester la plateforme avec Robot2Wheel ==
=== Les mouvements en image ===
=== Les mouvements en image ===
[[Fichier:RB-2-WHEEL-MOVE-00.jpg|640px]] [[Fichier:RB-2-WHEEL-MOVE-01.jpg|640px]]
[[Fichier:RB-2-WHEEL-MOVE-00.jpg|480px]] [[Fichier:RB-2-WHEEL-MOVE-01.jpg|480px]]
[[Fichier:RB-2-WHEEL-MOVE-02.jpg|640px]]
[[Fichier:RB-2-WHEEL-MOVE-02.jpg|640px]]
Allons y:
Allons y:
<syntaxhighlight lang="python">
from r2wheel import Robot2Wheel
r2 = Robot2Wheel()
r2.forward( 80 )
r2.halt()
</syntaxhighlight>
Dans cet exemple, nous avons demandé à la plateforme d'avancer à la vitesse de 80% avec {{fname|r2.forward(80)}} .
Dans cet exemple, nous avons demandé à la plateforme d'avancer à la vitesse de 80% avec {{fname|r2.forward(80)}} .
Vous l'aurez compris, pour passer la marche arrière, il suffit de...
Vous l'aurez compris, pour passer la marche arrière, il suffit de...
<syntaxhighlight lang="python">
r2.backward()
</syntaxhighlight>
=== Un moteur tourne dans le mauvais sens! ===
=== Un moteur tourne dans le mauvais sens! ===
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.
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.
<syntaxhighlight lang="python">
r2 = Robot2Wheel( reverse_mot2 = True )
r2 = Robot2Wheel( reverse_mot1 = True )
r2 = Robot2Wheel( reverse_mot1 = True )
r2 = Robot2Wheel( reverse_mot1 = True, reverse_mot2 = True )</nowiki>
r2 = Robot2Wheel( reverse_mot1 = True, reverse_mot2 = True )
</syntaxhighlight>
Dans le cadre de mes tests, j'ai utilisé {{fname|1=r2 = Robot2Wheel( reverse_mot2 = True )}} pour corriger la rotation de l'un de mes moteurs.
Dans le cadre de mes tests, j'ai utilisé {{fname|1=r2 = Robot2Wheel( reverse_mot2 = True )}} pour corriger la rotation de l'un de mes moteurs.
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.
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.
<syntaxhighlight lang="python">
r2 = Robot2Wheel( reverse_mot2 = True ) # inverser la commande du moteur moteur
r2.turn( Robot2Wheel.RIGHT_ROTATE )
r2.halt()
</syntaxhighlight>
Vous pouvez également indiquer une vitesse moteur durant la rotation.
Vous pouvez également indiquer une vitesse moteur durant la rotation.
<syntaxhighlight lang="python">
r2.turn( Robot2Wheel.RIGHT_ROTATE, speed=60 )
</syntaxhighlight>
=== La plateforme tourne dans le mauvais sens! ===
=== La plateforme tourne dans le mauvais sens! ===
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.
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.
<syntaxhighlight lang="python">
r2 = Robot2Wheel( fix_rotate = True )
</syntaxhighlight>
Après cela, la plateforme tournera dans le bon sens.
Après cela, la plateforme tournera dans le bon sens.
=== Tourner dans tous les sens ===
=== Tourner dans tous les sens ===
[[Fichier:RB-2-WHEEL-MOVE-01.jpg|640px]] [[Fichier:RB-2-WHEEL-MOVE-02.jpg|640px]]
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
[[Fichier:RB-2-WHEEL-MOVE-01.jpg|480px]] [[Fichier:RB-2-WHEEL-MOVE-02.jpg|640px]]
==== Tourner sur place ====
Plus approprié dans le déplacement dans les labyrinthes, ce type de virage permet de tourner dans un espace minimum.
[[Fichier:RB-2-WHEEL-MOVE-01.jpg|320px]]
C'est aussi le plus simple à appeler. La méthode standard est {{fname|turn()}} avec soit le paramètre {{fname|Robot2Wheel.LEFT_ROTATE}} {{fname|Robot2Wheel.RIGHT_ROTATE}}.
Comme pour la marche avant/arrière, vous avez la possibilité d'indiquer une vitesse (par défaut c'est 100%).
<syntaxhighlight lang="python">
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()
</syntaxhighlight>
Vous pourriez obtenir le même résultat avec les méthodes {{fname|right()}} et {{fname|left()}}.
<syntaxhighlight lang="python">
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()
</syntaxhighlight>
=== 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.
[[Fichier:RB-2-WHEEL-MOVE-02.jpg|480px]]
Dans l'exemple suivant, nous allons entamer un virage à droite {{fname|Robot2Wheel.RIGHT_BEND}}. Pour cela, nous allons ralentir le moteur droit de 40% ({{fname|1=speed=40}}) par rapport au moteur gauche.
Lorsqu'il n'y a qu'un seul paramètre de vitesse, ce paramètre {{fname|speed}} mentionne la différence de vitesse entre les deux moteurs.
<syntaxhighlight lang="python">
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()
</syntaxhighlight>
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 {{fname|speed}}, puis la différence de vitesse entre les deux moteurs dans {{fname|speed2}}.
<syntaxhighlight lang="python">
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()
</syntaxhighlight>
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 ===
=== Corriger la dérive ===
[[Fichier:RB-2-WHEEL-MOVE-02.jpg|800px]]
{{ambox|text=Ce point n'est pertinent que si vous avez besoin de parcourir des distances relativement importantes en ligne droite.}}
==== Qu'est-ce que la dérive ====
Deux moteurs d'un même fabricant et d'un même modèle ne sont {{underline|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.
[[Fichier:RB-2-WHEEL-MOVE-Derive.jpg|900px]]
==== Comment corriger la dérive ====
{{underline|'''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.
{{underline|'''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 {{fname|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:
<syntaxhighlight lang="python">
robot = Robot2Wheel( reverse_mot2 = True, derivative_fix = 5 )
robot.forward()
delay( 15000 )
robot.halt()
</syntaxhighlight>
<syntaxhighlight lang="python">
robot = Robot2Wheel( reverse_mot2 = True, derivative_fix = -3 )
robot.forward()
delay( 15000 )
robot.halt()
</syntaxhighlight>
==== 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 ==
== Bibliothèque r2wheel et hbridge ==
** DualHBridge.RIGHT_ROTATE - Rotation à droite, sur place.
** DualHBridge.RIGHT_ROTATE - Rotation à droite, sur place.
** DualHBridge.LEFT_ROTATE - Rotation à gauche, 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.
** 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.
** 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.
{{Hack-micropython-Robot2Wheel-TRAILER}}
{{Hack-micropython-Robot2Wheel-TRAILER}}