Placa controladora: Arduino Mega 2560
Módulo: Motor Shield L293D V1.0
Nivel: Iniciación a robótica y programación Arduino
Objetivo: Controlar motores de corriente continua, variar su velocidad, invertir su giro y realizar un pequeño proyecto de vehículo robot.
1. ¿Qué placa tenemos?
La placa de tu fotografía es una Motor Shield L293D V1.0, compatible con el diseño Adafruit Motor Shield V1.
Se conecta directamente sobre el Arduino Mega 2560 y permite controlar motores sin tener que construir manualmente el circuito electrónico de potencia.
La compatibilidad con Arduino Mega 2560 está documentada para este diseño de shield.
Características principales
| Elemento | Capacidad |
|---|---|
| Motores DC | Hasta 4 independientes |
| Motores paso a paso | Hasta 2 |
| Servomotores | 2 conectores |
| Control de velocidad | PWM, valores de 0 a 255 |
| Inversión de giro | Sí |
| Controladores principales | 2 × L293D |
| Corriente por canal | 600 mA continuos, 1,2 A de pico |
| Biblioteca | AFMotor |
Importante: aunque el circuito L293D admite diferentes tensiones, la alimentación de los motores debe elegirse según los motores utilizados. Además, los L293D producen una caída de tensión apreciable y no son adecuados para motores de gran consumo.
2. Identificar los componentes de la placa
En la placa de tu fotografía encontramos:
| Componente | Función |
|---|---|
| M1, M2, M3 y M4 | Bornes de conexión para motores DC |
| EXT_PWR | Entrada de alimentación externa de motores |
| SERVO1, SERVO2 | Conexiones para servomotores |
| Dos circuitos L293D | Control de potencia, velocidad y sentido de giro |
| Circuito 74HC595 | Gestión de señales de dirección |
| PWR jumper | Selección de alimentación compartida o independiente |
| RESET | Reinicio del Arduino |
| LED | Indicador de alimentación de motores |
El shield utiliza determinados pines digitales del Arduino Mega para gestionar internamente los motores. Por ello, no debemos asignar libremente esos mismos pines a otros dispositivos.
3. Material necesario
Para la primera prueba necesitaremos:
- Un Arduino Mega 2560.
- La placa Motor Shield L293D V1.0.
- Un motor DC pequeño, preferiblemente de 6 V.
- Una fuente de alimentación adecuada al motor.
- Un cable USB para programar el Arduino.
- Un ordenador con Arduino IDE.
- Un destornillador pequeño para los bornes.
Para posteriores prácticas podremos incorporar otros tres motores, ruedas, un chasis, servomotores y sensores.
4. Montaje sobre el Arduino Mega 2560
- Desconectamos el Arduino del ordenador y de cualquier alimentación.
- Colocamos el Motor Shield encima del Mega, haciendo coincidir las filas de pines del shield con los conectores correspondientes del Arduino.
- Comprobamos la orientación y que no haya ningún pin desplazado.
- Presionamos suavemente hasta que los conectores estén completamente introducidos.
- Verificamos que ningún terminal metálico esté produciendo un cortocircuito.
No debemos intentar conectar el shield a todos los conectores del Mega: este modelo utiliza principalmente la distribución de pines del Arduino UNO, que también está presente en el Mega.
5. Alimentación de los motores
Esta es una de las partes más importantes del montaje.
El Arduino Mega necesita energía para ejecutar el programa, mientras que los motores necesitan energía para moverse.
La mejor opción para las prácticas es utilizar alimentaciones independientes.
Esquema conceptual de alimentación independiente.
Alimentación recomendada para las pruebas
- Arduino Mega conectado al ordenador mediante USB.
- Fuente externa para los motores conectada a
EXT_PWR. - Jumper de alimentación
PWRretirado. - Cable positivo de la fuente conectado a
+y negativo conectado a−del bloque de alimentación.
Precaución: verifica la polaridad impresa en tu placa antes de conectar la fuente. No utilices la salida de 5 V del Arduino para alimentar directamente los motores. Tampoco utilices una pila rectangular de 9 V como solución habitual para varios motores, porque suele entregar poca corriente.
Si se conectan motores pequeños de 6 V, una fuente regulada de 6 V con corriente suficiente puede ser apropiada, teniendo en cuenta que la tensión efectiva en el motor será algo menor debido al L293D.
La alimentación de los servomotores se trata por separado porque los conectores SERVO toman normalmente sus 5 V del Arduino.
6. Instalación de Arduino IDE
Descargamos Arduino IDE desde la web oficial:Descargar Arduino IDE
Conectamos el Arduino Mega al ordenador y abrimos el programa.
En el menú de placas seleccionamos:
Herramientas → Placa → Arduino AVR Boards → Arduino Mega or Mega 2560
Y seleccionamos el procesador:
ATmega2560
Finalmente seleccionamos el puerto USB correspondiente.
Para comprobar la comunicación podemos cargar el ejemplo:
Archivo → Ejemplos → 01.Basics → Blink
Si el LED integrado parpadea, el Arduino está correctamente configurado.
7. Instalar la biblioteca AFMotor
Esta placa utiliza la biblioteca AFMotor, correspondiente a los Motor Shield V1.
No debemos confundirla con Adafruit Motor Shield V2 Library, que está diseñada para otro controlador.
Descargamos la biblioteca:Biblioteca AFMotor — GitHub
En GitHub pulsamos Code → Download ZIP.
Después, en Arduino IDE:
Programa → Incluir librería → Añadir biblioteca .ZIP
Seleccionamos el archivo descargado.
Una vez instalada, comprobamos que podemos incluirla en un programa:
#include <AFMotor.h>El Arduino Mega 2560 está contemplado expresamente en el código de esta biblioteca.
blog.adafruit.com
+1
Parte práctica: nuestros primeros programas
8. Práctica 1. Hacer girar un motor
Objetivo: conseguir que un motor conectado a M1 funcione durante tres segundos y después se detenga.
Conexiones
- Con el circuito desconectado, conectamos los dos cables del motor al borne
M1. - Retiramos el jumper
PWR. - Conectamos una fuente adecuada a
EXT_PWR. - Conectamos el Arduino Mega mediante USB.
- Cargamos el programa.
Código completo
#include <AFMotor.h>
// Motor conectado al borne M1
AF_DCMotor motor1(1);
void setup() {
// Velocidad entre 0 y 255
motor1.setSpeed(150);
}
void loop() {
// Girar hacia delante
motor1.run(FORWARD);
delay(3000);
// Detener el motor
motor1.run(RELEASE);
delay(2000);
}
¿Qué hace el programa?
AF_DCMotor motor1(1); crea un objeto que representa el motor conectado a M1.
setSpeed(150) establece un valor de velocidad PWM. No significa exactamente 150 revoluciones por minuto, sino un nivel de control dentro de la escala 0–255.
run(FORWARD) ordena girar al motor en uno de los sentidos.
run(RELEASE) deja de alimentar el motor y permite que se detenga libremente. No aplica un frenado activo.
delay(3000) mantiene el programa esperando tres segundos.
Resultado esperado: el motor gira durante tres segundos, se detiene dos segundos y repite el proceso.
9. Práctica 2. Invertir el sentido de giro
Vamos a conseguir que el mismo motor gire alternativamente en ambos sentidos.
#include <AFMotor.h>
AF_DCMotor motor1(1);
void setup() {
motor1.setSpeed(180);
}
void loop() {
motor1.run(FORWARD);
delay(2000);
motor1.run(RELEASE);
delay(1000);
motor1.run(BACKWARD);
delay(2000);
motor1.run(RELEASE);
delay(1000);
}
El motor gira dos segundos hacia delante, descansa uno, gira dos segundos en sentido contrario y vuelve a descansar.
Ejercicio: modifica los tiempos para que cada giro dure cinco segundos y las pausas solo medio segundo.
10. Práctica 3. Regular la velocidad
En esta ocasión aumentaremos la velocidad progresivamente.
#include <AFMotor.h>
AF_DCMotor motor1(1);
void setup() {
motor1.setSpeed(0);
motor1.run(FORWARD);
}
void loop() {
// Aceleracion progresiva
for (int velocidad = 0; velocidad <= 255; velocidad += 5) {
motor1.setSpeed(velocidad);
delay(100);
}
delay(1000);
// Desaceleracion progresiva
for (int velocidad = 255; velocidad >= 0; velocidad -= 5) {
motor1.setSpeed(velocidad);
delay(100);
}
motor1.run(RELEASE);
delay(1000);
}
El motor acelera hasta alcanzar el máximo valor PWM, comienza a reducir su velocidad y finalmente se detiene.
A velocidades muy bajas es posible que el motor no se mueva, aunque reciba una señal PWM. Esto depende de la fricción y de las características del motor.
11. Práctica 4. Controlar cuatro motores simultáneamente
Conectamos cuatro motores, cada uno a su correspondiente borne M1, M2, M3 y M4.
#include <AFMotor.h>
AF_DCMotor motor1(1);
AF_DCMotor motor2(2);
AF_DCMotor motor3(3);
AF_DCMotor motor4(4);
void setup() {
motor1.setSpeed(180);
motor2.setSpeed(180);
motor3.setSpeed(180);
motor4.setSpeed(180);
}
void loop() {
// Arrancar los cuatro motores
motor1.run(FORWARD);
motor2.run(FORWARD);
motor3.run(FORWARD);
motor4.run(FORWARD);
delay(3000);
// Detener los cuatro motores
motor1.run(RELEASE);
motor2.run(RELEASE);
motor3.run(RELEASE);
motor4.run(RELEASE);
delay(2000);
}
Resultado esperado: los cuatro motores giran simultáneamente durante tres segundos y se detienen durante dos.
La etiqueta FORWARD no garantiza que todas las ruedas giren hacia delante físicamente, porque depende de cómo estén colocados los motores y de la polaridad de sus cables.
Antes de utilizar los cuatro motores, debemos comprobar que el consumo individual y total es compatible con el shield y con la fuente de alimentación.
12. Práctica 5. Controlar un servomotor
La placa dispone de dos conexiones para servomotores. Podemos utilizarlas, por ejemplo, para girar un sensor de ultrasonidos instalado en un coche robot.
Conectaremos un servomotor SG90 a SERVO1, respetando el orden de señal, positivo y negativo indicado en la placa.
El conector SERVO1 corresponde al pin digital 9 y SERVO2 al pin 10.
Adafruit Learning System
+1
#include <Servo.h>
Servo servo1;
void setup() {
servo1.attach(9);
}
void loop() {
servo1.write(0);
delay(1000);
servo1.write(90);
delay(1000);
servo1.write(180);
delay(1000);
}Resultado esperado: el servomotor se mueve a tres posiciones, esperando un segundo entre ellas.
Los servomotores reciben alimentación de 5 V desde el Arduino en la configuración habitual del shield. Si se utilizan varios servos o modelos de elevado consumo, habrá que estudiar una alimentación independiente apropiada para evitar reinicios y sobrecargas.
13. Pines utilizados por el Motor Shield
Esta información resulta especialmente importante cuando queramos incorporar sensores al Arduino Mega.
| Pines digitales | Utilización |
|---|---|
| 11 | Velocidad M1 |
| 3 | Velocidad M2 |
| 5 | Velocidad M3 |
| 6 | Velocidad M4 |
| 4, 7, 8, 12 | Control interno de dirección |
| 9 | SERVO1 |
| 10 | SERVO2 |
| 2 y 13 | Disponibles |
Los pines indicados corresponden al diseño V1. Los demás pines libres del Mega pueden aprovecharse para sensores, siempre comprobando que no exista conflicto con otros módulos.
Adafruit Learning System
14. Proyecto final: coche robot de cuatro motores
Una vez comprobado el funcionamiento de la placa, podremos construir un vehículo utilizando cuatro motores DC.
La distribución de motores será:
| Motor | Posición del vehículo |
|---|---|
| M1 | Delantero izquierdo |
| M2 | Trasero izquierdo |
| M3 | Delantero derecho |
| M4 | Trasero derecho |
La siguiente programación permite avanzar, retroceder, girar a izquierda y derecha y detener el vehículo.
#include <AFMotor.h>
AF_DCMotor motor1(1);
AF_DCMotor motor2(2);
AF_DCMotor motor3(3);
AF_DCMotor motor4(4);
void detener() {
motor1.run(RELEASE);
motor2.run(RELEASE);
motor3.run(RELEASE);
motor4.run(RELEASE);
}
void avanzar() {
motor1.run(FORWARD);
motor2.run(FORWARD);
motor3.run(FORWARD);
motor4.run(FORWARD);
}
void retroceder() {
motor1.run(BACKWARD);
motor2.run(BACKWARD);
motor3.run(BACKWARD);
motor4.run(BACKWARD);
}
void izquierda() {
motor1.run(BACKWARD);
motor2.run(BACKWARD);
motor3.run(FORWARD);
motor4.run(FORWARD);
}
void derecha() {
motor1.run(FORWARD);
motor2.run(FORWARD);
motor3.run(BACKWARD);
motor4.run(BACKWARD);
}
void setup() {
motor1.setSpeed(180);
motor2.setSpeed(180);
motor3.setSpeed(180);
motor4.setSpeed(180);
}
void loop() {
avanzar();
delay(2000);
detener();
delay(500);
retroceder();
delay(2000);
detener();
delay(500);
izquierda();
delay(1000);
detener();
delay(500);
derecha();
delay(1000);
detener();
delay(2000);
}
Importante: este ejemplo supone que los motores están conectados de forma que FORWARD mueve todas las ruedas hacia delante. Habrá que invertir los cables o ajustar el programa de aquellos motores que giren en sentido contrario. Es preferible hacer la primera prueba con el vehículo levantado, sin que las ruedas toquen el suelo.
Además, comprueba la corriente de bloqueo de cada motor. Los motores TT de algunos kits pueden superar los límites del L293D al arrancar o quedarse atascados.
15. Solución de problemas
| Problema | Posible solución |
|---|---|
El código no compila porque falta AFMotor.h | Instalar la biblioteca AFMotor V1 |
| El motor no gira | Comprobar fuente externa, LED indicador y conexiones |
| El motor gira al revés | Intercambiar sus dos cables o invertir el comando |
| El Arduino se reinicia al arrancar el motor | Revisar alimentación y consumo |
| El motor no gira con PWM bajo | Aumentar el valor de setSpeed() |
| El L293D se calienta demasiado | Detener el ensayo y comprobar consumo y posibles bloqueos |
| Los cuatro motores no funcionan simultáneamente | Comprobar fuente, conexiones y corriente de cada motor |
16. Actividades de evaluación
Para comprobar que se ha comprendido el funcionamiento, los alumnos deberán resolver estas actividades:
- Hacer que M1 gire cinco segundos hacia delante y otros cinco hacia atrás.
- Conseguir que M1 y M2 giren a distintas velocidades.
- Programar una aceleración progresiva de 0 a 255.
- Poner en marcha los cuatro motores y detenerlos en orden inverso.
- Crear las funciones
avanzar(),retroceder(),izquierda(),derecha()ydetener(). - Diseñar un recorrido para que un coche describa aproximadamente un cuadrado, ajustando experimentalmente los tiempos de giro.
- Incorporar un servomotor que mire alternativamente a izquierda, centro y derecha.
17. Recursos oficiales
Siguiente paso recomendado: comenzar probando un único motor DC en M1 y, una vez verificada la alimentación y el funcionamiento, conectar los cuatro motores.
Para el proyecto del coche con Arduino Mega, cuatro motores y sensor de ultrasonidos sobre un servomotor, esta placa es una buena opción didáctica siempre que los motores no superen su capacidad eléctrica.
