Está en la página 1de 85

1

Contenido
EL HARDWARE DE LA PLACA ARDUINO ................................................................................ 5
Programacin ........................................................................................................................ 7
5.-INTALACION DEL IDE ARDUINO UNO en WINDOWS 7 ........................................ 7
2 | Descarga el IDE de Arduino.................................................................................... 7
3 | Conecta la placa ....................................................................................................... 8
4 | Instala los drivers ...................................................................................................... 8
5 | Ejecuta la Aplicacin Arduino y abre el ejemplo Blink (Parpadeo) ................... 8
6 | Selecciona tu placa .................................................................................................. 8
7 | Selecciona tu puerto serie ....................................................................................... 8
8 | Sube el sketch a la placa ......................................................................................... 9
6.-LENGUAJE C (PROGRAMACION ARDUINO)....................................................................... 9

2
1.-PREFACIO:

El propsito de este pequeo manual de consulta rpida es que el alumno


de ingeniera electrnica pueda entender de la manera ms cmoda y fcil la
programacin bsica con arduino.

En este libro se menciona la estructura de hardware de arduino y la


estructura bsica de C del que deriva el lenguaje de programacin de
Arduino. Ademas se anexan ejemplos de cdigo asi como prcticas de
arduino.

2.-HISTORIA DE ARDUINO:

El lenguaje del Arduino est basado en el mtico lenguaje C. Si ya has


trabajado en C este tutorial te parecer un paseo. Si no, te basta con saber
que C es el lenguaje en el que se ha desarrollado los sistemas operativos
UNIX, Linux, y cientos de sistemas, programas y aplicaciones de ordenador.
El lenguaje del Arduino es una versin reducida y mucho ms sencilla de
manejar que el lenguaje C. El objetivo de este lenguaje es que puedas
programar de una manera intuitiva concentrndote en lo que quieres hacer
ms que en la manera de hacerlo.

Arduino fue desarrollado originalmente en el Interactive Design Institute en


Ivrea (Italia) donde los estudiantes estaban familiarizados con un lenguaje
llamado Processing. Este lenguaje estaba orientado a estudiantes de arte y
diseo y utilizaba un entorno de desarrollo visual e intuitivo en el cual se
bas el entorno de desarrollo del Arduino y su lenguaje de programacin.

Trabajar con un Arduino consiste fundamentalmente en interactuar con los


diferentes puertos de entrada y salida del Arduino. A fin de evitar al
programador el engorro y la complejidad de programar estos puertos (ya
sean analgicos, digitales o de cualquier otro tipo) el lenguaje de Arduino usa
una serie de libreras (de las que no te tienes que preocupar ya que forman
parte del lenguaje, ya las iremos viendo con detenimiento ms adelante).
Estas libreras te permiten programar los pins digitales como puertos de
entrada o salida, leer entradas analgicas, controlar servos o encender y
apagar motores de continua. La mayor parte de estas libreras de base (core
libraries) forman parte de una macro librera llamada Wiring desarrollada por
Hernando Barragn.

3
Cada vez que un nuevo puerto de entrada o salida es aadido al Arduino, un
nuevo conjunto de libreras especializadas en ese puerto es suministrada y
mantenida por los desarrolladores del nuevo puerto.

3.-POR QUE UTILIZAR ARDUINO?


Hay muchos otros microcontroladores y plataformas con microcontroladores
disponibles para la computacin fsica. Parallax Basic Stamp, BX-24 de
Netmedia, Phidgets, Handyboard del MIT, y muchos otros ofrecen
funcionalidades similares. Todas estas herramientas organizan el complicado
trabajo de programar un microcontrolador en paquetes fciles de usar.
Arduino, adems de simplificar el proceso de trabajar con
microcontroladores, ofrece algunas ventajas respecto a otros sistemas a
profesores, estudiantes y amateurs:

Asequible - Las placas Arduino son ms asequibles comparadas con


otras plataformas de microcontroladores. La versin ms cara de un
modulo de Arduino puede ser montada a mano, e incluso ya montada
cuesta bastante menos de 60
Multi-Plataforma - El software de Arduino funciona en los sistemas
operativos Windows, Macintosh OSX y Linux. La mayora de los
entornos para microcontroladores estn limitados a Windows.
Entorno de programacin simple y directo - El entorno de
programacin de Arduino es fcil de usar para principiantes y lo
suficientemente flexible para los usuarios avanzados. Pensando en los
profesores, Arduino est basado en el entorno de programacin de
Procesing con lo que el estudiante que aprenda a programar en este
entorno se sentir familiarizado con el entorno de desarrollo Arduino.

4
Software ampliable y de cdigo abierto- El software Arduino esta
publicado bajo una licencia libre y preparado para ser ampliado por
programadores experimentados. El lenguaje puede ampliarse a travs
de libreras de C++, y si se est interesado en profundizar en los
detalles tcnicos, se puede dar el salto a la programacin en el
lenguaje AVR C en el que est basado. De igual modo se puede
aadir directamente cdigo en AVR C en tus programas si as lo
deseas.
Hardware ampliable y de Cdigo abierto - Arduino est basado en los
microcontroladores ATMEGA168, ATMEGA328 y ATMEGA1280. Los
planos de los mdulos estn publicados bajo licencia Creative
Commons, por lo que diseadores de circuitos con experiencia
pueden hacer su propia versin del mdulo, amplindolo u
optimizndolo. Incluso usuarios relativamente inexpertos pueden
construir la versin para placa de desarrollo para entender cmo
funciona y ahorrar algo de dinero.

4.-INTRODUCCIN

Arduino es una plataforma de hardware libre, basada en una placa con un


microcontrolador y un entorno de desarrollo integrado (IDE), diseada para
facilitar el uso de la electrnica en proyectos multidisciplinares, que pueden
abarcar desde sencillas aplicaciones electrnicas domsticas hasta
proyectos ms elaborados para la industria. Su principal ventaja es su
facilidad de programacin, al alcance de cualquiera. Para encontrar toda la
informacin que necesites sobre Arduino en la web http://www.arduino.cc/es/.

EL HARDWARE DE LA PLACA ARDUINO


Nuestras placas Arduino son la Duemilanove y la UNO, ambas incorporan el
chip ATmega328.
Tienen 14 entradas/salidas digitales, 6 entradas analgicas, entradas de
alimentacin, conexin USB para conectar al ordenador, conector de
alimentacin y un botn de Reset.

5
Alimentacin
Las placas pueden ser alimentadas por medio de la conexin USB o con una
fuente de alimentacin externa de entre 6 a 20 V, aunque el rango
recomendado es de 7 a 12 V.
Las fuentes de alimentacin externas (no-USB) pueden ser tanto un
transformador como una batera. El transformador se puede conectar usando
un conector macho de 2.1 mm con centro positivo en el conector hembra de
la placa. Los cables de la batera pueden conectarse a los pines Gnd y Vin
en los conectores de alimentacin (POWER).

Entradas y Salidas
Cada uno de los 14 pines digitales (de 0 a 13) pueden utilizarse como
entradas o como salidas usando las funciones pinMode(), digitalWrite() y
digitalRead(). Las E/S operan a 5 V. Cada pin puede proporcionar o recibir
una intensidad mxima de 40 mA.
Los pines 3, 5, 6, 9, 10, y 11 proporcionan una salida PWM (modulacin por
anchura de pulsos) de 8 bits de resolucin (valores de 0 a 255) mediante la
funcin analogWrite().
El pin digital 13 lleva conectado un LED integrado en la propia placa. Se
encender cuando dicho pin se configura como salida y adopte un valor
HIGH.; con valor LOW se apaga.
La placa tiene 6 entradas analgicas, y cada una de ellas proporciona una
resolucin de 10 bits (1024 valores).

Comunicaciones
La placa Arduino proporciona comunicacin va serie a travs de los pines
digitales 0 (RX) y 1 (TX). Un chip integrado en la placa canaliza esta
comunicacin serie a travs del puerto USB. El software de Arduino incluye
un monitor de puerto serie que permite enviar y recibir informacin textual

6
hacia y desde la placa Arduino. Los leds RX y TX de la placa parpadearn
cuando se detecte comunicacin transmitida a travs de la conexin USB.
Programacin
La placa Arduino se puede programar a travs del IDE (Entorno de
Desarrollo Integrado) de Arduino. Primero hay que decirle al IDE nuestro tipo
de placa. Para ello, selecciona bien "Arduino Duemilanove w/ ATmega328" o
bien Arduino Uno del menu Herramientas > Tarjeta. Tambin hay que
decirle al IDE en qu puerto USB hemos conectado la placa. Lo haremos a
travs del men Herramientas > Puerto Serial. Aparecen una serie de
puertos denominados COMx, donde x es un nmero. Para saber cul es,
desconecta y conecta el cable USB del ordenador, y el que desaparezca y
vuelva a aparecer es nuestro puerto.

5.-INTALACION DEL IDE ARDUINO UNO en WINDOWS 7

Para poder empezar a utilizar Arduino no basta con tener la placa, tambin
se requiere el entorno de programacin donde construiremos la parte lgica
de nuestro proyecto. Para este tutorial nos apoyamos de la informacin
existente en la web oficial de Arduino. Puede seguir los pasos completos
desde ella o leer nuestra versin resumida.

Entonces sigamos los siguentes pasos:

Inicio: Ver video tutorial. No te qued claro? entonces sigue los


pasos uno por uno.
Paso 1: Tenga a la mano la placa Arduino y un cable USB de
conexin tipo A B (similares a los que usamos para conectar
impresoras).
Paso 2: Descargar Arduino de la pgina oficial de descargas.
Paso 3: Descomprima el archivo y cpielo en su unidad de disco. De
preferencia grbelo en la raz.
Paso 4: Conecta la placa con el cable USB. Si es Windows 7
Paso 5: Ejecuta la aplicacin y carga tu primer ejemplo.
Paso 6: Selecciona la placa.
Paso 7: Selecciona el puerto serie y sube el programa (sketch) a la
placa.

2 | Descarga el IDE de Arduino

Descarga la ltima versin de la pgina de descargas. Cuando la descarga


finalice, descomprime el fichero. Asegrate de mantener la estructura de
directorios. Haz doble click en la carpeta arduino-00XX para abrirla. Deberas

7
ver una serie de ficheros y carpetas ah dentro.

3 | Conecta la placa

Conecta la placa Arduino a tu ordenador usando el cable USB. el


LED indicador de la alimentacin (nombrado comoPWR en la placa) debera
quedar encendido a partir de ese momento. Nota: Este led puede ser verde
(Arduino) amarilo o rojo (compatibles).

4 | Instala los drivers

Cuando conectas la placa, Windows debera inicializar la instalacin de


los drivers (siempre y cuando no hayas utilizado ese ordenador con una
placa Arduino anteriormente). En Windows Vista y Windows 7, los drivers
deberan descargarse e instalarse automticamente. Si est usando
Windows XP vea aqu.

5 | Ejecuta la Aplicacin Arduino y abre el ejemplo Blink (Parpadeo)

Haz doble click en la aplicacin Arduino. Luego abre el programa de ejemplo


para hacer parpadear un LED (LED blink): File > Examples > Basics >
Blink.

6 | Selecciona tu placa

Necesitars seleccionar el tipo de placa de tu Arduino en el menu Tools >


Board. Para las nuevas placas Arduino con el chip ATmega 328 (comprueba
el texto escrito en el chip de la placa), selecciona la opcin Arduino
Duemilanove or Nano w/ ATmega328 del men desplegable. Anteriormente
las placas Arduino incluan un chip ATmega 168; para estos casos
selecciona la opcin Arduino Diecimila, Duemilanove, or Nano
w/ ATmega168.

7 | Selecciona tu puerto serie

Selecciona el dispositivo serie de la placa Arduino en el men Tools | Serial


Port (Herramientas | Puertos Serie). Lo ms probable es que sea COM3 o
mayor (COM1 y COM2 se reservan, por regla general para puertos serie de
hardware). Para asegurarte de cual es, puedes desconectar la placa y volver
a mirar el men; el puerto de la placa habr desaparecido de la lista.
Reconecta la placa y selecciona el puerto apropiado.

8
8 | Sube el sketch a la placa

Ahora simplemente pulsa sobre el botn Upload en el Entorno Arduino.


Espera unos pocos segundos deberas ver parpadear los led RX y TX de la
placa. Si el volcado del cdigo es exitoso vers aparecer el mensaje Done
uploading en la barra de estado. (Aviso: Si tienes una placa Arduino Mini,
NG, u otras placas, necesitars presionar el boton de reseteo de la placa
inmediatamente antes de presional el botn Upload el Entorno de
programacin Arduino.)

Video del Proceso de instalacin:

https://www.youtube.com/watch?v=cwNcKnKDj_M

6.-LENGUAJE C (PROGRAMACION ARDUINO).


6.1 estructura de un sketch
La estructura basica del lenguaje de programacin de Arduino es bastante
simple y se compone de al menos dos partes. Estas dos partes necesarias, o
funciones, encierran bloques que contienen declaraciones, estamentos o
instrucciones.

void setup()
{
estamentos;
}
void loop()
{
estamentos;
}

En donde setup() es la parte encargada de recoger la configuracin y loop()


es la que contienen el programa que se ejecutara ciclicamente (de ahi el
termino loop bucle-). Ambas funciones son necesarias para que el
programa trabaje.

La funcion de configuracion debe contener la declaracion de las variables. Es


la primera funcin a ejecutar en el programa, se ejecuta solo una vez, y se
utiliza para configurar o inicializarpinMode (modo de trabajo de las E/S),
configuracin de la
comunicacin en serie y otras.

La funcin bucle (loop) siguiente contiene el cdigo que se ejecutara


continuamente (lectura de entradas, activacin de salidas, etc.) Esta funcin
es el ncleo de todos los programas de Arduino y la que realiza la mayor
parte del trabajo.

9
6.2 setup()
La funcin setup() se invoca una sola vez cuando el programa empieza. Se
utiliza para inicializar los modos de trabajo de los pins, o el puerto serie.
Debe ser incluido en un programa aunque no haya declaracin que ejecutar.
Asi mismo se puede utilizar para
establecer el estado inicial de las salidas de la placa.

