prototipado-de-disenos-con-arduino

Vista previa del material en texto

TRABAJO FIN DE ESTUDIOS
Plataforma de experimentación para prototipado de
diseños mediante Arduino
Santiago Reig Chiva
PROYECTO FIN DE CARRERA
Tutor: Carlos Alberto Rodríguez González
Curso 2011-2012
© El autor
© Universidad de La Rioja, Servicio de Publicaciones, 2012
publicaciones.unirioja.es
E-mail: publicaciones@unirioja.es
Plataforma de experimentación para prototipado de diseños mediante 
Arduino, trabajo fin de estudios
de Santiago Reig Chiva, dirigido por Carlos Alberto Rodríguez González (publicado por la
Universidad de La Rioja), se difunde bajo una Licencia
Creative Commons Reconocimiento-NoComercial-SinObraDerivada 3.0 Unported.
Permisos que vayan más allá de lo cubierto por esta licencia pueden solicitarse a los
titulares del copyright.
 
 
 
 
 
 
 
 
Peticionario: Universidad de La Rioja 
Área de proyectos de ingeniería 
 
Informante: Santiago Reig Chiva 
Alumno de I.T.I. Electrónica Industrial 
Universidad de La Rioja 
 
Director: Carlos Alberto Rodríguez González 
 Departamento de Ingeniería Eléctrica 
 
Lugar y fecha: Logroño, 20 de julio de 2012 
 
“PLATAFORMA DE EXPERIMENTACIÓN PARA 
PROTOTIPADO DE DISEÑOS MEDIANTE ARDUINO” 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Índice 
 Página 2 
 
Í ndice 
 
Memoria ............................................................................................. 3 
Anexos .............................................................................................. 85 
Pliego de condiciones ............................................................... 166 
Planos ............................................................................................ 183 
Presupuesto ................................................................................. 185 
Bibliografía .................................................................................. 195 
 
 
 
MEMORIA 
 
 
 
DOCUMENTO Nº 1 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 4 
 
Í ndice de la memoria 
1. Antecedentes ............................................................................................ 13 
2. Objetivo del proyecto ............................................................................... 14 
3. Definiciones .............................................................................................. 17 
4. Introducción ............................................................................................. 19 
4.1. El polímetro .............................................................................................. 19 
4.2. Osciloscopio .............................................................................................. 20 
4.3. Analizador lógico ...................................................................................... 21 
4.4. Actualidad ................................................................................................. 22 
5. Estudios previos al diseño ........................................................................ 23 
5.1. Estudio de ArduLab ................................................................................... 23 
5.2. Estudio de Bus Pirate ................................................................................ 25 
5.3. Estudio de Little Wire ............................................................................... 28 
6. Análisis de soluciones ............................................................................... 30 
6.1. Comparativa de soluciones para la placa de interfaz ............................... 31 
6.1.1. Análisis de la plataforma Atmel AVR ................................................. 32 
6.1.1.1. Análisis de Arduino ...................................................................... 32 
6.1.2. Análisis de la plataforma Microchip PIC ............................................ 33 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 5 
 
6.1.2.1. Análisis de Pingüino ..................................................................... 33 
6.1.2.2. Análisis chipKIT ............................................................................ 34 
6.1.3. Análisis de la plataforma ARM .......................................................... 35 
6.1.3.1. Análisis de ST Micro ..................................................................... 36 
6.1.3.2. Análisis de NXP ............................................................................ 37 
6.1.4. Análisis de la plataforma de Texas Instruments MSP430 ................. 38 
6.1.4.1. Análisis de Launchpad ................................................................. 38 
6.2. Comparativa de soluciones para el medio de comunicación ................... 40 
6.2.1. Análisis del puerto paralelo ............................................................... 40 
6.2.2. Análisis del puerto serie .................................................................... 41 
6.2.3. Análisis del USB ................................................................................. 42 
6.2.4. Análisis del Bluetooth ........................................................................ 42 
6.2.5. Análisis del XBee ................................................................................ 43 
6.2.6. Otras soluciones ................................................................................ 44 
6.3. Comparativa de soluciones para el protocolo de comunicaciones .......... 45 
6.3.1. Análisis de Firmata ............................................................................ 45 
6.3.2. Análisis del protocolo de ArduLab .................................................... 47 
6.3.3. Análisis para la creación de un protocolo propio ............................. 47 
6.4. Comparativa de soluciones para el lenguaje de programación ............... 48 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 6 
 
6.4.1. Análisis de Java .................................................................................. 48 
6.4.2. Análisis de Qt ..................................................................................... 49 
6.4.3. Análisis de Python ............................................................................. 50 
7. Descripción de la solución adoptada ........................................................ 52 
7.1. Descripción de la placa de interfaz adoptada .......................................... 52 
7.2. Descripción del medio de comunicación adoptado ................................. 52 
7.3. Descripción del protocolo de comunicación adoptado ........................... 53 
7.4. Descripción del lenguaje adoptado .......................................................... 53 
8. Desarrollo ................................................................................................. 55 
8.1. Diseño general .......................................................................................... 55 
8.2. Análisis del protocolo Firmata .................................................................. 56 
8.2.1. Introducción ...................................................................................... 56 
8.2.2. Descripción del protocolo ................................................................. 57 
8.2.2.1. Mensajes ...................................................................................... 57 
8.2.3. Descripción de la comunicación ........................................................ 58 
8.2.4. Mejoras en la implementación del protocolo ................................... 60 
8.2.5. Descripción de la capa física.............................................................. 61 
8.2.6. Descripción de los conectores...........................................................61 
8.2.7. Descripción del cableado .................................................................. 63 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 7 
 
8.2.8. Distancias y terminaciones ................................................................ 63 
8.3. Análisis de la aplicación software ............................................................. 64 
8.3.1. Introducción ...................................................................................... 64 
8.3.2. Entorno de trabajo utilizado para el desarrollo ................................ 66 
8.3.3. Descripción del código fuente ........................................................... 67 
8.3.3.1. Inicialización de los módulos ....................................................... 67 
8.3.3.2. Selección del puerto serie ........................................................... 69 
8.3.3.3. Programación del Arduino ........................................................... 70 
8.3.3.4. Comunicación con Firmata .......................................................... 71 
8.4. Análisis de la placa de interfaz ................................................................. 74 
8.4.1. Introducción ...................................................................................... 74 
8.4.2. Características principales ................................................................. 76 
8.4.3. Formas de alimentación eléctrica ..................................................... 77 
8.4.4. Análisis de la memoria ...................................................................... 78 
8.4.5. Análisis de las entradas y salidas ....................................................... 78 
8.4.6. Análisis de la Interfaz USB-Serie ........................................................ 79 
8.4.6.1. Chip FTDI ...................................................................................... 80 
8.4.6.2. Chip Atmel ................................................................................... 80 
8.4.6.3. Sin chip ......................................................................................... 81 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 8 
 
8.4.7. Análisis de los métodos de programación ........................................ 82 
8.4.8. Análisis del entorno de trabajo ......................................................... 82 
 
 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 9 
 
Í ndice de ilustraciones 
Ilustración 1 | Polímetro analógico .................................................................... 20 
Ilustración 2 | Polímetro digital .......................................................................... 20 
Ilustración 3 | Osciloscopio analógico ................................................................ 21 
Ilustración 4 | Osciloscopio digital ..................................................................... 21 
Ilustración 5 | Analizador lógico ......................................................................... 21 
Ilustración 6 | Captura de ArduLab .................................................................... 24 
Ilustración 7 | Bus Pirate v3.6 ............................................................................. 26 
Ilustración 8 | Usando el Bus Pirate con Putty ................................................... 28 
Ilustración 9 | Little Wire .................................................................................... 29 
Ilustración 10 | Arduino UNO ............................................................................. 33 
Ilustración 11 | Placa Pingüino ........................................................................... 34 
Ilustración 12 | chipKIT Uno32 ........................................................................... 35 
Ilustración 13 | STM32 Discovery ....................................................................... 37 
Ilustración 14 | LPCXPRESSO con ARM Cortex-M0 ............................................ 38 
Ilustración 15 | TI Launchpad ............................................................................. 39 
Ilustración 16 | Módulo Bluetooth ..................................................................... 42 
Ilustración 17 | XBee Serie 1 .............................................................................. 43 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 10 
 
