Shield L293D para Arduino: AFMotor, 4 motores, paso a paso, servo

El shield L293D (L293D motor shield) es una placa controladora de motores que se encaja directamente sobre un Arduino Uno y te permite manejar 4 motores DC, 2 motores paso a paso y 2 servos desde una sola placa. Sus dos chips L293D entregan la corriente que necesitan los motores, invierten su sentido de giro y regulan su velocidad con PWM, así que puedes controlar todos los motores de un coche robot de cuatro ruedas sin un solo cable jumper. Casi todas las placas del mercado son copias del antiguo Motor Shield V1 de Adafruit y se programan con la misma librería: AFMotor.

En esta guía verás qué lleva el shield, qué pines del Arduino ocupa y cuáles quedan libres para sensores, cómo funciona el confuso jumper PWR en tres formas de alimentación distintas, los comandos de la librería AFMotor y el código completo de un coche robot de cuatro ruedas que manejas desde el móvil. En las últimas secciones explicamos el límite de corriente de 0,6 A, por qué se calienta el chip, en qué se diferencia del L298N y todas las causas conocidas de "los motores no giran" en una sola tabla.

¿Qué es el shield L293D y cómo funciona?

Para que un motor DC gire en los dos sentidos hace falta un circuito de cuatro interruptores llamado puente H; explicamos la idea con detalle en Control de motores DC con el L298N. El chip L293D contiene dos puentes H y, como el shield lleva dos de estos chips, tienes cuatro canales de motor en total. La "D" del nombre indica que los diodos de protección que absorben los picos de tensión inversa que genera un motor al apagarse están integrados en el chip. Además, el L293D desactiva sus salidas por sí solo cuando se sobrecalienta.

El verdadero truco del shield es el registro de desplazamiento 74HC595 del centro. Cada uno de los cuatro motores necesita dos señales de sentido y una de velocidad, lo que suma 12 pines del Arduino. El shield envía las ocho señales de sentido en serie al 74HC595 y solo gasta 4 pines en ellas (D4, D7, D8, D12), más 4 pines PWM para la velocidad (D3, D5, D6, D11). Este diseño ahorra pines, pero tiene un precio: no puedes mover los motores directamente con digitalWrite, necesitas una librería que cargue los bits de sentido en el registro. Esa librería es AFMotor.

¿Qué hay en la placa? Borneras, conectores y jumper

¿Qué pines usa el shield y cuáles quedan libres?

Los seis pines analógicos libres sobran para sensores, porque A0–A5 del Uno también funcionan como pines digitales 14–19 cuando hace falta. Un reparto práctico sería: un sensor de distancia HC-SR04 o un módulo Bluetooth por SoftwareSerial en A0 y A1, sensores de línea u obstáculos en A2 y A3, y el bus I2C (OLED, LCD, MPU6050) en A4 y A5. Para un encoder de rueda o un pulsador con attachInterrupt(), el único pin libre es D2; el otro pin de interrupción del Uno, D3, es el pin de velocidad de M2. Si no usas servos, D9 y D10 también quedan libres. Puedes ver el patillaje de tu placa en la herramienta Pinout y qué hace cada pin en Pines del Arduino Uno.

Alimentación y jumper PWR: tres formas correctas de conectarlo

La bornera de dos tornillos EXT_PWR del borde inferior de la placa es la entrada de alimentación de los motores; el positivo suele estar marcado como "+M" o "+" y el negativo como "GND". El jumper PWR que está justo al lado une esta línea de motores con el pin Vin del Arduino. Con el jumper puesto, las dos placas se alimentan de una sola fuente: la tensión que metes por EXT_PWR también alimenta el Arduino a través de Vin, o un adaptador enchufado en el conector DC del Arduino alimenta también los motores. Sin el jumper, las dos líneas quedan totalmente separadas. El LED PWR de la placa solo se enciende cuando llega alimentación a los motores; es lo primero que debes revisar antes de pelearte con los motores.

