Introducción a la Mecatrónica NOTA

I Ciclo

Laboratorio 10: Programación con

Arduino

Alumnos: Amaya Canchumanta Fabrizio Santiago

Docente: Armando Sarco Montiel

Fecha de realización: 25-05-2021

Fecha de entrega: 30-05-2021

 Lab. N° 10 Programación Básica del Arduino

I. Procedimiento:
Led de prueba (pin 13) intermitente:

Ejercicio 1: Copiar el programa de abajo, compilar, analizar y comentar lo que sucede.

//Ejemplo programa Led intermitente
int led = 13;
//Función de configuración
void setup(){
pinMode(led, OUTPUT);
}

//Se declara la rutina que se va a ejecutar siempre

void loop(){
digitalWrite(led, HIGH); //Enciende el LED con 5V
delay(500); //Espera medio segundo
digitalWrite(led, LOW); //Apaga el LED con 0V
delay(500); //Espera medio segundo
}

Nota: Se utiliza “//” y “/*---*/”, para documentar nuestro programa (comentarios), es una muy buena
práctica comentar siempre nuestro programa, aunque este no se almacene en la memoria del
arduino.

EVIDENCIA DE TINKERCAD

Responder las siguientes preguntas:

● ¿Qué pasa si cambiamos uno de los 2 valores del delay a 2000?

: Dependiendo de qué valor de delay cambiemos el led demorara en prender o

apagar 2 segundos.

● ¿Qué pasa si en vez de poner “int led = 13” ponemos “int led = 2”? explicar

: El led no se prendera porque este está conectado a la terminal (13) pero la

tensión está pasando por el terminal (2) donde no hay nada conectado.
 Lab. N° 10 Programación Básica del Arduino

Ejercicio 2: Utilizando el Tinkercad, armar el siguiente circuito en el protoboard, realizar un programa

para que se activen cuatro leds uno tras otro con un tiempo de espera de 200ms, compilar, analizar y
comentar lo que sucede.

CODIGO
//Leds intermitentes secuenciales
int led1 = 2;
int led2 = 3;
int led3 = 4;
int led4 = 5;

void setup(){
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(led3, OUTPUT);
pinMode(led4, OUTPUT);
}

void loop(){
digitalWrite(led1, HIGH);
delay(200);
digitalWrite(led1, LOW);
delay(200);
digitalWrite(led2, HIGH);
delay(200);
digitalWrite(led2, LOW);
delay(200);
digitalWrite(led3, HIGH);
delay(200);
digitalWrite(led3, LOW);
delay(200);
digitalWrite(led4, HIGH);
delay(200);
digitalWrite(led4, LOW);
delay(200);
}
 Lab. N° 10 Programación Básica del Arduino

EVIDENCIA DE TINKERCAD

Lo que sucede en el circuito es que los leds se activan uno tras otro en un
intervalo de 200ms y una vez acaba el ciclo vuelve a repetirse y así
sucesivamente.

Responder la siguiente pregunta:

● Tener cuidado conectando el led puesto que si se conecta al revés ¿Qué pasaría?

: Si se conectara al revés el led no prendería y en el peor de los casos podría

llegar a quemarse.
 Lab. N° 10 Programación Básica del Arduino

Ejercicio 3: Modificar el programa anterior para que ocho Leds se vayan prendiendo y apagando uno tras otro y
una vez el último led se ha prendido se invierte el sentido. Compilar, analizar y comentar lo que sucede.

//Leds secuenciales
int led1 = 0;
int led2 = 1;
int led3 = 2;
int led4 = 3;
int led5 = 4;
int led6 = 5;
int led7 = 6;
int led8 = 7;
int tiempo = 50;

