Différences entre versions de « Rasp-Hat-Moteur-Moteurs-pas-a-pas »
(Page créée avec « {{Rasp-Hat-Moteur-NAV}} {{traduction}} == Utiliser des moteurs pas-à-pas == Stepper motors are great for (semi-)precise control, perfect for many robot and CNC projects.... ») |
|||
(14 versions intermédiaires par le même utilisateur non affichées) | |||
Ligne 1 : | Ligne 1 : | ||
{{Rasp-Hat-Moteur-NAV}} | {{Rasp-Hat-Moteur-NAV}} | ||
− | |||
== Utiliser des moteurs pas-à-pas == | == Utiliser des moteurs pas-à-pas == | ||
− | + | Les moteurs pas-à-pas sont vraiment géniaux pour un contrôle (semi-)précis. Ils sont parfait pour de nombreux robots, projets CNC et impression 3D. Ce HAT supporte jusqu'à 2 moteurs pas-à-pas. La bibliothèque Python fonctionne de manière identique pour les moteurs unipolaires et les moteurs bipolaires. | |
− | + | Faire tourner un moteur pas-à-pas est un peu plus complexe que de faire tourner un moteur continu même si cela reste encore très simple. | |
{{ADFImage|Rasp-Hat-Moteur-Moteurs-pas-a-pas-00.jpg|640px}} | {{ADFImage|Rasp-Hat-Moteur-Moteurs-pas-a-pas-00.jpg|640px}} | ||
Ligne 12 : | Ligne 11 : | ||
Pour cette démonstration, utilisé M1 et M2 pour connecter le moteur. | Pour cette démonstration, utilisé M1 et M2 pour connecter le moteur. | ||
− | Après avoir raccordé le moteur (voir ci-dessous), rendez vous dans le répertoire {{fname|Adafruit-Motor-HAT-Python/examples}} et exécutez la commande {{sudo python StepperTest.py}} pour voir le moteur pas-à-pas tourner dans un sens puis l'autre. | + | Après avoir raccordé le moteur (voir ci-dessous), rendez vous dans le répertoire {{fname|Adafruit-Motor-HAT-Python/examples}} et exécutez la commande {{fname|sudo python StepperTest.py}} pour voir le moteur pas-à-pas tourner dans un sens puis l'autre. |
=== Pour les moteurs unipolaires === | === Pour les moteurs unipolaires === | ||
− | + | Pour connecter un moteur pas-à-pas, vous devez d'abord identifier quels sont les fils branchés sur les différentes bobines du moteur. Sur un moteur 6 fils, il faut identifier quels sont les fils correspondant à la connexion centrale de chaque bibine. Sur un moteur 5 fils, il faut identifier le fils qui est connecté sur les sur la connexion centrale des deux bobines. [[Adafruit_Motor_Shield_V2-Ressources|Il existe de nombreux tutoriels expliquant comment faire du "reverse ingeneering" du brochage des moteurs]]. | |
+ | |||
+ | La/les connexion(s) centrale(s) des bobines doit/doivent être raccordés ensemble sur le bornier '''GND''' du bloc moteur. | ||
+ | Ensuite, la bobine 1 devrait être connectée sur l'un des ports moteur, disons '''M1''' et la bobine 2 connectée sur l'autre port, donc '''M2'''. | ||
+ | |||
+ | Il est bien entendu possible d'utiliser '''M3''' et '''M4''' à la place des port '''M1''' + '''M2'''. | ||
=== Pour les moteurs bipolaires === | === Pour les moteurs bipolaires === | ||
− | + | Les moteurs bipolaires n'ont pas de 5ieme fils à connecter à la masse. Le code fonctionne à l'identique. | |
+ | |||
+ | S'il n'y a que {{pl|236|4 fils sur votre moteur pas-à-pas}} la bobine 1 devrait être connectée sur l'un des ports moteur, disons '''M1''' et la bobine 2 connectée sur l'autre port, donc '''M2'''. | ||
+ | |||
+ | Il est bien entendu possible d'utiliser '''M3''' et '''M4''' à la place des ports '''M1''' + '''M2'''. | ||
== Contrôler un moteur pas-à-pas == | == Contrôler un moteur pas-à-pas == | ||
− | |||
− | + | Nous allons réviser le contenu du code permettant de prendre le contrôle du moteur à l'aide de la bibliothèque MotorHAT. | |
+ | |||
+ | Nous commençons par importer les éléments nécessaires pour qu'ils puissent être utilisé par notre script : | ||
<syntaxhighlight lang="python"> | <syntaxhighlight lang="python"> | ||
Ligne 33 : | Ligne 42 : | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | + | La bibliothèque MotorHAT contient quelques classes, il y a la classe MotorHAT qui est le principal contrôleur du générateur PWM. Vous aurez toujours besoin de créer un objet et de fixer l'adresse. L'adresse par défaut est 0x60 (voyez la [[Rasp-Hat-Moteur-Empiler-les-Hats|concernant l'empilement des HATs]] où il sera nécessaire de changer l'adresse). | |
<syntaxhighlight lang="python"> | <syntaxhighlight lang="python"> | ||
− | # | + | # Créer l'objet par défaut, indiquer l'adresse I2C (celle par défaut), pas de changement de fréquence. |
mh = Adafruit_MotorHAT(addr = 0x60) | mh = Adafruit_MotorHAT(addr = 0x60) | ||
</syntaxhighlight> | </syntaxhighlight> | ||
+ | Même si cet exemple n'utilise pas de moteur continu, il reste très important de mentionner que le contrôleur PWM fonctionne toujours de façon autonome. Cela signifie que même si le programme plante (ou si le module noyau crashe), le générateur PWM continue à générer un signal PWM. | ||
− | + | Les moteurs pas-à-pas ne continuerons pas à bouger si le script plante mais il est fortement recommandé de garder la section de code {{fname|at exit}} pour désactiver le générateur PWM: | |
− | |||
− | |||
− | |||
<syntaxhighlight lang="python"> | <syntaxhighlight lang="python"> | ||
− | # | + | # Il est recommandé de faire une auto-désactivation des moteurs |
+ | # lors de l'arrêt du programme! | ||
def turnOffMotors(): | def turnOffMotors(): | ||
mh.getMotor(1).run(Adafruit_MotorHAT.RELEASE) | mh.getMotor(1).run(Adafruit_MotorHAT.RELEASE) | ||
Ligne 58 : | Ligne 66 : | ||
== Créer un objet moteur pas-à-pas == | == Créer un objet moteur pas-à-pas == | ||
− | + | Nous disposons maintenant d'un objet MotorHAT pouvant contrôer deux moteurs pas-à-pas. Il est possible d'avoir plusieurs HAT moteurs branchés sur le Raspberry-Pi! | |
− | + | L'objet MotorHAT expose une méthode {{fname|getStepper()}} permettant de créer un objet "moteur pas-à-pas" (dit "Stepper" en anglais) permettant de contrôler facilement celui-ci. | |
+ | |||
+ | La méthode '''getStepper(steps, portnum)''' accepte deux paramètres : | ||
+ | * '''steps''' - indique le nombre de pas nécessaires pour faire une révolution complète du moteur pas-à-pas (habituellement entre 35 et 200). | ||
+ | * '''portnum''' - indique le port à utiliser avec la valeur 1 et 2. Port #1 correspond à '''M1''' et '''M2''', port #2 correspond à '''M3''' et '''M4''' | ||
<syntaxhighlight lang="python"> | <syntaxhighlight lang="python"> | ||
− | myStepper = mh.getStepper(200, 1) | + | # 200 pas par révolution, moteur sur port 1 |
+ | myStepper = mh.getStepper(200, 1) | ||
</syntaxhighlight> | </syntaxhighlight> | ||
− | + | Si vous envisagez utilise la fonction 'bloquante' '''step()''' pour avancer de plusieurs pas en une fois alors vous pouvez fixer la vitesse en Rotation Par Minute. | |
+ | |||
+ | A contrario, si vous voulez utiliser utiliser la fonction '''oneStep()''' alors l'étape suivante n'est pas nécessaire. | ||
+ | |||
+ | A noter que la vitesse est approximative car le Raspberry-Pi n'est pas capable de gérer les délais avec la même précision qu'un Arduino. Comme Adafruit voulait des bibliothèques Arduino et Pi similaires, ils ont maintenu la fonction '''setSpeed()''' dans la bibliothèque Pi: | ||
<syntaxhighlight lang="python"> | <syntaxhighlight lang="python"> | ||
− | myStepper.setSpeed(30) | + | myStepper.setSpeed(30) # fixer la vitesse à 30 RPM |
</syntaxhighlight> | </syntaxhighlight> | ||
== Les pas == | == Les pas == | ||
− | + | Les moteurs pas-à-pas diffèrent des moteurs continu en ce sens que le contrôleur (dans ce cas, le Raspberry Pi) doit activer chacune des 4 bobines dans le bon ordre pour que moteur tourne. En alternant l'activation des bobines, le moteur pas-à-pas tournera tout au long du stator. Si les bobines sont activées dans l'ordre opposé alors le moteur tournera dans le sens inverse. | |
− | + | Si le code Python ou le Raspberry-Pi crashe (ou arrête de s'exécuter) alors le moteur cessera de tourner. C'est différent d'un moteur continu qui tourne aussi longtemps qu'une tension est présente aux bornes du moteur. | |
[[Fichier:Rasp-Hat-Moteur-Moteurs-pas-a-pas-01.gif]]<br />[http://commons.wikimedia.org/wiki/File:StepperMotor.gif#mediaviewer/File:StepperMotor.gif "StepperMotor" par Wapcaplet; Teravolt.] | [[Fichier:Rasp-Hat-Moteur-Moteurs-pas-a-pas-01.gif]]<br />[http://commons.wikimedia.org/wiki/File:StepperMotor.gif#mediaviewer/File:StepperMotor.gif "StepperMotor" par Wapcaplet; Teravolt.] | ||
− | + | Il y a quatre types principaux de pas pouvant être utilisé avec le HAT moteur. Les quatre types de pas fonctionnerons avec tous les moteurs unipolaire ou bipolaires. | |
− | # | + | # '''Simple pas''' - dit "''Single Steps''" en anglais. C'est le type de pasle plus simple et celui qui utilise le moins de puissance. Il utilise une seule bobine pour 'maintenir' le moteur en place (comme indiqué sur la GIF animée ci-dessous). |
+ | # '''Double pas''' - dit "''Double Steps''" en anglais. Il est également très simple à mettre en oeuvre, excepté qu'à la place d'une seule bobine, il utilise deux bobines en une fois. Par exemple, à la place de la seule bobine #1 activée, nous aurons les bobines #1 et #2 activées en même temps. Cela utilise plus de puissance (environ 2x plus) mais offrira un mouvement plus "puissant" (d'environ 25%) | ||
+ | # '''Pas entrelacés''' - dit "''Interleaved Steps''". C'est un mélange de fonctionnement en pas simple et en pas double où nous utilison les pas simples entrelacés avec les douvle. Il propose un peu plus de couple que le ''simple pas'' en consomme environ 50% de puissance en plus. L'avantage de cette approche est que le moteur apparaît comme ayant 2x plus de pas pour une transition plus fluide entre les pas. | ||
+ | # '''Microstepping''' - Le micro pas-à-pas est un mélange de simple pas avec un signal PWM permettant de faire une transition plus file entre les pas (avoir des Micro Pas). C'est plus lent que du pas simple mais cela permet d'atteindre une précision nettement plus importante en multipliant par 8 le nombre de pas du moteur. Le micro-stepping permet, dans ce cas, de réduire l'avance au 1/8 de pas. Cela signifie qu'une révolution complète d'un moteur 200 pas nécessitera donc 8x200 = 1600 pas en mode "micro-stepping". | ||
+ | |||
+ | <syntaxhighlight lang="python"> | ||
+ | while (True): | ||
+ | print("Pas simple / Single coil steps") | ||
+ | myStepper.step(100, Adafruit_MotorHAT.FORWARD, Adafruit_MotorHAT.SINGLE) | ||
+ | myStepper.step(100, Adafruit_MotorHAT.BACKWARD, Adafruit_MotorHAT.SINGLE) | ||
+ | print("Double pas / Double coil steps") | ||
+ | myStepper.step(100, Adafruit_MotorHAT.FORWARD, Adafruit_MotorHAT.DOUBLE) | ||
+ | myStepper.step(100, Adafruit_MotorHAT.BACKWARD, Adafruit_MotorHAT.DOUBLE) | ||
+ | print("Pas entrelacés / Interleaved coil steps") | ||
+ | myStepper.step(100, Adafruit_MotorHAT.FORWARD, Adafruit_MotorHAT.INTERLEAVE) | ||
+ | myStepper.step(100, Adafruit_MotorHAT.BACKWARD, Adafruit_MotorHAT.INTERLEAVE) | ||
+ | print("MicroStepping / Microsteps") | ||
+ | myStepper.step(100, Adafruit_MotorHAT.FORWARD, Adafruit_MotorHAT.MICROSTEP) | ||
+ | myStepper.step(100, Adafruit_MotorHAT.BACKWARD, Adafruit_MotorHAT.MICROSTEP) | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | == step() - fonction bloquante == | ||
+ | Comme vous pouvez le voir ci-dessus, vous pouvez faire des avances de plusieurs pas en une fois à l'aide de la fonction '''step()''' | ||
+ | |||
+ | step(numbre_de_pas, direction, type) | ||
+ | |||
+ | Où : | ||
+ | * '''nombre_de_pas''' est le nombre de pas à faire | ||
+ | * '''direction''' indique le sens de rotation (FORWARD pour avant et BACKWARD pour l'arrière). | ||
+ | * '''type''' est le type de pas SINGLE (''simple''), DOUBLE (''double''), INTERLEAVE (''entrelacé'') ou MICROSTEP (''micro-stepping''). | ||
+ | |||
+ | {{ambox|text=Le type de pas entrelacé (''INTERLEAVE'') tournera l'axe de la moitié du type simple ou double pas (''SINGLE'' ou ''DOUBLE'') parce qu'il y a deux fois plus de pas en mode entrelacé. Le type de pas MICROSTEP tournera l'axe du 1/8 de rotation par rapport au pas simple ou double parce que chaque micro-pas compte pour un pas et qu'il y en a 8x plus!}} | ||
+ | |||
+ | Cette approche est l'approche la plus simple mais elle est également '''bloquante''' - cela signifie que le programme Python reste occupé pendant toute la phase de déplacement du moteur. Si vous avez deux moteurs et faites les appels suivants: | ||
+ | |||
+ | <syntaxhighlight lang="python"> | ||
+ | stepper1.step(100, Adafruit_MotorHAT.FORWARD, Adafruit_MotorHAT.SINGLE) | ||
+ | stepper2.step(100, Adafruit_MotorHAT.BACKWARD, Adafruit_MotorHAT.SINGLE) | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Alors le premier moteur se déplacera de 100 pas puis stopper. Ensuite seulement, le second moteur pas-à-pas entamera sa révolution de 100 pas. | ||
+ | |||
+ | Cette approche est intéressante si votre projet s'accommode qu'un seul moteur puisse fonctionner à fois! | ||
+ | |||
+ | Si vous désirez faire fonctionner plusieurs moteurs pas-à-pas en même temps, il est possible d'exploiter le support multitâche de Python. L'exemple '''DualStepperTest.py''' exploite le support multitâche et utilise des threads pour faire fonctionner les deux moteurs en même temps. | ||
+ | |||
+ | La partie importante de l'exemple '''DualStepperTest''' est la définition d'une fonction qui agit comme un ''wrapper'' (surcouche) pour la fonction {{fname|step()}}: | ||
+ | |||
+ | <syntaxhighlight lang="python"> | ||
+ | def stepper_worker(stepper, numsteps, direction, style): | ||
+ | #print("Faire des pas!") | ||
+ | stepper.step(numsteps, direction, style) | ||
+ | #print("Fait") | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Il y a quelques instructions d'affichage (''print'') pour le cas où vous voudriez faire du débogage. | ||
+ | |||
+ | Ensuite, lorsque vous voulez faire tourner le premier moteur pas-à-pas, vous pouvez appeler: | ||
+ | |||
+ | <syntaxhighlight lang="python"> | ||
+ | st1 = threading.Thread(target=stepper_worker, args=(myStepper1, numsteps, direction, stepping_style)) | ||
+ | st1.start() | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Ce qui crée une tâche d'arrière plan (un ''thread'') pour faire tourner ''Stepper1'' et rend immédiatement la main au programme principal. | ||
+ | |||
+ | Vous pouvez faire de même avec le second moteur pas-à-pas avec la ligne suivante: | ||
+ | |||
+ | <syntaxhighlight lang="python"> | ||
+ | st2 = threading.Thread(target=stepper_worker, args=(myStepper2, numsteps, direction, stepping_style)) | ||
+ | st2.start() | ||
+ | </syntaxhighlight> | ||
+ | |||
+ | Il est possible de savoir lorsque le moteur pas-à-pas à terminé sa rotation parce que le ''thread'' créé sera 'mort'. Il est possible de tester les thread avec '''st1.isAlive()''' (ou '''st2.isAlive()'''). Si vous obtenez la valeur '''True''' cela signifie que le moteur tourne (puisque le ''thread'' est toujours en cours d'exécution). | ||
+ | |||
+ | == oneStep() - fonction non bloquante == | ||
+ | Si vous désirez avoir beaucoup plus de contrôle sur vos moteurs pas-à-pas, vous pouvez utiliser la fonction {{fname|oneStep(direction, type_de_pas)}} qui exécute l'avance d'un simple pas sans délai. Cela permettra à votre programme d'exécuter des avances d'un pas {{underline|exactement}} au moment souhaité. | ||
{{Rasp-Hat-Moteur-TRAILER}} | {{Rasp-Hat-Moteur-TRAILER}} |
Version actuelle datée du 3 septembre 2017 à 13:05
Utiliser des moteurs pas-à-pas
Les moteurs pas-à-pas sont vraiment géniaux pour un contrôle (semi-)précis. Ils sont parfait pour de nombreux robots, projets CNC et impression 3D. Ce HAT supporte jusqu'à 2 moteurs pas-à-pas. La bibliothèque Python fonctionne de manière identique pour les moteurs unipolaires et les moteurs bipolaires.
Faire tourner un moteur pas-à-pas est un peu plus complexe que de faire tourner un moteur continu même si cela reste encore très simple.
Crédit: AdaFruit Industries www.adafruit.com
Connecter des moteurs pas-à-pas
Pour cette démonstration, utilisé M1 et M2 pour connecter le moteur.
Après avoir raccordé le moteur (voir ci-dessous), rendez vous dans le répertoire Adafruit-Motor-HAT-Python/examples et exécutez la commande sudo python StepperTest.py pour voir le moteur pas-à-pas tourner dans un sens puis l'autre.
Pour les moteurs unipolaires
Pour connecter un moteur pas-à-pas, vous devez d'abord identifier quels sont les fils branchés sur les différentes bobines du moteur. Sur un moteur 6 fils, il faut identifier quels sont les fils correspondant à la connexion centrale de chaque bibine. Sur un moteur 5 fils, il faut identifier le fils qui est connecté sur les sur la connexion centrale des deux bobines. Il existe de nombreux tutoriels expliquant comment faire du "reverse ingeneering" du brochage des moteurs.
La/les connexion(s) centrale(s) des bobines doit/doivent être raccordés ensemble sur le bornier GND du bloc moteur. Ensuite, la bobine 1 devrait être connectée sur l'un des ports moteur, disons M1 et la bobine 2 connectée sur l'autre port, donc M2.
Il est bien entendu possible d'utiliser M3 et M4 à la place des port M1 + M2.
Pour les moteurs bipolaires
Les moteurs bipolaires n'ont pas de 5ieme fils à connecter à la masse. Le code fonctionne à l'identique.
S'il n'y a que 4 fils sur votre moteur pas-à-pas la bobine 1 devrait être connectée sur l'un des ports moteur, disons M1 et la bobine 2 connectée sur l'autre port, donc M2.
Il est bien entendu possible d'utiliser M3 et M4 à la place des ports M1 + M2.
Contrôler un moteur pas-à-pas
Nous allons réviser le contenu du code permettant de prendre le contrôle du moteur à l'aide de la bibliothèque MotorHAT.
Nous commençons par importer les éléments nécessaires pour qu'ils puissent être utilisé par notre script :
#!/usr/bin/python
from Adafruit_MotorHAT import Adafruit_MotorHAT, Adafruit_DCMotor, Adafruit_StepperMotor
import time
import atexit
La bibliothèque MotorHAT contient quelques classes, il y a la classe MotorHAT qui est le principal contrôleur du générateur PWM. Vous aurez toujours besoin de créer un objet et de fixer l'adresse. L'adresse par défaut est 0x60 (voyez la concernant l'empilement des HATs où il sera nécessaire de changer l'adresse).
# Créer l'objet par défaut, indiquer l'adresse I2C (celle par défaut), pas de changement de fréquence.
mh = Adafruit_MotorHAT(addr = 0x60)
Même si cet exemple n'utilise pas de moteur continu, il reste très important de mentionner que le contrôleur PWM fonctionne toujours de façon autonome. Cela signifie que même si le programme plante (ou si le module noyau crashe), le générateur PWM continue à générer un signal PWM.
Les moteurs pas-à-pas ne continuerons pas à bouger si le script plante mais il est fortement recommandé de garder la section de code at exit pour désactiver le générateur PWM:
# Il est recommandé de faire une auto-désactivation des moteurs
# lors de l'arrêt du programme!
def turnOffMotors():
mh.getMotor(1).run(Adafruit_MotorHAT.RELEASE)
mh.getMotor(2).run(Adafruit_MotorHAT.RELEASE)
mh.getMotor(3).run(Adafruit_MotorHAT.RELEASE)
mh.getMotor(4).run(Adafruit_MotorHAT.RELEASE)
atexit.register(turnOffMotors)
Créer un objet moteur pas-à-pas
Nous disposons maintenant d'un objet MotorHAT pouvant contrôer deux moteurs pas-à-pas. Il est possible d'avoir plusieurs HAT moteurs branchés sur le Raspberry-Pi!
L'objet MotorHAT expose une méthode getStepper() permettant de créer un objet "moteur pas-à-pas" (dit "Stepper" en anglais) permettant de contrôler facilement celui-ci.
La méthode getStepper(steps, portnum) accepte deux paramètres :
- steps - indique le nombre de pas nécessaires pour faire une révolution complète du moteur pas-à-pas (habituellement entre 35 et 200).
- portnum - indique le port à utiliser avec la valeur 1 et 2. Port #1 correspond à M1 et M2, port #2 correspond à M3 et M4
# 200 pas par révolution, moteur sur port 1
myStepper = mh.getStepper(200, 1)
Si vous envisagez utilise la fonction 'bloquante' step() pour avancer de plusieurs pas en une fois alors vous pouvez fixer la vitesse en Rotation Par Minute.
A contrario, si vous voulez utiliser utiliser la fonction oneStep() alors l'étape suivante n'est pas nécessaire.
A noter que la vitesse est approximative car le Raspberry-Pi n'est pas capable de gérer les délais avec la même précision qu'un Arduino. Comme Adafruit voulait des bibliothèques Arduino et Pi similaires, ils ont maintenu la fonction setSpeed() dans la bibliothèque Pi:
myStepper.setSpeed(30) # fixer la vitesse à 30 RPM
Les pas
Les moteurs pas-à-pas diffèrent des moteurs continu en ce sens que le contrôleur (dans ce cas, le Raspberry Pi) doit activer chacune des 4 bobines dans le bon ordre pour que moteur tourne. En alternant l'activation des bobines, le moteur pas-à-pas tournera tout au long du stator. Si les bobines sont activées dans l'ordre opposé alors le moteur tournera dans le sens inverse.
Si le code Python ou le Raspberry-Pi crashe (ou arrête de s'exécuter) alors le moteur cessera de tourner. C'est différent d'un moteur continu qui tourne aussi longtemps qu'une tension est présente aux bornes du moteur.
"StepperMotor" par Wapcaplet; Teravolt.
Il y a quatre types principaux de pas pouvant être utilisé avec le HAT moteur. Les quatre types de pas fonctionnerons avec tous les moteurs unipolaire ou bipolaires.
- Simple pas - dit "Single Steps" en anglais. C'est le type de pasle plus simple et celui qui utilise le moins de puissance. Il utilise une seule bobine pour 'maintenir' le moteur en place (comme indiqué sur la GIF animée ci-dessous).
- Double pas - dit "Double Steps" en anglais. Il est également très simple à mettre en oeuvre, excepté qu'à la place d'une seule bobine, il utilise deux bobines en une fois. Par exemple, à la place de la seule bobine #1 activée, nous aurons les bobines #1 et #2 activées en même temps. Cela utilise plus de puissance (environ 2x plus) mais offrira un mouvement plus "puissant" (d'environ 25%)
- Pas entrelacés - dit "Interleaved Steps". C'est un mélange de fonctionnement en pas simple et en pas double où nous utilison les pas simples entrelacés avec les douvle. Il propose un peu plus de couple que le simple pas en consomme environ 50% de puissance en plus. L'avantage de cette approche est que le moteur apparaît comme ayant 2x plus de pas pour une transition plus fluide entre les pas.
- Microstepping - Le micro pas-à-pas est un mélange de simple pas avec un signal PWM permettant de faire une transition plus file entre les pas (avoir des Micro Pas). C'est plus lent que du pas simple mais cela permet d'atteindre une précision nettement plus importante en multipliant par 8 le nombre de pas du moteur. Le micro-stepping permet, dans ce cas, de réduire l'avance au 1/8 de pas. Cela signifie qu'une révolution complète d'un moteur 200 pas nécessitera donc 8x200 = 1600 pas en mode "micro-stepping".
while (True):
print("Pas simple / Single coil steps")
myStepper.step(100, Adafruit_MotorHAT.FORWARD, Adafruit_MotorHAT.SINGLE)
myStepper.step(100, Adafruit_MotorHAT.BACKWARD, Adafruit_MotorHAT.SINGLE)
print("Double pas / Double coil steps")
myStepper.step(100, Adafruit_MotorHAT.FORWARD, Adafruit_MotorHAT.DOUBLE)
myStepper.step(100, Adafruit_MotorHAT.BACKWARD, Adafruit_MotorHAT.DOUBLE)
print("Pas entrelacés / Interleaved coil steps")
myStepper.step(100, Adafruit_MotorHAT.FORWARD, Adafruit_MotorHAT.INTERLEAVE)
myStepper.step(100, Adafruit_MotorHAT.BACKWARD, Adafruit_MotorHAT.INTERLEAVE)
print("MicroStepping / Microsteps")
myStepper.step(100, Adafruit_MotorHAT.FORWARD, Adafruit_MotorHAT.MICROSTEP)
myStepper.step(100, Adafruit_MotorHAT.BACKWARD, Adafruit_MotorHAT.MICROSTEP)
step() - fonction bloquante
Comme vous pouvez le voir ci-dessus, vous pouvez faire des avances de plusieurs pas en une fois à l'aide de la fonction step()
step(numbre_de_pas, direction, type)
Où :
- nombre_de_pas est le nombre de pas à faire
- direction indique le sens de rotation (FORWARD pour avant et BACKWARD pour l'arrière).
- type est le type de pas SINGLE (simple), DOUBLE (double), INTERLEAVE (entrelacé) ou MICROSTEP (micro-stepping).
Le type de pas entrelacé (INTERLEAVE) tournera l'axe de la moitié du type simple ou double pas (SINGLE ou DOUBLE) parce qu'il y a deux fois plus de pas en mode entrelacé. Le type de pas MICROSTEP tournera l'axe du 1/8 de rotation par rapport au pas simple ou double parce que chaque micro-pas compte pour un pas et qu'il y en a 8x plus! |
Cette approche est l'approche la plus simple mais elle est également bloquante - cela signifie que le programme Python reste occupé pendant toute la phase de déplacement du moteur. Si vous avez deux moteurs et faites les appels suivants:
stepper1.step(100, Adafruit_MotorHAT.FORWARD, Adafruit_MotorHAT.SINGLE)
stepper2.step(100, Adafruit_MotorHAT.BACKWARD, Adafruit_MotorHAT.SINGLE)
Alors le premier moteur se déplacera de 100 pas puis stopper. Ensuite seulement, le second moteur pas-à-pas entamera sa révolution de 100 pas.
Cette approche est intéressante si votre projet s'accommode qu'un seul moteur puisse fonctionner à fois!
Si vous désirez faire fonctionner plusieurs moteurs pas-à-pas en même temps, il est possible d'exploiter le support multitâche de Python. L'exemple DualStepperTest.py exploite le support multitâche et utilise des threads pour faire fonctionner les deux moteurs en même temps.
La partie importante de l'exemple DualStepperTest est la définition d'une fonction qui agit comme un wrapper (surcouche) pour la fonction step():
def stepper_worker(stepper, numsteps, direction, style):
#print("Faire des pas!")
stepper.step(numsteps, direction, style)
#print("Fait")
Il y a quelques instructions d'affichage (print) pour le cas où vous voudriez faire du débogage.
Ensuite, lorsque vous voulez faire tourner le premier moteur pas-à-pas, vous pouvez appeler:
st1 = threading.Thread(target=stepper_worker, args=(myStepper1, numsteps, direction, stepping_style))
st1.start()
Ce qui crée une tâche d'arrière plan (un thread) pour faire tourner Stepper1 et rend immédiatement la main au programme principal.
Vous pouvez faire de même avec le second moteur pas-à-pas avec la ligne suivante:
st2 = threading.Thread(target=stepper_worker, args=(myStepper2, numsteps, direction, stepping_style))
st2.start()
Il est possible de savoir lorsque le moteur pas-à-pas à terminé sa rotation parce que le thread créé sera 'mort'. Il est possible de tester les thread avec st1.isAlive() (ou st2.isAlive()). Si vous obtenez la valeur True cela signifie que le moteur tourne (puisque le thread est toujours en cours d'exécution).
oneStep() - fonction non bloquante
Si vous désirez avoir beaucoup plus de contrôle sur vos moteurs pas-à-pas, vous pouvez utiliser la fonction oneStep(direction, type_de_pas) qui exécute l'avance d'un simple pas sans délai. Cela permettra à votre programme d'exécuter des avances d'un pas exactement au moment souhaité.
Source: Adafruit DC and Stepper Motor HAT for Raspberry Pi
Créé par LadyAda pour AdaFruit Industries.
Traduction réalisée par Meurisse D pour 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.
Traduit avec l'autorisation d'AdaFruit Industries - Translated with the permission from Adafruit Industries - www.adafruit.com