Estructura de un sketch en Arduino

Un programa de Arduino se denomina sketch o proyecto y tiene la extensin .ino

Importante: para que funcione el sketch, el nombre del fichero debe estar en un directorio con el
mismo nombre que el sketch.
No es necesario que un sketch est en un nico fichero, pero si es imprescindible que todos los
ficheros estn dentro del mismo directorio que el fichero principal y que este contenga
obligatoriamente las funciones setup() y loop().
void setup() {
// put your setup code here, to run once:
}
void loop() {
// put your main code here, to run repeatedly:
}
La estructura bsica de un sketch de Arduino es bastante simple y se compone de al menos dos
partes. Estas dos partes son obligatorios y encierran bloques que contienen declaraciones,
estamentos o instrucciones.
setup() http://arduino.cc/en/Reference/Setup
loop() http://arduino.cc/en/Reference/Loop

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

programa que se ejecutar cclicamente (de ah el trmino loop bucle-). Ambas funciones son
necesarias para que el programa trabaje.
La funcin de configuracin (setup) debe contener la inicializacin de los elementos y esta funcin
slo se ejecuta una vez justo despus de hacer el reset y no se vuelve a ejecutar hasta que no haya
otro reset. Es la primera funcin a ejecutar en el programa y se utiliza para configurar, inicializar
variables, comenzar a usar libreras, etc
La funcin bucle (loop) siguiente contiene el cdigo que se ejecutar continuamente (lectura de
entradas, activacin de salidas, etc). Esta funcin es el ncleo de todos los programas de Arduino y
se usa para el control activo de la placa.
La funcin loop se ejecuta justo despus de setup.
La estructura del sketch est definida en el siguiente enlace: http://arduino.cc/en/Tutorial/Sketch
Los componentes principales de un sketch de Arduino son:
Variables, son un espacio en memoria donde se almacenan datos y estos datos pueden variar.

 Funciones, son un trozo de cdigo que puede ser usado/llamado desde cualquier parte del
sketch. A la funcin se le puede llamar directamente o pasarle unos parmetros, en funcin
de cmo est definida.
setup() y loop, son dos funciones especiales que es obligatorio declarar en cualquier sketch.
Comentarios, fundamentales para documentar el proyecto
Se puede resumir un sketch de Arduino en los siguientes diagramas de flujo:

Por ejemplo para un robot que esquiva obstculos, el diagrama sera:

Y en un caso ms complejo, este puede ser el diagrama de flujo de un sistema de control de acceso
mediante lectura de tarjetas RFID:

Y el cdigo asociado a este diagrama se puede encontrar en

http://geekchickens.blogspot.com.es/2014/01/control-de-acceso-con-lector-de.html

Primer proyecto: blink

En lugar del clsico hola mundo que es el primer programa cuando se aprende un lenguaje de
programacin, en Arduino el equivalente el proyecto blink.
Nuestro primer programa ser hacer parpadear el led integrado que lleva Arduino u otro led
conectado a un pin digital a travs de una resistencia.
Este es el esquema a usar:

Conexiones internas de la protoboard son as:

Pasos a seguir:
Abrir la aplicacin Arduino
Abrir el ejemplo blink

Seleccionar la placa y el puerto adecuado

Cargar el programa pulsando el botn subir. El programa se compilar y luego se ver

parpadeando los leds Tx y Rx de Arduino, indicando que se est cargando el fichero binario
(.hex) en la flash del Arduino. Cuando aparezca el mensaje subido habremos acabado.
Unos segundos despus veremos el LED parpadeando.
Una explicacin completa del proyecto y enlaces a las funciones usadas est en:
http://arduino.cc/en/Tutorial/Blink
Prctica: Modificar el programa para que cada vez que encienda y apague saque por el puerto serie
la cadena encendido, apagado cuando corresponda. Luego guardarlo en nuestro entorno de
trabajo.
Ser necesario usar la librera Serial: http://arduino.cc/en/Reference/Serial
Solucin: https://github.com/jecrespo/Aprendiendo-Arduino/blob/master/Ejercicio01Blink/Ejercicio01-Blink.ino
Prctica: Revisar el cdigo del programa DigitalReadSerial de los ejemplos en Basis. Cargar y
ejecutar en Arduino:http://arduino.cc/en/Tutorial/DigitalReadSerial

Explicacin completa de la prctica: http://arduino.cc/en/Tutorial/DigitalReadSerial

Que valores lee si dejo al aire la entrada digital 2?
Las 10 primeras cosas que debes hacer con tu arduino:
http://antipastohw.blogspot.com.es/2009/12/first-10-things-everyone-does-with.html

Libreras
Las libreras son trozos de cdigo hechas por terceros que usamos en nuestro sketch. Esto nos
facilita mucho la programacin y hace que nuestro programa sea ms sencillo de hacer y luego de
entender. En este curso no veremos como hacer o modificar una librera pero en este curso debemos
ser capaces de buscar una librera, instalarla, aprender a usar cualquier librera y usarla en un
sketch.
Las libreras son colecciones de cdigo que facilitan la interconexin de sensores, pantallas,
mdulos electrnicos, etc. El entorno de arduino ya incluye algunas libreras de manera que facilita,
por ejemplo, mostrar texto en pantallas LCD.
Existen infinidad de libreras desarrolladas por terceros en internet con sus correspondientes forks,
que nos ayudarn a conectar prcticamente cualquier dispositivo a nuestras tarjetas con arduino.
Las libreras normalmente incluyen los siguientes archivos comprimidos en un archivo ZIP o dentro
de un directorio:
Un archivo .cpp (cdigo de C++)
Un archivo .h o encabezado de C, que contiene las propiedades y mtodos o funciones de la
librera.
Un archivo Keywords.txt, que contiene las palabras clave que se resaltan en el IDE
Muy posiblemente la librera incluye un archivo readme con informacin adicional sobre la
librera para el desarrollador.
Directorio denominado examples con varios sketchs de ejemplo que nos ayudar a entender
como usar la librera.
Como instalar libreras: http://arduino.cc/en/Guide/Libraries
Hay varios mtodos de instalar libreras:

 Mediante el IDE de Arduino de forma automtica. Admite la instalacin desde un fichero zip
o desde una carpeta ya descomprimida.

Instalacin Manual. Descomprimiendo en un directorio la librera y copiandolo en el

directorio de libreras. Generalmente Mi Documentos Arduino libraries. Aqu se guardan
las libreras contribuidas por el usuario como lo denomina el IDE.

El propio IDE de Arduino ya trae integradas varias libreras, pero adems podemos descargar otras
e incorporarlas a nuestro IDE y luego usarlas en nuestros programas.
Por ejemplo, la librera para trabajar con pantallas LCD. En este enlace est la ducumentacin para
el uso de esta libreras as como los mtodos que nos facilita para trabajar con este tipo de pantallas:
http://arduino.cc/en/Reference/LiquidCrystal
El listado de libreras incluidas en el IDE y algunas de terceros podemos verlo en este enlace y
acceder a la documentacin de cada una de ellas para saber como usarlas:
http://arduino.cc/en/Reference/Libraries

En el Arduino Playground tambin tenemos un listado mucho ms amplio de libreras, ordenadas

por categoras: http://playground.arduino.cc/Main/LibraryList
Para finalizar con las libreras, generalmente cada dispositivo que compramos, shield, sensor,
actuador, etc viene con su propia librera que debemos instalar para poder usarlo. Estas libreras
podemos verlas, modificarlas o incluso aadir funcionalidades.
Por ejemplo si compramos una sonda de temperatura y humedad de tipo DHT11 como esta:
http://www.adafruit.com/product/386, para usarla necesitaremos su libreria correspondiente.
En la web del fabricante o el vendedor deberemos tener disponible la librera y el datasheet del
dispositivo, en este caso.
Librera: https://github.com/adafruit/DHT-sensor-library
Datasheet: http://www.adafruit.com/datasheets/DHT22.pdf

Prctica: Instalacin de libreras

Prctica. Librera MsTimer2:
Instalar la librera MsTimer2 que nos ser de utilidad en el futuro. Y ejecutar el programa de
ejemplo que incluye.
Documentacin de la librera: http://playground.arduino.cc/Main/MsTimer2
Nueva versin de la librera: http://www.pjrc.com/teensy/td_libs_MsTimer2.html
Repositorio: https://github.com/PaulStoffregen/MsTimer2
Prctica. Librera Sonda temperatura/humedad:
Instalar la librera del sensor de temperatura y humedad DHT22.
Web del sensor: http://www.seeedstudio.com/depot/grove-temperaturehumiditysensor-pro-p-838.html
Documentacin: http://www.seeedstudio.com/wiki/Grove__Temperature_and_Humidity_Sensor_Pro
Repositorio: https://github.com/SeeedStudio/Grove_Temperature_And_Humidity_Sensor
Pasos para realizar las prcticas:

Leer la documentacin y entender que hace la librera.

Descargar el .zip del repositorio de github. Botn Download zip.
Instalar la librera de forma automtica
Abrir el ejemplo FlashLed y ejecutarlo en Arduino.
Abrir algunos de los ejemplos de la sonda y leer el cdigo.

IMPORTANTE: Para aadir una librera a nuestro proyecto simplemente se aade a nuestro
cdigo la palabra clave #include seguido del nombre de la librera.
EXTRA: Ver la diferencia entre usar varios ficheros para estructurar nuestro cdigo y hacer lo
mismo con una librera. Ver los ejercicios 2 y 3:

 https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio02-Funciones
https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio03-Librerias

Simulador Arduino
Fritzing es el programa por excelencia para la realizacin de esquemas elctricos en proyectos con
Arduino. Es software open source. Dispone bibliotecas con la mayora de componentes, incluido
por supuesto los propios Arduinos, placas de conexiones, led, motores, displays etc. Adems
permite hacer esquemas elctricos, cambiar el color de los cables, disear nuestro PCB final un
sin fin de opciones que convierten a este programa en una herramienta muy til.
Tambin nos permitir obtener el esquema elctrico, listado de componente usados y el diagrama
para fabricar la PCB. Nos permitira disear un shield propio con nuestras necesidades.
Fritzing no es un simulador.

Web Principal: http://fritzing.org/home/

Descarga: http://fritzing.org/download/
Solicitar fabricar diseo realizado con Fritzing: http://fab.fritzing.org/fritzing-fab
Prctica: Instalar Fritzing y hacer un pequeo proyecto.
123D Circuit.io: Herramienta online gratuita de Autodesk que permite dibujar esquemas de forma
similar a Fritzing. Adems permite simulacin de circuitos, e incluso podemos realizar la
programacin virtual de las placas Arduino y comprobar el funcionamiento, es un simulador
online.

Una genial iniciativa que, de momento, an tiene unos cuantos problemas. La simulacin es lenta y
como programa de dibujo sigue siendo mejor Fritzing. No obstante, una aplicacin muy interesante
que esperamos mejore y a la que desde luego merece la pena echar un vistazo.

Web principal que merece la pena ser visitada y ver todo lo que ofrece: http://123d.circuits.io/
Web del simulador: http://www.123dapp.com/circuits

Prctica: Uso del simulador de Arduino

Prctica: Darse de alta en http://123d.circuits.io y simular el sketch de blink.
Darse de alta en la web
New Breadboard Circuit
Aadir un Arduino, un led y una resistencia
Copiar el cdigo del sketch de blink completo: https://github.com/jecrespo/AprendiendoArduino/blob/master/Ejercicio01-Blink/Ejercicio01-Blink.ino
Ejecutar el cdigo y ver por la consola virtual que funciona igual que en la realidad.
Probar a poner diferentes valores de resistencia.
Probar a hacer un fork de un ejemplo y guardarlo en la cuenta creada.

EXTRA: Guias Arduino, un recopilacin de guias de iniciacin a Arduino disponible en el

playground: http://playground.arduino.cc/Es/Guias
EXTRA: La comunidad Arduino:
Artculo completo: https://aprendiendoarduino.wordpress.com/2014/11/22/tema-2plataforma-software-arduino-2/
Arduino playground: http://playground.arduino.cc/
stackexchange: http://arduino.stackexchange.com/

 Arduino en las redes sociales

Listado de Hackerspaces: https://hackerspaces.org/wiki/List_of_ALL_Hacker_Spaces

Lenguaje de programacin de Arduino,

estructura de un programa
Para programar un Arduino, el lenguaje estndar es C++, aunque es posible programarlo en otros
lenguajes. No es un C++ puro sino que es una adaptacin que proveniente de avr-libc que provee de
una librera de C de alta calidad para usar con GCC en los microcontroladores AVR de Atmel y
muchas funciones especficas para los MCU AVR de Atmel.
avr-binutils, avr-gcc y avr-libc son las herramientas necesarias para programar los
microcontroladores AVR de Atmel.
AVR-libc reference manual de Atmel:
http://www.atmel.com/webdoc/AVRLibcReferenceManual/index.html
Dispositivos soportados:
http://www.atmel.com/webdoc/AVRLibcReferenceManual/index_1supp_devices.html
Webs del proyecto: http://www.nongnu.org/avr-libc/ y http://savannah.nongnu.org/projects/avr-libc/
Tratamiento de la memoria de la MCU por avr-libc:
http://www.atmel.com/webdoc/AVRLibcReferenceManual/malloc_1malloc_intro.html
Mdulos de avr-libc: http://www.atmel.com/webdoc/AVRLibcReferenceManual/ch20.html
GNU C libc: http://www.gnu.org/software/libc/index.html
GCC es un conjunto de compiladores que se considera el estndar para los Sistemas Operativos
derivados de UNIX y requiere de un conjunto de aplicaciones conocidas como binutils que son unas
herramientas de programacin para la manipulacin de cdigo de objeto.
Cuando GCC est construido para ejecutarse en un sistema como Linux, Windows o mac OS y
generar cdigo para un microcontrolador AVR, entonces se denomina avr-gcc
avr-gcc es el compilador que usa el IDE de arduino para convertir el sketch en C++ a un fichero
binario (.hex) que es el que se carga en la flash del MCU y que ejecuta.
Informacin sobre las binutils:
http://www.atmel.com/webdoc/AVRLibcReferenceManual/overview_1overview_binutils.html
Proyecto GCC: https://gcc.gnu.org/
Pero para programar proyectos de complejidad media, la mayora de los comandos que necesitemos
con Arduino los encontraremos en la referencia de programacin de Arduino en el Arduino
Reference, que es donde debemos recurrir para cualquier duda de programacin que surja. Arduino
provee de unas libreras que facilitan la programacin del microcontrolador.
http://arduino.cc/en/Reference/HomePage

El gran xito de Arduino en parte se debe a que nos permite programar un MCU sin tener que saber
todo lo anterior y nos da unas herramientas sencillas y especficas para programar unos
microcontroladores que suministra en sus placas.
Por ejemplo veamos las funciones que nos ofrece para comunicar por el puerto serie:
http://arduino.cc/en/Reference/Serial
El lenguaje de programacin usado por Arduino est basado en Processing:
http://www.gnu.org/software/libc/index.html, es un lenguaje de programacin y entorno de
desarrollo integrado de cdigo abierto basado en Java, de fcil utilizacin, y que sirve como medio
para la enseanza y produccin de proyectos multimedia e interactivos de diseo digital.
Web del proyecto de Proccesing: https://processing.org/
Processing en github: https://github.com/processing/processing

Processing es til cuando queremos comunicar Arduino con un ordenador y mostrar datos o guardar
datos, pero tambin podemos usar otros lenguajes de programacin como python, .NET o cualquier
otro que conozcamos.
Arduino trae algunos ejemplos para trabajar con Processing en el apartado communication, por
ejemplo, para hacer una grfica de datos en http://arduino.cc/en/Tutorial/Graph
Ver el reference y la librera Serial de processing para darnos cuenta en la similitud de los lenguajes:
https://processing.org/reference/ y https://processing.org/reference/libraries/serial/
Tambin disponemos de una librera de Arduino dentro de processing que nos permite interactuar
entre processing y arduino: http://playground.arduino.cc/interfacing/processing
Por supuesto Arduino se puede programar en otros lenguajes y desde otros entornos de
programacin, lo que va a hacer que el cdigo sea diferente. Cabe destacar scratch como un
lenguaje visual que hace innecesario saber programacin o Atmel Studio que es la herramienta que
proporciona Atmel.
Ms informacin en: https://aprendiendoarduino.wordpress.com/2014/11/20/tema-4-conceptosbasicos-de-programacion/
Como ya hemos visto, la estructura bsica 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.
setup() http://arduino.cc/en/Reference/Setup

 loop() http://arduino.cc/en/Reference/Loop

Lenguaje de programacin C++

El lenguaje de programacin de Arduino est basado en C++ y aunque la referencia para el lenguaje
de programacin de Arduino est en http://arduino.cc/en/Reference/HomePage, tambin es posible
usar comandos estandar de C++ en la programacin de Arduino.

Caractersticas de C:
Es el lenguaje de programacin de propsito general asociado al sistema operativo UNIX.
Es un lenguaje de medio nivel. Trata con objetos bsicos como caracteres, nmeros, etc
tambin con bits y direcciones de memoria.
Posee una gran portabilidad
Se utiliza para la programacin de sistemas: construccin de intrpretes, compiladores,
editores de texto, etc
Un buen libro de referencia para C: http://es.wikipedia.org/wiki/El_lenguaje_de_programaci
%C3%B3n_C
Y un libro que se puede descargar gratuitamente Essential C:
http://cslibrary.stanford.edu/101/EssentialC.pdf
Por supuesto en Internet hay muchas webs de referencia donde consultar dudas a la hora de
programar en C++:

