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

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

robocraze.com

En la placa de tu fotografía encontramos:

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

1. Desconectamos el Arduino del ordenador y de cualquier alimentación.
2. Colocamos el Motor Shield encima del Mega, haciendo coincidir las filas de pines del shield con los conectores correspondientes del Arduino.
3. Comprobamos la orientación y que no haya ningún pin desplazado.
4. Presionamos suavemente hasta que los conectores estén completamente introducidos.
5. 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 PWR retirado.
• 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

1. Con el circuito desconectado, conectamos los dos cables del motor al borne M1.
2. Retiramos el jumper PWR.
3. Conectamos una fuente adecuada a EXT_PWR.
4. Conectamos el Arduino Mega mediante USB.
5. 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.

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.

codemahal.com

La distribución de motores será:

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

16. Actividades de evaluación

Para comprobar que se ha comprendido el funcionamiento, los alumnos deberán resolver estas actividades:

1. Hacer que M1 gire cinco segundos hacia delante y otros cinco hacia atrás.
2. Conseguir que M1 y M2 giren a distintas velocidades.
3. Programar una aceleración progresiva de 0 a 255.
4. Poner en marcha los cuatro motores y detenerlos en orden inverso.
5. Crear las funciones avanzar(), retroceder(), izquierda(), derecha() y detener().
6. Diseñar un recorrido para que un coche describa aproximadamente un cuadrado, ajustando experimentalmente los tiempos de giro.
7. Incorporar un servomotor que mire alternativamente a izquierda, centro y derecha.

17. Recursos oficiales

• Manual técnico de Adafruit Motor Shield V1
• Biblioteca AFMotor V1
• Documentación Arduino Mega 2560

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.

Presentación del proyecto

En este proyecto aprenderás a utilizar los componentes que más adelante formarán parte de un coche robot de cuatro motores.

Antes de construir el coche completo, trabajaremos por etapas para comprender qué hace cada componente, cómo se conecta y cómo se controla desde un programa.

El proyecto se divide en dos partes:

En la primera parte no conectaremos motores DC ni el controlador L293D. El servomotor se utilizará para orientar el sensor.

El coche completo será una fase posterior. En estas dos partes nos centraremos en comprender y comprobar sus componentes.

Objetivos generales

Al finalizar el proyecto deberás ser capaz de:

• Identificar los cables y conexiones de cada componente.
• Distinguir entre un sensor y un actuador.
• Medir distancias con un HC-SR04.
• Colocar un servo en diferentes posiciones.
• Combinar el servo y el sensor para observar distintas direcciones.
• Controlar el sentido y la velocidad de motores DC mediante un L293D.
• Utilizar una lectura del sensor para tomar una decisión.
• Documentar los montajes y explicar los resultados.

Forma de trabajo

En cada práctica seguirás este proceso:

1. Comprender: lee qué hace el componente y para qué sirve.
2. Predecir: escribe qué esperas que ocurra.
3. Montar: realiza las conexiones con la alimentación desconectada.
4. Programar: introduce el código y súbelo al Arduino.
5. Comprobar: observa el resultado y registra las pruebas.
6. Modificar: cambia una parte del programa y explica su efecto.

No basta con conseguir que el montaje funcione. Debes poder explicar por qué funciona.

Parte 1. Medir y observar el entorno

Material necesario

• Arduino Uno R3 y cable USB.
• Sensor de ultrasonidos HC-SR04.
• Servomotor de posición SG90 o similar.
• Fuente regulada de 5 V adecuada para el servo.
• Cables y protoboard.
• Regla o cinta métrica.
• Una caja o superficie plana para realizar las mediciones.
• Un soporte ligero para colocar el sensor sobre el servo.

Preparación del entorno

Antes de comenzar:

1. Abre Arduino IDE.
2. Selecciona la placa Arduino Uno.
3. Selecciona el puerto al que está conectado el Arduino.
4. Crea un programa diferente para cada práctica.
5. Guarda los programas con estos nombres:

01_ultrasonidos
02_servo
03_escaner

