Adafruit PCA9685

Servodriver 16 canaux



​

Adafruit PCA9685 Servodriver 16 canaux  -  https://learn.adafruit.com/16-channel-pwm-servo-driver?view=all#using-the-adafruit-library

Sauvegarder S'abonner

Conduire des servomoteurs avec la bibliothèque Arduino Servo est assez facile, mais chacun consomme une broche précieuse - sans parler de la puissance de traitement Arduino. Le pilote PWM/servo 16 canaux 12 bits d'Adafruit pilotera jusqu'à 16 servos sur I2C avec seulement 2 broches. Le contrôleur PWM embarqué pilotera les 16 canaux simultanément sans surcharge de traitement Arduino supplémentaire. De plus, vous pouvez en chaîner jusqu'à  62 pour contrôler jusqu'à 992 servos - tous avec les mêmes 2 broches !

Le pilote Adafruit PWM/Servo est la solution parfaite pour tout projet nécessitant de nombreux servos.

Brochages

Il y a deux ensembles de broches d'entrée de commande de chaque côté. Les deux côtés des broches sont identiques ! Utilisez le côté que vous aimez, vous pouvez également facilement enchaîner en connectant deux côte à côte.

Broches d'alimentation

  • GND - Il s'agit de la broche de terre d'alimentation et de signal, doit être connectée
  • VCC - Il s'agit de la broche d'alimentation logique , connectez-la au niveau logique que vous souhaitez utiliser pour la sortie PCA9685, doit être de 3 à 5 V max ! Il est également utilisé pour les pullups 10K sur SCL/SDA, donc à moins que vous n'ayez vos propres pullups, faites-le également correspondre au niveau logique du microcontrôleur !
  • V+ - Il s'agit d'une broche d'alimentation optionnelle qui fournira une alimentation distribuée aux servos. Si vous n'utilisez pas de servos, vous pouvez laisser déconnecté. Il n'est pas du tout utilisé par la puce. Vous pouvez également injecter de l'énergie à partir du bornier à 2 broches en haut de la carte. Vous devez fournir 5-6VDC si vous utilisez des servos. Si vous le devez, vous pouvez monter à 12VDC, mais si vous vous trompez et que vous connectez VCC à V+, vous risquez d'endommager votre carte !

Broches de contrôle

  • SCL - Broche d'horloge I2C, connectez-vous à la ligne d'horloge I2C de votre microcontrôleur. Peut utiliser la logique 3V ou 5V, et a une faible traction vers VCC
  • SDA - Broche de données I2C, connectez-vous à la ligne de données I2C de votre microcontrôleur. Peut utiliser la logique 3V ou 5V, et a une faible traction vers VCC
  • OE - Activation de la sortie. Peut être utilisé pour désactiver rapidement toutes les sorties. Lorsque cette broche est basse , toutes les broches sont activées . Lorsque la broche est haute , les sorties sont désactivées . Tiré bas par défaut, c'est donc une broche facultative !

Ports de sortie

Il y a 16 ports de sortie. Chaque port a 3 broches : V+, GND et la sortie PWM. Chaque PWM fonctionne de manière complètement indépendante mais ils doivent tous avoir la même fréquence PWM. Autrement dit, pour les LED, vous voulez probablement 1,0 KHz mais les servos ont besoin de 60 Hz - vous ne pouvez donc pas utiliser la moitié pour les LED à 1,0 KHz et la moitié à 60 Hz.

Ils sont configurés pour les servos mais vous pouvez les utiliser pour les LED ! Le courant maximum par broche est de 25mA.

Il y a des résistances de 220 ohms en série avec toutes les broches PWM et la logique de sortie est la même que VCC  , alors gardez cela à l'esprit si vous utilisez des LED. 

Assemblée

Installer les en-têtes servo

Installez 4 embases mâles 3x4 broches dans les positions marquées le long du bord de la carte.

Souder toutes les broches

Il y en a beaucoup!

Ajouter des en-têtes pour le contrôle