En los coches robot lo más habitual es una sola fuente: conectas un pack de dos pilas 18650 a EXT_PWR, pones el jumper y tanto el Arduino como los motores funcionan con la misma batería. Es sencillo, pero cuando los motores arrancan y tiran de mucha corriente, la tensión de la batería puede caer un instante y el Arduino reiniciarse. Si te pasa, la solución definitiva es quitar el jumper y alimentar el Arduino con otra fuente (una power bank, el USB o un adaptador de 9 V). Para hacer pruebas en la mesa, la segunda configuración es la más práctica: el Arduino sigue conectado al ordenador, los motores van con pilas y el jumper está quitado.

¿Qué batería elegir? Según la corriente, los transistores de salida del L293D se comen unos 1,5–2,6 V, así que el motor recibe esa tensión menos que la batería. Para los motores TT amarillos de 3–6 V de los kits de robótica, dos pilas de litio 18650 (7,4 V nominales, 8,4 V con carga completa) son ideales: los motores reciben unos 5,5–6 V y, con el jumper puesto, el regulador del Arduino también trabaja holgado. Cuatro pilas AA (6 V) dejan solo unos 4 V a los motores y no bastan para alimentar el Arduino por Vin. Una pila de 9 V no da más de unos cientos de miliamperios: los motores no giran o la pila se agota en minutos. Puedes calcular la autonomía con la calculadora de duración de batería y leer todas las opciones de alimentación en Alimentar Arduino con pilas.

Instalar la librería AFMotor

1. Abre el Gestor de librerías en el Arduino IDE (Herramientas > Gestionar bibliotecas o Ctrl+Mayús+I).
2. Escribe Adafruit Motor Shield en el buscador. Aparecen dos resultados: Adafruit Motor Shield library, con "V1 firmware" en la descripción, y Adafruit Motor Shield V2 Library.
3. Para el shield L293D instala la V1. La librería V2 es para una placa totalmente distinta que se comunica por I2C y usa chips TB6612.
4. Añade la línea #include <AFMotor.h> al principio de tu sketch.
5. Si quieres, abre Archivo > Ejemplos > Adafruit Motor Shield library > MotorTest y prueba la placa con un motor en M1.

Primer programa: mover un motor DC hacia delante, hacia atrás y a distintas velocidades

Atornilla los dos cables del motor a los dos tornillos exteriores de la bornera M1 y deja libre el tornillo GND del centro. Conecta el pack de pilas a EXT_PWR, enchufa el Arduino al ordenador por USB y quita el jumper PWR (la segunda configuración de arriba). Si el LED PWR está encendido, sube el código de abajo: el motor primero acelera y frena suavemente, luego gira hacia atrás dos segundos y se detiene.

1#include <AFMotor.h>                  // Adafruit Motor Shield V1 kütüphanesi / library
2
3AF_DCMotor motor(1);                  // M1 klemensi / M1 terminal
4
5void setup() {
6  Serial.begin(9600);
7  Serial.println(F("L293D motor testi / motor test"));
8  motor.setSpeed(200);                // 0–255; bunu unutursan motor dönmez / skip this and the motor won't turn
9  motor.run(RELEASE);                 // başlangıçta dur / start stopped
10}
11
12void loop() {
13  motor.run(FORWARD);                 // ileri / forward
14  for (int s = 60; s <= 255; s++) {   // yavaşça hızlan / ramp up
15    motor.setSpeed(s);
16    delay(10);
17  }
18  for (int s = 255; s >= 60; s--) {   // yavaşça yavaşla / ramp down
19    motor.setSpeed(s);
20    delay(10);
21  }
22  motor.run(RELEASE);                 // dur / stop
23  delay(500);
24
25  motor.setSpeed(180);
26  motor.run(BACKWARD);                // geri / backward
27  delay(2000);
28  motor.run(RELEASE);
29  delay(1000);
30}

