DEPARTAMENTO DE CIENCIAS DE LA ENERGÍA

MECÁNICA
CARRERA DE INGENIERÍA MECATRÓNICA

ASIGNATURA: TECNOLOGIAS DE SOFTWARE MCT

TEMA: ENTRADA Y SALIDAS DIGITALES

PROYECTO DEL SEGUNDO PARCIAL

CALIFICACIÓN:

NRC: 4531

INTEGRANTES:

Dutan Ariel

Profesor: Ing. David Loza

Fecha: 6 de marzo del 2021

Sangolquí – Ecuador
 1. TEMA:
ENTRADAS Y SALIDAS DIGITALES EN ARDUINO
2. OBJETIVOS:
- Implementar los conocimientos sobre entradas y salidas digitales recibidos en
clases por medio de la resolución de retos de programación.
- Desarrollar de manera eficiente y efectiva los retos planteados de semáforos.
- Practicar el entendimiento y uso de entradas y salidas digitales.
3. EQUIPO Y MATERIALES
- Placa de Arduino 1
- Cables macho macho (x20)
- Luces led de color verde, amarillo y rojo (x3 cada uno)
- Protoboard
- Resistencias de 220 ohms
- Software de arduino
4. MARCO TEÓRICO
4.1. Entradas y salidas digitales
Una señal digital es un tipo de señal generada por algún tipo de fenómeno
electromagnético en que cada signo que codifica el contenido de la misma puede ser
analizado en término de algunas magnitudes que representan valores discretos, en lugar
de valores dentro de un cierto rango. Por ejemplo, el interruptor de la luz sólo puede tomar
dos valores o estados: abierto o cerrado, o la misma lámpara: encendida o apagada.
4.2 Arduino
Arduino es una compañía de desarrollo de software y hardware libres, así como una
comunidad internacional que diseña y manufactura placas de desarrollo de hardware
para construir dispositivos digitales y dispositivos interactivos que puedan detectar y
controlar objetos del mundo real.
4.3 Conexión de PULLUP

La acción de Pull-Up en electrónica se asigna a la acción de elevar una tensión de entrada

o salida que tiene un circuito lógico mientras éste está en reposo.
Esto evita que se hagan lecturas erróneas si este pin ya no tiene nada conectado o no está
recibiendo una señal.
La resistencia se conecta a la fuente de alimentación.
Cuando el interruptor está abierto la corriente va desde la fuente de alimentación al Vout
dando un valor lógico de HIGH y cuando el interruptor está cerrado la corriente se mueve
hacia tierra (GND) dejando un 0 (LOW) en el pin.

5. PROCEDIMIENTO:
Reto 1:
Programar un sistema, que ponga en funcionamiento secuencial un semáforo de tres luces
con el uso de un Arduino.
Código de Arduino:
int pin_rojo=8;
int pin_amarillo=10;
int pin_verde=9;
int t_verde=22000;
int t_amarillo=7000;
int t_rojo=25000;
void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
delay(100);
 pinMode(pin_rojo, OUTPUT);
pinMode(pin_amarillo, OUTPUT);
pinMode(pin_verde, OUTPUT);

// posicion inicial
digitalWrite(pin_rojo,LOW);
digitalWrite(pin_amarillo,LOW);
digitalWrite(pin_verde,HIGH);
delay(1000);
}
void loop() {
digitalWrite(pin_verde,HIGH);
delay(t_verde);
digitalWrite(pin_verde, LOW);
delay(10);

digitalWrite(pin_amarillo,HIGH);
delay(t_amarillo);
digitalWrite(pin_amarillo, LOW);
delay(10);

digitalWrite(pin_rojo,HIGH);
delay(t_rojo);
digitalWrite(pin_rojo, LOW);
delay(10);
}
Diagrama y explicación:

Este diagrama indica como se comporta el semáforo, además resume el funcionamiento

del código anterior. Se comienza en luz verde, esta dura 22 segundos, luego empieza la
luz amarilla, que dura 7 segundos, y finalmente la luz roja que dura 25 segundos. Una
ves completado el patrón se repite el bucle.
Reto 2:
Programar un sistema, que ponga en funcionamiento secuencial un semáforo de tres
luces con el uso de un Arduino, para este caso la luz amarilla debe parpadear 5 veces
antes de cambiar a rojo.
Código de programación:
int pin_rojo=8;
int pin_amarillo=10;
int pin_verde=9;
int t_verde=22000;
int t_amarillo=7000;
int t_rojo=25000;
void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
delay(100);

pinMode(pin_rojo, OUTPUT);
pinMode(pin_amarillo, OUTPUT);
pinMode(pin_verde, OUTPUT);

// posicion inicial
digitalWrite(pin_rojo,LOW);
digitalWrite(pin_amarillo,LOW);
digitalWrite(pin_verde,HIGH);
delay(1000);
}

