Tutorial de servomotor para Arduino, ESP8266 y ESP32

En este tutorial aprenderás la funcionalidad de un servomotor así como a controlar uno o varios servos con tu placa Arduino o ESP8266.

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.

diagrama de control de posición del servomotor

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.

Tutorial de servomotor para Arduino, ESP8266 y ESP32

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.

.

CriteriosEspecificación
Velocidad de funcionamiento0,12 segundos/ 60 grados ( 4,8V sin carga)
Par de arranque (4,8V)17,5oz /in (1kg/cm)
Tensión de funcionamiento3,0V~7,2V
Rango de temperatura30 a +60 grados Celsius
Ancho de banda muerta7µs
Frecuencia de trabajo50Hz
Tipo de motorMotor de corriente continua con escobillas
Tipo de engranajeEngranajes de plástico
Dimensiones23 x 11,5 x 24mm
Peso9 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 NanoAmazonAliExpress
Arduino Pro MiniAmazonAliExpress
Arduino UnoAmazonAliExpress
Arduino MegaAmazonAliExpress
ESP32 ESP-WROOM-32AmazonAliExpress
ESP8266 NodeMCUAmazonAliExpress
ESP8266 WeMos D1 MiniAmazonAliExpress
Potenciómetro / Codificador rotativoAmazonAliExpress
Servo MotorAmazonAliExpress
PCA9685 16 CH 12Bit PWM Servo Motor DriverAmazonAliExpress

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

Arduino Nano Servo

Para obtener más información sobre Arduino Nano, visite el tutorial de Arduino Nano.

Arduino Pro Mini

Arduino Pro Mini Servo

Arduino Uno

Servo Arduino Uno

Para obtener más información sobre Arduino Uno, visite el tutorial de Arduino Uno.

Arduino Mega

Arduino Mega Servo

Para obtener más información sobre Arduino Mega, visite Arduino Nano Mega.

ESP32 NodeMCU

Servo ESP32 NodeMCU

ESP8266 NodeMCU

Servo ESP8266 NodeMCU

ESP8266 WeMos D1 Mini

ESP8266 WeMos D1 Mini Servo

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.

https://youtu.be/EV91A7WgEb0

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

Servo potenciómetro Arduino Nano

Para obtener más información sobre Arduino Nano, visite el tutorial de Arduino Nano.

Arduino Pro Mini

Servo potenciómetro Arduino Pro Mini

Arduino Uno

Potenciómetro Servo Arduino Uno

Para obtener más información sobre Arduino Uno, visite el tutorial de Arduino Uno.

Arduino Mega

Potenciómetro Servo Arduino Mega

Para obtener más información sobre Arduino Mega, visite el tutorial de Arduino Mega.

ESP32 NodeMCU

Servo potenciómetro ESP32 NodeMCU

ESP8266 NodeMCU

Servo potenciómetro ESP8266 NodeMCU

ESP8266 WeMos D1 Mini

Potenciómetro Servo 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.

https://youtu.be/Nhsb5cZb8ds

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.

PCA9685

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.

. . . . .

PCA9685DescripciónArduinoESP32ESP8266
GNDTierraGNDGNDGND
VCCPin de alimentación lógico que debe estar entre 3V y 5V5V3,3V3,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.VINVIN
SCLPin de reloj I2CPin SCL (19)Pin SCL (22)Pin SCL (D1)
SDAPin de datos I2CPin SDA (18)Pin SDA (21)Pin SDA (D2)
OEPuede 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

Servo PCA9685 Arduino Nano

Para obtener más información sobre Arduino Nano, visite el tutorial de Arduino Nano.

Arduino Pro Mini

Servo PCA9685 Arduino Pro Mini

Arduino Uno

Servo PCA9685 Arduino Uno

Para obtener más información sobre Arduino Uno, visite el tutorial de Arduino Uno.

Arduino Mega

Servo PCA9685 Arduino Mega

Para obtener más información sobre Arduino Mega, visite el tutorial de Arduino Mega.

ESP32 NodeMCU

Servo PCA9685 ESP32 NodeMCU

ESP8266 NodeMCU

Servo PCA9685 ESP8266 NodeMCU

ESP8266 WeMos D1 Mini

Servo PCA9685 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

Fuente de alimentación externa Servo PCA9685 Arduino Nano

Para obtener más información sobre Arduino Nano, visite el tutorial de Arduino Nano.

Arduino Pro Mini

Servo PCA9685 Fuente de alimentación externa Arduino Pro Mini

Arduino Uno

Fuente de alimentación externa Servo PCA9685 Arduino Uno

Para obtener más información sobre Arduino Uno, visite el tutorial de Arduino Uno.

Arduino Mega

Fuente de alimentación externa Servo PCA9685 Arduino Mega

Para obtener más información sobre Arduino Mega, visite el tutorial de Arduino Mega.

ESP32 NodeMCU

Fuente de alimentación externa Servo PCA9685 ESP32 NodeMCU

ESP8266 NodeMCU

Servo PCA9685 Fuente de alimentación externa ESP8266 NodeMCU

ESP8266 WeMos D1 Mini

Servo PCA9685 Fuente de alimentación externa 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
Encuentre el ancho de pulso mínimo y máximo

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:

  1. En qué posición del PCA9685 está conectado el servo. Los números están impresos en la pizarra comenzando del 0 al 15.
  2. Constante 0
  3. Función para especificar el ángulo: PulseWidth (ángulo) donde el ángulo puede estar entre 0 y 180.
    1. Para encontrar el valor óptimo de MIN_PULSE_WIDTH, establezca el ángulo en 0
    2. 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.

https://youtu.be/UC3flOXLzR0
https://youtu.be/B80TmoR24bk

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.

Múltiples Arduino Servo 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.


Deja un comentario