2014-15. PROYECTO INTEGRADO. ARDUINO. INICIACIÓN I

cabecera-entradas-blog

PROYECTO INTEGRADO. INTRODUCCIÓN A ARDUINO

CONOCIMIENTOS BÁSICOS. TRABAJO DE EVALUACIÓN

Algunos apuntes básicos para el desarrollo de la práctica

En este apéndice repasaremos los comandos vistos hasta ahora, su función, su sintaxis y disiparemos algunas dudas sobre ellos.

Arduino no utiliza como entrada un teclado y como salida una pantalla (la configuración más habitual en ordenadores), sino que se conecta directamente a su entorno físico o a periféricos que serán los que interactuarán con el entorno físico. Arduino es un ordenador que enciende y apaga luces, mueve cosas, mide temperaturas, presiones, emite sonidos y se comunica con otros dispositivos.

Básicos del void setup y void loop

pinMode (númerodepin, modo);

El comando pinMode() sirve para establecer a cada pin de entrada o salida digital que vayamos a utilizar el modo en el que lo haremos, es decir, declararemos un pin identificado por su número como entrada o como salida.

El número del pin se puede introducir tal cual está serigrafiado en la placa (del 0 al 13) , pero es muy recomendable introducirlo como una variable, constante o definición con el valor introducido previamente en la parte del Sketch en la que se hace la definición de variables. Esto nos permitirá cambiar su valor sin tener que repasar todo el código para cambiar el número de pin de forma manual y en las ocasiones en las que trabajamos con cables y, por la razón que sea, los queremos cambiar de pin resulta sumamente práctico.

Como modo pondremos OUTPUT o INPUT dependiendo de si queremos que el pin sea una salida o una entrada digital. En mayúsculas, recordemos que en este lenguaje se hace distinción entre mayúsculas y minúsculas, si escribimos una palabra mal el compilador nos dará un error.

Declararemos solo los pines que vayamos a utilizar, no tiene sentido declarar pines a los que no vamos a conectar a nada. ¿Que pasa con los pines que no declaramos? por definición Arduino trata a todos los pines como entradas a menos que especifiquemos lo contrario, esto significa que los pines que vayamos a utilizar como entradas no sería necesario declararlos con el comando pinMode(), solo los que vayamos a utilizar como salidas. Pero esto último no es nada recomendable, de hecho casi sería mejor que no lo hubiera dicho.

No cuesta nada declarar cada pin que utilice el Sketch como entrada o salida en el setup() y si lo documentamos correctamente ganamos en claridad y limpieza. Esto es especialmente útil si vamos a publicar nuestro Sketch o si lo vamos a tener que volver a editar en el futuro.

pinMode (pulsador, INPUT);  // declara el pin al que está conectado el
//pulsador como entrada

Este ejemplo es perfectamente comprensible para todo el que lo lee hoy y dentro de seis meses, si no lo hacemos así y suponemos que un pin está conectado a un pulsador y trabajamos con el directamente será difícil de entender por otra persona… en unos meses incomprensible incluso para nosotros.

digitalWrite (númerodepin, estado);

El comando digitalWrite() sirve para establecer la salida digital en el pin que establezcamos. Para el parámetro del número de pin digital sirve todo lo dicho en la explicación del comando pinMode(), mejor desde una variable, constante o definición y por los mismos motivos.

Este comando sólo admite dos estados HIGH o LOW, alto o bajo y que se corresponden con un 1 ó un 0. De hecho podríamos introducir el comando de las siguientes formas:

1
2
3
digitalWrite(pin, HIGH);   // la forma correcta de hacerlo
digitalWrite(pin, 1);   // no es nada conveniente hacerlo así
digitalWrite(pin, estado);   // donde estado es una variable

En el último caso la variable de nombre estado, declarada en la cabecera del Sketch, puede ser del tipo entero (int) y contener un 0 o un 1 o asignarle los valores HIGH o LOW.

Eléctricamente un nivel HIGH de corresponde a +5v en la salida del pin y el nivel LOW a 0v.

Los modelos de Arduino que trabajan a 3’3v tienen esta misma salida para el nivel HIGH.

El comando delay

delay(número);

El comando delay() detiene la ejecución del Sketch durante el tiempo que le especifiquemos expresado en milisegundos.

Generalmente utilizaremos este comando de forma muy limitada precisamente por esa característica suya de detener completamente la ejecución del Sketch. Es útil en algunos procesos de comunicación para darle tiempo a un periférico a que procese la información que le mandamos y nos devuelva un resultado o para impedir rebotes en la lectura de sensores, y en estos casos el intervalo de tiempo lo introduciremos de forma directa como un número.

Si necesitamos pasarle al comando delay() el tiempo dentro de una variable hay que tener en cuenta que esta debe ser del tipo unsigned long, es decir, un número de 32 bits sin signo (veremos lo que esto significa en el siguiente comando).

El bucle FOR