void setup(){
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(led3, OUTPUT);
pinMode(led4, OUTPUT);
pinMode(led5, OUTPUT);
pinMode(led6, OUTPUT);
pinMode(led7, OUTPUT);
pinMode(led8, OUTPUT);
//regreso }
digitalWrite(led7, 1);
delay(tiempo); void loop(){
digitalWrite(led7, 0); //ida
delay(tiempo); digitalWrite(led1, 1);
digitalWrite(led6, 1); delay(tiempo);
delay(tiempo); digitalWrite(led1, 0);
digitalWrite(led6, 0); delay(tiempo);
delay(tiempo); digitalWrite(led2, 1);
digitalWrite(led5, 1); delay(tiempo);
delay(tiempo); digitalWrite(led2, 0);
digitalWrite(led5, 0); delay(tiempo);
delay(tiempo); digitalWrite(led3, 1);
digitalWrite(led4, 1); delay(tiempo);
delay(tiempo); digitalWrite(led3, 0);
digitalWrite(led4, 0); delay(tiempo);
delay(tiempo); digitalWrite(led4, 1);
digitalWrite(led3, 1); delay(tiempo);
delay(tiempo); digitalWrite(led4, 0);
digitalWrite(led3, 0); delay(tiempo);
delay(tiempo); digitalWrite(led5, 1);
digitalWrite(led2, 1); delay(tiempo);
delay(tiempo); digitalWrite(led5, 0);
digitalWrite(led2, 0); delay(tiempo);
delay(tiempo); digitalWrite(led6, 1);
digitalWrite(led1, 1); delay(tiempo);
delay(tiempo); digitalWrite(led6, 0);
digitalWrite(led1, 0); delay(tiempo);
delay(tiempo); digitalWrite(led7, 1);
} delay(tiempo);
digitalWrite(led7, 0);
delay(tiempo);
digitalWrite(led8, 1);
delay(tiempo);
digitalWrite(led8, 0);
delay(tiempo);
 Lab. N° 10 Programación Básica del Arduino

EVIDENCIA DE TINKERCAD

Lo que sucede en el circuito en el circuito es que los leds se prenden y apagan

uno tras otro y al llegar al último se invierte el sentido y así repitiéndose una y
otra vez.
 Lab. N° 10 Programación Básica del Arduino

Ejercicio 4: Montar el circuito con un display cátodo común, para que realice una cuenta de 0 a 9; realizar el
programa, compilar, analizar y comentar lo que sucede.

digitalWrite(a, 1);//3
digitalWrite(b, 1);
digitalWrite(c, 1);
digitalWrite(d, 1);
digitalWrite(e, 0);
digitalWrite(f, 0);
digitalWrite(g, 1);
delay(tiempo);
digitalWrite(a, 0);//4
digitalWrite(b, 1);
digitalWrite(c, 1);
digitalWrite(d, 0);
digitalWrite(e, 0);
digitalWrite(f, 1);
// ejercicio 4 digitalWrite(g, 1);
int a = 9; delay(tiempo);
int b = 10; digitalWrite(a, 1);//5
int c = 6; digitalWrite(b, 0);
int d = 5; digitalWrite(c, 1);
int e = 4; digitalWrite(d, 1);
int f = 8; digitalWrite(e, 0);
int g = 7; digitalWrite(f, 1);
int tiempo = 500; digitalWrite(g, 1);
delay(tiempo);
void setup(){ digitalWrite(a, 1);//6
pinMode(a, OUTPUT); digitalWrite(b, 0);
pinMode(b, OUTPUT); digitalWrite(c, 1);
pinMode(c, OUTPUT); digitalWrite(d, 1);
pinMode(d, OUTPUT); digitalWrite(e, 1);
pinMode(e, OUTPUT); digitalWrite(f, 1);
pinMode(f, OUTPUT); digitalWrite(g, 1);
pinMode(g, OUTPUT); delay(tiempo);
} digitalWrite(a, 1);//7
void loop() digitalWrite(b, 1);
{ digitalWrite(c, 1);
digitalWrite(a, 1);//0 digitalWrite(d, 0);
digitalWrite(b, 1); digitalWrite(e, 0);
digitalWrite(c, 1); digitalWrite(f, 0);
digitalWrite(d, 1); digitalWrite(g, 0);
digitalWrite(e, 1); delay(tiempo);
digitalWrite(f, 1); digitalWrite(a, 1);//8
digitalWrite(g, 0); digitalWrite(b, 1);
delay(tiempo); digitalWrite(c, 1);
digitalWrite(a, 0);//1 digitalWrite(d, 1);
digitalWrite(b, 1); digitalWrite(e, 1);
digitalWrite(c, 1); digitalWrite(f, 1);
digitalWrite(d, 0); digitalWrite(g, 1);
digitalWrite(e, 0); delay(tiempo);
digitalWrite(f, 0); digitalWrite(a, 1);//9
digitalWrite(g, 0); digitalWrite(b, 1);
delay(tiempo); digitalWrite(c, 1);
digitalWrite(a, 1);//2 digitalWrite(d, 0);
digitalWrite(b, 1); digitalWrite(e, 0);
digitalWrite(c, 0); digitalWrite(f, 1);
digitalWrite(d, 1); digitalWrite(g, 1);
digitalWrite(e, 1); delay(tiempo);
digitalWrite(f, 0); }
digitalWrite(g, 1);
EVIDENCIA
delay(tiempo);
 Lab. N° 10 Programación Básica del Arduino

Lo que sucede es que el display al iniciar la simulación inicia el conteo de 0 a 9

repitiéndose una y otra vez
 Lab. N° 10 Programación Básica del Arduino

Ejercicio 5: Montar el circuito con un led y pulsador, probar con los dos programas de abajo, compilar, analizar y
comentar lo que sucede.

int puls = 2;
int led = 3;
int value = 0;

void setup() {
pinMode(puls, INPUT);
pinMode(led, OUTPUT);
}

void loop(){
value = digitalRead(puls);

if (value == HIGH) {
digitalWrite(led, 1);
}
else {
digitalWrite(led, 0);
}
delay(100);
}

//Enclavamiento
int pulsador, contador = 0;

void setup(){
pinMode(3,OUTPUT);
pinMode(2,INPUT);
}

void loop(){
pulsador = digitalRead(2);
if (pulsador == HIGH){
contador = 1 - contador;
delay(200);
}

if (contador == 1) {
digitalWrite(3, HIGH);
}
else {
digitalWrite(3,LOW);
}
}
 Lab. N° 10 Programación Básica del Arduino

Podemos observar que si mantenemos presionado el pulsador el led se prende,

pero si lo soltamos se apaga.

Podemos observar que al presionar una vez el pulsador el led se queda encendido
indefinidamente y solo se apaga si se vuelve a presionar.
 Lab. N° 10 Programación Básica del Arduino

Ejercicio 6 (Reto Tecsup): Utilizando el Tinkercad, monte el circuito eléctrico en el protoboard tal como se
muestra en la figura de abajo, compilar, analizar y comentar lo que sucede.

● Realizar un programa tal que al mantener presionado un pulsador se observe una cuenta
ascendente de 0 a 9 de forma cíclica en el display de 7 segmentos cátodo común. Con el otro
pulsador se debe observar una cuenta descendente de 9 a 0 de forma cíclica siempre y cuando
el pulsador se mantenga presionado. La cuenta ascendente o descendente debe verse en
intervalos de 500 ms. Colocar evidencia del programa realizado con su respectivo comentario y
análisis. Colocar evidencia de la simulación realizada en el TINKERCAD.

COMENTARIO: Este fue el ejercicio que me presento más dificultad de todos

ya que se debía combinar dos de los ejercicios antes vistos, funciona de la
siguiente forma:

 Al mantener presionado el primer pulsador el display empezará a llevar

una cuenta ascendente de 0 a 9, pero al dejar de pulsarlo se detendrá
el conteo.

 Al mantener presionado el segundo pulsador el display empezará una

cuenta descendente de 9 a 0, pero al dejar de pulsarlo se detendrá el
conteo.
 Lab. N° 10 Programación Básica del Arduino

//Contador ascendente y descendente case 5: void cuatro(){

cinco(); digitalWrite(a, 0);//4
int tiempo = 500; break; digitalWrite(b, 1);
int puls1 = 3; case 6: digitalWrite(c, 1);
int puls2 = 2; seis(); digitalWrite(d, 0);
int a = 9; //A break; digitalWrite(e, 0);
int b = 10;//B case 7: digitalWrite(f, 1);
int c = 6; //C siete(); digitalWrite(g, 1);
int d = 5; //D break; delay(tiempo);
int e = 4; //E case 8: }
int f = 8; //F ocho(); void cinco(){
int g = 7; //G break; digitalWrite(a, 1);//5
int value = 0; case 9: digitalWrite(b, 0);
nueve(); digitalWrite(c, 1);
void setup(){ break; digitalWrite(d, 1);
} digitalWrite(e, 0);
pinMode(puls1,INPUT); } digitalWrite(f, 1);
pinMode(puls2,INPUT); void cero(){ digitalWrite(g, 1);
pinMode(a,OUTPUT); digitalWrite(a, 1);//0 delay(tiempo);
pinMode(b,OUTPUT); digitalWrite(b, 1); }
pinMode(c,OUTPUT); digitalWrite(c, 1); void seis(){
pinMode(d,OUTPUT); digitalWrite(d, 1); digitalWrite(a, 1);//6
pinMode(e,OUTPUT); digitalWrite(e, 1); digitalWrite(b, 0);
pinMode(f,OUTPUT); digitalWrite(f, 1); digitalWrite(c, 1);
pinMode(g,OUTPUT); digitalWrite(g, 0); digitalWrite(d, 1);
delay(tiempo); digitalWrite(e, 1);
} } digitalWrite(f, 1);
void loop(){ void uno(){ digitalWrite(g, 1);
digitalWrite(a, 0);//1 delay(tiempo);
if(digitalRead(puls1)){ digitalWrite(b, 1);
digitalWrite(c, 1); }
value++; digitalWrite(d, 0); void siete(){
if(value>9){ digitalWrite(e, 0); digitalWrite(a, 1);//7
value = 0; digitalWrite(f, 0); digitalWrite(b, 1);
} digitalWrite(g, 0); digitalWrite(c, 1);
Serial.println(value); delay(tiempo); digitalWrite(d, 0);
delay(500); } digitalWrite(e, 0);
} void dos(){ digitalWrite(f, 0);
if(digitalRead(puls2)){ digitalWrite(a, 1);//2 digitalWrite(g, 0);
digitalWrite(b, 1); delay(tiempo);
value--; digitalWrite(c, 0); }
if(value<0){ digitalWrite(d, 1); void ocho(){
value =9; digitalWrite(e, 1); digitalWrite(a, 1);//8
} digitalWrite(f, 0); digitalWrite(b, 1);
Serial.println(value); digitalWrite(g, 1); digitalWrite(c, 1);
delay(500); delay(tiempo); digitalWrite(d, 1);
} } digitalWrite(e, 1);
switch(value){ void tres(){ digitalWrite(f, 1);
digitalWrite(a, 1);//3 digitalWrite(g, 1);
case 0: digitalWrite(b, 1); delay(tiempo);
cero(); digitalWrite(c, 1);
break; digitalWrite(d, 1); }
case 1: digitalWrite(e, 0); void nueve(){
uno(); digitalWrite(f, 0); digitalWrite(a, 1);//9
break; digitalWrite(g, 1); digitalWrite(b, 1);
case 2: delay(tiempo); digitalWrite(c, 1);
dos(); } digitalWrite(d, 0);
break; digitalWrite(e, 0);
case 3: digitalWrite(f, 1);
tres(); digitalWrite(g, 1);
break; delay(tiempo);
case 4:
cuatro(); }
break;
 Lab. N° 10 Programación Básica del Arduino

● Modificar el programa anterior para que se active el LED verde sólo cuando se vea el número 9
en el display de 7 segmentos y el LED rojo solo cuando se vea el número 0. Colocar evidencia
del programa realizado con su respectivo comentario y análisis. Colocar evidencia de la
simulación realizada en el TINKERCAD.

Este ejercicio del reto tecsup fue sencillo ya que, solo se modificó el programa
anterior, para que cuando en el display se muestre el 0 se encienda el led rojo y
se apague al cambiar de numero; también se modificó, para que cuando el display
muestre el 9 se encienda el led verde y se apague al cambiar de número.
 Lab. N° 10 Programación Básica del Arduino

//Contador ascendente y descendente }

con indicador de luz led case 4:
cuatro(); void cuatro(){
break; digitalWrite(a, 0);//4
int tiempo = 500; digitalWrite(b, 1);
int puls1 = 3; case 5:
cinco(); digitalWrite(c, 1);
int puls2 = 2; digitalWrite(d, 0);
int led1 = 12; break;
case 6: digitalWrite(e, 0);
int led2 = 13; digitalWrite(f, 1);
int a = 9; //A seis();
break; digitalWrite(g, 1);
int b = 10;//B delay(tiempo);
int c = 6; //C case 7:
siete(); }
int d = 5; //D void cinco(){
int e = 4; //E break;
case 8: digitalWrite(a, 1);//5
int f = 8; //F digitalWrite(b, 0);
int g = 7; //G ocho();
break; digitalWrite(c, 1);
int value = 0; digitalWrite(d, 1);
case 9:
nueve(); digitalWrite(e, 0);
void setup(){ digitalWrite(f, 1);
break;
} digitalWrite(g, 1);
pinMode(puls1 ,INPUT); delay(tiempo);
pinMode(puls2 ,INPUT); }
void cero(){ }
pinMode(led1 , OUTPUT); void seis(){
pinMode(led2 , OUTPUT); digitalWrite(a, 1);//6
pinMode(a ,OUTPUT); digitalWrite(a, 1);//0
digitalWrite(b, 0);
pinMode(b ,OUTPUT); digitalWrite(c, 1);
pinMode(c ,OUTPUT); digitalWrite(b, 1);
digitalWrite(c, 1); digitalWrite(d, 1);
pinMode(d ,OUTPUT); digitalWrite(e, 1);
pinMode(e ,OUTPUT); digitalWrite(d, 1);
digitalWrite(e, 1); digitalWrite(f, 1);
pinMode(f ,OUTPUT); digitalWrite(g, 1);
pinMode(g ,OUTPUT); digitalWrite(f, 1);
digitalWrite(g, 0); delay(tiempo);
} digitalWrite(led1, HIGH);
delay(tiempo); }
void loop(){ void siete(){
digitalWrite(led1, LOW);
digitalWrite(a, 1);//7
if(digitalRead(puls1)){ digitalWrite(b, 1);
}
void uno(){ digitalWrite(c, 1);
value++; digitalWrite(d, 0);
if(value>9){ digitalWrite(a, 0);//1
digitalWrite(b, 1); digitalWrite(e, 0);
value = 0; digitalWrite(f, 0);
} digitalWrite(c, 1);
digitalWrite(d, 0); digitalWrite(g, 0);
Serial.println(value); delay(tiempo);
delay(500); digitalWrite(e, 0);
digitalWrite(f, 0); }
} void ocho(){
if(digitalRead(puls2)){ digitalWrite(g, 0);
delay(tiempo); digitalWrite(a, 1);//8
} digitalWrite(b, 1);
value--; digitalWrite(c, 1);
if(value<0){ void dos(){
digitalWrite(a, 1);//2 digitalWrite(d, 1);
value =9; digitalWrite(e, 1);
} digitalWrite(b, 1);
digitalWrite(c, 0); digitalWrite(f, 1);
Serial.println(value); digitalWrite(g, 1);
delay(500); digitalWrite(d, 1);
digitalWrite(e, 1); delay(tiempo);
}
switch(value){ digitalWrite(f, 0);
digitalWrite(g, 1); }
case 0: void nueve(){
cero(); delay(tiempo);
} digitalWrite(led2,HIGH);
break; digitalWrite(a, 1);//9
case 1: void tres(){
digitalWrite(a, 1);//3 digitalWrite(b, 1);
uno(); digitalWrite(c, 1);
break; digitalWrite(b, 1);
digitalWrite(c, 1); digitalWrite(d, 0);
case 2: digitalWrite(e, 0);
dos(); digitalWrite(d, 1);
digitalWrite(e, 0); digitalWrite(f, 1);
break; digitalWrite(g, 1);
case 3: digitalWrite(f, 0);
digitalWrite(g, 1); delay(tiempo);
tres(); digitalWrite(led2, LOW);
break; delay(tiempo);
}
 Lab. N° 10 Programación Básica del Arduino

● Realizar un programa tal que cuando se presione una sola vez un pulsador el LED de color verde
debe parpadear 10 veces a intervalos de 250 ms. Cuando se presione una sola vez el otro pulsador
el LED de color rojo debe parpadear 15 veces a intervalos de 150 ms. Colocar evidencia del
programa realizado con su respectivo comentario y análisis. Colocar evidencia de la simulación
realizada en el TINKERCAD.

Este ejercicio fue complicado ya que, se necesitó crear un nuevo programa, así como
de mucha investigación para poder culminarlo, este consiste en que al presionar uno
de los pulsadores una sola vez uno de los led debe de parpadear en un determinado
intervalo y número veces, lo mismo sucederá con el otro led.
 Lab. N° 10 Programación Básica del Arduino

//bucle de led intermitente

int puls1 = 3;
int led1 = 12;
int value = 0;//estado del pulsador1
int puls2 = 2;
int led2 = 13;
int value1 = 0;//estado del pulsador2

void setup() {
pinMode(led1, OUTPUT);
pinMode(puls1, INPUT);
pinMode(led2, OUTPUT);
pinMode(puls2, INPUT);
}

void loop() {
value = digitalRead(puls1);

if (value == HIGH) {
for (int x = 0; x < 15; x++) {
digitalWrite(led1, HIGH);
delay(150);
digitalWrite(led1, LOW);
delay(150);
}
}
value1 = digitalRead(puls2);

if (value1 == HIGH) {
for (int x = 0; x < 10; x++) {
digitalWrite(led2, HIGH);
delay(250);
digitalWrite(led2, LOW);
delay(250);
}
}
}
 Lab. N° 10 Programación Básica del Arduino

Observaciones:

 Se realizó un contador en un display usando arduino

 Se observo que el termino HIGH o 1 representan los niveles de

salida altos o 5V

 Se observo que el termino LOW o 0 representan los niveles de

salida bajos o 0V

 Se observaron diversos puertos a tierra en la placa controladora

 Se ve que el delay es una función que hace que el procesador

espere, es usado para determinar intervalos de encendido y
apagado

Conclusiones:

 Se llegó a la conclusión que una sola letra o signo mal colocado

puede alterar de gran manera la configuración de un circuito

 El termino int sirve para declarar una variable

 El display tiene diversas configuraciones según las variables que se

le den

 El microcontrolador arduino permite la realización de circuitos de

manera rápida y concisa

 La declaración for se usa para repetir un bloque de sentencias

encerradas entre llaves un número determinado de veces (se usó el
termino en uno de los ejercicios del reto tecsup)

Bibliografía

1. https://www.youtube.com/watch?v=eTUkvDe1i6Y

2. https://forum.arduino.cc/t/encender-y-apagar-un-led-3-veces-al-
pulsar-un-pulsador/301091/12