Mapa de conexiones de esta parte

Práctica 1. Medir distancias con ultrasonidos

Qué vamos a aprender

El HC-SR04 permite medir la distancia hasta un objeto.

Para hacerlo:

1. El Arduino envía una orden por el pin TRIG.
2. El sensor emite una señal ultrasónica.
3. La señal rebota en el objeto.
4. El sensor comunica por ECHO el tiempo asociado al recorrido.

Como el sonido viaja hasta el objeto y vuelve, debemos dividir el recorrido entre dos.

Conexiones

Comprueba los nombres impresos en el sensor antes de conectar los cables.

Montaje paso a paso

1. Desconecta el cable USB del Arduino.
2. Conecta VCC a 5V.
3. Conecta GND a GND.
4. Conecta TRIG a D12.
5. Conecta ECHO a D13.
6. Coloca el sensor de forma que sus dos cápsulas apunten hacia la zona que quieres medir.
7. Revisa las conexiones antes de conectar el USB.

Programa

const byte TRIG = 12;
const byte ECHO = 13;

float medirCm() {
  // Preparar el disparo.
  digitalWrite(TRIG, LOW);
  delayMicroseconds(2);

  // Enviar el pulso de disparo.
  digitalWrite(TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG, LOW);

  // Esperar el eco, con un límite de tiempo.
  unsigned long tiempo = pulseIn(ECHO, HIGH, 30000UL);

  // Un resultado de cero significa que no llegó el eco.
  if (tiempo == 0) {
    return -1.0;
  }

  // Convertir el tiempo en distancia.
  return tiempo * 0.0343 / 2.0;
}

void setup() {
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);

  Serial.begin(9600);
}

void loop() {
  float distancia = medirCm();

  if (distancia < 0) {
    Serial.println("Sin eco");
  } else {
    Serial.print("Distancia: ");
    Serial.print(distancia, 1);
    Serial.println(" cm");
  }

  delay(100);
}

Cómo comprobarlo

1. Sube el programa.
2. Abre el Monitor serie a 9600 baudios.
3. Coloca una caja plana aproximadamente a 10 cm.
4. Mide la distancia real con una regla.
5. Repite a 20 y 40 cm.
6. Inclina la caja y observa si cambia la lectura.
7. Retira el objeto y observa qué sucede.

Tabla de resultados

Resultado esperado

La distancia mostrada cambia al mover el objeto.

Cuando no se recibe el eco dentro del tiempo de espera, aparece «Sin eco». Esto no significa que el objeto esté a cero centímetros.

Modificación obligatoria

Modifica el programa para que, además de la distancia, muestre:

• «Objeto cercano» cuando la distancia sea de 20 cm o menos.
• «Objeto alejado» cuando supere los 20 cm.
• «Sin eco» cuando no exista una lectura.

Preguntas

1. ¿Qué función tiene TRIG?
2. ¿Qué función tiene ECHO?
3. ¿Por qué dividimos entre dos?
4. ¿Por qué una superficie inclinada puede afectar a la lectura?
5. ¿Por qué no debemos interpretar «Sin eco» como cero centímetros?

Práctica 2. Controlar la posición de un servo

Qué vamos a aprender

Un servo de posición permite mover su eje hasta un ángulo determinado.

Lo utilizaremos para orientar el sensor de ultrasonidos hacia diferentes direcciones.

Este servo recibe una orden de posición. Su funcionamiento es distinto al de los motores DC que harán girar las ruedas.

Conexiones

Comprueba los colores y las características de tu modelo.

La masa de la fuente y la del Arduino deben estar unidas.

Montaje paso a paso

1. Desconecta todas las alimentaciones.
2. Conecta la señal del servo a D9.
3. Conecta los cables de alimentación del servo a su fuente.
4. Une el GND de la fuente con el GND del Arduino.
5. Coloca el servo sobre una superficie estable.
6. Revisa las conexiones.
7. Conecta el Arduino y sube el programa.

Programa

#include <Servo.h>

Servo giro;
const byte PIN_SERVO = 9;