void loop() {
digitalWrite(pin_verde,HIGH);
delay(t_verde);
digitalWrite(pin_verde, LOW);
delay(10);
digitalWrite(pin_amarillo,HIGH);
 delay(t_amarillo*0.75);
for (int i=0;i<6;i++){
digitalWrite(pin_amarillo,HIGH);
delay((t_amarillo*0.25)/10);
digitalWrite(pin_amarillo, LOW);
delay((t_amarillo*0.25)/10);
}
digitalWrite(pin_rojo,HIGH);
delay(t_rojo);
digitalWrite(pin_rojo, LOW);
delay(10);
}
Diagrama y explicación:

Este diagrama indica cómo se comporta el semáforo, además resume el funcionamiento

del código anterior. Se comienza en luz verde, esta dura 22 segundos, luego empieza la
luz amarilla, que dura 7 segundos en total, pero se divide en dos etapas, la primera que es
la de mayor duración y es equivalente al 75% de la duración total, mantiene la luz amarilla
encendida de manera seguida, luego va la segunda etapa que dura el tiempo restante y
hace parpadear a la luz amarilla en intervalos de tiempo constante, y finalmente la luz
roja que dura 25 segundos. Una vez completado el patrón se repite el bucle.
Reto 3:
Implementar un programa, que ponga en funcionamiento dos semáforos (un semáforo
para los carros (3 luces) y otro para el peatón (2 luces) con una secuencia que cambiara
su estado al presionar un botón de paso peatonal.
Código de programación:
int boton1=8;
int verde_c=2;
int ama_c=3;
int rojo_c=4;
int verde_p=6;
int rojo_p=7;
int t_verde=22000;
int t_amarillo=7000;
int t_rojo=25000;
int tiempo_espera=10;
byte estado_anterior1=HIGH;
unsigned long tiempo_pulsador1;
void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
delay(100);

pinMode(boton1, INPUT_PULLUP);
pinMode(verde_c, OUTPUT);
pinMode(ama_c, OUTPUT);
pinMode(rojo_c, OUTPUT);
pinMode(verde_p, OUTPUT);
pinMode(rojo_p, OUTPUT);
digitalWrite(verde_c,LOW);
digitalWrite(ama_c,LOW);
digitalWrite(rojo_c,LOW);
digitalWrite(verde_p,LOW);
digitalWrite(rojo_p,LOW);
}

void loop() {
semaforo_normal();
}

void semaforo_normal() {
for (int j=0;j<1;j++){
int bandera=1;
for (int i=0;i<101;i++){
digitalWrite(rojo_c,LOW);
 digitalWrite(verde_c,HIGH);
digitalWrite(rojo_p,HIGH);
delay(t_verde/100);
//
int estado1=digitalRead(boton1);
if(estado1!=estado_anterior1){
if (millis()-tiempo_pulsador1 >= tiempo_espera){
tiempo_pulsador1=millis();
estado_anterior1=estado1;
if (estado1==LOW){
bandera=0;
digitalWrite(verde_c,LOW);
digitalWrite(ama_c,HIGH);
delay(3000);
digitalWrite(ama_c,LOW);
digitalWrite(rojo_c,HIGH);
delay(1000);
digitalWrite(rojo_p,LOW);
digitalWrite(verde_p,HIGH);
delay(t_rojo*0.75);
for (int i=0;i<11;i++){
digitalWrite(verde_p,HIGH);
delay((t_rojo*0.25)/(20+2*i));
digitalWrite(verde_p, LOW);
delay((t_rojo*0.25)/(20+2*i));
}
break;
}
}
}
//
}
if (bandera==0){
 digitalWrite(rojo_p,HIGH);
delay(1000);
break;
}
digitalWrite(verde_c,LOW);
delay(10);
digitalWrite(ama_c,HIGH);
delay(t_amarillo);
digitalWrite(ama_c,LOW);
delay(10);
digitalWrite(rojo_c,HIGH);
delay(1000);
digitalWrite(rojo_p,LOW);
digitalWrite(verde_p,HIGH);
delay(t_rojo*0.75);
for (int i=0;i<11;i++){
digitalWrite(verde_p,HIGH);
delay((t_rojo*0.25)/(20+2*i));
digitalWrite(verde_p, LOW);
delay((t_rojo*0.25)/(20+2*i));
}
digitalWrite(verde_p,LOW);
digitalWrite(rojo_p,HIGH);
delay(1000);
digitalWrite(rojo_c,LOW);
}
}
Diagrama y explicación:
Esta secuencia cuenta con dos semáforos.
El semáforo de carros comienza en verde y el de peatones en rojo, después de 22 segundos
el semáforo de carros cambia a amarillo y el de peatones se mantiene en verde, aquí se
puede pulsar el botón, pero se explicará después. Después de la luz amarilla de carros se
enciende la luz roja de los carros, pero la luz roja de peatones se mantiene durante un
segundo mas para mayor seguridad. Después se enciende la luz verde de los peatones y
se mantiene la roja de los carros, los primeros 18.75 segundos de las luz de los peatones
será continua, pero después empezara a parpadear aumentado la frecuencia con cada
parpadeo, son 10 en total. Al final de la luz verde de los peatones se cambia a luz roja de
peatones mientras la luz roja de los carros sigues, dando así un margen de seguridad, si
de ahí se repite el bucle.
El presionado del botón es posible únicamente durante la luz roja de los peatones y la luz
verde de los carros, puesto a que a los peatones no les interesa cambiar de su luz verde a
su luz roja, solo les interesa cambiar de su luz roja a su luz verde para poder cruzar. Dicho
esto, se explicará el funcionamiento, cuando un peatón presione el botón
automáticamente la luz de los carros ser tornara amarilla, avisando a los conductores que
se viene el cambio a rojo, se dará un aviso de 3 segundos en total, pasados los 3 segundos
el color de los carros sea rojo, y después de un segundo los peatones tendrán luz verde,
una ves terminado este cambio comenzara la secuencia nuevamente.