void setup()

{
pinMode(pin, OUTPUT); // configura el 'pin' como
Salida
digitalWrite(pin, HIGH); // pone el pin en estado
// HIGH
}

6.3.-loop()
Despus de llamar a setup(), la funcin loop() hace precisamente lo que
sugiere su nombre, se ejecuta de forma ciclica, lo que posibilita que el
programa este respondiendo continuamente ante los eventos que se
produzcan en la placa.

void loop()
{
digitalWrite(pin, HIGH); // pone en uno (on, 5v) elpin
delay(1000); // espera un segundo (1000 ms)
digitalWrite(pin, LOW); // pone en cero (off, 0v.) el
delay(1000); // pin
}

6.4 funciones
Una funcion es un bloque de cdigo que tiene un nombre y un conjunto de
instrucciones que son ejecutadas cuando se llama a la funcin. Son
funciones setup() y loop() de las que ya se ha hablado.

Las funciones de usuario pueden ser escritas para realizar tareas repetitivas
y para reducir el tamao de un programa. Las funciones se declaran
asociadas a un tipo de valor. Este valor ser el que devolver la funcin, por
ejemplo 'int' se utilizara cuando la funcin devuelva un dato numrico de tipo
entero. Si la funcin no devuelve ningn valor entonces se colocara delante
la palabra void, que significa funcin vaca. Despus de declarar el tipo de
dato que devuelve la funcin se debe escribir el nombre de la funcin y entre

10
parntesis se escribirn, si es necesario, los parmetros que se deben pasar
a la funcin para que se ejecute.

tipo nombreFuncin(parmetros)
{
instrucciones;
}

La funcin siguiente devuelve un numero entero, delayVal() se utiliza para


poner un valor de retraso en un programa que lee una variable analgica de
un potencimetro conectado a una entrada de Arduino. Al principio se
declara como una variable local, v recoge el valor ledo del potencimetro
que estar comprendido entre 0 y 1023, luego se divide el valor por 4 para
ajustarlo a un margen comprendido entre 0 y 255, finalmente se devuelve el
valor v y se retornara al programa principal.

int delayVal()
{
int v; // crea una variable temporal 'v'
v= analogRead(pot); // lee el valor del potencimetro
v /= 4; // convierte 0-1023 a 0-255
return v; // devuelve el valor final
}

6.5 {} entre llaves


Las llaves sirven para definir el principio y el final de un bloque de
instrucciones. Se utilizan para los bloques de programacin setup(), loop(), if,
etc.

type funcion()
{
instrucciones;
}

Una llave de apertura { siempre debe ir seguida de una llave de cierre },


si no es as el compilador dar errores.

El entorno de programacin de Arduino incluye una herramienta de gran


utilidad para comprobar el total de llaves. Solo tienes que hacer click en el
punto de insercin de una llave abierta e inmediatamente se marca el
correspondiente cierre de ese bloque (llave cerrada).

6.6 ; punto y coma


11
El punto y coma ; se utiliza para separar instrucciones en el lenguaje de
programacin de Arduino. Tambin se utiliza para separar elementos en una
instruccin de tipo bucle for.

int x = 13; // declara la variable 'x' como tipo // entero de valor 13

Nota: Si olvidas poner fin a una lnea con un punto y coma se producir en
un error de compilacin. El texto de error puede ser obvio, y se referir a la
falta de un punto y coma, o puede que no. Si se produce un error raro y de
difcil deteccin lo primero que
debemos hacer es comprobar que los puntos y comas estn colocados al
final de las instrucciones.

6.7 /* */ bloque de comentarios


Los bloques de comentarios, o comentarios multi-linea son reas de texto
ignorados por el programa que se utilizan para las descripciones del cdigo o
comentarios que ayudan a comprender el programa. Comienzan con / * y
terminan con * / y pueden abarcar
Varias lneas.

/* esto es un bloque de comentario no se debe olvidar cerrar los comentarios


estos deben estar equilibrados */ Debido a que los comentarios son
ignorados por el compilador y no
ocupan espacio en la memoria de Arduino pueden ser utilizados con
generosidad. Tambin pueden utilizarse para "comentar" bloques de cdigo
con el propsito de anotar informaciones para depuracin y hacerlo ms
comprensible para cualquiera.

Nota: Dentro de una misma lnea de un bloque de comentarios no


se puede escribir otra bloque de comentarios (usando /*..*/).

// lnea de comentarios
Una lnea de comentario empieza con / / y terminan con la siguiente lnea de
cdigo. Al igual que los comentarios de bloque, los de lnea son ignoradas
por el programa y no ocupan espacio en la memoria. // esto es un comentario

Una lnea de comentario se utiliza a menudo despus de una instruccin,


para proporcionar ms informacin acerca de lo que hace esta o para
recordarla ms adelante.

6.8 variables
Una variable es una manera de nombrar y almacenar un valor numrico para
su uso posterior por el programa. Como su nombre indica, las variables son
nmeros que se pueden variar continuamente en contra de lo que
ocurre con las constantes cuyo valor nunca cambia. Una variable debe ser
declarada y, opcionalmente, asignarle un valor. El siguiente cdigo de
12
ejemplo declara una variable llamada variableEntrada y luego le asigna el
valor obtenido en la entrada analgica del PIN2: int variableEntrada = 0; //
declara una variable y le // asigna el valor 0 variableEntrada =
analogRead(2); // la variable recoge //el valor analgico del PIN2
'variableEntrada' es la variable en s.

La primera lnea declara quesera de tipo entero int. La segunda lnea fija a
la variable el valor correspondiente a la entrada analgica PIN2. Esto hace
que el valor
de PIN2 sea accesible en otras partes del cdigo.

Una vez que una variable ha sido asignada, o re-asignada, usted puede
probar su valor para ver si cumple ciertas condiciones, o puede utilizar
directamente su valor. Como ejemplo ilustrativo veamos tres operaciones
tiles con variables:

El siguiente cdigo prueba si la variable entradaVariable es inferior a 100,


si es cierto se asigna el valor 100 a entradaVariable y, a continuacin,
establece un retardo (delay) utilizando como valor entradaVariable que
ahora ser como mnimo de valor 100:

if (entradaVariable < 100) // pregunta si la variable es


{ //menor de 100
entradaVariable = 100; // si es cierto asigna el valor
} //100
delay(entradaVariable); // usa el valor como retardo

Nota: Las variables deben tomar nombres descriptivos, para hacer el cdigo
ms legible. Los nombres de variables pueden ser contactoSensor o
pulsador, para ayudar al programador y a cualquier otra persona a leer el
cdigo y entender lo que representa
la variable. Nombres de variables como var o valor, facilitan muy poco que
el cdigo sea inteligible. Una variable puede ser cualquier nombre o palabra
que no sea una palabra reservada en el entorno de Arduino.

6.9 declaracin de variables


Todas las variables tienen que declararse antes de que puedan ser
utilizadas. Para declarar una variable se comienza por definir su tipo como int
(entero), long (largo), float (coma flotante), etc, asignndoles siempre un
nombre, y, opcionalmente, un valor inicial.
Esto solo debe hacerse una vez en un programa, pero el valor se puede
cambiar en cualquier momento usando aritmtica y reasignaciones diversas.
El siguiente ejemplo declara la variable entradaVariable como una variable
de tipo entero int, y asignndole un valor inicial igual a cero. Esto se llama
una asignacin. int entradaVariable = 0;

13
Una variable puede ser declarada en una serie de lugares del programa y en
funcin del lugar en donde se lleve a cabo la definicin esto determinara en
que partes del programa se podr hacer uso de ella.

6.10 Utilizacin de una variable


Una variable puede ser declarada al inicio del programa antes de la parte de
configuracin setup(), a nivel local dentro de las funciones, y, a veces, dentro
de un bloque, como para los bucles del tipo if..
for.., etc. En funcin del lugar de declaracin de la variable as se
determinara el mbito de aplicacin, o la capacidad de ciertas partes de un
programa para hacer uso de ella.
Una variable global es aquella que puede ser vista y utilizada por cualquier
funcin y estamento de un programa. Esta variable se declara al comienzo
del programa, antes de setup(). Una variable local es aquella que se define
dentro de una funcin o como parte de un bucle. Solo es visible y solo puede
utilizarse dentro de la funcin en la que se declar.

Por lo tanto, es posible tener dos o ms variables del mismo nombre en


diferentes partes del mismo programa que pueden contener valores
diferentes. La garanta de que solo una funcin tiene acceso a sus variables
dentro del programa simplifica y reduce el potencial
de errores de programacin. El siguiente ejemplo muestra como declarar a
unos tipos diferentes de variables y la visibilidad de cada variable:

int value; // 'value' es visible para cualquier


funcin
void setup()
{
// no es necesario configurar nada en este ejemplo
}
void loop()
{
for (int i=0; i<20;) // 'i' solo es visible
{ // dentro del bucle for
i++
} // 'f' es visible solo
float f; // dentro de loop()
}

El lenguaje de Arduino maneja los siguientes tipos de variables:

6.11 tipos de datos byte

14
Byte almacena un valor numrico de 8 bits sin decimales. Tienen un rango
entre 0 y 255.
byte unaVariable = 180; // declara 'unaVariable' como // de tipo byte

int
Enteros son un tipo de datos primarios que almacenan valores numricos de
16 bits sin decimales comprendidos en el rango 32,767 to -32,768. int
unaVariable = 1500; // declara 'unaVariable' como // una variable de tipo
entero

Nota: Las variables de tipo entero int pueden sobrepasar su valor mximo o
mnimo como consecuencia de una operacin. Por ejemplo, si x = 32767 y
una posterior declaracin agrega 1 a x, x = x + 1 entonces el valor se x
pasara a ser -32.768. (algo as como que el valor da la vuelta).

long
El formato de variable numrica de tipo extendido long se refiere a nmeros
enteros (tipo 32 bits) sin decimales que se encuentran dentro del rango -
2147483648 a 2147483647.
long unaVariable = 90000; // declara 'unaVariable' como // de tipo long.

float
El formato de dato del tipo punto flotante float se aplica a los nmeros con
decimales. Los nmeros de punto flotante tienen una mayor resolucin que
los de 32 bits con un rango comprendido

3.4028235E +38 a +38-3.4028235E.


float unaVariable = 3.14; // declara 'unaVariable' como // de tipo flotante

Nota: Los nmeros de punto flotante no son exactos, y pueden producir


resultados extraos en las comparaciones. Los clculos matemticos de
punto flotante son tambin mucho ms lentos que los del tipo de nmeros
enteros, por lo que debe evitarse su uso si
es posible.

arrays
Un array es un conjunto de valores a los que se accede con un nmero
ndice. Cualquier valor puede ser recogido haciendo uso del nombre de la
matriz y el nmero del ndice. El primer valor de la matriz es el que est
indicado con el ndice 0, es decir el primer valor
del conjunto es el de la posicin 0. Un array tiene que ser declarado y
opcionalmente asignados valores a cada posicin antes de ser utilizado.

int miArray[] = {valor0, valor1, valor2...}

Del mismo modo es posible declarar una matriz indicando el tipo de datos y
el tamao y posteriormente, asignar valores a una posicin especifica:
15
int miArray[5]; // declara un array de enteros de 6
// posiciones
miArray[3] = 10; // asigna l valor 10 a la posicin 4
Para leer de un array basta con escribir el nombre y la posicin a leer
:x = miArray[3]; // x ahora es igual a 10 que est en
// la posicin 3 del array

Las matrices se utilizan a menudo para estamentos de tipo bucle, en los que
la variable de incremento del contador del bucle se utiliza como ndice o
puntero del array. El siguiente ejemplo usa una matriz para el parpadeo de
un LED.

Utilizando un bucle tipo for, el contador comienza en cero 0 y escribe el valor


que figura en la posicin de ndice 0 en la serie que hemos escrito dentro del
array parpadeo[], en este caso 180, que se enva a la salida analgica tipo
PWM configurada en el PIN10, se hace una pausa de 200 ms y a
continuacin se pasa al siguiente valor que asigna el ndice i.

int ledPin = 10; // LED en el PIN 10


byte parpadeo[] = {180, 30, 255, 200, 10, 90, 150, 60};
// array de 8 valores
void setup()
{
pinMode(ledPin, OUTPUT); // configura la salida
}
void loop()
{
for(int i=0; i<7; i++)
{
analogWrite(ledPin, parpadeo[i]);
delay(200); // espera 200ms
}
}

6.12 aritmtica
Los operadores aritmticos que se incluyen en el entorno de programacin
son suma, resta, multiplicacin y divisin. Estos devuelven la suma,
diferencia, producto, o cociente (respectivamente) de dos operando.

y = y + 3; x = x - 7; i = j * 6; r = r / 5;

La operacin se efecta teniendo en cuenta el tipo de datos que hemos


definido para los operandos (int, dbl, float, etc.), por lo que, por ejemplo, si
definimos 9 y 4 como enteros int, 9 / 4 devuelve de resultado 2 en lugar de

16
2,25 ya que el 9 y 4 se valores de tipo entero int (enteros) y no se
reconocen los decimales con este tipo de
Datos.

Esto tambin significa que la operacin puede sufrir un desbordamiento si el


resultado es ms grande que lo que puede ser almacenada en el tipo de
datos. Recordemos el alcance de los tipos de datos numricos que ya hemos
explicado anteriormente.
Si los operandos son de diferentes tipos, para el clculo se utilizara el tipo
ms grande de los operandos en juego. Por ejemplo, si uno de los nmeros
(operandos) es del tipo float y otra de tipo integer, para el clculo se utilizara
el mtodo de float es decir el mtodo de
Coma flotante.

Elija el tamao de las variables de tal manera que sea lo suficientemente


grande como para que los resultados sean lo precisos que usted desea. Para
las operaciones que requieran decimales utilice variables tipo float, pero sea
consciente de que las operaciones con este tipo de variables son ms lentas
a la hora de realizarse el cmputo.

Nota: Utilice el operador (int) para convertir un tipo de variable a otro sobre la
marcha. Por ejemplo, i = (int) 3,6 establecer i igual a 3.