Ilustración 18 | Diagrama de conexiones ........................................................... 56 
Ilustración 19 | Conectores USB ......................................................................... 62 
Ilustración 20 | Líneas de datos .......................................................................... 63 
Ilustración 21 | Cable USB A-B............................................................................ 63 
Ilustración 22 | Proyecto ejecutado en Windows 7 ........................................... 64 
Ilustración 23 | Proyecto ejecutado en Linux Ubuntu 12.04 ............................. 65 
Ilustración 24 | Proyecto ejecutado en Mac OS X Lion ...................................... 65 
Ilustración 25 | Eric IDE ...................................................................................... 66 
Ilustración 26 | Logo Arduino ............................................................................. 74 
Ilustración 27 | Arduino UNO R2 ........................................................................ 75 
Ilustración 28 | ATmega328P ............................................................................. 76 
Ilustración 29 | Interfaz USB-Serie ..................................................................... 79 
Ilustración 30 | Arduino Duemilanove ............................................................... 80 
Ilustración 31 | Arduino UNO ............................................................................. 81 
Ilustración 32 | Arduino Leonardo ..................................................................... 81 
Ilustración 33 | Software Arduino en Windows 7 .............................................. 83 
Ilustración 34 | Botones de verificación y carga ................................................ 83 
 
file:///D:/Dropbox/Universidad/Proyecto%20Tecnica/proyecto.docx%23_Toc329685255
file:///D:/Dropbox/Universidad/Proyecto%20Tecnica/proyecto.docx%23_Toc329685263
file:///D:/Dropbox/Universidad/Proyecto%20Tecnica/proyecto.docx%23_Toc329685265
file:///D:/Dropbox/Universidad/Proyecto%20Tecnica/proyecto.docx%23_Toc329685266
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 11 
 
Í ndice de tablas 
Tabla 1 | Análisis Arduino UNO ......................................................................... 33 
Tabla 2 | Análisis de Pingüino ............................................................................. 34 
Tabla 3 | Análisis chipKIT .................................................................................... 35 
Tabla 4 | Análisis de ST Micro ............................................................................. 37 
Tabla 5 | Análisis de NXP .................................................................................... 38 
Tabla 6 | Análisis de Launchpad ......................................................................... 39 
Tabla 7 | Análisis del puerto paralelo ................................................................. 41 
Tabla 8 | Análisis del puerto serie ...................................................................... 41 
Tabla 9 | Análisis del USB ................................................................................... 42 
Tabla 10 | Análisisdel Bluetooth ........................................................................ 43 
Tabla 11 | Análisis del XBee ................................................................................ 44 
Tabla 12 | Análisis de Firmata ............................................................................ 46 
Tabla 13 | Análisis del protocolo de ArduLab .................................................... 47 
Tabla 14 | Análisis de protocolo propio ............................................................. 48 
Tabla 15 | Análisis de Java .................................................................................. 49 
Tabla 16 | Análisis de Qt ..................................................................................... 50 
Tabla 17 | Análisis de Python ............................................................................. 51 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 12 
 
Tabla 18 | Comparación mensajes MIDI y Firmata ............................................ 58 
Tabla 19 | Características del Arduino UNO ....................................................... 76 
 
 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 13 
 
1. Antecedentes 
El presente proyecto, titulado “Plataforma de experimentación para 
prototipado de diseños mediante Arduino”, surge de las conversaciones mantenidas 
entre D. Eduardo Gallego, principal desarrollador de ArduLab y orientador del aula de 
robótica del C.P. Miguel Hernández de Madrid; D. Carlos Alberto Rodríguez González, 
profesor perteneciente al departamento de Ingeniería Eléctrica de la Universidad de La 
Rioja y D. Santiago Reig Chiva, alumno de Ingeniería Técnica Industrial especialidad en 
Electrónica Industrial de la Universidad de La Rioja, con motivo de la realización del 
proyecto final de carrera de dicho alumno. 
El nombre en clave utilizado para el proyecto es Platex, por lo que en las 
ocasiones en las que aparezca esta palabra, se referirá al proyecto en si. 
Este documento es el resultado de la elaboración del proyecto y se presenta a 
efectos de reconocimiento académico para la obtención del título de Ingeniero Técnico 
Industrial especialidad en Electrónica Industrial. 
 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 14 
 
2. Objetivo del proyecto 
El objetivo de este proyecto es el desarrollo de una solución formada por 
aplicación multiplataforma, garantizando su funcionamiento en Windows, Linux y Mac 
OS, con la que poder manejar la información desde y hacia la placa de interfaz; un 
protocolo de comunicación y una placa de interfaz con el mundo físico. 
Hace dos años apareció ArduLab, un software que combinado con una placa 
Arduino permitía controlar manualmente los periféricos del chip integrado en la placa 
Arduino, por lo que facilitaba las tareas de prototipado al poder cambiar los valores 
lógicos en los pines, leer dichos valores o tensiones de forma analógica, sacar ondas 
PWM y todo esto sin tener que cambiar cables ni programar una línea de código por 
parte del usuario. El problema de este programa es que es de código cerrado y 
programado sobre LabView, por lo que depende también depende de las librerías 
cerradas de éste. La idea inicial fue la de que el programa llegara a la mayor cantidad 
de personas, pero para ello se necesitaba soporte para Windows, Linux y Mac, y 
aunque LabView en las especificaciones proveía ese soporte, a la hora de la realidad no 
se podía preparar el compilar el programa para los sistemas operativos Linux y Mac, 
quedando sólo disponible la versión de Windows. Las actualizaciones de las librerías 
han ido arreglando problemas existentes en el pasado, pero llegan muy lentamente y 
no solucionan el problema de forma completa, por lo que no es viable la dependencia 
que existe sobre éste paquete de software. 
El proyecto surge como respuesta a estos problemas, crear un programa similar 
en funcionamiento para solucionar este problema de dependencia, por lo que se vio la 
necesidad evidente de crear un framework desde cero, implementando desde el 
comienzo el soporte multiplataforma, a partir del cual ir incorporando tanto módulos 
similares a los ya existentes como otros nuevos. También era requisito indispensable 
que fuera de código abierto, para permitir que cualquier persona pudiera modificar, 
adaptar o añadir los cambios que crea necesarios sin tener que depender del 
desarrollador principal en caso de que se tengan los conocimientos necesarios para 
ello. 
Las características del framework deberán cumplir las siguientes 
especificaciones: 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 15 
 
 Placa de interfaz con el mundo físico accesible a todo el mundo y de bajo 
coste. 
 Los periféricos de la placa de interfaz deben incluir al menos los siguientes: 
entradas y salidas digitales, entradas analógicas, salidas de PWM y USART 
para la comunicación con el ordenador. 
 Fácil montaje de la placa de interfaz de manera casera y con componentes 
comunes. 
 Protocolo de comunicaciones simple pero estable. 
 Programa de la interfaz de usuario en el ordenador intuitiva. 
 Fácil inclusión de nuevos módulos al programa. 
 Todas las partes estén bajo licencias libres y sean de código abierto. 
 Multiplataforma: Windows, Linux, Mac OS. 
 
Por todo ello se consideran importantes las siguientes tareas: 
 Estudio del estado del arte sobre sistemas de prototipado similares ya 
existentes. 
 Aprendizaje y uso del entorno de desarrollo integrado Eric, así como del 
lenguaje de programación Python. 
 Análisis del protocolo de comunicaciones Firmata. 
 Aprendizaje y uso tanto entorno de desarrollo integrado Arduino como su 
ecosistema y los lenguajes de programación C y C++. 
 Estudio de la plataforma y programación de los AVR de Atmel. 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 16 
 
 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 17 
 
3. Definiciones 
El vocabulario técnico utilizado a lo largo de este documento es definido para 
su correcta comprensión: 
 Microcontrolador: es un circuito integrado programable, capaz de ejecutar 
órdenes grabadas en su memoria. Está formado por la unidad central de 
procesamiento, memoria y periféricos de entrada y salida. 
 Framework: es un conjunto estandarizado de conceptos, prácticas y 
criterios para enfocar un tipo de problemática particular, que sirve como 
referencia para enfrentar y resolver nuevos problemas de índole similar. 
 Bit: es la unidad mínima de información empleada en informática, capaz de 
representar dos estados, verdadero o falso, activado o desactivado. 
 Byte: unidad de información formada por 8 bits. 
 Core: (núcleo) parte principal de los microcontroladores y 
microprocesadores que se encarga de todo el procesamiento. Está formado 
por los registros, la unidad de control, la unidad aritmético lógica y los 
buses. 
 Compilador: programa informático que traduce el código fuente escrito en 
un lenguaje de programación a otro lenguaje de programación de menor 
nivel, generando un programa equivalente que la máquina sea capaz de 
interpretar. Normalmente al lenguaje al que se compila suele ser a lenguaje 
máquina. 
 Toolchain: (cadena de herramientas) conjunto de herramientas de 