http://www.cplusplus.com/
http://en.cppreference.com/w/cpp
http://www.c.conclase.net/
http://www.tutorialspoint.com/cplusplus/

C++ es un lenguaje de programacin diseado a mediados de los aos 1980 por Bjarne Stroustrup.
La intencin de su creacin fue el extender al exitoso lenguaje de programacin C con mecanismos
que permitan la manipulacin de objetos. En ese sentido, desde el punto de vista de los lenguajes
orientados a objetos, el C++ es un lenguaje hbrido.
Posteriormente se aadieron facilidades de programacin genrica, que se sum a los otros dos
paradigmas que ya estaban admitidos (programacin estructurada y la programacin orientada a
objetos). Por esto se suele decir que el C++ es un lenguaje de programacin multiparadigma.
Actualmente existe un estndar, denominado ISO C++,
C# es un lenguaje propietario de Microsoft que mezcla las caractersticas bsicas de C++ (no las
avanzadas) simplificndolas al estilo Java y ofreciendo un framework. C# forma parte de la
plataforma .NET
Elementos bsicos en la programacin en C++

{} 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.
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. Slo 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).
; punto y coma
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.
Nota: Si olvidis poner fin a una lnea con un punto y coma se producir en un error de
compilacin.
/* */ bloque de comentarios

Los bloques de comentarios, o comentarios multi-lnea 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.
Debido a que los comentarios son ignorados por el compilador y no ocupan espacio en la memoria
de Arduino pueden ser utilizados con generosidad.
// 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.
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.
A la hora de programar Arduino, es fundamental usar la referencia que disponemos online en
http://arduino.cc/en/Reference/HomePage o en la ayuda del IDE de Arduino. Cualquier duda sobre
un comando, funcin, etc debemos consultar en la referencia de Arduino.
Un manual sencillo de entender para programacin y en el que est basado este captulo es el
arduino programming notebook de brian w. Evans. Puedes consultarlo o descargarlo desde:
http://www.ardumania.es/wp-content/uploads/2011/10/Arduino_programing_notebook_ES.pdf
Existe una gua de estilo para escribir cdigo claro de Arduino y que sea fcil de entender. No es
obligatorio, pero es una recomendacin:

Documentar al mximo
Usar esquemas
Predominar la facilidad de lectura sobre la eficiencia del cdigo
Poner el setup() y loop() al principio del programa
Usar variables descriptivas
Explicar el cdigo al principio
Usar identacin

Guia de estilo: http://arduino.cc/en/Reference/StyleGuide

Una buena gua de estilo de C++: http://informatica.uv.es/iiguia/AED/laboratorio/Estilocpp.pdf

Variables
Que es una variable? Una variable es un lugar donde almacenar un dato y se caracteriza por tener
un nombre, un valor y un tipo.

Los nombres de variables pueden tener letras, nmeros y el smbolo _. Deben empezar por una
letra (pueden empezar por _ pero no es recomendable pues es el criterio que usan las rutinas de la
biblioteca). Pueden llevar maysculas y minsculas. El C distingue entre maysculas y
minsculas.
La costumbre es que las variables van en minscula y las constantes en mayscula
Usa las mismas reglas dentro del cdigo para el nombramiento de variables, ya sea en minscula
con palabras separadas con guiones bajos, tantos como sea necesario para mejorar la legibilidad o
utilizar la convencin CapWords (palabras que comienzan con maysculas), aunque generalmente
la primera palabra se pone en minsculas.
Usa un solo guin bajo como prefijo para mtodos no pblicos y variables de instancia.
Las palabras reservadas if, else . . . no pueden usarse como nombres de variables.
Nombres para evitar: Nunca uses los caracteres l (letra ele en minscula), O (letra o mayscula),
o I (letra i mayscula) como simples caracteres para nombres de variables, para evitar confusiones
a la hora de leer el cdigo.
Declaracin de variables.
Una variable tiene un nombre, un valor y un tipo. Con la asignacin, se puede cambiar el valor de la
variable.
Todas las variables deben ser declaradas antes de su uso. Las declaraciones deben aparecer al
principio de cada funcin o bloque de sentencias. Al declarar una variable se debe indicar primero
el tipo de variable y luego su nombre, opcionalmente se le puede dar un valor, lo que se llama
inicializar la variable.
La declaracin consta de un tipo de variable y una lista de variables separadas por coma.
int i,j;
float x,pi;
unsigned long longitud, contador;
Las variables pueden inicializarse en la declaracin
float pi=3.1416;

 unsigned long contador=0;

Puede utilizarse el modificador const para indicar que la variable no puede ser cambiada en tiempo
de ejecucin.
const float e=2.7182;
Esto slo debe hacerse una vez en un programa, pero el valor de la variable se puede cambiar en
cualquier momento usando aritmtica y reasignaciones diversas.
Una variable puede ser declarada en una serie de lugares del programa y en funcin del lugar en
donde se lleve a cabo la declaracin, esto determinar en qu partes del programa se podr hacer
uso de ella, es lo que se denomina mbito de la variable o scope.
C y C++ se dice que son lenguajes de tipado esttico, es decir, la comprobacin de tipificacin se
realiza durante la compilacin, y no durante la ejecucin, por lo tanto no podemos cambiar el tipo
de una variable en tiempo de ejecucin. Otros lenguajes, generalmente interpretados, son de tipado
dinmico y una misma variable puede tomar valores de distinto tipo en distintos momentos, como
PHP o python.
La explicacin de www.arduino.cc de las variables: http://arduino.cc/en/Tutorial/Variables y
http://arduino.cc/en/Reference/VariableDeclaration
mbito 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 determinar 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().
Recordad que al declarar una variable global, est un espacio en memoria permanente en la zona de
static data y el abuso de variables globales supone un uso ineficiente de la memoria.
Una variable local es aquella que se define dentro de una funcin o como parte de un bucle. Slo es
visible y slo 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, pero no es una prctica aconsejable porque complica la lectura de
cdigo.
En el reference de Arduino hay una muy buena explicacin del mbito de las
variables:http://arduino.cc/en/Reference/Scope
El modificador de variable static, es utilizado para crear variables que solo son visibles dentro de
una funcin, sin embargo, al contrario que las variables locales que se crean y destruyen cada vez
que se llama a la funcin, las variables estticas mantienen sus valores entre las llamadas a las
funciones.
La variables estticas solo se crean e inicializan la primera vez que la funcin es llamada.

Ver ejemplo en: http://arduino.cc/en/Reference/Static

Tipos de Datos

byte Byte almacena un valor numrico de 8 bits sin decimales. Tienen un rango entre 0 y 255. Sin
signo. http://arduino.cc/en/Reference/Byte
int Enteros son un tipo de datos primarios que almacenan valores numricos de 16 bits sin
decimales comprendidos en el rango 32,767 a -32,768.
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 hacemos x++, entonces x pasar a ser
-32.768. Porque ocurre esto? http://en.wikipedia.org/wiki/Two%27s_complement
Ms informacin en:
http://arduino.cc/en/Reference/Int
http://arduino.cc/en/Reference/UnsignedInt
http://arduino.cc/en/Reference/Word
Las constantes enteras son nmeros utilizados en el sketch, estos nmeros son tratados como
enteros, pero podemos cambiar su comportamiento
Las constantes enteras son tratadas como base 10 (Decimal), pero con una notacin especial
podemos cambiar su representacin en otras bases.

Binario B00001110
Octal 0173
Hexadecimal 0x7C3
Para forzar a formato unsigned: 78U 78u
Para forzar a formato long: 1000L 1000l
Para forzar a formato unsigned long: 2521UL 2521ul

Ms informacin en: http://arduino.cc/en/Reference/IntegerConstants

long El formato de variable numrica de tipo extendido long se refiere a nmeros enteros (tipo
32 bits = 4 bytes) sin decimales que se encuentran dentro del rango -2147483648 a 2147483647.

Ver ms informacin en:

http://arduino.cc/en/Reference/Long
http://arduino.cc/en/Reference/UnsignedLong
float El formato de dato del tipo coma flotante o float se aplica a los nmeros con decimales.
Los nmeros de coma flotante tienen una mayor resolucin que los de 32 bits que ocupa con un
rango comprendido 3.4028235E+38 a -3.4028235E+38.
Los nmeros de punto flotante no son exactos, y pueden producir resultados extraos en las
comparaciones. Los clculos matemticos de coma flotante son tambin mucho ms lentos que los
del tipo de nmeros enteros, por lo que debe evitarse su uso si es posible. En Arduino el tipo de dato
double es igual que el float.
Ms informacin:
http://arduino.cc/en/Reference/Float
http://arduino.cc/en/Reference/Double
Las constantes de coma flotante se usan para facilitar la lectura del cdigo, pero aunque no se use,
el compilador no va a dar error y se ejecutar normalmente.
10.0 se evala como 10
2.34E5 67e-12 (expresado en notacin cientfica)
Ms informacin en: http://arduino.cc/en/Reference/Fpconstants
Para entenderlo mejor: la representacin de coma flotante (en ingls floating point, punto flotante)
es una forma de notacin cientfica usada en las CPU, GPU, FPU, etc, con la cual se pueden
representar nmeros racionales extremadamente grandes y pequeos de una manera muy eficiente y
compacta, y con la que se pueden realizar operaciones aritmticas. El estndar para la
representacin en coma flotante es el IEEE 754. http://es.wikipedia.org/wiki/Coma_flotante
Signo (s) 1: negativo , 0: positivo (bit 31)
Mantisa (M) La mantisa incluye 23 bits (bit 0.. 22). Representa la parte derecha de nmero
decimal.
Exponente (e) El exponente incluye 8 bits (bit 23..30).

boolean Un booleano solo tiene dos valores true y false. Cada booleano ocupa un byte de
memoria. Ver:
http://arduino.cc/en/Reference/BooleanVariables
Lgica binaria: http://es.wikipedia.org/wiki/L%C3%B3gica_binaria
char Un char representa un carcter que ocupa 1 byte de memoria. Los caracteres simples se
representan con comillas simples a y para mltiples caracteres o strings se representan con
comillas dobles Hola!.
Recordar que los caracteres se almacenan como nmeros usando la codificacin ASCII, lo que
significa que es posible hacer operaciones aritmticas con los caracteres.
Ver lo siguientes enlaces del Arduino reference:
http://arduino.cc/en/Reference/Char
http://arduino.cc/en/Reference/ASCIIchart
http://arduino.cc/en/Reference/UnsignedChar
Sistemas de codificacin utilizados:

Binario.
BCD (Binario codificado a decimal)
Hexadecimal.
ASCII

Prctica: Efectos con LEDs

Ejercicio: Hacer el efecto de las luces del coche fantastico con 6 leds
Esquema de conexin:

Recordar poner la resistencia adecuada a cada led. Ley de ohm: V = I * R, si el voltaje es de 5 V y

queremos que al LED solo le lleguen entre 5 mA (0.005 A) y 20 mA (0.02 A), entonces usar una
resistencia entre 250 y 1000 ohms.
Cdigo de colores de las resistencias.

Mirad este tutorial y hacer solo la primera solucin: http://www.arduino.cc/en/Tutorial/KnightRider,

las otras soluciones la veremos justo despus de ver arrays y nos servir para entender mejor su uso.
Solucin:
https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio17-CocheFantastico
https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio17-CocheFantastico2

Arrays y Strings
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 un array indicando el tipo de datos y el tamao y
posteriormente, asignar valores a una posicin especfica:
int miArray[5];
miArray[3] = 10;
Para leer de un array basta con escribir el nombre y la posicin a leer:
x = miArray[3];
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 realizada sigue escribiendo en las siguientes posiciones. Con un
bucle for podremos recorrer un array ya sea para leerlo o para escribir en l.
int myPins[5];
int i;
for (i = 0; i < 5; i = i + 1) {
Serial.println(myPins[i]);
}
No se puede crear un array sin definir su tamao, sino da un error de compilacin.
Los arrays slo pueden contener elementos del mismo tipo de datos. Si quisiramos guardar tipos de
datos diferentes en una misma variable, C nos ofrece la opcin definir estructuras:
http://www.ib.cnea.gov.ar/~icom/web/estructuras.htm
Ver ms informacin en: http://arduino.cc/en/Reference/Array
Es posible definir arrays de varias dimensiones o matrices, simplemente haciendo un arrary de
arrays:

int matriz[5][5];
matriz[2][0] = 3;
Ejercicio: Hacer las otras el ejercicio del coche fantastico con un array de 6 elementos.
string Es un array de chars.

Cuando se trabaja con grandes cantidades de texto, es conveniente usar un array de strings. Puesto
que los strings son en si mismo arrays.
Ver:

http://arduino.cc/en/Reference/String
http://en.wikipedia.org/wiki/Null_character (representa el fin de un string)
http://en.wikipedia.org/wiki/Null-terminated_string
clase string de c++: http://www.cplusplus.com/reference/string/string/

String Se trata de una clase que permite usar y manipular cadenas de texto de una forma ms
sencilla que los strings. Puedes concatenar, aadir, buscar, etc usando los mtodos/funciones que
ofrece esta clase.
Los Strings tienen un uso intensivo de memoria, pero son muy tiles.
Tener en cuenta que al no ser un tipo de dato propiamente dicho sino una clase, tienes unas
funciones asociadas (mtodos), operadores y unas propiedades. Es una abstraccin del dato y para
saber usarlo hay que leerse la documentacin correspondiente.
Ver documentacin de Arduino sobre la clase String:
http://arduino.cc/en/Reference/StringObject
http://arduino.cc/en/Reference/StringConstructor Constructir
http://arduino.cc/en/Reference/StringCompareTo Comparador
http://arduino.cc/en/Reference/StringConcat Concatenar
http://arduino.cc/en/Reference/StringGetBytes copiar a un buffer
http://arduino.cc/en/Reference/StringIndexOf localiza un caracter o string
http://arduino.cc/en/Reference/StringLength longitud del String
http://arduino.cc/en/Reference/StringStartsWith Comprueba si comienza por una cadena
que se pasa como parmetor
http://arduino.cc/en/Reference/StringToCharArray Pasa de String a string
http://arduino.cc/en/Reference/StringCharAt Accede a un caracter concreto del String
http://arduino.cc/en/Reference/StringReserve Permite asignar un buffer en memoria para
manipular strings.

Adems de la clase String, podemos utilizar las funciones estndar de C++ para manipular strings y
hacer lo mismo que hacemos con la clase String, pero de una forma ms compleja, donde tendremos
que manejarnos bien con los punteros.
http://www.cplusplus.com/reference/cstring/
http://www.cplusplus.com/reference/cstring/strcmp/
http://www.cplusplus.com/reference/cstring/strcat/
Conversiones de tipos (Casting)
En ocasiones es necesario forzar el cambio de tipo de dato (casting). Podemos usar las siguientes
funciones:

char() http://arduino.cc/en/Reference/CharCast
byte() http://arduino.cc/en/Reference/ByteCast
int() http://arduino.cc/en/Reference/IntCast
word() http://arduino.cc/en/Reference/WordCast
long() http://arduino.cc/en/Reference/LongCast
float() http://arduino.cc/en/Reference/FloatCast

Constantes
Las constantes son generalmente definidas a nivel mdulo, escritas con todas las letras en
mayscula y con guiones bajos separando palabras. Por ejemplo, MAX_OVERFLOW y TOTAL.
El modificador const, modifica el comportamiento de una variable hacindola read-only, esto
significa que puede usarse como cualquier otra variable pero su valor no puede ser cambiado.
Ver ejemplo en: http://arduino.cc/en/Reference/Const
Constantes predefinidas en Arduino: http://arduino.cc/en/Reference/Constants

Prctica: Arrays, strings y Strings

Ejercicio: Aprender a manejar strings y Strings
Revisar todos estos tutoriales y ver como funciona cada uno:

http://arduino.cc/en/Tutorial/StringConstructors
http://arduino.cc/en/Tutorial/StringCharacters
http://arduino.cc/en/Tutorial/StringComparisonOperators
http://arduino.cc/en/Tutorial/StringCaseChanges
http://arduino.cc/en/Tutorial/StringCharacters

Ejercicio: Partiendo de la base del ejercicio StringsComparisonOperators intentar hacer las mismas
operaciones pero con string en lugar de String.
Ejercicio: Hacer una versin donde al reiniciar Arduino pregunta que introduzca un string
cualquiera y lo paso por puerto serie. Luego lo almacena en una variable y muestra lo leido por el
puerto serie.
No olvidar poner en el setup() la inicializacin del puerto serie: Serial.begin(9600);
Para leer por el puerto serie:
while (Serial.available() == 0){
//Ho hago nada
}
do{
caracter_leido = Serial.read();
cadena_Leida += caracter_leido;

delay(5);
} while (Serial.available() > 0);
Ejercicio: Hacer otra versin donde me pide un nmero al reiniciar Arduino y lo paso por el puerto
serie. Luego multiplicar por 15 ese nmero y sacar por el puerto serie el resultado. En caso que lo
introducido no sea un nmero sacar por pantalla el error.
Esto lo aplicaremos en la prctica de dimmer para manejar la luminosidad de un led con un valor
que paso por el puerto serie ms adelante.
Recordar que es necesario usar la funcin toInt(): http://arduino.cc/en/Reference/StringToInt
Solucin: https://github.com/jecrespo/Aprendiendo-Arduino/blob/master/Ejercicio18strings/Ejercicio18-strings.ino

Operadores
1 respuesta