6.13 Asignaciones compuestas


Las asignaciones compuestas combinan una operacin aritmtica con una
variable asignada. Estas son comnmente utilizadas en los bucles tal como
se describe ms adelante.

Estas asignaciones compuestas pueden ser:


x ++ // igual que x = x +1, o incremento de x en +1
x -- // igual que x = x - 1, o decremento de x en -1
x += y // igual que x = x + y, o incremento de x en +y
x -= y // igual que x = x - y, o decremento de x en -y
x *= y // igual que x = x * y, o multiplica x por y
x /= y // igual que x = x / y, o divide x por y

Nota: Por ejemplo, x * = 3 hace que x se convierta en el triple del antiguo


valor x y por lo tanto x es reasignada al nuevo valor.

6.14 Operadores de comparacin


Las comparaciones de una variable o constante con otra se utilizan con
frecuencia en las estructuras condicionales del tipo if.. Para testear si una
condicin es verdadera. En los ejemplos que siguen en las prximas pginas
se ver su utilizacin practica usando los
siguientes tipo de condicionales:
17
x == y // x es igual a y
x != y // x no es igual a y
x < y // x es menor que y
x > y // x es mayor que y
x <= y // x es menor o igual que y
x >= y // x es mayor o igual que y

6.15 Operadores lgicos


Los operadores lgicos son usualmente una forma de comparar dos
expresiones y devolver un VERDADERO o FALSO dependiendo del
operador. Existen tres operadores lgicos, AND (&&), OR (||) y NOT (!), que a
menudo se utilizan en estamentos de tipo if:

Lgica AND:
if (x > 0 && x < 5) // cierto slo si las dos
Expresiones // son ciertas

Lgica OR:
if (x > 0 || y > 0) // cierto si una cualquiera de las
// Expresiones es cierta

Lgica NOT:
if (!x > 0) // cierto solo si la expresin es
// Falsa

6.16 Constantes
El lenguaje de programacin de Arduino tiene unos valores predeterminados,
que son llamados constantes. Se utilizan para hacer los programas ms
fciles de leer. Las constantes se clasifican en grupos.

6.17 cierto/falso (true/false)


Estas son constantes booleanas que definen los niveles HIGH (alto) y LOW
(bajo) cuando estos se refieren al estado de las salidas digitales. FALSE se
asocia con 0 (cero), mientras que TRUE se asocia con 1, pero TRUE tambin
puede ser cualquier otra cosa
excepto cero. Por lo tanto, en sentido booleano, -1, 2 y -200 son todos
tambin se define como TRUE. (esto es importante tenerlo en cuanta).

if (b == TRUE);
{
Ejecutar las instrucciones;
}

6.18 high/low
Estas constantes definen los niveles de salida altos o bajos y se utilizan para
la lectura o la escritura digital para las patillas. ALTO se define como en la
18
lgica de nivel 1, ON, o 5 voltios, mientras que BAJO es lgica nivel 0, OFF,
o 0 voltios.

digitalWrite(13, HIGH); // activa la salida 13 con un


// Nivel alto (5v.)

6.19 input/output
Estas constantes son utilizadas para definir, al comienzo del programa, el
modo de funcionamiento de los pines mediante la instruccin pinMode de tal
manera que el pin puede ser una entrada INPUT o una salida OUTPUT.

pinMode(13, OUTPUT); // designamos que el PIN 13 es


// Una salida

6.20 Control de flujo


if (si condicional)
if es un estamento que se utiliza para probar si una determinada condicin se
ha alcanzado, como por ejemplo averiguar si un valor analgico est por
encima de un cierto nmero, y ejecutar una serie de declaraciones
(operaciones) que se escriben dentro de llaves, si es verdad. Si es falso (la
condicin no se cumple) el programa salta y no ejecuta las operaciones que
estn dentro de las llaves, El formato para if es el siguiente:

if (unaVariable ?? valor)
{
Ejecuta Instrucciones;
}

En el ejemplo anterior se compara una variable con un valor, el cual puede


ser una variable o constante. Si la comparacin, o la condicin entre
parntesis se cumple (es cierta), las declaraciones dentro de los corchetes se
ejecutan. Si no es as, el programa salta sobre ellas y sigue.

Nota: Tenga en cuenta el uso especial del smbolo '=', poner dentro de if (x =
10), podra parecer que es vlido pero sin embargo no lo es ya que esa
expresin asigna el valor 10 a la variable x, por eso dentro de la estructura if
se utilizara X==10 que en este caso lo que
Hace el programa es comprobar si el valor de x es 10. Ambas cosas son
distintas por lo tanto dentro de las estructuras if, cuando se pregunte por un
valor se
Debe poner el signo doble de igual ==.

if else (si.. sino ..)


if else viene a ser un estructura que se ejecuta en respuesta a la idea si
esto no se cumple haz esto otro. Por ejemplo, si se desea probar una
entrada digital, y hacer una cosa si la entrada fue alto o hacer otra cosa si la
entrada es baja, usted escribira que de esta manera:
19
if (inputPin == HIGH)
{
instruccionesA;
}
else
{
instruccionesB;
}

Else puede ir precedido de otra condicion de manera que se pueden


establecer varias estructuras condicionales de tipo unas dentro de las otras
(anidamiento) de forma que sean mutuamente excluyentes pudindose
ejecutar a la vez. Es incluso posible tener un
Nmero ilimitado de estos condicionales. Recuerde sin embargo que solo un
conjunto de declaraciones se llevara a cabo dependiendo de la condicion
probada:

if (inputPin < 500)