void setup() {
  giro.attach(PIN_SERVO);

  // Comenzar en la posición central.
  giro.write(90);
  delay(1000);
}

void loop() {
  giro.write(30);
  delay(1000);

  giro.write(90);
  delay(1000);

  giro.write(150);
  delay(1000);
}

Cómo comprobarlo

1. Observa el movimiento entre las tres posiciones.
2. Comprueba que el brazo no choque con ningún objeto.
3. No fuerces el eje con la mano.
4. Cambia las posiciones a 45°, 90° y 135°.
5. Cambia los tiempos de espera y observa la diferencia.

Tabla de resultados

Resultado esperado

El servo se coloca sucesivamente en las posiciones indicadas.

Los ángulos del programa son órdenes de posición; la posición física exacta depende del servo y de cómo se haya colocado su brazo.

Modificación obligatoria

Crea una secuencia que:

1. Comience a 90°.
2. Se mueva a 45°.
3. Regrese a 90°.
4. Se mueva a 135°.
5. Regrese a 90°.

Espera un segundo entre posiciones.

Preguntas

1. ¿Para qué sirve el cable de señal?
2. ¿Qué hace attach()?
3. ¿Qué hace write()?
4. ¿Por qué unimos las masas?
5. ¿Qué diferencia existe entre un servo de posición y un motor DC de una rueda?

Práctica 3. Construir un escáner de distancias

Qué vamos a aprender

Combinaremos los dos montajes anteriores.

El servo orientará el HC-SR04 hacia distintas posiciones y el Arduino realizará una medición en cada una.

El resultado será un pequeño escáner del entorno.

Conexiones

Mantén las conexiones de las prácticas anteriores:

Montaje paso a paso

1. Lleva el servo a 90° con un programa de prueba.
2. Desconecta las alimentaciones.
3. Fija el sensor sobre el brazo del servo mediante un soporte ligero.
4. Deja holgura en los cables del sensor.
5. Comprueba que puede moverse entre 30° y 150° sin tirar de los cables.
6. Combina las conexiones.
7. Sube el programa.

Programa

#include <Servo.h>

Servo giro;

const byte PIN_SERVO = 9;
const byte TRIG = 12;
const byte ECHO = 13;

float medirCm() {
  digitalWrite(TRIG, LOW);
  delayMicroseconds(2);

  digitalWrite(TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG, LOW);

  unsigned long tiempo = pulseIn(ECHO, HIGH, 30000UL);

  if (tiempo == 0) {
    return -1.0;
  }

  return tiempo * 0.0343 / 2.0;
}

void setup() {
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);

  Serial.begin(9600);

  giro.attach(PIN_SERVO);
  giro.write(90);
  delay(600);
}

void loop() {
  const byte angulos[] = {30, 90, 150, 90};

  for (byte i = 0; i < 4; i++) {
    giro.write(angulos[i]);

    // Esperar a que termine el movimiento antes de medir.
    delay(500);

    float distancia = medirCm();

    Serial.print("Angulo: ");
    Serial.print(angulos[i]);
    Serial.print(" grados | ");

    if (distancia < 0) {
      Serial.println("Sin eco");
    } else {
      Serial.print(distancia, 1);
      Serial.println(" cm");
    }

    delay(100);
  }
}

Cómo comprobarlo

1. Abre el Monitor serie a 9600 baudios.
2. Coloca objetos en distintas direcciones.
3. Observa la distancia asociada a cada ángulo.
4. Anota qué ángulo corresponde físicamente a izquierda, centro y derecha en tu montaje.
5. Cambia la posición de los objetos y repite.

Tabla de resultados

Resultado esperado

El sensor se orienta hacia varias posiciones y muestra una distancia asociada a cada una.

Modificación obligatoria

Modifica el programa para guardar las lecturas de las tres posiciones y mostrar cuál tiene mayor distancia entre las lecturas válidas.

Si ninguna lectura es válida, debe mostrar:

No se puede determinar la dirección más despejada.

Preguntas

