Hack-micropython-ServoRobot-Tester

Préambule

Surélever la plateforme

Pour faire nos premiers tests, nous vous proposons de placer votre plateforme robotique sur une boîte de sorte que les pattes puissent se mouvoir librement.

Cela facilitera grandement nos premiers tests.

Assurez-vous d'avoir copié les fichiers de les bibliothèques servorobot et pca9685 sur votre PyBoard comme expliqué dans cette partie du tutoriel.

Préparer la plateforme

• Brancher votre PyBoard sur votre ordinateur à l'aide via le port USB.
• Brancher votre alimentation sur le bornier d'alimentation du contrôleur PWM.
• Démarrer une session REPL sur votre PyBoard comme expliqué dans nos tutoriels pour la PyBoard.

Vous êtes prêt? C'est maintenant que l'on commence à jouer.

Avant de sursauter!

Les servo-moteurs savent se positionner à un certain angle... mais n'ont pas de capteur informant la PyBoard l'angle actuel du moteur.

La bibliothèque servorobot fait donc le nécessaire pour mémorisé l'angle sélectionné et positionné pour chaque servo-moteur.

En conséquence:

Si le robot est debout sur ses pattes, la séquence d'initialisation le couche en une seule opération... et cela surprend parfois (d'où le titre "avant de sursauter!").

Tester

La bibliothèque servorobot contient de nombreux exemples servorobot/samples/Doggy/

Les plus curieux pourrons également se pencher sur les exemples servorobot/samples/RobotBase qui testent les éléments fondamentaux.

Reinitialisation

Script de base pour Doggy, l'initialisation de la classe Doggy fait un appel à la méthode de réinitialisation reset().

