Introducción a la electrónica

CÓDIGO C33529

LABORATORIO N° 12

“Lenguaje de programación Arduino –

Estructuras Decisivas”
Arduino

1. Jacho Ttica Anderson Macool

2. Choquehuayta Condori, Bryan Angel
Alumno (os):
3. Hurtado Mamani, Diego Andres
4.
Grupo (mesa) : Profesor: Nota:
Semestre : 1 Yamir Flórez
Fecha de entrega : 03 06 24 Hora: 23:59
ATS: 30/05/24
 Laboratorio Nro. 12: Lenguaje de programación Arduino – Nro. DD-107
Estructuras Decisivas Página 3

I. OBJETIVOS:
 Utilizar el IDE de Arduino usando el módulo de programación IOT Arduino.
 Hacer uso del hardware de Arduino Mega 2560 (Atmega 2560) o Arduino UNO (Atmega 328p).
 Realizar la implementación y desarrollo de cada uno de los programas propuestos en la guía de
laboratorio

II. INTRODUCCION TEORICA:

El Arduino UNO es una tarjeta electrónica programable de código abierto basado en el microchip
ATmega328P y desarrollado por Arduino.cc. La tarjeta electrónica está equipada con conjuntos de
pines de E/S digitales y analógicas que pueden conectarse a varias placas de expansión y otros
circuitos. La tarjeta electrónica tiene 14 pines digitales, 6 pines analógicos y programables con el
Arduino IDE (Entorno de desarrollo integrado) a través de un cable USB tipo B. Puede ser alimentado
por el cable USB o por una batería externa de 9 voltios, aunque acepta voltajes entre 7 y 20 voltios.
También es similar al Arduino Nano y Leonardo. El diseño de referencia de hardware se distribuye
bajo una licencia Creative Commons Attribution Share-Alike 2.5 y está disponible en el sitio web de
Arduino. Los archivos de diseño y producción para algunas versiones del hardware también están
disponibles.
La tarjeta electrónica Arduino UNO es la primera de una serie de placas Arduino basadas en USB, y
la versión 1.0 del Arduino IDE fueron las versiones de referencia de Arduino, ahora evolucionadas a
nuevas versiones. El ATmega328 en la tarjeta electrónica viene preprogramado con un cargador de
arranque que le permite cargar un nuevo código sin el uso de un programador de hardware externo.
Mientras que el Arduino UNO se comunica utilizando el protocolo STK500 original, difiere de todas
las placas anteriores en que no utiliza el chip de controlador USB a serie FTDI. En cambio, usa el
Atmega16U2 (Atmega8U2 hasta la versión R2) programado como un adaptador USB a serie.

III. PREPARACION:
El estudiante debe haber revisado la información de clase, el texto de la SESION 11 y haber leído la
parte introductoria de la guía de laboratorio.

IV. EQUIPOS Y MATERIALES A EMPLEAR:

- Módulo IOT Arduino - Diodos Leds
- Fuente de Alimentación Variable - Pulsadores
- Protoboard
- Resistencias

V. PROCEDIMIENTO
REQUERIEMINTOS
a) Colocar imágenes como fotográficas, capturas de pantalla, etc., que corresponde a la
implementación de cada uno de los códigos de programa a desarrollar.
b) Colocar las imágenes de la implementación terminada indicando los nombres de los componentes
utilizados y su respectiva función.
c) Debe de colocar un comentario breve explicando el funcionamiento de cada línea de instrucción
o código de programa desarrollado en IDE Arduino

 Desarrollar los siguientes códigos de programa haciendo usando del IDE de Arduino y modulo
IOT de Arduino.
 Laboratorio Nro. 12: Lenguaje de programación Arduino – Nro. DD-107
Estructuras Decisivas Página 4

1. PROGRAMA 01 (3.67 ptos.)

Realizar un programa y comentado para Arduino UNO que realice lo siguiente:

Usando el teclado de la computadora:

 Al presionar la tecla A se debe prender el LED 01 que está conectado al pin 12 del Arduino
