ASSISTANCE TECHNIQUE
Publié 2026-04-08
Ce guide fournit une solution pratique et testée sur le terrain pour contrôler jusqu'à 20servomoteurs en utilisant simultanément un ordinateur monocarte comme le Raspberry Pi. Connecter directement plus de deuxservomoteurLes connexions aux broches GPIO provoquent des chutes de tension, des conflits de synchronisation PWM et des dommages à la carte. La méthode fiable consiste à utiliser un module pilote PWM dédié (par exemple, PCA9685). Vous trouverez ci-dessous la configuration matérielle exacte, les schémas de câblage, les calculs de puissance, le code Python et les étapes de dépannage, le tout basé sur des projets robotiques et animatroniques courants du monde réel.
Limite actuelle: Chaque broche GPIO fournit un maximum de 16 mA, tandis qu'un servo standard consomme 150 à 500 mA lors du déplacement. 20 servos nécessiteraient plus de 10 A, bien au-delà de la capacité du rail 3,3 V/5 V de la carte.
Limite matérielle PWM: Raspberry Pi n'a que deux canaux PWM matériels (GPIO 18 et 19). Le logiciel PWM sur d'autres broches introduit une gigue et une surcharge du processeur pour 20 servos.
Effondrement de tension: L'utilisation de 20 servos à partir de la broche 5 V de la carte provoquera une chute de tension immédiate, réinitialisant le système.
Utilisez unModule pilote PWM basé sur I²C(Le PCA9685 à 16 canaux est la norme industrielle). Connectez deux de ces modules (chacun gère jusqu'à 16 servos) ou un module plus un multiplexeur. Ce guide utilise deux cartes PCA9685 (32 canaux au total, en utilisant seulement 20).
1 ordinateur monocarte (Raspberry Pi 3B+ ou plus récent)
2 cartes pilotes PWM 12 bits 16 canaux PCA9685
20 servos standard 5 V (par exemple, SG90, MG90S ou MG996R – choisissez en fonction des besoins de couple)
1 alimentation externe 5V DC – calculer le courant : 20 servos × 0,5A = 10A minimum. Utilisez unAlimentation 5 V régulée 10 A – 15 A.
Condensateurs : 2x 1000µF électrolytiques (≥10V) pour le lissage de la puissance
Fils de liaison (femelle à femelle pour I²C, mâle à femelle pour les connexions servo)
Planches à pain ou borniers pour la distribution d'énergie
Étape 1 – Connexion I²C entre Raspberry Pi et le premier PCA9685
Pi 3,3 V → VCC du PCA9685 (Remarque : certains modules acceptent la logique 5 V ; vérifiez votre module. Pour les modules logiques 5 V, utilisez le 3,3 V du Pi uniquement si le module est tolérant à 3,3 V. Plus sûr : connectez le VCC à la broche 5 V du Pi uniquement si la fiche technique du module confirme la tolérance de 5 V. La plupart des cartes PCA9685 fonctionnent avec une logique I²C de 3,3 V mais ont besoin de 5 V pour le servo V+ – voir l'étape suivante.)
Câblage standard correct (pour 99% des cartes PCA9685) :
Pi 5V (broche 2 ou 4) → PCA9685 VCC (alimentation pour la logique de la puce – oui, beaucoup fonctionnent sur une logique 5 V)
Pi GND → PCA9685 GND
Pi SDA (GPIO 2) → PCA9685 SDA
Pi SCL (GPIO 3) → PCA9685 SCL
Étape 2 – Alimentation externe pour les servos
Alimentation externe 5 V (10 A+) positif (+) → borne PCA9685 V+ (souvent étiquetée « V+ » ou « servo power »)
Alimentation externe GND → PCA9685 GND (doit partager la masse commune avec Pi – connectez Pi GND au PCA9685 GND comme déjà fait ci-dessus)
Placez un condensateur de 1 000 µF entre V+ et GND à proximité du PCA9685 pour absorber les pics de contre-EMF.
Étape 3 – Connexion des servos
Le rouge de chaque servo (alimentation) → rail PCA9685 V+ (utilisez un rail d'alimentation pour planche à pain)
Servo marron/noir (GND) → rail PCA9685 GND
Servo orange/jaune (signal) → broche de sortie PWM PCA9685 (0 à 15 sur la première carte, 0 à 3 sur la deuxième carte)
Étape 4 – Deuxième PCA9685
Définir l'adresse I²C de la deuxième carte : soudez les cavaliers d'adresse. L'adresse par défaut du PCA9685 est 0x40. Pour la deuxième carte : soudez le cavalier A0 → l'adresse devient 0x41.
Connectez le SDA/SCL/GND/VCC de la deuxième carte en parallèle avec la première carte (même bus I²C).
Connectez son V+ à la même alimentation externe 5V.
Activer I²C sur le Pi :
sudo raspi-config # Options d'interface → I2C → Oui sudo rebootInstallez les bibliothèques requises :
sudo apt update sudo apt installer python3-pip python3-smbus i2c-tools sudo pip3 installer adafruit-circuitpython-pca9685Vérifiez les appareils I²C :
sudo i2cdetect -y 1Vous devriez voir 0x40 et 0x41 (si la deuxième carte est correctement adressée).
Créer un fichierservo_control.py:
temps d'importation carte d'importation import busio depuis adafruit_pca9685 import PCA9685 # Initialiser le bus I2C i2c = busio.I2C(board.SCL, board.SDA) # Premier PCA9685 à l'adresse 0x40 pca1 = PCA9685(i2c, adresse=0x40) pca1.fréquence = 50 # 50Hz pour les servos standard # Deuxième PCA9685 à adresse 0x41 pca2 = PCA9685(i2c, adresse=0x41) pca2.fréquence = 50 # Plage de largeur d'impulsion du servo (typique 500 à 2500 microsecondes) # Convertir en rapport cyclique : duty = pulse_us / 2000065535 def angle_to_duty(angle, min_us=500, max_us=2500) : impulsion = min_us + (angle / 180,0)(max_us - min_us) return int((pulse / 20000.0) * 65535) # Contrôlez n'importe quel servo par carte et canal def set_servo(board, canal, angle) : si angle 180 : angle = 180 board.channels[channel].duty_cycle = angle_to_duty(angle) # Exemple : Déplacez les 20 servos à 90° servos = [(pca1, i) for i in range(16)] + [(pca2, i) for i in range(4)] # total 20 pour la carte, ch dans les servos : set_servo(board, ch, 90) time.sleep(0.01) # échelonnement pour réduire la surtension de courant # Servo de balayage sur la carte 1 canal 0 de 0 à 180 print ("Servo de balayage sur la carte 1 ch0") pour l'angle dans la plage (0, 181, 10) : set_servo(pca1, 0, angle) time.sleep(0.05) # Relâchez tous les servos (arrêtez d'envoyer du PWM) - important pour éviter la gigue pca1.deinit() pca2.deinit()Un cas réel : un amateur a connecté une fois 10 servos directement à une alimentation 5V/3A. Lors d'un mouvement simultané, la tension est tombée à 3,8 V, les servos ont calé et le Raspberry Pi a redémarré. Solution:Utilisez une alimentation régulée 5V/15A(par exemple, une alimentation LED ou le rail 5V de l’alimentation ATX d’un ordinateur). Ajoutergros condensateurs(1 000 µF pour 5 à 8 servos) à proximité de chaque carte pilote.
Règle exploitable: Calculez votre courant simultané maximum. Si les 20 servos bougent en même temps, supposons 10A. Par sécurité, ajoutez 30% de marge →13A minimum. Utilisez des fils de 14 AWG ou plus épais pour la distribution électrique.
Tous les servos n'ont pas la même impulsion min/max. Valeurs communes :
500 µs (0°) – 2 500 µs (180°) pour les servos analogiques
600 µs (0°) – 2 400 µs (180°) pour de nombreux servos numériques
Pour calibrer : écrivez un script de test qui balaie de 300 à 2 700 µs, recherchez les limites mécaniques, puis mettez à jourmoinsetmax_usdans la fonction ci-dessus.
Mouvement décalé: Ne commandez pas à tous les servos de changer d'angle exactement à la même microseconde. Ajoutertemps.sommeil (0,005)entre chaqueset_servoappel. Cela réduit le courant de pointe en répartissant la charge.
Taux de mise à jour: 50 Hz (période de 20 ms) est standard. N'augmentez pas la fréquence au-dessus de 100 Hz – la plupart des servos surchaufferont.
Utilisation du processeur: Le matériel PCA9685 génère du PWM indépendamment. Votre script Python envoie uniquement des commandes I²C à chaque fois que vous changez d'angle. Pour les positions statiques, le script peut se terminer – les servos conservent la dernière position tant que l'alimentation est appliquée.
1. Composants de commande– Deux cartes PCA9685, 20 servos, alimentation 5V/15A, condensateurs 1000µF.
2. Test avec un servo– Câblez un seul servo au premier PCA9685, exécutez le code de balayage.
3. Ajouter une alimentation– Connectez le 5 V/15 A externe au rail V+, vérifiez que le servo bouge fortement.
4. Échelle jusqu'à 5 servos– Ajoutez progressivement des servos, en surveillant la température des fils d’alimentation.
5. Ajouter un deuxième PCA9685– Réglez l’adresse sur 0x41, connectez 4 servos, testez.
6. Test complet de 20 servos– Exécutez le code fourni en déplaçant tous les servos à 90°, puis un lent balayage de tous les canaux.
Vous ne pouvez pas contrôler 20 servos directement à partir du GPIO d'un Raspberry Pi : utilisez des cartes de pilote PWM PCA9685 avec une alimentation dédiée de 5 V à courant élevé.Cette méthode est utilisée dans des milliers de projets réels d'animatroniques, de robots hexapodes et d'automatisation. Il est fiable, évolutif et bien documenté. Commencez par un petit test, vérifiez la stabilité de l’alimentation, puis augmentez. Votre succès dépend d’une mise à la terre appropriée et d’un ampérage suffisant – les deux ne sont pas négociables.
Passez maintenant à l'action : câblez un PCA9685 avec un seul servo et une alimentation externe de 5 V. Une fois que cela fonctionne, ajoutez le reste. Vous disposerez d'un système stable à 20 servos dans les deux heures suivant l'assemblage.
Heure de mise à jour：2026-04-08
Contactez le spécialiste des produits Kpower pour recommander un moteur ou une boîte de vitesses adapté à votre produit.
