Variables

Una variable es un espacio de memoria de un sistema con micro al que se le da un nombre, y que contiene un valor, es decir, contiene un dato de un tipo determinado. Ese valor o contenido puede ir cambiando en el transcurso del tiempo, por eso se llama variable. Se almacena en memoria RAM ya que es un contenido que puede ir cambiando.

Hay distintos tipos de variables. Lo más común en Arduino es que una variable contenga un número.

Por ejemplo:

Sea una variable i, que contiene el número entero 3. El nombre de la variable es i, el tipo es int, el valor es 3 (int significa tipo entera en Arduino).

El alcance, ámbito o scope tiene que ver con en que parte del sketch tiene validez la variable, lo más fácil es una variable global que es la que vale para todo el sketch. Es un tema para profundizar.

Declaración o definición de variables

Para poder usar una variable, antes hay que declararla, esto es, decir su nombre y su tipo. Según qué tipo de variable sea, se usan más o menos cantidad de bytes de la memoria RAM para almacenarla.

Una variable puede ser declarada en distintos lugares de un sketch y en función del lugar en donde se lleve a cabo la declaración, esto determinará en qué partes del programa se podrá hacer uso de ella, es lo que se denomina ámbito de la variable o scope. Antes de setup(), arriba de todo se declaran las variables globales (que sirven para todo el programa).

Como se vio antes, también se pueden definir “constantes” que son como variables pero que no pueden cambiar de valor.

¿Qué se declara?: el tipo de variable y el nombre.

El nombre no puede coincidir con el de una palabra reservada (por ej: delay), y tiene que comenzar con una letra, luego letras y/o números. No puede usar como nombre A0, A1, A2, A3, A4, A5 ya que son palabras reservadas que hacen referencia a las entradas analógicas de Arduino.

Algunos tipos posibles de variables en Arduino: int, byte, long.

int: variable entera, puede contener en número entre -32768 y 32767 (16 bits con signo, ocupa dos bytes).

byte: variable tipo byte, puede contener número entre 0 y 255 (8 bits, ocupa un byte).

long: variable entera larga, puede contener un número desde -2147483648 a 2147483647 (32 bits con signo, ocupa cuatro bytes).

Define a las variables i y j de un byte (puede tomar valores desde 0 a 255), si hay varias, como en este caso, se separan con comas.

 

Define la variable canti como un número entero int (puede tomar valores entre -32768 y 32767), luego en el loop() se le asignará valores.

 

Define un valor constante (que no puede cambiar a lo largo del programa) llamado LED1 que luego puedo usarse para hacer referencia a un Led n°1 ubicado en el pin 9. Esto facilita la “legibilidad” del programa porque después podemos llamarlo “LED1” en vez de “9”. veremos ejemplos de declaración de variables.

Ejercicio 10:

Investigá que otros tipos de variables tiene Arduino.

Sistema de numeración

En Arduino los números se pueden expresar en sistema decimal, hexadecimal o binario. Para especificar hexadecimal se usa el prefijo 0x (cero equis), para binario se usa el prefijo B, mientras que no se usa prefijo para número decimal.

Ejemplos:

Uso de variables

En cada momento una variable tiene un valor determinado (que está entre ciertos límites según el tipo de variable). El valor de una variable puede ir cambiando.

Por ejemplo, la variable a es tipo int, entonces puede contener números entre -32768 y 32767. En un determinado momento a puede valer 8, en otro momento puede valer 9. Pero es imposible que a valga 1200000.

Se usa el símbolo igual para asignar un valor a una variable, a la izquierda del símbolo igual se escribe el nombre de la variable, a la derecha el valor que se quiere que tome la variable.

Ejemplos:

a= b+1; // el valor de la variable b más uno se pone en a, es decir, luego de que se ejecute esta orden, a vale b +1.

c=3; // a partir de este momento c vale 3.

Importante: el símbolo igual en un programa no significa como en matemática igualdad entre la izquierda y la derecha. El símbolo igual en un programa significa: poner en la variable de la izquierda el valor que toma la expresión escrita a la derecha del signo igual.

Por ejemplo:

En matemática a=a+1 no tiene sentido porque jamás un número es igual a su consecutivo (3 nunca es igual a 4).

Pero en un programa de computación a=a+1 si es válido. Significa poner en la variable a el valor de la variable a más uno, o sea: aumentar en uno el valor de a. Por ejemplo, si a vale 23, luego de que se ejecute a=a+1, a pasa a valer 24.

