Semforo

En este nuevo post daremos unas pautas sobre cmo debe estructurarse un
programa en Arduino, tambin veremos cmo son las sentencias bsicas usadas
con esta IDE, cmo cargar nuestro programa a la placa y para finalizar,
realizaremos un ejemplo con el que encenderemos leds con Arduino montando
nuestro propio semforo.

Estructura bsica de los cdigos

Un cdigo Arduino es una serie de comandos de programacin que le dirn a
nuestro microcontrolador como configurarse al iniciarse y qu acciones tiene que
realizar mientras est en funcionamiento. Estos comandos utilizados en Arduino
son sentencias muy fciles e intuitivas.
El bloque de cdigo debe tener 2 partes, o funciones principales, que siempre
debemos incluir.

Ilustracin 1 Partes bsicas de un cdigo

Primero void setup() . Dentro de esta funcin principal escribiremos las
sentencias de configuracin que necesitaremos para que Arduino trabaje
correctamente. stas se ejecutarn al iniciar Arduino y una nica vez. Con ellas,
por ejemplo, asignaremos la caracterstica de entrada/salida a los pines, el modo
de comunicacin serial, activaremos los sensores que vayamos a necesitar,
escribiremos rdenes de inicio del programaetc. Algunas de estas sentencias
pueden ser: pinMode( , ), Serial.begin(), sensors.begin()

La segunda funcin principal es void loop() . sta debe ir siempre despus de

void setup(). En ella escribiremos todas las sentencias, bucles y llamadas a
funciones que necesitemos que nuestro Arduino repita constantemente. Se
escribirn en orden de ejecucin. Ejemplo de stas pueden ser digitalWrite( , ),
Serial.print( ), if( )
Existen otras partes del cdigo que no son obligatorias pero que podemos
necesitar, segn el cdigo lo requiera, para organizarlo todo.
Estas zonas pueden ser un espacio para el ttulo, el autor, libreras, definiciones
(variables que vayamos a usar en el programa), una zona para funciones a las que
el programa ir llamandoCada uno es libre de organizarlo como quiera, pero
cuanto ms ordenado est todo, ms difcil ser perdernos cuando los cdigos se
compliquen.
Abajo podemos ver un ejemplo simple de cmo debe estructurarse un cdigo.

Ilustracin 2 Como debe estructurarse un cdigo

Sentencias bsicas, funciones y libreras

Para poder realizar un cdigo Arduino debemos tener las herramientas con las que
decirle a nuestro microcontrolador que es lo que debe hacer en cada momento.
Estas herramientas son las sentencias y funciones.
Arduino usa una serie de sentencias y comandos bsicos muy sencillitos pero a la
vez muy potentes. Combinndolos crearemos programas para decirle a nuestra
placa que haga prcticamente cualquier cosa que queramos.
Las sentencias se dividen por su manera de funcionar dentro del programa,
pudiendo dividirlas en 3 grades grupos:

Estructurales: Nos dan la forma computacional del cdigo y las

operaciones lgicas a ejecutar. Con stos son con los que le marcamos al
programa qu camino debe seguir el cdigo al ejecutarse y qu
operaciones debe hacer. Algn ejemplo de las ms usadas son if, for, while,
+, -, =, *, /, ==, >, <

Variables: Con stas definiremos qu tipo y qu caractersticas tendrn los

valores que vamos a usar en el cdigo. Pueden ser nmeros, caracteres o
estados. Podemos encontrarnos aqu las sentencias int, float, HIGH, LOW,
char, string, true, false

Funciones: Nos permiten realizar una serie de operaciones concretas y

volver a la zona del cdigo en la que se ejecut. Existen funciones que
estn propiamente definidas ya por Arduino como tales y tambin podemos

crearnos nuestras propias funciones para que sean llamadas en las zonas
de setup o loop cuando lo necesitemos. Son muy tiles cuando
necesitamos realizar un grupo de acciones varias veces en distintas zonas
del cdigo. Tambin es una buena forma de ahorrar lneas y de
organizarse. Ejemplo de funciones tenemos pinMode, digitalWrite, delay,
max, sin, cos, analogWrite
Como explicar qu accin concreta realiza cada sentencia o funcin sera muy
extenso, os dejamos este enlacepara que podis consultarlos. Nosotros iremos
comentando todos los que vayamos usando en nuestros ejemplos.
Otra cosa importante son las libreras. Son una serie de sentencias y funciones
especficas de cada elemento o shield que conectemos a Arduino, que no estn
dentro de las propias de la IDE, y que realizarn acciones especficas de cada uno
facilitndonos mucho la programacin.
Por ltimo nombraremos un par de pequeos detalles necesarios para poder
programar nuestro cdigo. Para que cada sentencia o funcin se ejecute debe
llevar al final de cada orden el signo de puntuacin punto y coma ; y al utilizar la
doble barra // le decimos al cdigo que lo que se escriba a la derecha es un
comentario y que no debe ejecutarlo (Arduino lo colorear en gris). Esto veris que
es muy til

para

explicar que

estamos haciendo en cada momento.