compilación y enlazado, necesarias para transformar el código fuente en un 
programa ejecutable compatible con la plataforma con la que se desarrolla. 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 18 DIP: empaquetado en el que se pueden fabricar los chips, consistente en 
dos filas paralelas de pines distribuidas a lo largo del empaquetado y con 
una separación de 0,1 pulgadas entre ellos. 
 Shield: en el mundo relacionado con Arduino, se refiere a la placa que se 
conecta encima de éste para ampliar sus capacidades tanto de 
procesamiento, como de control o interfaz. 
 Bootloader: porción de código almacenado en una zona especial de la flash 
del microcontrolador que le permite ejecutarse en cada inicio. 
Normalmente es utilizado para poder programar el microcontrolador a 
través del puerto serie en vez de con un programador especializado. 
 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 19 
 
4. Íntroduccio n 
Las herramientas para prototipado han ido apareciendo en el tiempo según se 
iba aumentado el conocimiento existente sobre la física, especialmente en los campos 
de la electricidad y magnetismo. Estas herramientas son vitales tanto para el desarrollo 
de nuevas aplicaciones como para la reparación y revisión del funcionamiento de las ya 
existentes. 
Las herramientas más importantes y versátiles para análisis en la historia han 
sido el voltímetro, procedente del desarrollo de los galvanómetros y el osciloscopio. 
La tecnología ha ido mejorando a lo largo de los años y esto ha permitido crear 
analizadores para magnitudes físicas que no se podían verificar con exactitud o hacerlo 
de una manera más barata, sencilla o cómoda. 
El analizador lógico apareció como el sustituto de los osciloscopios para el 
análisis de circuitos digitales, que permitía tener un gran número de entradas en 
comparación con el primero. 
4.1. El polímetro 
El polímetro es un instrumento eléctrico portátil para medir directamente 
magnitudes eléctricas como pudieran ser tensiones, corrientes o pasivas como 
resistencias, continuidad y otras. Las medidas pueden realizarse para corriente 
continua o alterna. 
Los modelos más avanzados pueden incluir mediciones más avanzadas tales 
como temperatura, normalmente con el uso de termopares, capacidades, 
inductancias, etc. 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 20 
 
 
Ilustración 1 | Polímetro analógico 
 
Ilustración 2 | Polímetro digital 
Los polímetros han sido tradicionalmente analógicos, basados en la tecnología 
del galvanómetro, aunque en las últimas décadas ha desaparecido totalmente del 
mercado en favor de los modelos digitales. 
4.2. Osciloscopio 
Un osciloscopio es un instrumento de medición electrónico para la 
representación gráfica de señales eléctricas que pueden variar en el tiempo. Dada su 
gran versatilidad, se utiliza con asiduidad en electrónica y telecomunicaciones. 
Están clasificados según su funcionamiento interno en analógicos o digitales, 
siendo el resultado mostrado prácticamente iguales, teniendo cada uno sus ventajas y 
desventajas, aunque la tendencia actual es la de adoptar la digital, ya que suelen 
incorporar una mayor cantidad de características comparados con sus similares 
analógicos. 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 21 
 
 
Ilustración 3 | Osciloscopio analógico 
 
Ilustración 4 | Osciloscopio digital 
4.3. Analizador lógico 
Es un instrumento de medida que captura los datos de un circuito digital y los 
muestra para su análisis, de un modo similar a un osciloscopio, como un diagrama de 
tiempos. Pero también existen otras representaciones que pueden ser de más utilidad 
como decodificación de un protocolo que se esté usando, lenguaje ensamblador o 
relacionar el código ensamblador con el código fuente. 
Un analizador lógico, al igual que el osciloscopio, inicia la captura cuando en el 
circuito a analizar se da una determinada condición lógica (entre todos los canales). En 
ese momento se realiza una gran captura de datos del sistema que se está observando, 
para más tarde poder observarlos. 
 
Ilustración 5 | Analizador lógico 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 22 
 
Estos analizadores pueden existir como dispositivos independientes, con sus 
controles, pantallas y demás hardware necesario; como basados en PC, normalmente 
conectados a través de USB o Ethernet y mostrando los datos en el software del 
ordenador, por lo que son más baratos al sólo necesitar el hardware de captura; o 
como está empezando a aparecer, integrados en osciloscopio digitales de alto 
rendimiento, teniendo ambos dispositivos en uno solo. 
4.4. Actualidad 
Actualmente se utilizan todas las herramientas mencionadas anteriormente y la 
práctica totalidad de ellas en las versiones digitales o electrónicas, que poseen una 
funcionalidad mucho mayor a la de sus homólogos analógicos, aunque cuenta con las 
limitaciones de la propia conversión de analógico a digital y al revés, como pueden ser, 
velocidad, resolución, etc. 
 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 23 
 
5. Estudios previos al disen o 
Para definir las características del proyecto final, se han realizado estudios 
previos de las soluciones ya existentes para poder mejorarlas. 
5.1. Estudio de ArduLab 
La única solución similar existente hasta la fecha, ha sido el paquete de 
software ArduLab, también en combinación con una placa Arduino. 
ArduLab ha sido desarrollado por la asociación de robótica educativa 
Complubot, localizada en el C.P. Miguel Hernández de la ciudad de Alcalá de Henares 
en la comunidad autónoma de Madrid. Se puede descargar sin limitaciones desde la 
página del grupo. 
ArduLab es un software similar, salvando las distancias, al realizado en éste 
proyecto. Permite interactuar con una placa Arduino para crear un laboratorio virtual y 
de esta manera, realizar actividades y experimentos. 
Es un programa realizado en LabView, por lo que es necesaria la adquisición de 
una licencia de éste para poder realizar su distribución, también se depende completa 
y únicamente de la empresa desarrolladora para solucionar los fallos existentes en las 
librerías y procesos. 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 24 
 
 
Ilustración 6 | Captura de ArduLab 
Pretendía ser un programa gratuito multiplataforma y se consiguió el primer 
objetivo, pero el segundo no fue todavía terminado, ya sea por fallos en las librerías 
que no permitían que el software funcionara como debiera o en los procesos de 
compilación, por lo que no se podía conseguir siquiera el paquete para distribuir. 
El programa está distribuido bajo una licencia freeware, es decir, se puede 
descargar el programa de forma gratuita y con acceso a toda su funcionalidad de 
forma ilimitada. El código fuente del Arduino fue liberado (aunque sin especificar bajo 
que licencia) y está disponible a cualquiera que se baje su paquete de software, 
mientras que el del propio software nunca ha sido liberado para que la comunidad 
pudiera solucionar posibles fallos existentes o se facilitara la conversión del software a 
una plataforma que permita sin licencias que restrinjan su desarrollo o distribución y 
garanticen en mayor medida la compatibilidad multiplataforma, tal y como se 
pretende en el proyecto de que trata este documento. 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 25 
 
La transmisión entre la placa Arduino y el software se realiza a través del puerto 
serie virtual sobre el protocolo USB y se utiliza un protocolo de comunicación de 
creación propia, que es simple y eficaz, aunque de limitada escalabilidad, no muy 
optimizado y difícilde rescribir para ser utilizado por otras vías de comunicación como 
podría ser Ethernet. 
5.2. Estudio de Bus Pirate 
Bus Pirate es una herramienta que comparte la misma filosofía que este 
proyecto, descubrir el funcionamiento de un dispositivo sin tener que llegar a 
programar una sola línea de código. 
Fue creada por Ian Lesnet mientras era escritor en el blog de noticias de 
electrónica Hackaday, que debido al éxito del proyecto creó la empresa Dangerous 
Prototypes, la cual se ocupa del actual desarrollo de éste proyecto entre otros tantos 
que han ido apareciendo. La evolución del proyecto no es realizada sólo por Ian, si no 
que al tratarse de un proyecto de software y hardware libre, mucha gente colabora 
con su tiempo y código para la mejora de la herramienta en beneficio de toda la 
comunidad de usuarios. 
El hardware de Bus Pirate es un diseño propio basado en la familia de 
microcontroladores PIC, utilizando un chip de la empresa FTDI para realizar la 
conversión de serie a USB y poder conectarlo al PC de una manera sencilla una vez los 
drivers estén instalados correctamente. En futuras revisiones se va a eliminar este chip 
conversor e implementar el stack USB dentro del propio PIC, gracias a unas librerías 
USB que se han desarrollado recientemente y de software libre, que permiten la 
distribución libre del código fuente del proyecto, al contrario de lo que ocurría con las 
librerías propietarias de Microchip. 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 26 
 
 
Ilustración 7 | Bus Pirate v3.6 
BusPirate está más orientado a desarrolladores, ya que sus funcionalidades son 
las siguientes: 
 Interfaz con buses de comunicación 