1. ¿Por qué esperamos después de mover el servo?
2. ¿Por qué debemos relacionar cada distancia con su ángulo?
3. ¿Podemos considerar que una dirección sin eco está necesariamente libre?
4. ¿Cómo podría utilizar esta información el futuro coche?

Entrega de la parte 1

Entrega una carpeta comprimida con:

parte_1/
├── README.md
├── imagenes/
├── 01_ultrasonidos/
├── 02_servo/
└── 03_escaner/

En el README.md incluye:

• Explicación de las tres prácticas.
• Fotografías y conexiones.
• Tablas de resultados.
• Respuestas a las preguntas.
• Modificaciones realizadas.
• Una conclusión sobre cómo funciona el escáner.

1. Presentación

En este proyecto aprenderás los fundamentos de Arduino utilizando Wokwi, un simulador electrónico que funciona directamente desde el navegador. Durante la primera parte no necesitarás instalar Arduino IDE ni disponer de una placa física.

Realizarás varios ejercicios guiados y resueltos. Deberás reproducirlos, comprobar su funcionamiento, introducir pequeñas modificaciones y documentar el trabajo realizado.

En la última parte trasladarás uno de los circuitos a un Arduino real.

No basta con copiar el código. Debes montar cada circuito, ejecutarlo, observar qué sucede y explicar con tus palabras cómo funciona.

2. Objetivos

Al terminar el proyecto serás capaz de:

• Crear y guardar proyectos en Wokwi.
• Reconocer las partes principales de una placa Arduino Uno.
• Comprender la función de setup() y loop().
• Configurar pines digitales como entradas o salidas.
• Encender y apagar LED.
• Utilizar pausas con delay().
• Enviar información al monitor serie.
• Leer el estado de un pulsador.
• Construir un circuito sencillo en una protoboard.
• Documentar una práctica técnica en formato Markdown.

3. Herramientas necesarias

Parte simulada

• Ordenador con navegador web.
• Cuenta de Wokwi.
• Acceso a https://wokwi.com/.
• Editor de Markdown utilizado en clase.

Parte física final

• Arduino Uno o placa compatible.
• Cable USB.
• Protoboard.
• Un LED rojo, uno amarillo y uno verde.
• Tres resistencias de 220 Ω o 330 Ω.
• Un pulsador.
• Cables de conexión.
• Un equipo preparado por el profesor con Arduino IDE o Arduino Cloud Agent.

4. Normas de trabajo

Para cada ejercicio debes:

1. Crear o duplicar un proyecto en Wokwi.
2. Montar el circuito indicado.
3. Copiar y ejecutar el código proporcionado.
4. Abrir el monitor serie cuando se solicite.
5. Comprobar el resultado.
6. Realizar la modificación propuesta.
7. Guardar el enlace del proyecto.
8. Añadir a la documentación una captura y una explicación personal.

En la documentación no se aceptarán explicaciones como «funciona bien» o «enciende el LED». Debes indicar qué elementos intervienen, qué instrucciones se ejecutan y cuál es el resultado observado.

Parte I. Ejercicios guiados y resueltos en Wokwi

Ejercicio 1. Hola, Arduino: uso del monitor serie

Objetivo

Aprender a enviar mensajes desde Arduino al ordenador mediante la comunicación serie.

Componentes

• Arduino Uno.

No es necesario añadir componentes externos.

Esquema visual

En este ejercicio no existe cableado externo: la salida se observa en el monitor serie.

flowchart LR
    A["Arduino Uno"] -->|"USB / comunicación serie a 9600 baudios"| M["Monitor serie de Wokwi"]
    M --> R["Mensajes y resultados"]

Preparación en Wokwi

1. Entra en https://wokwi.com/.
2. Selecciona Start from Scratch.
3. Elige Arduino Uno.
4. Abre el archivo sketch.ino.
5. Sustituye su contenido por el siguiente código.

Código resuelto

void setup() {
  Serial.begin(9600);
  Serial.println("Arduino iniciado correctamente");
}