La velocidad se regula encendiendo y apagando la alimentación del motor miles de veces por segundo; los detalles están en ¿Qué es PWM?. Como M1 y M2 usan el Timer2, puedes elegir su frecuencia: MOTOR12_64KHZ, MOTOR12_8KHZ (por defecto), MOTOR12_2KHZ y MOTOR12_1KHZ. A 64 kHz deja de oírse el pitido del motor, pero el L293D se calienta más. M3 y M4, en cambio, dependen del Timer0; como ese temporizador también mueve millis() y delay(), la librería no toca su frecuencia y estos dos canales siempre trabajan a 1 kHz aproximadamente.

Código del coche robot de cuatro ruedas (4WD)

El uso favorito del shield L293D es un coche robot de cuatro ruedas, porque cada uno de los cuatro motores tiene su propia bornera y no hay lío de cables. Estos coches no tienen dirección; giran como un tanque: si las dos ruedas izquierdas giran en un sentido y las dos derechas en el otro, el coche gira sobre sí mismo. Por eso el código no controla los motores uno a uno, sino en dos grupos: lado izquierdo y lado derecho. Para manejarlo desde el móvil conectamos un módulo Bluetooth HC-05 a los pines libres A0 y A1 con SoftwareSerial; el módulo se explica a fondo en Módulo Bluetooth HC-05.

1#include <AFMotor.h>
2#include <SoftwareSerial.h>
3
4AF_DCMotor frontLeft(1);              // M1: sol ön / front left
5AF_DCMotor rearLeft(2);               // M2: sol arka / rear left
6AF_DCMotor rearRight(3);              // M3: sağ arka / rear right
7AF_DCMotor frontRight(4);             // M4: sağ ön / front right
8
9SoftwareSerial bt(A0, A1);            // RX = A0 (HC-05 TXD), TX = A1 (HC-05 RXD, bölücüyle / via a divider)
10
11int speed = 200;                      // 0–255 arası sürüş hızı / driving speed 0–255
12
13void setSide(AF_DCMotor &a, AF_DCMotor &b, int value) {   // -255 … 255
14  uint8_t dir = value > 0 ? FORWARD : (value < 0 ? BACKWARD : RELEASE);
15  uint8_t pwm = constrain(abs(value), 0, 255);
16  a.setSpeed(pwm);
17  b.setSpeed(pwm);
18  a.run(dir);
19  b.run(dir);
20}
21
22void drive(int left, int right) {     // sol ve sağ taraf / left and right side
23  setSide(frontLeft, rearLeft, left);
24  setSide(frontRight, rearRight, right);
25}
26
27void setup() {
28  Serial.begin(9600);                 // hata ayıklama / debugging
29  bt.begin(9600);                     // HC-05 varsayılan hızı / default baud rate
30  drive(0, 0);
31}
32
33void loop() {
34  if (!bt.available()) return;
35  char c = bt.read();
36  Serial.println(c);
37
38  switch (c) {
39    case 'F': drive(speed, speed);        break;   // ileri / forward
40    case 'B': drive(-speed, -speed);      break;   // geri / backward
41    case 'L': drive(-speed, speed);       break;   // yerinde sola / spin left
42    case 'R': drive(speed, -speed);       break;   // yerinde sağa / spin right
43    case 'G': drive(speed / 3, speed);    break;   // ileri-sola kavis / curve forward-left
44    case 'I': drive(speed, speed / 3);    break;   // ileri-sağa kavis / curve forward-right
45    case 'S': drive(0, 0);                break;   // dur / stop
46    case 'q': speed = 255;                break;   // tam hız / full speed
47    default:
48      if (c >= '0' && c <= '9') speed = map(c - '0', 0, 9, 90, 240);   // hız kademesi / speed step
49  }
50}