Compilacin y carga.

Una vez que hayamos escrito nuestro cdigo en la IDE Arduino procederemos a
verificar que est correctamente escrito. Para ello pulsamos el botn

arriba a

la izquierda. Arduino leer el texto y nos dir si es correcto o no. Para ello lo que
har ser compilarlo, que significa traducir el cdigo del lenguaje de programacin
a un lenguaje que entienda el microcontrolador directamente.
En el caso de contener un error nos aparecer en la consola una explicacin
orientativa del error. (Ilustracin 5)

Ilustracin 3 Verificando el cdigo

Ilustracin 4 Cdigo correcto

Ilustracin 5 Error en el cdigo. Falta un ";"

Si la compilacin ha sido correcta, ya podremos cargar nuestro programa al

Arduino. Para ello, con la placa conectada por USB, pulsamos el botn de
carga

y esperamos a que termine.

Ilustracin 6 Carga de programa terminada

Ejemplo: Semforo
Como primer proyecto, realizaremos un semforo con unos Leds. Es ideal para
iniciarnos en la programacin y el montaje de circuitos porque, como veris, es
muy

fcil.

Empezaremos nuestro primer proyecto describiendo los elementos que vamos a

necesitar.

1 x Arduino UNO R3

1 x Protoboard

1 x Led rojo 3mm

1 x Led amarillo 3mm

1 x Led verde 3mm

3 x resistencias de 220.

Cables para conectar todo.

Una vez que tenemos todo, hacemos nuestro montaje siguiendo el siguiente
esquema.

Ilustracin 7 Esquema de montaje del semforo

Utilizaremos los pines digitales 2 (rojo), 4 (amarillo) y 7 (verde). Al conectar los

Leds debis tener en cuenta que tienen polaridad, por lo que tenis que colocarlos
bien para que funcionen. En los Leds la patilla corta, o el lado que est achatado,
es el negativo e ir conectado a tierra (GND en la placa) a travs de una
resistencia. La patilla larga, o lado redondeado, es el positivo y se conectar al pin
del Arduino correspondiente.

Ilustracin 8 Protoboard del proyecto semforo

Una vez montado, abriremos nuestro IDE Arduino y escribiremos el programa
(sketch).

/*************/
/* SEMAFORO */
/*************/
/*** Fernando Martinez Mendoza ***/
//** Definiciones **//
int rojo=2;
//definimos el valor del pin para el led rojo
int amarillo=4; //definimos el valor del pin para el led amarillo
int verde=7;
//definimos el valor del pin para el led verde
//** Programa **//
void setup() {
pinMode(verde,OUTPUT); //declaramos el pin verde como salida
pinMode(amarillo,OUTPUT);//declaramos el pin amarillo como salida
pinMode(rojo,OUTPUT); //declaramos el pin rojo como salida
}

void loop() {
digitalWrite(verde,HIGH); //encendemos el led rojo
delay(2000);
//esperamos 2 segundos
digitalWrite(verde,LOW); //apagamos el led rojo
delay(500);
//esperamos medio segundo
digitalWrite(amarillo,HIGH); //encendemos el led amarillo
delay(2000);
//esperamos 2 segundos
digitalWrite(amarillo,LOW); //apagamos el led amarillo
delay(500);
//esperamos medio segundo
digitalWrite(rojo,HIGH); //encendemos el led verde
delay(2000);
//esperamos 2 segundos
digitalWrite(rojo,LOW); //apagamos el led verde
delay(500);
//esperamos medio segundo
}

Con la sentencia int estamos declarando una variable numrica entera, para
poderla

usar

despus

en

nuestro

cdigo.

El comando delay hace que el programa pare un tiempo determinado. ste lo

definiremos,

en

milisegundos,

dentro

de

los

parntesis.

Las funciones pinMode y digitalWrite se explicarn en el siguiente post, salidas,

con detalle.

Cruce de semforos LED

Objetivo: Montar un cruce de semforos con un tiempo de espera de 6

segundos antes del cambio. La secuencia har una espera de 4 segundos en
verde, 2 segundos parpadeando, luego Amarillo y luego Rojo (6 segundos de
nuevo). El botn lo programaremos para que reinicie el contador cambiando de
semforo (similar a cuando pulsamos el botn para cruzar en uno de estos).
Componentes a usar en este tutorial:
2 x Diodo LED Red
2 x Diodo LED Yellow
2 x Diodo LED Green
6 x Resistencia 220 ohmios
1 x Resistencia 10 Kohmios
1 x Arduino UNO
Cables
1 x Pulsador

En la imagen superior tenemos el diagrama del montaje. Podemos identificar