Reto 4:
Implementar un programa, que ponga en funcionamiento un grupo de semáforos con
una secuencia similar a la que se encuentra en los semáforos de la entrada principal de
la universidad.
Código de programación:
int v_1=2;
int a_1=3;
int r_1=4;
int v_2=5;
int a_2=6;
int r_2=7;
int v_3=8;
int a_3=9;
int r_3=10;
int v_4=11;
int a_4=12;
int r_4=13;
int t_v=22000;
int t_a=7000;
int t_r=25000;
void setup() {
Serial.begin(9600);
delay(100);
pinMode(v_1, OUTPUT);
pinMode(a_1, OUTPUT);
pinMode(r_1, OUTPUT);
pinMode(v_2, OUTPUT);
pinMode(a_2, OUTPUT);
pinMode(r_2, OUTPUT);
pinMode(v_3, OUTPUT);
pinMode(a_3, OUTPUT);
pinMode(r_3, OUTPUT);
pinMode(v_4, OUTPUT);
pinMode(a_4, OUTPUT);
pinMode(r_4, OUTPUT);
 digitalWrite(v_1,HIGH);
digitalWrite(a_1,LOW);
digitalWrite(r_1,LOW);

digitalWrite(v_2,LOW);
digitalWrite(a_2,LOW);
digitalWrite(r_2,HIGH);

digitalWrite(v_3,LOW);
digitalWrite(a_3,LOW);
digitalWrite(r_3,HIGH);

digitalWrite(v_4,HIGH);
digitalWrite(a_4,LOW);
digitalWrite(r_4,LOW);

void loop() {

digitalWrite(v_1,HIGH);
digitalWrite(v_4,HIGH);
digitalWrite(r_2,HIGH);
digitalWrite(r_3,HIGH);
delay(t_v);
digitalWrite(v_1,LOW);
digitalWrite(v_4,LOW);
digitalWrite(a_1,HIGH);
digitalWrite(a_4,HIGH);
delay(t_a);
digitalWrite(a_1,LOW);
digitalWrite(a_4,LOW);
 digitalWrite(r_1,HIGH);
digitalWrite(r_4,HIGH);
delay(1000);
digitalWrite(r_2,LOW);
digitalWrite(r_3,LOW);
digitalWrite(v_2,HIGH);
digitalWrite(v_3,HIGH);
delay(t_v);
digitalWrite(v_2,LOW);
digitalWrite(v_3,LOW);
digitalWrite(a_2,HIGH);
digitalWrite(a_3,HIGH);
delay(t_a);
digitalWrite(a_2,LOW);
digitalWrite(a_3,LOW);
digitalWrite(r_2,HIGH);
digitalWrite(r_3,HIGH);
delay(1000);
digitalWrite(r_1,LOW);
digitalWrite(r_4,LOW);
}
Diagrama y explicación:
La secuencia de semáforos en este caso dura 60 segundos. Y básicamente es lo mismo
que una secuencia de dos semáforos, solo que entre los cambios de luz roja a verde se
tiene un margen de seguridad de 1 segundo.
6. CONCLUSIONES
- Cuando se trata de la vida de las personas es importante siempre mantener
márgenes de seguridad, pues siempre puede haber un peatón o conductor que no
este actuando con la debía precaución
7. RECOMENDACIONES
- Se recomienda que en clase se muestre mucho mas detallado el circuito
implementado, pues es difícil de ver por medio de una reunión virtual.