Entonces en programación:

j=j+1 significa aumentar en 1 el valor de j (incrementar j).

j=j-1 significa disminuir en 1 el valor de j.

j=j+10 significa aumentar en 10 el valor de j.

Otras formas para Arduino y lenguaje C++:

j++ significa aumentar en 1 el valor de j.

j— significa disminuir en 1 el valor de j.

j+=10 significa aumentar en 10 el valor de j.

Atención, esto no es válido: j+1=……, ¡a la izquierda va una variable, no una expresión!

Ejercicio 11:

Escribir las instrucciones para:

1. Definir las variables i, j como enteras.

2. Definir la variable demo como tipo long.

3. Definir una constante llamada LED1 con el valor 5.

4. Aumentar en 1 el valor de la variable w. Hacerlo de dos maneras:

5. Asignar a la variable s el valor de a más b.

6. Aumentar en 50 el valor de la variable demo.

7. Disminuir en 5 el valor de la variable demo.

8. Disminuir en 1 el valor de la variable demo. Hacerlo de dos maneras

Ejercicio 12:

Tachá lo que no corresponda de lo que está separado por barras entre paréntesis.

1. Para aumentar en 5 el valor de la variable c puedo escribir: c+5=c; (verdadero/falso).
2. Las variables del tipo int ocupan 16 bits (2 bytes) (verdadero/falso)
3. Las variables globales hay que definirlas dentro del loop() (verdadero/falso).
4. Es posible guardar el número -100.000.000 en una variable definida como tipo long (verdadero/falso).
5. La variable tipo byte puede contener un número negativo (verdadero/falso).
6. Una variable se almacena en memoria RAM (verdadero/falso).

Estructura de control FOR

La estructura FOR se usa en programación cuando se quiere repetir un conjunto de instrucciones un número finito de veces. Cuando hay un bloque repetitivo, en programación se dice que hay un bucle.

Para lograr la repetición, la estructura de control for (o bucles for) va cambiando el valor de una variable numérica generando una secuencia de números, y actúa sobre la orden siguiente, o bien sobre un bloque de instrucciones encerradas entre llaves.

Por ejemplo, ¿cómo hacer para que un bloque de instrucciones se repita cinco veces? (sin copiar y pegar cinco veces el bloque):

Hay que definir una variable tipo int (entera) para ir contando, y usar la estructura de programación for. Recordemos que una variable tipo int permite almacenar un número entero con signo de 16 bits, pudiendo tomar cualquier valor entero entre -32768 y 32767. En este caso se tiene que ir contando 1,2,3,4,5. A la variable la podemos llamar i, y se puede declarar localmente en el propio for (luego al terminar el for desaparece la variable por haber estado definida localmente).

Sintaxis: la estructura for necesita de tres parámetros separados por punto y coma (que en este caso no está indicando fin de instrucción), encerrados entre paréntesis. Luego se encierra entre llaves lo que se quiere hacer en cada ciclo (si es una sola instrucción no hace falta encerrar entre llaves).

Ejemplos:

Entonces empieza con i=1, luego i va cambiando 2,3,4,5 y termina. Vemos que se repite 5 veces (para i=1, i=2, i=3, i=4, i=5) lo que se escriba dentro de las llaves

1. El siguiente segmento de programa hace parpadear el led LED1 cinco veces (suponiendo que LED1 es el número de pin donde se ha colocado el led):2. Para repetir cinco veces, en vez de contar 1,2,3,4,5, sería lo mismo contar 20,21,22,23,24, aunque es más enrevesado:

3. Establecer que los pines 8 al 13 se van a usar como salidas digitales:

4. Poner a nivel alto los pines 5 al 10

5. Hacer que la variable j vaya disminuyendo de uno en uno desde 40 a 10 (40,39,38,……12,11,10, se repite 31 veces)

6. Hacé que la variable j vaya aumentando de 2 en 2, desde 50 a 100 (50,52,54,….98,100)

La orden para aumentar j en 2 puede ser j=j+2 o j+=2 (suma 2 a j y pone el resultado en j).

7. Hacé que la variable j vaya generando los números : 500, 600, 700,……1900, 2000, es decir, desde 500 hasta 2000 saltando de a 100.

Notas:

1. Si la condición no se cumple nunca, el bloque de instrucciones no se ejecuta nunca.
2. Observá que dentro del paréntesis se usan puntos y coma, y no marcar el fin de la instrucción.