Aritmticos
Compuestos
Comparacin
Booleanos

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 operandos.
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 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 utilizar 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 utilizar el mtodo de float es decir el mtodo de coma flotante.
Elegir el tamao de las variables de tal manera que sea lo suficientemente grande como para que los
resultados sean lo precisos que deseamos. Para las operaciones que requieran decimales utilizar
variables tipo float, pero ser conscientes de que las operaciones con este tipo de variables son ms
lentas a la hora de realizarse el cmputo.
Asignacin: http://arduino.cc/en/Reference/Assignment

 +, -, *, /: http://arduino.cc/en/Reference/Arithmetic
Mdulo: http://arduino.cc/en/Reference/Modulo
Las operadores compuestos 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:
++, : http://arduino.cc/en/Reference/Increment
+= , -= , *= , /= : http://arduino.cc/en/Reference/IncrementCompound
Operadores de comparacin. Las comparaciones de una variable o constante con otra se utilizan
con frecuencia en las estructuras condicionales del tipo if, while, etc.. para testear si una condicin
es verdadera.
http://arduino.cc/en/Reference/If
Los operadores lgicos o booleanos son usualmente una forma de comparar dos expresiones y
devuelve 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.
http://arduino.cc/en/Reference/Boolean
Tambin existen operadores para los Strings:
http://arduino.cc/en/Tutorial/StringComparisonOperators
http://arduino.cc/en/Reference/StringCompareTo
http://arduino.cc/en/Reference/StringSubstring
Un resumen de los operadores en C /C++ y ms
informacin:http://es.wikipedia.org/wiki/Anexo:Operadores_de_C_y_C%2B%2B

structuras de control
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.
Referencia Arduino: http://arduino.cc/en/Reference/If
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.
else: puede ir precedido de otra condicin 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 slo un conjunto de declaraciones se llevar a cabo
dependiendo de la condicin probada.

Referencia Arduino: http://arduino.cc/en/Reference/Else

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 condicin. La declaracin for tiene tres partes separadas por (;). La inicializacin de la
variable local se produce una sola vez y la condicin se testea cada vez que se termina la ejecucin
de las instrucciones dentro del bucle. Si la condicin sigue cumplindose, las instrucciones del
bucle se vuelven a ejecutar. Cuando la condicin no se cumple, el bucle termina.
Cualquiera de los tres elementos de cabecera puede omitirse, aunque el punto y coma es obligatorio.
Tambin las declaraciones de inicializacin, condicin y expresin puede ser cualquier estamento
vlido en lenguaje C sin relacin con las variables declaradas.
Referencia Arduino: http://arduino.cc/en/Reference/For
While: 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.
Referencia Arduino: http://arduino.cc/en/Reference/While y
http://arduino.cc/en/Tutorial/WhileLoop
do..while: El bucle do while funciona de la misma manera que el bucle while, con la salvedad de
que la condicin se prueba al final del bucle, por lo que el bucle siempre se ejecutar al menos una
vez.
Referencia Arduino: http://arduino.cc/en/Reference/DoWhile
switch..case: Al igual que if, switch..case controla el flujo del programa especificando en el
programa que cdigo se debe ejecutar en funcin de unas variables. En este caso en la instruccin
switch se compara el valor de una variable sobre los valores especificados en la instruccin case.
break es la palabra usada para salir del switch. Si no hay break en cada case, se ejecutar la
siguiente instruccin case hasta que encuentre un break o alcance el final de la instruccin.
default es la palabra que se usa para ejecutar el bloque en caso que ninguna de las condiciones se
cumpla.
Referencia Arduino: http://arduino.cc/en/Reference/SwitchCase
goto: transfiere el flujo de programa a un punto del programa que est etiquetado.
Referencia Arduino: http://arduino.cc/en/Reference/Goto
break se usa en las instrucciones do, for, while para salir del bucle de una forma diferente a la
indicada en el bucle.
Referencia Arduino: http://arduino.cc/en/Reference/Break
continue se usa en las instrucciones do, for, while para saltar el resto de las instrucciones que estn
entre llaves y se vaya a la siguiente ejecucin del bucle comprobando la expresin condicional.

Referencia Arduino: http://arduino.cc/en/Reference/Continue

Y por su puesto ante cualquier duda: http://arduino.cc/en/Reference/HomePage

Funciones definidas por el usuario

Una funcin 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 utilizar cuando la funcin devuelva un dato numrico de tipo entero. Si la
funcin no devuelve ningn valor entonces se colocar delante la palabra void, que significa
funcin vaca
Sintaxis:
tipo nombreFuncin(parmetros){
instrucciones;
}
Para llamar a una funcin, simplemente:
nombreFuncin(parmetros);
Return: Termina una funcin y devuelve un valor a quien ha llamado a la funcin.
http://arduino.cc/en/Reference/Return
Ms informacin: http://arduino.cc/en/Reference/FunctionDeclaration
Nombres de funciones
Generalmente los nombres de las funciones deben ser en minscula, con las palabras separadas por
un guin bajo, aplicndose stos tanto como sea necesario para mejorar la legibilidad.
mixedCase (primera palabra en minscula) es aceptado nicamente en contextos en donde ste es
el estilo predominante con el objetivo de mantener la compatibilidad con versiones anteriores.

En el caso de las clases, los nombres deben utilizar la convencin CapWords (palabras que
comienzan con maysculas).

Libreras
Como se ha visto anteriormente, las libreras son trozos de cdigo hechas por terceros que usamos
en nuestro sketch. Esto nos facilita mucho la programacin y hace que nuestro programa sea ms
sencillo de hacer y luego de entender. En el curso avanzado veremos como hacer una librera.
Este tutorial explica como crear una librera: http://arduino.cc/en/Hacking/LibraryTutorial
Guia de estilo para escribir libreras: http://arduino.cc/en/Reference/APIStyleGuide
Listado de libreras: http://playground.arduino.cc/Main/LibraryList
Otras funciones

millis() http://arduino.cc/en/Reference/Millis
micros() http://arduino.cc/en/Reference/Micros
delay() http://arduino.cc/en/Reference/Delay
delayMicroseconds() http://arduino.cc/en/Reference/DelayMicroseconds
min() http://arduino.cc/en/Reference/Min
max() http://arduino.cc/en/Reference/Max
abs() http://arduino.cc/en/Reference/Abs
constrain() http://arduino.cc/en/Reference/Constrain
pow() http://arduino.cc/en/Reference/Pow
sqrt() http://arduino.cc/en/Reference/Sqrt
sin() http://arduino.cc/en/Reference/Sin
cos() http://arduino.cc/en/Reference/Cos
tan() http://arduino.cc/en/Reference/Tan
random() http://arduino.cc/en/Reference/Random
randomSeed() http://arduino.cc/en/Reference/RandomSeed

Prctica: Blink sin delay

Ejercicio: Ejercicio19-BlinkSinDelay.
Hacer el ejercicio de blink pero sin usar la funcin delay(). Para ello se puede usar las funciones
millis() o micros(). Ejemplo de ejercicio: http://arduino.cc/en/Tutorial/BlinkWithoutDelay
Despus de entender el ejercicio, aadir un botn y a la vez que el LED parpadea, contar cuantas
veces se pulsa el botn y mostrarlo por el puerto serie cada vez que se pulse aumentando el
contador de pulsos. Comprobar la multitarea.
Hacer el mismo ejercicio con las libreras mstimer2 y la librera Timer, de forma con una de ellas
programo cada 5 segundos el parpadeo del LED y con la otra muestro cada 3 segundos el nmero
de pulsaciones contadas.

Libreras:
http://www.doctormonk.com/2012/01/arduino-timer-library.html
http://www.pjrc.com/teensy/td_libs_MsTimer2.html
Y si queremos hacerlo con dos leds?
Solucin: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio19-BlinkSinDelay
EXTRA:
Muchos ms ejemplos y prcticas para hacer: http://arduino.cc/en/Tutorial/HomePage
Una buena chuleta para tener a mano cuando programemos, Cheat Sheet:
https://dlnmh9ip6v2uc.cloudfront.net/learn/materials/8/Arduino_Cheat_Sheet.pdf
Ms cdigo:
Software contribuido por terceros:http://playground.arduino.cc/Main/GeneralCodeLibrary
Como conectar Arduino con una gran variedad de
HW:http://playground.arduino.cc/Main/InterfacingWithHardware
Mas snippets y sketches: http://playground.arduino.cc/Main/SketchList
Todos los tutoriales de Arduino: http://playground.arduino.cc/Main/TutorialList
Ver este ejemplo de programa y fijarse en la estructura:
https://github.com/jecrespo/Home_Power_Meter/blob/master/Home_Power_Meter.ino

Microcontrolador vs Microprocesador
Diferencia principal entre un ordenador y un Arduino: las entradas y salidas que conectamos.
Analoga: Arduino es un Autmata programable, Raspberry Pi es un Ordenador, as que a la hora de
decidirse que utilizar para un proyecto pensar que usaramos un autmata o un Ordenador.
Para programacin en tiempo real el HW a utilizar es el Arduino, para programacin intensiva con
gran cantidad de datos usaramos una Raspberry Pi o un PC.
En un proyecto grande la eleccin es usar ambos, cada uno en la tarea que mejor hace. Por ejemplo,
la recoleccin de datos, supervisin del entorno, envo de alarmas, accionar motores, etc.. lo
dejaremos para el arduino, el tratamiento de los datos recogidos, el interfaz grfico de usuario,
envo de correos, etc lo dejaremos para un ordenador o una raspberry pi o similar.
Diferencias entre el microprocesador y el microcontrolador, caractersticas al usarlos en la
implementacin de sistemas digitales programables:

CPU
Memorias RAM y ROM
Velocidad de Operacin
Tamao
Costes
Interferencias (ruido)

 Tiempo de desarrollo
El uso de una u otra tecnologa depende del fin que se espera, pues debido a sus caractersticas
propias, los microcontroladores y los microprocesadores pueden adquirir variados y diferentes
espacios de implementacin, por ejemplo, los microprocesadores se han desarrollado
fundamentalmente orientados al mercado de los ordenadores personales y las estaciones de trabajo,
pues all se requiere una elevada potencia de clculo, el manejo de gran cantidad de memoria y una
gran velocidad de procesamiento. Mientras que los microcontroladores estn concebidos
fundamentalmente para ser utilizados en aplicaciones puntuales, es decir, aplicaciones donde el
microcontrolador debe realizar un pequeo nmero de tareas, al menor costo posible. En estas
aplicaciones el microcontrolador ejecuta un programa almacenado permanentemente en su
memoria, el cual trabaja con algunos datos almacenados temporalmente e interacta con el exterior
a travs de las lneas de entrada y salida de que dispone.
Microprocesadores
Microcontroladores
El microprocesador tiene mucha ms
potencia de clculo, por lo cual
Es una de sus partes principales, la cual se
CPU
solamente realiza sus funciones con lo
encarga de dirigir sus operaciones.
que tiene (datos) y su algoritmo o
programa establecida.
Son dispositivos externos que lo
Memorias
complementan para su ptimo
Las incluye en un solo circuito integrado.
RAM y ROM
funcionamiento.
Velocidad de
Lenta en comparacin con la de un
Rpida
Operacin
microprocesador
La configuracin mnima bsica de un El Microcontrolador incluye todo estos
Microprocesador est constituida por elementos en un solo Circuito Integrado
un Microprocesador, una memoria
por lo que implica una gran ventaja en
Tamao
RAM, una memoria ROM, un
varios factores, como por ejemplo, la
decodificador de direcciones, lo cual lo disminucin en el tamao del circuito
convierte en un circuito bastante
impreso por la reduccin de los circuitos
engorroso.
externos.
Para el Microprocesador, el costo es
El costo para un sistema basado en
Costos
muy alto en la actualidad.
Microcontrolador es mucho menor.
Son ms susceptibles a la interferencia
electromagntica debido a su tamao y El alto nivel de integracin reduce los
Interferencias
a su cableado externo que lo hace ms niveles de interferencia electromagntica
propenso al ruido.
Tiempo de
El tiempo de desarrollo de un
Por el contrario, el de un microcontrolador
desarrollo
microprocesador es lento.
es rpido.
Raspberry Pi es un ordenador de placa reducida o (placa nica) (SBC) de bajo coste, desarrollado
en Reino Unido por la Fundacin Raspberry Pi. El diseo incluye un System-on-a-chip Broadcom
BCM2835, que contiene un procesador central (CPU) ARM1176JZF-S a 700 MHz, un procesador
grfico (GPU) VideoCore IV, y 512 MiB de memoria RAM.
Los sistemas operativos soportados son distribuciones Linux para arquitectura ARM, Raspbian
(derivada de Debian), RISC OS 5, Arch Linux ARM (derivado de Arch Linux) y Pidora (derivado
de Fedora)

Web principal: http://www.raspberrypi.org/

Especificaciones tcnicas:
http://es.wikipedia.org/wiki/Raspberry_Pi#Especificaciones_t.C3.A9cnicas
El System-on-a-chip Broadcom BCM2835: http://www.raspberrypi.org/wpcontent/uploads/2012/02/BCM2835-ARM-Peripherals.pdf
GPIO:

Tambin intel saca su alternativa a raspberry: http://www.intel.es/content/www/es/es/do-ityourself/edison.html

Vdeo que lo explica todo esto de una forma muy clara: https://www.youtube.com/watch?
v=7vhvnaWUZjE&feature=youtu.be
Ejercicio: Puedo convertir un arduino en un ordenador? Cmo? Es prctico?
Arduino como un ordenador:
Salida TV: https://code.google.com/p/arduino-tvout/, http://www.instructables.com/id/TVOut-with-Arduino/
Pantalla tactil: http://tienda.bricogeek.com/shields-arduino/521-arduino-tft-touch-shieldv20.html
Teclado:
http://playground.arduino.cc/code/Keypad,http://abedulengenharia.blogspot.com.es/2011/07/
arduino-y-teclado-34.html
Separar los procesos en diferentes MCUs, mejor con chips especficos, pero se puede hacer
usando varios microcontroladores, uno ejecuta el SO, otros acceso a disco (controladora),
otro muestra datos por pantalla (tarjeta grfica), tarjeta de sonido, etc
Sistema Operativo, el sketch.
Disco Duro, leer y escribir ficheros. Acceso a una tarjeta SD.
Microcontroladores 8 bits, 16 bits, 32 bits
El tamao de la palabra es un aspecto importante en la arquitectura de procesadores.
La mayora de los registros de un Microprocesador/Microcontrolador tienen el tamao de la palabra
y las operaciones que hace la ALU es manejando operandos cuyo tamao es el tamao de la
palabra, as como la cantidad de datos transferidos a memoria y direccin utilizada para designar
una localizacin de memoria a menudo ocupa una palabra.
Tambin los valores que pueden tomar las variables dependen del tamao de la palabra.
http://es.wikipedia.org/wiki/Palabra_%28inform%C3%A1tica%29

Memoria Flash, SRAM y EEPROM

Tipos de memorias en Arduino:
SRAM: Variables locales, datos parciales. Usualmente se trata como banco de registros
(PIC), Memoria voltil. Donde el sketch crea y manipula las variables cuando se ejecuta. Es
un recurso limitado y debemos supervisar su uso para evitar agotarlo.
EEPROM: Se puede grabar desde el programa del microcontrolador. Usualmente,
constantes de programa. Memoria no voltil para mantener datos despus de un reset. Las
EEPROMs tienen un nmero limitado de lecturas/escrituras, tener en cuenta a la hora de
usarla.
Flash: Memoria de programa. Usualmente desde 1 Kb a 4 Mb (controladores de familias
grandes). Donde se guarda el sketch.
Memoria en Arduino: http://arduino.cc/en/Tutorial/Memory

Un buen tutorial para aprender como funcionan las memorias de tu Arduino:

https://learn.adafruit.com/memories-of-an-arduino/you-know-you-have-a-memory-problem-whendot-dot-dot
MCU vs CPU en funcion de la arquitectura de la memoria: https://learn.adafruit.com/memories-ofan-arduino/arduino-memory-architecture
Como medir la memoria libre que tenemos en Arduino: https://learn.adafruit.com/memories-of-anarduino/measuring-free-memory
Como saber cuando me he quedado sin memoria: https://learn.adafruit.com/memories-of-an-arduino
Como guardar variables en la memoria flash en lugar de en la SRAM, le decimos al compilador que
ponga esta informacin en la memoria flash: http://playground.arduino.cc/Learning/Memory
Como optimizar la memoria: https://learn.adafruit.com/memories-of-an-arduino/optimizingprogram-memory

A partir de la versin 1.6 del IDE al compilar un sketch nos da el tamao que va a ocupar en la flash
el proyecto y el espacio que va a ocupar en la SRAM las variables globales, es decir, la zona de
static data.

Ms informacin sobre el uso de memoria en lso microcontroladores AVR de Atmel, visitar lso
siguientes enlaces: http://www.nongnu.org/avr-libc/usermanual/malloc.html y http://www.atmel.com/webdoc/AVRLibcReferenceManual/malloc.html

Prctica: Uso de Memoria en Arduino.