void loop() {
  Serial.println("El programa sigue funcionando");
  delay(1000);
}

Explicación

• Serial.begin(9600) inicia la comunicación serie a 9600 bits por segundo.
• Serial.println() envía un texto y añade un salto de línea.
• El mensaje incluido en setup() aparece una sola vez.
• El mensaje incluido en loop() se repite cada segundo.
• delay(1000) detiene el programa durante 1000 milisegundos.

Comprobación

Inicia la simulación. La consola o monitor serie debería mostrar:

Arduino iniciado correctamente
El programa sigue funcionando
El programa sigue funcionando
El programa sigue funcionando

Modificación obligatoria

Modifica el programa para que:

• Muestre tu nombre al comenzar.
• Muestre el texto Han pasado dos segundos cada dos segundos.

Documentación

Incluye una captura del monitor serie y explica por qué el primer mensaje aparece una sola vez y el segundo se repite.

Ejercicio 2. LED integrado intermitente

Objetivo

Controlar una salida digital utilizando el LED integrado de Arduino Uno.

Componentes

• Arduino Uno.
• LED integrado de la placa, conectado internamente al pin 13.

Esquema visual

flowchart LR
    A["Arduino Uno"] --> P["Pin digital 13"]
    P --> L["LED integrado L"]
    A -.->|"USB"| M["Monitor serie"]

El LED marcado como L ya está montado en la placa. No debes añadir cables ni componentes.

Código resuelto

const int LED = 13;

void setup() {
  pinMode(LED, OUTPUT);
  Serial.begin(9600);
  Serial.println("Prueba del LED iniciada");
}

void loop() {
  digitalWrite(LED, HIGH);
  Serial.println("LED encendido");
  delay(1000);

  digitalWrite(LED, LOW);
  Serial.println("LED apagado");
  delay(1000);
}

Explicación

• const int LED = 13 asigna un nombre al número del pin.
• pinMode(LED, OUTPUT) configura el pin como salida.
• digitalWrite(LED, HIGH) activa el pin y enciende el LED.
• digitalWrite(LED, LOW) desactiva el pin y apaga el LED.
• Los mensajes permiten relacionar el estado físico del LED con la ejecución del programa.

Modificación obligatoria

Consigue que el LED:

1. Permanezca encendido durante dos segundos.
2. Permanezca apagado durante medio segundo.
3. Muestre los estados correspondientes en el monitor serie.

Preguntas

1. ¿Para qué sirve pinMode()?
2. ¿Qué diferencia hay entre HIGH y LOW?
3. ¿Cuántas veces se ejecuta setup()?
4. ¿Cuántas veces se ejecuta loop()?

Ejercicio 3. Conexión de un LED externo

Objetivo

Aprender a conectar un LED externo y una resistencia a Arduino.

Componentes

• Arduino Uno.
• Un LED rojo.
• Una resistencia de 220 Ω o 330 Ω.
• Cables.

Conexiones

La resistencia limita la corriente que atraviesa el LED y ayuda a evitar que se dañe.

Esquema visual

flowchart LR
    D8["Arduino D8"] --> R["Resistencia 220–330 Ω"]
    R --> A["Ánodo + · pata larga"]
    A --> L["LED rojo"]
    L --> C["Cátodo − · pata corta"]
    C --> G["Arduino GND"]
    USB["Conexión USB"] -.-> M["Monitor serie"]

Recorrido de la corriente: D8 → resistencia → ánodo del LED → cátodo → GND.

Código resuelto

const int LED_ROJO = 8;
int numeroParpadeo = 0;

void setup() {
  pinMode(LED_ROJO, OUTPUT);
  Serial.begin(9600);
  Serial.println("LED externo preparado");
}

void loop() {
  numeroParpadeo++;

  digitalWrite(LED_ROJO, HIGH);
  Serial.print("Parpadeo numero: ");
  Serial.println(numeroParpadeo);
  delay(500);

  digitalWrite(LED_ROJO, LOW);
  delay(500);
}

Explicación