El corazón del código es la función drive(izquierda, derecha): recibe un valor de -255 a 255 para cada lado; positivo es hacia delante, negativo hacia atrás y cero parado. setSide() da la misma velocidad y sentido a los dos motores de un lado. Los comandos son las letras sueltas que envían las apps tipo "Arduino Bluetooth RC Car" de las tiendas de aplicaciones: F adelante, B atrás, L y R giro sobre sí mismo, G e I curva, S parar. El deslizador de velocidad de la app envía un dígito del 0 al 9; el código lo convierte en un valor PWM entre 90 y 240 y, como el mínimo es 90, los motores arrancan incluso en el nivel más bajo. Si una rueda gira al revés, no cambies el código: intercambia los dos cables de ese motor en su bornera. Para el montaje del chasis y una versión de dos motores, mira Cómo hacer un coche robot con Arduino.

Controlar motores paso a paso: 28BYJ-48 y NEMA 17

El shield puede mover dos motores paso a paso a la vez: el puerto 1 usa las borneras M1 y M2 y el puerto 2 usa M3 y M4. En un motor bipolar (4 cables, como un NEMA 17) conectas una bobina a M1 y la otra a M2. En un motor unipolar (5 o 6 cables) las dos bobinas también van a M1 y M2, y el cable común va al tornillo GND del centro de la bornera. Para el popular 28BYJ-48 la conexión es: cables azul y amarillo a M1, rosa y naranja a M2, y el cable común rojo a GND. Cómo usar este motor con la placa ULN2003 lo explicamos en ¿Qué es un motor paso a paso?.

El 28BYJ-48 es un motor de 5 V; para esta prueba alimenta los motores con 4 pilas AA (6 V), quita el jumper y alimenta el Arduino por USB. Por la reductora interna, una vuelta son 2048 pasos completos:

1#include <AFMotor.h>
2
3// 28BYJ-48: tam adımda tur başına 2048 adım / 2048 full steps per revolution
4AF_Stepper stepper(2048, 1);          // 1 = M1 + M2, 2 = M3 + M4
5
6void setup() {
7  stepper.setSpeed(10);               // dakikada 10 tur / 10 RPM
8}
9
10void loop() {
11  stepper.step(2048, FORWARD, DOUBLE);       // bir tur ileri, güçlü tork / one turn forward, more torque
12  delay(500);
13  stepper.step(4096, BACKWARD, INTERLEAVE);  // yarım adımla bir tur geri / one turn back in half steps
14  stepper.release();                         // bobinleri kapat, ısınmasın / de-energise the coils
15  delay(1000);
16}

setSpeed() fija las revoluciones por minuto; por su reductora, el 28BYJ-48 no pasa de unas 10–15 rpm. Lo que debes tener en cuenta es que step() es bloqueante: hasta que el motor termina los pasos pedidos, loop() no hace nada más. Si quieres leer sensores o mover motores DC mientras gira el paso a paso, usa la función onestep() de la librería junto con la librería AccelStepper; el ejemplo AFMotor_ConstantSpeed que trae la librería muestra justo eso. Llamar a release() mientras el motor espera apaga las bobinas y evita que se caliente, pero el eje pierde su par de retención mientras tanto.

Conectar servos: los conectores SER1 y SERVO_2

Los dos conectores de tres pines de la esquina del shield son para servos. Según las marcas de la placa, los pines son − (GND), + (5 V) y S (señal): el cable marrón del servo va a −, el rojo a + y el naranja a S. Según el esquema de la placa, SER1 está conectado a D10 y SERVO_2 a D9 (algunas fuentes indican los números al revés; si el servo no se mueve, prueba el otro pin en el código). Los servos se controlan con la librería estándar Servo, y el Timer1 que usa en el Uno no choca con los temporizadores de los motores, así que los motores DC y los servos funcionan a la vez sin problemas.

Los servos no se alimentan de la batería de los motores, sino de la línea de 5 V del Arduino. Para un SG90 no hay problema, pero servos grandes como el MG996R pueden consumir más de 1 A al moverse; el regulador del Arduino se calienta, la tensión cae y la placa se reinicia. Con servos grandes, conecta solo el cable de señal al conector, alimenta el + y el − del servo con una fuente aparte de 5–6 V y une las masas. Tienes los detalles en Servo MG996R con Arduino y ¿Qué es un servomotor?. El código de abajo hace que el servo de SER1 barra a izquierda y derecha mientras gira el motor de M3:

1#include <AFMotor.h>
2#include <Servo.h>
3
4AF_DCMotor motor(3);                  // M3 klemensi / M3 terminal
5Servo servo1;                         // SER1 başlığı / SER1 header
6
7void setup() {
8  servo1.attach(10);                  // SER1 = D10, SERVO_2 = D9
9  motor.setSpeed(170);
10  motor.run(FORWARD);                 // motor dönerken servo tarar / servo sweeps while the motor runs
11}
12
13void loop() {
14  for (int a = 20; a <= 160; a += 2) {   // sağa tara / sweep right
15    servo1.write(a);
16    delay(15);
17  }
18  for (int a = 160; a >= 20; a -= 2) {   // sola tara / sweep left
19    servo1.write(a);
20    delay(15);
21  }
22}

Límite de corriente (0,6 A) y calentamiento

La línea más importante de la hoja de datos del L293D es 0,6 A continuos y 1,2 A de pico por canal. El valor de pico solo vale para impulsos muy cortos; si un motor consume 1 A durante segundos, el chip sufre. Un cálculo sencillo muestra por qué se calienta: el L293D es un controlador antiguo con transistores bipolares y, a 0,6 A, cae típicamente 1,4 V en el transistor superior y 1,2 V en el inferior. Es decir, cuando un motor consume 0,6 A se generan 0,6 A × 2,6 V ≈ 1,6 W de calor en el chip; dos motores en el mismo chip producen el doble, unos 3 W. Un pequeño chip DIP sin disipador no puede evacuar ese calor, su temperatura sube rápido y al final la protección térmica apaga las salidas. El síntoma es conocido: los motores funcionan un rato, se paran y vuelven a arrancar cuando el chip se enfría.

Los motores TT amarillos consumen unos 150 mA en vacío y 200–300 mA rodando por el suelo, dentro de los límites del shield. El problema llega cuando una rueda empuja contra un obstáculo o el coche gira sobre sí mismo: un motor TT bloqueado puede consumir 1–1,5 A, y en un coche 4WD los cuatro motores se esfuerzan a la vez durante el giro. Para conocer la corriente real de tu motor, conecta un multímetro en serie con él y mide mientras sujetas la rueda con la mano un momento; cómo hacerlo está en Cómo usar un multímetro. Para mantener fresco el shield:

• Arranca suave: No saltes de 0 a 255 de golpe; sube la velocidad poco a poco en 200–300 ms y la corriente de arranque baja claramente.
• No bloquees el motor: En los robots que esquivan obstáculos, para el coche antes de que choque; un motor bloqueado es el que más calor genera.
• Pega disipadores en los chips: Unos pequeños disipadores de aluminio con cinta térmica bajan algo la temperatura del L293D.
• Suelda un segundo L293D encima: Adafruit también comenta que, para aumentar la capacidad de corriente, se puede soldar un segundo L293D encima de los chips existentes, pata con pata; los dos chips se reparten la corriente.
• No uses más tensión de la necesaria: Dar 12 V a motores de 6 V aumenta la corriente y el calor.
• Cambia al controlador adecuado: Si tu motor consume de forma continua más de 0,6 A, usa un controlador basado en L298N o TB6612FNG.

¿Shield L293D o L298N?

En resumen, si montas un coche 4WD con motores TT sobre un Arduino Uno, el shield L293D reduce el cableado al mínimo y reúne los cuatro motores en una sola placa. Si tus motores son más potentes, tu placa es un ESP32 o una Pico, o te importa elegir los pines, el L298N es más flexible; los detalles están en Control de motores DC con el L298N. Si quieres algo más eficiente que ambos, el TB6612FNG, basado en MOSFET, tiene una caída de tensión muy baja y alarga la duración de las pilas. Comparamos qué tipo de motor conviene para cada tarea en Motor DC, servo y paso a paso: diferencias.