A continuación, se muestra un for que comienza con i=1, y la condición es que i sea menor o igual que cero, nunca se cumple, el led no parpadeará ni una vez.

Ejercicio 13:

Usando FOR escribí las instrucciones para:

1. Repetir 10 veces: poner a nivel alto el pin 3 durante 2 segundos, luego a nivel bajo durante 3 segundos.
2. Hacer variar la variable i desde 40 a 55 saltando de uno en uno.
3. Hacer variar la variable i desde 200 hasta 0 disminuyendo de a uno.
4. Hacer variar la variable i desde 55 a 40 saltando de uno en uno.
5. Hacer que la variable i vaya siendo los números impares entre 100 y 200.
6. Hacer que la variable j sea 1000,900,800,….300, o sea desde 1000 a 300 disminuyendo de a 100.
7. Usando FOR, establecer que los pines 7 al 12 se van a usar como salidas digitales.

   Uso del monitor serie

La placa Arduino puede enviar datos a la computadora por el cable USB mediante comunicación serie. En la computadora, ejecute IDE Arduino, vaya a Tools, Serial Monitor.

El siguiente sketch muestra como Arduino va enviando el valor de la variable i. Serial.println imprime y sigue en el renglón siguiente, mientras que Serial.print hace que lo próximo se imprima al lado. Vea que entre comillas se pueden enviar textos, mientras que, si se pone una variable, se envía el valor de la variable.

Para saber más: https://aprendiendoarduino.wordpress.com/category/monitor-serie/

Otro ejemplo de uso de for

Dado el circuito de la figura (circuito 2, ver apunte anterior), abajo se muestra un sketch que usa bucles for. Repite 5 veces: todos los leds 0,1 seg. prendidos, 2 segundos apagados, luego 3 segundos todos apagado. Luego 10 veces parpadea el led L1 (medio segundo prendido, un segundo apagado). Luego espera tres segundos. Luego vuelta a empezar.

Ejercicio 14

Dado el circuito anterior, usando bucles for, hacé un sketch que haga parpadear 20 veces el led L2 (100 ms prendido, 900 ms apagado) y luego hacé parpadear 15 veces el led L3 (0,2 seg prendido, 2 seg apagado). Enviá el valor de las variables for a la computadora por la conexión serie.

Como controlar una tira de leds

Si se quiere controlar el encendido y apagado de una tira de leds con Arduino, habrá que conectarla a una salida, intercalando un circuito de potencia, como se explica a continuación.

Una salida digital de un micro alimentado con 5V da: o bien 0V o bien 5V y unos pocos miliamperes (máximo 25 o 40mA según la familia de microcontrolador), mientras que una tira de leds necesita 12V y bastante más corriente de la que puede dar una salida de micro.

Así que no se puede conectar directamente una tira de leds a un micro porque la tira de leds necesita otro nivel de tensión (0 o 12V, y no 0 o 5V como da el Arduino), y además la tira de leds necesita mucha más intensidad de corriente que la que puede dar Arduino por un pin de salida. Hay que conectar un “circuito de potencia”. Por ejemplo, el circuito de la figura.

Con un transistor NPN trabajando al corte/saturación (en este caso un BC337) si se puede controlar una tira de leds con micro o cualquier otra señal digital.

La tira de led recibe el positivo de una fuente de 12V mientras que el negativo de la tira se conecta al transistor que funciona como interruptor, conectando o desconectando el negativo.

Nota: el negativo de la fuente de 12V se debe conectar a masa, junto con el negativo de la fuente de 5V que alimenta al microcontrolador o placa ARDUINO.

Sucede que, si la salida del micro (en este caso la salida pin 4) está a:

• Nivel bajo “0”: el transistor se corta, entonces la tira de led no tiene su negativo conectado, por lo que se apaga.
• Nivel alto, 5 voltios, “1”: circula una corriente de base suficiente como para hacer saturar el transistor, por lo que el transistor funciona como un interruptor cerrado, la tira de leds recibe negativo (a través del transistor) y positivo directo por lo que se prende.

Con el siguiente sketch, si se aprieta el pulsador P1 ubicado en la entrada 3, la tira de leds parpadea 5 veces.

Ejercicio 15:

1. ¿qué cambios tendrías que hacer en el sketch anterior para que la tira parpadee 8 veces, un segundo prendida, tres segundos apagada?
2. Leé por qué no es posible conectar una tira de leds directamente a una salida de Arduino. Observá una posible solución y su funcionamiento.