MEGA 2560. En el monitor serie debe de indicar que la Opción 01: Led 01 – Encendido.
 Al presionar la tecla ‘a’ se debe apagar el LED 01 que está conectado al pin 12 del Arduino
MEGA 2560. En el monitor serie debe de indicar que la Opción 01: Led 01 – Apagado.
 Al presionar la tecla B se debe prender el LED 02 que está conectado al pin 11 del Arduino
MEGA 2560. En el monitor serie debe de indicar que la Opción 02: Led 02 – Encendido.
 Al presionar la tecla ‘b’ se debe apagar el LED 02 que está conectado al pin 12 del Arduino
MEGA 2560. En el monitor serie debe de indicar que la Opción 02: Led 02 – Apagado.
 Al presionar la tecla ‘1’ debe de parpadear el LED 01 de forma cíclica solo 3 veces. En el
monitor serie debe de indicar que la Opción 03: Encendido y al finalizar la secuencia repetitiva
debe en el monitor serie debe de indicar que la Opción 03: Terminado.
 Al presionar la tecla ‘0’ debe de parpadear el LED 2 de forma cíclica solo 2 veces. En el
monitor serie debe de indicar que la Opción 04: Encendido y al finalizar la secuencia repetitiva
debe en el monitor serie debe de indicar que la Opción 04: Terminado.

Para su evaluación:
 Colocar evidencia del código de programa desarrollado con su respectivo comentario y
análisis.
 Adjuntar el diagrama esquemático del circuito electrónico.
 Colocar evidencia del código realizado e implementado haciendo uso del módulo IOT
Arduino. (Adjuntar imágenes fotografías y una captura de pantalla como evidencia)

// Definición de pines
const int ledPin1 = 12; // LED 01 conectado al pin 12
const int ledPin2 = 11; // LED 02 conectado al pin 11

// Configuración inicial
void setup() {
// Inicializar los pines como salidas
pinMode(ledPin1, OUTPUT);
pinMode(ledPin2, OUTPUT);

// Inicializar la comunicación serie

 Laboratorio Nro. 12: Lenguaje de programación Arduino – Nro. DD-107
Estructuras Decisivas Página 5

Serial.begin(9600);

// Asegurarse de que los LEDs estén apagados al inicio

digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, LOW);
}

// Bucle principal
void loop() {
// Verificar si hay datos disponibles en el puerto serie
if (Serial.available() > 0) {
// Leer el carácter ingresado
char input = Serial.read();

// Verificar el carácter ingresado y realizar las acciones correspondientes

switch (input) {
case 'A':
// Encender LED 01
digitalWrite(ledPin1, HIGH);
Serial.println("Opción 01: Led 01 - Encendido");
break;
case 'a':
// Apagar LED 01
digitalWrite(ledPin1, LOW);
Serial.println("Opción 01: Led 01 - Apagado");
break;
case 'B':
// Encender LED 02
digitalWrite(ledPin2, HIGH);
Serial.println("Opción 02: Led 02 - Encendido");
break;
case 'b':
// Apagar LED 02
digitalWrite(ledPin2, LOW);
Serial.println("Opción 02: Led 02 - Apagado");
break;
case '1':
// Parpadear LED 01 3 veces
Serial.println("Opción 03: Encendido");
for (int i = 0; i < 3; i++) {
digitalWrite(ledPin1, HIGH);
delay(500); // Esperar 500 ms
digitalWrite(ledPin1, LOW);
delay(500); // Esperar 500 ms
}
Serial.println("Opción 03: Terminado");
break;
 Laboratorio Nro. 12: Lenguaje de programación Arduino – Nro. DD-107
Estructuras Decisivas Página 6

case '0':
// Parpadear LED 02 2 veces
Serial.println("Opción 04: Encendido");
for (int i = 0; i < 2; i++) {
digitalWrite(ledPin2, HIGH);
delay(500); // Esperar 500 ms
digitalWrite(ledPin2, LOW);
delay(500); // Esperar 500 ms
}
Serial.println("Opción 04: Terminado");
break;
default:
// Si se ingresa un carácter no reconocido
Serial.println("Opción no reconocida");
break;
}
}
}