Cette dernière positionne tous mes angles à 0° (étend les pattes à l'horizontal)

from doggy import *
d = Doggy()

Mais rien ne vous empêche de faire appel directement à la méthode reset()

d.reset()

Lorsqu'un angle est sélectionné sur un servo, ce dernier le maintient activement la position.

Il est possible de désactiver les servos en utilisant la méthode release()

d.release()

Etude du mouvement

Par exemple, SI vous êtes assis sur un chaise et que vous voulez marcher ALORS vous passez par une étape préparatoire qui consiste à vous mettre debout PUIS seulement à faire un pas après l'autre.

Ce principe est repris dans les classes RobotBase et Movement... donc dans Doggy.

Dans ServoRobot, un mouvement se prépare en appelant prepare() puis s'exécute en appelant move(), vous allez pouvoir admirer cette mécanique au point suivant.

L'appel à prepare() configure les membres dans une position permettant de débuter le mouvement souhaité.

L'appel à move() peut être appelé de différentes façons mais elle permet d'exécuter le mouvement.

Pour les plus curieux:

1. Les mouvements sont implémentés dans des classes dérivées de Movement.
2. La classe Movement contient un méthode prepare(). prepare() accepte des paramètres optionnels, ce qui permet d'ajuster les paramètres du mouvement.
3. La classe Movement contient également une méthode do() appelée répétitivement par move().
   do() permet de décomposer un mouvement complexe (par exemple: la marche) en plusieurs opérations élémentaires (ou sous mouvement partiels).
   Il faudra donc de plusieurs appels a Movement.do() pour effectuer le mouvement complet qui permet à Doggy d'avancer sur ses 4 pattes.

N'hésitez pas à consulter les classes Foward, Backward, etc disponibles dans le module doggy.py

Se lever

Avant de faire bouger le robot, il serait peut être opportun de mettre le robot debout sur ses pattes

from doggy import *
from pyb import delay
d = Doggy()

# Nous avons besoin de connaître la position initiale
d.reset() 

# Laisser un peu de temps pour que les oscillations mécaniques se calme 
delay( 1500 )

# Place toutes les epaules à +20 et -20 degree
d.align( sdegree=20, asymetric=True )

# FR: Place tous les poignets à +90 pour mettre Doggy debout
d.standup()

Avancer / Reculer (version prédictive)

Vous disposez de plusieurs approches pour faire avancer Doggy.

Nous présentons ici une approche prédictive, c'est à dire que vous savez combien de "pas" vous allez faire avant d'appeler la fonction forward.

Nous présentons ici les approches les plus simples jusqu'au plus avancées.

from doggy import *
from pyb import delay
d = Doggy()

# Place le robot en positions de marche (debout). Les épaules sont placés a angles adéquat pour commencer la marche
# prepare() EST IMPORTANT AVANT DE COMMENCER UN MOUVEMENT  
d.prepare('FORWARD')

delay( 2000 )

# Déplacement en marche avant (angle poignet=90) en 40 étapes (de 5 degrés chacun)
for i in range( 40 ):
	d.move( 'FORWARD' )

delay( 2000 )

# Une autre façon de faire: appelle prepare() avant d'exécuter 40 fois l'étape de mouvement
d.reset()
d.move( 'FORWARD', repeat=40, prepare=True)

delay( 2000 )

# Changer les angles des mouvements des epaules (shoulder min & max) 
# ainsi que l'angle du poignet (a 75 degrés). 
# Chaque pas fait un déplacement de 2 degres
#
# Tous les paramètres correspondent a Forward.do()
d.reset()
d.prepare('FORWARD', sdegree_min=0, sdegree_max=85, wdegree=75 )
for i in range( 150 ):
	d.move( 'FORWARD', sdegree_min=0, sdegree_max=85, wdegree=75, step_angle=2 )


# Tout en un
d.move( 'FORWARD', sdegree_min=0, sdegree_max=85, wdegree=75, step_angle=2, repeat=150, prepare=True )

delay( 2000 )

# Faisons le vraiment à la dure (obtenir l'objet Movement). Voyez comment est implémenté Doggy.move()
d.reset()
mov_obj = d.movement('FORWARD')
mov_obj.prepare( wdegree=65 )
for i in range( 50 ):                                                       
    mov_obj.do( wdegree=65, step_angle=10 )

Vous noterez l'utilisation du mot 'FORWARD' pour avancer. Vous pouvez le remplacer par 'F'.

Pour reculer, vous pouvez utiliser les mots clés 'BACKWARD', 'BACK', 'B'.

Tourner

Il est possible de faire tourner le robot Doggy à droite (RIGHT) ou à gauche (LEFT) Nous présentons ici les approches les plus simples jusqu'au plus avancées.

from doggy import *
from pyb import delay
d = Doggy()

# Place le robot en positions de marche (debout).
# Les épaules sont placés a angles adéquat pour commencer à tourner à gauche
# prepare() EST IMPORTANT AVANT DE COMMENCER UN MOUVEMENT  
d.prepare('LEFT')

delay( 2000 )

# Tourne à gauche (angle poignet=90) en 1 étapes de 90° (valeur par défaut)
d.move( 'LEFT' )

delay( 2000 )

# Une autre façon de faire: appeler prepare() avant d'exécuter 2fois l'étape 
# de mouvement (de 90 degrees)
d.reset()
d.move( 'LEFT', repeat=2, prepare=True)

delay( 2000 )

# Changer les angles des mouvements des épaules pour tourner à gauche de
# 160 degree (en total) et l'angle des poignet fixé à 5 degrees.
# Tous les paramètres correspondent a Left.do()
d.reset()
d.prepare('LEFT', wdegree=75 )
d.move( 'LEFT', sdegree=160, wdegree=75 )

# Tout en un
d.move( 'LEFT', sdegree=160, wdegree=75, prepare=True )

delay( 2000 )

# Faisons le vraiment a la dure (obtenir l'objet Movement). Voyez comment est implémenté Doggy.move()
d.reset()
mov_obj = d.movement('LEFT')
mov_obj.prepare( wdegree=65 )            
mov_obj.do( sdegree=60, wdegree=65, prepare=True, repeat=3 ) # repeat 3 times the turn left

# Réduire l'amplitude du mouvement de 60 degrés (valeur par défaut) 
# à 30 degrées & faire une rotation à gauche de 75 degrée
d.move( 'L', sdegree=75, sdegree_max=30, prepare=True )

Vous noterez l'utilisation du mot 'LEFT' pour tourner à gauche. Vous pouvez le remplacer par 'L'.

Pour tourner à droite, vous pouvez utiliser les mots clés 'RIGHT', 'R'.

---

Créé par Meurisse D. pour MCHobby.be - Created by Meurisse D. for MCHobby.be

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.