o 1-Wire 
o I2C 
o SPI 
o Serie 
o JTAG 
o MIDI 
o Teclados de PC 
o Y más 
 Programar microcontroladores 
o PIC 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 27 
 
o AVR 
 Herramienta de depuración de chips ARM 
 Programador de CPLDs 
 Flasheador de ROMs serie 
 Medidor de frecuencia y generador de onda cuadrada 
 Analizador lógico de bajo coste 
 Medidor de voltaje 
 Otras muchas 
Como se podrá apreciar más adelante, comparte muchas funcionalidades con el 
proyecto del que trata este documento, pero el proyecto Bus Pirate está orientado 
más hacia el desarrollador, ya que la interfaz se realiza a través de una consola a través 
del puerto serie, aunque recientemente han ido saliendo interfaces de usuario que 
realizan la comunicación con el Bus Pirate y facilitan el uso de éste. 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 28 
 
 
Ilustración 8 | Usando el Bus Pirate con Putty 
5.3. Estudio de Little Wire 
Little Wire es un proyecto basado en el programador de microcontroladores 
AVR vusbtiny, al que se le añadieron características extras, quedando su funcionalidad 
en: 
 Programación de microcontroladores Atmel AVR 
 Control de pines digitales 
 Control de pines con PWM 
 Manejo de servos 
 Control del módulo I2C 
 Control del módulo SPI 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 29 
 
 Control del módulo UART 
Como se puede ver, es muy similar al Bus Pirate en cuanto a funcionalidad, 
pero su principal diferencia es que la comunicación se realiza a través del protocolo 
USB puro, sin emulación de puerto serie u otras técnicas, y junto con el proyecto se 
desarrollaron librerías con una API basadas en la librería multiplataforma de 
comunicación por USB LibUSB. Estas librerías fueron realizadas en varios lenguajes de 
comunicación tales como C, C++, C#, etc. por lo que le permite a una gran masa de 
desarrolladores utilizar dicha placa sin mayores complicaciones. 
 
Ilustración 9 | Little Wire 
 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 30 
 
6. Ana lisis de soluciones 
La solución ideal será una combinación de placa de interfaz, protocolo de 
comunicaciones y software que congenien de forma que permita realizar el proyecto 
sin una gran inversión de tiempo. 
Al ser un proyecto de software libre, podremos utilizar el trabajo pasado y 
actual de la comunidad de software libre sobre el que construir nuestro proyecto. 
 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 31 
 
6.1. Comparativa de soluciones para la placa de 
interfaz 
Para realizar la interacción entre el software y el mundo físico, lo más sencillo 
es utilizar una placa con un microcontrolador con una cantidad aceptable de pines 
disponibles para nuestro uso, salidas de PWM, temporizadores y entradas analógicas, 
con lo que poder tener un gran abanico de posibilidades de uso. 
Las características que deberán reunir estos componentes para ser objetos del 
estudio, serán las siguientes: 
 Alta disponibilidad en los distribuidores de componentes electrónicos más 
conocidos y presentes alrededor del mundo. 
 Larga vida útil, es decir, que no estén en proceso de ser descatalogados en 
corto plazo, para evitar tener que rescribir o portar el código de la parte de 
hardware a otra plataforma. 
 Precio reducido, incluso en bajas cantidades, con una alta relación 
funcionalidad/precio. 
 Baja cantidad de electrónica adicional necesaria para el funcionamiento del 
microcontrolador, así como su precio, facilitando de esta manera poder se 
replicada de forma a partir de los planos de la placa recomendada. Esto 
facilita el acceso al proyecto en lugares y países en los que el acceso a la 
electrónica está muy limitado. 
 Existencia de placas de desarrollo basadas en el microcontrolador 
analizado, que permitan ser utilizadas junto al proyecto sin realizar grandes 
modificaciones. De esta manera se facilita el acceso al hardware por parte 
de los usuarios finales, ya que no se dependerá de una placa propia 
exclusiva para el proyecto y probablemente tengan mejores precios al estar 
algunas de ellas subvencionadas en parte por los fabricantes. Se valorará su 
alta disponibilidad, precio y diseño abierto. 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 32 
 
6.1.1. Análisis de la plataforma Atmel AVR 
La arquitectura AVR, perteneciente a Atmel, es de 8 bits y fue diseñado desde 
el comienzo para una eficiente ejecución de código C compilado. 
Esta arquitectura ha sufrido un aumento importante en popularidad y 
desarrollos durante estos últimos años debido al lanzamiento de la plataforma 
Arduino, que ha logrado una popularidad sin precedentes. Como consecuencia de 
esto, existen una gran cantidad de documentación, ejemplos de código y comunidad 
de usuarios. 
6.1.1.1. Análisis de Arduino 
Arduino es un conjunto de librerías que facilitan en gran medida el desarrollo 
en la plataforma AVR, que aunque no muy extensamente documentadas debido a su 
simpleza y facilidad de uso, existen innumerables proyectos realizados por sus 
usuarios. 
Arduino también es una sencilla placa de desarrollo, que está actualmente muy 
extendida y puede encontrarse en prácticamente cualquier distribuidor de electrónica 
del mundo, a un precio que ronda los 18 a 26 euros según modelo y distribuidor y 
cuenta además con un diseño libre. La sencillez de esta placa también es uno de sus 
puntos fuertes, ya que permite replicar de forma artesanal la placa con componentes 
disponibles en las tiendas de electrónica. 
 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 33 
 
Ilustración 10 | Arduino UNO 
Una de las ventajas, y la razón por la que Arduino eligió la plataforma AVR, es la 
existenciadel compilador libre basado en GCC denominado avr-gcc. 
Tabla 1 | Análisis Arduino UNO 
Ventajas 
 Toolchain libre y gratuito 
 Gran comunidad de usuarios 
 Cantidad de documentación y ejemplos 
Desventajas 
 Precio 
6.1.2. Análisis de la plataforma Microchip PIC 
Microchip con su familia de microcontroladores PIC ha estado durante años 
liderando el mercado del desarrollo de proyectos personales gracias al programa de 
muestras de Microchip. Sus compiladores y librerías, aunque gratuitos o con límite de 
compilación poseen licencias con cláusulas que dificultan la distribución del código 
fuente en según que casos. 
6.1.2.1. Análisis de Pingüino 
Dado que Arduino está basado en la arquitectura AVR, un grupo de 
desarrolladores se propuso portar las librerías a la arquitectura del PIC, de donde nació 
el proyecto Pingüino. Aunque funcionales, dichas librerías no están totalmente a la 
par, ni tan desarrolladas y probadas como las de Arduino. La plataforma consiguió una 
sólida base de usuarios debido al programa de muestras de Microchip, ya que con 
unos pocos componentes de bajo precio y fácil adquisición era posible montarse una 
placa compatible. 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 34 
 
 
Ilustración 11 | Placa Pingüino 
Tabla 2 | Análisis de Pingüino 
Ventajas 
 Toolchain gratuito 
Desventajas 
 Toolchain no libre 
 Librerías poco desarrolladas 
6.1.2.2. Análisis chipKIT 
chipKit apareció más tarde como una seria alternativa a Arduino en la 
plataforma PIC, en una colaboración entre la propia Microchip y Digilent, portando con 
fiabilidad las librerías de Arduino e intentando mantenerlas a la par con respecto a 
estas. El principal problema es que aunque el entorno de desarrollo, que es el mismo 
que el de Arduino, es libre, el compilador no lo era, ya que seguía usando los 
propietarios ya existentes. Más tarde se liberó parte del compilador para su uso con las 
placas chipKIT, pero algunas librerías seguían siendo propietarias. La gran ventaja es 
que utiliza un microcontrolador de 32 bits, por lo que se nota una gran mejoría en 
trabajos que requieren una gran cantidad de procesamiento con respecto al 
microcontrolador de 8 bits de Arduino. 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 35 
 
 
Ilustración 12 | chipKIT Uno32 
 
 
 
Tabla 3 | Análisis chipKIT 
Ventajas 
 Toolchain gratuito 
 API exactamente igual que la de Arduino 
 Se mantiene la API lo más actualizada posible 
Desventajas 
 Toolchain no libre 
 Pequeña comunidad de usuarios 
6.1.3. Análisis de la plataforma ARM 
Los procesadores de ARM han venido siendo muy competitivos desde siempre 
tanto en precio como en rendimiento, llegando a hacer frente a los existentes 
fabricantes tanto microcontroladores como de microprocesadores que lideran el 
mercado actual. 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 36 
 