Serial.print() escribe sin realizar un salto de línea. A continuación, Serial.println(numeroParpadeo) muestra el valor y termina la línea. De esta manera, texto y número aparecen juntos.

Resultado esperado

LED externo preparado
Parpadeo numero: 1
Parpadeo numero: 2
Parpadeo numero: 3

Modificación obligatoria

Conecta el LED al pin 7, adapta el programa y haz que parpadee cada 250 milisegundos.

Preguntas

1. ¿Por qué se utiliza una resistencia?
2. ¿Qué ocurriría si cambias el montaje al pin 7 pero no modificas el código?
3. ¿Para qué sirve la variable numeroParpadeo?

Ejercicio 4. Semáforo sencillo

Objetivo

Controlar varias salidas digitales y crear una secuencia.

Componentes

• Arduino Uno.
• Un LED rojo.
• Un LED amarillo.
• Un LED verde.
• Tres resistencias de 220 Ω o 330 Ω.

Conexiones

Cada LED debe disponer de su propia resistencia.

Esquema visual

Los tres puntos GND representan la misma conexión de tierra de Arduino. Puedes unir los tres cátodos a la línea negativa de la protoboard y conectar esa línea a un pin GND de la placa.

flowchart LR
    D10["D10"] --> RR["Resistencia"] --> LR["LED rojo"] --> G1["GND"]
    D9["D9"] --> RA["Resistencia"] --> LA["LED amarillo"] --> G2["GND"]
    D8["D8"] --> RV["Resistencia"] --> LV["LED verde"] --> G3["GND"]

Código resuelto

const int LED_ROJO = 10;
const int LED_AMARILLO = 9;
const int LED_VERDE = 8;

void setup() {
  pinMode(LED_ROJO, OUTPUT);
  pinMode(LED_AMARILLO, OUTPUT);
  pinMode(LED_VERDE, OUTPUT);

  Serial.begin(9600);
  Serial.println("Semaforo iniciado");
}

void loop() {
  digitalWrite(LED_ROJO, HIGH);
  digitalWrite(LED_AMARILLO, LOW);
  digitalWrite(LED_VERDE, LOW);
  Serial.println("ROJO: detenerse");
  delay(3000);

  digitalWrite(LED_ROJO, LOW);
  digitalWrite(LED_VERDE, HIGH);
  Serial.println("VERDE: avanzar");
  delay(3000);

  digitalWrite(LED_VERDE, LOW);
  digitalWrite(LED_AMARILLO, HIGH);
  Serial.println("AMARILLO: precaucion");
  delay(1000);
}

Comprobación

Observa que solamente debe permanecer encendido un LED en cada momento. Comprueba que el monitor serie muestra el mismo estado que representa el circuito.

Modificación obligatoria

Cambia los tiempos para que:

• El rojo dure cuatro segundos.
• El verde dure cinco segundos.
• El amarillo dure dos segundos.

Añade antes de cada cambio el mensaje Cambiando estado del semaforo.

Preguntas

1. ¿Por qué se declaran tres constantes diferentes?
2. ¿Qué LED se enciende después del rojo?
3. ¿Cuánto dura una secuencia completa tras realizar la modificación?
4. ¿Por qué conviene mostrar el estado en el monitor serie?

Ejercicio 5. Pulsador y monitor serie

Objetivo

Leer una entrada digital y mostrar su estado en el monitor serie.

Componentes

• Arduino Uno.
• Un pulsador.
• Un LED.
• Una resistencia para el LED.

Conexiones

Se utilizará la resistencia interna de Arduino mediante INPUT_PULLUP. Por ello, el pulsador tendrá lógica invertida:

• Sin pulsar: HIGH.
• Pulsado: LOW.

Esquema visual

flowchart LR
    D2["Arduino D2 · INPUT_PULLUP"] --> B["Pulsador"] --> G1["GND"]
    D8["Arduino D8 · OUTPUT"] --> R["Resistencia 220–330 Ω"]
    R --> A["Ánodo + del LED"] --> L["LED"] --> C["Cátodo −"] --> G2["GND"]

