Control PID de velocidad para motor DC con ESP32
Control PID de velocidad para motor DC con ESP32, encoder y pantalla OLED: proyecto completo
Aprende a construir un controlador de velocidad con cinco estados de configuración. El sistema permite definir una referencia de 0 a 160 RPM, ajustar las ganancias Kp, Ki y Kd con un potenciómetro, medir la velocidad de un motor DC con encoder y visualizar las variables en una OLED SSD1306. El control del motor se realiza por PWM mediante MOSFET.
Transparencia: Algunos enlaces de compra de este artículo son enlaces de afiliado. Si compras desde ellos, podría recibir una comisión sin costo adicional para ti.
¿Qué aprenderás?
- Medir la velocidad de un motor con un encoder de 64 PPR.
- Calcular las RPM del eje de salida con una reductora 30:1.
- Implementar una máquina de estados con un botón y un potenciómetro.
- Regular la velocidad del motor con un controlador PID discreto.
- Mostrar referencia, RPM, error y PWM en una pantalla OLED.
Materiales necesarios y enlaces de Temu
Los botones siguientes son marcadores de posición. Antes de publicar, reemplaza cada URL_AFILIADO_TEMU_XX por tu enlace personal generado en el programa de afiliados de Temu; de lo contrario no serán enlaces de compra funcionales.
| Material | Cantidad | Qué verificar | Enlace de compra |
|---|---|---|---|
| ESP32 DevKit (ESP32-WROOM) | 1 | ESP32 de 3.3 V; este montaje usa GPIO 34, 21 y 22. | Ver en Temu |
| Motor DC con encoder 64 PPR y reductora 30:1 | 1 | Confirma 64 PPR por canal, encoder situado antes de la reductora y tensión del motor. | Ver en Temu |
| Pantalla OLED SSD1306 I2C de 0.96 pulgadas | 1 | 128×64 píxeles, dirección I2C usual 0x3C. | Ver en Temu |
| Módulo MOSFET para motor DC | 1 | Compatible con señal de 3.3 V y corriente de arranque del motor; con protección inductiva. | Ver en Temu |
| Potenciómetro de 10 kΩ | 1 | Tres terminales; extremos a 3.3 V y GND. | Ver en Temu |
| Botón pulsador normalmente abierto | 1 | Entre GPIO 4 y GND. | Ver en Temu |
| Fuente DC para el motor | 1 | Tensión nominal correcta, corriente suficiente y GND compartida. | Ver en Temu |
| Protoboard o placa perforada | 1 | Para montaje de prototipo. | Ver en Temu |
| Juego de cables Dupont | 1 | Para interconexiones. | Ver en Temu |
| Resistencia de compuerta y pull-down / diodo flyback | 1 | Según el MOSFET y el módulo utilizado; no omitir protección de la carga. | Ver en Temu |
Nota: los productos de Temu pueden cambiar de vendedor, disponibilidad y características. Revisa la ficha técnica antes de recomendar o comprar.
Características técnicas
- Controlador: ESP32 clásico tipo DevKit/WROOM.
- Referencia: 0–160 RPM en el eje de salida (no garantiza que el motor alcance todo el rango).
- Encoder: 64 PPR en el eje del motor, contando flancos de subida del canal A.
- Reductora: 30:1.
- PWM: 20 kHz, resolución de 8 bits (0–255).
- Intervalo de control: 200 ms.
- Interfaz: OLED de 128×64 px, 1 botón, 1 potenciómetro.
¿Cómo funciona la máquina de estados?
- Estado 0 — Referencia: gira el potenciómetro para seleccionar de 0 a 160 RPM. Pulsa el botón para guardar.
- Estado 1 — Kp: ajusta la ganancia proporcional y pulsa para guardar.
- Estado 2 — Ki: ajusta la ganancia integral y pulsa para guardar.
- Estado 3 — Kd: ajusta la ganancia derivativa y pulsa para iniciar el control.
- Estado 4 — PID: el motor funciona, se mide la velocidad y la OLED muestra referencia, RPM, error y PWM. Al pulsar el botón se apaga la señal PWM y regresa al estado 0.
Durante los estados de configuración el motor permanece apagado. El potenciómetro no cambia la referencia durante el funcionamiento PID: los parámetros quedan guardados en memoria RAM hasta la siguiente configuración o reinicio.
Conexiones del circuito
| Componente o señal | Conexión ESP32 | Observaciones |
|---|---|---|
| Potenciómetro, terminal central | GPIO 34 | Extremos a 3.3 V y GND; nunca aplicar 5 V a la entrada. |
| Botón | GPIO 4 y GND | Entrada INPUT_PULLUP. |
| Encoder, canal A | GPIO 2 | Cuenta flancos ascendentes. GPIO 2 puede afectar el arranque; se puede cambiar a GPIO 25. |
| Encoder, canal B | GPIO 26 | Conectado, pero no se utiliza para medir velocidad en este programa. |
| Señal de control MOSFET | GPIO 23 | Control PWM de 3.3 V; dimensionar driver y protección. |
| OLED SDA / SCL | GPIO 21 / GPIO 22 | Bus I2C. |
| Alimentación del motor | Fuente externa | No alimentar el motor desde los GPIO del ESP32. |
| GND del circuito | GND común | Compartir referencia entre ESP32, driver y fuente. |
Precaución eléctrica: usa un MOSFET o módulo controlador apto para el voltaje y la corriente de arranque del motor. Instala protección contra el voltaje inductivo (por ejemplo, diodo flyback correctamente dimensionado si corresponde). El GPIO de 3.3 V no debe recibir 5 V desde el encoder; adapta niveles si es necesario. Antes de energizar comprueba el cableado y la polaridad.
Cómo calcular las RPM con encoder y reductora
Este proyecto supone 64 pulsos por revolución por canal en el eje del motor, y que 30 vueltas del motor equivalen a una vuelta del eje de salida. Por ello se generan 64 × 30 = 1920 pulsos por vuelta de salida al contar solo flancos ascendentes del canal A.
RPM_salida = (pulsos × 60000) / (64 × 30 × tiempo_ms)
Con una muestra de 200 ms: RPM_salida = pulsos × 0.15625. Ejemplo: 640 pulsos en 200 ms son 100 RPM de salida. El software utiliza el tiempo real medido para mantener la precisión si el bucle se demora ligeramente.
Importante: si tu motor indica 64 cuentas por revolución con decodificación de cuatro flancos, o si el encoder se encuentra después de la reductora, hay que modificar la constante; el factor 1920 no sería válido.
Explicación del control PID
El PID compara la referencia con la velocidad real: error = referencia − RPM_medida. El término proporcional reacciona al error actual; el integral acumula error en el tiempo; el derivativo se calcula sobre el cambio de la medición para reducir el salto al modificar la referencia. La salida se limita a un PWM de 0 a 255. Se incluye anti-windup por integración condicional.
Los rangos del potenciómetro son: Kp de 0 a 5, Ki de 0 a 5 y Kd de 0 a 0.20. Estos intervalos son solo orientativos: el ajuste real depende del motor, fuente de alimentación, carga y fricción. Comienza con Ki y Kd en cero y aumenta Kp gradualmente.
Código Arduino completo para ESP32
Instala las bibliotecas Adafruit SSD1306 y Adafruit GFX Library desde el gestor de bibliotecas del Arduino IDE. Usa una placa ESP32 clásica compatible; el código detecta las familias Arduino-ESP32 2.x y 3.x para utilizar la API PWM correspondiente.
#include <Arduino.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <esp_arduino_version.h>
// Proyecto: controlador PID de velocidad del eje de salida
// Encoder 64 PPR en el eje del motor, reduccion 30:1.
// Unicamente se cuentan flancos ascendentes del canal A.
#define ANCHO_OLED 128
#define ALTO_OLED 64
#define DIRECCION_OLED 0x3C
Adafruit_SSD1306 oled(ANCHO_OLED, ALTO_OLED, &Wire, -1);
constexpr uint8_t PIN_POT = 34;
constexpr uint8_t PIN_BOTON = 4;
constexpr uint8_t PIN_ENC_A = 2; // GPIO de arranque: ver advertencia del articulo
constexpr uint8_t PIN_ENC_B = 26; // Reservado: no necesario para RPM
constexpr uint8_t PIN_MOSFET = 23;
constexpr uint8_t PIN_SDA = 21;
constexpr uint8_t PIN_SCL = 22;
constexpr float PPR_MOTOR = 64.0f;
constexpr float REDUCTORA = 30.0f;
constexpr float PULSOS_VUELTA_SALIDA = PPR_MOTOR * REDUCTORA;
constexpr float RPM_MAX_REF = 160.0f;
constexpr uint32_t MUESTREO_MS = 200;
constexpr uint32_t OLED_MS = 100;
constexpr uint32_t REBOTE_MS = 50;
constexpr uint8_t CANAL_PWM = 0;
constexpr uint32_t FRECUENCIA_PWM = 20000;
constexpr uint8_t RESOLUCION_PWM = 8;
constexpr float PWM_MAX = 255.0f;
// Rangos propuestos, ajustar al motor real
constexpr float KP_MAX = 5.0f;
constexpr float KI_MAX = 5.0f;
constexpr float KD_MAX = 0.20f;
enum Estado : uint8_t { REF, AJUSTE_KP, AJUSTE_KI, AJUSTE_KD, PID_ACTIVO };
Estado estado = REF;
volatile uint32_t pulsosAcumulados = 0;
portMUX_TYPE muxEncoder = portMUX_INITIALIZER_UNLOCKED;
float referencia = 0.0f;
float kp = 0.10f, ki = 0.04f, kd = 0.002f;
float ajuste = 0.0f;
float rpm = 0.0f;
float rpmPrev = 0.0f;
float integral = 0.0f;
float pwm = 0.0f;
float error = 0.0f;
uint32_t ultimoPID = 0, ultimoOLED = 0;
uint32_t ultimoCambioBoton = 0;
bool lecturaPrevia = HIGH, botonEstable = HIGH;
void IRAM_ATTR interrupcionEncoder() {
portENTER_CRITICAL_ISR(&muxEncoder);
pulsosAcumulados++;
portEXIT_CRITICAL_ISR(&muxEncoder);
}
void configurarPWM() {
#if ESP_ARDUINO_VERSION_MAJOR >= 3
if (!ledcAttach(PIN_MOSFET, FRECUENCIA_PWM, RESOLUCION_PWM)) {
Serial.println("Error al configurar PWM");
while (true) delay(1000);
}
#else
ledcSetup(CANAL_PWM, FRECUENCIA_PWM, RESOLUCION_PWM);
ledcAttachPin(PIN_MOSFET, CANAL_PWM);
#endif
}
void escribirPWM(uint8_t duty) {
#if ESP_ARDUINO_VERSION_MAJOR >= 3
ledcWrite(PIN_MOSFET, duty);
#else
ledcWrite(CANAL_PWM, duty);
#endif
}
void apagarMotor() {
pwm = 0;
escribirPWM(0);
}
void reiniciarPID() {
apagarMotor();
integral = 0;
error = 0;
rpmPrev = rpm;
}
float leerRango(float minimo, float maximo) {
int valor = constrain(analogRead(PIN_POT), 0, 4095);
return minimo + (maximo - minimo) * (valor / 4095.0f);
}
void actualizarAjuste() {
switch (estado) {
case REF: ajuste = leerRango(0, RPM_MAX_REF); break;
case AJUSTE_KP: ajuste = leerRango(0, KP_MAX); break;
case AJUSTE_KI: ajuste = leerRango(0, KI_MAX); break;
case AJUSTE_KD: ajuste = leerRango(0, KD_MAX); break;
case PID_ACTIVO: break;
}
}
void avanzarEstado() {
// Guardar el valor exactamente al pulsar el boton
if (estado != PID_ACTIVO) actualizarAjuste();
switch (estado) {
case REF:
referencia = ajuste;
estado = AJUSTE_KP;
break;
case AJUSTE_KP:
kp = ajuste;
estado = AJUSTE_KI;
break;
case AJUSTE_KI:
ki = ajuste;
estado = AJUSTE_KD;
break;
case AJUSTE_KD:
kd = ajuste;
reiniciarPID();
estado = PID_ACTIVO;
break;
case PID_ACTIVO:
apagarMotor(); // Parar inmediatamente al pulsar
reiniciarPID();
estado = REF;
break;
}
actualizarAjuste();
Serial.print("Estado actual: ");
Serial.println((int)estado);
}
void leerBoton() {
bool lectura = digitalRead(PIN_BOTON);
uint32_t t = millis();
if (lectura != lecturaPrevia) ultimoCambioBoton = t;
if ((uint32_t)(t - ultimoCambioBoton) >= REBOTE_MS && lectura != botonEstable) {
botonEstable = lectura;
if (botonEstable == LOW) avanzarEstado();
}
lecturaPrevia = lectura;
}
void actualizarRPM(uint32_t dtMs) {
portENTER_CRITICAL(&muxEncoder);
uint32_t n = pulsosAcumulados;
pulsosAcumulados = 0;
portEXIT_CRITICAL(&muxEncoder);
rpm = (n * 60000.0f) / (PULSOS_VUELTA_SALIDA * dtMs);
}
void ejecutarPID(float dt) {
if (referencia < 0.5f) {
reiniciarPID();
return;
}
error = referencia - rpm;
float P = kp * error;
float D = -kd * (rpm - rpmPrev) / dt;
float candidata = integral + error * dt;
float salidaTentativa = P + ki * candidata + D;
// Anti-windup por integracion condicional
if (!((salidaTentativa > PWM_MAX && error > 0) ||
(salidaTentativa < 0 && error < 0))) {
integral = candidata;
}
pwm = constrain(P + ki * integral + D, 0.0f, PWM_MAX);
rpmPrev = rpm;
escribirPWM((uint8_t)(pwm + 0.5f));
}
void mostrarOLED() {
oled.clearDisplay();
oled.setTextSize(1);
oled.setTextColor(SSD1306_WHITE);
oled.setCursor(0, 0);
switch (estado) {
case REF:
oled.println("0/4 REFERENCIA");
oled.println("--------------------");
oled.print("Ref: "); oled.print(ajuste, 1); oled.println(" RPM");
oled.println("Rango: 0-160 RPM");
oled.println(); oled.println("Boton: guardar");
break;
case AJUSTE_KP:
oled.println("1/4 GANANCIA Kp");
oled.println("--------------------");
oled.print("Kp: "); oled.println(ajuste, 3);
oled.print("Ref: "); oled.print(referencia, 1); oled.println(" RPM");
oled.println(); oled.println("Boton: guardar");
break;
case AJUSTE_KI:
oled.println("2/4 GANANCIA Ki");
oled.println("--------------------");
oled.print("Ki: "); oled.println(ajuste, 3);
oled.print("Kp: "); oled.println(kp, 3);
oled.println(); oled.println("Boton: guardar");
break;
case AJUSTE_KD:
oled.println("3/4 GANANCIA Kd");
oled.println("--------------------");
oled.print("Kd: "); oled.println(ajuste, 4);
oled.print("Ki: "); oled.println(ki, 3);
oled.println(); oled.println("Boton: iniciar");
break;
case PID_ACTIVO:
oled.println("4/4 PID ACTIVO");
oled.print("Ref: "); oled.print(referencia, 1); oled.println(" RPM");
oled.print("Med: "); oled.print(rpm, 1); oled.println(" RPM");
oled.print("Err: "); oled.println(error, 1);
oled.print("PWM: "); oled.print(pwm, 0); oled.println("/255");
oled.println("Boton: detener");
break;
}
oled.display();
}
void setup() {
Serial.begin(115200);
pinMode(PIN_POT, INPUT);
pinMode(PIN_BOTON, INPUT_PULLUP);
pinMode(PIN_ENC_A, INPUT_PULLUP);
pinMode(PIN_ENC_B, INPUT_PULLUP);
pinMode(PIN_MOSFET, OUTPUT);
digitalWrite(PIN_MOSFET, LOW);
analogReadResolution(12);
configurarPWM();
apagarMotor();
Wire.begin(PIN_SDA, PIN_SCL);
if (!oled.begin(SSD1306_SWITCHCAPVCC, DIRECCION_OLED)) {
Serial.println("No se detecto pantalla OLED");
while (true) delay(1000);
}
attachInterrupt(digitalPinToInterrupt(PIN_ENC_A), interrupcionEncoder, RISING);
actualizarAjuste();
mostrarOLED();
ultimoPID = millis();
ultimoOLED = ultimoPID;
Serial.print("Version Arduino ESP32: ");
Serial.println(ESP_ARDUINO_VERSION_STR);
}
void loop() {
uint32_t ahora = millis();
if (estado != PID_ACTIVO) actualizarAjuste();
leerBoton();
ahora = millis();
if ((uint32_t)(ahora - ultimoPID) >= MUESTREO_MS) {
uint32_t dtMs = ahora - ultimoPID;
ultimoPID = ahora;
actualizarRPM(dtMs);
if (estado == PID_ACTIVO) ejecutarPID(dtMs / 1000.0f);
else apagarMotor();
Serial.print("Estado:"); Serial.print((int)estado);
Serial.print(" Ref:"); Serial.print(referencia, 1);
Serial.print(" RPM:"); Serial.print(rpm, 1);
Serial.print(" PWM:"); Serial.println(pwm, 0);
}
if ((uint32_t)(ahora - ultimoOLED) >= OLED_MS) {
ultimoOLED = ahora;
mostrarOLED();
}
}
Pasos de montaje y puesta en marcha
- Identifica tensión nominal del motor y tipo de salida del encoder.
- Con la alimentación desconectada, conecta pantalla OLED, potenciómetro y botón al ESP32.
- Conecta el encoder con los niveles de señal adecuados y el MOSFET según su hoja de datos.
- Añade protección inductiva y conecta una fuente externa adecuada para el motor, con GND común.
- En Arduino IDE, instala el soporte ESP32 y las bibliotecas de Adafruit.
- Copia el código en un archivo
Control_PID_ESP32.ino, selecciona la placa y carga el programa. - Con el motor detenido, revisa las cuatro pantallas de ajuste y el comportamiento del botón.
- Para iniciar pruebas, define una referencia baja y establece Ki = 0 y Kd = 0; después aumenta Kp suavemente.
- Comprueba que las RPM mostradas correspondan al eje de salida y ajusta las ganancias progresivamente.
- Al presionar el botón durante el PID, el MOSFET deja de aplicar PWM. El motor puede seguir girando por inercia; no es frenado activo.
Problemas frecuentes y soluciones
La pantalla OLED no enciende
Revisa alimentación, SDA en GPIO 21, SCL en GPIO 22 y la dirección I2C 0x3C. Algunas pantallas usan otra dirección.
Las RPM aparecen en cero
Verifica el canal A del encoder, la masa común y que la señal sea compatible con 3.3 V. El encoder puede necesitar resistencias pull-up adecuadas.
La lectura de RPM es incorrecta
Confirma si 64 significa pulsos por canal o cuentas totales x4; comprueba que la reductora sea 30:1 y que el encoder mida el eje del motor.
El motor no arranca en velocidades bajas
Puede necesitar un PWM mínimo para vencer la fricción estática, además de un ajuste de ganancias. No fuerces el motor si se calienta o consume demasiada corriente.
El ESP32 no inicia
GPIO 2 es un pin implicado en el arranque de muchos ESP32 clásicos. Cambia el canal A a GPIO 25 y modifica PIN_ENC_A en el código si el encoder interfiere con el inicio.
Conclusión
Este controlador de velocidad con ESP32 combina electrónica de potencia, medición por encoder, programación por estados y control automático PID. Es un proyecto práctico para estudiar cómo un lazo de realimentación regula las RPM del eje de salida de un motorreductor.
¿Quieres construirlo? Consulta los materiales de la tabla anterior y adapta el circuito a las características de tu motor.