La arquitectura Cortex-M ha sido la apuesta de ARM en el segmento de los 
microcontroladores de baja potencia, siendo mucho más potente y eficiente que los ya 
existentes y con un precio muy competitivo. El modelo más adecuado para el proyecto 
sería el ARM Cortex-M0, ya que es el de menor capacidad de procesamiento, que no se 
va a necesitar, pero también el de menor coste. Esta familia dispone de una gran 
cantidad de pines, módulos de comunicación, etc. 
Dicha arquitectura es prácticamente nueva y esto sumando a que ARM licencia 
los cores a distintas empresas fabricantes de electrónica (Texas Instruments, NXP, ST 
Electronics, etc.), crea una gran segmentación, ya que cada fabricante añade los 
periféricos que más les interesa, crea sus propias librerías, etc., siendo la 
documentación de la programación en esta arquitectura y de las librerías de los 
fabricantes algo escasa. También existe una gran variedad de compiladores tanto 
propietarios como de código abierto y todo esto hace que se tenga que estar bastante 
familiarizado tanto como con la arquitectura ARM como con las librerías y periféricos 
propios de cada fabricante. 
Otro problema es que los chips con este núcleo casi siempre están a la venta 
con empaquetado de montaje superficial, por lo que dificulta su montaje si no se tiene 
los conocimientos necesarios, aunque actualmente están empezando a aparecer las 
primeras versiones con empaquetado en tipo DIP. 
6.1.3.1. Análisis de ST Micro 
ST Micro tiene disponible una gama de placas de evaluación de los 
microcontroladores ARM que ellos fabrican, es llamada Discovery. Son placas de bajo 
coste que incluyen un microcontrolador, un programador y algún periférico extra, todo 
en una misma placa, con los pines fácilmente accesibles y programable por USB. Se 
disponen de varios de modelos con la familia Cortex-M de ARM, que sería la más 
indicada para el proyecto. 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 37 
 
 
Ilustración 13 | STM32 Discovery 
Se dispone tanto de compilador propietario como la versión gratuita y de 
código abierto de GCC. 
Tabla 4 | Análisis de ST Micro 
Ventajas 
 Toolchain gratuito y libre 
 Programador compatible con opciones libres 
 Alta velocidad de procesamiento 
Desventajas 
 Pines de conexión por el lado inferior de la placa 
6.1.3.2. Análisis de NXP 
NXP es la Antigua división de electrónica de Philips, que también se introdujo 
en el mercado de los microcontroladores de bajo coste y consumo y alto rendimiento 
con una familia basada en ARM. Dispone de placas de evaluación de bajo coste basada 
en microcontroladores de la familia ARM Cortex-M con el programador y 
microcontrolador en una misma placa y comunicación con el entorno de desarrollo a 
través de USB o JTAG, según se prefiera. 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 38 
 
 
Ilustración 14 | LPCXPRESSO con ARM Cortex-M0 
Tabla 5 | Análisis de NXP 
Ventajas 
 Toolchain gratuito y libre 
 Alta velocidad de procesamiento 
Desventajas 
 Precio 
Se dispone tanto de compilador propietario como la versión gratuita y de 
código abierto de GCC. 
6.1.4. Análisis de la plataforma de Texas Instruments 
MSP430 
El MSP430 es una familia de controladores producidos por Texas Instruments 
con una arquitectura de 16 bits, pero con un precio a la par con sus competidores de 8 
bits. 
También existe un grupo de usuarios en esta plataforma para portar las 
librerías de Arduino o una simplificación/aproximación de ellas, pero debido al bajo 
número de desarrolladores implicados en el proyecto, no están muy completas. 
6.1.4.1. Análisis de Launchpad 
Esta familia es interesante debido a que tiene una placa de desarrollo 
denominada Launchpad, realizada por la misma TI, que cumpliría con los requisitos del 
proyecto y a un precio extremadamente competitivo. 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 39 
 
La principal desventaja es que los chips básicos de esta familia no suelen tener 
módulo hardware de UART, por lo que habría que implementarlo por software. 
 
Ilustración 15 | TI Launchpad 
Aunque el fabricante nos recomienda utilizar unos compiladores propietarios, 
también existe una versión libre basada en GCC denominada mspgcc. 
Tabla 6 | Análisis de Launchpad 
Ventajas 
 Toolchain gratuito y libre 
 Precio 
Desventajas 
 Pocas librerías 
 Dificultad de desarrollo 
 Ausencia de USART en el microcontrolador provisto 
 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 40 
 
6.2. Comparativa de soluciones para el medio de 
comunicaciónPara realizar el intercambio de información y datos entre el software en el 
ordenador y la placa de interfaz con el mundo físico, es necesario realizarlo a través de 
un medio de comunicación. 
La velocidad de transmisión, así como su ancho de banda, no serán altos, que 
aunque esto viene determinado principalmente por el protocolo, suele estar 
directamente relacionado con el medio de transmisión. Esto nos permite poder 
seleccionar un amplio abanico de soluciones simples, muy maduras y altamente 
compatibles con los ordenadores. 
Los que se han estudiado para su posible implantación en el proyecto, han sido 
los siguientes: 
6.2.1. Análisis del puerto paralelo 
El puerto paralelo nos podría servir de interfaz entre el mundo virtual y real, ya 
que podemos controlar las tensiones en los pines de éste y tenemos pines que pueden 
ser configurados como salida pero también como entrada. 
La desventaja es que no existe manera de realizar lecturas de tensiones de 
forma analógica y debido a que los sistemas operativos comunes no son en tiempo 
real, tampoco se podría realizar PWM en los pines de forma eficaz y consistente a lo 
largo del tiempo. Estas deficiencias pueden ser suplidas con la ayuda de circuitería 
externa, pero debiendo de poner casi obligatoriamente un microcontrolador, es 
mucho más eficiente y cómodo trabajar por el puerto serie. 
Otro problema existente es que cada vez es más difícil que un ordenador que 
disponga de un puerto paralelo, siendo hoy en día casi imposible encontrar uno. 
 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 41 
 
Tabla 7 | Análisis del puerto paralelo 
Ventajas 
 Posibilidad de usarlo directamente para realizar la interfaz con el mundo físico 
Desventajas 
 Los sistemas operativos no suelen trabajar en tiempo real 
 Difícil de encontrar en equipos nuevos 
6.2.2. Análisis del puerto serie 
El puerto serie es un estándar de comunicación simple y con una gran madurez, 
por lo que no suele ser difícil realizar una comunicación a través de éste. También 
tiene la ventaja de que un gran abanico de microcontroladores, incluso los de bajo 
precio y prestaciones, suelen tener un módulo hardware, que trabaja 
independientemente del núcleo, dedicado a las comunicaciones por este medio, 
facilitando en gran medida el funcionamiento de cara al implementador. 
Aunque al igual que el puerto paralelo cada vez es más difícil encontrar dicha 
interfaz en ordenadores nuevos, aunque debido a su gran versatilidad y utilidad 
todavía siguen apareciendo en ordenadores de sobremesa, pero prácticamente 
desaparecido en los ordenadores portátiles. De todas maneras, debido a esta 
desaparición, fomentada en gran medida por la aparición del puerto USB, se han 
creado chips que traducen el protocolo serie desde el microcontrolador y lo 
empaquetan a través del USB, mostrando luego al ordenador un puerto serie virtual a 
través del cual se realiza la conexión. 
Tabla 8 | Análisis del puerto serie 
Ventajas 
 Suficientemente rápido 
 Buena inmunidad al ruido 
 Barato de implementar 
 Muy utilizado y sencillo de trabajar 
Desventajas 
 Difícil de encontrar en nuevos equipos 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 42 
 
6.2.3. Análisis del USB 
Cada vez es más común ver pequeños microcontroladores de bajo coste con 
módulos hardware de comunicación por USB, aunque suelen duplicar su precio con 
respecto a sus homólogos sin este módulo. También han ido apareciendo librerías que 
implementan la funcionalidad USB en software mediante bit banging, pero a costa de 
largos tiempos de procesamiento e interrupciones que deben ser atendidas lo más 
rápido posible. 
Tabla 9 | Análisis del USB 
Ventajas 
 Muy rápido 
 Buena inmunidad al ruido 
 Muy versátil 
 Corrección de errores 
Desventajas 
 Encarece el microcontrolador 