Manejo de display 7 segmentos

Recordemos que un display cátodo común está compuesto por siete leds rectangulares y uno redondo, con todos los cátodos unidos entre sí, mientras que cada ánodo a,b,c,d,e,f,g,p aparece en un pin. La disposición de pines y su correspondencia con los segmentos se muestra en la figura.

Un display muestra una cifra 0 al 9 mediante el encendido de leds.

Sea una placa ARDUINO UNO que tiene conectado un display siete segmentos cátodo común, un pulsador y un led, como se muestra en la siguiente figura:

El pin cátodo común K se conecta a masa. Se tiene que poner un nivel alto de tensión en cada pin que se quiera prender, siempre a través de una resistencia de valor adecuado.

Para que se muestre el número 0 se tienen que prender todos los segmentos excepto el g, por lo tanto, los pines 11,10,9,8,7,6 tienen que tener “1” y el pin 12 tiene que tener “0”.

Para que se muestre el número 1 se tienen que prender solo los segmentos b y c, o sea, poner a “1” los pines 7 y 8.

Ejercicio 16:

Dibujá como armarías el circuito en un protoboard (las resistencias dibujadas son para el display, faltaría la correspondiente al led).

Sketch cuenta regresiva nivel básico:

Con el circuito anterior, el siguiente sketch muestra una cuenta regresiva en el display (9,8…1,0) con una demora de 0,7 segundos, luego el led L1 parpadea 6 veces. Luego de 2 segundos empieza todo de nuevo.

Es un sketch muy básico, simplemente va estableciendo los valores alto o bajo en los pines para que se vaya mostrando el número descendente en el display. Hay otras técnicas de programación más eficientes.

 

Esta forma de programar no es eficiente, si hay que mostrar un número más de una vez, ya que habría que repetir el código, y se va usando memoria de programa que es limitada. Se verá el uso de funciones, que mejora notablemente la programación.

Ejercicio 16:

Elegí dos letras de las que están abajo. Dado el circuito de la figura hacé un sketch que muestre las dos letras elegidas con una pausa de medio segundo entre cada una.

Funciones en Arduino definidas por el usuario

Delay(tiempoms) es una función predefinida para Arduino que detiene la ejecución del programa el tiempo en milisegundos indicado entre paréntesis. DigitalWrite es una función predefinida que establece el nivel de tensión en una salida digital y necesita que se le indique entre paréntesis el número de pin y el estado alto o bajo.

El programador (usuario) también puede definir sus propias funciones, son las funciones definidas por el usuario.

Una función es un fragmento de código (un trozo de programa) que realiza una tarea bien definida. La utilización de funciones definidas por el usuario permite dividir un programa extenso en pequeños segmentos que realizan tareas concretas. La verdadera potencia de las funciones aparece cuando se le pasan parámetros.

Una función se define una sola vez al principio, luego se puede usar o llamar tantas veces como se necesite en distintos lugares del loop() o setup(). Esto ahorra memoria, concentra y encapsula código, facilita la programación, permite compartir código entre distintos programadores (a través de librerías).

Cuando una función hace algo pero no devuelve ningún valor, se le antepone la palabra “void” (significa vacío en inglés) en su definición.

Las funciones se usan escribiendo su nombre y encerrando entre paréntesis sus argumentos o parámetros.

Es de destacar que el programa es más entendible usando funciones con nombres significativos. Y la complejidad de las operaciones queda “escondida” en cada función.

Sketch cuenta regresiva en un display usando una función definida por el usuario

Se quiere que cada vez que se apriete el pulsador, se muestre una cuenta regresiva (9,8,7…1,0) en el display del circuito de la figura y luego el led parpadee seis veces.

Se puede definir una función (hay que definirla, escribirla), llamada ponenumeroendisplay (u otro nombre), que muestre en un display 7 segmentos el número que se le pasa como parámetro. Y si el número está fuera del rango 0 al 9, que apague el display

La función se usa así, por ejemplo:

ponenumeroendisplay(3); muestra el número 3 en el display.

ponenumeroendisplay(i); muestra el valor de la variable i en el display, siempre y cuando i sea un número entre 0 y 9.

ponenumendisplay(-1); con número fuera de rango, apaga el display.

Entonces, en el loop() se puede escribir lo siguiente lo que va mostrando 9,9,7…1,0 cada 0,8 segundos:

