ASSISTANCE TECHNIQUE
Publié 2026-04-22
Ce guide fournit une approche complète, étape par étape, pour écrire du code de microcontrôleur qui contrôle avec précision un standard.servomoteurmoteur. Vous apprendrez les exigences exactes en matière de synchronisation des impulsions, consulterez des exemples de codes testés et obtiendrez des étapes concrètes pour que votreservomoteurse déplacer avec précision de 0 à 180 degrés. Tous les exemples sont basés sur des configurations courantes et évitent toute dépendance spécifique à la marque, vous pouvez donc les appliquer à pratiquement n'importe quelle carte microcontrôleur générique.
Tous les servomoteurs standards (couramment utilisés dans les bras robotiques, les véhicules RC et les cardans de caméra) répondent au même type de signal de commande :Modulation de largeur d'impulsion (PWM) à 50 Hz. Cela signifie que vous devez générer une impulsion répétitive toutes les 20 millisecondes. La position du servo est déterminée uniquement par la largeur de l'impulsion haute dans cette trame de 20 ms :
impulsion de 0,5 ms→ 0 degré (complètement à gauche/dans le sens inverse des aiguilles d'une montre)
impulsion de 1,5 ms→ 90 degrés (centre)
Impulsion de 2,5 ms→ 180 degrés (complètement à droite/dans le sens des aiguilles d'une montre)
Toute largeur d'impulsion comprise entre 0,5 ms et 2,5 ms donne un angle intermédiaire proportionnel. Par exemple, une impulsion de 1,0 ms correspond à 45 degrés et une impulsion de 2,0 ms correspond à 135 degrés.
> Fait critique à retenir :Si la largeur de votre impulsion descend en dessous de 0,5 ms ou au-dessus de 2,5 ms, le servo peut trembler, surchauffer ou être endommagé. Fixez toujours vos valeurs à cette plage de sécurité.
Le code suivant est écrit en standard C, et peut être compilé pour presque tous les microcontrôleurs 8 bits ou 32 bits. Vous devrez adapter les noms de la minuterie et des registres GPIO à votre matériel spécifique, mais la logique reste identique.
Tout d’abord, configurez une minuterie matérielle pour générer une période de 20 ms. La plupart des microcontrôleurs ont une minuterie de 16 bits. En supposant une horloge système de 16 MHz (très courante), vous pouvez configurer la minuterie comme suit :
// Pré-échelle de minuterie : 64 // Période de minuterie pendant 20 ms = 16 000 000 Hz / 64 = 250 000 coups par seconde // Pendant 20 ms (0,02 sec) : 250 0000,02 = 5000 ticks de minuterie #define TIMER_PERIOD_20MS 5000 void init_servo_timer(void) { // Définir le mode de minuterie sur PWM avec la valeur supérieure = 5000 // Activer le canal de comparaison de sortie pour la broche de commande d'asservissement // Exemple d'écriture de registre (générique) TCCR1A = (1La relation est linéaire. Utilisez cette formule :
// angle : 0 à 180 degrés // renvoie la largeur d'impulsion en microsecondes (500 à 2 500) uint16_t angle_to_pulse(uint8_t angle) { if (angle > 180) angle = 180 ; // 500 us + (angle (2000 us / 180 deg)) renvoie 500 + (angle 2000 / 180);
}
Convertissez ensuite les microsecondes en ticks de minuterie. Si votre horloge est de 250 kHz (16 MHz / 64 = 250 000 Hz), chaque tick = 4 microsecondes. Donc:
uint16_t pulse_to_ticks(uint16_t pulse_us) { return pulse_us / 4; // parce que 4 us par tick }Combinez le tout dans une fonction qui définit la position du servo :
void set_servo_angle(uint8_t angle) { uint16_t pulse_us = angle_to_pulse(angle); uint16_t ticks = pulse_to_ticks(pulse_us); // Mise à jour du registre de comparaison OCR1A = ticks ; }
Pour qu’un bras robotique ramasse un objet, vous avez souvent besoin d’un mouvement progressif pour éviter les secousses. Voici une boucle complète qui balaie le servo de 0° à 180° et inversement :
#inclure#inclure// ... initialisation du timer comme ci-dessus ... int main(void) { init_servo_timer(); while (1) { // Balayage de 0 à 180 degrés pour (uint8_t angle = 0; angle 0; angle--) { set_servo_angle(angle); _delay_ms(15); } } renvoie 0 ; } Prenons un projet éducatif simple dans lequel un servo soulève un petit objet. Un élève construit une pince à l'aide de deux servos : un pour la rotation du poignet, un pour l'ouverture/fermeture de la poignée. Après avoir écrit le code ci-dessus, ils remarquent que le servo vibre lorsqu'il est réglé à 0°. La cause ? Leur calcul de largeur d'impulsion a produit 495 µs en raison d'erreurs d'arrondi des nombres entiers. Le correctif ajoutait une vérification de saturation :
uint16_t angle_to_pulse_safe(uint8_t angle) { uint16_t impulsion = 500 + (angle 2000/180); si (impulsion 2500) impulsion = 2500 ; impulsion de retour ; }Autre problème courant : l'utilisation d'une alimentation 5V partagée avec le microcontrôleur. Lorsque le servo bouge, il consomme jusqu'à 500 mA, provoquant la réinitialisation du microcontrôleur.La solutionconsiste toujours à alimenter le servo à partir d'une alimentation 5 V/2 A séparée et à connecter uniquement le fil de signal et la masse au microcontrôleur. Ne tirez jamais de courant d’asservissement via le régulateur de tension du microcontrôleur.
1. Vérifiez votre minuterie– Calculez la période exacte du tick de la minuterie. Un décalage de seulement 1 µs par tick peut provoquer une erreur de 20° à des angles extrêmes. Utilisez un oscilloscope pour mesurer la sortie réelle de largeur d'impulsion.
2. Ajouter des limites logicielles– Même si votre code ne demande que 0 à 180°, le bruit électrique peut provoquer des problèmes. Implémentez un filtre qui rejette les largeurs d’impulsion en dehors de 400 à 2 600 µs.
3. Utilisez un convertisseur de niveau logique si nécessaire– De nombreux servos fonctionnent avec une logique 5V. Si votre microcontrôleur fonctionne à 3,3 V, utilisez un levier de niveau dédié ; sinon, le servo pourrait ne pas reconnaître l'impulsion élevée.
4. Incluez toujours un condensateur de 100 à 470 µF– Placez un condensateur électrolytique entre les broches d'alimentation et de masse du servo, aussi près que possible du servo. Cela absorbe les pointes de contre-EMF et empêche la réinitialisation du microcontrôleur.
5. Testez votre code sans charger au préalable– Détachez le palonnier du servo et lancez le balayage. Écoutez un mouvement fluide sans bourdonnement. Un bourdonnement indique un timing d’impulsion incorrect ou une puissance insuffisante.
La clé absolue pour écrire un code de servo fonctionnel estgénérer un signal PWM stable à 50 Hz avec des largeurs d'impulsion précises comprises entre 0,5 ms et 2,5 ms. Quel que soit le microcontrôleur que vous utilisez, si vous y parvenez, votre servo se déplacera exactement selon l'angle souhaité. Les exemples de code ci-dessus ont été testés sur plusieurs plates-formes génériques et fonctionnent de manière fiable lorsque les paramètres d'alimentation et de minuterie sont correctement implémentés.
Copiez leangle_to_pulse_safe()fonctionner dans votre projet.
Configurez une minuterie pour produire une période de 20 ms (50 Hz).
Écrivez la largeur d'impulsion dans le registre de comparaison en utilisant la vitesse d'horloge de votre minuterie.
Alimentez le servo à partir d’une alimentation 5 V séparée avec un condensateur de 470 µF.
Exécutez le test de balayage. S'il passe doucement de 0° à 180°, votre code est correct.
Heure de mise à jour：2026-04-22
Contactez le spécialiste des produits Kpower pour recommander un moteur ou une boîte de vitesses adapté à votre produit.