Prctica: Calcula memoria RAM de tu Arduino UNO sin ejecutar ningn programa con la funcin
free() y comparalo con el dato que da al compilar, tambin averigua cunto ocupa la memoria Flash.
Luego calcula la memoria RAM y la Flash utilizada con un programa que cada loop saque por
puerto serie cada 5 segundos el siguiente texto:
Desde octubre de 2012, Arduino se usa tambin con microcontroladoras CortexM3 de ARM de 32
bits,5 que coexistirn con las ms limitadas, pero tambin econmicas AVR de 8 bits. ARM y AVR
no son plataformas compatibles a nivel binario, pero se pueden programar con el mismo IDE de
Arduino y hacerse programas que compilen sin cambios en las dos plataformas. Eso s, las
microcontroladoras CortexM3 usan 3,3V, a diferencia de la mayora de las placas con AVR que
generalmente usan 5V. Sin embargo ya anteriormente se lanzaron placas Arduino con Atmel AVR a
3,3V como la Arduino Fio y existen compatibles de Arduino Nano y Pro como Meduino en que se
puede conmutar el voltaje.
Luego haz que aumente la RAM con el modificador F y compruebalo.
Solucin: https://github.com/jecrespo/Aprendiendo-Arduino/blob/master/Ejercicio05Memoria/Ejercicio05-Memoria.ino

USB to Serial
Arduino se conecta a nuestro ordenador a travs del puerto USB, pero el puerto USB se debe
conectar al microcontrolador a travs del puerto serie, por ello debemos entender como estn
relacionados el puerto USB y el puerto serie.
En un Arduino usamos el puerto USB para dos funciones: cargar nuestro programa ya compilado en
la memoria flash y conectarnos al puerto Serie (UART) predefinido en cada Arduino para
comunicarnos durante la ejecucin del programa. Ambas cosas se puede hacer sin la necesidad del
puerto USB, pero dada la facilidad de uso y que todos los ordenadores disponen de un puerto USB,
nos facilita mucho hacer estas dos operaciones.
El puerto serie conectado al USB lo usamos como puerto de consola o puerto de debug.
UART: http://es.wikipedia.org/wiki/Universal_Asynchronous_Receiver-Transmitter
Las funciones principales de chip UART son de manejar las interrupciones de los dispositivos
conectados al puerto serie y de convertir los datos en formato paralelo, transmitidos al bus de
sistema, a datos en formato serie, para que puedan ser transmitidos a travs de los puertos y
viceversa.

El UART normalmente no genera directamente o recibe las seales externas entre los diferentes
mdulos del equipo. Usualmente se usan dispositivos de interfaz separados para convertir las
seales de nivel lgico del UART hacia y desde los niveles de sealizacin externos.
RS232 http://en.wikipedia.org/wiki/RS-232
Tecnologa TTL: http://es.wikipedia.org/wiki/Tecnolog%C3%ADa_TTL
Cable FTDI: es la forma ms fcil de conectar el microcontrolador a un ordenador por USB.
Consiste en un chip de conversin USB a Serie. Como ocurre con Arduino cuando lo conectamos,
necesitamos los drivers de windows, cuando conectamos un cable FTDI tambin necesita sus
drivers. Los driver FTDI vienen integrados en el IDE de Arduino.

Drivers:https://web.archive.org/web/20141005060035/http://www.ftdichip.com/Drivers/VCP.htm
Productos de FTDI:
http://www.ftdichip.com/FTProducts.htm
http://www.ftdichip.com/Products/Cables/USBTTLSerial.htm
Explicacin de la diferencia entre comunicacin RS232 y TTL: RS-232 vs. TTL Serial
Communication y http://www.atmel.com/Images/doc4322.pdf
Como usar RS232 con Arduino: necesito un driver receptor para poder usarlo:
http://arduino.cc/en/pmwiki.php?n=Tutorial/ArduinoSoftwareRS232
Y si vamos a lo fcil: https://www.sparkfun.com/products/13029

Comunicacin Serie
Para manejar el puerto serie, debemos leer a fondo la referencia de Arduino:
http://arduino.cc/en/Reference/Serial

Funciones importantes que debemos conocer: begin(), read(), write(), print(), available() y flush()
En el playground de Arduino tenemos ms explicaciones y ejemplos de como funcional el puerto
serie en Arduino: http://playground.arduino.cc/ArduinoNotebookTraduccion/Serial
Buffer Serial: los puertos serie de los microcontroladores tienen un buffer que se va llenando hasta
que nosotros lo vamos leyendo con la funcin read() que lo vamos vaciando, es una pila LIFO. El
tamao del buffer serie en el Arduino Uno es de 64 bytes, cuando se llena ese buffer el resto de
elementos recibidos se pierden.
El microcontrolador de Arduino no tiene buffer de salida del puerto serie, solo de entrada.
Toda la informacin del puerto sere del microcontrolador del arduino UNO la tenemos en la
pgina 176 de http://www.atmel.com/Images/doc8161.pdf
Por ejemplo la funcin available() de Serial, podemos ver como se hace en C o en ensamblador en
la pgina 183.
La funcin write() podemos verla en la pgina 184 y la funcin read() en la pgina 186.
Una descripcin de los registros usados por el microcontrolador en la comunicacin serie se
pueden ver en la pgina 195.
OJO las funciones de serial que usamos valen para cualquier arduino soportado por el IDE que
estamos usando, pero luego cada microcontrolador internamente usa unos registros y operaciones
diferentes, por lo que si usamos las funciones a bajo nivel vistas, slo funcionarn con Arduino
UNO.
Entrar en temas ms complejos como los vistos tiene dos objetivos, saber que tenemos toda la
documentacin disponible para entrar a fondo en el conocimiento del microcontrolador y sobre todo
que todas esas funciones que usamos de una forma sencilla, saber que detrs de ellas hay mucha
ms complejidad de la que pueda parecer.
Arduino nos facilita un lenguaje de programacin y unas funciones sencillas para manejar unas
serie de microcontroladores diferentes.
Y si necesitas ms puertos serie? http://arduino.cc/en/Reference/SoftwareSerial

rctica: Uso de puerto serie en Arduino

Prctica: Generar una tabla de caracteres y sus valores ASCII en decimal, hexadecimal, octal y
binario

Caracteres ASCII: http://es.wikipedia.org/wiki/ASCII y http://www.asciitable.com/

Ejercicio: http://arduino.cc/en/Tutorial/ASCIITable
Fijaros en el carcter y recordad cual es su valor en binario.
Solucin: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio06-ASCII

Prctica: Dimmer puerto serie

Prctica: Hacer un dimmer con un led, regulando la intensidad de brillo de un LED mediante el
envo de una cadena entre 0 y 100, de forma que 0 es apagado y 100 es el 100% encendido. Debe
usarse un pin digital que tenga salida PWM para poder tener una salida analgica.
Funciones a utilizar:

analogwrite() http://arduino.cc/en/Reference/AnalogWrite
Serial.read() http://arduino.cc/en/Serial/Read
Serial.available() http://arduino.cc/en/Serial/Available
map() http://arduino.cc/en/Reference/Map

Solucin: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio07-dimmer
Solucin mejorada: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio07bdimmer_mejorado

Entradas y salidas Digitales

Una seal digital es un tipo de seal generada por algn tipo de fenmeno electromagntico en que
cada signo que codifica el contenido de la misma puede ser analizado en trmino de algunas
magnitudes que representan valores discretos, en lugar de valores dentro de un cierto rango. Por
ejemplo, el interruptor de la luz slo puede tomar dos valores o estados: abierto o cerrado, o la
misma lmpara: encendida o apagada (vase circuito de conmutacin).
http://es.wikipedia.org/wiki/Se%C3%B1al_digital
Los sistemas digitales, como por ejemplo un microcontrolador, usan la lgica de dos estados
representados por dos niveles de tensin elctrica, uno alto, H y otro bajo, L (de High y Low,
respectivamente, en ingls). Por abstraccin, dichos estados se sustituyen por ceros y unos, lo que
facilita la aplicacin de la lgica y la aritmtica binaria. Si el nivel alto se representa por 1 y el bajo
por 0, se habla de lgica positiva y en caso contrario de lgica negativa.
Cabe mencionar que, adems de los niveles, en una seal digital estn las transiciones de alto a
bajo y de bajo a alto, denominadas flanco de bajada y de subida, respectivamente.
En una seal digital, se denomina flanco a la transicin del nivel bajo al alto (flanco de subida) o del
nivel alto al bajo (flanco de bajada).

En la siguiente imagen el flanco de bajada es detectado por el retardo que realiza la compuerta not
as cuando a la entrada haya uno las dos entradas de la or negada sern uno y cero, por tanto la
salida ser de cero, pero en el momento en que la entrada sea de cero la conexin directa que hay a
la or negada nos dar un cero inmediato en una de sus entradas, mientras que por el retardo que
presenta la not tambin tendremos un cero y esto nos generar un uno a la salida por unos
momentos, o sea la deteccin del flanco de bajada.

Las seales digitales:

Discreta: puede tomar un conjunto de valores
Binaria: Encendido (1) Apagado (0)
Arduino trabaja con tecnologa TTL (transistor-transistor logic):
http://es.wikipedia.org/wiki/Tecnolog%C3%ADa_TTL
Caractersticas
Su tensin de alimentacin caracterstica se halla comprendida entre los 4,75V y los 5,25V.
Normalmente TTL trabaja con 5V.
Los niveles lgicos vienen definidos por el rango de tensin comprendida entre 0,0V y 0,8V
para el estado L (bajo) y los 2,4V y Vcc para el estado H (alto).
La velocidad de transmisin entre los estados lgicos es su mejor base, si bien esta
caracterstica le hace aumentar su consumo siendo su mayor enemigo. Motivo por el cual
han aparecido diferentes versiones de TTL como FAST, LS, S, etc y ltimamente los CMOS:
HC, HCT y HCTLS. En algunos casos puede alcanzar poco ms de los 250 MHz.
Las seales de salida TTL se degradan rpidamente si no se transmiten a travs de circuitos
adicionales de transmisin (no pueden viajar ms de 2 m por cable sin graves prdidas).
En arduino los pines digitales se describen y tienen la propiedades siguientes:
http://arduino.cc/en/Tutorial/DigitalPins
En arduino para tratar las entradas y salidas digitales usamos las siguientes funciones:
pinMode() http://arduino.cc/en/Reference/PinMode
digitalWrite() http://arduino.cc/en/Reference/DigitalWrite
digitalRead() http://arduino.cc/en/Reference/DigitalRead
En la imagen siguiente se muestra el estado por defecto de una I/O digital en un microcontrolador
de Arduino. Se ha simplificado con interruptores la compleja electrnica que hay dentro.

Por defecto los digital I/O pins estn configurados como inputs en un estado de alta impedancia
(equivalente a una resistencia de 100 Mohms en frente del pin), es decir, SW3 a ON y no hace falta
llamar a la funcin pinMode() aunque es recomendable para aclarar el cdigo.
PinMode(x, INPUT) > SW3 = ON (resto a OFF). Los valores leidos sern aleatorios si el
pin de Arduino est al aire.
PinMode(x,INPUT_PULLUP) > SW3 = ON & SW4 = ON (resto a OFF). Los valores
leidos sin nada conectado al pin es HIGH. La Resistencia R1 tiene un valor dependiendo del
microcontrolador, pero tiene un valor entre 20kOhm y 150kOhm.
PinMode(x, OUTPUT) & digitalWrite(x,HIGH) > SW2 = ON & SW1 = +5V (resto a
OFF). Estado de baja impedancia, no hay resistencia interna y es necesario poner una
adecuada para no superar los 40mA mximos admitidos
PinMode(x, OUTPUT) & digitalWrite(x,LOW) > SW2 = ON & SW1 = GND (resto a
OFF). Estado de baja impedancia, no hay resistencia interna y es necesario poner una
adecuada para no superar los 40mA mximos admitidos

En el caso que el pin est configurado como OUTPUT, hay diferencia entre sink (recogida de
corriente) y source (fuente de corriente) de un pin digital configurado como salida.
En el primer caso para encender el LED debo poner digitalWrite() a HIGH y en el segundo a LOW

En el caso que el pin de entrada configurado como INPUT. Cuando el botn no est pulsado, en
el primer caso leo digitalRead() un valor HIGH y en el segundo LOW y cuando pulso el botn, en
el primer caso leo digitalRead() un valor LOW y en el segundo HIGH. Como vis, dependiendo de
la configuracin de lo conectado cambia lo leido.

En el caso que el pin de entrada configurado como INPUT_PULLUP. Si el botn no est pulsado
leo HIGH (no se producen lecturas aleatorias con el pin al aire) y cuando pulso el botn leo LOW.

Prctica: Contador de pulsos

Ejercicio: Usar la resistencia de pullup para leer estados de un botn.

 http://arduino.cc/en/Tutorial/InputPullupSerial
Solucin: Ejercicio08-pullup
Ejercicio: Contar el nmero de veces que se pulsa un botn. Deteccin de flancos ascendentes y
descendentes.
http://arduino.cc/en/Tutorial/ButtonStateChange
Solucin: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio09-cuentapulsos
Ejercicio Avanzado: Ejercicio2 del libro.
Ejercicios para los ms avanzados:
http://arduino.cc/en/Tutorial/Tone
http://arduino.cc/en/Tutorial/Tone3
Leer la funcin tone()
Solucin: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio10-tone

Entradas y salidas analgicas, PWM

Una seal elctrica analgica es aquella en la que los valores de la tensin o voltaje varan
constantemente y pueden tomar cualquier valor. En el caso de la corriente alterna, la seal analgica
incrementa su valor con signo elctrico positivo (+) durante medio ciclo y disminuye a continuacin
con signo elctrico negativo () en el medio ciclo siguiente.
Un sistema de control (como un microcontrolador) no tiene capacidad alguna para trabajar con
seales analgicas, de modo que necesita convertirlas en seales digitales para poder trabajar con
ellas.
La seal digital obtenida de una analgica tiene dos propiedades fundamentales:
Valores. Que valor en voltios define 0 y 1. En nuestro caso es tecnologa TTL (0 5V)
Resolucin analgica: n de bits que usamos para representar con una notacin digital una
seal analgica:
http://arduino.cc/en/Reference/AnalogReadResolution
http://arduino.cc/en/Reference/AnalogWriteResolution
En el caso de un arduino Uno, el valor de 0 voltios analgico es expresado en digital como
B0000000000 (0) y el valor de 5V analgico es expresado en digital como B1111111111 (1023).
Por lo tanto todo valor analgico intermedio es expresado con un valor entre 0 y 1023, es decir,
sumo 1 en binario cada 4,883 mV.
Arduino Uno tiene una resolucin de 10 bits, es decir, unos valores entre 0 y 1023.
Arduino Due tiene una resolucin de 12 bits, es decir, unos valores entre 0 y 4095.
Diferencia entre seales analgicas y digitales:

PWM
Como hemos dicho Arduino Uno tiene entradas analgicas que gracias a los conversores analgico
digital puede entender ese valor el microcontrolador, pero no tiene salidas analgicas puras y para
solucionar esto, usa la tcnica de PWM.
Las Salidas PWM (Pulse Width Modulation) permiten generar salidas analgicas desde pines
digitales. Arduino Uno no posee salidas analgicas puras.
El arduino due, posee dos salidas analgicas puras mediante dos conversores digital a analgico.
Estos pines pueden usarse para crear salidas de audio usando la librera correspondiente.
La modulacin por ancho de pulsos (tambin conocida como PWM, siglas en ingls de pulse-width
modulation) de una seal o fuente de energa es una tcnica en la que se modifica el ciclo de trabajo
de una seal peridica (una senoidal o una cuadrada, por ejemplo), ya sea para transmitir
informacin a travs de un canal de comunicaciones o para controlar la cantidad de energa que se
enva a una carga.
El ciclo de trabajo de una seal peridica es el ancho relativo de su parte positiva en relacin con el
perodo. duty cycle = (tiempo que la salida est a uno o HIGH)/ (periodo de la funcin)

En este ejemplo se ve como simular con PWM una onda sinusoidal analgica.

En Arduino la frecuencia de PWM es de 500Hz.

En la actualidad existen muchos circuitos integrados en los que se implementa la modulacin
PWM, por ejemplo para lograr circuitos funcionales que puedan controlar fuentes conmutadas,
controles de motores, controles de elementos termoelctricos, choppers para sensores en ambientes
ruidosos y algunas otras aplicaciones.
Definicin de PWM en la web de Arduino: http://arduino.cc/en/Tutorial/PWM
No confundir PWM con la funcion tone() que es utilizada para generar una onda cuadrada de ciclo
de trabajo 50%, con el fin de emitir sonidos audibles, modificando la frecuencia.
Ms informacin de tone() en: https://code.google.com/p/roguecode/wiki/ToneLibraryDocumentation

Conversor analgico digital (ADC)

Un microcontrolador solo entiende seales digitales (1s y 0s), por lo tanto para poder leer seales
analgicas necesitamos los convertidores Analgico a Digital (ADC).
Como funciona un conversor analgico a digital:
http://es.wikipedia.org/wiki/Conversi%C3%B3n_anal%C3%B3gica-digital
http://en.wikipedia.org/wiki/Analog-to-digital_converter

Conversor digital analgico (DAC)

Definicin: http://en.wikipedia.org/wiki/Digital-to-analog_converter
Al contrario que las seales analgicas, las seales digitales se pueden almacenar y transmitir sin
degradacin. Los DAC se usan para los altavoces, amplificadores para producir sonido. Ejemplo de
la transmisin de la voz por la lneas telefnicas.
En arduino los pines analgicos se definen y tienen las propiedades siguientes:
http://arduino.cc/en/Tutorial/AnalogInputPins
En arduino para tratar las entradas y salidas digitales usamos las siguientes funciones:
analogReference() http://arduino.cc/en/Reference/AnalogReference
analogRead() http://arduino.cc/en/Reference/AnalogRead
analogWrite() http://arduino.cc/en/Reference/AnalogWrite
Otras funciones interesantes con entradas/salidas analicas:
map(value, fromLow, fromHigh, toLow, toHigh) http://arduino.cc/en/Reference/Map
constrain(x, a, b) http://arduino.cc/en/Reference/Constrain
Las entradas digitales y analgicas (especialmente estas) son un recurso escaso en los
microntroladores, para poder multiplicar esas entradas/salidas, podemos hacer uso de los
multiplexores.
Los multiplexores son circuitos combinacionales con varias entradas y una nica salida de datos,
estn dotados de entradas de control capaces de seleccionar una, y slo una, de las entradas de datos
para permitir su transmisin desde la entrada seleccionada hacia dicha salida.