6.2.4. Análisis del Bluetooth 
Es un canal de comunicación inalámbrico de corto alcance (menos a 100 metros 
en el mejor de los casos), pero con velocidades similares a la del puerto serie, que 
permite realizar una conexión entre dos dispositivos. Su bajo coste y orientación al uso 
por el consumidor, le ha permitido situarse como el medio de comunicación entre 
dispositivos móviles. 
 
Ilustración 16 | Módulo Bluetooth 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 43 
 
Durante los últimos años se ha producido una reducción enorme del coste de 
implantación de este protocolo, siendo incluido cada vez más en proyectos de bajo 
coste y comercialización. 
Los módems Bluetooth tienen una interfaz por la que configurarlos y 
comunicarse a través de ellos basada en el puerto serie, por lo que podrían reemplazar 
el cable del puerto serie sin grandes modificaciones del código. 
Tabla 10 | Análisis del Bluetooth 
Ventajas 
 Inalámbrico 
 Velocidad similar al puerto serie 
 Fácil de implementar 
Desventajas 
 Poca potencia de transmisión 
 No muy fiable y consistente a largo plazo 
6.2.5. Análisis del XBee 
Los dispositivos XBee, basados en la tecnología ZigBee, disponen de un stack 
con añadidos que les permite realizar una función similar a la del bluetooth pero con 
algunas diferencias: un menor consumo, la posibilidad de realizar redes de conexión 
avanzadas como en malla y una mayor distancia, aunque a una velocidad menor. 
 
Ilustración 17 | XBee Serie 1 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 44 
 
Dependiendo del modelo escogido, podríamos llegar a alcanzar incluso decenas 
de kilómetros. 
Tabla 11 | Análisis del XBee 
Ventajas 
 Largas distancias de comunicación 
 Corrección de errores 
 Fácil de implementar 
Desventajas 
 Precio 
6.2.6. Otras soluciones 
Existen otros muchos protocolos por los que se podría realizar la comunicación 
entre la placa de interfaz física y el ordenador con el software, tales como 
radiofrecuencia, WiFi, Ethernet, GSM y cualquier otro para el que exista una puerta de 
enlace que haga de traductora entre ambos protocolos. 
 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 45 
 
6.3. Comparativa de soluciones para el protocolo 
de comunicaciones 
El protocolo de comunicaciones será el encargado de definir como se transmite 
toda la información relativa a la configuración de la placa y el estado de ésta entre ésta 
y el ordenador con el software. 
La cantidad de información va a ser muy baja durante la mayor parte del 
tiempo, por lo que un protocolo sencillo de implementar, que funcione a través de un 
medio de bajo coste y sea de bajo ancho de banda para facilitar su portabilidad e 
implantación. Además que cuanto menor sean estos requerimientos, menor coste 
tendrá la placa de interfaz que se necesite para utilizar junto al software del proyecto. 
6.3.1. Análisis de Firmata 
Firmata es un protocolo de comunicación genérico para controlar los 
periféricos de un microcontrolador desde un software en un ordenador. Está diseñado 
para ser incluido en cualquier software, ya que es de sencilla implementación. 
Firmata está centrado principalmente en realizar el intercambio de información 
a través del puerto serie y codificado en binario en vez de en ASCII como puede ocurrir 
con otros, por lo que se aumenta bastante la cantidad de información posible de 
transmitir en un solo paquete. 
Éste protocolo esta desarrollado alrededor del ecosistema de Arduino, 
pensando en las capacidades de estas placas. De hecho, junto a las distribuciones del 
software de Arduino viene el firmware con la versión más actualizada del protocolo 
listo para ser incorporado en las placas. Este firmware soporta las placas Arduino tantoUno, Duemilanove, Diecimila como las Mega. 
El protocolo guarda una estrecha relación con el protocolo MIDI, ya que ha sido 
su referencia desde casi la primera versión, cuando se rescribió el código para hacerse 
compatible con éste. 
Las principales funciones que están implementadas en el protocolo en la actual 
versión 2.2, son las siguientes: 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 46 
 
 Configurar los pines: entrada, salida. 
 Lectura estado de los pines: alto, bajo. 
 Lectura entradas analógicas (con control de velocidad de muestreo). 
 PWM. 
 Control de servomotores. 
 I2C. 
La licencia de las librerías de Firmata, así como de su implementación en el 
firmware en la versión de Arduino, son libres, por lo que se podrán utilizar sin 
problemas para el proyecto y al disponer del código fuente, se pueden realizar 
modificaciones a éste para arreglar fallos de programación o añadir funcionalidades 
que no existían. 
Al estar incluido en el software de Arduino, el protocolo es usado por infinidad 
de personas en cantidad de aplicaciones distintas, que demuestran la diversidad de 
aplicaciones que puede tener el protocolo y confirman su estabilidad. Su desarrollo 
también es continuo, con un flujo constante de ideas y mejoras que poco a poco se van 
implementando. 
Tabla 12 | Análisis de Firmata 
Ventajas 
 Ya implementado 
 Comunidad de usuarios 
 Desarrolladores activos 
 Protocolo libre y gratuito 
Desventajas 
 Ninguna 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 47 
 
6.3.2. Análisis del protocolo de ArduLab 
El paquete de software de ArduLab viene implementado con un protocolo de 
comunicaciones propio, que en el fondo no difiere mucho de Firmata y con unas 
funciones muy similares a éste último. 
No es el más adecuado, ya que aunque es muy simple en su implementación, 
limita su escalabilidad y no es lo suficientemente conocido en la comunidad tanto de 
usuario como de desarrolladores para que siga el desarrollo del protocolo por su 
propia inercia. 
Tabla 13 | Análisis del protocolo de ArduLab 
Ventajas 
 Ya implementado 
 Sencillo 
Desventajas 
 No muy escalable 
6.3.3. Análisis para la creación de un protocolo propio 
La alternativa a utilizar los protocolos ya existentes, sería realizar un protocolo 
propio, en el que se implementaran las capacidades exactas que se vayan a utilizar y 
según se vayan necesitando. 
Teniendo en cuenta que Firmata es un protocolo muy similar a lo que se 
acabaría diseñando una vez avance el protocolo y ya dispone de muchas de las 
optimizaciones que se le pueden realizar para mejorar su desempeño. Por lo que lo 
más razonable en el caso de querer implementar un protocolo propio sería, tomar 
como base el protocolo de Firmata, eliminar lo que no se necesite o interfiera en lo 
planificado y desarrollar a partir de ahí. 
 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 48 
 
Tabla 14 | Análisis de protocolo propio 
Ventajas 
 Totalmente adaptado a las necesidades 
Desventajas 
 Tiempo de desarrollo 
6.4. Comparativa de soluciones para el lenguaje 
de programación 
La elección del lenguaje de programación es posiblemente la que va a influir en 
mayor medida durante el desarrollo del proyecto, por lo que habrá que seleccionarlo 
tras un buen análisis de las opciones existentes. 
En este análisis solo se tendrán en cuenta los lenguajes de programación para 
la parte de software que funcionará en el lado del ordenador, la parte de 
programación en la placa de interfaz será con una muy alta probabilidad C o C++, 
debido a la capacidad de proceso y almacenamiento de estos dispositivos. 
El lenguaje deberá ser multiplataforma, sin tener que realizar grandes cambios 
en el código para tener que conseguirlo, ser un lenguaje conocido y estable y que el 
desarrollo con él sea simple y versátil, con el que poder realizar todas las 
funcionalidades del proyecto que se nos ocurran. Al deber ser multiplataforma la parte 
de software, se descartarán de entrada la familia de lenguajes Visual y .NET de 
Microsoft. 
6.4.1. Análisis de Java 
Es un lenguaje orientado a objetos, toma mucha de la sintaxis de C++, pero con 
un modelo de objetos más simples, eliminando las herramientas de bajo nivel tales 
como la manipulación directa de punteros y memoria, que solían inducir a error. 
Al contrario de muchos lenguajes, Java se compila a bytecode pudiéndose 
también compilar también a código máquina, pero estos suele realizarse por el 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 49 
 
intérprete en tiempo real desde el código en bytecode, que permite ejecutarse en 
cualquier plataforma que tenga el intérprete adecuado. 
La principal desventaja es la antigüedad de la interfaz de usuario disponible con 
y prácticamente sin actualizaciones en los últimos años, siendo esta además un 
compleja para el desarrollo, que sigue los estilos de programación del momento en el 
que se lanzó. 
Tabla 15 | Análisis de Java 
Ventajas 
 Gran comunidad de usuarios 
 Gran cantidad de ejemplos 
 Elimina las complejidades de C++ 
Desventajas 
 Librería para interfaces de usuario incluida muy antigua 