Así, de esta manera, el programa queda mucho más fácil de entender.

El siguiente loop() muestra la cuenta regresiva y hace parpadear el led 6 veces cuando se aprieta el pulsador.

Pero falta “definir” la función, es decir, escribir el conjunto de órdenes que hace prender los segmentos adecuados del display de manera de mostrar el número que se le dice a la función. Para definir la función ponenumeroendisplay se escribe, afuera de setup, o loop o de cualquier otra función:

void ponenumeroendisplay(int n) {

entre las llaves se escriben las órdenes de la función

}

“Void” significa que la función no devuelve ningún valor, la función se llama “ponenumeroendisplay”, se le pasa un número entero que adentro de la función va a parar a la variable n.

Según el valor de n hay que poner a nivel alto o bajo los pines correspondientes a los segmentos del display. Se puede hacer con if, por ejemplo, para cuando n vale 1 hay que encender solo los pines b y c:

El sketch completo tiene cuatro partes:

1. Sección #define (líneas 3 a 11)
2. Definición de la función ponenumendisplay (líneas 13 a 94)
3. Setup (función que se ejecuta al principio por única vez) (líneas 97 a 107)
4. Loop (parte repetitiva) (líneas 109 a 117)

Y queda así:

Observá lo siguiente: en la línea 87 se declara que, si el valor pasado como parámetro es mayor que 9 o es menor que 0, apaga todos los segmentos. Por ejemplo: ponenumendisplay(-1); apaga el display.

Notemos que el programa principal (loop a partir de la línea 109) queda fácil de leer al usar la función ponenumendisplay().

Cuando aprendas el uso de matrices, podrás confeccionar esta función en forma mas compacta, sin repetir tantas instrucciones digitalWrite.

Ejercicio 17:

Modificar el loop() del sketch anterior para mostrar su fecha de cumpleaños. Son 6 números (dos para el día, dos para el mes y dos para el año), debe haber una demora de un segundo entre cada número. Al final se debe apagar el display durante cinco segundos luego volver a repetirse.

Estructura de control WHILE

Antes se vio que la estructura for permite repetir un conjunto de instrucciones una cantidad fija de veces. A continuación, se verá la estructura while que también hace repetir un conjunto de instrucciones, pero mientras se cumpla una condición.

La estructura while permite repetir un grupo de instrucciones mientras se cumpla una condición (tipo booleana, que puede ser verdadera o falsa). Cuando la condición no se cumple más, se deja de repetir y se continua con la orden de más abajo.

Se puede traducir como “mientras se cumpla la condición {se ejecutan acciones}”.

Y se vuelven a repetir hasta que no se cumpla la condición. Si es una sola acción, no hace falta poner llaves.

Es posible que las acciones no se realicen ni una sola vez (si la condición es falsa al principio), o que se ejecuten una sola vez, o que se ejecuten varias veces.

A la derecha se muestra el diagrama de flujo equivalente a la estructura while.

Ejemplo 1:

En el pin 3 se tiene un pulsador a masa con pull-up, que entrega LOW si está apretado y HIGH si está suelto.

El siguiente segmento de programa tiene dos partes bien diferenciadas, primero (parte encerrada con líneas de trazos) hace parpadear el led pin 13 mientras el pulsador esté suelto (pin3 a HIGH). Esto se puede repetir varias veces, una sola vez, o ninguna vez, según si esté suelto o no el pulsador. Luego, enciende el led pin 13 durante 5 segundos, luego lo apaga y espera 5 segundos. Esto no se repite.

Ejemplo 2:

Mientras (while) la entrada P1 esté a nivel alto hago {nada, entre llaves no hay nada}, o sea, mientras el pulsador P1 esté suelto no hago nada. En otras palabras, se queda esperando a que se apriete el pulsador (suponiendo que entrega nivel bajo al apretarse), y luego continúa con la siguiente orden.

Ejemplo3:

Mientras la entrada P1 esté a nivel alto (pulsador suelto) va incrementando en uno el valor de la variable i, y si llega a 10 (es mayor que 9) la vuelve a poner a cero. Entonces i puede valer 0,1,2…9, 0,1,2…. generándose muy rápidamente mientras P1 esté a nivel alto. Cuando P1 pasa a nivel bajo, se deja de contar, y entonces i queda en un determinado valor que no se puede predecir. Se puede usar para generar un número “al azar” entre 0 y 9.

Ejemplo 4