Esta es una tcnica muy utilizada para multiplicar las seales, con arduino podemos usar varios
shield para multiplexar las seales.
Muxshield: https://www.sparkfun.com/products/11723

Para ver las funciones de la librera de este shield para Arduino se pueden ver en la pgina 5:
http://dlnmh9ip6v2uc.cloudfront.net/datasheets/Dev/Arduino/Shields/Mux_Shield_II_User_Guide.
pdf
Permite hasta 48 pines de Arduino. Usa el TI 74HC4067 para la funcionalidad de multiplexacin de
16 canales y TI 74HC595 para los registros de cambio (registro de desplazamiento de tres estados).
Tiene mltiples modos: entrada y salida digital y entrada analgica
Librera de arduino: Arduino Library

Prctica: Smoothing
Ejercicio: Leer un voltaje analgico y sacarlo por consola.
http://arduino.cc/en/Tutorial/ReadAnalogVoltage
http://arduino.cc/en/Tutorial/AnalogInOutSerial
Solucin: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio11-Analog
Ejercicio:
Smoothing, leer una entrada analgica llegada de un poteciometro y sacar por el puerto serie
la media de los ltimas 10 lecturas http://arduino.cc/en/Tutorial/Smoothing. Para los ms
avanzados mezclar con la prctica de dimmer para que saque el valor ms alisado a un LED
y gradualmente.
Solucin: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio12-Smoothing
Ejercicios Avanzados: Ejercicios 3 y 4 del libro.

Sensores
Un sensor es un dispositivo capaz de detectar magnitudes fsicas o qumicas, llamadas variables de
instrumentacin, y transformarlas en variables elctricas. Las variables de instrumentacin pueden
ser por ejemplo: temperatura, intensidad lumnica, distancia, aceleracin, inclinacin,
desplazamiento, presin, fuerza, torsin, humedad, movimiento, pH, etc. Una magnitud elctrica
puede ser una resistencia elctrica (como en una RTD), una capacidad elctrica (como en un sensor
de humedad o un sensor capacitivo), una tensin elctrica (como en un termopar), una corriente
elctrica (como en un fototransistor), etc.
Los sensores se pueden clasificar en funcin de los datos de salida en:
Digitales
Analgicos
Y dentro de los sensores digitales, estos nos pueden dar una seal digital simple con dos estados
como una salida de contacto libre de tensin o una salida en bus.
Un ejemplo de sensor analgico sera el ACS714:

Datasheet: http://www.allegromicro.com/~/Media/Files/Datasheets/ACS714-Datasheet.ashx
Como medir corriente: http://playground.arduino.cc/Main/CurrentSensing
Caractersticas de un sensor:
http://es.wikipedia.org/wiki/Sensor#Caracter.C3.ADsticas_de_un_sensor
Tipos de sensores: http://es.wikipedia.org/wiki/Sensor#Tipos_de_sensores
A la hora de elegir un sensor, debemos leer detenidamente las caractersticas y elegir uno que sea
compatible con nuestro sistema (tensin y voltaje) y que sea sencillo de usar o nos facilite una
librera sencilla y potente.
Catlogo de sensores:

http://tienda.bricogeek.com/23-sensores
http://www.trossenrobotics.com/c/arduino-sensors.aspx
http://www.seeedstudio.com/depot/Sensors-c-25/?ref=side
https://www.sparkfun.com/categories/23

Sensores con comunicacin por bus. Un bus (o canal) es un sistema digital que transfiere datos
entre los componentes de una dispositivo electrnico o entre varios. Est formado por cables o
pistas en un circuito impreso, dispositivos como resistencias y condensadores adems de circuitos
integrados.
La tendencia en los ltimos aos hacia el uso de buses seriales como el USB, Firewire para
comunicaciones con perifricos, reemplazando los buses paralelos, incluyendo el caso del
microprocesador con el chipset en la placa base, a pesar de que el bus serial posee una lgica
compleja (requiriendo mayor poder de cmputo que el bus paralelo) se produce a cambio de
velocidades y eficacias mayores.

Ms informacin en: http://es.wikipedia.org/wiki/Bus_(inform%C3%A1tica)

Existen muchos tipos de buses de comunicaciones, algunos de ellos los implementa arduino
mediante controladores HW integrados en la MCU (I2C) o mediante una librera (one wire) y en
otros casos es necesario un hardware adicional para adaptar la seal con un transceiver y manejar el
protocolo con un controlador, por ejemplo can bus o modbus.
Los sensores DHT11 o DHT22 que vimos anteriormente, son unos pequeos dispositivos que nos
permiten medir la temperatura y la humedad. A diferencia de otros sensores, stos los tendremos
que conectar a pines digitales, ya que la seal de salida es digital. Llevan un pequeo
microcontrolador interno para hacer el tratamiento de seal. Estos sensores han sido calibrados en
laboratorios, presentan una gran fiabilidad.
Ambos sensores funcionan con ciclos de operacin de duracin determinada. En determinados
casos de aplicaciones los tiempos de lectura de los sensores puede ser determinante a la hora de
elegirlo.
Parmetro
DHT11
Alimentacin
3Vdc Vcc 5Vdc
Seal de Salida
Digital
Rango de medida Temperatura De 0 a 50 C
Precisin Temperatura
2 C
Resolucin Temperatura
0.1C
Rango de medida Humedad
De 20% a 90% RH
Precisin Humedad
4% RH
Resolucin Humedad
1%RH
Tiempo de sensado
1s
Tamao
12 x 15.5 x 5.5mm
Veamos en profundidad la sonda DHT22.

DHT22
3.3Vdc Vcc 6Vdc
Digital
De -40C a 80 C
<0.5 C
0.1C
De 0 a 100% RH
2% RH
0.1%RH
2s
14 x 18 x 5.5mm

http://www.seeedstudio.com/wiki/Grove_-_Temperature_and_Humidity_Sensor_Pro
Datasheet:
https://www.sparkfun.com/datasheets/Sensors/Temperature/DHT22.pdf
http://www.adafruit.com/datasheets/Digital%20humidity%20and%20temperature%20sensor
%20AM2302.pdf
Veamos como para un mismo sensor tenemos diferentes libreras y con funciones y uso diferente en
cada una de ellas. Cada uno de los distribuidores de estas sondas ha creado su propia librera.

 https://github.com/Seeed-Studio/Grove_Temper_Humidity_TH02
https://github.com/sparkfun/RHT03
https://github.com/adafruit/DHT-sensor-library
Otra sonda de temperatura pero que usa un bus de comunicacin, lo que nos permite leer muchas
sondas con una sola i/o digital es la DS18B20.
Sonda: http://www.seeedstudio.com/depot/One-Wire-Temperature-Sensor-p-1235.html
Sensor: http://datasheets.maximintegrated.com/en/ds/DS18B20.pdf
Librera: http://playground.arduino.cc/Learning/OneWire
ltima version de la librera: http://www.pjrc.com/teensy/td_libs_OneWire.html
one-wire: http://en.wikipedia.org/wiki/1-Wire
one-wire: http://www.maximintegrated.com/en/app-notes/index.mvp/id/148

Prctica: Sensor de temperatura

Prctica: Ejercicio15-Temperatura. Ejercicio 3 del libro. Leer sonda de temperatura y en funcin
de unas condiciones encender 3 LEDS, el primero al alcanzar 22 grados, el segundo a los 24 y el
tercero a los 26. Que muestre por pantalla la temperatura leda por el puerto serie en Celsius si lee
una C por el puerto serie o en Farenheit si les una F, en cualquier otro caso que muestre: En que
formato quieres que muestre la temperatura?
Solucin: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio15-Temperatura

Actuadores y perifricos de salida

Un actuador es un dispositivo capaz de transformar energa hidrulica, neumtica o elctrica en la
activacin de un proceso con la finalidad de generar un efecto sobre elemento externo. Este recibe
la orden de un regulador, controlador o en nuestro caso un Arduino y en funcin a ella genera la
orden para activar un elemento final de control como, por ejemplo, una vlvula.

Existen varios tipos de actuadores como son:

Electrnicos
Hidrulicos
Neumticos
Elctricos
Motores
Bombas

Para cada actuador, necesitamos un driver o manejador para poder mandar rdenes desde
Arduino.
Recordad que los pines de Arduino solo pueden manejar un mximo de 40mA y
recomendable usar 20mA de forma continua.
Recordar que Arduino solo puede manejar un total de 200 mA de salida. Es decir que la
corriente mxima que admite Vcc y GND son 200 mA.
Este enlace explica mucho mejor los las limitaciones de corriente en los pines de Arduino:
http://playground.arduino.cc/Main/ArduinoPinCurrentLimitations
Otro tipo de actuadores son los rels. Para manejar un rel necesitamos un driver, puesto que con
los 40mA posiblemente no sea suficiente para activar la bobina del rel.
Un relay driver es un circuito electrnico que usa un transistor para activar la bobina del rel de
forma que con una pequea corriente activamos el circuito que alimenta al rel desde una fuente
externa.

Los Relay Shield ya tienen integrados los rels y los drives, lo que nos facilita el trabajo, incluso
algunas shields incluyen su librera: http://www.seeedstudio.com/wiki/Relay_Shield

O tambin una placa con dos rels y su driver con posibilidad de alimentarlos externamente:
http://www.geeetech.com/wiki/index.php/2-Channel_Relay_module

Tambin existen integrados como el ULN2803A que nos permiten controlar reles, se trata de un
array o conjunto de 8 pares darlington que soportan 500mA y 50V. Sirve para conectar la carga a
masa. Caractersticas: http://www.ti.com/lit/ds/symlink/uln2803a.pdf

Si tuviramos que controlar elementos con ms potencia como Motores o sistemas que tienen
muchos arranques y paradas, es recomendable usar contactores a los que atacaremos desde los rels.

Motores
Motor DC. Un motor de corriente continua convierte la energa elctrica en mecnica. Se
compone de dos partes: el estator y el rotor. El estator es la parte mecnica del motor donde
estn los polos del imn. El rotor es la parte mvil del motor con devanado y un ncleo, al
que llega la corriente a travs de las escobillas. Si queremos cambiar el sentido de giro del
rotor, tenemos que cambiar el sentido de la corriente que le proporcionamos al rotor, basta
con invertir la polaridad de la pila o batera.
Para controlar un motor DC desde Arduino, tendremos que usar un driver para motores para
proporcionarle ms corriente al motor ya que las salidas del Arduino slo dan 40mA. De esta
manera, con el driver podemos alimentar el motor con una fuente de alimentacin externa.
El L293D es un integrado para controlar motores DC que usa el sistema puente en H. Es un sistema
para controlar el sentido de giro de un motor DC usando cuatro transistores. En la imagen vemos
que los transistores se comportan como interruptores y dependiendo que transistores conducen y
cules no cambia la polarizacin del motor, y con esto el sentido de giro.

El L293D tiene dos puentes H y proporciona 600mA al motor y soporta un voltaje entre 4,5V y
36V tal y cmo pone en el datasheet: http://www.ti.com/lit/ds/symlink/l293d.pdf

Nosotros usaremos la parte de la izquierda (los diodos externos hay que ponerlos para evitar las
corrientes inducidas del motor). Cmo se aprecia en la imagen, los pins 3 y 6 son las salidas y se
conectan a los bornes del motor. Y los pins 2 y 7 son las entradas donde conectaremos las salidas
del Arduino. Dependiendo que valor ponemos entre los pins 2 y 7 el motor girar en un sentido o en
otro.
Es muy IMPORTANTE que si optais o necesitais utilizar el driver L293, utiliceis diodos para evitar
daar el integrado con las corrientes parsitas generadas por los propios solenoides de las cargas.
No obstante el modelo L293D no los necesita, ya que, los lleva incorporados el propio integrado,
con lo que se hace ms sencillo y econmico su uso. Tambin es cierto que L293 al no llevarlos
integrados nos permite escoger los que mejor se adapten a nuestras cargas o necesidades.
Para controlar la velocidad del motor vamos a usar PWM. Sabemos que hay que atacar los pins 2 y
7 del L293D desde dos salidas del Arduino. En estas dos salidas habr un PWM a cada una. Pero
tenemos que invertir un PWM. Qu quiere decir invertir? Pues que cuando en un PWM tengamos
un pulso a un valor alto, en el otro PWM el mismo pulso sea valor bajo. En la imagen lo
entenderemos de una manera ms grfica.

Esquema de Montaje.

Fuente, ms informacin y cdigo en: http://diymakers.es/control-velocidad-y-sentido-de-motordc/

Servomotor (o tambin llamado servo) es similar a un motor de corriente continua pero con
la capacidad de posicionarse en una posicin determinada y permanecer fija en esta.
Normalmente el ngulo es de 0 a 180 grados, y se alimentan a 5 voltios mnimo.

Un servomotor est formado por un motor de corriente continua, una caja reductora, un juego de
engranajes, un potencimetro y un circuito de control. Puede aguantar cierto peso a travs del par o
torque del servo indicado en sus caractersticas. Normalmente se indica con Kg/cm, que quiere decir
los kilos que aguanta a 1 cm de distancia.

Para controlar un servo, se usa el PWM. La mayora trabaja en una frecuencia de 50 Hz (20ms).
Cuando se manda un pulso, la anchura de este determina la posicin angular del servo. La anchura
vara segn el servomotor pero normalmente es entre 0,5ms a 2,5ms.

El Arduino utiliza la librera <Servo.h> para controlar los servos y usa las siguientes funciones:

http://arduino.cc/en/Reference/Servo
http://arduino.cc/en/Reference/ServoAttach
http://arduino.cc/en/Reference/ServoWrite
http://arduino.cc/en/Reference/ServoRead

Fuente, ms informacin y cdigo en: http://diymakers.es/controlar-servomotor-con-mando-ir/

Ms informacin: http://en.wikipedia.org/wiki/Servomotor
Motor paso a paso. Un motor paso a paso (tambin llamado stepper) es un dispositivo
electromagntico que convierte impulsos elctricos en movimientos mecnicos de rotacin.
La principal caracterstica de estos motores es que se mueven un paso por cada impulso que
reciben. Normalmente los pasos pueden ser de 1,8 a 90 por paso, dependiendo del motor.
Son motores con mucha precisin, que permiten quedar fijos en una posicin (como un
servomotor) y tambin son capaces de girar libremente en un sentido u otro (como un motor
DC).
Cuando circula corriente por una o ms bobinas del estator se crea un campo magntico creando
los polos Norte-Sur. Luego el rotor se equilibrar magnticamente orientando sus polos Norte-Sur
hacia los polos Sur-Norte del estator. Cuando el estator vuelva a cambiar la orientacin de sus polos
a travs de un nuevo impulso recibido hacia sus bobinas, el rotor volver a moverse para
equilibrarse magnticamente. Si se mantiene esta situacin, obtendremos un movimiento giratorio
permanente del eje. El ngulo de paso depende de la relacin entre el nombre de polos magnticos
del estator y el nombre de polos magnticos del rotor.

Los motores bipolares son ms complejos de controlar ya que el flujo de corriente tiene que cambiar
de direccin a travs de las bobinas con una secuencia determinada. Para esto debemos conectar
cada una de las dos bobinas en un puente en H (H-Bridge). Utilizaremos el integrado L293 que
contiene dos H-Bridge (datasheet).

Para controlar motores paso a paso con Arduino, utilizaremos la librera <Stepper.h>:
http://arduino.cc/en/Reference/Stepper/
http://www.tigoe.net/pcomp/code/circuits/motors/stepper-motors/
Fuente, ms informacin y cdigo en: http://diymakers.es/mover-motores-paso-paso-con-arduino/
Definicin de la Wikipedia: http://es.wikipedia.org/wiki/Motor_paso_a_paso
Un ejemplo de driver de un motor paso a paso https://www.pololu.com/product/2133
Datasheet del driver: https://www.pololu.com/file/download/drv8825.pdf?file_id=0J590
Este tipo de motor es ms lento, su rotacin es precisa, es de fcil configuracin y control , adems
mientras que los servos requieren un mecanismo de retroalimentacin y circuitos de soporte para
accionamiento de posicionamiento, un motor paso a paso tiene control de posicin a travs de su
naturaleza de rotacin por incrementos fraccionales.
Adecuado para las impresoras 3D y dispositivos similares en los que la posicin es fundamental.
Otros motores, como los de alterna monofsicos que podemos controlar su encendido,
apagado y sentido de giro con un rel o un contactor y los trifsicos que habr que usar un
arrancador para controlar su encendido y apagado y un variador para controlar la velocidad.
Disponemos de shields para controlar mltiples motores, ya sean DC, servos o paso a paso.
A la hora de seleccionar un motor, hay varios factores que deben evaluarse antes de decidir qu tipo
utilizar. Estos factores incluyen velocidad, par, bucle abierto o cerrado, resolucin, precio y
mantenimiento.

