En este tutorial, aprenderá todo lo que necesita saber sobre la funcionalidad de un servomotor.
Primero aprendemos los fundamentos teóricos de cómo funciona un servomotor.
En varios ejemplos, aprende a controlar uno o más servos con su microcontrolador Arduino, ESP8266 o ESP32.
Un servomotor es un motor eléctrico que puede controlar con precisión la posición angular, la velocidad y la aceleración. Por lo tanto, el motor utiliza un mecanismo de retroalimentación de circuito cerrado. Un servo consta de las siguientes partes:
- Un motor eléctrico (motor de corriente continua, motor asíncrono o motor síncrono)
- Un sensor para retroalimentación de posición
- Un controlador para regular el movimiento del motor de acuerdo con uno o más puntos de ajuste ajustables, como la posición angular deseada del eje o la velocidad establecida, en un bucle de control.
Los servos se utilizan en aplicaciones como robótica, máquinas CNC y diferentes áreas de la tecnología de automatización.
Descripción general del servomecanismo de circuito cerrado
Como se mencionó al comienzo de este tutorial, el servomotor utiliza un sistema de retroalimentación de circuito cerrado para controlar la posición angular, la velocidad y la aceleración. La siguiente imagen muestra el circuito cerrado.
Camino de avance en servomecanismo de bucle cerrado
La entrada para el controlador es una señal de pulso, que será proporcionada por nuestro microcontrolador en los siguientes ejemplos de este tutorial. La señal de pulso define el ajuste de posición del servo que resulta en un comando de velocidad y final a un comando de corriente que es la entrada para que el variador gire el motor en la dirección preferida.
Hay diferentes tipos de motores que se pueden usar para un servo porque el servomotor no depende del motor sino de la funcionalidad con el circuito de retroalimentación cerrado. Los motores más utilizados son desde motores de CC de imanes permanentes cepillados simples y económicos hasta motores de inducción de CA industriales.
Camino hacia atrás en servo de lazo cerrado
El motor está acoplado a un codificador para proporcionar retroalimentación de velocidad y posición. La retroalimentación de corriente la proporciona directamente el inversor.
En nuestro ejemplo, estamos usando un servomotor económico que solo usa retroalimentación de posición a través de un potenciómetro. Por lo tanto, el motor siempre funciona a máxima velocidad. Para aplicaciones industriales, los servomotores también tienen un circuito de retroalimentación de velocidad a través de un codificador rotatorio óptico. Estos tipos de servo son capaces de controlar la velocidad y, por tanto, alcanzar la posición deseada de forma más rápida y precisa con menos sobreimpulso.
La retroalimentación de posición para controlar el movimiento y la posición final se compara con la señal de entrada. Si hay una diferencia, se genera una señal de error. La señal de error gira el servo en la dirección preferida hasta que la señal de error es cero. Si la señal de error es cero, se alcanza la posición final y el motor se detiene.
Señal de pulso de entrada en servomecanismo de bucle cerrado
Ahora queremos controlar el servomotor con nuestro microcontrolador Arduino, ESP8266 o ESP32. Por lo tanto, la señal de pulso como entrada debe crearse desde el microcontrolador como una onda cuadrada similar a una señal PWM.
Dado que no estamos creando una señal PWM, el pin del motor digital no tiene que ser un pin PWM en su placa. Cada pin digital funcionará.
La mayoría de los servomotores, especialmente los más baratos que utilizo, no pueden girar 360 grados, pero pueden girar entre 0 y 180 grados. Con la señal PWM, el control es
- 0 grados para un ancho de pulso de 1 ms,
- 90 grados con un ancho de pulso de 1,5 ms y
- 180 grados con un ancho de pulso de 2 ms.
El tiempo total del ciclo es de 20 ms cuando se repite el PWM. La siguiente imagen muestra las tres posiciones diferentes con su pulso.
Longruner SG90 Micro Servo Motor 9G RC (KY66-5) hoja de datos
El servo que estoy usando es el Micro Servo Motor Longruner SG90 9G RC (KY66-5). La siguiente tabla muestra la ficha técnica del motor.
.
| Criterios | Especificación |
|---|---|
| Velocidad de funcionamiento | 0,12 segundos/ 60 grados ( 4,8V sin carga) |
| Par de arranque (4,8V) | 17,5oz /in (1kg/cm) |
| Tensión de funcionamiento | 3,0V~7,2V |
| Rango de temperatura | 30 a +60 grados Celsius |
| Ancho de banda muerta | 7µs |
| Frecuencia de trabajo | 50Hz |
| Tipo de motor | Motor de corriente continua con escobillas |
| Tipo de engranaje | Engranajes de plástico |
| Dimensiones | 23 x 11,5 x 24mm |
| Peso | 9 gramos |
El par de bloqueo es el par que el motor empuja contra una diferencia de la posición actual si desea hacer funcionar el motor con la mano. Con un amplio rango de voltaje operativo, el servo puede trabajar con placas Arduino (voltaje de suministro de 5 V) y placas EPS8266 (voltaje de suministro de 3,3 V).
La siguiente tabla le brinda una descripción general de todos los componentes y partes que utilicé para este tutorial.
| Arduino Nano | Amazon | AliExpress |
| Arduino Pro Mini | Amazon | AliExpress |
| Arduino Uno | Amazon | AliExpress |
| Arduino Mega | Amazon | AliExpress |
| ESP32 ESP-WROOM-32 | Amazon | AliExpress |
| ESP8266 NodeMCU | Amazon | AliExpress |
| ESP8266 WeMos D1 Mini | Amazon | AliExpress |
| Potenciómetro / Codificador rotativo | Amazon | AliExpress |
| Servo Motor | Amazon | AliExpress |
| PCA9685 16 CH 12Bit PWM Servo Motor Driver | Amazon | AliExpress |
Usaremos la biblioteca Servo en los siguientes ejemplos. Si no sabe cómo instalar una biblioteca en el IDE de Arduino, aquí hay un tutorial.
Si usamos la biblioteca Servo, la funcionalidad PWM en los pines 9 y 10 de las placas Arduino se deshabilita automáticamente.
Cómo girar un servomotor hasta 180 grados
El primer ejemplo es el más simple que puedas imaginar. Queremos rotar el motor de 0 a 180 grados con un tamaño de paso de 1 y después de una pausa de 180 grados durante un segundo, queremos rotar el motor hacia atrás a 0 grados pero con un tamaño de paso más rápido de 5.
Cableado entre el servomotor y el microcontrolador para girar el servo 180 grados
Las siguientes imágenes muestran el cableado entre el microcontrolador Arduino, ESP8266 o ESP32 y el servomotor.
La potencia del servomotor es el pin de 5V para placas Arduino o el pin de 3.3V para placas ESP8266 o ESP32. Si alimenta las placas del microcontrolador a través de USB, también puede utilizar la salida de 5 V de las placas ESP8266 o ESP32.
Para controlar el servomotor usamos un pin de E / S digital como 9 (Arduino), D7 (ESP8266) o 4 (ESP32). Puede usar cualquier otro pin digital en su microcontrolador, pero también debe modificar el script del programa.
Arduino Nano
Para obtener más información sobre Arduino Nano, visite el tutorial de Arduino Nano.
Arduino Pro Mini
Arduino Uno
Para obtener más información sobre Arduino Uno, visite el tutorial de Arduino Uno.
Arduino Mega
Para obtener más información sobre Arduino Mega, visite Arduino Nano Mega.
ESP32 NodeMCU
ESP8266 NodeMCU
ESP8266 WeMos D1 Mini
Script de programa para girar el servo 180 grados
Después de realizar el cableado entre el microcontrolador y el servomotor, creamos el script Arduino que avanza el servomotor a un grado de 180 y lo devuelve a 0 grados. Describo en detalle el script escrito para las placas de microcontroladores Arduino, ESP8266 y ESP32.
#include "Servo.h"
int servo_pin = 9; // for Arduino microcontroller
//int servo_pin = D7; // for ESP8266 microcontroller
//int servo_pin = 4; // for ESP32 microcontroller
Servo myservo;
int angle = 0;
void setup()
{
myservo.attach(servo_pin);
}
void loop()
{ // move from 0 to 180 degrees with a positive angle of 1
for(angle = 0; angle < 180; angle += 1)
{
myservo.write(angle);
delay(15);
}
delay(1000);
// move from 180 to 0 degrees with a negative angle of 5
for(angle = 180; angle>=1; angle-=5)
{
myservo.write(angle);
delay(5);
}
delay(1000);
}
Al comienzo del script, incluimos la biblioteca Servo que facilita mucho la operación del servo.
A continuación, necesitamos definir el pin de E / S digital que conecta el microcontrolador al servomotor. Debido a que el pin utilizado depende del microcontrolador, creé un total de 3 líneas de código que corresponden a las imágenes de cableado anteriores. Depende de tu microcontrolador debes comentar 2 líneas y descomentar la línea de código que corresponde a tu microcontrolador.
Ahora podemos inicializar un objeto servo de la biblioteca de servos incluida anteriormente.
Nuestro objetivo es rotar el servo hasta cierto punto en cada bucle del código del programa. Por lo tanto, necesitamos una variable para almacenar el ángulo actual del motor. El valor inicial del ángulo es 0.
En la función de configuración, usamos la función adjuntar objeto de servo para decirle al objeto que el servomotor está conectado al husillo del servo.
En la función de bucle, necesitamos dos bucles para girar el motor de 0 grados a 180 grados y una segunda función que devuelve el motor a 0 grados pero con otra velocidad.
Por lo tanto, en cada bucle for, usamos la función de escritura del objeto myservo para establecer el ángulo absoluto que debe girar el servo. Este ángulo puede ser positivo y también negativo.
En el primer ciclo for, aumentamos el ángulo de cada ciclo en +1 y usamos un retardo de 15 milisegundos. Por lo tanto, el motor funciona con relativa lentitud.
En la función del segundo bucle, donde queremos que el servo vuelva a 0 grados, disminuimos el ángulo en cada bucle en 5 y usamos un retraso de 5 milisegundos. El motor gira más rápido de 180 grados a 0 grados.
Al final del script, esperamos 1 segundo y volvemos a iniciar la función de bucle.
El siguiente video muestra el script Arduino en acción con un Arduino Uno como ejemplo.
Ajuste el servomotor a un ángulo específico con un potenciómetro
En el segundo ejemplo, queremos usar un potenciómetro para ajustar el servomotor a un ángulo específico. Por lo tanto, leemos el valor del potenciómetro que está entre 0 y 1023, reescalamos el valor entre 0 y 180 para mover el motor entre 0 y 180 grados.
Cableado entre servomotor, microcontrolador y potenciómetro
La siguiente imagen muestra el cableado entre la placa del microcontrolador Arduino, EPS8266 o ESP32, el servomotor y el potenciómetro.
El cableado se basa en el primer cableado donde solo usamos el servomotor y el microcontrolador. Ahora necesitamos agregar la conexión para el potenciómetro. Usamos los mismos pines para la alimentación y necesitamos usar un pin analógico para leer el valor analógico actual del potenciómetro.
Arduino Nano
Para obtener más información sobre Arduino Nano, visite el tutorial de Arduino Nano.
Arduino Pro Mini
Arduino Uno
Para obtener más información sobre Arduino Uno, visite el tutorial de Arduino Uno.
Arduino Mega
Para obtener más información sobre Arduino Mega, visite el tutorial de Arduino Mega.
ESP32 NodeMCU
ESP8266 NodeMCU
ESP8266 WeMos D1 Mini
Código de programa para configurar el servomotor en un ángulo específico
La siguiente sección muestra y explica el código del programa Arduino para los microcontroladores Arduino, ESP8266 y ESP32 para configurar el servomotor en un ángulo específico con la entrada de un potenciómetro.
#include "Servo.h"
// for Arduino microcontroller
int servo_pin = 9;
int potpin = 0;
// for ESP8266 microcontroller
//int servo_pin = D7;
//int potpin = A0;
// for ESP32 microcontroller
//int servo_pin = 4;
//int potpin = 0;
Servo myservo;
int val;
void setup() {
myservo.attach(servo_pin);
}
void loop() {
val = analogRead(potpin);
val = map(val, 0, 1023, 0, 180);
myservo.write(val);
delay(15);
}
La primera parte del script de Arduino es muy similar a la anterior. Primero necesitamos incluir la biblioteca de servos y definir los pines que conectan la placa del microcontrolador al servo. Debido a que tenemos otro componente conectado en este ejemplo, también necesitamos configurar el pin analógico que conecta el potenciómetro y la placa Arduino, ESP8266 o ESP32.
Si no sabe qué pines de la placa del microcontrolador Arduino, ESP8266 o ESP32 se pueden usar para conectar diferentes componentes eléctricos, puedo recomendar el libro electrónico de la hoja de datos del microcontrolador.
Después de inicializar un objeto servo, creamos una variable para almacenar el valor del potenciómetro entre 0 y 1023.
La función de configuración sigue siendo la misma, basta con indicar al objeto servo a qué cabezal está conectado el motor.
En la función de lazo leemos el valor analógico del potenciómetro y asociamos el rango de valores del potenciómetro (0… 1023) con el rango de valores del servo (0… 180). Después del mapeo de valores, configuramos el ángulo del servo al valor del potenciómetro mapeado con la función de escritura e incluimos un breve retraso de 15 milisegundos para asegurarnos de que el servo pueda girar a la posición deseada.
El siguiente video muestra cómo gira el servo, controlado por el potenciómetro.
Conecte varios servomotores
Por supuesto, es posible conectar varios servos a su microcontrolador y el Arduino Mega tiene muchos pines. Pero hay una forma más inteligente de conectar múltiples servos a su Arduino o NodeMCU usando la conexión I2C. Si desea saber más sobre la conexión I2C, encontrará una guía completa en este artículo.
Servocontrolador de 16 canales PCA9685
Para conectar varios servomotores a través de I2C, utilizamos el servomotor de 16 canales PCA9685 que utiliza un controlador PWM integrado para controlar los 16 canales al mismo tiempo. Además, puede conectar varios servomotores PCA9685 de 16 canales en una cadena de hasta 62 controladores. Por lo tanto, podemos controlar hasta 992 servos con los 2 pines I2C.
La conexión entre el PCA9685 y el microcontrolador es simple y se muestra en la siguiente tabla, así como en el esquema de fritzing.
. . . . .
| PCA9685 | Descripción | Arduino | ESP32 | ESP8266 |
|---|---|---|---|---|
| GND | Tierra | GND | GND | GND |
| VCC | Pin de alimentación lógico que debe estar entre 3V y 5V | 5V | 3,3V | 3,3V |
| V+ | Pin de alimentación opcional para alimentar los servomotores. Conecte V+ a VIN o utilice el bloque de terminales de 2 pines en la parte superior de la placa PCA9685. Suministre 5V DC a 12V DC. Nota: No conecte V+ y el terminal de 2 pines al mismo tiempo. | VIN | VIN | |
| SCL | Pin de reloj I2C | Pin SCL (19) | Pin SCL (22) | Pin SCL (D1) |
| SDA | Pin de datos I2C | Pin SDA (18) | Pin SDA (21) | Pin SDA (D2) |
| OE | Puede utilizarse para deshabilitar rápidamente toda la salida cuando se tira a HIGH. No utilizamos la funcionalidad |
Si no está familiarizado con los pines SCL y SDA de su microcontrolador, encontrará los pines para cada placa en los siguientes artículos: Arduino Nano, Arduino Uno, Arduino Mega, ESP8266, ESP32 o mejor en el libro de jugadas de la hoja de datos del microcontrolador.
Los 16 puertos de salida (V +, GND y PWM) se pueden utilizar para conectar servos o LED. Todas las salidas usan la misma frecuencia PWM que puede ser de 1 kHz para LED y 60 Hz para servos. La corriente máxima por pin es de 25 mA. Si solo usa ciertos servos como hasta cinco, puede alimentarlos desde su microcontrolador. Pero si desea utilizar más motores, recomendaría alimentar los servos con el terminal de 2 pines y una fuente de alimentación externa. En la lista de piezas encontrará algunas buenas opciones para una fuente de alimentación externa.
Cableado entre el PCA9685 y el microcontrolador
Las siguientes imágenes muestran el cableado cuando no estamos usando una fuente de alimentación externa para la placa PCA9685.
Arduino Nano
Para obtener más información sobre Arduino Nano, visite el tutorial de Arduino Nano.
Arduino Pro Mini
Arduino Uno
Para obtener más información sobre Arduino Uno, visite el tutorial de Arduino Uno.
Arduino Mega
Para obtener más información sobre Arduino Mega, visite el tutorial de Arduino Mega.
ESP32 NodeMCU
ESP8266 NodeMCU
ESP8266 WeMos D1 Mini
Y si queremos utilizar muchos servomotores y por tanto necesitamos una fuente de alimentación externa, tenemos que desconectar la conexión entre V + y el microcontrolador y por tanto conectar el PCA9685 a una fuente de alimentación externa entre 5V y 12V.
Arduino Nano
Para obtener más información sobre Arduino Nano, visite el tutorial de Arduino Nano.
Arduino Pro Mini
Arduino Uno
Para obtener más información sobre Arduino Uno, visite el tutorial de Arduino Uno.
Arduino Mega
Para obtener más información sobre Arduino Mega, visite el tutorial de Arduino Mega.
ESP32 NodeMCU
ESP8266 NodeMCU
ESP8266 WeMos D1 Mini
Cómo parametrizar un servomotor
Antes de que podamos comenzar con el ejemplo en sí, debemos configurar nuestros servomotores para encontrar la posición exacta en 0 y 180 grados, cuando el motor está controlado por el PCA9685. Por lo tanto, utilizamos el boceto del primer ejemplo y debemos recordar la posición exacta del sujetador de plástico en el motor.
Ahora debemos encontrar los valores óptimos para dos parámetros: MIN_PULSE_WIDTH y MAX_PULSE_WIDTH para establecer la posición del servo en 0 grados y 180 grados. La siguiente imagen muestra el resultado deseado. He descubierto que para el Micro Servo Motor Longruner SG90 9G RC (KY66-5) los parámetros son los siguientes:
- MIN_PULSE_WIDTH = 600
- MAX_PULSE_WIDTH = 2600
Debido a que estos valores dependen de sus servos individuales, ahora necesitamos encontrar los valores óptimos para sus servos.
Encuentre el valor de MIN_PULSE_WIDTH
Usamos parte del futuro boceto completo para permitir que el motor se estabilice en 0 grados. Utilice el siguiente esquema y cambie los valores de MIN_PULSE_WIDTH hasta alcanzar la posición deseada. Tal vez sobrepase la posición y luego deba cambiar la configuración nuevamente.
El script de Arduino puede sonar un poco complicado pero explico todo en detalle. Además, la mayoría de los siguientes scripts son reutilizables para nosotros para el ejemplo real.
#include "Wire.h"
#include "Adafruit_PWMServoDriver.h"
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x40);
#define MIN_PULSE_WIDTH 600
#define MAX_PULSE_WIDTH 2600
#define FREQUENCY 50
void setup() {
pwm.begin();
pwm.setPWMFreq(FREQUENCY);
// find MIN_PULSE_WIDTH: set angle to 0
// find MAX_PULSE_WIDTH: set angle to 180
pwm.setPWM(0,0,pulseWidth(0)); // 0 or 180
}
int pulseWidth(int angle) {
int pulse_wide, analog_value;
pulse_wide = map(angle, 0, 180, MIN_PULSE_WIDTH, MAX_PULSE_WIDTH);
analog_value = int(float(pulse_wide) / 1000000 * FREQUENCY * 4096);
return analog_value;
}
void loop() {
}
Para controlar el PCA9685, usamos la biblioteca Adafruit_PWMServoDriver. Si no sabe cómo instalar una biblioteca, encontrará un tutorial aquí.
Primero incluimos las bibliotecas Wire.h para usar la comunicación I2C y Adafruit_PWMServoDriver para administrar la placa de servo de 16 canales CA9685. A continuación, creamos un objeto ServoDriver llamado pwm con la correspondiente dirección I2C HEX, es decir, en mi caso 0x40. Para encontrar la dirección I2C HEX correcta, puede utilizar el escáner de código I2C HEX en este artículo.
A continuación, definimos nuestras variables. En este paso, debe modificar los parámetros MIN_PULSE_WIDTH y establecer el parámetro MAX_PULSE_WIDTH en un valor fijo. Casi todos los servos utilizan una frecuencia de 50 Hz. Puede encontrar esta información en la hoja de datos de su motor.
En la función de configuración, el objeto PWM que creamos anteriormente se activa con la frecuencia de 50 Hz. También controlamos el servomotor con la función setPWM del objeto pwm. La función contiene 3 argumentos:
- En qué posición del PCA9685 está conectado el servo. Los números están impresos en la pizarra comenzando del 0 al 15.
- Constante 0
- Función para especificar el ángulo: PulseWidth (ángulo) donde el ángulo puede estar entre 0 y 180.
- Para encontrar el valor óptimo de MIN_PULSE_WIDTH, establezca el ángulo en 0
- Para encontrar el valor óptimo de MAX_PULSE_WIDTH, establezca el ángulo en 180
Debido a que solo queremos configurar el servomotor, necesitamos esta iteración de la función de configuración y necesitamos cambiar el valor de MIN_PULSE_WIDTH para obtener la posición de 0 grados. Por lo tanto, no necesitamos una función de bucle.
Ahora creamos la función pulseWidth para calcular el valor analógico del motor en función del ángulo deseado. Primero, el pulso con se calcula entre 0 grados y 180 grados según el ancho de pulso mínimo y máximo con la función de mapa. Luego, el valor del servo analógico se calcula dividiendo el ancho del pulso por 1,000,000 para convertir el valor a nosotros por segundo y multiplicarlo por la frecuencia y 4096 para una resolución de 12 bits. Al final de esta función, se devuelve este valor analógico.
Encuentre el valor de MAX_PULSE_WIDTH
Si encontró el valor correcto para MIN_PULSE_WIDTH, hacemos lo mismo con MAX_PULSE_WIDTH para encontrar la posición del motor 180 grados. Usamos el mismo código de programa y cambiamos el valor de MAX_PULSE_WIDTH hasta encontrar la posición de 180 grados. También debe cambiar el valor del ángulo en la función setPWM a 180. Debe establecerse el valor de MIN_PULSE_WIDTH.
Cómo controlar varios servomotores con el PCA9685
En este ejemplo, queremos utilizar 3 servomotores al mismo tiempo. La secuencia de comandos no tiene un uso práctico directo, pero muestra cómo controlar varios servos en una secuencia de comandos a través de la conexión I2C.
#include "Wire.h"
#include "Adafruit_PWMServoDriver.h"
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x40);
#define MIN_PULSE_WIDTH 600
#define MAX_PULSE_WIDTH 2600
#define FREQUENCY 50
void setup() {
pwm.begin();
pwm.setPWMFreq(FREQUENCY);
}
int pulseWidth(int angle) {
int pulse_wide, analog_value;
pulse_wide = map(angle, 0, 180, MIN_PULSE_WIDTH, MAX_PULSE_WIDTH);
analog_value = int(float(pulse_wide) / 1000000 * FREQUENCY * 4096);
return analog_value;
}
void loop() {
pwm.setPWM(0, 0, pulseWidth(0));
pwm.setPWM(1, 0, pulseWidth(180));
delay(1000);
pwm.setPWM(4, 0, pulseWidth(0));
delay(1000);
pwm.setPWM(0, 0, pulseWidth(180));
pwm.setPWM(1, 0, pulseWidth(90));
delay(500);
pwm.setPWM(4, 0, pulseWidth(180));
delay(1000);
pwm.setPWM(0, 0, pulseWidth(90));
pwm.setPWM(1, 0, pulseWidth(0));
delay(1000);
}
Debido a que ya conocemos la mayor parte del script por la parametrización, me centraré en los cambios que hicimos para este ejemplo.
La primera parte del script donde incluimos las bibliotecas, creamos el objeto pwm y establecemos las variables es la misma. MIN_PULSE_WIDTH y MAX_PULSE_WIDTH son los valores de la parametrización.
En la función de configuración, no usamos la función setPWM para hacer funcionar el motor. Esto se hace en la función de bucle, donde giramos los servomotores bajo diferentes ángulos con el argumento de la función pulseWidth.
Para diferenciar los servos, cambiamos el primer argumento de la función setPWM a un pin de conexión en la placa PCA9685. En mi caso, tengo un servo conectado a los pines 0, 1 y 4.
La función pulseWidth es la misma que la configuración del parámetro.
El siguiente video muestra el ejemplo en acción para Arduino Uno y ESP8266 NodeMCU.
Cómo utilizar varios PCA9685 en una cadena
Como se dijo anteriormente, es posible conectar varios PCA9685 en una cadena para conectar hasta 992 servos con los 2 pines I2C de su microcontrolador.
El siguiente esquema muestra cómo conectar varias tarjetas PCA9685.
Puede usar el diagrama del ejemplo anterior y solo necesita cambiar la dirección hexadecimal y crear tantos objetos ServoDriver como conecte las tarjetas PCA9685. Los objetos se pueden llamar pwm1, pwm2, etc. con la dirección individual I2C HEX. Como se mencionó anteriormente, puede usar el escáner de código I2C HEX en este artículo para encontrar las direcciones correctas.
Conclusión
En este tutorial, hemos aprendido mucho sobre servomotores. Primero analizamos la teoría sobre los servos y la funcionalidad. En la segunda parte del tutorial, llegamos a los ejemplos prácticos y comenzamos con algunos ejemplos básicos para cambiar a motor hasta 180 grados y volver a 0 grados. También logramos rotar el servo según la posición de un potenciómetro. Después del ejemplo simple, aprendimos cómo controlar múltiples servos con el PCA9685 y cómo conectar múltiples placas PCA9685.
Si tiene alguna pregunta sobre la funcionalidad del servomotor o cualquier ejemplo en este tutorial, use la sección de comentarios a continuación para hacer preguntas para que pueda responderlas directamente.
