ASSISTANCE TECHNIQUE
Publié 2026-04-01
Ce guide fournit une explication complète et pratique du code de modulation de largeur d'impulsion (PWM) pour contrôler lesservomoteurmoteurs. Si vous recherchez le code exact, les instructions de câblage et les principes de synchronisation pour créer unservomoteurdéplacez-vous selon un angle précis, vous êtes au bon endroit. Cet article se concentre sur la norme universellement acceptée pourservomoteurcontrol (le signal PWM 50 Hz avec une largeur d'impulsion comprise entre 1 ms et 2 ms) et fournit des exemples de code fonctionnel indépendants du matériel, garantissant que vous pouvez les appliquer à n'importe quelle plate-forme de microcontrôleur.
Au fond, contrôler un servo analogique standard ne consiste pas à envoyer des paquets de données complexes mais à générer une impulsion électrique spécifique et répétitive. Les circuits internes du servo interprètent la largeur de cette impulsion pour déterminer la position cible de son arbre de sortie.
Le signal de commande standard est défini par deux paramètres clés :
1. Période (Fréquence) :Le signal se répète toutes les 20 millisecondes (ms). Cela équivaut à une fréquence de 50 Hz (1/0,02 s = 50 Hz).
2. Largeur d'impulsion (cycle de service) :La durée pendant laquelle le signal est haut (logique 1) au cours de cette période de 20 ms. Cette valeur correspond directement à l'angle du servo.
La cartographie entre la largeur et l’angle d’impulsion est l’information critique. Pour la grande majorité des servos standards, la relation est linéaire et suit cette spécification standard de l'industrie :
Impulsion de 1,0 ms :Fait pivoter le servo à 0 degré (complètement dans le sens inverse des aiguilles d'une montre).
Impulsion de 1,5 ms :Fait pivoter le servo à 90 degrés (position centrale).
Impulsion de 2,0 ms :Fait pivoter le servo à 180 degrés (à fond dans le sens des aiguilles d'une montre).
Bien que de nombreux servos respectent cette norme, il est essentiel de vérifier la plage exacte de votre modèle spécifique, car certains servos à couple élevé ou spécialisés peuvent avoir des points finaux légèrement différents (par exemple, 0,9 ms à 2,1 ms). Les exemples de code ci-dessous sont structurés pour permettre un ajustement facile de ces constantes de largeur d'impulsion minimale et maximale.
La logique du code est cohérente sur toutes les plates-formes : initialisez une minuterie/compteur pour générer un signal de 50 Hz, puis modulez le "temps de marche" de ce signal pour définir l'angle du servo. Le pseudo-code suivant illustre la logique de base, que vous pouvez adapter à n'importe quel environnement de programmation.
// --- Constantes de configuration --- #define PWM_FREQUENCY_HZ 50 #define PERIOD_MS (1000 / PWM_FREQUENCY_HZ) // Calcule jusqu'à 20 ms #define PULSE_MIN_MS 1.0 // Largeur d'impulsion pour 0 degrés #define PULSE_MAX_MS 2.0 // Largeur d'impulsion pour 180 degrés #define ANGLE_MIN 0 #define ANGLE_MAX 180 // --- Fonction pour mapper un angle sur une largeur d'impulsion --- float angleToPulseWidth(int angle_degrees) { // Contraindre l'angle à une plage valide if (angle_degrees ANGLE_MAX) angle_degrees = ANGLE_MAX; // Mappage linéaire de la plage d'angle à la plage de largeur d'impulsion float pulse_width = PULSE_MIN_MS + ( (float)(angle_degrees - ANGLE_MIN) / (ANGLE_MAX - ANGLE_MIN) )(PULSE_MAX_MS - PULSE_MIN_MS) ; renvoyer pulse_width ; } // --- Concept principal de la boucle de contrôle --- // Dans une implémentation réelle, les éléments suivants seraient gérés par un temporisateur matériel. // 1. Définissez la broche de sortie HIGH. // 2. Attendez (délai) la largeur d'impulsion calculée (par exemple, 1,5 ms). // 3. Réglez la broche de sortie FAIBLE. // 4. Attendez le reste de la période de 20 ms (PERIOD_MS - pulse_width).Pour que cela soit immédiatement exploitable, voici des implémentations concrètes pour deux des plateformes de développement les plus courantes. Les principes restent identiques, démontrant la portabilité du standard 50 Hz, 1-2 ms.
C’est le point d’entrée le plus courant pour les amateurs. L'ArduinoServomoteurLa bibliothèque résume la complexité du minuteur matériel, fournissant une interface propre. Cet exemple est basé sur la pratique standard consistant à connecter le fil de signal du servo à une broche numérique compatible PWM.
#inclure// Crée un objet servo Servo myServo; // Définit la broche connectée au fil de signal du servo const int servoPin = 9; void setup() { // Attache l'objet servo à la broche // La bibliothèque configure automatiquement le signal 50 Hz myServo.attach(servoPin); // --- Scénario courant : centrer le servo au démarrage --- // Dans de nombreuses applications robotiques, il est crucial de démarrer à partir d'une position // sûre connue pour éviter les contraintes mécaniques. Le centrage à 90 degrés // est une bonne pratique universelle. monServo.write(90); // Déplacement vers la position centrale delay(1000); // Laisser le temps pour atteindre la position } void loop() { // Balayage de 0 à 180 degrés pour (int angle = 0; angle = 0; angle--) { myServo.write(angle); retard(15); } } Remarque : Leécrire()La fonction convertit automatiquement l'angle (0-180) en la largeur d'impulsion correcte (1-2 ms).
Sur un Raspberry Pi, vous générez généralement le signal PWM dans un logiciel, ce qui nécessite un timing précis. LeRPi.GPIOLa bibliothèque fournit une interface PWM matérielle sur des broches spécifiques pour des signaux plus précis. Cet exemple reflète l'approche standard pour le contrôle d'un seul servo sur un ordinateur monocarte basé sur Linux.
importer RPi.GPIO en tant que temps d'importation GPIO # Définitions des broches servo_pin = 18 # Utiliser une broche qui prend en charge le matériel PWM, comme GPIO 18 GPIO.setmode(GPIO.BCM) GPIO.setup(servo_pin, GPIO.OUT) # Configuration PWM : fréquence 50 Hz pwm = GPIO.PWM(servo_pin, 50) pwm.start(0) # Démarrer avec 0 % de cycle de service def set_angle(angle): """Convertir un angle (0-180) en cycle de service pour un signal de 50 Hz.""" # Contraindre l'angle d'angle = max(0, min(180, angle)) # Mapper l'angle (0-180) en largeur d'impulsion (1-2 ms) # Pour une période de 20 ms (50 Hz), cycle de service = (pulse_width_ms / 20) 100 pulse_width_ms = 1,0 + (angle / 180,0)1.0 # Correspond à 1,0-2,0 ms duty_cycle = (pulse_width_ms / 20,0)100.0 pwm.ChangeDutyCycle(duty_cycle) # --- Scénario courant : Calibrage d'un nouveau servo --- # Lors de la première intégration d'un servo, il est essentiel de vérifier ses vraies # limites mécaniques. Le code ci-dessous démontre une routine d'étalonnage sûre. try: # Test de la position du centre print("Déplacement à 90 degrés...") set_angle(90) time.sleep(2) # Test de la position à 0 degré (impulsion de 1,0 ms) print("Déplacement à 0 degrés...") set_angle(0) time.sleep(2) # Test de la position à 180 degrés (impulsion de 2,0 ms) print("Déplacement à 180 degrés...") set_angle(180) time.sleep(2) # Retour au centre print("Retour au centre.") set_angle(90) time.sleep(1) except KeyboardInterrupt : print("Arrêté par l'utilisateur") enfin : pwm.stop() GPIO.cleanup()Remarque : Cette méthode utilise le calcul du rapport cyclique. Pour un signal de 50 Hz, une impulsion de 1 ms correspond à un rapport cyclique de (1/20)100 = 5 %. Une impulsion de 2 ms vaut (2/20)100 = 10%.
Même avec un code correct, plusieurs problèmes liés au matériel peuvent empêcher un servo de fonctionner. Comprendre ces scénarios courants vous aidera à diagnostiquer et à résoudre rapidement les problèmes.
1. Alimentation électrique insuffisante :C'est le problème le plus fréquent. Un servo typique peut consommer 200 à 500 mA lors du déplacement et des courants de décrochage encore plus élevés. Les ports USB du microcontrôleur (généralement 500 mA) sont souvent insuffisants, notamment pour plusieurs servos.
Solution:Utilisez une alimentation externe dédiée (par exemple, 5 V provenant d'une batterie ou d'une alimentation de banc régulée). Assurez-vous que la masse (GND) du microcontrôleur est connectée à la masse de l'alimentation externe.
2. Valeurs de synchronisation incorrectes :Si le servo tremble, bourdonne ou ne se déplace pas sur toute la plage, les limites de largeur d'impulsion ne correspondent probablement pas aux spécifications du servo.
Solution:Consultez la fiche technique du servo pour connaître la plage exacte de largeur d'impulsion. Une variation courante est de 0,9 ms à 2,1 ms. Ajustez lePULSE_MIN_MSetPULSE_MAX_MSconstantes dans votre code en conséquence.
3. Dérive de fréquence dans le logiciel PWM :Sur des plates-formes comme le Raspberry Pi sans broches PWM matérielles dédiées, le PWM généré par logiciel peut souffrir d'incohérences de synchronisation dues au multitâche du système d'exploitation.
Solution:Pour les applications critiques ou à grande vitesse, utilisez une carte de servocontrôleur dédiée (comme un PCA9685) qui décharge la synchronisation sur une puce matérielle dédiée, garantissant une génération stable de 50 Hz.
Pour piloter avec succès un servo avec du code PWM, rappelez-vous ces trois principes fondamentaux :
1. Standardisez le signal :Visez toujours à générer un signal précis de 50 Hz. La largeur d'impulsion est la seule variable qui contrôle la position.
2. Mapper les angles aux impulsions :Utilisez le mappage linéaire de 1,0 ms (0°) à 2,0 ms (180°) comme ligne de base. Cette formule fonctionne pour plus de 90 % des servos standards.
3. Prioriser la puissance :Vérifiez que votre source d’alimentation peut fournir le courant requis. Un servo qui tremble de manière erratique est presque toujours un problème de puissance, pas un problème de code.
Étape d'action :Commencez par le simple code de balayage sur la plate-forme de votre choix en utilisant un seul servo. Une fois le balayage effectué, remplacez les angles codés en dur par des entrées de capteur, des valeurs de joystick ou des positions calculées pour intégrer le servo dans votre projet plus vaste. En adhérant à la norme 50 Hz et en vérifiant votre alimentation électrique, vous créez une base solide pour toute application de contrôle de mouvement.
Heure de mise à jour：2026-04-01
Contactez le spécialiste des produits Kpower pour recommander un moteur ou une boîte de vitesses adapté à votre produit.