La velocidad es uno de los criterios ms importantes a tener en cuenta al elegir entre servo y motor
paso a paso. Hay una relacin inversa entre velocidad y par en los motores por pasos. Cuando la
velocidad se incrementa, el par decrece. Los motores servo tienen un par constante hasta la
velocidad nominal. Como criterio general, por encima de 1000 rpm, debe seleccionarse servo. Si la
velocidad est por debajo de 500 rpm, los motores por pasos son una buena eleccin porque
producen un par ms alto que el servomotor de tamao equivalente. Los servomotores tienen la
capacidad de producir un par pico en cortos periodos de tiempo que es hasta 8 veces su par nominal
continuo. Esto es particularmente til cuando la resistencia del movimiento no es constante. Los
motores por pasos no tienen esta capacidad.
En algunos casos que requieren la alta velocidad, alta aceleracin o aplicaciones crticas, el bucle
cerrado es importante. Esto ocurre por ejemplo cuando se trabaja con accesorios caros en los que
los fallos no son aceptables.
Ejemplo de actuadores que se pueden comprar
Actuadores
http://www.seeedstudio.com/depot/Actuators-c-39/?ref=side
http://www.trossenrobotics.com/c/arduino-motor-controllers.aspx
http://www.trossenrobotics.com/linear-actuators.aspx
Rels http://www.trossenrobotics.com/c/data-i-o-Relay-switching-boards.aspx
Por ltimo tenemos otros dispositivos que usan las salidas digitales, que podemos denominarlos
perifricos:

Pantalla LCD
displays numricos
pantallas tctiles
impresoras
zumbadores
pulsadores/interruptores
indicadores luminosos
etc..

Displays:
http://www.seeedstudio.com/depot/Displays-c-34/?ref=side
https://www.sparkfun.com/categories/76
Como funciona un display LCD: http://ww1.microchip.com/downloads/cn/AppNotes/cn011075.pdf
Aprender a usar un display LCD:
http://diymakers.es/aprender-usar-un-display-lcd/
Y mucho ms https://www.sparkfun.com/categories/20

Prctica: Motores
Servo
Ejercicio: Controlar la posicin de un servo con un potencimetro.
Solucin: http://arduino.cc/en/Tutorial/Knob
Ejercicio: Programar un barrido continuo del 0 a 180 en un servo. Activar y descativar el barrido
con una pulsacin de un botn. p.e. activacin de un limpiaparabrisas.
Solucin: http://arduino.cc/en/Tutorial/Sweep

Prctica: Display LCD

Ejercicio: Ejemplo 11 del libro de prcticas, la bola de cristal. Hacer que cada vez que mueva
Arduino, detecte el movimiento con el tilt sensor y devuelva por la pantalla LCD una respuesta
aleatoria.
Mejora: Hacer que tambin funcione la bola de cristal al usar el puerto serie. Hacer una pregunta
por el puerto serie, que se muestre la pregunta en la pantalla LCD y luego a los 5 segundos responda
por la pantalla LCD y por el puerto serie.
Solucin: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio23-LCD
Ejercicio: Controlar en qu direccin se mueve el display.
Solucin: http://arduino.cc/en/Tutorial/LiquidCrystalTextDirection
Esquemas:

EXTRA:
Ejemplo: Ejemplo de las zapatillas de John Luck:
http://www.ciclismoafondo.es/material/Noticias-material/articulo/Luck-zapatillas-ciclismomedidor-de-potencia
http://esmtb.com/27772/john-luck-se-une-al-centro-tecnologico-del-calzado-de-la-rioja/

 http://cyclingtips.com.au/2014/09/the-best-of-eurobike-2014-helmets-and-shoes/
El arduino que va montado y se ve en la foto, que vale
9.95$:https://www.sparkfun.com/products/11113
El modulo bluetooth, que vale 34.95$: https://www.sparkfun.com/products/12580
El sensor: https://www.sparkfun.com/products/10293, que vale 1.5$, posiblemente no sea este
puesto que sera necesario un sensor con mucha ms sensibilidad.
El resto de elementos posiblemente sean para adaptar la seal del sensor piezo elctrico y cargador
de batera

Proyectos final de curso

Como final de curso, se propone realizar varios proyectos individualmente o en grupo que se
presentarn el viernes 17 de abril.
El horario del taller del da 17 de abril, ser de 17.30 a 21.30. Durante las 4 horas de taller se
montarn los proyectos y se presentarn. Tambin se resolvern todas las dudas que hayan surgido y
se explicar el cdigo.
Al finalizar el taller se entregar el material y se comprobar que est todo en perfecto estado y se
firmar el documento de devolucin de material.
Desde la finalizacin del curso hasta la realizacin del taller, se podr consultar cualquier duda que
surja sobre la realizacin de los proyectos. El mtodo preferido ser a travs de la comunidad de
google+ https://plus.google.com/communities/104107521992758374331, pero tambin por twitter o
por correo electrnico.
Medios de contacto: https://aprendiendoarduino.wordpress.com/acerca-de/
Proyectos
Proyecto 1 Estacin meteorolgica. Hacer una estacin meteorolgica con una sonda de
temperatura y la pantalla LCD. Hacer que lea continuamente la temperatura y la muestre por
pantalla. Poner un botn que al pulsarlo la primera vez muestre por pantalla la mxima
temperatura leda, al volver a pulsarlo muestre la temperatura mnima leda y al volver a
pulsarlo muestre la temperatura actual. Para resetear los valores mximo y mnimo, pulsar
durante 5 segundos el botn y muestre por pantalla valores reseteados.
Avanzado: Con el shield de ethernet conectarse a internet y mediante la API de
http://openweathermap.org/ y obtener los datos de humedad y presion y mostrarlos por
pantalla. Actualizar estos datos cada hora. Tambin se pueden obtener los datos de la API de
AEMET.
Informacin adicional:
API: http://openweathermap.org/API
WebClient: http://arduino.cc/en/Tutorial/WebClient

Como usar la librera Ethernet: https://aprendiendoarduino.wordpress.com/2014/11/18/tema-6comunicaciones-con-arduino-2/

JSON Parser: https://github.com/bblanchon/ArduinoJson
Datos para Logroo de http://openweathermap.org/
http://api.openweathermap.org/data/2.5/weather?q=Logrono&mode=xml
http://api.openweathermap.org/data/2.5/weather?id=3118150
Datos para Logroo AEMET: http://www.aemet.es/xml/municipios/localidad_26089.xml
Proyecto 2 Arranque y parada de motor DC controlado. Basndose en los ejercicios 9
y 10 del libro del Arduino Starter Kit, aadir una rampa de arranque y otra de parada cuando
se detecte el encendido y apagado. Tambin aadir una rampa de parada y arranque cuando
se detecte un cambio de sentido. Aadir un botn de parada de emergencia, que al pulsarlo,
se pare el motor inmediatamente.

Informacin adicional: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio21MotorDC

Proyecto 3 Juego de Sogatira. Hacer un juego con 7 leds y dos botones. El led central se
ilumina y en funcin de quien ms veces pulsa el botn el led encendido se va desplazando
hacia l, hasta que gana cuando ha llegado al ltimo led. En el inicio el led central parpadea
y comienza el juego cuando se queda fijo, cada vez que se gana una posicin el led parpadea
y cuando gana el led final se queda parpadeando en un bucle infinito hasta que reseteo el
Arduino para volver a jugar.
Informacin adicional:
Ejemplo: http://123d.circuits.io/circuits/463198-juego-sogatira
Ejemplo: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio13-sogatira

 Proyecto 4 Simon. Hacer el juego de Simon con Arduino

Informacin adicional:
Juego: http://es.wikipedia.org/wiki/Simon_%28juego%29
Ejemplo: http://www.arduteka.com/2012/07/juego-simon-con-s4a-y-arduino/
Ejemplo: http://www.instructables.com/id/Arduino-Simon-Says/
Ejemplo: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio24-Simon

Proyecto 5 Grfica de datos de temperatura en plot.ly. Recoger datos de temperatura

cada 5 segundos y mandarlos a la web de plot.ly para que nos los imprima en tiempo real.
Ser necesario conectarse a Internet y usar el Ethernet Shield.
Informacin adicional:
API Arduino para Plot.ly:https://github.com/plotly/arduino-api
Informacin: http://makezine.com/2014/01/21/streaming-data-with-plotly/
Ejemplo: https://plot.ly/arduino/dht22-temperature-tutorial/
Otro ejemplo: https://plot.ly/arduino/tmp36-temperature-tutorial/

A B C D E

G H

J
1

10

10

15

15

RESET

ICSP2

TX
RX

AREF
GND
13

IOREF

3V3

20

20

5V
GND

TMP
36

25

A0
A1

A3

A B C D E

G H

A5

ICSP

ON

30

A4

30

ANALOG IN

A2

10
9
8
DIGITAL (PWM= )

25

11

TM

VIN

POWER

GND

12

Arduino

RESET

TX0

RX0

6
5
4
3
2

Proyecto 6 Grfica de datos de temperatura con Processing. Enviar los datos de voltaje
ledos a travs de un potencimetro a nuestro ordenador mediante el puerto serie e
imprimirlos en una grfica mediante processing.
AVANZADO: Encender un Led al ejecutar una determinada accin sobre un programa en
Processing.
En lugar de processing se puede hacer con otros lenguajes como Python o .Net para hacer
los dos ejemplos anteriores.
Informacin adicional:
Comunicar Arduino y Processing: http://playground.arduino.cc/interfacing/processing
Ejemplo: http://arduino.cc/en/Tutorial/Graph
Ejemplo Led: http://arduino.cc/en/Tutorial/PhysicalPixel

 Proyecto 7 Alerta de intrusin por email con plataforma IoT www.carriots.com.

Poner un sensor de iluminacin conectado al arduino y cuando se encienda la luz mande los
datos a la plataforma carriots y configurar en ella un aviso por email de intrusin.
Informacin adicional:
Documentacin: https://www.carriots.com/documentation
Librera Arduino de Carriots: https://github.com/carriots/arduino_library
API Rest de Carriots: https://www.carriots.com/documentation/api
Ejemplo: http://blog.biicode.com/iot-temperature-email-arduino-carriots/
Otro ejemplo: https://nukalamadhu.wordpress.com/2014/04/14/internet-of-things-with-arduinocarriots-m2m-cloud-platform/
Tutorial: https://www.carriots.com/tutorials/arduino_carriots/alert_system

 Proyecto 8 Comunicar dos Arduinos mediante I2C. Comunicar dos Arduinos para que
se manden informacin va I2C, ya sea el master quien lea datos y los enve el slave o el
master escriba y el slave lo lea.
Informacin adicional:
I2C: https://aprendiendoarduino.wordpress.com/2014/11/18/tema-6-comunicaciones-con-arduino-4/
Ejemplo1: http://arduino.cc/en/Tutorial/MasterReader
Ejemplo2: http://arduino.cc/en/Tutorial/MasterWriter
Otro ejemplo: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio33-I2C

Proyecto 9 Servidor Web embebido. Hacer una sencilla web embebida en Arduino
usando el ethernet shield. La web estar en una tarjeta SD dentro de un ficheo llamada
index.html.
Informacin adicional:
Librera Ethernet: https://aprendiendoarduino.wordpress.com/2014/11/18/tema-6-comunicacionescon-arduino-2/

Ejemplo: https://github.com/jecrespo/Aprendiendo-Arduino/blob/master/Ejercicio30SD/Ejercicio30-SD.ino
Ejemplo: http://arduino.cc/en/pmwiki.php?n=Tutorial/WebServer
Tutorial:
http://www.academia.edu/7510788/Embedded_Web_Server_using_Arduino_Ethernet_Shield
Otro tutorial: http://blog.startingelectronics.com/arduino-web-server-tutorial/
Proyecto 10 Grabar datos de temperatura en una Raspberry Pi. Datalogger de los
datos de temperatura ledos en una Raspberry Pi. Con una RPi que tenga un servidor LAMP
instalado, grabar en una tabla de una BBDD MySQL los datos de temperatura que mande
Arduino cada 5 segundo:
Informacin adicional:
Ejemplo: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio32-EnviaDatos

Tema 5 Taller de Proyectos con Arduino

A continuacin se dan las soluciones a los proyectos propuestos.

Proyecto 1 Estacin meteorolgica.

Enunciado
Estacin meteorolgica con una sonda de temperatura y pantalla LCD. Hacer que actualice
continuamente la temperatura y la muestre por pantalla. Poner un botn que al pulsarlo la primera
vez muestre por pantalla la mxima temperatura leda, al volver a pulsarlo muestre la temperatura
mnima leda y al volver a pulsarlo muestre la temperatura actual. Para resetear los valores mximo
y mnimo, pulsar durante 5 segundos el botn y muestre por pantalla valores reseteados.
Versin mejorada: Con el shield de ethernet conectarse a internet y mediante la API de
http://openweathermap.org/ y obtener los datos de humedad y presion y mostrarlos por pantalla.
Actualizar estos datos cada hora. Tambin se pueden obtener los datos de la API de AEMET.
Informacin o referencias usadas
Informacin sobre el uso de la sonda de temperatura:
http://arduino.cc/documents/datasheets/TEMP-TMP35_36_37.pdf
Pantalla LCD: http://arduino.cc/en/Tutorial/LiquidCrystal
Informacin sobre uso de un cliente ethernet para conexin a internet:
https://aprendiendoarduino.wordpress.com/2014/11/18/tema-6-comunicaciones-conarduino-2/ y https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio25EthernetClient
API: http://openweathermap.org/API
WebClient: http://arduino.cc/en/Tutorial/WebClient

 Una librera: https://github.com/Benjamin3992/OpenWeatherDuino

Datos para Logroo de http://openweathermap.org/:
http://api.openweathermap.org/data/2.5/weather?q=Logrono&mode=xml
http://api.openweathermap.org/data/2.5/weather?id=3118150
Esquema de conexin

Diagrama de flujo

Solucin
https://github.com/jecrespo/Aprendiendo-Arduino-Proyectos/tree/master/Proyecto_1Estacion_Meteorologica
https://github.com/jecrespo/Aprendiendo-Arduino-Proyectos/tree/master/Proyecto_1Estacion_Meteorologica_Mejorada

Proyecto 2 Arranque y parada de motor DC controlado.

Enunciado
Basndose en los ejercicios 9 y 10 del libro del Arduino Starter Kit, aadir una rampa de arranque y
otra de parada cuando se detecte el encendido y apagado. Tambin aadir una rampa de parada y
arranque cuando se detecte un cambio de sentido. Aadir un botn de parada de emergencia, que al
pulsarlo, se pare el motor inmediatamente.
Informacin o referencias usadas
Ejemplo bsico: http://diymakers.es/control-velocidad-y-sentido-de-motor-dc/
Esquema de conexin

Diagrama de flujo

Solucin

 https://github.com/jecrespo/Aprendiendo-ArduinoProyectos/tree/master/Proyecto_2%20%E2%80%93Motor_DC_Controlado

Proyecto 3 Juego de Sogatira

Enunciado
Hacer un juego con 7 leds y dos botones. El led central se ilumina y en funcin de quien ms veces
pulsa el botn el led encendido se va desplazando hacia l, hasta que gana cuando ha llegado al
ltimo led. En el inicio el led central parpadea y comienza el juego cuando se queda fijo, cada vez
que se gana una posicin el led parpadea y cuando gana el led final se queda parpadeando en un
bucle infinito hasta que reseteo el Arduino para volver a jugar.
Informacin o referencias usadas
Ejemplo simulado: http://123d.circuits.io/circuits/463198-juego-sogatira
Esquema de conexin

Diagrama de flujo

Solucin
https://github.com/jecrespo/Aprendiendo-Arduino-Proyectos/tree/master/Proyecto_3Juego_Sogatira

Proyecto 4 Simon
Enunciado
Hacer el juego de Simon con Arduino
Informacin o referencias usadas
Juego Simn: http://es.wikipedia.org/wiki/Simon_%28juego%29
Varios ejemplos:
http://www.arduteka.com/2012/07/juego-simon-con-s4a-y-arduino/
http://www.instructables.com/id/Arduino-Simon-Says/
Esquema de conexin

Solucin
https://github.com/jecrespo/Aprendiendo-Arduino-Proyectos/tree/master/Proyecto_4-Simon

Proyecto 5 Grfica de datos de temperatura en plot.ly

Enunciado
Recoger datos de temperatura cada 5 segundos y mandarlos a la web de plot.ly para que nos los
imprima en tiempo real. Ser necesario conectarse a Internet y usar el Ethernet Shield.
Informacin o referencias usadas
API Arduino para Plot.ly: https://github.com/plotly/arduino-api
Informacin: http://makezine.com/2014/01/21/streaming-data-with-plotly/
Ejemplo: https://plot.ly/arduino/dht22-temperature-tutorial/
Otro ejemplo: https://plot.ly/arduino/tmp36-temperature-tutorial/
Esquema de conexin
A B C D E

G H

J
1

10

10

15

15

RESET

ICSP2

TX
RX

AREF
GND
13

IOREF

3V3

20

20

5V
GND

TMP
36

25

A0
A1

A3

30
A B C D E

G H

A5

ICSP

ON

30

A4

ANALOG IN

A2

10
9
8
DIGITAL (PWM= )

25

11

TM

VIN

POWER

GND

12

Arduino

RESET

TX0

RX0

6
5
4
3
2

Solucin
https://github.com/jecrespo/Aprendiendo-Arduino-Proyectos/tree/master/Proyecto_5Grafic_Plotly

Proyecto 6 Grfica de datos potencimetro con Processing

