a
PROGRAMACION DE
SEMAFOROS EN UN
CRUCE DE CALLES
Año 2024
Comisión 2
Carrera: tecnicatura superior en mecatrónica
Asignatura: mecatrónica
Docente/s: CABALLERO, Iván
Integrantes:
VERA, Ezequiel Martin
SALAS, Dante Gustavo
QUIPILDOR, Andrea Belén
Mediante este informe presentaremos un pequeño proyecto de un “SEMAFORO
INTELIGENTE” con “ARDUINO” el cual este permite el paso más rápido de los automóviles. En
nuestro caso enfocado al cruce de calles con sus respectivos semáforos
OBJETIVOS
Objetivo General
Familiarizar el lenguaje ARDUINO con el fin de usar estas herramientas para la
elaboración de proyectos.
Objetivo Especifico
Desarrollar un proyecto realizado con materiales electrónicos.
Mejorar el proceso electrónico.
Familiarizar y conocer el lenguaje ARDUINO.
MARCO TEÓRICO
Arduino
Características técnicas del ARDUINO UNO
Arduino es una placa con un microcontrolador de la marca Atmel y con toda la circuitería de
soporte, que incluye, reguladores de tensión, un puerto USB (En los últimos modelos, aunque
el original utilizaba un puerto serie) conectado a un módulo adaptador USB-Serie que permite
programar el microcontrolador desde cualquier PC de manera cómoda y también hacer
pruebas de comunicación con el propio chip.
Un Arduino dispone de 14 pines que pueden configurarse como entrada o salida y a los que
puede conectarse cualquier dispositivo que sea capaz de transmitir o recibir señales digitales
de 0 y 5 V.
También dispone de entradas y salidas analógicas. Mediante las entradas analógicas podemos
obtener datos de sensores en forma de variaciones continuas de un voltaje. Las salidas
analógicas suelen utilizarse para enviar señales de control en forma de señales PWM.
Arduino UNO tiene dos variantes, la Arduino UNO convencional y la Arduino UNO SMD. La
única diferencia entre ambas es el tipo de microcontrolador que montan.
• La primera es un microcontrolador Atmega en formato DIP.
• Y la segunda dispone de un microcontrolador en formato SMD.
Nosotros nos decantaremos por la primera porque nos permite programar el chip sobre la
propia placa y después integrarlo en otros montajes.
Arduino UNO con microcontrolador en formato DIP Arduino UNO con microcontrolador en
formato SMD Entradas y salidas:
Cada uno de los 14 pines digitales se puede usar como entrada o como salida. Funcionan a 5V,
cada pin puede suministrar hasta 40 mA. La intensidad máxima de entrada también es de 40
mA.
Cada uno de los pines digitales dispone de una resistencia de pull-up interna de entre 20KΩ y
50 KΩ que está desconectada, salvo que nosotros indiquemos lo contrario.
Arduino también dispone de 6 pines de entrada analógicos que trasladan las señales a un
conversor analógico/digital de 10 bits.
Pines especiales de entrada y salida:
• RX y TX: Se usan para transmisiones serie de señales TTL.
• Interrupciones externas: Los pines 2 y 3 están configurados para generar una
interrupción en el atmega. Las interrupciones pueden dispararse cuando se encuentra un
valor bajo en estas entradas y con flancos de subida o bajada de la entrada.
• PWM: Arduino dispone de 6 salidas destinadas a la generación de señales PWM de
hasta
8 bits.
• SPI: Los pines 10, 11, 12 y 13 pueden utilizarse para llevar a cabo comunicaciones SPI,
que permiten trasladar información full dúplex en un entorno Maestro/Esclavo.
• I2C: Permite establecer comunicaciones a través de un bus I2C. El bus I2C es un producto
de Phillips para interconexión de sistemas embebidos. Actualmente se puede encontrar
una gran diversidad de dispositivos que utilizan esta interfaz, desde pantallas LCD,
memorias EEPROM, sensores...
Alimentación de un Arduino
Puede alimentarse directamente a través del propio cable USB o mediante una fuente de
alimentación externa, como puede ser un pequeño transformador o, por ejemplo, una pila de
9V. Los límites están entre los 6 y los 12 V. Como única restricción hay que saber que, si la
placa se alimenta con menos de 7V, la salida del regulador de tensión a 5V puede dar menos
que este voltaje y si sobrepasamos los 12V, probablemente dañaremos la placa.
La alimentación puede conectarse mediante un conector de 2,1mm con el positivo en el centro
o directamente a los pines Vin y GND marcados sobre la placa.
Hay que tener en cuenta que podemos medir el voltaje presente en el jack directamente desde
Vin. En el caso de que el Arduino esté siendo alimentado mediante el cable USB, ese voltaje no
podrá monitorizarse desde aquí.
Resumen de características Técnicas
Microcontrolador Atmega328
Voltaje de operación 5V
Voltaje de entrada 7 – 12V
(Recomendado)
Voltaje de entrada (Límite) 6 – 20V
Pines para entrada- salida 14 (6 pueden usarse como salida de
digital. PWM)
Pines de entrada analógica. 6
Corriente continua por pin IO 40 mA
Corriente continua en el pin 50 mA
3.3V
Memoria Flash 32 KB (0,5 KB ocupados por el
bootloader)
SRAM 2 KB
EEPROM 1 KB
Frecuencia de reloj 16 MHz
CALCULO DE RESISTENCIA LIMITADORA PARA EL LED
Los diodos LED son seguramente la forma más popular de señalización de estados en los
equipos electrónicos. Veremos la manera de sacar todo el provecho posible a estos coloridos
componentes.
Para que un LED funcione, necesitamos que una corriente lo atraviese. La intensidad de esta
corriente debe ser cuidadosamente calculada, dado que, si excedemos los límites
especificados en la hoja de datos del componente, este se destruirá. La lista siguiente nos da
una idea de que tensión aproximada necesita la juntura de los Leds de colores comunes para
funcionar
La corriente que debe atravesar el LED depende del tipo de componente, pero se puede
generalizar un valor entre 10mA y 30mA.
Correspondiendo el primer valor a la corriente mínima para que encienda, con vida útil muy
larga.
El segundo valor a la corriente máxima que soporta, con vida útil bastante más corta, corriente
mayor a ésta el componente se inutiliza
Por lo general se toma un valor medio de 20mA (0,02A) con el cuál se logra un buen brillo con
una vida útil larga
Para limitar la corriente que circula por el LED, lo más usual, es colocar un resistor en serie con
él.
Una resistencia en serie con el LED limita la corriente que lo atraviesa.
El cálculo del valor de esta resistencia es muy sencillo, y solo implica el uso de la ley de ohm.
Debemos restar la tensión del LED a la tensión de la fuente, y dividir el resultado por la
corriente que deseamos atraviese el componente. Si usamos las unidades correctas (tensiones
en Volts y corrientes en Amperes), el resultado estará expresado en Ohm.
5 v−1 , 9 v
Rl=
1 0 mA
Rl=310 Ω valor comercial 330 Ω
Como el valor comercial más próximo es 330 Ω
MATERIALES EMPLEADOS
- Arduino uno
- 12 leds rojos
- 4 leds amarillos
- 12 leds verdes
- Cables conectores
- Protoboard
- 28 resistencias según el valor calculado
- 1 mts de caño de cobre 3/16”
- 0,50mts de termo contraíble
CÓDIGO
//definimos los nombres de los pines y variables
#define amarillo1 12
#define verde1 11
#define rojo2 10
#define amarillo2 9
#define verde2 8
#define rojo3 7
#define amarillo3 6
#define verde3 5
#define rojo4 4
#define amarillo4 3
#define verde4 2
#define rp1 1
#define vp1 0
#define rp2 A0
#define vp2 A1
#define rp3 A2
#define vp3 A3
#define rp4 A4
#define vp4 A5
int i=0, a=0, b=0, c=0,d=0;
void setup() {
//definimos los pines de salida
pinMode(rojo1, OUTPUT);
pinMode(rojo2, OUTPUT);
pinMode(rojo3, OUTPUT);
pinMode(rojo4, OUTPUT);
pinMode(amarillo1, OUTPUT);
pinMode(amarillo2, OUTPUT);
pinMode(amarillo3, OUTPUT);
pinMode(amarillo4, OUTPUT);
pinMode(verde1, OUTPUT);
pinMode(verde2, OUTPUT);
pinMode(verde3, OUTPUT);
pinMode(verde4, OUTPUT);
pinMode(rp1, OUTPUT);
pinMode(rp2, OUTPUT);
pinMode(rp3, OUTPUT);
pinMode(rp4, OUTPUT);
pinMode(vp1, OUTPUT);
pinMode(vp2, OUTPUT);
pinMode(vp3, OUTPUT);
pinMode(vp4, OUTPUT);
parpadeo_amarillos(); //iniciamos con el parpadeo de las luces amarillas
}
void loop(){
//llamado de funciones. comienzo de la secuencia
semaforo1();
semaforo2();
semaforo3();
semaforo4();
}
void parpadeo_amarillos(){
for (i = 1; i <= 5; i += 1) { //ciclo for para el parpadeo de luces
digitalWrite(12, HIGH);
digitalWrite(9, HIGH);
digitalWrite(6, HIGH);
digitalWrite(3, HIGH);
delay(1000);
digitalWrite(12, LOW);
digitalWrite(9, LOW);
digitalWrite(6, LOW);
digitalWrite(3, LOW);
delay(1000);
}
}
void semaforo1(){//secuencia semaforo1
digitalWrite(rp1, HIGH);
digitalWrite(rojo1, HIGH);
digitalWrite(amarillo1, HIGH);
digitalWrite(rojo2, HIGH);
digitalWrite(rojo3, HIGH);
digitalWrite(rojo4, HIGH);
digitalWrite(rp1, HIGH);
digitalWrite(rp2, HIGH);
digitalWrite(rp3, HIGH);
digitalWrite(rp4, HIGH);
delay(1000);
digitalWrite(rojo1, LOW);
digitalWrite(amarillo1, LOW);
digitalWrite(verde1, HIGH);
digitalWrite(vp1, LOW);
digitalWrite(rp2, LOW);
digitalWrite(vp2, HIGH);
digitalWrite(rp3, LOW);
digitalWrite(vp3, HIGH);
digitalWrite(rp4, LOW);
digitalWrite(vp4, HIGH);
delay(16000);
for (a = 1; a <=5; a += 1) {
digitalWrite(verde1, LOW);
digitalWrite(vp2, LOW);
delay(1000);
digitalWrite(verde1, HIGH);
digitalWrite(vp2, HIGH);
delay(1000);
}
digitalWrite(amarillo1, HIGH);
digitalWrite(verde1, LOW);
digitalWrite(vp2, LOW);
delay(1000);
digitalWrite(amarillo1, LOW);
digitalWrite(rp2, HIGH);
digitalWrite(rojo1, HIGH);
delay(2000);
}
void semaforo2(){//secuencia semaforo2
digitalWrite(amarillo2, HIGH);
delay(1000);
digitalWrite(rojo1,HIGH);
digitalWrite(rojo2, LOW);
digitalWrite(amarillo2, LOW);
digitalWrite(verde2, HIGH);
digitalWrite(verde1, LOW);
digitalWrite(vp1, HIGH);
digitalWrite(rp1, LOW);
digitalWrite(vp2, LOW);
delay(16000);
for (b = 1; b <=5; b += 1) {
digitalWrite(8, LOW);
digitalWrite(vp3, LOW);
delay(1000);
digitalWrite(8, HIGH);
digitalWrite(vp3, HIGH);
delay(1000);
}
digitalWrite(amarillo2, HIGH);
digitalWrite(verde2, LOW);
digitalWrite(vp3, LOW);
delay(1000);
digitalWrite(amarillo2, LOW);
digitalWrite(rp3, HIGH);
digitalWrite(rojo2, HIGH);
delay(2000);
}
void semaforo3(){//secuencia semaforo3
digitalWrite(amarillo3, HIGH);
digitalWrite(rojo3, LOW);
delay(1000);
digitalWrite(amarillo3, LOW);
digitalWrite(verde3, HIGH);
digitalWrite(vp2, HIGH);
digitalWrite(rp2, LOW);
digitalWrite(vp3, LOW);
delay(16000);
for (c = 1; c <=5; c += 1) {
digitalWrite(5, LOW);
digitalWrite(vp4, LOW);
delay(1000);
digitalWrite(5, HIGH);
digitalWrite(vp4, HIGH);
delay(1000);
}
digitalWrite(verde3, LOW);
digitalWrite(vp4, LOW);
delay(1000);
digitalWrite(amarillo3, HIGH);
digitalWrite(rp4, HIGH);
delay(1000);
digitalWrite(amarillo3, LOW);
digitalWrite(rojo3, HIGH);
delay(2000);
}
void semaforo4(){ //secuencia semaforo4
digitalWrite(amarillo4, HIGH);
delay(1000);
digitalWrite(rojo3,HIGH);
digitalWrite(amarillo4, LOW);
digitalWrite(rojo4, LOW);
digitalWrite(verde4, HIGH);
digitalWrite(rp3, LOW);
digitalWrite(vp3, HIGH);
delay(16000);
for (d = 1; d <=5; d += 1) {
digitalWrite(2, LOW);
digitalWrite(vp1, LOW);
delay(1000);
digitalWrite(2, HIGH);
digitalWrite(vp1, HIGH);
delay(1000);
}
digitalWrite(verde4, LOW);
digitalWrite(vp1, LOW);
delay(1000);
digitalWrite(amarillo4, HIGH);
digitalWrite(rp1, HIGH);
delay(1000);
digitalWrite(amarillo4, LOW);
digitalWrite(rojo4, HIGH);
delay(2000);
}
CIRCUITO DE PRUEBA
armamos el circuito en la protoboard para hacer las pruebas correspondientes del código
CONCLUSIONES
- Se observo el funcionamiento de un semáforo con la programación en Arduino a través
del encendido de un circuito con diodos leds.
- Mediante la programación de leds, se evidencio a prueba y error que la complejidad de
la programación se reducía mediante la practica
- Se pudo poner en practica lo aprendido en clases con el tema diodos
