Control de velocidad de un motor BLCD usando el driver ESC, ESP32 y un potenciómetro
Práctica: Control de velocidad de un motor BLCD usando el driver ESC, ESP32 y un potenciómetro
Introducción
En esta práctica, controlaremos la velocidad de un motor brushless (BLDC) utilizando un Electronic Speed Controller (ESC), un ESP32 y un potenciómetro. Los motores BLDC son ampliamente utilizados en drones, vehículos eléctricos y sistemas que requieren alta eficiencia. El ESC es un controlador que convierte las señales de control PWM (modulación por ancho de pulso) para manejar este tipo de motores. El ESP32 se encargará de generar la señal PWM en función de la posición del potenciómetro, permitiendo controlar la velocidad del motor de forma precisa.
Material necesario
- ESP32
- Motor BLDC (Brushless DC)
- ESC (Electronic Speed Controller) compatible con el motor
- Potenciómetro de 10kΩ
- Fuente de alimentación para el motor (dependiendo del ESC y motor)
- Cables de conexión
- Protoboard (opcional)
Desarrollo
1. Conexiones del circuito
- ESP32 y ESC: Conecta el pin de señal del ESC a un pin PWM del ESP32, por ejemplo, el pin GPIO 18.
- ESC y motor: Conecta el motor BLDC al ESC. Generalmente, el ESC tiene tres cables de salida que deben conectarse al motor.
- Potenciómetro y ESP32: Conecta el pin central del potenciómetro a un pin analógico del ESP32, como el GPIO 34. Los otros dos pines del potenciómetro se conectan a 3.3V y GND respectivamente.
- Alimentación: Conecta la fuente de alimentación al ESC y verifica que el motor y el ESC estén correctamente conectados.
2. Código para el ESP32
El siguiente código genera una señal PWM para controlar la velocidad del motor según la posición del potenciómetro. El valor analógico del potenciómetro se convierte en una señal PWM que varía la velocidad del motor.
#include <Arduino.h>
const int escPin = 18; // Pin de control del ESC
const int potPin = 34; // Pin analógico conectado al potenciómetro
int potValue = 0; // Variable para almacenar el valor del potenciómetro
int pwmValue = 0; // Variable para almacenar el valor del PWM
// Parámetros del PWM
const int pwmFreq = 50; // Frecuencia PWM para el ESC (50 Hz es típico para ESCs)
const int pwmChannel = 0; // Canal de PWM
const int pwmResolution = 16; // Resolución del PWM (16 bits para mayor precisión)
void setup() {
// Configuración del canal PWM
ledcSetup(pwmChannel, pwmFreq, pwmResolution);
ledcAttachPin(escPin, pwmChannel);
// Configuración del potenciómetro
pinMode(potPin, INPUT);
}
void loop() {
// Leer el valor del potenciómetro (0-4095)
potValue = analogRead(potPin);
// Mapear el valor del potenciómetro al rango del PWM del ESC (escala de 0 a 65535 para 16 bits)
pwmValue = map(potValue, 0, 4095, 3277, 6553); // Ajuste de velocidad mínima a máxima
// Escribir el valor PWM al ESC
ledcWrite(pwmChannel, pwmValue);
// Pequeña pausa para estabilidad
delay(10);
}
3. Descripción del código
- Configuración del PWM: Utilizamos el pin 18 del ESP32 para generar la señal PWM, con una frecuencia de 50 Hz, que es la típica para ESCs.
- Lectura del potenciómetro: Se lee el valor analógico del potenciómetro con el pin 34. El valor leido es de 0 a 4095, ya que el ESP32 tiene un ADC de 12 bits.
- Control del ESC: El valor leído se mapea a un rango apropiado para el ESC. Los ESC suelen aceptar señales PWM de entre 1000 y 2000 microsegundos, por lo que ajustamos el rango de salida.
4. Funcionamiento
Una vez que las conexiones están hechas y el código cargado en el ESP32, podrás controlar la velocidad del motor BLDC girando el potenciómetro. Cuando el potenciómetro está en su posición mínima, el motor estará parado o girando muy despacio, mientras que al girarlo hacia la posición máxima, el motor alcanzará su máxima velocidad.
Conclusión
Este proyecto es una aplicación práctica de cómo controlar motores BLDC utilizando el ESP32, un ESC y un potenciómetro. La señal PWM es crucial para el control de motores de este tipo, y el ESP32, con su capacidad para generar PWM en múltiples canales, es una herramienta poderosa para estos proyectos.