6.4.2. Análisis de Qt 
Está basado en C++ y su punto fuerte es la capa de abstracción que han creado 
encima de este para añadir características multiplataforma, tanto de escritorio como 
móviles (Windows, Linux, Mac OS, Symbian, and Maemo), incluye librerías para 
desarrollar interfaces de usuario con ventanas y está acompañado por una gran 
cantidad de herramientas potentes y una extensa y bien organizada documentación. 
Hace una temporada tuvo un futuro incierto, ya que éste lenguaje de 
programación pertenece a Nokia, que no pasó por unos años muy buenos y su 
existencia peligraba, pero hace poco decidieron liberar el lenguaje de programación 
con sus librerías, por lo que se asienta su futuro; habiendo aparecido durante el 
desarrollo de este proyecto de una revisión menor y la casi finalización de una revisión 
mayor. 
 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 50 
 
Tabla 16 | Análisis de Qt 
Ventajas 
 Basado en C++ 
 Gran calidad de la documentación 
 Herramientas de desarrollo muy completas e integradas 
 Librerías para interfaces de usuario de gran calidad 
Desventajas 
 Futuro algo incierto 
6.4.3. Análisis de Python 
Es un lenguaje de alto nivel y de propósito general, cuya filosofía se centra en la 
legibilidad, notable potencia y una muy clara sintaxis, con una biblioteca estándar 
grande y completa. 
Python es un lenguaje ideal tanto para realizar programas prototipo como para 
programas finales, ya que aunque es interpretado, los ordenadores hoy en día son lo 
suficientemente potentes como para poder con esta sobrecarga. La ventaja es que se 
pueden probar trozos de código directamente en la consola de ejecución para su 
prueba, pero con la desventaja de que los fallos de programación no aparecen hasta 
que el intérprete ejecuta la instrucción errónea, pudiendo pasarse por alto en las 
revisiones de código. 
Al igual que Java, Python es interpretado y también puede ser compilado a 
bytecode, aunque no a código máquina, pero si que puede ser ejecutado con el código 
fuente, realizando el propio intérprete la compilación a bytecode antes de ejecutarlo. 
Python viene por defecto con la librería de Tk para realizar interfaces de 
ventanas, aunque su uso es complicado y su apariencia deja bastante de desear. Este 
problema se compensa debido a la existencia de librerías que enlazan con proyectos 
como Qt, wxWidgets o GTK+, con una excelente aparienciay mayor facilidad de uso. 
Uno de los problemas es que la creación de paquetes de distribución en Python 
no está muy documentada, por lo que en principio se hace casi imprescindible el uso 
de librerías que facilitan su uso, pero no son todo lo completas que se desearían. 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 51 
 
Tabla 17 | Análisis de Python 
Ventajas 
 Sencillez de desarrollo 
 Cantidad de librerías 
 Gran comunidad de usurarios 
Desventajas 
 Librería para interfaces de usuario incluida muy antigua 
 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 52 
 
7. Descripcio n de la solucio n 
adoptada 
7.1. Descripción de la placa de interfaz adoptada 
En el proyecto utilizaremos la placa Arduino, por su alta disponibilidad y 
cantidad de documentación disponible. Es una placa con entradas y salidas digitales y 
salidas de PWM, entradas analógicas, pudiendo conectarla a una gran cantidad de 
periféricos como leds, sensores resistivos o de voltaje, servomotores, dimmers, etc. 
Al estar todo lo que necesitamos de esa plataforma (hardware, librerías, 
compilador y protocolo) bajo una licencia libre, se podrá utilizar sin problemas en el 
desarrollo del proyecto. 
Una de las principales ventajas es que el firmware del protocolo Firmata viene 
ya implementado y probado, por lo que se puede centrar todo el esfuerzo en el 
desarrollo de la parte de la interfaz de usuario. 
7.2. Descripción del medio de comunicación 
adoptado 
Debido a que la placa Arduino posee un puerto USB por el que es posible 
realizar una comunicación serie, se utilizará este medio de comunicación. Además el 
USB es un estándar implementado en prácticamente cualquier ordenador en su 
versión 2.0 desde hace más de una década, por lo que se asegura una compatibilidad 
prácticamente total. 
Al estar la comunicación serie encapsulada en el protocolo USB, se pueden 
llegar a utilizar velocidades mucho mayores que a través del tradicional puerto serie. 
La única desventaja es la necesidad de instalar los drivers USB en la plataforma 
Windows al conectar por primera vez una placa Arduino para realizar la comunicación, 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 53 
 
pero debido a la gran cantidad de documentación existente sobre este tema y su 
sencillez no se tendrá en cuenta como un problema mayor. 
De todas maneras, se podrá utilizar cualquier solución de comunicación que sea 
invisible para el Arduino, tales como Bluetooth, XBee, puerto serie y otros muchos con 
el hardware y software adecuado, sin necesidad de cambiar una sola línea de código 
del firmware contenido en el Arduino. 
7.3. Descripción del protocolo de comunicación 
adoptado 
El protocolo utilizado para la comunicación será Firmata, ya que al estar 
bastante asentado y probado para este tipo de uso, con una base de datos y lista de 
correo para solucionar los problemas durante su uso o implementación, no tiene 
sentido implementar un protocolo dedicado para este proyecto cuando su 
funcionamiento sería similar en un 90%. 
Su evolución es constante y con visos a dar compatibilidad a los nuevos 
modelos de Arduino, también a hacer las adaptaciones correspondientes para permitir 
ser utilizado a través de Ethernet u otros medios de comunicación. 
7.4. Descripción del lenguaje adoptado 
Python ha sido el lenguaje escogido para la programación de la interfaz de 
usuario, ya que es multiplataforma y permite un desarrollo rápido de aplicaciones. 
Para suplir las deficiencias de la librería estándar de Python se hará uso de las 
siguientes librerías adicionales: 
 PyQt: para la parte de interfaz de usuario se usarán las librerías de Qt para 
Python, por lo que también se tendrá a disposición todo el poder de este 
lenguaje, tanto con los tipos de datos como la creación de interfaces de 
usuario, todo ello también compatible con cualquier plataforma. Qt tiene 
una interfaz de usuario multiplataforma que imita muy bien la apariencia de 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 54 
 
las aplicaciones nativas, por lo que el usuario se sentirá familiar con la 
forma de ésta, dejando también la opción al desarrollador de modificarlo a 
su gusto. 
 PyQwt: es una librería que añade elementos gráficos científicos tales como 
gráficas, sliders con medida, etc. Se basa en la librería Qwt desarrollada 
para Qt. 
 PySerial: librería que se ocupa de las comunicaciones desde Python con el 
puerto serie, ya sea real o virtual (a través de USB). Su interfaz es muy 
simple y de fácil uso. 
 PyFirmata: se encarga del protocolo de comunicación y en conjunción con 
PySerial, realiza la transmisión de datos con la placa de interfaz mediante el 
protocolo Firmata a través del puerto serie. No es una librería muy común, 
por lo que presenta algunos fallos que tuvieron que ser solucionados. 
 cx_Freeze: una vez terminado el proyecto debe ser empaquetado para su 
distribución de forma sencilla por los usuarios. Al ser la interfaz de 
empaquetamiento de Python un poco compleja, esta librería hace de 
intermediario facilitando su uso. Nos permite crear instaladores para 
cualquiera de las plataformas más conocidas. 
Tanto el lenguaje de programación, como las librerías listadas anteriormente 
son de uso sin restricciones para proyectos de código abierto, por lo que no se tendrá 
ningún problema en este sentido. 
 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 55 
 
8. Desarrollo 
8.1. Diseño general 
Una vez ya conocidas las tecnologías a utilizar en el proyecto, conocemos 
cuales van a ser las características y límites que nos vamos a encontrar. El proyecto va 
a constar de cuatro partes diferenciadas, las cuales son: 
 Aplicación software: es el centro de control de los periféricos de la placa a 
la que está conectado. Se comunica con la placa para configurarla según se 
ha indicado por el usuario y muestra la información recibida de la placa de 
forma visual en la pantalla. Se desarrollará en Python y Qt con 
compatibilidad multiplataforma. 
 Interfaz USB-serie: es el encargado de convertir la señal USB procedente 
del PC a serie estándar. Este conversor existe en la propia placa Arduino, 
que en las placas antiguas es un FTDI FT2332 y en las nuevas versiones un 
ATmega 16u2. Como se ha comentado anteriormente, la comunicación 
también puede realizarse por muchos otros medios adecuados para el uso. 
 Arduino: interpreta los comandos recibidos por el puerto serie, realizando 