Enunciado
Enviar los datos de voltaje ledos a travs de un potencimetro a nuestro ordenador mediante el
puerto serie e imprimirlos en una grfica mediante processing.
AVANZADO: Encender un Led al ejecutar una determinada accin sobre un programa en
Processing.

En lugar de processing se puede hacer con otros lenguajes como Python o .Net para hacer los dos
ejemplos anteriores.
Informacin o referencias usadas
Comunicar Arduino y Processing: http://playground.arduino.cc/interfacing/processing
Ejemplo: http://arduino.cc/en/Tutorial/Graph
Ejemplo Led: http://arduino.cc/en/Tutorial/PhysicalPixel
Esquema de conexin

Solucin
https://github.com/jecrespo/Aprendiendo-Arduino-Proyectos/tree/master/Proyecto_6Grafic_Processing

Proyecto 8 Comunicar dos Arduinos mediante I2C

Enunciado
Comunicar dos Arduinos para que se manden informacin va I2C. Configurar uno como master
para que todo lo que recoja por el puerto serie lo mande al bus I2C y el slave lo recoja y lo muestre
por pantalla.
Informacin o referencias usadas
I2C: https://aprendiendoarduino.wordpress.com/2014/11/18/tema-6-comunicaciones-con-arduino-4/
Ejemplo1: http://arduino.cc/en/Tutorial/MasterReader
Ejemplo2: http://arduino.cc/en/Tutorial/MasterWriter
Otro ejemplo: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio33-I2C
Esquema de conexin

Solucin
https://github.com/jecrespo/Aprendiendo-Arduino-Proyectos/tree/master/Proyecto_8Chat_I2C

Proyecto 9 Servidor Web embebido

Enunciado
Hacer una sencilla web embebida en Arduino usando el ethernet shield. La web estar en una tarjeta
SD dentro de un fichero llamada index.html.
Informacin o referencias usadas
Librera Ethernet: https://aprendiendoarduino.wordpress.com/2014/11/18/tema-6-comunicacionescon-arduino-2/
Ejemplo: https://github.com/jecrespo/Aprendiendo-Arduino/blob/master/Ejercicio30SD/Ejercicio30-SD.ino

Ejemplo: http://arduino.cc/en/pmwiki.php?n=Tutorial/WebServer
Tutorial:
http://www.academia.edu/7510788/Embedded_Web_Server_using_Arduino_Ethernet_Shield
Otro tutorial: http://blog.startingelectronics.com/arduino-web-server-tutorial/
Diagrama de flujo

Solucin
https://github.com/jecrespo/Aprendiendo-Arduino-Proyectos/tree/master/Proyecto_9Servidor_Web_%20Embebido

Proyecto 10 Grabar datos de temperatura en una Raspberry

Pi
Enunciado
Datalogger de los datos de temperatura ledos en una Raspberry Pi. Con una RPi que tenga un
servidor LAMP instalado, grabar en una tabla de una BBDD MySQL los datos de temperatura que
mande Arduino cada 5 segundos.
Informacin o referencias usadas
Ejemplo: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio32-EnviaDatos

Solucin
https://github.com/jecrespo/Aprendiendo-Arduino-Proyectos/tree/master/Proyecto_10Grabar_Raspberry

Y aqu no acaba el curso

Recordad que el curso sigue en:
https://aprendiendoarduino.wordpress.com/
Y tambin en las redes sociales:
Twitter: https://twitter.com/hashtag/aprendiendoarduino
Comunidad google+: https://plus.google.com/communities/104107521992758374331
Pgina google+: https://plus.google.com/u/0/113483615106580578460/posts

Firmata
2 respuestas
Firmata es un protocolo genrico para la comunicacin con microcontroladores desde software
instalado en un ordenador. Este protocolo se puede implementar en cualquier arquitectura de
microcontroladores, as como en cualquier paquete de software.
El objetivo de firmata es permitir controlar completamente Arduino desde software instalado en un
ordenador, sin escribir una sola lnea de cdigo de Arduino.
Por ejemplo, cuando se dice que Windows 10 puede usarse con Arduino o incluso se puede leer en
algunos artculos Como instalar windows 10 en Arduino, realmente lo que significa es que puedes
controlar un Arduino desde Windows 10, mediante la comunicacin con el protocolo firmata entre
Windows 10 y Arduino. Windows 10 implementa este protocolo de forma nativa.
Enlaces Windows 10 y Arduino:
https://blogs.windows.com/buildingapps/2015/04/29/microsoft-brings-windows-10-tomakers/
https://dev.windows.com/es-es/iot
http://computerhoy.com/noticias/software/como-instalar-windows-10-placa-arduino-28209
http://arstechnica.com/information-technology/2015/04/microsoft-bringing-windows-10-toarduino-with-open-source-libraries/
Explicacin de Windows + Arduino:
https://www.hackster.io/blog/windows-remote-arduino
https://blogs.windows.com/buildingapps/2016/02/04/what-is-windows-remote-arduino-andwhat-can-it-do/
https://www.hackster.io/windowsiot/basic-windows-remote-arduino-47eeb9
La librera: https://github.com/ms-iot/remote-wiring

Esto permite instalar un programa en windows 10 con soporte nativo de .NET para comunicarse con
un Arduino y hacer que encienda un led, mueva un motor o lea la temperatura de un sensor
conectado al Arduino sin tener que programar el Microcontrolador.
Ms adelante entraremos a fondo en como usar Arduino con Windows 10.
Para comprobar fcilmente cmo funciona firmata, disponemos de un programa que funciona en
Windows, Linux, Mac OS-X y necesita la version 2.2 o superior de la librera Firmata para Arduino
(actualmente est en la 2.5). Este programa se llama Firmata Test Program y est disponible en:
http://firmata.org/wiki/Main_Page#Firmata_Test_Program
Para implementar el protocolo firmata en Arduino debemos usar el sketch StandardFirmata que est
incluido en el IDE de Arduino:
https://github.com/firmata/arduino/tree/master/examples/StandardFirmata
La ltima versin de la librera Firmata para Arduino est en: https://github.com/firmata/arduino
Hay dos modos de uso de firmata. Un modelo es usar los mtodos ofrecidos por la librera firmata
dentro del sketch para enviar y recibir datos entre el Arduino y el software ejecutndose en el
ordenador. Por ejemplo, mandar el valor ledo de una entrada analgica.
El segundo modelo y ms comn es cargar en Arduino el sketch de propsito general llamado
StandardFirmata o alguna de sus variaciones como StandardFirmataPlus o
StandardFirmataEthernet y usar el software en el ordenador para interactuar con Arduino.
Un listado de los clientes de firmata para diversos lenguajes de programacin se puede encontrar
en: https://github.com/firmata/arduino#firmata-client-libraries
En caso que deseemos contribuir en el desarrollo o mejorar en la implementacin de firmata en
Arduino ver: https://github.com/firmata/arduino#contributing
Y cualquier problema sobre el desarrollo se puede seguir en el hilo de gitter:
https://gitter.im/firmata/arduino y en los problemas de diseo: http://firmata.org/wiki/Design_Issues
Se debe tener en cuenta que debido a la limitada memoria de Arduino, el nmero de funcionalidades
que se puede aadir es limitada.
Prctica: Probar como funciona el protocolo firmata en Arduino.
1. Descargar el programa Firmata Test Program para sistema operativo correspondiente de
http://www.pjrc.com/teensy/firmata_test/
2. Cargar el sketch StandardFirmata en Arduino: Archivo -> Ejemplos -> Firmata ->
StandardFirmata.
3. Probar que funciona encendiendo Leds y leyendo valores de los pines analgicos y digitales.

Detalles del protocolo

El estndar del protocolo firmata se puede encontrar en: https://github.com/firmata/protocol, donde
disponemos de las espcificaciones del protocolo standard, as como las implementaciones para
comunicar con dispositivos i2c, onewire, soporte para encoders, servos, motores paso a paso, etc

La anterior web oficial del protocolo firmata es http://firmata.org/wiki/Main_Page que se mantiene

