|
|
| (16 versions intermédiaires par le même utilisateur non affichées) |
| Ligne 1 : |
Ligne 1 : |
| | {{MicroPython-Hack-Prepare-NAV}} | | {{MicroPython-Hack-Prepare-NAV}} |
| | | | |
| − | {{traduction}} | + | {{MicroPython-Hack-servo-core}} |
| − | | |
| − | == Contrôler un Servo moteur ==
| |
| − | | |
| − | {{bloc-etroit|text=Sur la PyBoard, il y a 4 points de connexion dédiés au branchement de servo-moteur hobbyiste (voyez ce-dessous).}}
| |
| − | | |
| − | [[Fichier:MicroPython-Hack-servo.jpg|480px]]
| |
| − | | |
| − | == Qu'est-ce qu'un servo moteur? ==
| |
| − | Un servo-moteur est un type de moteur électrique. C'est un dispositif typiquement utilisé en modélisme pour, par exemple, contrôler la direction d'une voiture télécommandée.
| |
| − | | |
| − | [[fichier:servomoteur.jpg]]
| |
| − | | |
| − | Sur un servo-moteur, l'angle de de l'axe reste fixé dans une position et peu varier entre 0 et 180° en fonction du signal envoyé.
| |
| − | Un servo-moteur comprend :
| |
| − | * Un moteur électrique (continu), généralement assez petit.
| |
| − | * Des engrenages réducteur en sortie du ce moteur (pour avoir moins de vitesse et plus de couple ou de force).
| |
| − | * Un capteur type "potentiomètre" raccordé sur la sortie.
| |
| − | ** Il s'agit donc d'une résistance qui varie en fonction de l'angle, ce qui permet de mesurer l'angle de rotation sur l'axe de sortie.
| |
| − | ** Un asservissement électronique pour contrôler la position/rotation, de cet axe de sortie pour le maintenir à la bonne position.
| |
| − | | |
| − | === Commander électronique d'un servo-moteur? ===
| |
| − | Le principe de base est assez simple. Il suffit d'envoyer une impulsion et c'est le temps que durera cette impulsion qui déterminera l'angle du servo-moteur.
| |
| − | ce temps d'impulsion est de quelques de quelques millisecondes et doit être répété à intervalle régulier (toutes les 20 ms à 50ms).
| |
| − | Si le temps d'impulsion varie d'un fabricant à l'autre, les valeurs suivantes sont assez standard:
| |
| − | | |
| − | * 1.25 ms = 0 degré
| |
| − | * 1.50 ms = 90 degrés
| |
| − | * 1.75 ms = 180 degrés
| |
| − | | |
| − | [[Fichier:ServoImpluseAngle.jpg|450px]]
| |
| − | | |
| − | Source: [http://www.rc-bot.com/tpebot.php?part=motorisation Area RC-Bot]
| |
| − | | |
| − | == Raccordement d'un servo-moteur ==
| |
| − | Puisque l'interface de commande est assez simple, un servo-moteur se raccorde avec seulement 3 fils (la masse, +5v et la commande d'impulsion).
| |
| − | Les raccordements les plus standardisés sont:
| |
| − | | |
| − | === Noir, Rouge, Blanc ===
| |
| − | * Noir: Raccordé à la Masse,
| |
| − | * Rouge: Alimentation moteur et logique de commande. Raccordé à VCC 5v,
| |
| − | * Blanc: Commande de la position du servo-moteur.
| |
| − | | |
| − | === Marron, Rouge, Jaune ===
| |
| − | Couleurs du standard [http://www.graupner.de/fr/products/e34b2ab4-ebb7-436c-8d26-a59f0d2b1979/7947/product.aspx Graupner].
| |
| − | | |
| − | [[Fichier:servograupner.png|300px]]
| |
| − |
| |
| − | * Marrons: Raccordé à la Masse,
| |
| − | * Rouge: Alimentation moteur et logique de commande. Raccordé à VCC 5v,
| |
| − | * Jaune: Commande de la position du servo-moteur.
| |
| − | | |
| − | === Les autres cas ===
| |
| − | La plupart des servo-moteur ont 3 conducteurs avec des couleurs noir, rouge et blanc OU brun, rouge et orange/jaune/etc:
| |
| − | | |
| − | [[Fichier:servo-autre-raccord.jpg|300px]]
| |
| − | | |
| − | * brun ou nour = MASSE/GND (borne négative de l'alimentation)
| |
| − | * Rouge = alimentation servo (Vservo, borne positive de l'alimentation)
| |
| − | * Orange, jaune, blanc ou bleu = Commande de position du servo
| |
| − | | |
| − | Vérifiez la fiche technique de votre servo pour déterminer la tension d'alimentation adéquate et faite très attention lorsque vous branchez un servo sur un périphérique afin qu'il soit orienté correctement (il n'y a pas de détrompeur et brancher le servo à l'envers pourrait détruire le périphérique).
| |
| − | | |
| − | == Brancher un Servo Moteur ==
| |
| − | Les servo-moteurs dispose de 3 fils: la masse/gnd, l'alimentation/power et le signal.
| |
| − | | |
| − | [[Fichier:MicroPython-Hack-servo.jpg|480px]]
| |
| − | | |
| − | Le fil de masse/ground d'un servo c'est souvent celui qui à la couleur la plus sombre (ex: noir ou brun). Le fil d'alimentation est est habituellement en rouge (sur les moteur hobbyiste il est toujours au centre).
| |
| − | | |
| − | Pour finir, le dernier fil est celui portant le signal (jaune, orange ou blanc).
| |
| − | | |
| − | | |
| − | [[Fichier:MicroPython-Hack-servo-wire-01.jpg|480px]]
| |
| − | | |
| − | Notez la broche de signal (fil blanc dans ce cas) est sur la droite du connecteur.
| |
| − | | |
| − | Comme les servo-moteurs sont équipés de fiche femelle, l'idéal est d'utiliser une {{pl|97|petite section pinHeader extra-long}} pour faciliter le raccordement.
| |
| − | | |
| − | [[Fichier:MicroPython-Hack-servo-wire-02.jpg|480px]]
| |
| − | | |
| − | Et voila, le servo-moteur moteur est branché sur le premier connecteur.
| |
| − | | |
| − | === Alimenter les servo moteurs ===
| |
| − | La broche d'alimentation des moteur (libellée VIN) est directement branché sur la source d'alimentation de la carte PyBoard.
| |
| − | | |
| − | Lorsque vous alimentez votre PyBoard par USB, VIN est alimenté par l'intermédiaire d'une diode (par l'intermédiaire de l'alimentation USB 5 Volts). Connecté en USB, la carte PyBoard est capable d'alimenter 4 {{pl|64|petit servo-moteur}}.
| |
| − | | |
| − | {{ambox-stop|text=Si vous alimentez la carte PyBoard via des piles (ou accu) et que vous utilisez des servo-moteur, assurez-vous de ne pas dépasser 6 volts (c'est la tension maximale d'alimentation de la plupart des servo-moteurs)}}
| |
| − | | |
| − | Notez que certains servo-moteurs n'acceptent pas une tension supérieur à 4.8V, n'hésitez donc pas à vérifier la fiche technique de votre moteur.
| |
| − | | |
| − | == Commander un servo-moteur ==
| |
| − | Plug in a servo to position 1 (the one with pin X1) and create a servo object using:
| |
| − | | |
| − | <nowiki>>>> servo1 = pyb.Servo(1)</nowiki>
| |
| − | | |
| − | To change the angle of the servo use the angle method:
| |
| − | | |
| − | <nowiki>>>> servo1.angle(45)
| |
| − | >>> servo1.angle(-60)</nowiki>
| |
| − | | |
| − | The angle here is measured in degrees, and ranges from about -90 to +90, depending on the motor. Calling angle without parameters will return the current angle:
| |
| − | | |
| − | <nowiki>>>> servo1.angle()
| |
| − | -60</nowiki>
| |
| − | | |
| − | Note that for some angles, the returned angle is not exactly the same as the angle you set, due to rounding errors in setting the pulse width.
| |
| − | | |
| − | You can pass a second parameter to the {{fname|angle}} method, which specifies how long to take (in milliseconds) to reach the desired angle. For example, to take 1 second (1000 milliseconds) to go from the current position to 50 degrees, use
| |
| − | | |
| − | <nowiki>>>> servo1.angle(50, 1000)</nowiki>
| |
| − | | |
| − | This command will return straight away and the servo will continue to move to the desired angle, and stop when it gets there. You can use this feature as a speed control, or to synchronise 2 or more servo motors. If we have another servo motor ({{fname|1=servo2 = pyb.Servo(2)}}) then we can do
| |
| − | | |
| − | <nowiki>>>> servo1.angle(-45, 2000); servo2.angle(60, 2000)</nowiki>
| |
| − | | |
| − | This will move the servos together, making them both take 2 seconds to reach their final angles.
| |
| − | | |
| − | Note: the semicolon between the 2 expressions above is used so that they are executed one after the other when you press enter at the REPL prompt. In a script you don’t need to do this, you can just write them one line after the other.
| |
| − | 1.2. Continuous rotation servos
| |
| − | | |
| − | == Commander servo à rotation continue ==
| |
| − | So far we have been using standard servos that move to a specific angle and stay at that angle. These servo motors are useful to create joints of a robot, or things like pan-tilt mechanisms. Internally, the motor has a variable resistor (potentiometer) which measures the current angle and applies power to the motor proportional to how far it is from the desired angle. The desired angle is set by the width of a high-pulse on the servo signal wire. A pulse width of 1500 microsecond corresponds to the centre position (0 degrees). The pulses are sent at 50 Hz, ie 50 pulses per second.
| |
| − | | |
| − | You can also get continuous rotation servo motors which turn continuously clockwise or counterclockwise. The direction and speed of rotation is set by the pulse width on the signal wire. A pulse width of 1500 microseconds corresponds to a stopped motor. A pulse width smaller or larger than this means rotate one way or the other, at a given speed.
| |
| − | | |
| − | On the pyboard, the servo object for a continuous rotation motor is the same as before. In fact, using {{fname|angle}} you can set the speed. But to make it easier to understand what is intended, there is another method called {{fname|speed}} which sets the speed:
| |
| − | | |
| − | <nowiki>>>> servo1.speed(30)</nowiki>
| |
| − | | |
| − | {{fname|speed}} has the same functionality as {{fname|angle}}: you can get the speed, set it, and set it with a time to reach the final speed.
| |
| − | | |
| − | <nowiki>>>> servo1.speed()
| |
| − | 30
| |
| − | >>> servo1.speed(-20)
| |
| − | >>> servo1.speed(0, 2000)</nowiki>
| |
| − | | |
| − | The final command above will set the motor to stop, but take 2 seconds to do it. This is essentially a control over the acceleration of the continuous servo.
| |
| − | | |
| − | A servo speed of 100 (or -100) is considered maximum speed, but actually you can go a bit faster than that, depending on the particular motor.
| |
| − | | |
| − | The only difference between the {{fname|angle}} and {{fname|speed}} methods (apart from the name) is the way the input numbers (angle or speed) are converted to a pulse width.
| |
| − | | |
| − | == Calibration ==
| |
| − | The conversion from angle or speed to pulse width is done by the servo object using its calibration values. To get the current calibration, use
| |
| − | | |
| − | <nowiki>>>> servo1.calibration()
| |
| − | (640, 2420, 1500, 2470, 2200)</nowiki>
| |
| − | | |
| − | There are 5 numbers here, which have meaning:
| |
| − | * Minimum pulse width; the smallest pulse width that the servo accepts.
| |
| − | * Maximum pulse width; the largest pulse width that the servo accepts.
| |
| − | * Centre pulse width; the pulse width that puts the servo at 0 degrees or 0 speed.
| |
| − | * The pulse width corresponding to 90 degrees. This sets the conversion in the method {{fname|angle}} of angle to pulse width.
| |
| − | * The pulse width corresponding to a speed of 100. This sets the conversion in the method {{fname|speed}} of speed to pulse width.
| |
| − | | |
| − | You can recalibrate the servo (change its default values) by using:
| |
| − | | |
| − | <nowiki>>>> servo1.calibration(700, 2400, 1510, 2500, 2000)</nowiki>
| |
| − | | |
| − | Of course, you would change the above values to suit your particular servo motor.
| |
| − | | |
| − | {{MicroPython-Hack-Servo-TRAILER}}
| |
| − | | |
| − | == Servo à rotation continue ==
| |
| − | So far we have been using standard servos that move to a specific angle and stay at that angle. These servo motors are useful to create joints of a robot, or things like pan-tilt mechanisms. Internally, the motor has a variable resistor (potentiometer) which measures the current angle and applies power to the motor proportional to how far it is from the desired angle. The desired angle is set by the width of a high-pulse on the servo signal wire. A pulse width of 1500 microsecond corresponds to the centre position (0 degrees). The pulses are sent at 50 Hz, ie 50 pulses per second.
| |
| − | | |
| − | | |
| − | You can also get continuous rotation servo motors which turn continuously clockwise or counterclockwise. The direction and speed of rotation is set by the pulse width on the signal wire. A pulse width of 1500 microseconds corresponds to a stopped motor. A pulse width smaller or larger than this means rotate one way or the other, at a given speed.
| |
| − | | |
| − | | |
| − | On the pyboard, the servo object for a continuous rotation motor is the same as before. In fact, using {{fname|angle}} you can set the speed. But to make it easier to understand what is intended, there is another method called {{fname|speed}} which sets the speed:
| |
| − | | |
| − | >>> servo1.speed(30)
| |
| − | | |
| − | speed has the same functionality as angle: you can get the speed, set it, and set it with a time to reach the final speed.
| |
| − | | |
| − | >>> servo1.speed()
| |
| − | 30
| |
| − | >>> servo1.speed(-20)
| |
| − | >>> servo1.speed(0, 2000)
| |
| − | | |
| − | The final command above will set the motor to stop, but take 2 seconds to do it. This is essentially a control over the acceleration of the continuous servo.
| |
| − | | |
| − | A servo speed of 100 (or -100) is considered maximum speed, but actually you can go a bit faster than that, depending on the particular motor.
| |
| − | | |
| − | The only difference between the angle and speed methods (apart from the name) is the way the input numbers (angle or speed) are converted to a pulse width.
| |
| − | 1.3. Calibration
| |
| − | | |
| − | The conversion from angle or speed to pulse width is done by the servo object using its calibration values. To get the current calibration, use
| |
| − | | |
| − | >>> servo1.calibration()
| |
| − | (640, 2420, 1500, 2470, 2200)
| |
| − | | |
| − | There are 5 numbers here, which have meaning:
| |
| − | | |
| − | Minimum pulse width; the smallest pulse width that the servo accepts.
| |
| − | Maximum pulse width; the largest pulse width that the servo accepts.
| |
| − | Centre pulse width; the pulse width that puts the servo at 0 degrees or 0 speed.
| |
| − | The pulse width corresponding to 90 degrees. This sets the conversion in the method angle of angle to pulse width.
| |
| − | The pulse width corresponding to a speed of 100. This sets the conversion in the method speed of speed to pulse width.
| |
| − | | |
| − | You can recalibrate the servo (change its default values) by using:
| |
| − | | |
| − | >>> servo1.calibration(700, 2400, 1510, 2500, 2000)
| |
| − | | |
| − | Of course, you would change the above values to suit your particular servo motor.
| |
| − | | |
| | | | |
| | {{MicroPython-Hack-Servo-TRAILER}} | | {{MicroPython-Hack-Servo-TRAILER}} |
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.Contrôler un Servo moteur
Sur la PyBoard, il y a 4 points de connexion dédiés au branchement de servo-moteur hobbyiste (voyez ce-dessous).
Qu'est-ce qu'un servo moteur?
Un servo-moteur est un type de moteur électrique. C'est un dispositif typiquement utilisé en modélisme pour, par exemple, contrôler la direction d'une voiture télécommandée.
Sur un servo-moteur, l'angle de de l'axe reste fixé dans une position et peu varier entre 0 et 180° en fonction du signal envoyé.
Un servo-moteur comprend :
- Un moteur électrique (continu), généralement assez petit.
- Des engrenages réducteur en sortie du ce moteur (pour avoir moins de vitesse et plus de couple ou de force).
- Un capteur type "potentiomètre" raccordé sur la sortie.
- Il s'agit donc d'une résistance qui varie en fonction de l'angle, ce qui permet de mesurer l'angle de rotation sur l'axe de sortie.
- Un asservissement électronique pour contrôler la position/rotation, de cet axe de sortie pour le maintenir à la bonne position.
Commander électronique d'un servo-moteur?
Le principe de base est assez simple. Il suffit d'envoyer une impulsion et c'est le temps que durera cette impulsion qui déterminera l'angle du servo-moteur.
ce temps d'impulsion est de quelques de quelques millisecondes et doit être répété à intervalle régulier (toutes les 20 ms à 50ms).
Si le temps d'impulsion varie d'un fabricant à l'autre, les valeurs suivantes sont assez standard:
- 1.25 ms = 0 degré
- 1.50 ms = 90 degrés
- 1.75 ms = 180 degrés
Source: Area RC-Bot
Raccordement d'un servo-moteur
Puisque l'interface de commande est assez simple, un servo-moteur se raccorde avec seulement 3 fils (la masse, +5v et la commande d'impulsion).
Les raccordements les plus standardisés sont:
Noir, Rouge, Blanc
- Noir: Raccordé à la Masse,
- Rouge: Alimentation moteur et logique de commande. Raccordé à VCC 5v,
- Blanc: Commande de la position du servo-moteur.
Marron, Rouge, Jaune
Couleurs du standard Graupner.
- Marrons: Raccordé à la Masse,
- Rouge: Alimentation moteur et logique de commande. Raccordé à VCC 5v,
- Jaune: Commande de la position du servo-moteur.
Les autres cas
La plupart des servo-moteur ont 3 conducteurs avec des couleurs noir, rouge et blanc OU brun, rouge et orange/jaune/etc:
- brun ou noir = MASSE/GND (borne négative de l'alimentation)
- Rouge = alimentation servo (Vservo, borne positive de l'alimentation)
- Orange, jaune, blanc ou bleu = Commande de position du servo
Vérifiez la fiche technique de votre servo pour déterminer la tension d'alimentation adéquate et faite très attention lorsque vous branchez un servo sur un périphérique afin qu'il soit orienté correctement (il n'y a pas de détrompeur et brancher le servo à l'envers pourrait détruire le périphérique).
Montage
Le matériel nécessaire
Brancher un Servo Moteur
Les servo-moteurs dispose de 3 fils: la masse/gnd, l'alimentation/power et le signal.
Le fil de masse/ground d'un servo c'est souvent celui qui à la couleur la plus sombre (ex: noir ou brun). Le fil d'alimentation est est habituellement en rouge (sur les moteur hobbyiste il est toujours au centre).
Pour finir, le dernier fil est celui portant le signal (jaune, orange ou blanc).
Notez la broche de signal (fil blanc dans ce cas) est sur la droite du connecteur.
Comme les servo-moteurs sont équipés de fiche femelle, vous pouvez utiliser des fils mâle-mâle (l'idéal est d'utiliser une petite section pinHeader extra-long pour faciliter le raccordement).
Et voila, le servo-moteur moteur est branché sur le premier connecteur.
Alimenter les servo moteurs en 5V
La broche d'alimentation des moteur (libellée VIN) est directement branché sur la source d'alimentation de la carte PyBoard.
Lorsque vous alimentez votre PyBoard par USB, VIN est alimenté par l'intermédiaire d'une diode (par l'intermédiaire de l'alimentation USB 5 Volts). Connecté en USB, la carte PyBoard est capable d'alimenter 4 petit servo-moteur.
Notez que certains servo-moteurs n'acceptent pas une tension supérieur à 4.8V, n'hésitez donc pas à vérifier la fiche technique de votre moteur.
Commander un servo-moteur
Branchez le servo moteur sur la position 1 (celle de la broche X1 comme montré ci-dessus) et créez un objet servo en utilisant:
>>> servo1 = pyb.Servo(1)
Pour changer l'angle du servo, il faut utiliser la méthode servo:
>>> servo1.angle(45)
>>> servo1.angle(-60)
L'angle est mesuré en degrés et la valeur comprise entre -90 et +90 (environ, cela dépend du moteur).
Appeler la méthode angle sans paramètre retournera l'angle actuel du moteur:
>>> servo1.angle()
-60
Note: Pour certaines valeur d'angle, la valeur retournée n'est pas exactement la même que celle utilisée pour assigner l'angle. Cela est dut aux erreurs d'arrondis lorsque la carte PyBoard calcule et assigne la longueur d'impulsion.
Vous pouvez passer un second paramètre à la méthode angle, qui spécifie en combien de temps (en milliseconde) le servo-moteur doit atteindre l'angle désiré. Par exemple, pour prendre une seconde (1000 millisecondes)pour aller de la position courante à 50 degréee, il faut utiliser:
>>> servo1.angle(50, 1000)
Cette commande termine son exécution immédiatement mais le servo continue son déplacement jusqu'à l'angle désiré puis arrêté une fois la position atteinte. Vous pouvez utiliser cette fonctionnalité pour contrôler la vitesse de déplacement ou pour synchroniser 2 ou plusieurs servo moteurs. Si nous avons un autre servo moteur (servo2 = pyb.Servo(2)) alors nous pouvons faire:
>>> servo1.angle(-45, 2000); servo2.angle(60, 2000)
Cela bougera les deux servos ensembles, faisant en sorte que les deux moteurs prennent deux secondes pour atteindre leurs angles finals.
Note: le point-virgule entre les deux expressions ci-dessous est utilisé pour faire en sorte que les commandes sont exécutées l'une après l'autre lorsque vous pressez la touche enter/retour-clavier sur l'invite de commande REPL. Dans un script, cela n'est pas nécessaire, vous pouvez simplement écrire les commandes sur deux lignes l'une après l'autre.
Commander servo à rotation continue
Jusqu'à maintenant, nous avons utiliser un servo moteur standard pour bouger l'axe à un angle spécifique (et le garder). Ces servo-moteurs sont utiles pour créer des jointures de robot ou de petites choses tels que des mécanismes d'orientation de caméra.
A l'intérieur, le moteur est équipé d'une résistance variable (potentiomètre) qui mesure l'angle actuel et appliquer une puissance proportionnelle à la distance à parcourir pour atteindre l'angle désiré. L'angle désiré est indiqué à l'aide d'une impulsion répétitive dont la largeur d'impulsion avant le front haut indique l'angle à atteindre. Ce signal est envoyé sur le fil de signal. Une largeur d'impulsion de 1500 microsecondes correspond à la position centrale (0 degrées). Les impulsions sont envoyées à 50 Hz (soit 50 impulsions par seconde).
Mais il existe aussi les servo à rotation continue...
avec ce type de moteur, vous pouvez réaliser des projets comme la planche à pain mobile mais avec une carte PyBoard.
PAPM
La Plance A Pain Mobile (PAMP) est un projet pour réaliser une plateforme mobile abordable.
Les servo-moteurs à rotation continue tournent continuellement dans le sens horlogique, anti-horlogique ou reste à l'arrêt. La direction et la vitesse de rotation est configuré par la largeur d'impulsion sur le fil de signal. Une largeur d'impulsion de 1500 microsecondes correspond à un moteur à l'arrêt. Une largeur d'impulsion plus petite ou plus large fera tournée le moteur dans un sens ou dans l'autre (à une vitesse donnée).
Sur la carte PyBoard, l'objet servo est le même lorsque vous voulez utiliser des servo à rotation continue. En réalité, vous pouvez fixer la vitesse en utilisant la méthode angle. Mais pour rendre le tout plus facile à comprendre, il y a une autre méthode appelée speed qui fice la vitesse:
>>> servo1.speed(30)
speed dispose de la même fonctionnalité que angle: vous pouvez lire la vitesse, la fixer mais également indiquer le temps pour l'atteindre.
>>> servo1.speed()
30
>>> servo1.speed(-20)
>>> servo1.speed(0, 2000)
La dernière commande ci-dessus arrête le moteur, mais prend deux seconde pour le faire. Il s'agit principalement d'un contrôle de l'accélération pour moteur à rotation continue.
Une vitesse de servo de 100 (ou -100) est considéré comme la vitesse maximale mais, en réalité, vous pouvez aller un peu plus vite mais cela dépend des caractéristiques particulières du moteur.
La seule différence qui existe entre les méthodes angle et speed est la façon dont ont passe les valeurs en paramètre (angle ou vitesse) et leur conversion en largeur d'impulsion.
Calibration
La conversion d'angle (ou vitesse) vers la largeur d'impulsion est fait par l'objet servo en utilisant ses valeurs de calibration. Pour obtenir la calibration actuelle, utilisez:
>>> servo1.calibration()
(640, 2420, 1500, 2470, 2200)
Qui produit 5 nombres dont voici la signification:
- Largeur d'implusion minimale - la plus petite largeur d'impulsion que le servo moteur peut accepter.
- Largeur d'impulsion maximale - la plus grande largeur d'impulsion que le servo moteur peut accepter.
- Largeur d'impulsion du centre - la largeur d'impulsion correspondant à la position centrale du servo-moteur (soit l'angle 0 degré ou la vitesse 0).
- Largeur d'impulsion à 90° - initialise la conversion angle<->largeur_d_impulsion pour la méthode angle.
- Largeur d'impulsion à vitesse 100 - initialise la conversion vitesse<->largeur_d_impulsion dans la méthode speed.
Vous pouvez recalibrer le servo (modifier les valeurs par défaut) en utilisant:
>>> servo1.calibration(700, 2400, 1510, 2500, 2000)
Bien entendu, vous devriez uniquement modifier ces valeurs a un servo moteur particulier.
Source: Controling Hobby Servo écrit par/written by Damien P.George
Traduit et augmenté par Meurisse D. pour MCHobby.be - Translated and upsized by Meurisse D. for MCHobby.be
Traduit avec l'autorisation de micropython.org - Translated with the authorisation of micropython.org
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.