Comentarios:
1. Configuración del Hardware:
o La explicación sobre cómo conectar los LEDs y las resistencias al Arduino MEGA
2560 fue clara y detallada. La visualización del esquema de conexiones, con los
LEDs conectados a los pines digitales 12 y 11 a través de resistencias de 220Ω,
hizo que el proceso de ensamblaje fuera más sencillo.
2. Código para el Arduino:
o El código proporcionado para el Arduino cubre todas las funcionalidades
requeridas, incluyendo el encendido y apagado de LEDs y la implementación del
parpadeo cíclico. Los comentarios en el código también ayudaron a entender la
lógica detrás de cada sección, facilitando su personalización y depuración.
3. Uso del Monitor Serie:
o La instrucción para utilizar el monitor serie de Tinkercad para enviar comandos al
Arduino fue útil. Esto permite una interacción dinámica con el circuito, observando
en tiempo real cómo responde a diferentes entradas.
4. Simulación en Tinkercad:
o Las indicaciones paso a paso sobre cómo configurar la simulación en Tinkercad
fueron muy completas. La guía incluyó todos los detalles necesarios, desde la
adición de componentes hasta la interacción con el monitor serie, asegurando una
experiencia de simulación sin problemas.
 Laboratorio Nro. 12: Lenguaje de programación Arduino – Nro. DD-107
Estructuras Decisivas Página 7

Análisis de la Información:
La información proporcionada para configurar y simular un circuito en Tinkercad con un Arduino
MEGA 2560 cubre todos los aspectos fundamentales necesarios para llevar a cabo el proyecto
con éxito.

1. Configuración del Hardware:

 La guía de conexión del hardware es precisa y fácil de seguir. La elección de resistencias

de 220Ω para los LEDs es adecuada para limitar la corriente y proteger tanto los LEDs
como el Arduino. La visualización esquemática de las conexiones ayuda a evitar errores
comunes, como la conexión incorrecta de los pines o la orientación de los LEDs.

2. Código para el Arduino:

 El código presentado está bien estructurado y comentado, lo que facilita su comprensión.

Cada caso en el switch corresponde a una funcionalidad específica (encender, apagar,
parpadear), y el uso de la función Serial.println proporciona retroalimentación clara en el
monitor serie. Esto es crucial para depurar y verificar que el circuito está funcionando
como se espera.

3. Uso del Monitor Serie:

 La interacción con el monitor serie es una parte esencial del proyecto, ya que permite
controlar el circuito sin necesidad de hardware adicional (como botones físicos). La
capacidad de enviar comandos desde la computadora y recibir retroalimentación en tiempo
real facilita la prueba y la verificación de las funcionalidades implementadas.

4. Simulación en Tinkercad:

 La plataforma Tinkercad es ideal para simular proyectos de Arduino debido a su interfaz

intuitiva y la capacidad de emular tanto el hardware como el software. La guía detalla
cómo agregar componentes, configurar conexiones y cargar el código, asegurando que
incluso aquellos con poca experiencia en simulación puedan seguir los pasos y obtener
resultados.
 Laboratorio Nro. 12: Lenguaje de programación Arduino – Nro. DD-107
Estructuras Decisivas Página 8

2. PROGRAMA 02 (3.67 ptos.)

El semáforo
Debemos conseguir que los tres leds se enciendan en bucle alternativamente, como si de un
semáforo se tratase, según esta secuencia: rojo (2 seg.), verde (2 seg.), amarillo (500 ms). Para ello,
conectaremos el ánodo del led rojo al PIN 13, el ánodo del led amarillo al PIN 11 y el ánodo del
led verde al PIN 09

Para su evaluación:
 Colocar evidencia del código de programa desarrollado con su respectivo comentario y
análisis.
 Adjuntar el diagrama esquemático del circuito electrónico.
 Colocar evidencia del código realizado e implementado haciendo uso del módulo IOT
Arduino. (Adjuntar imágenes fotografías y una captura de pantalla como evidencia)

//declarando mis pines

int rojo=13;
int amarillo=11;
int verde=9;
void setup()
{
pinMode(rojo,OUTPUT);
pinMode(amarillo,OUTPUT);
pinMode(verde,OUTPUT);
}

