# Sistema para controlar un motor DC — guía práctica (rápida y utilizable)
Cuando se trata de diseñar un sistema de control para un motor DC, te doy un sistema completo (hardware + firmware) que puedes usar tal cual o adaptar: desde control simple (velocidad y dirección) hasta control cerrado (PID con encoder). Incluye lista de componentes, esquemas conceptuales, y código de ejemplo para Arduino.
—
# 1) Resumen rápido
* Objetivo: controlar velocidad y sentido de giro de un motor DC (desde pequeño hobby hasta motores de potencia media).
* Modos:
* **Open-loop**: PWM para velocidad, H-bridge o MOSFET para dirección.
* **Closed-loop**: añadir encoder + PID para mantener velocidad/posicion.
* Hardware típico: fuente de alimentación adecuada, driver (H-bridge o MOSFET), microcontrolador (Arduino/ESP32), sensor (encoder/ACS712 para corriente), protección (diodo flyback, fusible, snubber).
—
# 2) Componentes comunes (BOM básico)
* Motor DC (ej. 12 V, 5 A) — *según tu motor*.
* Driver H-bridge (bidireccional) o MOSFETs:
* Opciones fáciles: **L298N** (viejo, disipación alta) o **DRV8871/DRV8833** (más moderno).
* Para potencias mayores: H-bridge con MOSFETs (p.ej. IRF3205) o controladores integrados (p.ej. **VNH5019**, **IBT-2/MD30C**, etc.).
* Microcontrolador: **Arduino Uno / Nano / Pro Mini / ESP32**.
* Sensor de velocidad: encoder incremental (disco + opto / sensor Hall) o tacómetro.
* Sensor de corriente (opcional): **ACS712** o un shunt y amplificador.
* Fuente de alimentación DC estable (v rated ≥ motor voltaje, corriente nominal × margen 1.2–2×).
* Diodos flyback (si usas MOSFETs individuales), fusible, condensadores de desacoplo.
* Resistencias, pulsadores, potenciómetro (para control manual), cables, disipadores.
—
# 3) Bloques del sistema (concepto)
1. Fuente de alimentación -> 2. Driver de potencia (H-bridge / MOSFETs) <- control PWM y pines de dirección desde MCU -> 3. Motor
2. Feedback (encoder) -> MCU -> algoritmo de control (PID) -> PWM
—
# 4) Esquemas básicos
## A) Control **unidireccional** (solo velocidad) con MOSFET N-channel (low-side)
* Conexiones:
* Motor + -> alimentación +
* Motor – -> Drain de MOSFET (N-channel)
* Source -> GND
* Gate -> salida PWM del Arduino (vía resistor 100Ω) y gate-to-source resistor 100k a GND.
* Diodo flyback (p.ej. Schottky 60V) entre motor- y alimentación+ (si driver no lo incorpora).
* Condensador electrolítico grande cerca del motor (p.ej. 100µF–470µF).
* Nota: low-side solo permite girar en un sentido (a menos que pongas H-bridge).
## B) Control **bidireccional** con H-bridge (p.ej. DRV8871, VNH5019 o MOSFET H-bridge)
* Señales típicas:
* IN1/IN2 o DIR/PWM
* PWM para modular velocidad, DIR para sentido
* Si usas L298: conecta VMotor, GND, IN1/IN2 desde Arduino y ENA a PWM.
—
# 5) Frecuencia PWM recomendada
* Para motores DC mediante MOSFET/H-bridge, frecuencias **entre 8 kHz y 20 kHz** son comunes.
* < ~2–4 kHz puede generar zumbido audible.
* > ~20–30 kHz puede aumentar pérdidas de conmutación (depende del driver y MOSFET).
* Ajusta según tu driver y pruebas.
—
# 6) Selección de MOSFET/driver — cosas a chequear
* **Vds** ≥ 1.5× tensión de alimentación (ej. para 12 V usar MOSFET 30–60 V).
* **Rds(on)** lo más bajo posible para minimizar calentamiento (p. ej. < 10 mΩ para corrientes grandes).
* Corriente continua (Id) ≥ corriente máxima del motor × margen 1.5–2×.
* Añadir disipador si hay disipación significativa.
Cálculo pérdida aproximada en MOSFET: ( P = I_{rms}^2 \times R_{ds(on)} ).
—
# 7) Protección
* Fusible en línea: dimensionar a ~1.2× corriente nominal.
* Diodo flyback o driver que lo incluya.
* Capacitores de desacoplo (cerámico 0.1µF + electrolítico 100–470µF).
* Monitor de corriente para detectar sobrecargas.
* Limitación de velocidad por software (soft-start).
—
# 8) Aca tienes un ejemplo típico de control, elegimos este hardware por ser de los mas usados y conocidos (Arduino)
### A) Control básico velocidad + dirección (H-bridge con pines DIR y PWM)
«`cpp
// Control básico PWM + dirección (Arduino)
const int pinPWM = 9; // PWM pin (must be PWM)
const int pinDIR = 8; // Direction pin
const int pinBrake = 7; // optional brake pin
void setup() {
pinMode(pinPWM, OUTPUT);
pinMode(pinDIR, OUTPUT);
pinMode(pinBrake, OUTPUT);
digitalWrite(pinBrake, LOW);
}
void loop() {
// ejemplo: ramp up forward
digitalWrite(pinDIR, HIGH); // forward
for (int duty=0; duty<=255; duty+=5) {
analogWrite(pinPWM, duty);
delay(20);
}
delay(1000);
// ramp down
for (int duty=255; duty>=0; duty-=5) {
analogWrite(pinPWM, duty);
delay(20);
}
delay(500);
// cambio de sentido
digitalWrite(pinDIR, LOW); // reverse
for (int duty=0; duty<=200; duty+=5) {
analogWrite(pinPWM, duty);
delay(20);
}
delay(1000);
// stop
analogWrite(pinPWM, 0);
delay(2000);
}
«`
### B) Control PID simple con encoder (esquema conceptual)
* Lee encoder (pulsos por revolución) -> calcula velocidad (RPM)
* PID: compara velocidad deseada vs medida -> salida PWM
Snippet básico (usar librería Encoder y PID_v1 para más robustez):
«`cpp
#include <Encoder.h>
#include <PID_v1.h>
Encoder enc(2,3); // pines de encoder A,B
double setpoint = 100.0; // rpm objetivo
double input = 0;
double output = 0;
double Kp=1.0, Ki=0.5, Kd=0.05;
PID myPID(&input, &output, &setpoint, Kp, Ki, Kd, DIRECT);
unsigned long lastTime = 0;
long lastPos = 0;
void setup() {
pinMode(9, OUTPUT); // PWM
pinMode(8, OUTPUT); // DIR
myPID.SetMode(AUTOMATIC);
myPID.SetOutputLimits(0,255);
lastTime = millis();
}
void loop() {
unsigned long now = millis();
if (now – lastTime >= 100) { // cada 100 ms
long pos = enc.read();
long delta = pos – lastPos;
// convertir delta a RPM depende de PPR del encoder:
// RPM = (delta / PPR) * (60000 / dt_ms)
const int PPR = 360; // pulses per revolution (ajusta)
double rpm = ( (double)delta / PPR ) * (60000.0 / (now – lastTime));
input = rpm;
myPID.Compute();
analogWrite(9, (int)output);
lastPos = pos;
lastTime = now;
}
}
«`
*(Ajusta Kp, Ki, Kd, y PPR del encoder al motor.)*
—
# 9) Ejemplo de dimensionamiento rápido
Supongamos motor 12 V, corriente nominal 5 A, pico 15 A.
* Fuente: 12 V, 10–15 A (margen).
* MOSFET: Vds ≥ 30 V, Id ≥ 30 A, Rds(on) ≤ 10 mΩ.
* Fusible: 8 A (o PTC) en línea si quieres proteger nominal; o 15 A para pico con detección por software.
—
# 10) Recomendaciones prácticas / checklist antes de probar
* Verifica polaridad y conexión a tierra común (MCU GND = GND motor).
* Inserta fusible temporal y monitoriza corriente la primera vez.
* Empieza con duty bajo (p. ej. 20%) para probar.
* Añade protección contra sobrecorriente en software (lectura ACS712).
* Usa disipador en driver (L298 se calienta mucho).
—
# 11) Variantes rápidas según necesidad
* **Pequeños proyectos/hobby (< 3 A):** módulo MOSFET simple o DRV8833.
* **Medio (3–30 A):** módulos VNH5019, BTS7960 o puente H con MOSFET.
* **Alta potencia (>30 A):** drivers dedicados/módulos con detección de corriente y control térmico. —