Académique Documents
Professionnel Documents
Culture Documents
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:
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:
Pasos a seguir:
Abrir la aplicacin Arduino
Abrir el ejemplo blink
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.
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
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.
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
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
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
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;
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
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
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.
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
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.
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
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)
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
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
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
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
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.
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.
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
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.
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.
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
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.
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
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
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
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 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
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
Diagrama de flujo
Solucin
https://github.com/jecrespo/Aprendiendo-ArduinoProyectos/tree/master/Proyecto_2%20%E2%80%93Motor_DC_Controlado
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
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
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
Solucin
https://github.com/jecrespo/Aprendiendo-Arduino-Proyectos/tree/master/Proyecto_8Chat_I2C
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
Solucin
https://github.com/jecrespo/Aprendiendo-Arduino-Proyectos/tree/master/Proyecto_10Grabar_Raspberry
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.
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
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:
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
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
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
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.
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