Une bande d'en-tête mâle est incluse. L'endroit où vous souhaitez installer les en-têtes et de quel côté dépend un peu de l'utilisation :

  • Pour une utilisation sur planche à pain , installez les en-têtes au bas de la carte.
  • Pour une utilisation avec des fils de connexion , installez les en-têtes sur le dessus de la carte.
  • Pour une utilisation avec notre câble à 6 broches , installez les en-têtes sur le dessus de la carte.

Si vous enchaînez plusieurs cartes de pilote, vous aurez besoin d'en-têtes aux deux extrémités.

Installer les bornes d'alimentation

Si vous enchaînez plusieurs cartes de commande, vous n'avez besoin que d'une borne d'alimentation sur la première.

Le brancher

Connexion à l'Arduino

Le PWM/Servo Driver utilise I2C donc il ne faut que 4 fils pour se connecter à votre Arduino :

Câblage Arduino « classique » :

  • +5v -> VCC (il s'agit de l'alimentation du BREAKOUT uniquement, PAS de l'alimentation du servo !)
  • Terre -> Terre
  • Analogique 4 -> SDA
  • Analogique 5 -> SCL

Câblage Mega plus ancien :

  • +5v -> VCC (il s'agit de l'alimentation du BREAKOUT uniquement, PAS de l'alimentation du servo !)
  • Terre -> Terre
  • Numérique 20 -> SDA
  • Numérique 21 -> SCL

Câblage Arduino R3 et ultérieur (Uno, Mega & Leonardo):
(Ces cartes ont des broches SDA & SCL dédiées sur l'en-tête le plus proche du connecteur USB)

  • +5v -> VCC (il s'agit de l'alimentation du BREAKOUT uniquement, PAS de l'alimentation du servo !)
  • Terre -> Terre
  • SDA -> SDA
  • SCL -> SCL

La broche VCC n'est que l'alimentation de la puce elle-même. Si vous souhaitez connecter des servos ou des LED qui utilisent les broches V+, vous DEVEZ également connecter la broche V+. La broche V + peut atteindre 6 V même si VCC est de 3,3 V (la puce est sécurisée en 5 V). Nous suggérons de connecter l'alimentation via le bornier bleu car il est protégé contre la polarité.

Puissance pour les servos

La plupart des servos sont conçus pour fonctionner sur environ 5 ou 6v. Gardez à l'esprit que beaucoup de servos se déplaçant en même temps (en particulier les gros et puissants) auront besoin de beaucoup de courant. Même les micro servos consomment plusieurs centaines de mA lors du déplacement. Certains servos à couple élevé consomment plus de 1 A chacun sous charge.

Les bons choix de puissance sont :

Ce n'est pas une bonne idée d'utiliser la broche Arduino 5v pour alimenter vos servos. Le bruit électrique et les "coupures de courant" dues à une consommation de courant excessive peuvent entraîner un comportement erratique, une réinitialisation et/ou une surchauffe de votre Arduino.

Ajout d'un condensateur à l'emplacement du condensateur traversant

Nous avons un emplacement sur le circuit imprimé pour souder un condensateur électrolytique. En fonction de votre utilisation, vous pouvez ou non avoir besoin d'un condensateur. Si vous pilotez beaucoup de servos à partir d'une alimentation qui baisse beaucoup lorsque les servos bougent, n * 100 uF où n est le nombre de servos est un bon point de départ - par exemple 470 uF ou plus pour 5 servos. Étant donné qu'il dépend tellement de la consommation de courant d'asservissement, du couple de chaque moteur et de l'alimentation, il n'y a pas de "valeur de condensateur magique" que nous pouvons suggérer, c'est pourquoi nous n'incluons pas de condensateur dans le kit.

Connexion d'un servo

La plupart des servos sont livrés avec un connecteur femelle standard à 3 broches qui se branche directement dans les en-têtes du servomoteur. Assurez-vous d'aligner la fiche avec le fil de terre (généralement noir ou marron) avec la rangée du bas et le fil de signal (généralement jaune ou blanc) sur le dessus.

Ajout de plus de servos

Jusqu'à 16 servos peuvent être attachés à une carte. Si vous avez besoin de contrôler plus de 16 servos, des cartes supplémentaires peuvent être chaînées comme décrit à la page suivante.

Pilotes de chaînage

Plusieurs pilotes (jusqu'à 62) peuvent être enchaînés pour contrôler encore plus de servos. Avec des en-têtes aux deux extrémités de la carte, le câblage est aussi simple que de connecter un câble parallèle à 6 broches d'une carte à l'autre. 

S'adresser aux conseils

Chaque carte de la chaîne doit se voir attribuer une adresse unique. Cela se fait avec les cavaliers d'adresse sur le bord supérieur droit de la carte. L'adresse de base I2C pour chaque carte est 0x40. L'adresse binaire que vous programmez avec les cavaliers d'adresse est ajoutée à l'adresse I2C de base.

Pour programmer le décalage d'adresse, utilisez une goutte de soudure pour ponter le cavalier d'adresse correspondant pour chaque '1' binaire dans l'adresse.

Carte 0 : Adresse = 0x40 Décalage = binaire 00000 (aucun cavalier requis)
Carte 1 : Adresse = 0x41 Décalage = binaire 00001 (pont A0 comme sur la photo ci-dessus)
Carte 2 : Adresse = 0x42 Décalage = binaire 00010 (pont A1)
Carte 3 : Adresse = 0x43 Offset = binaire 00011 (pont A0 & A1)
Carte 4 : Adresse = 0x44 Offset = binaire 00100 (pont A2)

etc.

Dans votre sketch, vous devrez déclarer un pobject séparé pour chaque carte. L'appel commence sur chaque objet et contrôle chaque servo via l'objet auquel il est attaché. Par exemple:

Télécharger un fichierCopier le code

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

Adafruit_PWMServoDriver pwm1 = Adafruit_PWMServoDriver(0x40);
Adafruit_PWMServoDriver pwm2 = Adafruit_PWMServoDriver(0x41);

void setup() {
  Serial.begin(9600);
  Serial.println("16 channel PWM test!");

  pwm1.begin();
  pwm1.setPWMFreq(1600);  // This is the maximum PWM frequency

  pwm2.begin();
  pwm2.setPWMFreq(1600);  // This is the maximum PWM frequency
}

Utilisation de la bibliothèque Adafruit

Étant donné que le servomoteur PWM est contrôlé via I2C, il est très facile à utiliser avec n'importe quel microcontrôleur ou micro-ordinateur. Dans cette démo, nous montrerons son utilisation avec l'IDE Arduino, mais le code C++ peut être porté facilement

Installer la bibliothèque Adafruit PCA9685

Pour commencer à lire les données des capteurs, vous devrez installer la bibliothèque Adafruit_PWMServo (code sur notre référentiel github) . Il est disponible dans le gestionnaire de bibliothèque Arduino, nous vous recommandons donc de l'utiliser.

Depuis l'IDE, ouvrez le gestionnaire de bibliothèque...

Et tapez adafruit pwm pour localiser la bibliothèque. Cliquez sur Installer

Nous avons également un excellent tutoriel sur l'installation de la bibliothèque Arduino à l'adresse :
http://learn.adafruit.com/adafruit-all-about-arduino-libraries-install-use

Testez avec l'exemple de code :

Assurez-vous d'abord que toutes les copies de l'IDE Arduino sont fermées.

Ouvrez ensuite l'IDE Arduino et sélectionnez File->Examples->Adafruit_PWMServoDriver->Servo . Cela ouvrira le fichier d'exemple dans une fenêtre IDE.

Si vous utilisez un Breakout :

Connectez la carte de commande et le servo comme indiqué à la page précédente. N'oubliez pas d'alimenter à la fois Vin (niveau logique 3-5V) et V+ (alimentation servo 5V). Vérifiez que la LED verte est allumée !

Si vous utilisez un bouclier :

Branchez le shield sur votre Arduino. N'oubliez pas que vous devrez également fournir 5V au bornier V+. Les LED rouges et vertes doivent être allumées .

Si vous utilisez un FeatherWing :

Branchez le FeatherWing dans votre Feather. N'oubliez pas que vous devrez également fournir 5V au bornier V+. Vérifiez que la LED verte est allumée !

Connecter un servo

Un seul servo doit être branché sur le port PWM #0 , le premier port. Vous devriez voir le servo balayer d'avant en arrière sur environ 180 degrés.

Calibrage de vos servos

La synchronisation des impulsions de servo varie selon les marques et les modèles. Comme il s'agit d'un circuit de commande analogique, il existe souvent des variations entre les échantillons de la même marque et du même modèle. Pour un contrôle de position précis, vous souhaiterez calibrer les largeurs d'impulsion minimale et maximale dans votre code pour qu'elles correspondent aux positions connues du servo.

Trouver le minimum :
à l'aide de l'exemple de code, modifiez SERVOMIN jusqu'à ce que le point bas du balayage atteigne la plage de déplacement minimale. Il est préférable d'aborder cela progressivement et de s'arrêter avant que la limite physique de déplacement ne soit atteinte.

Trouver le maximum :
Encore une fois, en utilisant l'exemple de code, modifiez SERVOMAX jusqu'à ce que le point haut du balayage atteigne la plage de déplacement maximale. Encore une fois, il est préférable d'aborder cela progressivement et de s'arrêter avant que la limite physique de déplacement ne soit atteinte.

Soyez prudent lors du réglage de SERVOMIN et SERVOMAX. Frapper les limites physiques de la course peut dépouiller les engrenages et endommager de façon permanente votre servo.

Conversion de degrés en longueur d'impulsion

La fonction Arduino "map()" est un moyen facile de convertir entre les degrés de rotation et vos longueurs d'impulsions SERVOMIN et SERVOMAX calibrées. En supposant un servo typique avec 180 degrés de rotation ; une fois que vous avez calibré SERVOMIN sur la position 0 degré et SERVOMAX sur la position 180 degrés, vous pouvez convertir n'importe quel angle entre 0 et 180 degrés en la longueur d'impulsion correspondante avec la ligne de code suivante :
Télécharger un fichierCopier le code

pulselength = map(degrees, 0, 180, SERVOMIN, SERVOMAX);

Référence de la bibliothèque

setPWMFreq(fréq)

Description

Cette fonction peut être utilisée pour régler la fréquence PWM, qui détermine le nombre d'« impulsions » complètes par seconde générées par le CI. En d'autres termes, la fréquence détermine la "longueur" de chaque impulsion du début à la fin, en tenant compte à la fois des segments haut et bas de l'impulsion.

La fréquence est importante en PWM, car un réglage trop élevé de la fréquence avec un très petit rapport cyclique peut causer des problèmes, car le «temps de montée» du signal (le temps qu'il faut pour passer de 0V à VCC) peut être plus long que le temps le Le signal est actif et la sortie PWM apparaîtra lissée et peut même ne pas atteindre VCC, ce qui pourrait causer un certain nombre de problèmes.

Arguments

  • freq : Un nombre représentant la fréquence en Hz, entre 40 et 1600

Exemple

Le code suivant définira la fréquence PWM sur 1000 Hz :

Télécharger un fichierCopier le code

pwm.setPWMFreq(1000)

setPWM (canal, activé, désactivé)

Description

Cette fonction définit le début (on) et la fin (off) du segment haut de l'impulsion PWM sur un canal spécifique. Vous spécifiez la valeur 'tick' entre 0..4095 quand le signal s'allumera et quand il s'éteindra. Le canal indique laquelle des 16 sorties PWM doit être mise à jour avec les nouvelles valeurs.

Arguments

  • channel : Le canal qui doit être mis à jour avec les nouvelles valeurs (0..15)
  • on : Le tick (entre 0..4095) lorsque le signal doit passer de bas à haut
  • off : le tick (entre 0..4095) lorsque le signal doit passer de haut en bas

Exemple

L'exemple suivant fera démarrer le canal 15 bas, montera à environ 25 % dans l'impulsion (coche 1024 sur 4096), reviendra à bas 75 % dans l'impulsion (coche 3072) et restera bas pendant les 25 derniers 25 % de le pouls:

Télécharger un fichierCopier le code

pwm.setPWM(15, 1024, 3072)

Utilisation comme GPIO

Il existe également des paramètres spéciaux pour activer ou désactiver complètement les broches

Vous pouvez régler la broche pour qu'elle soit complètement allumée avec

pwm.setPWM(pin, 4096, 0);

Vous pouvez régler la broche pour qu'elle soit complètement désactivée avec

pwm.setPWM(pin, 0, 4096);

Python et CircuitPython

Il est facile d'utiliser le capteur PCA9685 avec Python ou CircuitPython et le module Adafruit CircuitPython PCA9685 . Ce module vous permet d'écrire facilement du code Python qui contrôle les servos et PWM avec cette évasion.

Vous pouvez utiliser ce capteur avec n'importe quelle carte microcontrôleur CircuitPython ou avec un ordinateur qui a GPIO et Python grâce à Adafruit_Blinka, notre bibliothèque de compatibilité CircuitPython-pour-Python .

Câblage du microcontrôleur CircuitPython

Câblez d'abord un PCA9685 à votre carte exactement comme indiqué sur les pages précédentes pour Arduino. Voici un exemple de câblage d'un Feather M0 au capteur avec I2C :

  • Carte 3V vers capteur VCC
  • Carte GND au capteur GND
  • Carte SCL vers capteur SCL
  • Carte SDA vers capteur SDA

Câblage informatique Python

Puisqu'il existe des dizaines d'ordinateurs/cartes Linux que vous pouvez utiliser, nous allons montrer le câblage pour Raspberry Pi. Pour les autres plates-formes, veuillez consulter le guide de CircuitPython sur Linux pour voir si votre plate-forme est prise en charge . 

Voici le Raspberry Pi câblé en I2C :

  • Pi 3V3 vers capteur VCC
  • Pi GND au capteur GND
  • Pi SCL au capteur SCL
  • Pi SDA vers capteur SDA

N'essayez pas d'alimenter vos servos à partir de l'alimentation 5V de la carte RasPi ou Linux, vous pouvez facilement provoquer une panne d'alimentation et gâcher votre Pi ! Utilisez un adaptateur 5v 2A ou 4A séparéAlimentation à découpage 5V 2A (2000mA) - Listée ULIl s'agit d'une alimentation électrique certifiée FCC/CE et répertoriée UL. Besoin de beaucoup de puissance 5V? Cette alimentation à découpage donne une sortie 5V régulée propre jusqu'à 2000mA. Entrée 110 ou 240, donc ça marche...7,95 $En stockAjouter au panierAlimentation à découpage 5V 4A (4000mA) - Listée ULBesoin de beaucoup de puissance 5V? Cette alimentation à découpage donne une sortie régulée propre de 5 V jusqu'à 4 A (4000 mA). Entrée 110 ou 240, donc ça marche dans n'importe quel pays. Les prises sont "US...14,95 $En stockAjouter au panier

Installation CircuitPython des bibliothèques PCA9685 et ServoKit

Vous devrez installer la  bibliothèque Adafruit CircuitPython PCA9685  sur votre carte CircuitPython.

Assurez-vous d'abord que vous utilisez la  dernière version d'Adafruit CircuitPython  pour votre carte.

Ensuite, vous devrez installer les bibliothèques nécessaires pour utiliser le matériel - suivez attentivement les étapes pour trouver et installer ces bibliothèques à partir du  bundle de bibliothèques CircuitPython d'Adafruit . Notre guide de démarrage CircuitPython contient une excellente page sur la façon d'installer le bundle de bibliothèques .

Pour les cartes non express comme la Trinket M0 ou la Gemma M0, vous devrez installer manuellement les bibliothèques nécessaires à partir du bundle :

  • adafruit_pca9685.mpy
  • adafruit_bus_device
  • adafruit_register
  • moteur_adafruit
  • adafruit_servokit

Avant de continuer, assurez-vous que le dossier lib ou le système de fichiers racine de votre carte contient les fichiers et dossiers adafruit_pca9685.mpy , adafruit_register, adafruit_servokit, adafruit_motor et adafruit_bus_device copiés.  

Connectez-vous ensuite  au REPL série de la carte afin d'être à l'invite CircuitPython  >>>  .

Installation Python des bibliothèques PCA9685 et ServoKit

Vous devrez installer la bibliothèque Adafruit_Blinka qui fournit le support CircuitPython en Python. Cela peut également nécessiter d'activer I2C sur votre plate-forme et de vérifier que vous utilisez Python 3. Étant donné que chaque plate-forme est un peu différente et que Linux change souvent, veuillez consulter le guide CircuitPython sur Linux pour préparer votre ordinateur !

Une fois cela fait, depuis votre ligne de commande, exécutez les commandes suivantes :

  • sudo pip3 install adafruit-circuitpython-pca9685
  • sudo pip3 install adafruit-circuitpython-servokit

Si votre Python par défaut est la version 3, vous devrez peut-être exécuter 'pip' à la place. Assurez-vous simplement que vous n'essayez pas d'utiliser CircuitPython sur Python 2.x, il n'est pas pris en charge !

Utilisation de CircuitPython et Python

La section suivante montrera comment contrôler le PCA9685 à partir de l'invite Python / REPL de la carte. Vous apprendrez à contrôler de manière interactive les servos et à atténuer les LED en tapant le code ci-dessous. 

LED de gradation

Exécutez le code suivant pour importer les modules nécessaires et initialiser la connexion I2C avec le capteur :

Télécharger un fichierCopier le code

import board
import busio
import adafruit_pca9685
i2c = busio.I2C(board.SCL, board.SDA)
pca = adafruit_pca9685.PCA9685(i2c)

Chaque canal du PCA9685 peut être utilisé pour contrôler la luminosité d'une LED. Le PCA9685 génère un signal PWM à grande vitesse qui allume et éteint la LED très rapidement. Si la LED est allumée plus longtemps qu'éteinte, elle apparaîtra plus lumineuse à vos yeux.

Câblez d'abord une LED à la carte comme suit. Notez que vous n'avez pas besoin d'utiliser une résistance pour limiter le courant à travers la LED car le PCA9685 limitera le courant à environ 10 mA :

  • Cathode LED/jambe plus courte  au  canal PCA9685 GND/sol .
  • Anode LED / jambe plus longue  au  canal PCA9685 PWM .

La classe PCA9685 permet de contrôler la fréquence PWM et le rapport cyclique de chaque canal. Consultez la  documentation de la classe PCA9685  pour plus de détails.

Pour la gradation des LED, vous n'avez généralement pas besoin d'utiliser une fréquence de signal PWM rapide et vous pouvez régler la fréquence PWM de la carte sur 60 Hz en définissant l'  attribut de fréquence :

Télécharger un fichierCopier le code

pca.frequency = 60

Le PCA9685 prend en charge 16 canaux distincts qui partagent une fréquence mais peuvent avoir des rapports cycliques indépendants. De cette façon, vous pouvez faire varier l'intensité de 16 LED séparément !

L'objet PCA9685 a un attribut de canaux qui a un objet pour chaque canal qui peut contrôler le rapport cyclique. Pour obtenir le canal individuel, utilisez le [] pour indexer les canaux .

Télécharger un fichierCopier le code

led_channel = pca.channels[0]

Contrôlez maintenant la luminosité de la LED en contrôlant le rapport cyclique du canal connecté à la LED. La valeur du rapport cyclique doit être une valeur de 16 bits, c'est-à-dire de 0 à 0xffff, qui représente le pourcentage de temps pendant lequel le signal est activé ou désactivé. Une valeur de 0xffff correspond à 100 % de luminosité, 0 à 0 % de luminosité et les valeurs intermédiaires vont de 0 % à 100 % de luminosité.

Par exemple, allumez complètement la LED avec un rapport cyclique de 0xffff :

Télécharger un fichierCopier le code

led_channel.duty_cycle = 0xffff

Après avoir exécuté la commande ci-dessus, vous devriez voir la LED s'allumer à pleine luminosité !

Maintenant, éteignez la LED avec un rapport cyclique de 0 :

Télécharger un fichierCopier le code

led_channel.duty_cycle = 0

Essayez une valeur intermédiaire comme 1000 :

Télécharger un fichierCopier le code

led_channel.duty_cycle = 1000

Vous devriez voir la LED faiblement allumée. Essayez d'expérimenter avec d'autres valeurs de rapport cyclique pour voir comment la LED change de luminosité !

Par exemple, allumez et éteignez la LED en définissant duty_cycle dans une boucle :

Télécharger un fichierCopier le code

# Increase brightness:
for i in range(0xffff):
    led_channel.duty_cycle = i
     
# Decrease brightness:
for i in range(0xffff, 0, -1):
    led_channel.duty_cycle = i

Ces boucles for prennent un certain temps car 16 bits représentent beaucoup de nombres. CTRL-C pour arrêter l'exécution de la boucle et revenir au REPL.

Exemple de code complet

Télécharger l'ensemble de projetsCopier le code

# SPDX-FileCopyrightText: 2021 ladyada for Adafruit Industries
# SPDX-License-Identifier: MIT

# This simple test outputs a 50% duty cycle PWM single on the 0th channel. Connect an LED and
# resistor in series to the pin to visualize duty cycle changes and its impact on brightness.

from board import SCL, SDA
import busio

# Import the PCA9685 module.
from adafruit_pca9685 import PCA9685

# Create the I2C bus interface.
i2c_bus = busio.I2C(SCL, SDA)

# Create a simple PCA9685 class instance.
pca = PCA9685(i2c_bus)

# Set the PWM frequency to 60hz.
pca.frequency = 60

# Set the PWM duty cycle for channel zero to 50%. duty_cycle is 16 bits to match other PWM objects
# but the PCA9685 will only actually give 12 bits of resolution.
pca.channels[0].duty_cycle = 0x7FFF

 Afficher sur GitHub

Contrôle des servos

Nous avons écrit une bibliothèque CircuitPython pratique pour les différents kits PWM/Servo appelés Adafruit CircuitPython ServoKit qui gère toute la configuration compliquée pour vous. Tout ce que vous avez à faire est d'importer la classe appropriée à partir de la bibliothèque, puis toutes les fonctionnalités de cette classe sont disponibles pour utilisation. Nous allons vous montrer comment importer la ServoKitclasse et l'utiliser pour contrôler des servomoteurs avec le breakout 16 canaux d'Adafruit.

Si vous n'êtes pas familier avec les servos, assurez-vous de lire d'abord cette  page d'introduction aux servos  et cette  page de guide approfondi des servos .

Connectez d'abord le servo au canal 0 sur le PCA9685. Voici un exemple de servo connecté à la voie 0 :

 

  • Fil orange servo pour le breakout PWM sur le canal 0
  • Fil rouge servo vers breakout V+ sur voie 0
  • Fil marron servo vers breakout Gnd sur la voie 0

Vérifiez la fiche technique de votre servo pour vérifier comment le connecter !

 

Assurez-vous d'avoir également allumé ou branché l'alimentation externe 5V sur la carte PCA9685 !

Vous devez d'abord importer et initialiser la ServoKitclasse. Vous devez spécifier le nombre de canaux disponibles sur votre carte. L'évasion a 16 canaux, donc lorsque vous créez l'objet de classe, vous spécifierez 16.

Télécharger un fichierCopier le code

from adafruit_servokit import ServoKit
kit = ServoKit(channels=16)

Vous êtes maintenant prêt à contrôler les servos à rotation standard et continue.

Servos standards

Pour contrôler un servo standard, vous devez spécifier le canal auquel le servo est connecté. Vous pouvez ensuite contrôler le mouvement en réglant anglele nombre de degrés.

Par exemple pour déplacer le servo connecté au canal 0en 180degrés :

Télécharger un fichierCopier le code

pca.frequency = 50

Maintenant que le PCA9685 est configuré pour les servos, créons un objet Servo afin que nous puissions régler le servo en fonction de l'angle au lieu de duty_cycle .

Par défaut, la classe Servo utilisera la plage d'actionnement, la largeur d'impulsion minimale et les valeurs de largeur d'impulsion maximale qui devraient fonctionner pour la plupart des servos. Cependant,  consultez la documentation de la classe Servo  pour plus de détails sur les paramètres supplémentaires permettant de personnaliser le signal généré pour vos servos.

Télécharger un fichierCopier le code

import adafruit_motor.servo
servo = adafruit_motor.servo.Servo(servo_channel)

Avec Servo, vous spécifiez une position sous forme d'angle. L'angle sera toujours compris entre 0 et la plage d'actionnement indiquée lors de la création du servo. La valeur par défaut est de 180 degrés, mais votre servo peut avoir un balayage plus petit - modifiez l'angle total en spécifiant le paramètre actuation_angle dans l'initialiseur de classe Servo ci-dessus.

Réglez maintenant l'angle sur 180, un extrême de la plage :

Télécharger un fichierCopier le code

    kit.servo[0].angle = 180

Pour remettre le servo en 0degrés :

Télécharger un fichierCopier le code

kit.servo[0].angle = 0

Avec un servo standard, vous spécifiez la position sous forme d'angle. L'angle sera toujours compris entre 0 et la plage d'actionnement. La valeur par défaut est de 180 degrés, mais votre servo peut avoir un balayage plus petit. Vous pouvez modifier l'angle total en réglant actuation_range.

Par exemple, pour régler la plage d'actionnement sur 160 degrés :

Télécharger un fichierCopier le code

servokit.servo[0].actuation_range = 160

Souvent, la plage reconnue par un servo individuel varie un peu par rapport aux autres servos. Si le servo n'a pas balayé toute la plage attendue, essayez de régler les largeurs d'impulsion minimale et maximale à l'aide de set_pulse_width_range(min_pulse, max_pulse).

Pour définir la plage de largeur d'impulsion sur un minimum de 1 000 et un maximum de 2 000 :

Télécharger un fichierCopier le code

kit.servo[0].set_pulse_width_range(1000, 2000)

C'est tout ce qu'il y a à faire pour contrôler les servos standard avec le breakout PCA9685, Python et ServoKit!

Servos à rotation continue

Pour contrôler un servo à rotation continue, vous devez spécifier le canal sur lequel se trouve le servo. Ensuite, vous pouvez contrôler le mouvement à l'aide de throttle.

Par exemple, pour démarrer le servo à rotation continue connecté au canal 1à pleins gaz vers l'avant :

Télécharger un fichierCopier le code

kit.continuous_servo[1].throttle = 1

Pour démarrer le servo de rotation continue connecté au canal 1à pleine accélération inversée :

Télécharger un fichierCopier le code

kit.continuous_servo[1].throttle = -1

Pour régler la moitié des gaz, utilisez un nombre décimal :

Télécharger un fichierCopier le code

kit.continuous_servo[1].throttle = 0.5

Et, pour arrêter le mouvement du servo à rotation continue, réglez throttlesur0 :

Télécharger un fichierCopier le code

kit.continuous_servo[1].throttle = 0

C'est tout ce qu'il y a à faire pour contrôler les servos à rotation continue avec le breakout 16 canaux PCA9685, Python et ServoKit!

Exemple de code complet

Télécharger l'ensemble de projetsCopier le code

# SPDX-FileCopyrightText: 2021 ladyada for Adafruit Industries
# SPDX-License-Identifier: MIT

"""Simple test for a standard servo on channel 0 and a continuous rotation servo on channel 1."""
import time
from adafruit_servokit import ServoKit

# Set channels to the number of servo channels on your kit.
# 8 for FeatherWing, 16 for Shield/HAT/Bonnet.
kit = ServoKit(channels=8)

kit.servo[0].angle = 180
kit.continuous_servo[1].throttle = 1
time.sleep(1)
kit.continuous_servo[1].throttle = -1
time.sleep(1)
kit.servo[0].angle = 0
kit.continuous_servo[1].throttle = 0

 Afficher sur GitHub

Téléchargements

Des dossiers

Impression de schéma et de fabrication

Les trous ont un diamètre de 2,5 mm

FAQ

Cette carte peut-elle être utilisée pour des LED ou simplement des servos ?Il peut être utilisé pour les LED ainsi que pour tout autre appareil compatible PWM !J'ai des problèmes étranges lorsque je combine ce bouclier avec les sacs à dos Adafruit LED Matrix/7Seg

La puce PCA9865 a une adresse "All Call" de 0x70. Ceci s'ajoute à l'adresse configurée. Définissez les sacs à dos sur l'adresse 0x71 ou toute autre adresse que la valeur par défaut 0x70 pour que le problème disparaisse.

Avec les LED, comment se fait-il que je n'arrive pas à éteindre complètement les LED ?

Si vous voulez éteindre complètement les LED, utilisez (dans Arduino) setPWM(pin, 0, 4096); pas setPWM (broche, 0, 4095);