El segmento anterior funciona igual que:

EJERCICIO 18:

1. Escribí un sketch usando while que espere a que la entrada 4 se ponga a nivel bajo, luego hacer parpadear 20 veces el led ubicado en la salida 8.
2. Hacé parpadear el led pin 13 si el pulsador está apretado, 0,1 segundos prendido, 2 segundos apagado.

Estructura de control DO WHILE

El bucle “do” funciona exactamente igual que el bucle “while”, con la excepción de que la condición es evaluada después de ejecutar las instrucciones escritas dentro de las llaves.

Esto hace que las instrucciones siempre sean ejecutadas como mínimo una vez aun cuando la condición sea falsa, porque antes de llegar a comprobar esta, las instrucciones ya han sido leídas (a diferencia del bucle “while”, donde si la condición ya de entrada era falsa las instrucciones no se ejecutaban nunca).

Vemos que va un punto y coma al final. A la derecha se muestra el diagrama de flujo equivalente.

Generación de un número al azar

El siguiente sketch genera un número al azar entre 1 y 9 y lo guarda en la variable numazar. Hay que definir la variable que va a contener al número como tipo long, agregar en el setup() como se muestra abajo, usar en el loop como se muestra. Para mayor información ver la referencia de lenguaje de Arduino.

EJERCICIO 18

Modificá el loop() del ejercicio que usa la función numDisplay de manera de mostrar un número al azar entre 0 y 9 cada vez que se apriete el pulsador.

Una sugerencia:

Si se aprieta el pulsador P1 entonces {

Generar un número al azar entre 0 y 9 con random

Mostrar el número en el display }

Puede escribir en la carpeta solo el loop() que es corto, y hacer en computadora el sketch completo. Simular o armar y probar.

Anexo B: FUNCIONES EN ARDUINO DEFINIDAS POR EL USUARIO

Una función es un fragmento de código (un trozo de programa) que realiza una tarea bien definida. Las funciones que define el programador son conocidas como funciones de usuario. La utilización de funciones nos permite dividir un programa extenso en pequeños segmentos que realizan tareas concretas.

En nombre de la función lo elige el programador, que sea significativo, que tenga sentido. A una función se le pueden “pasar” parámetros o argumentos que modifican su funcionamiento, y también la función puede devolver un valor. Esa es su verdadera potencia: pasarle parámetros que determinan su funcionamiento y la hacen flexible.

Además el programa principal escrito en el loop() se hace mucho más entendible ya que se puede armar como una serie de funciones con nombres significativos. Y la complejidad de las operaciones queda “escondida” en cada función.

La función se define una sola vez al principio, luego se puede usar o llamar tantas veces como se necesite en distintos lugares del loop(). Esto ahorra memoria, concentra y encapsula código, facilita la programación, permite compartir código entre distintos programadores (a través de librerías) y es más fácil leer un programa (sketch en Arduino).

¿Cómo se define y se usa una función?

Tenemos el hardware circuito 2 de la figura.

Quiero hacer un “trozo de programa” que prenda el led L1 (que está en el pin 8) durante un tiempo que se pueda cambiar, o sea, que quiero hacer una función a la que se le pasa como parámetro el tiempo. ¿Qué nombre le doy a la función? Se me ocurre como nombre PrenderL1.

En el loop quiero que el led se prenda 3 segundos y se apague. Luego que siga cinco segundos apagado, y luego medio segundo prendido.

Entonces, escribo dentro del loop():

void loop() {

PrendeL1(3000);

delay(5000);

PrendeL1(500);

}

Listo el programa principal.

Ahora voy arriba de todo a escribir la función (a definirla). La función no entrega valor, entonces pongo void al principio. Al tiempo lo llamo tiempo, delay acepta variables del tipo unsigned long.

Entonces, arriba del setup() escribo:

void PrendeL1(unsigned long tiempo) {

}

Ahora, ¿qué va adentro? Pienso que tengo que prender L1, esperar el tiempo indicado, apagar L1. Listo, ahora a escribir dentro de las llaves:

void PrendeL1(unsigned long tiempo) {

digitalWrite(8,HIGH); //un nivel alto en el pin 8 prende el led

delay(tiempo); //espera

digitalWrite(8, LOW); //ahora apago el led

}

Listo.

Sketch ejemplo con tres funciones:

Analicemos el sketch:

Por arriba del setup() se han definido tres funciones, desde la línea 6 hasta 18. Las funciones que no devuelven parámetros deben empezar con void.