los LEDs, las resistencias y el botn pulsador.
Vamos a pasar a comentar las conexiones:
Para conectar nuestro Arduino UNO a la protoboard
o BreadBoard sacaremos un cable (cable rojo) del PIN 5V hasta nuestra fila
positiva de la protoboard (+) y un cable (cable azul) desde el PIN GND hasta
nuestra fila (-) de la protoboard.
Para evitarnos problemas de conexin haremos ya el puente a mitad de la
protoboard. El cable azul de la imagen conecta la fila negativa para que todos
los pines estn unidos. Nota: esto no es obligado hacerlo pero suele ser til
para evitarnos problemas de montaje.
Ahora que ya tenemos la protoboard preparada para seguir, procederemos a
conectar nuestro botn pulsador. Este componente est dotado de 4
terminales o "patas". Podemos conectarlo como en la imagen haciendo de
puente entre las bandas verticales de la protoboard. A la pata de la izquierda le
conectaremos la resistencia de 10 Kohmios y la resistencia ir conectada a
la fila negativa (GND) de la protoboard mediante un cable.
De la pata de la derecha del pulsador saldr un cable que conectara ste a la
fila positiva de la protoboard (5V).
Seguidamente procederemos a colocar los LEDs en la protoboard. Usando el
polo negativo del LED en la zona vertical de la protoboard y el positivo en la fila
negativa de la protoboard (GND) como indica la imagen. Del polo negativo del
LED deber ir conectado la resistencia de 220 ohmios como muestra la
imagen. Es recomendable que su disposicin tambin haga de puente entre las
columnas verticales de la protoboard.

Una vez tenemos montados y conectados los componentes, tan slo nos
faltarconectar los LEDs y el botn a nuestro Arduino UNO. Estas
conexiones las haremos de la siguiente manera:
Los LEDs los conectaremos desde la salida de la resistencia hacia el
controlador. (ver imagen)
-

LED
LED
LED
LED
LED
LED

Verde (derecha): PIN 2 del Arduino.

Amarillo: PIN 3 (PWM)
Rojo: PIN 4
Verde: PIN 5
Amarillo: PIN 6
Rojo: PIN 7

Por ltimo nos faltar conectar el botn a nuestro controlador. La pata superior
izquierda la conectaremos al PIN 8 del Arduino UNO. Cable negro de la imagen.

Ahora vayamos al programa:

/*
Programa para un par de semaforos que cambian de uno
a otro, y la implementacion de un boton para terminar
el tiempo de la luz verde y pasar al otro.
*/
// Declaramos la variable para el pin del boton
const int button = 8;
void setup() {
// Con un ciclo activamos los pines del 2 al 7 como salidas
for (int pin = 2; pin <= 7; pin++) {
pinMode(pin, OUTPUT);

}
// El pin del boton lo ponemos como entrada
pinMode(button, INPUT);
}
// Funcion para el primer semaforo y sus cambios de estado
void semaphoreOne() {
digitalWrite(2, HIGH);
int count = 0;
while (count < 30) {
// El ciclo esta en espera mientras el boton no es presionado
if (digitalRead(button) == true) {
break;
}
count++;
delay(200);
}
// Programamos el cambio entre semaforos. Cuando el LED tiene la posicion LOW
estara apagado, mientras que si esta en posicion HIGH estada encendido.
digitalWrite(2, LOW);
delay(500);
digitalWrite(2, HIGH);
delay(500);
digitalWrite(2, LOW);
delay(500);
digitalWrite(2, HIGH);
delay(500);
digitalWrite(2, LOW);
delay(500);
digitalWrite(2, HIGH);
delay(500);
digitalWrite(2, LOW);
delay(500);
digitalWrite(2, HIGH);
delay(500);
digitalWrite(2, LOW);
digitalWrite(3, HIGH);
delay(2500);
digitalWrite(3, LOW);
digitalWrite(4, HIGH);
digitalWrite(7, LOW);
// Mandamos a llamar al otro semaforo
semaphoreTwo();
}
// Funcion para el segundo semaforo y sus cambios de estado
void semaphoreTwo() {
digitalWrite(5, HIGH);
int count = 0;
while (count < 30) {
if (digitalRead(button) == true) {
break;
}
count++;
delay(200);

}
digitalWrite(5, LOW);
delay(500);
digitalWrite(5, HIGH);
delay(500);
digitalWrite(5, LOW);
delay(500);
digitalWrite(5, HIGH);
delay(500);
digitalWrite(5, LOW);
delay(500);
digitalWrite(5, HIGH);
delay(500);
digitalWrite(5, LOW);
delay(500);
digitalWrite(5, HIGH);
delay(500);
digitalWrite(5, LOW);
digitalWrite(6, HIGH);
delay(2500);
digitalWrite(6, LOW);
digitalWrite(7, HIGH);
digitalWrite(4, LOW);
// Mandamos a llamar al otro semaforo
semaphoreOne();
}
// Iniciamos nuestro semaforo
void loop() {
// Cambiamos el estado de todos los leds para
// que esten apagados todos al inicio
for (int pin = 2; pin <= 7; pin++) {
digitalWrite(pin, LOW);
}
// Prendemos el verde de un semaforo y el
// rojo del otro semaforo
digitalWrite(2, HIGH);
digitalWrite(7, HIGH);
// Iniciamos el primer semaforo
semaphoreOne();
}

Aqu mostramos un video explicativo con su posterior funcionamiento:

/*Fuente: https://www.youtube.com/watch?v=-xjaqt8HCFM