las tareas adecuadas e informando al PC de los cambios que se han 
producido en la placa. 
 Alimentación: si no se van a conectar grandes cargas al Arduino que 
superen los 500mA, se podrá usar la alimentación procedente del USB (en 
el caso que lo tengamos conectado a éste), si no, se utilizará un 
transformador conectado a la toma de red que nos provea de una tensión 
continua de 5 a 9V y se enchufará al conector provisto para esto. 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 56 
 
 
Ilustración 18 | Diagrama de conexiones 
8.2. Análisis del protocolo Firmata 
8.2.1. Introducción 
Firmata es un protocolo de comunicación entre un ordenador y un 
microcontrolador que apareció en los inicios de la historia de Arduino, por lo que las 
características de este protocolo están muy centradas en las capacidades del Arduino. 
Es un protocolo de comunicación genérico para controlar los periféricos de un 
microcontrolador desde un software en un ordenador. Está diseñado para ser incluido 
en cualquier software y hardware, ya que es de sencilla implementación.Éste protocolo soporta las placas Arduino tanto Uno, Duemilanove, Diecimila 
como las Mega, aunque en el proyecto se ha decidido soportar la placa más común y 
utilizada que es la Uno. 
Firmata realiza el intercambio de información a través del puerto serie y 
codificado en binario en vez de en ASCII como puede ocurrir con otros, por lo que se 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 57 
 
aumenta bastante la cantidad de información posible de transmitir en un solo 
paquete. 
Con las distribuciones del software de Arduino, se adjunta una copia del 
firmware de Firmata para las placas Arduino, que implementa el protocolo y nos 
permite realizar las siguientes acciones: 
 Configurar los pines: entrada, salida 
 Lectura estado de los pines: alto, bajo 
 Lectura entradas analógicas (con control de velocidad de muestreo) 
 PWM 
 Control de servomotores 
 I2C 
8.2.2. Descripción del protocolo 
Durante la realización del protocolo, los creadores vieron que era similar al 
existente MIDI, por lo que lo modificaron para hacerlo totalmente compatible con 
este, que aunque no es directamente usable con controladores MIDI, puede coexistir 
con MIDI sin problemas y ser tratado por intérpretes MIDI sin problemas, aunque 
algunos datos de los mensajes son utilizados de forma diferente al estándar. 
8.2.2.1. Mensajes 
El protocolo está formado por mensajes, que consisten en una serie de 8 bits. 
Cada mensaje tiene su función asignada. Algunos mensajes consisten en un solo byte, 
mientras que otros pueden llegar a tener 2 ó 3 bytes. También existe un mensaje con 
el que poder enviar un número ilimitado de bytes. Algo que todos los mensajes tienen 
en común es que el primer byte del mensaje es el de estado, que es especial ya que es 
el único que tiene el bit 7 activado, mientras que los siguientes bytes del mensaje no lo 
tienen activado, de ésta manera se puede detectar siempre el inicio de un mensaje. Se 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 58 
 
puede deducir entonces que los bytes de estado están en el rango 0x80÷0xFF, por lo 
que el número de éstos está limitado a 127 y el resto de los bytes del mensaje, los de 
datos si es que existen, estarán en el rango 0x00÷0x7F. 
Tabla 18 | Comparación mensajes MIDI y Firmata 
Comando Significado Parámetros Parámetro 1 Parámetro 2 
MIDI 
0x90 Activar nota 2 nota fuerza 
Firmata 
0x90 I/O digital 2 LSB (bits 0÷6) MSB (bits 7÷13) 
8.2.3. Descripción de la comunicación 
El firmware de Firmata para las placas Arduino, realiza la comunicación por la 
USART de éste, por lo que abre un gran abanico de posibilidades de comunicación a 
través de diversos medios. 
En el caso más común, se realizaría la conexión al PC utilizando el propio 
conversor serie-USB disponible en la propia placa Arduino, también podría conectarse 
al puerto serie del PC usando un adaptador de niveles serie de TTL a RS-232, que 
permitiría distanciar la placa del PC decenas de metros gracias a la robustez del medio 
de transmisión. En caso de disponer de los conversores adecuados y desear la 
comunicación de esta manera, puede realizarse a través de redes XBee, Bluetooth, 
radiofrecuencia, Ethernet, Internet y otros muchos. 
La comunicación es bidireccional ya que la placa necesita enviar al PC su estado 
(lecturas digitales y analógicas, estado de los pines, etc.) y el PC enviar los comandos 
necesarios para configurar la placa según requiera el usuario del software; y si el 
medio lo permite (en la implementación en Arduino se puede) será una comunicación 
totalmente full-duplex. 
Las transferencias se realizan en paquetes de 1 byte, utilizándose los 7 bits de 
menos peso para datos y el octavo para indicar si es un comando. Los mensajes están 
formados por una cantidad de 1 a 3 bytes según sea, pero en el caso de que 
necesitemos enviar una mayor cantidad de información puede extenderse a cualquier 
longitud utilizando el comando SysEx. 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 59 
 
La configuración de la comunicación serie por defecto se realiza a 57600 
baudios, con 8 bits de trama, 1 bit de parada y sin control de paridad o flujo, aunque al 
realizarse la transmisión por USB puede llegarse a sobrepasar el millón de baudios en 
el caso de ser estrictamente necesario. 
El paquete de transmisión se compone de: 
1. Idle: en ausencia de comunicación, la línea tendrá una señal mantenida a 
nivel alto (break). 
2. Inicio: antes de recibir la trama de información, se transmitirá un bit a nivel 
bajo (space) para indicar la transmisión de la trama. 
3. Trama: información que recibirá la placa o el PC (suponemos que se recibe 
primero el bit de mayor nivel). Está compuesta por 8 bits, divididos en dos 
partes. 
1. Bit de comando: si el bit está activo (break), indica que el byte 
recibido es un comando y deberá ser tratado como tal, si no, será 
información. Este bit debe estar siempre activo en el primer byte de 
un mensaje. 
2. Información: los 7 bits restantes son el comando o los datos 
transferidos, según se haya recibido el bit de comando. 
4. Bit de stop: al finalizar la trama se transmitirá un bit de stop a nivel alto 
(break). 
Después de esto pueden ocurrir dos cosas, o se deja de recibir/transmitir y la 
línea se deja a nivel alto (break) o se vuelve a transmitir otro byte en el caso de 
mensajes de 2 o más bytes, por lo que se volverá a comenzar en el punto número 1. 
 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 60 
 
La plantilla para interpretar una transmisión sería la siguiente: 
 
 
 
 
 
 
 
 
 
8.2.4. Mejoras en la implementación del protocolo 
El firmware de Firmata para Arduino (en su actual versión 2.2 en el momento 
de realizar éste documento) al inicializar los pines de éste, los configura como salida y 
a nivel alto, cosa que puede ser peligrosa para mantener la integridad de la placa 
Arduino a largo plazo, ya que si se conecta el cable de salida de un sensor o ya se tiene 
conectado uno a la hora de encender la placa, probablemente este sensor no tenga la 
salida a 5V, por lo que se producirá un cortocircuito, estresando el pin provocando una 
degradación prematura del silicio que en el caso extremo podría llegar a su 
inutilización, pudiendo también afectar al sensor o circuito conectado. 
Gracias a que este firmware es de código abierto, se procedió a añadir un 
nuevo modo en el que los pines estuvieran como entrada y a nivel bajo y se hizo que 
todos los pines se configuraran a este modo al inicio del programa o cuando se deje de 
utilizar un pin, dando una solución adecuada al anterior problema. 
Trama 
Idle o 
segundo byte 
Mensaje 
Bits de datos 
Plataforma de experimentación para prototipado de diseños mediante Arduino 
 
Santiago Reig Chiva Memoria 
 Página 61 
 
También se modificó el orden de inicio de las funciones de Firmata, ya que 
según estaba implementado, se necesitaba alrededor de dos segundos como mínimo 
de espera hasta poder realizar la conexión de la placa. 
8.2.5. Descripción de la capa física 
La capa física no viene definida por el protocolo, aunque indirectamente se 
prevé que por su campo de aplicación en microcontroladores sea la transmisión 
mediante transmisión serie asíncrona (USART) a niveles de tensión TTL a 5V en la 
mayoría de los casos y a 3.3V en una minoría, que es como viene diseñado el protocolo 
por defecto. Aunque como se ha comentado anteriormente, el protocolo puede ser 
transmitido por cualquier medio siempre que se tengan las herramientas y 
conocimientos necesarios para ello, ya que en el caso de la implementación en 
Arduino, la capa de procesamiento del protocolo está completamente