El pulsador se conecta entre D2 y GND. No necesita una resistencia externa porque el programa activa la resistencia interna con INPUT_PULLUP.

Código resuelto

const int PULSADOR = 2;
const int LED = 8;

void setup() {
  pinMode(PULSADOR, INPUT_PULLUP);
  pinMode(LED, OUTPUT);

  Serial.begin(9600);
  Serial.println("Sistema preparado");
}

void loop() {
  int estadoPulsador = digitalRead(PULSADOR);

  if (estadoPulsador == LOW) {
    digitalWrite(LED, HIGH);
    Serial.println("Pulsador presionado - LED encendido");
  } else {
    digitalWrite(LED, LOW);
    Serial.println("Pulsador libre - LED apagado");
  }

  delay(200);
}

Explicación

• INPUT_PULLUP configura el pin como entrada y activa una resistencia interna.
• digitalRead() lee el estado del pin.
• La estructura if permite tomar una decisión.
• Cuando se pulsa, el estado leído es LOW y el LED se enciende.

Modificación obligatoria

Modifica únicamente los textos para que el monitor serie muestre:

• ALARMA ACTIVADA al pulsar.
• Sistema en espera al soltar.

Después cambia el LED del pin 8 al pin 6, tanto en el circuito como en el programa.

Preguntas

1. ¿Qué valor devuelve el pulsador cuando está presionado?
2. ¿Por qué en este montaje se considera pulsado cuando devuelve LOW?
3. ¿Qué estructura del código permite decidir si el LED se enciende?

Parte II. Implementación final en Arduino real

Reto final: semáforo físico con diagnóstico serie

En esta parte trasladarás el ejercicio 4 a un Arduino real. Es el único ejercicio del proyecto que debe implementarse físicamente.

Esquema de referencia para el montaje físico

flowchart LR
    D10["D10"] --> R1["220–330 Ω"] --> RO["LED rojo"] --> G["Línea GND de la protoboard"]
    D9["D9"] --> R2["220–330 Ω"] --> AM["LED amarillo"] --> G
    D8["D8"] --> R3["220–330 Ω"] --> VE["LED verde"] --> G
    G --> AG["Arduino GND"]
    AU["Arduino Uno"] -.->|"USB"| PC["Arduino IDE y monitor serie"]

Antes de conectar el USB, comprueba que la pata larga de cada LED queda orientada hacia su resistencia y la pata corta hacia GND.

Trabajo que debes realizar

1. Recupera tu proyecto del semáforo en Wokwi.
2. Comprueba que la simulación funciona correctamente.
3. Reúne los componentes necesarios.
4. Desconecta la placa del USB mientras realizas el montaje.
5. Conecta los tres LED, cada uno con su propia resistencia.
6. Revisa la polaridad de los LED.
7. Solicita al profesor la revisión del circuito antes de alimentarlo.
8. Conecta Arduino al ordenador.
9. Abre el código con la herramienta indicada por el profesor.
10. Selecciona la placa y el puerto correspondientes.
11. Carga el programa.
12. Abre el monitor serie a 9600 baudios.
13. Comprueba que los LED y los mensajes siguen la misma secuencia.

Requisitos mínimos

• Los tres LED deben funcionar.
• Nunca deben encenderse los tres a la vez.
• Cada LED debe utilizar una resistencia.
• El monitor serie debe indicar el estado actual.
• El montaje físico debe corresponder con los pines declarados en el código.

Pequeña adaptación obligatoria

En el Arduino real, cambia la secuencia para que:

• Rojo: 5 segundos.
• Verde: 4 segundos.
• Amarillo: 2 segundos.

El monitor serie deberá mostrar también la duración de cada estado, por ejemplo:

ROJO: detenerse durante 5 segundos
VERDE: avanzar durante 4 segundos
AMARILLO: precaucion durante 2 segundos

Evidencias necesarias

• Fotografía general del montaje real.
• Fotografía donde puedan reconocerse los pines utilizados.
• Captura del monitor serie.
• Código final.
• Explicación de las diferencias encontradas entre Wokwi y el montaje físico.
• Breve descripción de cualquier error y de cómo se solucionó.