void loop()
{
digitalWrite(rojo,HIGH);
 Laboratorio Nro. 12: Lenguaje de programación Arduino – Nro. DD-107
Estructuras Decisivas Página 9

delay(2000);//espera 2 segundos
digitalWrite(rojo,LOW);
delay(2000);//espera 2 segundos
digitalWrite(amarillo,HIGH);
delay(500);//espera 2 segundos
digitalWrite(amarillo,LOW);
delay(500);//espera 2 segundos
digitalWrite(verde,HIGH);
delay(2000);//espera 2 segundos
digitalWrite(verde,LOW);
delay(2000);//espera 2 segundos
}

Comentarios:
-Se pretende que el alumnado de esta etapa asimile los componentes básicos
de la electrónica, que les servirá por un lado la adquisición de competencias
básicas.
- Diodo Led (electroluminiscente): diodo que da luz al pasar la corriente en un
sentido (polarización directa), y no al contrario, de bajo consumo, se emplea
como elemento señalizador.
- Resistencia: se coloca en los circuitos eléctricos y electrónicos para limitar
la corriente que pasará a los demás componentes. Su valor vendrá dado por
una serie de anillos según un código de colores, según una tabla, en concreto
tenemos cuatro anillos, que se leerán según un orden. Estos indicarán su
valor, poder multiplicador y tolerancia
Análisis de la Información:
-La guía de conexión del hardware es precisa y fácil de seguir. La elección de resistencias de
220Ω para los LEDs es adecuada para limitar la corriente y proteger tanto los LEDs
- El código presentado está bien estructurado y comentado, lo que facilita su comprensión. Cada
caso en el switch corresponde a una funcionalidad específica (encender, apagar, parpadear), y el
uso de la función Serial.println proporciona retroalimentación clara en el monitor serie.
-La plataforma Tinkercad es ideal para simular proyectos de Arduino debido a su interfaz intuitiva
y la capacidad de emular tanto el hardware como el software. La guía detalla cómo agregar
componentes, configurar conexiones y cargar el código

3. PROGRAMA 03 (3.67 ptos.)