La sintaxis de la definición de funciones que no devuelven parámetros es:

void nombredelafunción (parámetros separados por comas)

{entre llaves van las órdenes de lo que tiene que hacer la función}

Luego, en el loop() se llama (se ejecuta) a una función poniendo su nombre y pasándole parámetros si tiene.

Veamos la primera función.

En la línea 26 se llama a la función prendeL1unseg(). Adentro del paréntesis se le pasan parámetros, como esta función no tiene ninguno, está vacío.

En las líneas 6 y 7 se define la función prendeL1unseg(). Lo que hace esta función es poner a nivel alto la salida L1, luego espera un segundo y luego pone la salida L1 a nivel bajo. Todas estas órdenes van entre llaves. El efecto que tiene esta función es que el led L1 se prende durante un segundo.

Ahora veamos la segunda función.

En la línea 28 en el loop() se llama a la función prendeL2(2000); a la que se le pasa un parámetro, el número 2000.

¿Qué hace esta función? Hay que ir a las líneas 9 y 10, donde está definida. Se ve que recibe un número tipo unsigned long que lo asigna a la variable tiempo (variable que es propia de la función). Y en la línea 10 se ve que la función pone a nivel alto la salida correspondiente al led L2, luego espera un tiempo dado por la variable tiempo que en este caso es 2000, y luego pone a nivel bajo la salida L2. El efecto que se ve es que el led L2 se prende durante dos segundos.

Acá se ve la flexibilidad de una función, cambiando el número 2000 se logra otro tiempo de prendido. Si en el loop() se escribe prendeL2(7000); el led L2 se prenderá durante 7 segundos.

La tercera función es:

En la línea 29 se ejecuta la función parpadeaL1 a la que se le pasan tres parámetros:7,100 y 1000. ¿Qué hace esa función con esos números? Veamos entre las líneas 12 y 18 que es donde se define la función.

En la línea 12 se ve que el primer número se asigna a la variable entera veces, el segundo es tiempoencendido y el tercero es tiempoapagado, todos son números tipo unsigned long.

El for de la línea 14 se repite para i=1,2,3….6,7, haciendo que las órdenes líneas 15 y 16 se repitan 7 veces. Esas órdenes hacen que se prenda L1 durante tiempoencendido milisegundos, y luego que se apague y espera tiempoapagado milisegundos.

El efecto de parpadeaL1(7,100,1000) es que el led L1 parpadea 7 veces, 100ms prendido y 1000ms apagado cada vez. Cambiando los parámetros se logra otra cantidad de parpadeos con otros tiempos.

Usando funciones el programa principal quedó fácil de leer, es una serie de llamadas a funciones. Luego la complejidad de cada función se encara en la definición de cada una.

NOTA: las funciones que entregan valores se verán en otra ocasión.

Función semáforo

Supongamos que se han conectado a Arduino seis leds: LR1, LA1, LV1 correspondientes a rojo, amarillo y verde de semáforo 1 y LR2, LA2, LV2 correspondientes a rojo, amarillo y verde del semáforo 2. La correspondencia con los pines de Arduino se debe definir al principio del sketch. Además, se deben agregar los pinMode.

La siguiente función establece el valor de los seis leds y hace una pausa expresada en milisegundos. Vea la correspondencia entre los leds y los parámetros de la función.

Luego en el sketch se puede escribir:

para que se prendan los leds rojo1 (LR1) y verde2 (LV2) durante 4 segundos. Al definir esta función el programa gana en claridad.

Entre paréntesis se pone el valor deseado (0:apagado o 1:prendido) de los seis leds en orden: LR1, LA1, LV1, LR2, LA2, LV2, y al final el tiempo en milisegundos.

Ejercicio 19

1. Hacé un sketch que use las funciones prende L2 y parpadea L1 y que haga lo siguiente: Prender L2 durante medio segundo, esperar tres segundos, hacer parpadear el led L1 cuatro veces, medio segundo prendido, 2,5 segundos apagado, esperar cinco segundos, luego nuevamente a repetir.
2. Dibujar el hardware y hacer un sketch que simule un semáforo. Además de los leds, agregue un interruptor S1. Use la función semáforo.
3. Modificar el sketch anterior de manera de tener dos velocidades en la secuencia del semáforo, una lenta y otra rápida, según si el interruptor está abierto o cerrado.
4. Simular con Proteus o Simulide.