Seguridad y buenas prácticas

• No cambies conexiones con la placa alimentada.
• No conectes un LED directamente sin resistencia.
• Comprueba la polaridad antes de encender.
• No fuerces los conectores.
• Si el circuito se calienta o se comporta de forma extraña, desconecta el USB y avisa al profesor.

Parte III. Documentación y entrega

Formato de entrega

La documentación se entregará en un archivo llamado:

README.md

Se redactará en Markdown con el editor utilizado en clase. Además del archivo, se entregará una carpeta img que contenga las capturas y fotografías.

La estructura recomendada es:

proyecto-arduino/
├── README.md
└── img/
    ├── ejercicio1-monitor-serie.png
    ├── ejercicio2-led-integrado.png
    ├── ejercicio3-led-externo.png
    ├── ejercicio4-semaforo.png
    ├── ejercicio5-pulsador.png
    └── semaforo-real.jpg

Estructura obligatoria del README

# Proyecto de iniciación a Arduino

## Datos del alumno

- Nombre:
- Grupo:
- Fecha:

## Introducción

Explicación breve del objetivo del proyecto.

## Ejercicio 1. Monitor serie

### Montaje y funcionamiento

Explicación personal.

### Código

```cpp
// Código utilizado
```

### Resultado

![Monitor serie](img/ejercicio1-monitor-serie.png)

### Modificación realizada

Explicación y resultado.

### Respuestas

Respuestas a las preguntas del ejercicio.

## Ejercicio 2. LED integrado

Repetir la misma organización.

## Ejercicio 3. LED externo

Repetir la misma organización.

## Ejercicio 4. Semáforo

Repetir la misma organización.

## Ejercicio 5. Pulsador

Repetir la misma organización.

## Implementación en Arduino real

Descripción, código, fotografías y problemas encontrados.

## Conclusiones

Qué has aprendido y qué parte te ha resultado más difícil.

## Enlaces a los proyectos de Wokwi

- Ejercicio 1:
- Ejercicio 2:
- Ejercicio 3:
- Ejercicio 4:
- Ejercicio 5:

Para evitar problemas al incluir bloques de código dentro del README, utiliza tres acentos graves antes y después del código y escribe cpp junto a los tres primeros.

Requisitos de la documentación

El README.md debe contener:

• Portada o título.
• Datos del alumno.
• Índice.
• Explicación de cada ejercicio con palabras propias.
• Código correctamente presentado en bloques cpp.
• Una captura de cada simulación.
• Capturas del monitor serie.
• Enlaces a los proyectos de Wokwi.
• Respuestas a todas las preguntas.
• Evidencias del montaje real.
• Problemas encontrados y soluciones aplicadas.
• Conclusión personal.

Penalizaciones

• No entregar enlaces funcionales de Wokwi.
• No incluir las capturas solicitadas.
• Presentar código sin explicar su funcionamiento.
• Copiar explicaciones de otras personas o generadas automáticamente sin revisarlas.
• Conectar físicamente LED sin resistencia.
• Entregar un documento distinto de README.md sin autorización.

6. Lista de comprobación antes de entregar

• He completado los cinco ejercicios de Wokwi.
• He realizado todas las modificaciones obligatorias.
• He probado el monitor serie.
• He respondido las preguntas con mis palabras.
• Los enlaces de Wokwi se pueden abrir.
• He construido y probado el semáforo real.
• He incluido el código en bloques Markdown.
• Las imágenes se encuentran dentro de la carpeta img.
• Todas las imágenes aparecen correctamente en el README.md.
• He escrito una conclusión personal.
• El archivo principal se llama exactamente README.md.

7. Ampliación voluntaria

Si terminas antes, modifica el semáforo de Wokwi para que el LED amarillo parpadee tres veces antes de encenderse el rojo. El monitor serie deberá informar de cada parpadeo.

Documenta la ampliación indicando qué instrucciones has añadido y por qué.