El bucle for es una estructura que se utiliza cuando queremos que una serie de acciones se repita un número determinado de veces, para ello se necesita de una variable índice, una condición y un incrementador.
Su sintaxis es la siguiente:

1
2
3
4
for (variable índice; condición; incrementador)
{
// comandos
}

Así que si queremos que un led parpadee 5 veces tras accionar un pulsador… aprovecharemos el código del ejemplo anterior:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// variables para el pulsador y el led
int pulsador = 12;
int led= 4;void setup()
{
pinMode(pulsador, INPUT);
pinMode(led, OUTPUT);
}void loop()
{
if (digitalRead(pulsador) == HIGH)
{
for (int i = 0; i<=4; i++)
{
digitalWrite(led, HIGH);
delay(1000);
digitalWrite(led, LOW);
delay(1000);
}
}
else
{
digitalWrite(led, LOW)
}
}

Hay que tener en cuenta varios aspectos que hacen del bucle for una estructura peculiar:

-necesita una variable índice que en el ejemplo hemos definido directamente como int i = 0, esta variable índice es local y solo es accesible dentro del bucle for.

-necesita de una condición y se ejecutara tantas veces como sea necesario mientras se cumpla la condición, en el ejemplo hemos hecho que el código se repita mientras que la variable índice sea menor o igual a 4, como hemos empezado con el valor 0 para la variable índice esta condición solo se cumplirá 5 veces.

-necesita un incrementador de la variable índice. Cada vez que se evalúa la condición y se ejecuta el código se incrementa la variable índice, en nuestro caso el incrementador tiene la forma i++, que es la forma abreviada de i = i + 1.

Entradas y salidas analógicas

Ya hemos visto como trabajan las E/S digitales: son todo o nada, solo admiten esos dos estados. Para muchos proyectos esto nos sera útil pero para otros proyectos necesitaremos ir un paso mas allá y utilizaremos sensores o actuadores analógicos.

Las placas mas difundidas como la Arduino UNO o la Arduino Leonardo trabajan de 0 a 5 voltios, en la forma digital estos son los dos niveles lógicos: 0v para el nivel bajo (LOW) y 5v para el nivel alto (HIGH). Cuando hablamos de valores analógicos podremos trabajar con valores comprendidos entre el mínimo y el máximo. En el caso de las entradas analógicas (marcadas de A0 a A5) Arduino utiliza un convertidor analógico-digital de 10 bits, lo que nos da 1024 niveles intermedios entre 0 y 5 voltios numerados del 0 al 1023. Para las salidas analógicas Arduino UNO utiliza los pines 3, 5, 6, 9, 10 y 11 (en el caso de la Arduino Leonardo los mismos pines mas el numero 13) con una señal PWM de 8 bits, lo que nos da 256 niveles numerados del 0 al 255.

Para hacer lecturas analógicas utilizamos el comando analogRead que tiene la siguiente sintaxis:

analogRead(número de pin);

Donde “número de pin” es uno de los pines marcados de A0 a A5. Este comando nos devolverá un valor de 0 a 1023, por lo que generalmente lo usaremos como asignación del valor a una variable:

Variable = analogRead(A0);

o como parte de una comparación:

1
2
3
4
If (analogRead(A0) &lt;= 500))
{
// comandos
}

En el caso de las salidas analógicas utilizamos el comando analogWrite de la siguiente manera:

analogWrite(pinPWM, valor);

Como caso práctico vamos a ver un sencillo programa en el que utilizaremos un potenciómetro para la toma del valor analógico y como salida uno de los colores del LED, pues sus patillas están conectadas a las salidas PWM 9, 10 y 11.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
int valor; // definimos una variable en la que almacenaremos el valor leído del potenciómetro
int pin = 9; // pin PWM de salidavoid setup()
{
pinMode(led, OUTPUT);
}

void loop()
{
// tomamos una lectura analogica y la almacenamos en la variable valor
valor = analogRead(A0);

/* valor contiene un numero de 0 a 1023 y la salida la tenemos que dar de 0 a 255
por lo que tenemos que convertirla de un rango a otro, la forma mas sencilla es
dividir por 4 */

valor = valor / 4;

// ahora sacamos el valor analogico por el pin PWM
analogWrite(pin, valor);
}

Este sencillo ejemplo hace que al girar el potenciómetro con el correspondiente mando el LED  brille más o menos

Práctica a desarrollar

Adjunto os dejo la práctica que debéis realizar todos los alumnos de proyecto integrado para este trimestre. La originalidad de cada planteamiento para resolver este problema, básico por otra parte, será determinante para valoraros vuestra calificación trimestral, por ello, os recomiendo que, aunque sea el mismo ejercicio para todos, cada uno de vosotros intente ser original al resto, aportando indicaciones y comentarios, así como ampliando cualquier aspecto fuera del enunciado del problema, por ejemplo, haciendo un video-tutorial del desarrollo de la práctica.

 
CES_ARDUINO_BASICO1CES_ARDUINO_BASICO2