a efectos de documentacin
Firmata est basado en el formato de mensaje de midi:
http://www.midi.org/techspecs/midimessages.php en el que los comandos se mandan en 8 bits y los
datos en 7 bits. En Midi System Exclusive (Sysex http://www.2writers.com/eddie/tutsysex.htm), los
mensajes pueden tener cualquier longitud y se usa de forma ms extensiva en el protocolo firmata.
El ncleo del protocolo est descrito en:
https://github.com/firmata/protocol/blob/master/protocol.md
La implementacin del protocolo firmata para Arduino se encuentra en
https://github.com/firmata/arduino aunque este protocolo se podra implementar en cualquier otro
microcontrolador.
La versin actual del protocolo firmata es la 2.5. Se trata de un protocolo serie a una velocidad de
57600 baudios.

Comandos
Los comandos (primer byte del protocolo), se descomponen en el primer nibble (el ms
significativo) es el propio comando y el segundo nibble del byte (el menos significativo) que en
algunos casos aparece como 0 y da el nmero de puerto o de pin.
Los comandos son:
0x90 datos del pin digital (un puerto son hasta 8 pines digitales que se almacenan en en los
port registers que permiten una manipulacin a bajo nivel ms rpida. Cada puerto es
controlado por 3 registros. Ms informacin en
https://www.arduino.cc/en/Reference/PortManipulation o en el captulo del Tema 3
Microcontroladores. Registros de memoria.
0xE0 datos del pin analgico
0xF4 Configurar el modo del pin
0xF5 configurar el valor del pin digital
0xC0 configurar reporte del pin digital (una vez habilitado, el valor del pin debe ser
reportado a la aplicacin cliente)
0xD0 configurar reporte del pin analgico (una vez habilitado, el valor del pin debe ser
reportado a la aplicacin cliente)
0xF9 versin del protocolo
En esta tabla se ve el mensaje utilizado y los bytes de datos usados:
type
analog I/O message
digital I/O message
report analog pin
report digital port
start sysex

command
0xE0
0x90
0xC0
0xD0
0xF0

MIDI channel
pin #
port
pin #
port

first byte
second byte
LSB(bits 0-6)
MSB(bits 7-13)
LSB(bits 0-6)
MSB(bits 7-13)
disable/enable(0/1) n/a
disable/enable(0/1) n/a

set pin mode(I/O) 0xF4

pin # (0-127)
pin state(0=in)
set digital pin value 0xF5
pin # (0-127)
pin value(0/1)
sysex end
0xF7
protocol version
0xF9
major version
minor version
Comandos sysex: la idea de estos comandos es disponer de un espacio para un segundo comando
usando el primer byte despus del SysEx start byte (0xF0). La diferencia es que los datos pueden
tener cualquier tamao al contrario que los mensajes MIDI standard que tienen 2 bytes)
0x71 string
0x79 nombre/versin del firmware
0xF7 fin de Sysex
Ms informacin en: https://github.com/firmata/protocol/blob/master/protocol.md#sysex-messageformat
Ms informacin del protocolo en: https://github.com/firmata/protocol/blob/master/protocol.md

La librera Firmata para Arduino

La librera Firmata de Arduino implementa el protocolo Firmata visto anteriormente para comunicar
el Arduino con el software ejecutado en un ordenador
La ltima versin de la librera firmata para Arduino se encuentra en:
https://github.com/firmata/arduino
La referencia de la librera Firmata para Arduino se encuentra en:
https://www.arduino.cc/en/Reference/Firmata
Los mtodos disponibles en la librera son:
begin(long) Comienza la librera, es posible poner otra velocidad diferente a la velocidad
por defecto que es 57600 baudios. Tambin es posible iniciar el protocolo firmata desde otro
Stream que no sea el que viene por defecto que es Serial
printVersion() enva la versin del protocolo al ordenador
blinkVersion() parpadea la versin de protocolo en el build in LED, generalmente el pin
13.
printFirmwareVersion() . enva la versin de firmware y su versin al ordenador
setFirmwareVersion(byte major, byte minor) Configura la versin del firmware
setFirmwareNameAndVersion(const char *name, byte major, byte minor) Configura
nombre y versin del firmware
Mtodos de envo de mensajes:
sendAnalog(byte pin, int value) Manda el valor del pin analgico
sendDigitalPort(byte portNumber, int portData) Manda el valor de un puerto digital de 8
bits.
sendString(const char* string) Manda un string a un ordenador.

 sendString(byte command, byte bytec, byte *bytev) Manda un string al ordenador usando
un tipo de comando
sendSysex(byte command, byte bytec, byte* bytev) Manda un comando un con array de
bytes
write(byte c) Manda un byte al stream de datos.
Mtodos de recepcin de mensajes.
available() Comprueba si hay algn mensaje entrante en el buffer
processInput() Procesar los mensajes entrantes que hay en el buffer, mandado los datos a
cualquiera de las funciones de callback registradas.
attach(byte command, callbackFunction myFunction) Registrar una funcin a un tipo de
mensaje entrante.
detach(byte command) desregistrar la funcin del tipo de mensaje
Otros mtodos:
sendValueAsTwo7bitBytes(int value) Escribe el valor como 2 bytes
startSysex(void) Comenzar mensaje sysex
endSysex(void) Finalizar mensaje sysex
Para asociar una funcin de callback a un tipo de mensaje de Firmata, la funcin debe cumplir el
estndar de callback function. Hay varios tipos de funciones de respuesta en Firmata:

genrica: void callbackFunction(byte pin, int value);

reset del sistema: void systemResetCallbackFunction(void);
string: void stringCallbackFunction(char *myString);
sysex: void sysexCallbackFunction(byte command, byte byteCount, byte *arrayPointer);

Hay varios tipos de mensajes que se pueden asociar a las funciones de callback:
ANALOG_MESSAGE //the analog value for a single pin // Comando (0xE0)
DIGITAL_MESSAGE //8-bits of digital pin data (one port) // Comando (0x90)
REPORT_ANALOG //enable/disable the reporting of an analog pin // Comando (0xC0)
REPORT_DIGITAL //enable/disable the reporting of a digital port // Comando (0xD0)
SET_PIN_MODE //change the pin mode between INPUT/OUTPUT/PWM/etc. // Comando
(0xF4)
STRING_DATA //C-style strings, uses stringCallbackFunction for the function type //
Comando (0x71)
SYSEX_START //generic, arbitrary length messages (via MIDI SysEx protocol), uses
sysexCallbackFunction for the function type // Comando (0xF0)
SYSTEM_RESET //message to reset firmware to its default state, uses
systemResetCallbackFunction for the function type

Para instalar Standard Firmata en Arduino, se puede serguir este tutorial:

http://www.instructables.com/id/Arduino-Installing-Standard-Firmata/?ALLSTEPS

Veamos el sketch que implementa firmata en Arduino llamado StandardFirmata.ino y es muy usado
por aplicaciones para ordenador y mvil. Cdigo:
https://github.com/firmata/arduino/blob/master/examples/StandardFirmata/StandardFirmata.ino
Detalles:
Implementa control de servos (librera servo.h), dispositivos I2C (librera wire.h)
En lnea 96, implementa la funcin wireWrite y wireRead para que funcione con todo tipo
de versiones de IDE Arduino al compilar.
En lnea 747 setup: inicializa la versin de firmware y asocia las funciones de callback a los
mensajes de entrada. La implementacin de cada funcin se hace en las lneas anteriores.
Luego resetea a la configuracin por defecto de los pines.
En lnea 777 loop: en cada loop primero comprueba el cambio de estado de las entradas
digitales. Luego busca mensajes entrantes firmata y los procesa si es necesario. Por ltimo
lee las entradas analgicas segn el intervalo de muestreo configurado y manda datos a los
dispositivos I2C con modo de lectura continua activado.
Y tambin tenemos estas otras implementaciones de firmata en Arduino:
https://github.com/firmata/arduino/blob/master/examples/StandardFirmataPlus/StandardFir
mataPlus.ino
https://github.com/firmata/arduino/blob/master/examples/StandardFirmataEthernet/Standard
FirmataEthernet.ino
https://github.com/firmata/arduino/blob/master/examples/StandardFirmataEthernetPlus/Stan
dardFirmataEthernetPlus.ino
Existen implementaciones especficas otras plataforma de desarrollo como spark que se puede ver
en: https://github.com/firmata/spark
Ejercicio38 Entendiendo Firmata:
Para poder ver los mensajes enviados por el protocolo firmata y entender cmo funciona, vamos a
ejecutar un sketch que manda las lecturas de todos los puertos analgicos por el puerto serie con
firmata.
Dado que los mensajes son en hexadecimal no es posible ver los mensajes con el terminal
proporcionado por el IDE de Arduino y para ello se puede usar esta otra aplicacin de terminal:
https://sites.google.com/site/terminalbpp/
Pasos a seguir:
1. Cargar en Arduino el sketch del ejercicio38 Entendiendo_Firmata:
https://github.com/jecrespo/Aprendiendo-Arduino/blob/master/Ejercicio38Firmata/Entendiendo_Firmata/Entendiendo_Firmata.ino
2. Entender que hacer este sketch
3. Abrir el programa de Terminal y configurarlo con:
1. Baud rate = 57600
2. Receive en HEX
3. Habilitar las pantallas Dec, Hex y Bin

4. Ejecutar el programa y capturar lo que enva Arduino en Hexadecimal.

En cada loop manda FFFF que nos indica que inica un loop, luego manda para el caso de un
Arduino UNO manda las lecturas de los 6 puertos analgicos con el comando
ANALOG_MESSAGE E0, E1, E2, etc y luego el valor ledo
Para entender lo que muestra, hay que ver cmo est implementado el protocolo para el comando
ANALOG_MESSAGE en https://github.com/firmata/protocol/blob/master/protocol.md
type
command MIDI channel first byte
second byte
analog I/O message 0xE0
pin #
LSB(bits 0-6) MSB(bits 7-13)
E1 Pin analgico 1
7D 01111101
07 00000111
Valor = 00001111111101 = 1021
Tambin manda en valor en decimal para comprobar con el Serial.println
Avanzado: Ver los ejemplos que trae la librera firmata de Arduino, entender y comprobar cmo
funciona.
SimpleAnalogFirmata
SimpleDigitalFirmata
Solucin: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio38-Firmata

Firmata para controlar buses

Firmata no solo nos permite leer y escribir en puertos analgicos y digitales, tambin es posible
manejar diferentes buses.
I2C: permite la comunicacin con dispositivos I2C. La versin actual del protocolo solo
soporta un puerto I2C por placa. Ms informacin en:
https://github.com/firmata/protocol/blob/master/i2c.md
El intervalo de muestreo
(https://github.com/firmata/protocol/blob/master/protocol.md#sampling-interval) configura
con que frecuencia los datos analgicos y los I2C son enviados al software cliente. Por
defecto en Arduino es de 19ms. Estos significa que cada 19ms los datos sern reportados en
aquellos dispositivos en modo lectura continua.
Encoder: da soporte para encoders tanto lineales como rotativos. Para ms informacin:
https://github.com/firmata/protocol/blob/master/encoder.md y librera encoder:
http://www.pjrc.com/teensy/td_libs_Encoder.html
Onewire: da soporte para el caso de configurar los pins de Arduino como OneWire
Busmaster. Ms inforamcin: https://github.com/firmata/protocol/blob/master/onewire.md
Scheduler: Nos permite guardar un flujo de mensajes en el microcontrolador y luego
repetirlos una sola vez o de forma continua. Ms informacin en:
https://github.com/firmata/protocol/blob/master/scheduler.md.
Ejemplo:
https://github.com/firmata/ConfigurableFirmata/blob/master/src/FirmataScheduler.cpp
Serial: permite controlar hasta 4 software y 4 hardware (UART) puertos serie. Varios
puertos se pueden usar simultneamente dependiendo de las restricciones del propio
microcontrolador. Ms informacin:
https://github.com/firmata/protocol/blob/master/serial.md
Servos: Nos permite mandar un mensaje para configurar un servo. Ms informacin:
https://github.com/firmata/protocol/blob/master/servos.md
Motor Paso a Paso: da soporte para drivers de motores paso a paso de 4 y 2 hilos y tambin
para drivers de de paso + direccin como easydriver. La versin actual soporta hasta 6
motores paso a paso. Ms inforamcin en
https://github.com/firmata/protocol/blob/master/stepper.md. Ejemplo:
https://github.com/soundanalogous/AdvancedFirmata
Tambin existen propuestas del protocolo firmata para control de grupo de pines digitales,
registros de desplazamiento y tono.
https://github.com/firmata/protocol/blob/master/pingroups-proposal.md
https://github.com/firmata/protocol/blob/master/shift-proposal.md
https://github.com/firmata/protocol/blob/master/tone-proposal.md

Firmata y Arduino en Windows 10

Microsoft ha entrado en el IoT con Windows 10 IoT Core que es una versin de Windows 10
optimizada para pequeos dispositivos como Raspberry Pi 2 y que usa la API de Universal
Windows Platform (UWP) para construir aplicaciones.
En Abril de 2015 Microsoft anuncia Windows 10 IoT Core y la participacin con Arduino:
https://blogs.windows.com/buildingapps/2015/04/29/microsoft-brings-windows-10-to-makers/
Windows 10 IoT Core tambin soporta la API Arduino-Wiring usada en los sketches y libreras para
un acceso directo al hardware desde Windows 10. Para programar Arduino Microsoft nos propone
su IDE Visual Studio. Esto facilita a la gente familiarizada con la programacin en .NET entrar en
el mundo Arduino.
Ms informacin en:
https://dev.windows.com/es-es/iot
http://ms-iot.github.io/content/en-US/IoTCore.htm
Para empezar con Windows IoT, solo hay que seguir las instrucciones de: http://msiot.github.io/content/en-US/GetStarted.htm en el apartado de Arduino y Windows 10.
Arduino Wiring junto con Windows IoT Lightning functionality nos permite copiar y pegar
sketches de Arduino y libreras de Arduino en el IDE (zona de Arduino Wiring Projects) y
ejecutarlos en cualquiera de los dispositivos IoT Core como Raspberry Pi.
Guia de uso: http://ms-iot.github.io/content/en-US/win10/Lightning.htm
Ejemplo de Arduino Wiring con el blink: http://ms-iot.github.io/content/enUS/win10/samples/arduino-wiring/HelloBlinky.htm
Guia para portar a Arduino Wiring: http://ms-iot.github.io/content/enUS/win10/ArduinoWiringPortingGuide.htm
Windows Remote Arduino, es una librera que permite controlar Arduino a travs de
Bluetooth, USB, Wi-Fi o Ethernet. Permite incluir los sensores de Arduino a los proyectos
desarrollados con aplicaciones Windows.
La librera Windows Remote Arduino es una librera open source que conecta cualquier
dispositivo Windows 10 como un Windows Phone, Surface, PC, o incluso una Raspberry Pi
2 con un Arduino que est corriendo el StandardFirmata visto anteriormente. De esta forma
es posible controlar remotamente un Arduino con el software desarrollado con esta librera.
Ms informacin en: http://ms-iot.github.io/content/en-US/win10/WRALanding.htm
Ejemplo para hacer la primera aplicacin con la Windows Remote Arduino Library:
http://ms-iot.github.io/content/en-US/win10/WRA.htm
Librera Windows Remote Arduino: https://github.com/ms-iot/remote-wiring
Windows Virtual Shields, es una librera open source para Arduino UNO que comunica
con una aplicacin corriendo en Windows 10 de forma que expone los sensores de los
telfonos Lumia o cualquier dispositivo corriendo Windows 10 a un Arduino.
Para conseguir esto se intercambian mensajes en formato JSON.
Ms informacin en: http://ms-iot.github.io/content/en-US/win10/WVSA.htm

 Libreras de virtual shield para Arduino: https://github.com/ms-iot/virtual-shieldsarduino

En nuestro caso el apartado que nos interesa para comunicar una aplicacin desarrollada en
Windows con Arduino es el Windows Remote Arduino.
Bsicamente esta librera open source une un dispositivo con Windows 10 y Arduino mediante el
protocolo firmata de forma sencilla.
Ejemplo para hacer blink con Windows Remote: https://www.hackster.io/windowsiot/basicwindows-remote-arduino-47eeb9
Esta imagen explica el funcionamiento de Windows Remote Arduino:

Una muy buena explicacin de Windows Remote Arduino:

https://blogs.windows.com/buildingapps/2016/02/04/what-is-windows-remote-arduino-and-whatcan-it-do/
Tambin es posible hacer aplicaciones .NET sin tener windows 10 usando una librera de firmata:
http://www.acraigie.com/programming/firmatavb/
Es posible encontrar ms proyectos de Windows 10 + Arduino en: https://microsoft.hackster.io/enUS/search?q=arduino
Otros enlaces:

 Descarga kits y herramientas para windows 10: https://msdn.microsoft.com/eses/windows/hardware/dn913721(v=vs8.5).aspx

Documentos y Tutoriales: http://ms-iot.github.io/content/en-US/win10/StartCoding.htm
HW compatible: http://ms-iot.github.io/content/en-US/win10/SupportedInterfaces.htm
W10 IoT en github: https://github.com/ms-iot/
Comenzar con Windows Drivers: https://msdn.microsoft.com/enus/library/windows/hardware/ff554690(v=vs.85).aspx
Ejemplos de drivers para Windows 10: https://github.com/Microsoft/Windows-driversamples
Windows Debugging: https://msdn.microsoft.com/enus/library/windows/hardware/mt219729(v=vs.85).aspx
Comunidad: http://ms-iot.github.io/content/en-US/Community.htm

Firmata y Arduino con Python

Una forma sencilla de comunicar Arduino con el ordenador mediante software open source es usar
python. Hay disponibles varias libreras de firmata para python que facilitan el interfaz entre
Arduino y el programa hecho en python.
Dado que Python es posible usarlo en multitud de Sistemas Operativos e incluso en Raspberry Pi o
similares, tenemos una herramienta potente con Firmata + Python para comunicar Arduino con
cualquier otro dispositivo.
Una buena gua para usar Arduino con python se encuentra en el playground de Arduino:
http://playground.arduino.cc/Interfacing/Python
Para comunicar por puerto serie el ordenador ejecutando python, la mejor opcin es usar la librera
pyserial de python:

Documentacin: https://pyserial.readthedocs.org/en/latest/
pyserial API: https://pyserial.readthedocs.org/en/latest/pyserial_api.html
Proyecto en github: https://github.com/pyserial/pyserial
https://pypi.python.org/pypi/pyserial

No solo es posible interactuar con Arduino por el puerto serie, sera similar hacerlo va bluetooth,
ethernet, etc con las libreras adecuadas disponibles en python.
Libreras de Firmata para python:
python-firmata: https://github.com/lupeke/python-firmata/
Se trata de una implementacin muy sencilla del protocolo firmata y es intersante ver como
se implementan los mtodos en el cdigo fuente: https://github.com/lupeke/pythonfirmata/blob/master/firmata/firmata.py
pyFirmata:
Proyecto en github https://github.com/tino/pyFirmata
Librera: https://pypi.python.org/pypi/pyFirmata
API pyFirmata: http://pyfirmata.readthedocs.org/en/latest/index.html

 Documentacin: https://github.com/tino/pyFirmata/blob/master/README.rst
Ejemplos: https://bitbucket.org/fab/pyfirmata/src/96116e877527/examples/
pyduino: https://github.com/firmata/pyduino
PyMata: https://github.com/MrYsLab/PyMata
Documentacin: http://htmlpreview.github.io/?
https://github.com/MrYsLab/PyMata/blob/master/documentation/html/PyMata.pyma
ta.PyMata-class.html
Tutorial de uso de PyMata: http://www.instructables.com/id/Going-BeyondStandardFirmata-Adding-New-Device-Sup/
Un artculo que explica perfectamente y en un lenguaje muy sencillo cmo controlar un Arduino a
travs de un programa de ordenador mediante firmata se puede leer en:
http://edupython.blogspot.com.es/2014/06/como-programar-tu-arduino.html
Al usar firmata en Arduino y correr los programas en un ordenador tenemos unas serie de ventajas y
desventajas respecto a cargar el sketch en el propio Arduino. Dependiendo del objetivo de nuestro
proyecto puede ser ms til una estrategia u otra.
Ventajas:
Nuestro programa no est limitado por la memoria RAM y Flash de Arduino
El software de control se puede programar en cualquier lenguaje, no solo C++, siempre que
tenga soporte para firmata. Por ejemplo: Firmata: Processing, Visual Basic, Perl, C#, PHP,
Java, JavaScript, Ruby y por su puesto Python.
Desventajas:
Programas ms restringidos, es posible que algunas operaciones complejas no sea posible
hacerlas. Por ejemplo el uso de interrupciones.
Al arduino siempre debe estar conectado al ordenador. Debe tener comunicacin para poder
ejecutar acciones.
Ejercicio 38 Blink (Arduino + Python + Firmata)
Vamos a probar varios programas para controlar Arduino desde programas corriendo en el
ordenador hechos en python.
Preparar entorno para python:
1. Descargar Python para el sistema operativo correspondiente:
https://www.python.org/downloads/
2. Instalar Python: https://docs.python.org/3/using/windows.html
3. Instalar dependiencias python:
http://code.rancidbacon.com/LearningAboutArduinoandPython
pyserial: https://pypi.python.org/pypi/pyserial y https://github.com/pyserial/pyserial
Comando: pip install serial o directamente desde el cdigo fuente
pyFirmata: https://github.com/tino/pyFirmata
Comando: pip install pyFirmata

 PyMata: https://github.com/MrYsLab/PyMata
Comando: pip install PyMata
Preparar Arduino:
1. Cargar el sketch StandardFirmata en Arduino.
Ejecutar el programa desde el ordenador usando la librera PyMata:
1. Ejecutar el ejemplo blink.py: https://github.com/jecrespo/AprendiendoArduino/blob/master/Ejercicio38-Firmata/Python_Firmata/blink.py
2. Para conocer algo ms de PyMata, ver los ejemplos de
https://github.com/MrYsLab/PyMata/tree/master/examples
Para entender a fondo la librera PyMata ver la documentacin de la API:
http://htmlpreview.github.io/?
https://github.com/MrYsLab/PyMata/blob/master/documentation/html/PyMata.pymata.PyMataclass.html
Ejercicio 38 Medidor de luz con Firmata
Vamos a hacer un medidor de luz controlado por una fotoresistencia LDR pero usando firmata.
Hagamos este ejemplo sencillo pero sin programar una sola lnea en el Arduino y controlarlo desde
el ordenador: http://www.geekfactory.mx/tutoriales/tutoriales-arduino/tutorial-arduino-confotoresistencia-ldr/
Se trata de encender los LEDs en funcin de la intensidad de luz. Leer el cdigo del ejemplo
original y trasladarlo a un programa en python con firmata.
El esquema de conexiones es:

En este caso vamos a usar la librera pyFirmata que ya tenemos instalada y en Arduino ya est
instalado el standardFirmata.

Ejecutar el ejemplo Medidor_Luz.py de https://github.com/jecrespo/AprendiendoArduino/blob/master/Ejercicio38-Firmata/Python_Firmata/Medidor_Luz.py

Ms informacin de pyFirmata en: https://github.com/tino/pyFirmata
Solucin a los ejercicios: https://github.com/jecrespo/AprendiendoArduino/tree/master/Ejercicio38-Firmata
Otro ejemplo explicado similar est en http://edupython.blogspot.com.es/2014/06/como-programartu-arduino.html
Avanzado: ejemplos con pyFirmata ms complejos en:
https://bitbucket.org/fab/pyfirmata/src/96116e877527/examples/, incluso hay un programa con una
interfaz grfica que funciona en linux.

Implementaciones de firmata en otros lenguajes

Como hemos visto, podemos controlar Arduino desde el ordenador mediante el protocolo firmata
programando con cualquier lenguaje de programacin que tenga implementado firmata o hagamos
nosotros mismos la implementacin. Podemos usar diversas libreras en funcin del lenguaje de
programacin que queramos usar:
Cuando se habla que programar Arduino con tal o cual lenguaje se refiere a hacer el control desde
un ordenador que da rdenes a un Arduino corriendo standardFirmata.
En esta web tenemos mchos ejemplos de software/libreras para programar un Arduino desde un
ordenador: http://firmata.org/wiki/Download (alternativa
https://web.archive.org/web/20150911005414/http://firmata.org/wiki/Download)
Ejemplos interesantes:
Processing: http://playground.arduino.cc/Interfacing/Processing. Esta librera te permite
controlar Arduino sin escribir una lnea de cdigo de Arduino.
Librera en C: https://github.com/jdourlens/FirmataC
Librera en C++: https://sourceforge.net/projects/firmataplus/
Wolfram ModelPlug permite enlazar los modelos simulados en Mathematica con el mundo
real usando un Arduino. http://www.wolfram.com/system-modeler/libraries/model-plug/
PinGo: http://www.pingo.io/docs/
Visual Basic .NET: http://www.acraigie.com/programming/firmatavb/default.html
Firmata.js para nodejs: https://github.com/jgautier/firmata
Breakout, usando javascript y la web para interactuar con Arduino:
https://github.com/soundanalogous/Breakout (PROYECTO MUY INTERESANTE)
Para el uso de firmata en programacin de Arduino con javascript con node.js se puede usar
el framework de JavaScript + node.js: https://github.com/rwaldron/johnny-five/ y este
eBook: http://www.webondevices.com/ (PROYECTO MUY INTERESANTE)
Ruby: https://github.com/hardbap/firmata
Java: https://github.com/kurbatov/firmata4j

Como ya se ha dicho, firmata no solo puede usarse por el puerto serie sino por cualquier otro medio.
Ejemplo de uso de firmata con bluetooth para comunicar arduino + beaglebone:
http://www.instructables.com/id/Wireless-Arduino-Control-Using-the-BeagleBone-Blac/

Firmata Builder
Firmata Builder es un mdulo que nos permite generar un sketch de Arduino desde una seleccin
de caractersticas de firmata.
Ms informacin en:
https://github.com/firmata/firmata-builder
Esta librera es usada por: http://firmatabuilder.com/
Firmata Builder nos permite crear un sketch StandardFirmata reducido para nuestras necesidades y
aadir otras funcionalidades propias.
ConfigurableFirmata es una versin de Firmata que separa las caractersticas del protocolo en
clases individuales, haciendo ms sencillo mezclar las caractersticas estndar del protocolo con
otras personalizadas. La forma ms sencilla de usar ConfigurableFirmata es usando FirmataBuilder.
Proyecto en github: https://github.com/firmata/ConfigurableFirmata
Fuente de ConfigurableFirmata: https://github.com/firmata/ConfigurableFirmata/tree/master/src
Libreras cliente que soportan ConfigurableFirmata:
https://github.com/firmata/ConfigurableFirmata#firmata-client-libraries
Ejemplo:
https://github.com/firmata/ConfigurableFirmata/blob/master/examples/ConfigurableFirmata/Config
urableFirmata.ino