¿Funciona con ESP32, Raspberry Pi Pico o Mega?

Con el Arduino Mega 2560 funciona sin problemas: el shield encaja en los primeros pines digitales y analógicos del Mega y AFMotor conoce los temporizadores del Mega. Con Uno R4, Leonardo, ESP32 y Raspberry Pi Pico, en cambio, no funciona, porque AFMotor escribe directamente en los registros de temporizador del ATmega328P y del ATmega2560. Con un ESP32 seleccionado, la compilación se detiene con 'DC_MOTOR_PWM_RATE' was not declared in this scope, y con un Leonardo con #error "This chip is not supported!". Las placas ESP32 con formato Uno (como la ESPDuino-32) encajan físicamente en el shield, pero los números de pin y el nivel de señal de 3,3 V son distintos. Con estas placas es mucho más fácil usar un L298N, un TB6612FNG o un solo chip L293D en lugar del shield. Las entradas del L293D consideran HIGH todo lo que supere 2,3 V, así que funcionan directamente con placas de 3,3 V:

1from machine import Pin, PWM
2import time
3
4en = PWM(Pin(15))                 # L293D pin 1 (1,2EN): hız / speed
5en.freq(1000)
6in1 = Pin(14, Pin.OUT)            # L293D pin 2 (1A): yön / direction
7in2 = Pin(13, Pin.OUT)            # L293D pin 7 (2A): yön / direction
8
9def motor(speed):                 # -100 … 100
10    in1.value(1 if speed > 0 else 0)
11    in2.value(1 if speed < 0 else 0)
12    en.duty_u16(int(abs(speed) * 655.35))
13
14while True:
15    motor(80)                     # ileri / forward
16    time.sleep(2)
17    motor(0)                      # dur / stop
18    time.sleep(0.5)
19    motor(-60)                    # geri / backward
20    time.sleep(2)
21    motor(0)
22    time.sleep(0.5)

Las masas de la Pico y de la batería deben estar unidas. En el ESP32 montas la misma lógica en lenguaje Arduino: sentido con digitalWrite y velocidad con analogWrite en los pines de la tabla. Si estas placas son nuevas para ti, empieza por ¿Qué es el ESP32? y ¿Qué es la Raspberry Pi Pico?.

Los motores no giran: errores comunes y soluciones

Ideas de proyectos con el shield L293D

• Coche 4WD controlado por Bluetooth: Un robot con tracción a las cuatro ruedas que manejas desde el móvil con el código de arriba.
• Robot que esquiva obstáculos: Un coche que explora el frente con un HC-SR04 montado en el servo de SER1 y gira hacia la dirección más despejada; la guía completa está en Robot evasor de obstáculos con Arduino.
• Robot sigue líneas: Sigue una línea negra en el suelo con sensores infrarrojos en A0–A3; el ajuste PID está en Robot seguidor de línea con Arduino.
• Slider para cámara: Desliza una cámara despacio por un raíl con un motor paso a paso y graba timelapses.
• Cabezal pan-tilt: Conecta dos servos a los dos conectores de servo y orienta una cámara o un láser en dos ejes; para más servos, mira Brazo robótico con Arduino.
• Cortina automática o cinta transportadora: Abre y cierra una cortina con un motor DC según la luz o construye una pequeña cinta transportadora.

En resumen, para usar bien el shield L293D: instala la librería V1, revisa el LED PWR, coloca el jumper según tu forma de alimentación, no olvides setSpeed(), conecta los sensores a A0–A5 y mantén tus motores por debajo del límite de 0,6 A. Con estas reglas, un pequeño shield carga él solo con toda la fuerza de un robot de cuatro motores. En la app BlueGrays encontrarás el coche controlado por Bluetooth, el robot que esquiva obstáculos y proyectos con motores paso a paso y servos, paso a paso, con esquemas y código.