Con el mismo circuito físico de la practica anterior, debemos mejora el programa anterior para que
funcione de la siguiente manera. La primera vez que se ejecute el código de programa, los 3 diodos
leds deben de seguir la siguiente secuencia: Verde (verde (1 seg.), amarillo (1 seg.) y rojo (1 seg.).
Cada vez que se ejecute el bucle, el tiempo que permanecerá encendido cada led disminuirá en 100
ms. Cuando cada led permanezca encendido solo 100 ms, el retardo permanecerá con ese valor de
100 ms, no disminuyendo más.

Para su evaluación:
 Laboratorio Nro. 12: Lenguaje de programación Arduino – Nro. DD-107
Estructuras Decisivas Página 10

 Colocar evidencia del código de programa desarrollado con su respectivo comentario y

análisis.
 Adjuntar el diagrama esquemático del circuito electrónico.
 Colocar evidencia del código realizado e implementado haciendo uso del módulo IOT
Arduino. (Adjuntar imágenes fotografías y una captura de pantalla como evidencia)

//declarando mis pines

int rojo=13;
int amarillo=11;
int verde=9;
void setup()
{
pinMode(rojo,OUTPUT);
pinMode(amarillo,OUTPUT);
pinMode(verde,OUTPUT);
}

void loop()
{
digitalWrite(verde,HIGH);
delay(1000);//espera 1 segundos
digitalWrite(verde,LOW);
delay(1000);//espera 1 segundos
digitalWrite(amarillo,HIGH);
delay(1000);//espera 1 segundos
digitalWrite(amarillo,LOW);
delay(1000);//espera 1 segundos
 Laboratorio Nro. 12: Lenguaje de programación Arduino – Nro. DD-107
Estructuras Decisivas Página 11

digitalWrite(rojo,HIGH);
delay(1000);//espera 1 segundos
digitalWrite(rojo,LOW);
delay(1000);//espera 1 segundos

digitalWrite(verde,HIGH);
delay(900);//espera 0.9 segundos
digitalWrite(verde,LOW);
delay(900);//espera 0.9 segundos
digitalWrite(amarillo,HIGH);
delay(900);//espera 0.9 segundos
digitalWrite(amarillo,LOW);
delay(900);//espera 0.9 segundos
digitalWrite(rojo,HIGH);
delay(900);//espera 0.9 segundos
digitalWrite(rojo,LOW);
delay(900);//espera 2 segundos

digitalWrite(verde,HIGH);
delay(800);//espera 0.8 segundos
digitalWrite(verde,LOW);
delay(800);//espera 0.8 segundos
digitalWrite(amarillo,HIGH);
delay(800);//espera 0.8 segundos
digitalWrite(amarillo,LOW);
delay(800);//espera 0.8 segundos
digitalWrite(rojo,HIGH);
delay(800);//espera 0.8 segundos
digitalWrite(rojo,LOW);
delay(800);//espera 0.8 segundos

digitalWrite(verde,HIGH);
delay(700);//espera 0.7 segundos
digitalWrite(verde,LOW);
delay(700);//espera 0.7 segundos
digitalWrite(amarillo,HIGH);
delay(700);//espera 0.7 segundos
digitalWrite(amarillo,LOW);
delay(700);//espera 0.7 segundos
digitalWrite(rojo,HIGH);
delay(700);//espera 0.7 segundos
 Laboratorio Nro. 12: Lenguaje de programación Arduino – Nro. DD-107
Estructuras Decisivas Página 12

digitalWrite(rojo,LOW);
delay(700);//espera 0.7 segundos

digitalWrite(verde,HIGH);
delay(600);//espera 0.6 segundos
digitalWrite(verde,LOW);
delay(600);//espera 0.6 segundos
digitalWrite(amarillo,HIGH);
delay(600);//espera 0.6 segundos
digitalWrite(amarillo,LOW);
delay(600);//espera 0.6 segundos
digitalWrite(rojo,HIGH);
delay(600);//espera 0.6 segundos
digitalWrite(rojo,LOW);
delay(600);//espera 0.6 segundos

digitalWrite(verde,HIGH);
delay(500);//espera 0.5 segundos
digitalWrite(verde,LOW);
delay(500);//espera 0.5 segundos
digitalWrite(amarillo,HIGH);
delay(500);//espera 0.5 segundos
digitalWrite(amarillo,LOW);
delay(500);//espera 0.5 segundos
digitalWrite(rojo,HIGH);
delay(500);//espera 0.5 segundos
digitalWrite(rojo,LOW);
delay(500);//espera 0.5 segundos

digitalWrite(verde,HIGH);
delay(400);//espera 0.4 segundos
digitalWrite(verde,LOW);
delay(400);//espera 0.4 segundos
digitalWrite(amarillo,HIGH);
delay(400);//espera 0.4 segundos
digitalWrite(amarillo,LOW);
delay(400);//espera 0.4 segundos
digitalWrite(rojo,HIGH);
delay(400);//espera 0.4 segundos
digitalWrite(rojo,LOW);
delay(400);//espera 0.4 segundos

digitalWrite(verde,HIGH);
 Laboratorio Nro. 12: Lenguaje de programación Arduino – Nro. DD-107
Estructuras Decisivas Página 13

delay(300);//espera 0.3 segundos

digitalWrite(verde,LOW);
delay(300);//espera 0.3 segundos
digitalWrite(amarillo,HIGH);
delay(300);//espera 0.3 segundos
digitalWrite(amarillo,LOW);
delay(300);//espera 0.3 segundos
digitalWrite(rojo,HIGH);
delay(300);//espera 0.3 segundos
digitalWrite(rojo,LOW);
delay(300);//espera 0.3 segundos

digitalWrite(verde,HIGH);
delay(200);//espera 0.2 segundos
digitalWrite(verde,LOW);
delay(200);//espera 0.2 segundos
digitalWrite(amarillo,HIGH);
delay(200);//espera 0.2 segundos
digitalWrite(amarillo,LOW);
delay(200);//espera 0.2 segundos
digitalWrite(rojo,HIGH);
delay(200);//espera 0.2 segundos
digitalWrite(rojo,LOW);
delay(200);//espera 0.2 segundos

digitalWrite(verde,HIGH);
delay(100);//espera 0.1 segundos
digitalWrite(verde,LOW);
delay(100);//espera 0.1 segundos
digitalWrite(amarillo,HIGH);
delay(100);//espera 0.1 segundos
digitalWrite(amarillo,LOW);
delay(100);//espera 0.1 segundos
digitalWrite(rojo,HIGH);
delay(100);//espera 0.1 segundos
digitalWrite(rojo,LOW);
delay(100);//espera 0.1 segundos

while(true){

digitalWrite(verde,HIGH);
delay(100);//espera 0.1 segundos
digitalWrite(verde,LOW);
 Laboratorio Nro. 12: Lenguaje de programación Arduino – Nro. DD-107
Estructuras Decisivas Página 14

delay(100);//espera 0.1 segundos

digitalWrite(amarillo,HIGH);
delay(100);//espera 0.1 segundos
digitalWrite(amarillo,LOW);
delay(100);//espera 0.1 segundos
digitalWrite(rojo,HIGH);
delay(100);//espera 0.1 segundos
digitalWrite(rojo,LOW);
delay(100);//espera 0.1 segundos
}

Comentarios:
- Diodo Led (electroluminiscente): diodo que da luz al pasar la corriente en un
sentido (polarización directa), y no al contrario, de bajo consumo, se emplea
como elemento señalizador.
- Resistencia: se coloca en los circuitos eléctricos y electrónicos para limitar
la corriente que pasará a los demás componentes. Su valor vendrá dado por
una serie de anillos según un código de colores, según una tabla, en concreto
tenemos cuatro anillos, que se leerán según un orden. Estos indicarán su
valor, poder multiplicador y tolerancia

-En este circuito se quiere realizar un bucle de luces led en el tiempo de vaya
haciendo más rápido el parpadeo de los leds

Análisis de la Información:
-La guía de conexión del hardware es precisa y fácil de seguir. La elección de resistencias de
220Ω para los LEDs es adecuada para limitar la corriente y proteger tanto los LEDs
- El código presentado está bien estructurado y comentado, lo que facilita su comprensión. Cada
caso en el switch corresponde a una funcionalidad específica (encender, apagar, parpadear), y el
uso de la función Serial.println proporciona retroalimentación clara en el monitor serie.
-La plataforma Tinkercad es ideal para simular proyectos de Arduino debido a su interfaz intuitiva
y la capacidad de emular tanto el hardware como el software. La guía detalla cómo agregar
componentes, configurar conexiones y cargar el código
 Laboratorio Nro. 12: Lenguaje de programación Arduino – Nro. DD-107
Estructuras Decisivas Página 15

VI. OBSERVACIONES

 Durante la implementación de los programas es fundamental asegurarse de que todos los componentes
estén correctamente conectados según el esquema electrónico.
 Errores en la asignación de pines pueden causar fallos en los leds, como incorrectos encendidos o
apagados en los leds.
 Los comentarios detallados en cada línea de código ayudan a entender mejor el funcionamiento del
programa.
 El monitor serie es importante para verificar que las entradas se estén leyendo correctamente y que las
acciones se estén ejecutando según lo esperado.
 Es importante ajustar estos retardos para asegurar que las luces del "semáforo" funcionen en los
tiempos correctos.

VII. CONCLUSIONES.

 La planificación del cableado ha sido esencial para evitar errores de conexión que pueden provocar
fallas en el circuito.
 La estructura del código como la utilización de comentarios, es fundamental para desarrollar
programas de Arduino que sean fáciles de entender y modificar.
 El laboratorio demostró la importancia de los controles precisos de temporización y las secuencias de
leds, como la simulación de un semáforo.
 La implementación de los retardos como la función delay ( ) fue efectiva para controlar las secuencias
de encendido y apagado de los LEDs.
 Este laboratorio proporcionó una excelente oportunidad para aprender conceptos fundamentales de
programación en Arduino.