{
instruccionesA;
}
else if (inputPin >= 1000)
{
instruccionesB;
{
else
{
instruccionesC;
}

Nota: Un estamento de tipo if prueba simplemente si la condicin dentro del


parntesis es verdadera o falsa. Esta declaracin puede ser cualquier
declaracin valida. En el anterior ejemplo, si cambiamos y ponemos (inputPin
== HIGH). En este caso, el estamento if solo chequeara si la entrada
especificado esta en nivel alto (HIGH), o +5v.

6.21 for
La declaracin for se usa para repetir un bloque de sentencias encerradas
entre llaves un nmero determinado de veces. Cada vez que se ejecutan las
instrucciones del bucle se vuelve a testear la condicion. La declaracin for
tiene tres partes separadas por (;), vemos el ejemplo de su sintaxis:

for (inicializacin; condicin; expresin)


{
Instrucciones;
}
20
La inicializacin de una variable local se produce una sola vez y la condicion
se testea cada vez que se termina la ejecucin de las instrucciones dentro
del bucle. Si la condicion sigue cumplindose, las instrucciones del bucle se
vuelven a ejecutar. Cuando la condicion no se cumple, el bucle termina. El
siguiente ejemplo inicia el entero i en el 0, y la condicion es probar que el
valor es inferior a 20 y si es cierto i se incrementa en 1 y se
Vuelven a ejecutar las instrucciones que hay dentro de las llaves:

for (int i=0; i<20; i++) // declara i y prueba si es


{ // Menor que 20, incrementa i.
digitalWrite(13, HIGH); // enciende el pin 13
delay(250); // espera seg.
digitalWrite(13, LOW); // apaga el pin 13
delay(250); // espera de seg.
}

Nota: El bucle en el lenguaje C es mucho ms flexible que otros bucles


encontrados en algunos otros lenguajes de programacin, incluyendo BASIC.
Cualquiera de los tres elementos de cabecera puede omitirse, aunque el
punto y coma es obligatorio. Tambin las declaraciones de inicializacin,
condicion y expresin puede ser cualquier estamento valido en lenguaje C
sin relacin con las variables declaradas. Estos tipos de estados son raros
pero permiten disponer soluciones a algunos problemas de programacin
raras.

6.22while
Un bucle del tipo while es un bucle de ejecucin continua mientras se cumpla
la expresin colocada entre parntesis en la cabecera del bucle. La variable
de prueba tendr que cambiar para salir del bucle. La situacin podr
cambiar a expensas de una expresin dentro el cdigo del bucle o tambin
por el cambio de un valor en una entrada de un sensor.

while (unaVariable ?? valor)


{
ejecutarSentencias;
}

El siguiente ejemplo testea si la variable "unaVariable es inferior a 200 y, si


es verdad, ejecuta las declaraciones dentro de los corchetes y continuara
ejecutando el bucle hasta que 'unaVariable' no sea inferior a 200.

While (unaVariable < 200) // testea si es menor que 200


{
instrucciones; // ejecuta las instrucciones
// entre llaves
unaVariable++; // incrementa la variable en 1
21
}

6.23 do while
El bucle do while funciona de la misma manera que el bucle while, con la
salvedad de que la condicion se prueba al final del bucle, por lo que el bucle
siempre se ejecutara al menos una vez.

do
{
Instrucciones;
} while (unaVariable ?? valor);

El siguiente ejemplo asigna el valor ledo leeSensor() a la variable


'x', espera 50 milisegundos, y luego continua mientras que el valor
de la 'x' sea inferior a 100:

do
{
25
x = leeSensor();
delay(50);
} while (x < 100);

6.24 e/s digitales pinMode(pin, mode)


Esta instruccin es utilizada en la parte de configuracin setup () y sirve para
configurar el modo de trabajo de un PIN pudiendo ser INPUT (entrada) u
OUTPUT (salida).

pinMode(pin, OUTPUT); // configura pin como salida

Los terminales de Arduino, por defecto, estn configurados como entradas,


por lo tanto no es necesario definirlos en el caso de que vayan a trabajar
como entradas. Los pines configurados como entrada quedan, bajo el punto
de vista elctrico, como entradas en
Estado de alta impedancia.

Estos pines tienen a nivel interno una resistencia de 20 K a las que se


puede acceder mediante software. Estas resistencias se acceden de la
siguiente manera:

pinMode(pin, INPUT); // configura el pin como


// entrada
digitalWrite(pin, HIGH); // activa las resistencias
// internas

22
Las resistencias internas normalmente se utilizan para conectar las entradas
a interruptores. En el ejemplo anterior no se trata de convertir un pin en
salida, es simplemente un mtodo para activar las resistencias interiores.

Los pins configurado como OUTPUT (salida) se dice que estn en un estado
de baja impedancia estado y pueden proporcionar 40 mA (miliamperios) de
corriente a otros dispositivos y circuitos. Esta corriente es suficiente para
alimentar un diodo LED (no olvidando poner una resistencia en serie), pero
no es lo suficiente grande como para alimentar cargas de mayor consumo
como rels, solenoides, o motores. Un cortocircuito en las patillas Arduino
provocara una corriente elevada que puede daar o destruir el chip Atmega.
A menudo es 27 una buena idea conectar en la OUTUPT (salida) una
resistencia
externa de 470 o de 1000 .

6.25 digitalRead(pin)
Lee el valor de un pin (definido como digital) dando un resultado HIGH (alto)
o LOW (bajo). El pin se puede especificar ya sea como una variable o una
constante (0-13).
valor = digitalRead(Pin); // hace que 'valor sea igual // al estado ledo en Pin

6.26 digitalWrite(pin, value)


Envia al pin definido previamente como OUTPUT el valor HIGH o LOW
(poniendo en 1 o 0 la salida). El pin se puede especificar ya sea como una
variable o como una constante (0-13).digitalWrite(pin, HIGH); // deposita en el
'pin' un valor // HIGH (alto o 1).

El siguiente ejemplo lee el estado de un pulsador conectado a una entrada


digital y lo escribe en el pinde salida LED:

int led = 13; // asigna a LED el valor 13


int boton = 7; // asigna a botn el valor 7
int valor = 0; // define el valor y le asigna el
// valor 0
void setup()
{
pinMode(led, OUTPUT); // configura el led (pin13) como
salida
pinMode(boton, INPUT); // configura botn (pin7) como
entrada
}
void loop()
{
valor = digitalRead(boton); //lee el estado de la
// entrada botn
digitalWrite(led, valor); // enva a la salida ledel
} // valor ledo
23
6.27 e/s analgicas analogRead(pin)
Lee el valor de un determinado pin definido como entrada analgica con una
resolucin
de 10 bits. Esta instruccin solo funciona en los pines (0-5). El rango de valor
que podemos leer oscila de 0 a 1023.

valor = analogRead(pin); // asigna a valor lo que lee


// en la entrada pin'

Nota: Los pins analogicos (0-5) a diferencia de los pines digitales, no


necesitan ser declarados como INPUT u OUPUT ya que son siempre
INPUTs.

6.28 analogWrite(pin, value)


Esta instruccin sirve para escribir un pseudo-valor analgico utilizando el
procedimiento de modulacin por ancho de pulso (PWM) a uno de los pins
de Arduino marcados como pin PWM. El ms reciente Arduino, que
implementa el chip ATmega168, permite habilitar como salidas analgicas
tipo PWM los pines 3, 5, 6, 9, 10 y 11. Los modelos de Arduino ms antiguos
que implementan el chip ATmega8, solo tiene habilitadas para esta funcin
los pines 9, 10 y 11. El valor que se puede enviar a estos pines de salida
analgica
Puede darse en forma de variable o constante, pero siempre con un margen
de 0-255.

analogWrite(pin, valor); // escribe 'valor' en el 'pin'


// definido como analgico

Si enviamos el valor 0 genera una salida de 0 voltios en el pin especificado;


un valor de 255 genera una salida de 5 voltios de salida en el pin
especificado. Para valores de entre 0 y 255, el pin saca tensiones entre 0 y 5
voltios - el valor HIGH de salida equivale a 5v (5 voltios). Teniendo en cuenta
el concepto de seal PWM , por ejemplo, un valor de 64 equivaldr a
mantener 0 voltios de tres cuartas partes del tiempo y 5 voltios a una cuarta
parte del tiempo; un valor de 128 equivaldr a mantener la salida en 0 la
mitad del tiempo y 5 voltios la otra mitad del tiempo, y un valor de 192
equivaldr a mantener en la salida 0 voltios una cuarta parte del tiempo y de
5 voltios de tres cuartas partes del tiempo restante.

Debido a que esta es una funcin de hardware, en el pin de salida analgica


(PWN) se generara una onda constante despus de ejecutada la instruccin
analogWrite hasta que se llegue a ejecutar otra instruccin analogWrite (o
una llamada a digitalRead o
digitalWrite en el mismo pin).

24
Nota: Las salidas analgicas a diferencia de las digitales, no necesitan ser
declaradas como INPUT u OUTPUT.

El siguiente ejemplo lee un valor analgico de un pin de entrada analgica,


convierte el valor dividindolo por 4, y enva el nuevo valor convertido a una
salida del tipo PWM o salida analgica:

int led = 10; // define el pin 10 como led


int analog = 0; // define el pin 0 como analog
int valor; // define la variable valor
void setup(){} // no es necesario configurar
// entradas y salidas
void loop()
{
valor = analogRead(analog); // lee el pin 0 y lo
asocia a //la variable valor
valor /= 4; //divide valor entre 4 y lo
//reasigna a valor
analogWrite(led, value); // escribe en el pin10 valor
}

6.29 control del tiempo delay(ms)


Detiene la ejecucin del programa la cantidad de tiempo en ms que se indica
en la propia instruccin. De tal manera que 1000 equivale a 1seg.

delay(1000); // espera 1 segundo

6.30 millis()
Devuelve el nmero de milisegundos transcurrido desde el inicio del
programa en Arduino hasta el momento actual. Normalmente ser un valor
grande (dependiendo del tiempo que est en marcha la aplicacin despus
de cargada o despus de la ltima vez que se
pulso el botn reset de la tarjeta).

valor = millis(); // valor recoge el nmero de


// milisegundos

Nota: Este nmero se desbordara (si no se resetea de nuevo a cero),


despus de aproximadamente 9 horas.

6.31 Matemticas min(x, y)


Calcula el mnimo de dos nmeros para cualquier tipo de datos devolviendo
el nmero ms pequeo.

valor = min(valor, 100); // asigna a valor el ms


// pequeos de los dos
// nmeros especificados.
25
Si 'valor' es menor que 100 valor recoger su propio valor si valor es mayor
que 100 valor pasara a valer 100.

6.32 max(x, y)
Calcula el mximo de dos nmeros para cualquier tipo de datos devolviendo
el nmero mayor de los dos.

valor = max(valor, 100); // asigna a valor el mayor de


// los dos nmeros 'valor' y
// 100.
De esta manera nos aseguramos de que valor ser como mnimo 100.

6.33 aleatorios randomSeed(seed)


Establece un valor, o semilla, como punto de partida para la funcin
random().

randomSeed(valor); // hace que valor sea la semilla del


// random

Debido a que Arduino es incapaz de crear un verdadero nmero aleatorio,


randomSeed le permite colocar una variable, constante, u otra funcin de
control dentro de la funcin random, lo que permite generar nmeros
aleatorios "al azar". Hay una variedad de semillas, o funciones, que pueden
ser utilizados en esta funcin, incluido millis () o incluso analogRead () que
permite leer ruido elctrico a travs de un pin analgico.

6.34 random(max), random(min, max)


La funcin random devuelve un nmero aleatorio entero de un intervalo de
valores especificado entre los valores min y max.

valor = random(100, 200); // asigna a la variable


// 'valor' un numero aleatorio
// comprendido entre 100-200

Nota: Use esta funcin despus de usar el randomSeed(). El siguiente


ejemplo genera un valor aleatorio entre 0-255 y lo enva a una salida
analgica PWM :

int randNumber; // variable que almacena el valor


// aleatorio
int led = 10; // define led como 10
void setup() {} // no es necesario configurar nada
void loop()
{
randomSeed(millis()); // genera una semilla para
// aleatorio a partir
26
// de la funcin millis()
randNumber = random(255); // genera nmero aleatorio
// entre 0-255
analogWrite(led, randNumber); // enva a la salida
// led de tipo PWM el
// valor
delay(500); // espera 0,5 seg.
}

6.35 comunicacin serie Serial.begin(rate)


Abre el puerto serie y fija la velocidad en baudios para la transmisin de
datos en serie.
El valor tipico de velocidad para comunicarse con el ordenador es 9600,
aunque otras velocidades pueden ser soportadas.

void setup()
{
Serial.begin(9600); // abre el Puerto serie
} // configurando la velocidad en 9600 bps

Nota: Cuando se utiliza la comunicacin serie los pins digital 0 (RX) y 1 (TX)
no puede utilizarse al mismo tiempo.

6.36 Serial.println(data)
Imprime los datos en el puerto serie, seguido por un retorno de carro
automtico y salto de lnea. Este comando toma la misma forma que
Serial.print(), pero es ms fcil para la lectura de los datos en el Monitor
Serie del software.

Serial.println(analogValue); // enva el valor


// 'analogValue' al
// puerto

Nota: Para obtener mas informacin sobre las distintas posibilidades de


Serial.println () y Serial.print () puede consultarse el sitio web de Arduino.

El siguiente ejemplo toma de una lectura analgica pin0 y enva estos datos
al ordenador cada 1 segundo.

void setup()
{
Serial.begin(9600); // configura el puerto serie a
// 9600bps
}
void loop()
{
27
Serial.println(analogRead(0)); // enva valor analgico
delay(1000); // espera 1 segundo
}

6.37 Serial.print(data, data type)


Vuelca o enva un nmero o una cadena de caracteres, al puerto serie. Dicho
comando puede tomar diferentes formas, dependiendo de los parmetros
que utilicemos para definir el formato de volcado de los nmeros.

6.38 Parmetros
data: el nmero o la cadena de caracteres a volcar o enviar.
data type: determina el formato de salida de los valores numricos (decimal,
octal, binario, etc...) DEC, OCT, BIN, HEX, BYTE , si no se pe nada vuelva
ASCII
Ejemplos:
Serial.print(b) // Vuelca o enva el valor de b como
// un nmero decimal en caracteres
// ASCII.
int b = 79;
Serial.print(b); // imprime la cadena "79".
Serial.print(b, HEX); // Vuelca o enva el valor de
// b como un nmero hexadecimal
// en caracteres ASCII "4F".
Serial.print(b, OCT); // Vuelca o enva el valor de
// b como un nmero Octal en
// caracteres ASCII "117".
Serial.print(b, BIN) // Vuelca o enva el valor de
// b como un nmero binario en
// caracteres ASCII "1001111".
Serial.print(b, BYTE); // Devuelve el caracter "O",
// el cual representa el
// caracter ASCII del valor
// 79. (Ver tabla ASCII).
Serial.print(str); //Vuelca o enva la cadena de
// caracteres como una cadena ASCII.
Serial.print("Hello World!"); // vuelca "Hello World!".

6.39 Serial.avaible()
Devuelve Un entero con el nmero de bytes disponibles para leer desde el
buffer serie, o 0 si no hay ninguno. Si hay algn dato disponible,
SerialAvailable() ser mayor que 0. El buffer serie puede almacenar como
mximo 64 bytes.

int Serial.available() // Obtiene un nmero entero


// con el nmero de bytes
// (caracteres) disponibles
// para leer o capturar desde
28
// el puerto serie

Ejemplo
int incomingByte = 0; // almacena el dato serie
void setup() {
Serial.begin(9600); // abre el puerto serie, y le asigna
// la velocidad de 9600 bps
}
void loop() {
if (Serial.available() > 0) // enva datos slo si
{ // los recibe:
incomingByte = Serial.read();// lee el byte de entrada:
//lo vuelca a pantalla
Serial.print("I received: ");
Serial.println(incomingByte, DEC);
}
}

6.40 Serial.Read()
Lee o captura un byte (un caracter) desde el puerto serie. Devuelve el
siguiente byte (caracter) desde el puerto serie, o -1 si no hay ninguno.

Ejemplo:
int incomingByte = 0; // almacenar el dato serie
void setup() {
Serial.begin(9600); // abre el puerto serie,y le asigna
// la velocidad de 9600 bps
}
void loop() {
if (Serial.available() > 0)// enva datos slo si los
{ // recibe
incomingByte = Serial.read(); // lee el byte de
// entrada y lo vuelca
Serial.print("I received: "); // a pantalla
Serial.println(incomingByte, DEC);
}

9 Las libreras: qu son y para qu sirven


29
En el mundo del software, una librera es una coleccin de programas que
facilita la ejecucin de una serie de funciones relacionadas entre s. Por
ejemplo las funciones que facilitan la escritura en una pantalla LCD o las que
nos permiten calcular la posicin de un sistema de navegacin GPS.

Las libreras de software funcionan de la misma manera que una biblioteca


tradicional: pides informacin sobre un tema concreto y despus la utilizas
dentro de tu proyecto segn te convenga o la necesites.

En el mundo de Arduino, una librera es una coleccin de funciones que


incluyes de una manera muy sencilla y explcita en tu sketch y que
proporciona una cierta funcionalidad especfica. Por ejemplo, hay una librera
de cristal lquido que, cuando est incluida en tu sketch, te dar la capacidad
de usar fcilmente una pantalla LCD. Una misma librera puede usarse en
varios proyectos diferentes.

Algunas libreras se pueden utilizar sin necesidad de extender el Arduino con


otros dispositivos, mientras que otras necesitan ser utilizadas con
componentes electrnicos adicionales, a menudo bajo la forma de shields
(escudos = componentes adicionales de mayor o menor complejidad, pero
que cubren una funcin especfica).

9.1 Tipos de libreras

Hay tres diversos tipos de libreras de Arduino: base, estndar, y


contribuciones (contributed librairies). Comenzaremos con la librera de
base.

librera de base (Core library)

La biblioteca de la base forma parte del entorno de desarrollo del Arduino


(IDE). El propsito de esta librera es ocultar mucha de la complejidad que
tradicionalmente implica el trabajar con el microprocesador.

En efecto, esta es una de las razones aducidas ms frecuentemente por


principiantes y usuarios experimentados sobre la dificultad de trabajar con
microprocesadores tradicionales. Esta librera de base (core) es una de las
grandes ventajas del Arduino al hacerlo fcilmente accesible a todos los
usuarios.

Los diseadores del Arduino desarrollaron esta librera a partir de las


peticiones de los estudiantes e incluye aquellas acciones que son ms
comunes.

La mayora de los proyectos leen datos de una de las entradas o escriben


datos en una de las salidas. La librera core hace que estas tareas comunes

30
sean simples ejecutar. Por ejemplo, para leer el valor de un pin digital basta
con usar la funcin digitalRead (por otra parte, el nombre es fcil de
recordar).

En el captulo precedente (funciones) hemos visto todas las funciones de


base (core) que constituyen el ncleo del Arduino. A continuacin vamos a
pasar revista a las libreras estndar que forman parte del IDE del Arduino.

Libreras estndar

Al descargar e instalar en tu ordenador el entorno de desarrollo del Arduino


(IDE), se incluyeron algunas libreras estndar con la instalacin. Las
libreras estndar son aquellas que el equipo de desarrollo de Arduino estim
que seran necesarias para los desarrollos de muchos usuarios.

Estas libreras no se incluyen como opcin por defecto en tus sketches,


tienes que cargarlas una por una (aquellas que necesites). De esta manera
se utilizan los recursos de memoria del Arduino con mayor eficiencia al
cargar nicamente aquellas libreras que vas a usar en tu sketch.

Para incluir un librera basta con aadir una declaracin #include al comienzo
del sketch. Por ejemplo, si quieres incluir la librera de cristal lquido, que se
utiliza para exhibir datos en una pantalla LCD, basta con incluir la siguiente
declaracin al principio de tu sketch:

#include <LiquidCrystal.h>

Observa que el nombre de la librera tiene que ir limitado por los corchetes
menor/mayor: < y >. Adems hay que notar que la lnea no termina con un
punto y coma (;) como es la norma en las dems lneas de cdigo.

A continuacin veremos las diferentes libreras estndar:

1. Librera ArduinoTestSuite
2. Librera EEPROM
3. Librera SD
4. Librera Ethernet
5. Librera Firmata
6. Librera LiquidCrystal
7. Librera Servo
8. Librera Stepper
9. Librera SPI
10. Librera Wire
11. Librera SoftwareSerial

31
9.2 Programacin en un entorno de test: ArduinoTestSuite

La manera en que los programas y aplicaciones para Arduino se escriben


est sujeta a una continua evolucin y mejora. La innovacin ms reciente
consiste en un entorno de programacin llamado test-driven-development
(TDD, desarrollo bajo test).

En TDD, un proyecto de software se divide en pequeos mdulos, y antes de


escribir un mdulo dado, estableces las pruebas (tests) que verifican el
funcionamiento de cada funcin del mdulo.

Cuando finalmente escribes el mdulo, se ejecuta bajo un entorno de test


que comprueba que los resultados obtenidos por el mdulo son los descritos
en el entorno de test que definiste previamente. Si no es as corriges los
errores y vuelves a ejecutar el mdulo en el entorno de test.

Cuando un mdulo ha pasado los tests, desarrollas el siguiente mdulo de la


misma manera y as hasta que el proyecto haya sido completado. Si ms
tarde tienes que modificar uno de los mdulos lo ejecutas bajo el entorno de
test hasta que funcione de acuerdo con las especificaciones.

La biblioteca ArduinoTestSuite es el primer paso para implantar esta


metodologa TDD en el Arduino. Se trata de una librera relativamente nueva,
pero se considera como esencial para el futuro del desarrollo en Arduino.

La librera ArduinoTestSuite proporciona mtodos estndar y funciones que


se pueden utilizar para probar sus sketches antes de cargarlos en el Arduino.
De esta manera nos aseguramos de que el sketch funcione segn lo previsto
antes de usarlo en el mundo real con costosos dispositivos que pueden ser
daados si se utilizan incorrectamente.

La librera est todava en fase de desarrollo, pero tiene actualmente tests


para los procesos listados en la tabla siguiente:

Test Description
ATS_begin Inicia el proceso de test
ATS_end Termina el proceso de test
ATS_Test_DigitalPin Testea un pin de entrada digital dado
ATS_Test_PWM Testea la salida PWM
ATS_Test_AnalogInput Testea la entrada analogical
ATS_Test_EEPROM Testea la EEPROM
ATS_TestSerialLoopBack Testea los pins RX y TX de una puerta Serie
Devuelve el nmero de posiciones libres de
ATS_GetFreeMemory
memoria en el Arduino

32
La idea de incorporar un entorno de test como parte del Arduino IDE es
nueva, pero se convertir probablemente en una parte importante del IDE a
medida que la funcionalidad de los Arduinos siga evolucionando.

9.3 Usando la EEPROM como sistema de almacenamiento de datos

La memoria EEPROM es un tipo de memoria de slo lectura que puede ser


borrada y reescrita mediante la aplicacin de una tensin elctrica y al mismo
tiempo conserva los datos almacenados incluso tras desconectar la
alimentacin de la placa del microprocesador.

La cantidad de EEPROM en un Arduino depende del microprocesador de


base que lleve.El cuadro siguiente muestra la cantidad (en octetos o bytes)
de memoria EEPROM disponible en diversos Arduinos.

Microprocesador EEPROM memory (bytes)


ATMega8 and ATMega168 512
ATMega328 1,024
ATMega1280 and ATMega2560 4,096

Nota: El Arduino Uno basado en el chip ATMega328; tiene 1.024 bytes


de memoria EEPROM.

La librera EEPROM proporciona sketches que permiten el acceso a la


EEPROM del Arduino e incluye dos funciones, read y write, tal y como se
muestra en cuadro de abajo.

Function Description
Lee el valor de un byte almacenado en una posicin de la
Read
EEPROM
Write Escribe un valor en una posicin de la EEPROM

Nota: Cualquier dato escrito en la EEPROM se conserva incluso


cuando el Arduino se apaga.

Un buen uso de la librera EEPROM puede ser el almacenamiento de


aquellos datos que sern necesarios entre dos sesiones de uso del Arduino

33
(contadores, constantes necesarias para el uso de ciertos dispositivos
perifricos, como una pantalla LCD, etc.).

Si el volumen de datos que quieres almacenar entre sesin y sesin es


considerable, debes de usar una memoria SD.

9.4 Almacenando datos en un tarjeta SD

El Arduino no est dotado con memoria RAM ni memoria masiva para


almacenar datos en grandes cantidades.

En efecto, la memoria EEPROM integrada en el microprocesador slo puede


almacenar unos pocos cientos de octetos en el mejor de los casos. Para
almacenar volmenes considerables de datos (tal como demandan la mayor
parte de las aplicaciones) tenemos que recurrir a tarjetas de memoria SD o
SDHC.

Una de las muchas ventajas de estas memorias es que estn fcilmente


disponibles en una variedad de tamaos de memoria y de precios (en
general relativamente baratos). La tabla de abajo muestra las diferencias
entre las tarjetas SD y las SD de alta capacidad (SDHC).

SD SDHC
Capacidad 02 GB 4 GB32 GB
Sistema de Almacenamiento de
FAT16 o FAT32 FAT32
ficheros

William Greiman escribi una librera para Arduino llamada SdFat basada en
los sistemas de codificacin de ficheros FAT16 y FAT 32. La librera SdFat
proporciona una gama exhaustiva de funciones para el manejo de estas
tarjetas de memoria: crear y suprimir ficheros y directorios, formateo, etc.

El equipo de desarrollo del Arduino se di cuenta de que esta librera es


relativamente difcil de utilizar, as que construyeron una envoltura alrededor
de ella, hacindola ms sencilla de usar e incluyendo solamente un
subconjunto de sus funciones.

Nota: La librera utiliza mucha memoria de programa, lo cual limita el


tamao de tus sketches, por lo tanto se recomienda el uso de esta
librera solamente con un Arduino equipado de un procesador
ATMega328P.

34
Cuando se incluye esta librera en un sketch, la librera SD proporciona una
gama de funciones bsicas (ver siguiente tabla) que permiten a tu Arduino
interaccionar con las tarjetas SD:

Clase Funcin Descripcin


SD begin Inicializa la librera y la tarjeta SD
exists Verifica la existencia de un fichero o directorio en la tarjeta
mkdir Crea un directorio en la tarjeta
rmdir Suprime un directorio en la tarjeta
remove Suprime un fichero de la tarjeta
open Abre un fichero en la tarjeta
File available Verifica que quedan bytes por leer en el fichero
Cierra un fichero y se asegura que los datos escritos en l han sido
close
salvaguardados en la tarjeta.
seek Busca una posicin en un fichero
position Devuelve la posicin actual dentro del fichero.
size Devuelve el tamao del fichero.
print Escribe datos en un fichero abierto.
println Escribe datos en un fichero y aade un carcter newline al final.
write Escribe datos en un fichero
read Lee un octeto (byte) de un fichero abierto.

Nota: La librera SD usa solamente la nomenclatura 8,3 (8 caracteres


para el nombre del fichero y 3 para la extensin). No se pueden usar
nombres de fichero ms largos o conteniendo espacios.

Arduino usa un bus serie para comunicar con sus perifricos (el bus SPI del
que hablaremos ms adelante) y en particular con la tarjeta SD (pins digitales
11, 12, y 13 en un Arduino estndar y 50, 51, y 52 en un Mega).

Adems, el pin 10 se usa generalmente para seleccionar el dispositivo de


tarjeta en un Arduino estndar y el 53 en un Mega. Podemos usar un pin
diferente para esta funcin usando la funcin SD.begin.

Nota: Antes de usar una tarjeta SD en el Arduino, debemos


formatearla en formato FAT16 o FAT32 usando tu ordenador y el
lector de tarjetas.

35
Existen microSDshields disponibles en el mercado. Asimismo est disponible
una gama de shields con conectores integrados microSDcard, incluyendo el
ltimo shield oficial Ethernet y shields de registro de datos.

9.5 Conectndose con Ethernet

Si quieres que tus aplicaciones Arduino sean accesibles a otras personas de


nuestro entorno (o a travs de internet) vas a necesitar la librera Ethernet
que te simplificar el acceso a funciones TCP/IP y te permitir comunicar tu
Arduino con Internet o la red domstica.

Esta librera est diseada para interactuar con placas basadas en WIZnet
W5100. La placa oficial ms reciente de Arduino lleva incorporada tambin
un conector microSDcard que resulta muy apropiado para el registro
y almacenamiento continuo de datos.

De esta manera puedes, por ejemplo, utilizar el Arduino para tomar lecturas
de datos en una ubicacin remota y publicar estos datos en una pgina web
bsica mientras los almacena en un microSDcard que podra ser recuperado
y analizado ms adelante.

La biblioteca de Ethernet es muy extensa y permite configurar el Arduino


como servidor recibiendo conexiones de clientes, o como cliente, que se va
conectando con uno o varios servidores. La tabla siguiente muestra algunas
de las funciones de la librera.

Class Function Description


Ethernet begin Inicializa la librera y configura los parmetros de red
localIP Devuelve la direccin IP local
dnsServerIP Devuelve la direccin DNS del servidor
Server Server Crea un servidor
begin Comienza a escuchar posibles peticiones de conexin
Localiza un cliente para el que tiene datos disponibles para su
available
lectura
write Escribe datos a clientes; tipo: byte o char
Escribe datos a clientes; tipo puede ser: byte, char, int, long, o
print
string
println Escribe datos a clientes, seguidos por un carcter newline
Client Client Crea un cliente
connected Devuelve TRUE si el cliente est conectado al servidor
Connect Conecta a la direccin IP y al puerta especificado

36
write Escribe datos a un servidor conectado.
Escribe datos a un servidor, tipo puede ser: byte, char, int, long, o
print
string
println Escribe datos a un servidor seguido por un carcter newline
Devuelve el nmero de bytes que estn listos para su lectura en
available
el servidor
read Lee el siguiente octeto (byte) desde el servidor
Desestima los bytes que estn en espera de ser ledos por el
flush
cliente
stop Se desconecta del servidor

Como puedes ver la librera Ethernet es muy rica en contenido y sigue siendo
extendida dado su inters de cara a conectar nuestras aplicaciones Arduino
con el resto del mundo.

9.6 Comunicaciones serie con Firmata

Firmata es un protocolo de comunicaciones que permite al ordenador (tu PC


o laptop) comunicar con uno o varios Arduinos y controlar sus
microprocesadores desde el ordenador.

La librera Firmata proporciona los protocolos de comunicacin serie


(mtodos) que permitirn comunicar al PC con el Arduino. Usando Firmata
podrs controlar servos, motores, pantallas, LEDs, etc desde tu PC a travs
de uno o varios Arduinos. La tabla siguiente muestra los protocolos o
mtodos ms usuales de Firmata:

Mtodo Descripcin
Comn begin Inicializa la librera Firmata
printVersion Enva versin del protocolo al PC
setFirmwareVersion Establece la versin del firmware
Enviar mensajes sendAnalog Enva un mensaje analgico
sendDigitalPortPair Enva el valor de un pin digital
Enva un comando con un array de
sendsysex
bytes
sendString Enva un string al PC
Comprueba que hay mensajes en el
Recibir mensajes available
buffer de entrada
processInput Procesa los mensajes entrants
Asocia una funcin a un cierto tipo de
attach
mensaje de entrada
37
Mtodo Descripcin
Disocia una funcin de un cierto tipo de
detach
mensaje de entrada

El protocolo Firmata esta evolucionado constantemente; visita


http://firmata.org/wiki/ para obtener las actualizaciones ms recientes e
informarte sobre el protocolo.

9.7 Visualizando datos usando la librera LiquidCrystal

Muy frecuentemente queremos visualizar la informacin generada no en la


pantalla del PC, sino en una pequea pantalla LCD de 2 filas de 6 caracteres
para mostrar la informacin a los usuarios de la aplicacin (sin necesidad de
disponer de un PC).

La mayor parte de estas pequeas pantallas LCD se basan en el Hitachi


HD44780 u otro microprocesador compatible. La pantalla LCD puede
servirnos para mostrar datos del GPS, mensajes de situacin del sistema, y
cualquier otra informacin til para el usuario o el programador.

La herramienta que necesitamos para poder usar estas pantallas desde


nuestro sketch es la librera LiquidCrystal. La siguiente tabla enumera
algunas de las funciones disponibles en la librera.

Funcin Descripcin
Establece las dimensiones en filas y columnas de la pantalla
begin
LCD
Inicializa la librera y determina los pins usados para
LiquidCrystal
comunicar con la pantalla LCD
print Visualiza datos en la pantalla LCD
clear Borra los contenidos de la pantalla LCD
setCursor Posiciona el cursor sobre la pantalla

9.8 Controlando un motor servo

Los motores servo se usan generalmente para controlar con precisin


movimientos dentro de nuestros modelos (por ejemplo en radio-control, las
aletas de un aeroplano, o la direccin de un volante o timn, etc.).

Son ideales para los proyectos que necesitan el movimiento exacto, como
por ejemplo evitar obstculos o colocar una pieza en un ngulo pre-
determinado en aplicaciones robticas, etc.

38
La librera Servo permite al Arduino controlar hasta 12 motores servos con un
Arduino estndar, y 48 con un Mega. La siguiente tabla muestra las
principales funciones proporcionadas por la biblioteca Servo.

Funcin Descripcin
attach Asigna el servo a un pin.
Attached Verifica que el servo est conectado al pin
Detach Desconecta el servo del pin.
Read Lee el ngulo del servo.
Hace girar el eje del servo al ngulo especificado.
Write Entre 0 y 180 en un servo clsico. En un servo de
rotacin continua establece la velocidad de rotacin.
Gira el eje del servo un arco expresado en
writeMicroseconds
microsegundos.

Nota: El uso de la librera Servo en un Arduino estndar deshabilita la


funcin analogWrite en los pines 9 y 10 del PWM. En el Mega, se
deshabilita analogWrite en los pins 11 y 12 si estamos controlando
ms de 12 servos.

9.9 Controlando el giro de un motor de pasos

Un motor de pasos gira su eje en pasos. La especificacin de un motor de


pasos viene dada generalmente en pasos, as que un motor con una
especificacin de 200 pasos necesitara 200 pequeos giros angulares para
completar una revolucin.

La especificacin se da a veces grados que se pueden convertir fcilmente


en pasos dividiendo una revolucin (360 grados), por el nmero de grados
dados para cada paso en la especificacin. Para un motor de pasos con una
especificacin de 1,5 grados calculamos el nmero de pasos por la
revolucin como sigue:

360 grados/1,5 grados por paso = 240 pasos

Los motores de pasos nos proporcionan una manera muy precisa para
controlar dispositivos. La librera Stepper nos proporciona la manera de
controlar motores de pasos unipolares y bipolares con un Arduino.

Usando la librera podemos establecer la velocidad de la rotacin del motor


el nmero de pasos que queremos dar y la direccin de estos pasos. La
siguiente tabla muestra las principales funciones de la librera Stepper:

Funcin Descripcin

39
Funcin Descripcin
Inicializa la librera Stepper y establece el nmero de pasos por
Stepper
revolucin.
Establece la velocidad de rotacin del motor en revoluciones por
setSpeed
minute (RPM)
Gira el motor el nmero de pasos indicado. Un nmero positive
step
gira en un sentido y uno negativo en el contrario.

9.10 Comunicando con perifricos SPI

El Bus Serie para Perifricos (denominado con las siglas SPI en ingls),
tambin llamado el bus de 4 hilos (four-wire bus) es un protocolo de
comunicaciones sncrono usado para comunicar en distancias cortas con
perifricos externos como sensores, incluyendo los sensores de temperatura,
sensores de presin, convertidores analgico- digital, pantallas tctiles,
controladores de videojuegos, y pantallas de visualizacin. Arduino usa
tambin el bus SPI para comunicar con tarjetas de memoria SD.

Este protocolo tiene un solo master, el Arduino, y uno o ms dispositivos


esclavos. Debido a la falta de un estndar formal, han surgido diferentes
implementaciones del protocolo SPI segn los diversos fabricantes de
dispositivos perifricos, es decir, que probablemente tendrs que recurrir a
las especificaciones del perifrico en cuestin para manejarlo desde el
Arduino.

El protocolo utiliza cuatro hilos, de los cuales tres son comunes a cada
dispositivo y el cuarto que es especfico (no compartido) para cada perifrico.
Sus designaciones se muestran en la siguiente tabla:

Designacin Descripcin Pin Arduino Pin Mega


Master In Slave Out, envio datos al
MISO 12 50
master
Master Out Slave In, envio datos al
MOSI 11 51
esclavo
SCK Reloj Serie 13 52
SS Seleccin de esclavo Normalmente10 53

Cada esclavo tiene un hilo selectwire especfico para l, pero comparte los
otros tres hilos del bus con los otros perifricos. El pin 10 (53 en el Mega) se
usa generalmente como lnea de seleccin de esclavo (slave select), pero
los otros tres pueden ser elegidos durante la configuracin.

El shield Ethernet del Arduino utiliza el pin 4 para conectar con el conector
SD integrado y el pin 10 para el controlador Ethernet.

40
La librera SPI proporciona las funciones que nos permitirn actuar sobre los
perifricos SPI tal y como se muestra a continuacin:

Funcin Descripcin
Inicializa el bus SPI y pone los pins MOSI y SCK en baja y
Begin
el SS en alta
End Desactiva el bus SPI
setBitOrder Establece el orden en el cual se cargan los bits en el bus
Establece el divisor de reloj SPI como una fraccin del reloj
setClockDivider
del sistema
setDataMode Establece el modo de datos en el bus SPI
Transfer Transfiere un byte al bus

Veamos ms en detalle alguna de estas funciones:

setBitOrder: Establece el orden en el que los datos son puestos en el bus.


Hay dos posibilidades: empezar por el bit de mayor peso (Most Significant
Bit, MSB) o por el de menor peso (Least Significant Bit, LSB). Las
especificaciones del perifrico concreto te dirn cul de estas dos opciones
debes de usar.

setClockDivider: Establece la velocidad a la que opera el bus SPI como una


fraccin del periodo del reloj del sistema. El divisor por defecto es 4, lo cual
reduce la velocidad del bus SPI a un cuarto del periodo del reloj del sistema;
otros ratios posibles son 2, 8, 16, 32, 64, y 128.

setDataMode: Controla el modo de transmisin de datos entre el perifrico


esclavo y el master. Existen tres modos de transmisin que vienen dados por
cuando se ponen los datos en el bus: cuando el reloj del sistema pasa a alta,
cuando pasa a baja (estos dos modos se denominan fase de reloj (clock
phase). El tercer modo es cuando el reloj est estable en el momento de
poner los datos en el bus. Este es el modo de polaridad de reloj (clock
polarity). La tabla expuesta a continuacin resume estos modos de
transmisin.

Modo Polaridad del Reloj (CPOL) Fase del Reloj (CPHA)


0 0 0
1 0 1
2 1 0
3 1 1

Todo esto parece un poco complicado, sin embargo vers que leyendo las
especificaciones del perifrico y siguiendo sus instrucciones con cuidado
podrs comunicar con el bus SPI sin problemas.

41
9.11 Comunicando con el interface de dos hilos (I2C)

Este interface comnmente llamado interface de dos hilos (TWI, two wire
interface) se usa para comunicar a baja velocidad con una amplia gama de
dispositivos y componentes (incluyendo relojes de tiempo real).

Es muy indicado para aplicaciones de registro de datos (logging


applications), pantallas LCD, sensores ultrasnicos para medir distancias y
potencimetros digitales cuya resistencia pueda ser leda o regulada por
control remoto.

I2C se usa en los mandos Nintendo, el Wii Motion Plus, y Wii Nunchuks.

Solo se necesitan dos pins para el interface con el bus i2C (ver tabla).

Arduino Estndar Mega


SDA data line Analog input pin 4 Digital pin 20
SCL clock line Analog input pin 5 Digital pin 21

Con la librera Wire el Arduino puede actuar como master o esclavo. Lo ms


frecuente es que Arduino haga de master e interacte con uno o varios
esclavos en el bus I2C; cada esclavo tiene una direccin nica que lo
distingue en la red del bus. Se pueden concatenar hasta un mximo de 112
dispositivos en el bus. El Arduino puede tambin operar como dispositivo
esclavo interaccionado con un master.

La siguiente tabla lista las funciones ms importantes de la librera Wire:

Function Description
Inicializa la librera Wire y conecta el Arduino al bus I2C
Begin
como master o esclavo.
requestFrom Pide datos del esclavo al master.
beginTransmission Prepara la transmisin de datos.
Enva datos del esclavo al master o pone en cola bytes
Send
para la transmisin de master a esclavo.
Finaliza la transmisin (comenzada con
endTransmission beginTransmission) de datos a un esclavo y enva los
datos puestos en cola de envo por send.
Devuelve el nmero de bytes disponible para su
recepcin con receive. Debe de ser usado en el
Available
dispositivo master tras una llamada requestFrom de un
esclavo dentro de la funcin activada por onReceive.
Receive requestFrom o desde el master a un esclavo.
onReceive Determina la funcin que se ha de activar cuando el

42
Function Description
esclavo recibe una transmisin desde el master.
Determina la funcin que se ha de activar cuando el
onRequest
master pide datos al dispositivo esclavo.

9.12 Creando ms puertas serie con SoftwareSerial

Muchos de los proyectos que podemos realizar con el Arduino requieren al


menos una puerta serie. Los dispositivos GPS, las pantallas LCD y otros
dispositivos necesitan conectarse a una puerta serie. Esta puerta consiste en
dos conexiones: una RX para recibir mensajes y una TX para enviarlos.

La utilidad de esta puerta radica en su simplicidad. En el pasado todos los


ordenadores tenan una o varias puertas serie. De hecho, el Arduino original
usaba una puerta serie para conectarse al ordenador y, aunque actualmente
la conexin se realiza a travs de un USB, lo hace a travs de una emulacin
de puerta serie (que vista desde el ordenador es una conexin serie).

Los Arduino Uno y Duemilanove tienen una puerta serie conectado a los
pines digitales 0 y 1, pero si tu proyecto necesita conectarse a ms
dispositivos serie (por ejemplo un GPS y un display LCD) puedes hacer dos
cosas: comprarte el Arduino Mega (o compatible) que tiene 4 puertas serie o
usar la librera SoftwareSerial que se distribuye con el entorno de desarrollo
del Arduino (IDE).

La librera original solo proporcionaba una puerta software adicional adems


de la puerta hardware de serie y su velocidad estaba limitada a 9600
baudios. Estas limitaciones fueron superadas por la nueva librera
NewSoftSerial escrita por Mikal Hart que fue incorporada por el equipo de
desarrollo del Arduino a medidos de 2011 como la nueva SoftwareSerial. La
siguiente tabla muestra las funciones incluidas en esta librera:

Funcin Descripcin
Activa la puerta y establece la velocidad de transmisin en
Begin
baudios
Available Comienza a usar la puerta
isListening Devuelve la puerta active en este momento
listen Escucha a ese puerta y lo activa
end Termina el uso de ese puerta
read Lee datos de la puerta
write Escribe datos en la puerta

Esta nueva librera puede crear varias puertas serie software que pueden
comunicar a velocidades de hasta 115,000 baudios. Pero toda esta

43
funcionalidad adicional tiene un precio: el Arduino slo puede escuchar o
recibir datos de una puerta serie software a la vez (sin embargo, s que
puede transmitir por varias simultneamente).

Cuando uses la librera con ms de una puerta serie software tienes que
planificar cuidadosamente tu sketch y el orden en el que recibirs los datos.

Consideremos un ejemplo: quieres conectar un GPS y un termmetro usando


puertas serie software. Los dispositivos GPS suelen enviar sus datos en
paquetes espaciados un segundo entre s, de manera que tu sketch puede
comenzar escuchando la puerta serie software y una vez ha recibido el
primer paquete de datos pasar a escuchar la otra puerta software, procesar
sus datos y devolver la escucha al GPS.

Este sketch muestra cmo funciona esto en la prctica:

#include <SoftwareSerial.h>
SoftwareSerial gpsPort(2, 3);
SoftwareSerial thermPort(4, 5);

void setup()
{ gpsPort.begin(9600);
thermPort.begin(9600);
}

void loop()
{
gpsPort.listen();
while (gpsPort.available() > 0)
{ char inByte = gpsPort.read();
}
thermPort.listen();
while (thermPort.available() > 0)
{ char inByte = thermPort.read();
}
}

Como puedes ver la librera SoftwareSerial es una contribucin fantstica a


tu entorno de desarrollo, pero tienes que tener cuidado al usarla con ms de
una puerta software.

Esto cierra el captulo de libreras estndar. Te puedes preguntar, qu


sucede si quieres usar perifricos o dispositivos que no estn cubiertos por
las libreras estndar o de base (core).

44
Casi con seguridad existe una librera escrita por otro usuario que se puede
adecuar a tu proyecto. En el prximo captulo vamos a ver cmo usar estas
libreras llamadas contributed libraries.

9.13 Las contributed librairies

Estas libreras son contribuciones de los usuarios del Arduino que no se


distribuyen como parte del entorno de desarrollo IDE. Puedes encontrar
muchas de estas libreras listadas en el sitio web Arduino.

Algunas de estas libreras son extensiones de las libreras estndar que


aaden algunas funciones suplementarias, y con el tiempo, si estas
funciones resultan ser tiles, el equipo de desarrollo puede aadirlas a las
libreras estndar o incluso a la librera de base. Otras contributed librairies
estn diseadas para funcionar con dispositivos especficos como consolas
de juegos.

Dado que estas libreras no forman parte del IDE vas a necesitar hacer una
serie de operaciones previas para poder trabajar con ellas. En el siguiente
captulo explicamos cmo proceder.

10 Instalando una nueva librera en IDE

Para aadir una nueva librera al entorno de desarrollo IDE basta con realizar
las siguientes operaciones:

Bjate la librera (que va a venir normalmente como un fichero zip).


Instlala en el IDE copiando los ficheros extrados del fichero zip al
directorio establecido por defecto para las libreras. Si dicho directorio
no existe tienes que crearlo.
Si el IDE est ya funcionando tienes que reiniciarlo. Tras reiniciar el
IDE la librera debiera estar disponible para inclusin en tus sketches.
Aade la librera a tu sketch seleccionando Sketch > Import Library del
men

45
Nota: Una vez aadida la librera al IDE, queda disponible para su uso con
futuros proyectos, de la misma manera que las libreras estndar. Una vez
importada una librera en un sketch, todas sus funciones estn disponibles
en el sketch.

11 Cmo es una librera por dentro?

Los sketches en Arduino utilizan C++ como lenguaje de programacin, la


mayor parte de la complejidad interna del Arduino queda enmascarada por
las funciones disponibles en las diferentes libreras escritas en C++.

Una librera est constituida por al menos una clase C++. Una clase consiste
en dos ficheros: un fichero cabecera (header con una extensin .h) y un
fichero con una extension .cpp.

El fichero de cabecera (extensin .h o header) es una especie de mapa de la


librera: declara las funciones de la librera y la descripcin de la clase. El
fichero .cpp contiene el detalle de la librera: el cdigo de las funciones y las
variables declaradas en el fichero header.

El fichero cabecera (.h = header file)

En el fichero cabecera se describe la librera de clases. En este ejemplo se


describe una librera para un sensor de un detector de metales llamado
DetMet que detecta el nmero de objetos de metal en una zona. Esta librera
tiene dos funciones disponibles a nivel public: una inicializa el sensor
DetMet y la otra actualiza las lecturas del sensor.

El fichero header sera:

#ifndef DETMET_H // (1) Incluye directiva guard


#define DETMET _H

#include <Arduino.h> // (2) Incluye librera del Arduino


class MetDet // Comienzo de la clase MetDet
{
public: // Declaraciones de palabras clave pblicas
MetDet(); // (3) Declara class contructor MetDet
void begin(); //Declara funciones pblicas
void update();

private: // Declara palabras clave privadas a la clase


int pollMetDet(); // Declara funciones privadas
int countFossils(int inputData);
};

#endif // (4) Marca el fin de la directiva ifndef


46
Notas:

El propsito de la instruccin #ifndef al comienzo del fichero es evitar


que el cdigo se incluya ms de una vez en un sketch durante la
compilacin.
La inclusin de la librera Arduino es opcional, pero puede ser
necesaria si tu cdigo usa elementos de esta librera como
digitalWrite(), delay(), pinMode(), etc.
Tras la instruccin public: se incluyen las funciones pblicas de la
librera as como el nombre del constructor de la librera (MetDet()).
Tras la instruccin private: se especifican las funciones privadas a la
librera, estas son las funciones que son solamente accesibles dentro
de la librera. El final de la clase queda delimitado por la instruccin
#endif .

Una vez completado el fichero header podemos pasar a codificar el fichero


.cpp que contiene el cdigo que implementa las clases y funciones de la
librera.

El fichero .cpp

Si el fichero header es el esqueleto de la librera, el .cpp es la carne sobre


los huesos. Las clases y funciones declaradas en el header estn
desarrolladas en el .cpp:

#include "MetDet.h" //(1) Declara e incluye la clase MetDet


MetDet::MetDet () { //(2) Declara class constructor
}

void MetDet::begin()
{ //Define las funciones pblicas
// Aqu ira el cdigo de inicializacin del sensor MetDet
}

void MetDet::update()
{ int data = pollMetDet();
int result = countMetales(data);
}

int MetDet::pollMetDet()
{//Aqu ira el cdigo para realizar el sondeo de metales con el sensor
MetDet
}
47
int MetDet::countMetales(int inputData)
{//Aqu ira el cdigo para contar el nmero de metales encontrados al
sondear
}

Notas: La declaracin de la clase se incluye al principio del fichero


antes de construir la clase (1). Tras la declaracin de clase, se
construye la clase MetDet() con las funciones pblicas y privadas que
constituyen la librera (2).
Nota: los cuatro puntos (::) sirven para declarar que una funcin est
dentro de la clase (MetDet). Se denomina scope resolution operator.

Una vez hayas acabado de escribir tu librera el siguiente paso es usarla


desde tus sketches. Para hacer esto necesitas incluir una copia de los
ficheros .h (header) y .cpp en un subdirectorio del directorio de libreras del
Arduino que lleve el nombre de la librera:

libraries/MetDet/MetDet.h
libraries/MetDet/MetDet.cpp

12 Utilizacin de libreras

Una vez creada la librera y almacenados sus ficheros en el directorio


apropiado, puedes usarla en tus sketches y distribuirla de manera que otros
usuarios puedan tambin trabajar con ella. Puedes compartir tu cdigo en el
siguiente sitio web: http://playground.arduino.cc. Este sitio es un buen lugar
para compartir y encontrar cdigo escrito por otros usuarios que puede serte
til.

Utilizacin de una librera en un sketch

El siguiente sketch muestra como la librera DetMet sera usada desde un


sketch, con el Arduino conectado al detector de metales equipado de un
sensor MetDet:

#include "MetDet.h" // (1) Incluye librera MetDet


MetDet myMetDet // (2) Inicializa instancia de la clase MetDet

void setup()
{ // Inicializa el sensor MetDet

48
myMetDet.begin();
}

void loop()
{ // Actualiza lectura del sensor
myMetDet.update()
}

Notas: Es necesario incluir la librera MetDet (1) antes de inicializar


cualquier instancia de la clase MetDet (2). El sensor MetDet se
inicializa durante la fase setup y se actualiza en el bucle loop del
sketch.

Distribucin de una librera

Si quieres compartir tus libreras es aconsejable empaquetarlas en un fichero


zip con los ficheros de la librera (.h y .cpp) junto con algunos sketches de
ejemplo. Los ejemplos deben de ubicarse en un subdirectorio de ejemplos:

Libraries/MetDet/Examples/MetDet.ino

13 Instalando una librera

El uso de libreras estndar nos ayudan a manejar ciertos componentes sin


necesidad de entrar en el detalle fino (y molesto) de tener que conocer cmo
funciona cada una de las seales de ese componente o las caractersticas
especficas del bus de control con el que se maneja.

Lo primero que tenemos que hacer es descargar la librera en cuestin. El


procedimiento para instalar una librera es muy sencillo y basta seguir unos
pocos pasos para hacerlo con xito.

Elegimos en el men del IDE:

Arduino, Programa\Importar Librera\Aadir Librera

49
Ahora nos pedir la direccin del fichero descargado en formato xxx.zip.

Busca y selecciona la librera en cuestin. Cuando la pinchemos se debera


instalar. Si no hay ningn problema podemos comprobar que aparece en la
lista de libreras instaladas y que podemos pincharla.

Si por cualquier problema, el IDE rehsa instalar la librera, tendremos que


ver porqu y corregirlo. Vamos a ver algunas normas.

Arduino define un sistema simple para formar una librera y define una serie
de ficheros que deben ir incluidos, as como los ejemplos que la acompaan
y forman un paquete comprimido con ZIP para contener todo el conjunto.

50
Los ficheros que suele incluir una librera (Que llamaremos Biblos por
ejemplo), y que podis comprobar descomprimiendo aparte cualquiera de las
nos hemos descargado, son:

Un fichero Biblos.h, de headers, donde se suelen definir las


constantes , marcar includes que necesitara la librera y en muchas
ocasiones las definiciones de las clases de las que depende la librera.
Un fichero Biblos.cpp, que es donde suele estar el peso del programa.
Incluye normalmente, los mtodos o funciones de una clase y las
propiedades, as como cualquier funcin de apoyo que la librera
necesite.
Un fichero o varios o ninguno, del tipo xxx.c con funciones y
programas en C para apoyo
Un fichero keywords.txt donde indica una lista de palabras reservadas,
lase que define la librera.
Un Readme.txt con las indicaciones de uso, el autor o autores y la
pgina web donde se publican las actualizaciones.
Un directorio de ejemplos que son los que veremos luego en el IDE.
Podis editar todos estos ficheros y ver su cdigo, pero no hace falta
que os diga que no cambies cosas si no estis seguros de lo que
hacis. Podis abrirlos desde Arduino con la opcin de men
Programa\Aadir fichero, os abrir una nueva pestaa en el IDE con el
fichero formateado

Arduino establece que todo esto debe estar comprimido en un nico fichero
Zip que es capaz de importar con la instruccin Importar Librera.

Arduino espera que la librera solo incluya letras y nmeros y no


ningn carcter especial (Incluidos subrayados y similares). Adems
espera que el nombre de la librera coincida con el de los ficheros
xxx.cpp y.xxx.h
Si esto no es as devolver un error diciendo que nones y te tienes
que buscar la vida, revisando que puetas ser lo que no le gusta.
En aplicacin de las normas anti paletos y para evitar las cosas
sencillas, en Arduino existe tambin la peculiar costumbre de no hacer
coincidir el nombre del ZIP con el nombre interior de la librera,
consiguiendo as, que el IDE rehus instalarlo con un mensaje crptico.
Cuando esto ocurre no hay ms remedio que deszipear el fichero en
un directorio, entrar en ese directorio y zipear de nuevo todo con el
nombre del fichero xx.cpp, y despus pedirle al IDE que instale el

51
nuevo fichero Asegrate adems de que no hay directorios
encadenados.
Por este motivo, en nuestras sesiones siempre os incluyo una copia
de la librera para vuestra descarga, que haya comprobado que se
instala sin problemas.

Si a pesar de todo, la librera se niega a instalarse podemos hacerlo a la vieja


usanza. Cerramos el IDE y copiamos el directorio con los ficheros descritos
ms arriba directamente al directorio de libreras, que es lo que hace la orden
de importarla.

En Windows ese directorio suele estar en \\Usuario\Documentos\Arduino\


libraries. Dentro de el encontrareis un directorio por cada librera instalada
con los ficheros de cabecera y los ejemplos que podemos seleccionar desde
el IDE.

En Mac OSX, este directorio se instala por defecto en


Documentos/Arduino/libraries.

14 Desinstalar una librera

El proceso para desinstalar una librera es ms sencillo que el de instalarla,


porque no es probable que surjan problemas.

Basta con cerrar el IDE Arduino e ir a los directorios donde se instalan las
libreras. Ya dijimos que en Windows es
en \\Usuario\Documentos\Arduino\libraries\. SI vez con el explorador de
archivos veras algo como esto:

52
Lo que el IDE nos muestra en el men \\Programa\Importar\libreria es una
copia de los directorios que aparecen aqu y para desinstalar una librera
basta con que borrar el directorio en cuestin.

La prxima vez que arranque el IDE, la librera en cuestin habr


desaparecido.

Si usas Mac, las libreras se instalan en Documentos/Arduino/libraries

53
Y puedes borrar igualmente la carpeta de la librera correspondiente para
librarte de l.

54
15 PRACTICAS:
Practica 1

Led Intermitente

Se trata de realizar un ejercicio bsico que consiste en encender y apagar un


led que conectamos en el PIN 13 de Arduino que lo configuramos como
salida. El tiempo de
encendido y apagado es de 1 segundo.

Material:

Tarjeta Arduino uno

Protoboard

1 diodo LED

Cables para realizar las conexiones

Esquema de la conexin de la prctica:

En el pin 13 no se necesita colocar una resistencia ya que incorpora una


resistencia en su interior, en el caso de colocar el diodo LED en otra salida
deberamos colocar una resistencia de al entre 220 y 500 ohmios
dependiendo del consumo de corriente del diodo.

55
Codigo en arduino:

int ledPin = 13; // Definicin de la salida en el PIN 13


void setup() //Configuracin
{
pinMode(ledPin, OUTPUT); // designa la salida digital al PIN 13
}
void loop() // bucle de funcionamiento
{
digitalWrite(ledPin, HIGH); // activa el LED
delay(1000); // espera 1 seg. (tiempo encendido)
digitalWrite(ledPin, LOW); // desactiva el LED
delay(1000); // espera 1 seg. (tiempo apagado)
}

Circuito armado:

Practica 2

LEDs en secuencia
Se trata de encender y apagar 3 LEDs colocados en las salidas 6, 7 y 8
(PIN6, PIN7 y PIN8) con una cadencia de 200 ms. Las variables asignadas a
cada led son ledPin1,ledPin2 y ledPin3.

56
Material:

Tarjeta Arduino uno

Protoboard

3 diodo LED

3 resistencias de 220 ohms

Cables para realizar las conexiones.

Esquema de la conexin de la prctica:

Cdigo en arduino:

// Encendido y apagado de 3 LEDs


int ledPin1 = 6; // Define las salidas de los LEDs
int ledPin2 = 7;
int ledPin3 = 8;
void setup() { // Configura las SALIDAS
pinMode(ledPin1, OUTPUT); // declarar LEDs como SALIDAS
pinMode(ledPin2, OUTPUT);

pinMode(ledPin3, OUTPUT);
digitalWrite(ledPin1, LOW); // Apaga los LEDs
digitalWrite(ledPin2, LOW);
digitalWrite(ledPin3, LOW);
}
void loop(){ //Bucle de Funcionamiento
digitalWrite(ledPin1, HIGH); // Apaga y enciende los leds cada 200 ms
delay(200);
digitalWrite(ledPin1, LOW);

57
digitalWrite(ledPin2, HIGH);
delay(200);
digitalWrite(ledPin2, LOW);
digitalWrite(ledPin3, HIGH);
delay(200);
digitalWrite(ledPin3, LOW);
}

Circuito armado:

Practica 3
Potencimetro: Lectura de seal Analgica

Descripcin:
El potencimetro es un dispositivo electromecnico que consta de una
resistencia de
valor fijo sobre la que se desplaza un contacto deslizante, el cursor, que la
divide
elctricamente.

Un potencimetro es especificado por su resistencia total, R, entre los


terminales
externos 1 y 3; El movimiento del cursor origina un cambio en la resistencia
medida
entre el terminal central, 2, y uno cualquiera de los extremos.

58
Este cambio de resistencia puede utilizarse para medir desplazamientos
lineales o
angulares de una pieza acoplada al cursor.
Se conectan en paralelo al circuito y se comporta como un divisor de tensin.
Un potencimetro tambin puede ser usado como una resistencia variable (o
restato)
de dos terminales, en ese caso, se cortocircuitan dos de las tres patas del
potencimetro.

Material:

1 Potencimetro de 10k
1 Diodo LED
protoboard
Cables para realizar las conexiones

Esquema de la conexin de la practica:

Cdigo en arduino:

int potPin = 2; // seleccionar el pin de entrada analgico para el


potencimetro
int ledPin = 13; // seleccionar el pin de salida digital para el LED
int val = 0; // variable para almacenar el valor capturado desde el sensor
void setup() {
pinMode(ledPin, OUTPUT); // declara el ledPin en modo salida
}
void loop() {

59
val = analogRead(potPin); // lee el valor del sensor
digitalWrite(ledPin, HIGH); // enciende LED
delay(val); // detiene el programa por un tiempo val
digitalWrite(ledPin, LOW); // apaga el LED
delay(val); // detiene el programa por un tiempo val
}

Circuito armado:

Practica 4
El coche fantstico

Descripcin del ejercicio


Hemos denominado este ejemplo como "El coche fantstico" en memoria de
la serie de
TV de los aos 80 en la que el famoso David Hasselhoff tena una mquina
de IA
conduciendo su Pontiac. El coche estaba equipado con gran cantidad de
LED-s de todos
los tamaos posibles que realizaban efectos parpadeantes.

De esta manera hemos decidido, con el objetivo de aprender programacin


secuencial y

60
buenas tcnicas para programar la placa E/S, sera interesante usar el coche
fantstico
como una metfora.

Este ejemplo hace uso de 6 LED-s conectados a los PIN 2 a 7 de la placa


mediante
resistencias de 220 Ohmios. El primer cdigo de ejemplo hace parpadear a
los LED en
secuencia de uno en uno, utilizando slo las funciones
digitalWrite(pinNum,HIGH/LOW) y delay(time). El segundo ejemplo muestra
como
usar una secuencia de control for(;;;) para hacer lo mismo, pero en menos
lneas de
cdigo. El tercer y ltimo ejemplo se centra en el efecto visual de apagar y
encender los
LED-s de una forma ms suave.

Material:
6 LED-s.
1 resistencias de 220 Ohmios.
Protoboard.
Cables para realizar las conexiones

Esquema de la conexin de la practica:

61
Codigo en arduino:

int pin2 = 2; // PIN-es de los LED

int pin3 = 3;
int pin4 = 4;
int pin5 = 5;
int pin6 = 6;
int pin7 = 7;
int timer = 100; // Temporizador
void setup(){
pinMode(pin2, OUTPUT); // Configuracin de los PIN-es como salida
pinMode(pin3, OUTPUT);
pinMode(pin4, OUTPUT);
pinMode(pin5, OUTPUT);
pinMode(pin6, OUTPUT);
pinMode(pin7, OUTPUT);
}
void loop() {
digitalWrite(pin2, HIGH); // Enciende y apaga secuencialmente LED-s
delay(timer);
digitalWrite(pin2, LOW);
delay(timer);
digitalWrite(pin3, HIGH);
delay(timer);
digitalWrite(pin3, LOW);
delay(timer);
digitalWrite(pin4, HIGH);
delay(timer);
digitalWrite(pin4, LOW);
delay(timer);
digitalWrite(pin5, HIGH);
delay(timer);
digitalWrite(pin5, LOW);
delay(timer);
digitalWrite(pin6, HIGH);
delay(timer);
digitalWrite(pin6, LOW);
delay(timer);
digitalWrite(pin7, HIGH);
delay(timer);
digitalWrite(pin7, LOW);
delay(timer);
digitalWrite(pin6, HIGH);

delay(timer);
digitalWrite(pin6, LOW);

62
delay(timer);
digitalWrite(pin5, HIGH);
delay(timer);
digitalWrite(pin5, LOW);
delay(timer);
digitalWrite(pin4, HIGH);
delay(timer);
digitalWrite(pin4, LOW);
delay(timer);
digitalWrite(pin3, HIGH);
delay(timer);
digitalWrite(pin3, LOW);
delay(timer);
}

Circuito armado:

63
Practica 5
Sensor de Luz o LDR (Light Dependent Resistor):

Descripcion de la practica:

Vout=((Rbotton/(Rbottom+Rtop))*Vin

Si la LDR es usada como Rtop, como en el primer circuito, da tensin alta


(HIGH) en la
salida cuando la LDR est en la luz, y una tensin baja (LOW) en la salida
cuando la
LDR est en la sombra.
La accin del divisor de tensin es inversa cuando la LDR es usada como
Rbottom en
lugar de Rtop, como en el segundo circuito. El circuito da tensin Baja (LOW)
en la
salida cuando la LDR est en la luz, y una tensin alta (HIGH) en la salida
cuando la
LDR est en la sombra. El circuito divisor de tensin dar una tensin de la
salida que
cambia con la iluminacin, de forma inversamente proporcional a la cantidad
de luz que
reciba (sensor de oscuridad).

Materiales:

1 LDR
1 Resistencia de 5k
Protoboard
1 Diodo LED

Esquema de la conexin de la Practica:

64
Cdigo en arduino:

int LightPin = 3; // selecciona el pin de entrada para el sensor de luz


int ledPin = 13; // selecciona el pin para el LED
int val = 0; // variable para almacenar el valor capturado desde el sensor
void setup() {
pinMode(ledPin, OUTPUT); // declara el ledPin en modo salida
}
void loop() {
val = analogRead(LightPin); //lee el valor del sensor
digitalWrite(ledPin, HIGH); // enciende el LED
delay(val); // detiene el programa por un tiempo
digitalWrite(ledPin, LOW); // apaga el LED
delay(val); // detiene el programa por un tiempo
}

Circuito armado:

65
PRACTICA 6
Knop servo

Se trata de servo motor conectado a un potencimetro el cual enva una


seal de entrada analgica en instrucciones que conmute a grados que va a
ser ledos por el servomotor.

Materiales:

Potencimetro

Protoboard

Servomotor

Cables

Codigo en arduino:

#include <Servo.h>

Servo myservo; // create servo object to control a servo

int potpin = 0; // analog pin used to connect the potentiometer

int val; // variable to read the value from the analog pin

66
void setup()

myservo.attach(9); // attaches the servo on pin 9 to the servo object

void loop()

val = analogRead(potpin); // reads the value of the potentiometer


(value between 0 and 1023)

val = map(val, 0, 1023, 0, 180); // scale it to use it with the servo (value
between 0 and 180)

myservo.write(val); // sets the servo position according to the


scaled value

delay(15); // waits for the servo to get there

Circuito armado:

67
PRACTICA 7
Sweep servo

Se tratara de manipular la velocidad del giro del servomotor, va aumentado


conforme va aumentado el tiempo.

Materiales:

Servomotor

Protoboard

Cables

Esquema:

Cdigo en arduino:

#include <Servo.h>

Servo myservo; // create servo object to control a servo

// twelve servo objects can be created on most boards

int pos = 0; // variable to store the servo position

68
void setup()

myservo.attach(9); // attaches the servo on pin 9 to the servo object

void loop()

for(pos = 0; pos <= 180; pos += 1) // goes from 0 degrees to 180 degrees

{ // in steps of 1 degree

myservo.write(pos); // tell servo to go to position in variable 'pos'

delay(15); // waits 15ms for the servo to reach the position

for(pos = 180; pos>=0; pos-=1) // goes from 180 degrees to 0 degrees

myservo.write(pos); // tell servo to go to position in variable 'pos'

delay(15); // waits 15ms for the servo to reach the position

69
Circuito armado:

Practica 8

Sensor LM35

Se trata de medir la temperatura con un sensor lm35 aplicandole fuego al


sensor lm35.

Material:

LM35

Protoboard

Cables

70
Esquema:

Codigo en arduino:

int analog_pin = A1;

float temperatura;

float valor = 0 ;

void setup(){

Serial.begin(9600);

void loop() {

valor = analogRead(analog_pin);

temperatura = 5.0*valor*100/1024;

Serial.print("SENSOR = ");

Serial.println(temperatura);

delay(100);

71
Circuito armado:

Practica 9

Medicin de distancia mediante el sensor ultrasnico

Se trata de medir la distancia por medio de sensor ultrasnico.

Material:

Sensor ultrasnico

Protoboard

Cables

72
Esquema:

Cdigo en arduino:

long distancia;

long tiempo;

void setup(){

Serial.begin(9600);

pinMode(9, OUTPUT); /*activacin del pin 9 como salida: para el pulso


ultrasnico*/

pinMode(8, INPUT); /*activacin del pin 8 como entrada: tiempo del rebote
del ultrasonido*/

73
void loop(){

digitalWrite(9,LOW); /* Por cuestin de estabilizacin del sensor*/

delayMicroseconds(5);

digitalWrite(9, HIGH); /* envo del pulso ultrasnico*/

delayMicroseconds(10);

tiempo=pulseIn(8, HIGH); /* Funcin para medir la longitud del pulso


entrante. Mide el tiempo que transcurrido entre el envo

del pulso ultrasnico y cuando el sensor recibe el rebote, es decir: desde


que el pin 12 empieza a recibir el rebote, HIGH, hasta que

deja de hacerlo, LOW, la longitud del pulso entrante*/

distancia= int(0.017*tiempo); /*frmula para calcular la distancia obteniendo


un valor entero*/

/*Monitorizacin en centmetros por el monitor serial*/

Serial.println("Distancia ");

Serial.println(distancia);

Serial.println(" cm");

delay(100);

Circuito armado:

74
Practica 18
Generador de notas musicales
Se trata de generar hasta 8 notas musicales por una de las salidas analgicas de
Arduino
PIN10-
Se debe crear un array (vector) de datos compuesto por los valores
correspondientes a
las 8 notas que se pretende sacar:
int notas[] = {1915, 1700, 1519, 1432, 1275, 1136, 1014, 956};
Se deben definir tambin el tiempo de pausa entre nota y nota y el tiempo de pausa
de
fin de secuencia de notas:
int tnota=100;
int pausa=100;
Las iteraciones para el recorrido de las 8 notas se realizan con una instruccin de
tipo
for:
for(n=0;n<8;n++)
El tiempo de activado y desactivado de la salida del zumbador tambin se resuelve
con
un bucle for:
for(m=0;m<=tnota;m++){

Cdigo en arduino:

int piezo=10;
int notas[] = {1915, 1700, 1519, 1432, 1275, 1136, 1014, 956}; //cadena con los
tiempos que corresponden a las distintas notas
int n=0;
int m= 0;
int tnota=100; //n de repeticiones del pulso. Nos da la duracin de la nota
int pausa=100;
void setup() {
pinMode(piezo,OUTPUT);
}
void loop(){
for(n=0;n<8;n++){ //iteracin que recorre la lista con las duraciones de los
75
pulsos de cada nota
for(m=0;m<=tnota;m++){
digitalWrite(piezo,HIGH);
delayMicroseconds(notas[n]); //Tiempo en microsegundos que est a 5V la
salida del piezoelctrico
digitalWrite(piezo,LOW);
delayMicroseconds(notas[n]); //Tiempo en microsegundos que est a 0V la
salida del piezoelctrico
}
delay(pausa); //tiempo en silencio entre escalas
}
}

Practica 19
Toca tonos desde el puerto serial
En este ejercicio usaremos un Piezo elctrico para reproducir tonos, aprovechando
la
capacidad que tiene el procesador para producir seales PWM y as reproducir
msica.
Un piezo elctrico no es ms que un dispositivo que puede ser usado tanto para
reproducir o detectar tonos. En nuestro ejemplo estamos conectando el piezo en el
pin
nmero 9, que permite enviar una seal PWN .
Los tonos pueden ser generados a partir de cualquier programa capaz de enviar
valores
ASCII a travs del puerto serial. Programas de Terminal, Processing, Pure Data o
Director, pueden ser usados para generar los tonos. En nuestro caso los caracteres
ASCII los enviaremos por la ventana de dialogo del IDE Arduino.

Ejemplo de la conexin de un piezo elctrico al pin 9, y utilizaremos 8 tonos tal como


se indica en el cdigo del programa. Si pulsamos cualquier otra letra que no sea de
las
que tienen asignados tonos el zumbador deja de emitir tonos.

76
Lectura de un pulsador
Descripcin del ejercicio

El pulsador es un componente que conecta dos puntos de un circuito cuando es


Presionado.

Para generar una seal de tensin con el pulsador, se necesita un divisor de tensin.
Ejemplo:

La resistencia Rabajo(pull-down) en el primer circuito fuerza a Vout, llegando a nivel


CERO, hasta que se acciona el pulsador. Este circuito entrega una tensin alta,
cuando
se presiona el pulsador. Un valor para la resistencia de 10 k es adecuada.
En el segundo circuito, la resistencia Rarriba (pull-up) fuerza a nivel ALTO a Vout,
Mientras no se acte sobre el pulsador. Al presionar el pulsador, se conecta Vout
Directamente con 0 V. Es decir, este circuito entrega un nivel BAJO cuando se
presiona
el pulsador.

Material
Resistencia de 1K Ohmios.
Pulsador.
diodo LED
Cables para realizar las conexiones.

77
Circuito armado:

78
Entrada Analgica
Se trata de configurar un canal de entrad analgico pin 5 y enviar el valor ledo al PC
para visualizarlo

Programa
/* Entrada Analgica */
int potPin = 5; // selecciona el pin de entrada para colocar el potencimetro
int val = 0; // variable para almacenar el valor ledo por la entrada analgica
void setup() {
beginSerial(9600);
}
void loop() {
val = analogRead(potPin); // lee el valor del canal de ENTRADA analgica
printInteger(val); // Enva al PC el valor analgico ledo y lo muestra en pantalla
serialWrite(10);
delay(100);
}

79
Simulacin de la luz de una vela
De trata de simular el movimiento de la llama de una vela. Hacemos uso de la
instruccin para generar un numero aleatorio que lo asignamos a una salida analgica
PWM y otro numero que lo asociamos a la variable de temporizacin (tiempo que
esperamos para cambiar el valor de la salida).

/*
* Simula luz de vela
* Saca por una de las salidas del puerto PWM un valor aleatorio que activa un LED
*
* 2007 Tod E. Kurt <tod@todbot.com>
* http://todbot.com/

*
*/
int ledPin = 9; // selecciona el puerto PWM
int val = 0; // define y pone a cero la variable "brillo"
int delayval = 0; // define el intervalo de cambio de valor de salida
void setup() {

80
randomSeed(0); // inicializa el generador de nmeros aleatorios
pinMode(ledPin, OUTPUT); // declara el pin de SALIDA pin 9
}
void loop() {
val = random(100,255); // genera un nmero aleatorio entre 100 y 255 que asigna
a la variable val
analogWrite(ledPin, val); // enva ese valor a la salida pin 9
delayval = random(50,150); // genera un numero aleatorio entre 30 y 100 y lo
asigna a la variable de temporizacin
delay(delayval); // espera un tiempo delayval medido en milisegundos
}

81
Construccin de un indicador de nivel (vmetro con
diodos led)
Se trata de construir u indicador de nivel que sea capaz de medir el valor de una seal
de
entrada generada por un potencimetro desde una entrada analgica.
Se establecern 3 diodos Led conectados a las salidas PIN6, PIN7 y PIN8. La entrada
la
conectaremos en la entrada analgica PIN 1 (analog IN1)

int ledPin1 = 8; // Seleccin de PIN para cada LED


int ledPin2 = 7;
int ledPin3 = 6;
int inPin= 1; // selecciona la entrada analgica 1 (potencimetro)

void turn_off() { //Apaga los 3 LEDS


digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, LOW);
digitalWrite(ledPin3, LOW);
}
void setup() {
pinMode(ledPin1, OUTPUT); // declara LEDs como salidas
pinMode(ledPin2, OUTPUT);
pinMode(ledPin3, OUTPUT);
turn_off(); //
}
void loop(){
int val;
val= analogRead(inPin); // lee el valor de la seal analgica
turn_off();apaga los tres LED
// Si el valor de la seal medida es > 256 enciende LED del PIN8
if (val>= 256) digitalWrite(ledPin1, HIGH);
// Si el valor de la seal medida es > 512 enciende LED del PIN7
if (val>= 512) digitalWrite(ledPin2, HIGH);
// Si el valor de la seal medida es > 758 enciende LED del PIN6
if (val>= 768) digitalWrite(ledPin3, HIGH);
}

82
13. Encendido y apagado de una luz de manera analgica
Se trata de que enviemos hacia la salida 9 un valor analgico ascendente y
descendente
cclicamente comprendido entre 0 y 255 en incrementos de 5.
Para la realizacin de este ejercicio se debe emplear una estructura de programacin
tipo for que realice el incremento o decremento de una variable entre 0-255 y 255-0
con
un valor te retardo entre cambio de valor de 30 mseg.

En la figura vemos una repr4sentacion e l valor de la seal de salida en el PIN 9.


Tngase en cuenta que el valor 255 equivale a 5 voltios y el valor 0 a 0 voltios.

// Salida Analgica Cclica


// by BARRAGAN <http://people.interaction-ivrea.it/h.barragan>
int value = 0; // Valor a sacar por la salida analgica PIN 9
int ledpin = 9; // Salida analgicas PIN 9
void setup()
{
// nothing for setup
}
void loop()
{
for(value = 0 ; value <= 255; value+=5) // Variacin de la variable se salida
ente el MIN yMAX
{

83
analogWrite(ledpin, value); // Enviar valor a la salida (entre 0 y 255)
delay(30); // Esperar 30 ms para ver el efecto de variacin
}
for(value = 255; value >=0; value-=5) // Variacin de la variable de salida
entre MAX y MIN
{
analogWrite(ledpin, value);
delay(30);
}
}

84
Bibliografas:

Manual Prcticas con Arduino Nivel I

ARDUINO_APUNTES_2013

http://www.aprenderobotica.com/group/eslaprimeravez/page/principiantes-arduino

http://www.prometec.net/librerias/

http://www.prometec.net/funciones-iii/

http://www.prometec.net/intro-programacion/

http://rduinostar.com/documentacion/programacion-arduino/estructura-de-un-sketch/

85

También podría gustarte