Prototipado de Disenos Con Arduino PDF

TRABAJO FIN DE ESTUDIOS
PROYECTO FIN DE CARRERA
Plataforma de experimentacin para prototipado de

diseos mediante Arduino
Santiago Reig Chiva
Tutor: Carlos Alberto Rodrguez Gonzlez

Curso 2011-2012
Plataforma de experimentacin para prototipado de diseos mediante

Arduino, trabajo fin de estudios
de Santiago Reig Chiva, dirigido por Carlos Alberto Rodrguez Gonzlez (publicado por la
Universidad de La Rioja), se difunde bajo una Licencia
Creative Commons Reconocimiento-NoComercial-SinObraDerivada 3.0 Unported.
Permisos que vayan ms all de lo cubierto por esta licencia pueden solicitarse a los
titulares del copyright.
El autor
Universidad de La Rioja, Servicio de Publicaciones, 2012
publicaciones.unirioja.es
E-mail: publicaciones@unirioja.es
PLATAFORMA DE EXPERIMENTACIN PARA

PROTOTIPADO DE DISEOS MEDIANTE ARDUINO
Peticionario:
Universidad de La Rioja
rea de proyectos de ingeniera
Informante:
Santiago Reig Chiva

Alumno de I.T.I. Electrnica Industrial
Universidad de La Rioja
Director:
Carlos Alberto Rodrguez Gonzlez

Departamento de Ingeniera Elctrica
Lugar y fecha:
Logroo, 20 de julio de 2012
Plataforma de experimentacin para prototipado de diseos mediante Arduino

Santiago Reig Chiva
ndice
ndice
Memoria ............................................................................................. 3
Anexos ..............................................................................................85
Pliego de condiciones ............................................................... 166
Planos ............................................................................................ 183
Presupuesto ................................................................................. 185
Bibliografa .................................................................................. 195
Pgina 2
MEMORIA
DOCUMENTO N 1

Santiago Reig Chiva
Memoria
ndice de la memoria
1.
Antecedentes............................................................................................ 13
2.
Objetivo del proyecto ............................................................................... 14
3.
Definiciones .............................................................................................. 17
4.
Introduccin ............................................................................................. 19
4.1.
El polmetro .............................................................................................. 19
4.2.
Osciloscopio .............................................................................................. 20
4.3.
Analizador lgico ...................................................................................... 21
4.4.
Actualidad ................................................................................................. 22
5.
Estudios previos al diseo ........................................................................ 23
5.1.
Estudio de ArduLab................................................................................... 23
5.2.
Estudio de Bus Pirate ................................................................................ 25
5.3.
Estudio de Little Wire ............................................................................... 28
6.
Anlisis de soluciones ............................................................................... 30
6.1.
Comparativa de soluciones para la placa de interfaz ............................... 31
6.1.1.
Anlisis de la plataforma Atmel AVR................................................. 32
6.1.1.1. Anlisis de Arduino ...................................................................... 32

6.1.2.
Anlisis de la plataforma Microchip PIC............................................ 33
Pgina 4

Santiago Reig Chiva
Memoria
6.1.2.1. Anlisis de Pingino ..................................................................... 33

6.1.2.2. Anlisis chipKIT ............................................................................ 34
6.1.3.
Anlisis de la plataforma ARM .......................................................... 35
6.1.3.1. Anlisis de ST Micro ..................................................................... 36

6.1.3.2. Anlisis de NXP ............................................................................ 37
6.1.4.
Anlisis de la plataforma de Texas Instruments MSP430 ................. 38
6.1.4.1. Anlisis de Launchpad ................................................................. 38

6.2.
Comparativa de soluciones para el medio de comunicacin ................... 40
6.2.1.
Anlisis del puerto paralelo............................................................... 40
6.2.2.
Anlisis del puerto serie .................................................................... 41
6.2.3.
Anlisis del USB ................................................................................. 42
6.2.4.
Anlisis del Bluetooth........................................................................ 42
6.2.5.
Anlisis del XBee................................................................................ 43
6.2.6.
Otras soluciones ................................................................................ 44
6.3.
Comparativa de soluciones para el protocolo de comunicaciones .......... 45
6.3.1.
Anlisis de Firmata ............................................................................ 45
6.3.2.
Anlisis del protocolo de ArduLab .................................................... 47
6.3.3.
Anlisis para la creacin de un protocolo propio ............................. 47
6.4.
Comparativa de soluciones para el lenguaje de programacin ............... 48
Pgina 5

Santiago Reig Chiva
Memoria
6.4.1.
Anlisis de Java .................................................................................. 48
6.4.2.
Anlisis de Qt ..................................................................................... 49
6.4.3.
Anlisis de Python ............................................................................. 50
7.
Descripcin de la solucin adoptada ........................................................ 52
7.1.
Descripcin de la placa de interfaz adoptada .......................................... 52
7.2.
Descripcin del medio de comunicacin adoptado ................................. 52
7.3.
Descripcin del protocolo de comunicacin adoptado ........................... 53
7.4.
Descripcin del lenguaje adoptado .......................................................... 53
8.
Desarrollo ................................................................................................. 55
8.1.
Diseo general .......................................................................................... 55
8.2.
Anlisis del protocolo Firmata .................................................................. 56
8.2.1.
Introduccin ...................................................................................... 56
8.2.2.
Descripcin del protocolo ................................................................. 57
8.2.2.1. Mensajes ...................................................................................... 57

8.2.3.
Descripcin de la comunicacin ........................................................ 58
8.2.4.
Mejoras en la implementacin del protocolo ................................... 60
8.2.5.
Descripcin de la capa fsica.............................................................. 61
8.2.6.
Descripcin de los conectores........................................................... 61
8.2.7.
Descripcin del cableado .................................................................. 63
Pgina 6

Santiago Reig Chiva
8.2.8.
8.3.
Memoria
Distancias y terminaciones................................................................ 63
Anlisis de la aplicacin software ............................................................. 64
8.3.1.
Introduccin ...................................................................................... 64
8.3.2.
Entorno de trabajo utilizado para el desarrollo ................................ 66
8.3.3.
Descripcin del cdigo fuente........................................................... 67
8.3.3.1. Inicializacin de los mdulos ....................................................... 67

8.3.3.2. Seleccin del puerto serie ........................................................... 69
8.3.3.3. Programacin del Arduino ........................................................... 70
8.3.3.4. Comunicacin con Firmata .......................................................... 71
8.4.
Anlisis de la placa de interfaz ................................................................. 74
8.4.1.
Introduccin ...................................................................................... 74
8.4.2.
Caractersticas principales ................................................................. 76
8.4.3.
Formas de alimentacin elctrica ..................................................... 77
8.4.4.
Anlisis de la memoria ...................................................................... 78
8.4.5.
Anlisis de las entradas y salidas....................................................... 78
8.4.6.
Anlisis 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
Pgina 7

Santiago Reig Chiva
Memoria
8.4.7.
Anlisis de los mtodos de programacin ........................................ 82
8.4.8.
Anlisis del entorno de trabajo ......................................................... 82
Pgina 8

Santiago Reig Chiva
Memoria
ndice de ilustraciones
Ilustracin 1 | Polmetro analgico .................................................................... 20
Ilustracin 2 | Polmetro digital .......................................................................... 20
Ilustracin 3 | Osciloscopio analgico ................................................................ 21
Ilustracin 4 | Osciloscopio digital ..................................................................... 21
Ilustracin 5 | Analizador lgico ......................................................................... 21
Ilustracin 6 | Captura de ArduLab .................................................................... 24
Ilustracin 7 | Bus Pirate v3.6............................................................................. 26
Ilustracin 8 | Usando el Bus Pirate con Putty ................................................... 28
Ilustracin 9 | Little Wire .................................................................................... 29
Ilustracin 10 | Arduino UNO ............................................................................. 33
Ilustracin 11 | Placa Pingino ........................................................................... 34
Ilustracin 12 | chipKIT Uno32 ........................................................................... 35
Ilustracin 13 | STM32 Discovery ....................................................................... 37
Ilustracin 14 | LPCXPRESSO con ARM Cortex-M0 ............................................ 38
Ilustracin 15 | TI Launchpad ............................................................................. 39
Ilustracin 16 | Mdulo Bluetooth ..................................................................... 42
Ilustracin 17 | XBee Serie 1 .............................................................................. 43
Pgina 9

Santiago Reig Chiva
Memoria
Ilustracin 18 | Diagrama de conexiones ........................................................... 56

Ilustracin 19 | Conectores USB ......................................................................... 62
Ilustracin 20 | Lneas de datos.......................................................................... 63
Ilustracin 21 | Cable USB A-B............................................................................ 63
Ilustracin 22 | Proyecto ejecutado en Windows 7 ........................................... 64
Ilustracin 23 | Proyecto ejecutado en Linux Ubuntu 12.04 ............................. 65
Ilustracin 24 | Proyecto ejecutado en Mac OS X Lion ...................................... 65
Ilustracin 25 | Eric IDE ...................................................................................... 66
Ilustracin 26 | Logo Arduino ............................................................................. 74
Ilustracin 27 | Arduino UNO R2 ........................................................................ 75
Ilustracin 28 | ATmega328P ............................................................................. 76
Ilustracin 29 | Interfaz USB-Serie ..................................................................... 79
Ilustracin 30 | Arduino Duemilanove ............................................................... 80
Ilustracin 31 | Arduino UNO ............................................................................. 81
Ilustracin 32 | Arduino Leonardo ..................................................................... 81
Ilustracin 33 | Software Arduino en Windows 7 .............................................. 83
Ilustracin 34 | Botones de verificacin y carga ................................................ 83
Pgina 10

Santiago Reig Chiva
Memoria
ndice de tablas
Tabla 1 | Anlisis Arduino UNO ......................................................................... 33
Tabla 2 | Anlisis de Pingino ............................................................................. 34
Tabla 3 | Anlisis chipKIT .................................................................................... 35
Tabla 4 | Anlisis de ST Micro ............................................................................. 37
Tabla 5 | Anlisis de NXP .................................................................................... 38
Tabla 6 | Anlisis de Launchpad ......................................................................... 39
Tabla 7 | Anlisis del puerto paralelo ................................................................. 41
Tabla 8 | Anlisis del puerto serie ...................................................................... 41
Tabla 9 | Anlisis del USB ................................................................................... 42
Tabla 10 | Anlisis del Bluetooth ........................................................................ 43
Tabla 11 | Anlisis del XBee ................................................................................ 44
Tabla 12 | Anlisis de Firmata ............................................................................ 46
Tabla 13 | Anlisis del protocolo de ArduLab .................................................... 47
Tabla 14 | Anlisis de protocolo propio ............................................................. 48
Tabla 15 | Anlisis de Java .................................................................................. 49
Tabla 16 | Anlisis de Qt ..................................................................................... 50
Tabla 17 | Anlisis de Python ............................................................................. 51
Pgina 11

Santiago Reig Chiva
Memoria
Tabla 18 | Comparacin mensajes MIDI y Firmata ............................................ 58

Tabla 19 | Caractersticas del Arduino UNO ....................................................... 76
Pgina 12

Santiago Reig Chiva
Memoria
1. Antecedentes
El presente proyecto, titulado Plataforma de experimentacin para
prototipado de diseos mediante Arduino, surge de las conversaciones mantenidas
entre D. Eduardo Gallego, principal desarrollador de ArduLab y orientador del aula de
robtica del C.P. Miguel Hernndez de Madrid; D. Carlos Alberto Rodrguez Gonzlez,
profesor perteneciente al departamento de Ingeniera Elctrica de la Universidad de La
Rioja y D. Santiago Reig Chiva, alumno de Ingeniera Tcnica Industrial especialidad en
Electrnica Industrial de la Universidad de La Rioja, con motivo de la realizacin 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 elaboracin del proyecto y se presenta a
efectos de reconocimiento acadmico para la obtencin del ttulo de Ingeniero Tcnico
Industrial especialidad en Electrnica Industrial.
Pgina 13

Santiago Reig Chiva
Memoria
2. Objetivo del proyecto

El objetivo de este proyecto es el desarrollo de una solucin formada por
aplicacin multiplataforma, garantizando su funcionamiento en Windows, Linux y Mac
OS, con la que poder manejar la informacin desde y hacia la placa de interfaz; un
protocolo de comunicacin y una placa de interfaz con el mundo fsico.
Hace dos aos apareci ArduLab, un software que combinado con una placa
Arduino permita controlar manualmente los perifricos del chip integrado en la placa
Arduino, por lo que facilitaba las tareas de prototipado al poder cambiar los valores
lgicos en los pines, leer dichos valores o tensiones de forma analgica, sacar ondas
PWM y todo esto sin tener que cambiar cables ni programar una lnea de cdigo por
parte del usuario. El problema de este programa es que es de cdigo cerrado y
programado sobre LabView, por lo que depende tambin depende de las libreras
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 provea ese soporte, a la hora de la realidad no
se poda preparar el compilar el programa para los sistemas operativos Linux y Mac,
quedando slo disponible la versin de Windows. Las actualizaciones de las libreras
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 mdulos
similares a los ya existentes como otros nuevos. Tambin era requisito indispensable
que fuera de cdigo abierto, para permitir que cualquier persona pudiera modificar,
adaptar o aadir los cambios que crea necesarios sin tener que depender del
desarrollador principal en caso de que se tengan los conocimientos necesarios para
ello.
Las caractersticas
especificaciones:
del
framework
debern
cumplir
las
siguientes
Pgina 14

Santiago Reig Chiva
Memoria
Placa de interfaz con el mundo fsico accesible a todo el mundo y de bajo

coste.
Los perifricos de la placa de interfaz deben incluir al menos los siguientes:

entradas y salidas digitales, entradas analgicas, salidas de PWM y USART
para la comunicacin con el ordenador.
Fcil 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.
Fcil inclusin de nuevos mdulos al programa.
Todas las partes estn bajo licencias libres y sean de cdigo 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 programacin Python.
Anlisis del protocolo de comunicaciones Firmata.
Aprendizaje y uso tanto entorno de desarrollo integrado Arduino como su

ecosistema y los lenguajes de programacin C y C++.
Estudio de la plataforma y programacin de los AVR de Atmel.
Pgina 15

Santiago Reig Chiva
Memoria
Pgina 16

Santiago Reig Chiva
Memoria
3. Definiciones
El vocabulario tcnico utilizado a lo largo de este documento es definido para
su correcta comprensin:
Microcontrolador: es un circuito integrado programable, capaz de ejecutar

rdenes grabadas en su memoria. Est formado por la unidad central de
procesamiento, memoria y perifricos de entrada y salida.
Framework: es un conjunto estandarizado de conceptos, prcticas y

criterios para enfocar un tipo de problemtica particular, que sirve como
referencia para enfrentar y resolver nuevos problemas de ndole similar.
Bit: es la unidad mnima de informacin empleada en informtica, capaz de

representar dos estados, verdadero o falso, activado o desactivado.
Byte: unidad de informacin formada por 8 bits.
Core: (ncleo) 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 aritmtico lgica y los
buses.
Compilador: programa informtico que traduce el cdigo fuente escrito en

un lenguaje de programacin a otro lenguaje de programacin de menor
nivel, generando un programa equivalente que la mquina sea capaz de
interpretar. Normalmente al lenguaje al que se compila suele ser a lenguaje
mquina.
Toolchain: (cadena de herramientas) conjunto de herramientas de

compilacin y enlazado, necesarias para transformar el cdigo fuente en un
programa ejecutable compatible con la plataforma con la que se desarrolla.
Pgina 17

Santiago Reig Chiva
Memoria
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 separacin 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: porcin de cdigo 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
travs del puerto serie en vez de con un programador especializado.
Pgina 18

Santiago Reig Chiva
Memoria
4. ntroduccion
Las herramientas para prototipado han ido apareciendo en el tiempo segn se
iba aumentado el conocimiento existente sobre la fsica, especialmente en los campos
de la electricidad y magnetismo. Estas herramientas son vitales tanto para el desarrollo
de nuevas aplicaciones como para la reparacin y revisin del funcionamiento de las ya
existentes.
Las herramientas ms importantes y verstiles para anlisis en la historia han
sido el voltmetro, procedente del desarrollo de los galvanmetros y el osciloscopio.
La tecnologa ha ido mejorando a lo largo de los aos y esto ha permitido crear
analizadores para magnitudes fsicas que no se podan verificar con exactitud o hacerlo
de una manera ms barata, sencilla o cmoda.
El analizador lgico apareci como el sustituto de los osciloscopios para el
anlisis de circuitos digitales, que permita tener un gran nmero de entradas en
comparacin con el primero.
4.1. El polmetro
El polmetro es un instrumento elctrico porttil para medir directamente
magnitudes elctricas como pudieran ser tensiones, corrientes o pasivas como
resistencias, continuidad y otras. Las medidas pueden realizarse para corriente
continua o alterna.
Los modelos ms avanzados pueden incluir mediciones ms avanzadas tales
como temperatura, normalmente con el uso de termopares, capacidades,
inductancias, etc.
Pgina 19

Santiago Reig Chiva
Ilustracin 1 | Polmetro analgico
Memoria
Ilustracin 2 | Polmetro digital
Los polmetros han sido tradicionalmente analgicos, basados en la tecnologa

del galvanmetro, aunque en las ltimas dcadas ha desaparecido totalmente del
mercado en favor de los modelos digitales.
4.2. Osciloscopio
Un osciloscopio es un instrumento de medicin electrnico para la
representacin grfica de seales elctricas que pueden variar en el tiempo. Dada su
gran versatilidad, se utiliza con asiduidad en electrnica y telecomunicaciones.
Estn clasificados segn su funcionamiento interno en analgicos o digitales,
siendo el resultado mostrado prcticamente 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 caractersticas comparados con sus similares
analgicos.
Pgina 20

Santiago Reig Chiva
Memoria
Ilustracin 3 | Osciloscopio analgico
Ilustracin 4 | Osciloscopio digital
4.3. Analizador lgico

Es un instrumento de medida que captura los datos de un circuito digital y los
muestra para su anlisis, de un modo similar a un osciloscopio, como un diagrama de
tiempos. Pero tambin existen otras representaciones que pueden ser de ms utilidad
como decodificacin de un protocolo que se est usando, lenguaje ensamblador o
relacionar el cdigo ensamblador con el cdigo fuente.
Un analizador lgico, al igual que el osciloscopio, inicia la captura cuando en el
circuito a analizar se da una determinada condicin lgica (entre todos los canales). En
ese momento se realiza una gran captura de datos del sistema que se est observando,
para ms tarde poder observarlos.
Ilustracin 5 | Analizador lgico
Pgina 21

Santiago Reig Chiva
Memoria
Estos analizadores pueden existir como dispositivos independientes, con sus

controles, pantallas y dems hardware necesario; como basados en PC, normalmente
conectados a travs de USB o Ethernet y mostrando los datos en el software del
ordenador, por lo que son ms baratos al slo 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
prctica totalidad de ellas en las versiones digitales o electrnicas, que poseen una
funcionalidad mucho mayor a la de sus homlogos analgicos, aunque cuenta con las
limitaciones de la propia conversin de analgico a digital y al revs, como pueden ser,
velocidad, resolucin, etc.
Pgina 22

Santiago Reig Chiva
Memoria
5. Estudios previos al diseno

Para definir las caractersticas del proyecto final, se han realizado estudios
previos de las soluciones ya existentes para poder mejorarlas.
5.1. Estudio de ArduLab

La nica solucin similar existente hasta la fecha, ha sido el paquete de
software ArduLab, tambin en combinacin con una placa Arduino.
ArduLab ha sido desarrollado por la asociacin de robtica educativa
Complubot, localizada en el C.P. Miguel Hernndez de la ciudad de Alcal de Henares
en la comunidad autnoma de Madrid. Se puede descargar sin limitaciones desde la
pgina 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 adquisicin de
una licencia de ste para poder realizar su distribucin, tambin se depende completa
y nicamente de la empresa desarrolladora para solucionar los fallos existentes en las
libreras y procesos.
Pgina 23

Santiago Reig Chiva
Memoria
Ilustracin 6 | Captura de ArduLab
Pretenda ser un programa gratuito multiplataforma y se consigui el primer

objetivo, pero el segundo no fue todava terminado, ya sea por fallos en las libreras
que no permitan que el software funcionara como debiera o en los procesos de
compilacin, por lo que no se poda 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 cdigo 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 conversin del software a
una plataforma que permita sin licencias que restrinjan su desarrollo o distribucin y
garanticen en mayor medida la compatibilidad multiplataforma, tal y como se
pretende en el proyecto de que trata este documento.
Pgina 24

Santiago Reig Chiva
Memoria
La transmisin entre la placa Arduino y el software se realiza a travs del puerto

serie virtual sobre el protocolo USB y se utiliza un protocolo de comunicacin de
creacin propia, que es simple y eficaz, aunque de limitada escalabilidad, no muy
optimizado y difcil de rescribir para ser utilizado por otras vas de comunicacin como
podra ser Ethernet.
5.2. Estudio de Bus Pirate

Bus Pirate es una herramienta que comparte la misma filosofa que este
proyecto, descubrir el funcionamiento de un dispositivo sin tener que llegar a
programar una sola lnea de cdigo.
Fue creada por Ian Lesnet mientras era escritor en el blog de noticias de
electrnica 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 evolucin del proyecto no es realizada slo por Ian, si no
que al tratarse de un proyecto de software y hardware libre, mucha gente colabora
con su tiempo y cdigo para la mejora de la herramienta en beneficio de toda la
comunidad de usuarios.
El hardware de Bus Pirate es un diseo propio basado en la familia de
microcontroladores PIC, utilizando un chip de la empresa FTDI para realizar la
conversin de serie a USB y poder conectarlo al PC de una manera sencilla una vez los
drivers estn instalados correctamente. En futuras revisiones se va a eliminar este chip
conversor e implementar el stack USB dentro del propio PIC, gracias a unas libreras
USB que se han desarrollado recientemente y de software libre, que permiten la
distribucin libre del cdigo fuente del proyecto, al contrario de lo que ocurra con las
libreras propietarias de Microchip.
Pgina 25

Santiago Reig Chiva
Memoria
Ilustracin 7 | Bus Pirate v3.6
BusPirate est ms orientado a desarrolladores, ya que sus funcionalidades son

las siguientes:
Interfaz con buses de comunicacin

o 1-Wire
o I2C
o SPI
o Serie
o JTAG
o MIDI
o Teclados de PC
o Y ms
Programar microcontroladores
o PIC
Pgina 26

Santiago Reig Chiva
Memoria
o AVR
Herramienta de depuracin de chips ARM
Programador de CPLDs
Flasheador de ROMs serie
Medidor de frecuencia y generador de onda cuadrada
Analizador lgico de bajo coste
Medidor de voltaje
Otras muchas
Como se podr apreciar ms adelante, comparte muchas funcionalidades con el

proyecto del que trata este documento, pero el proyecto Bus Pirate est orientado
ms hacia el desarrollador, ya que la interfaz se realiza a travs de una consola a travs
del puerto serie, aunque recientemente han ido saliendo interfaces de usuario que
realizan la comunicacin con el Bus Pirate y facilitan el uso de ste.
Pgina 27

Santiago Reig Chiva
Memoria
Ilustracin 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 aadieron caractersticas extras, quedando su funcionalidad
en:
Programacin de microcontroladores Atmel AVR
Control de pines digitales
Control de pines con PWM
Manejo de servos
Control del mdulo I2C
Control del mdulo SPI
Pgina 28

Santiago Reig Chiva
Memoria
Control del mdulo UART
Como se puede ver, es muy similar al Bus Pirate en cuanto a funcionalidad,

pero su principal diferencia es que la comunicacin se realiza a travs del protocolo
USB puro, sin emulacin de puerto serie u otras tcnicas, y junto con el proyecto se
desarrollaron libreras con una API basadas en la librera multiplataforma de
comunicacin por USB LibUSB. Estas libreras fueron realizadas en varios lenguajes de
comunicacin tales como C, C++, C#, etc. por lo que le permite a una gran masa de
desarrolladores utilizar dicha placa sin mayores complicaciones.
Ilustracin 9 | Little Wire
Pgina 29

Santiago Reig Chiva
Memoria
6. Analisis de soluciones
La solucin ideal ser una combinacin de placa de interfaz, protocolo de
comunicaciones y software que congenien de forma que permita realizar el proyecto
sin una gran inversin 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.
Pgina 30

Santiago Reig Chiva
Memoria
6.1. Comparativa de soluciones para la placa de

interfaz
Para realizar la interaccin entre el software y el mundo fsico, lo ms sencillo
es utilizar una placa con un microcontrolador con una cantidad aceptable de pines
disponibles para nuestro uso, salidas de PWM, temporizadores y entradas analgicas,
con lo que poder tener un gran abanico de posibilidades de uso.
Las caractersticas que debern reunir estos componentes para ser objetos del
estudio, sern las siguientes:
Alta disponibilidad en los distribuidores de componentes electrnicos ms

conocidos y presentes alrededor del mundo.
Larga vida til, es decir, que no estn en proceso de ser descatalogados en

corto plazo, para evitar tener que rescribir o portar el cdigo de la parte de
hardware a otra plataforma.
Precio reducido, incluso en bajas cantidades, con una alta relacin

funcionalidad/precio.
Baja cantidad de electrnica 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 pases en los que el acceso a la
electrnica 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 diseo abierto.
Pgina 31

Santiago Reig Chiva
Memoria
6.1.1. Anlisis de la plataforma Atmel AVR

La arquitectura AVR, perteneciente a Atmel, es de 8 bits y fue diseado desde
el comienzo para una eficiente ejecucin de cdigo C compilado.
Esta arquitectura ha sufrido un aumento importante en popularidad y
desarrollos durante estos ltimos aos debido al lanzamiento de la plataforma
Arduino, que ha logrado una popularidad sin precedentes. Como consecuencia de
esto, existen una gran cantidad de documentacin, ejemplos de cdigo y comunidad
de usuarios.
6.1.1.1. Anlisis de Arduino

Arduino es un conjunto de libreras 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 tambin es una sencilla placa de desarrollo, que est actualmente muy
extendida y puede encontrarse en prcticamente cualquier distribuidor de electrnica
del mundo, a un precio que ronda los 18 a 26 euros segn modelo y distribuidor y
cuenta adems con un diseo libre. La sencillez de esta placa tambin es uno de sus
puntos fuertes, ya que permite replicar de forma artesanal la placa con componentes
disponibles en las tiendas de electrnica.
Pgina 32

Santiago Reig Chiva
Memoria
Ilustracin 10 | Arduino UNO
Una de las ventajas, y la razn por la que Arduino eligi la plataforma AVR, es la
existencia del compilador libre basado en GCC denominado avr-gcc.
Tabla 1 | Anlisis Arduino UNO
Ventajas
Toolchain libre y gratuito
Gran comunidad de usuarios
Cantidad de documentacin y ejemplos
Desventajas
Precio
6.1.2. Anlisis de la plataforma Microchip PIC

Microchip con su familia de microcontroladores PIC ha estado durante aos
liderando el mercado del desarrollo de proyectos personales gracias al programa de
muestras de Microchip. Sus compiladores y libreras, aunque gratuitos o con lmite de
compilacin poseen licencias con clusulas que dificultan la distribucin del cdigo
fuente en segn que casos.
6.1.2.1. Anlisis de Pingino

Dado que Arduino est basado en la arquitectura AVR, un grupo de
desarrolladores se propuso portar las libreras a la arquitectura del PIC, de donde naci
el proyecto Pingino. Aunque funcionales, dichas libreras no estn totalmente a la
par, ni tan desarrolladas y probadas como las de Arduino. La plataforma consigui una
slida base de usuarios debido al programa de muestras de Microchip, ya que con
unos pocos componentes de bajo precio y fcil adquisicin era posible montarse una
placa compatible.
Pgina 33

Santiago Reig Chiva
Memoria
Ilustracin 11 | Placa Pingino

Tabla 2 | Anlisis de Pingino
Ventajas
Toolchain gratuito
Desventajas
Toolchain no libre
Libreras poco desarrolladas
6.1.2.2. Anlisis chipKIT

chipKit apareci ms tarde como una seria alternativa a Arduino en la
plataforma PIC, en una colaboracin entre la propia Microchip y Digilent, portando con
fiabilidad las libreras 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 segua usando los
propietarios ya existentes. Ms tarde se liber parte del compilador para su uso con las
placas chipKIT, pero algunas libreras seguan siendo propietarias. La gran ventaja es
que utiliza un microcontrolador de 32 bits, por lo que se nota una gran mejora en
trabajos que requieren una gran cantidad de procesamiento con respecto al
microcontrolador de 8 bits de Arduino.
Pgina 34

Santiago Reig Chiva
Memoria
Ilustracin 12 | chipKIT Uno32
Tabla 3 | Anlisis chipKIT
Ventajas
Toolchain gratuito
API exactamente igual que la de Arduino
Se mantiene la API lo ms actualizada posible
Desventajas
Toolchain no libre
Pequea comunidad de usuarios
6.1.3. Anlisis 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.
Pgina 35

Santiago Reig Chiva
Memoria
La arquitectura Cortex-M ha sido la apuesta de ARM en el segmento de los

microcontroladores de baja potencia, siendo mucho ms potente y eficiente que los ya
existentes y con un precio muy competitivo. El modelo ms adecuado para el proyecto
sera el ARM Cortex-M0, ya que es el de menor capacidad de procesamiento, que no se
va a necesitar, pero tambin el de menor coste. Esta familia dispone de una gran
cantidad de pines, mdulos de comunicacin, etc.
Dicha arquitectura es prcticamente nueva y esto sumando a que ARM licencia
los cores a distintas empresas fabricantes de electrnica (Texas Instruments, NXP, ST
Electronics, etc.), crea una gran segmentacin, ya que cada fabricante aade los
perifricos que ms les interesa, crea sus propias libreras, etc., siendo la
documentacin de la programacin en esta arquitectura y de las libreras de los
fabricantes algo escasa. Tambin existe una gran variedad de compiladores tanto
propietarios como de cdigo abierto y todo esto hace que se tenga que estar bastante
familiarizado tanto como con la arquitectura ARM como con las libreras y perifricos
propios de cada fabricante.
Otro problema es que los chips con este ncleo casi siempre estn a la venta
con empaquetado de montaje superficial, por lo que dificulta su montaje si no se tiene
los conocimientos necesarios, aunque actualmente estn empezando a aparecer las
primeras versiones con empaquetado en tipo DIP.
6.1.3.1. Anlisis de ST Micro

ST Micro tiene disponible una gama de placas de evaluacin de los
microcontroladores ARM que ellos fabrican, es llamada Discovery. Son placas de bajo
coste que incluyen un microcontrolador, un programador y algn perifrico extra, todo
en una misma placa, con los pines fcilmente accesibles y programable por USB. Se
disponen de varios de modelos con la familia Cortex-M de ARM, que sera la ms
indicada para el proyecto.
Pgina 36

Santiago Reig Chiva
Memoria
Ilustracin 13 | STM32 Discovery
Se dispone tanto de compilador propietario como la versin gratuita y de

cdigo abierto de GCC.
Tabla 4 | Anlisis de ST Micro
Ventajas
Toolchain gratuito y libre
Programador compatible con opciones libres
Alta velocidad de procesamiento
Desventajas
Pines de conexin por el lado inferior de la placa
6.1.3.2. Anlisis de NXP

NXP es la Antigua divisin de electrnica de Philips, que tambin 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 evaluacin de bajo coste basada
en microcontroladores de la familia ARM Cortex-M con el programador y
microcontrolador en una misma placa y comunicacin con el entorno de desarrollo a
travs de USB o JTAG, segn se prefiera.
Pgina 37

Santiago Reig Chiva
Memoria
Ilustracin 14 | LPCXPRESSO con ARM Cortex-M0

Tabla 5 | Anlisis de NXP
Ventajas
Alta velocidad de procesamiento
Desventajas
Precio
Se dispone tanto de compilador propietario como la versin gratuita y de

cdigo abierto de GCC.
6.1.4. Anlisis 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.
Tambin existe un grupo de usuarios en esta plataforma para portar las
libreras de Arduino o una simplificacin/aproximacin de ellas, pero debido al bajo
nmero de desarrolladores implicados en el proyecto, no estn muy completas.
6.1.4.1. Anlisis de Launchpad

Esta familia es interesante debido a que tiene una placa de desarrollo
denominada Launchpad, realizada por la misma TI, que cumplira con los requisitos del
proyecto y a un precio extremadamente competitivo.
Pgina 38

Santiago Reig Chiva
Memoria
La principal desventaja es que los chips bsicos de esta familia no suelen tener
mdulo hardware de UART, por lo que habra que implementarlo por software.
Ilustracin 15 | TI Launchpad
Aunque el fabricante nos recomienda utilizar unos compiladores propietarios,

tambin existe una versin libre basada en GCC denominada mspgcc.
Tabla 6 | Anlisis de Launchpad
Ventajas
Precio
Desventajas
Pocas libreras
Dificultad de desarrollo
Ausencia de USART en el microcontrolador provisto
Pgina 39

Santiago Reig Chiva
Memoria
6.2. Comparativa de soluciones para el medio de

comunicacin
Para realizar el intercambio de informacin y datos entre el software en el
ordenador y la placa de interfaz con el mundo fsico, es necesario realizarlo a travs de
un medio de comunicacin.
La velocidad de transmisin, as como su ancho de banda, no sern altos, que
aunque esto viene determinado principalmente por el protocolo, suele estar
directamente relacionado con el medio de transmisin. 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 implantacin en el proyecto, han sido
los siguientes:
6.2.1. Anlisis del puerto paralelo

El puerto paralelo nos podra 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 tambin como entrada.
La desventaja es que no existe manera de realizar lecturas de tensiones de
forma analgica y debido a que los sistemas operativos comunes no son en tiempo
real, tampoco se podra realizar PWM en los pines de forma eficaz y consistente a lo
largo del tiempo. Estas deficiencias pueden ser suplidas con la ayuda de circuitera
externa, pero debiendo de poner casi obligatoriamente un microcontrolador, es
mucho ms eficiente y cmodo trabajar por el puerto serie.
Otro problema existente es que cada vez es ms difcil que un ordenador que
disponga de un puerto paralelo, siendo hoy en da casi imposible encontrar uno.
Pgina 40

Santiago Reig Chiva
Memoria
Tabla 7 | Anlisis del puerto paralelo
Ventajas
Posibilidad de usarlo directamente para realizar la interfaz con el mundo fsico
Desventajas
Los sistemas operativos no suelen trabajar en tiempo real
Difcil de encontrar en equipos nuevos
6.2.2. Anlisis del puerto serie

El puerto serie es un estndar de comunicacin simple y con una gran madurez,
por lo que no suele ser difcil realizar una comunicacin a travs de ste. Tambin
tiene la ventaja de que un gran abanico de microcontroladores, incluso los de bajo
precio y prestaciones, suelen tener un mdulo hardware, que trabaja
independientemente del ncleo, 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 ms difcil encontrar dicha
interfaz en ordenadores nuevos, aunque debido a su gran versatilidad y utilidad
todava siguen apareciendo en ordenadores de sobremesa, pero prcticamente
desaparecido en los ordenadores porttiles. De todas maneras, debido a esta
desaparicin, fomentada en gran medida por la aparicin del puerto USB, se han
creado chips que traducen el protocolo serie desde el microcontrolador y lo
empaquetan a travs del USB, mostrando luego al ordenador un puerto serie virtual a
travs del cual se realiza la conexin.
Tabla 8 | Anlisis del puerto serie
Ventajas
Suficientemente rpido
Buena inmunidad al ruido
Barato de implementar
Muy utilizado y sencillo de trabajar
Desventajas
Difcil de encontrar en nuevos equipos
Pgina 41

Santiago Reig Chiva
Memoria
6.2.3. Anlisis del USB

Cada vez es ms comn ver pequeos microcontroladores de bajo coste con
mdulos hardware de comunicacin por USB, aunque suelen duplicar su precio con
respecto a sus homlogos sin este mdulo. Tambin han ido apareciendo libreras 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 ms
rpido posible.
Tabla 9 | Anlisis del USB
Ventajas
Muy rpido
Buena inmunidad al ruido
Muy verstil
Correccin de errores
Desventajas
Encarece el microcontrolador
6.2.4. Anlisis del Bluetooth

Es un canal de comunicacin inalmbrico 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 conexin entre dos dispositivos. Su bajo coste y orientacin al uso
por el consumidor, le ha permitido situarse como el medio de comunicacin entre
dispositivos mviles.
Ilustracin 16 | Mdulo Bluetooth
Pgina 42

Santiago Reig Chiva
Memoria
Durante los ltimos aos se ha producido una reduccin enorme del coste de
implantacin de este protocolo, siendo incluido cada vez ms en proyectos de bajo
coste y comercializacin.
Los mdems Bluetooth tienen una interfaz por la que configurarlos y
comunicarse a travs de ellos basada en el puerto serie, por lo que podran reemplazar
el cable del puerto serie sin grandes modificaciones del cdigo.
Tabla 10 | Anlisis del Bluetooth
Ventajas
Inalmbrico
Velocidad similar al puerto serie
Fcil de implementar
Desventajas
Poca potencia de transmisin
No muy fiable y consistente a largo plazo
6.2.5. Anlisis del XBee

Los dispositivos XBee, basados en la tecnologa ZigBee, disponen de un stack
con aadidos que les permite realizar una funcin similar a la del bluetooth pero con
algunas diferencias: un menor consumo, la posibilidad de realizar redes de conexin
avanzadas como en malla y una mayor distancia, aunque a una velocidad menor.
Ilustracin 17 | XBee Serie 1
Pgina 43

Santiago Reig Chiva
Memoria
Dependiendo del modelo escogido, podramos llegar a alcanzar incluso decenas

de kilmetros.
Tabla 11 | Anlisis del XBee
Ventajas
Largas distancias de comunicacin
Correccin de errores
Fcil de implementar
Desventajas
Precio
6.2.6. Otras soluciones

Existen otros muchos protocolos por los que se podra realizar la comunicacin
entre la placa de interfaz fsica 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.
Pgina 44

Santiago Reig Chiva
Memoria
6.3. Comparativa de soluciones para el protocolo

de comunicaciones
El protocolo de comunicaciones ser el encargado de definir como se transmite
toda la informacin relativa a la configuracin de la placa y el estado de sta entre sta
y el ordenador con el software.
La cantidad de informacin va a ser muy baja durante la mayor parte del
tiempo, por lo que un protocolo sencillo de implementar, que funcione a travs de un
medio de bajo coste y sea de bajo ancho de banda para facilitar su portabilidad e
implantacin. Adems 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. Anlisis de Firmata

Firmata es un protocolo de comunicacin genrico para controlar los
perifricos de un microcontrolador desde un software en un ordenador. Est diseado
para ser incluido en cualquier software, ya que es de sencilla implementacin.
Firmata est centrado principalmente en realizar el intercambio de informacin
a travs 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 informacin 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 versin ms actualizada del protocolo
listo para ser incorporado en las placas. Este firmware soporta las placas Arduino tanto
Uno, Duemilanove, Diecimila como las Mega.
El protocolo guarda una estrecha relacin con el protocolo MIDI, ya que ha sido
su referencia desde casi la primera versin, cuando se rescribi el cdigo para hacerse
compatible con ste.
Las principales funciones que estn implementadas en el protocolo en la actual
versin 2.2, son las siguientes:
Pgina 45

Santiago Reig Chiva
Memoria
Configurar los pines: entrada, salida.
Lectura estado de los pines: alto, bajo.
Lectura entradas analgicas (con control de velocidad de muestreo).
PWM.
Control de servomotores.
I2C.
La licencia de las libreras de Firmata, as como de su implementacin en el

firmware en la versin de Arduino, son libres, por lo que se podrn utilizar sin
problemas para el proyecto y al disponer del cdigo fuente, se pueden realizar
modificaciones a ste para arreglar fallos de programacin o aadir funcionalidades
que no existan.
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
tambin es continuo, con un flujo constante de ideas y mejoras que poco a poco se van
implementando.
Tabla 12 | Anlisis de Firmata
Ventajas
Ya implementado
Comunidad de usuarios
Desarrolladores activos
Protocolo libre y gratuito
Desventajas
Ninguna
Pgina 46

Santiago Reig Chiva
Memoria
6.3.2. Anlisis 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 ms adecuado, ya que aunque es muy simple en su implementacin,
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 | Anlisis del protocolo de ArduLab
Ventajas
Ya implementado
Sencillo
Desventajas
No muy escalable
6.3.3. Anlisis para la creacin de un protocolo propio

La alternativa a utilizar los protocolos ya existentes, sera realizar un protocolo
propio, en el que se implementaran las capacidades exactas que se vayan a utilizar y
segn se vayan necesitando.
Teniendo en cuenta que Firmata es un protocolo muy similar a lo que se
acabara diseando una vez avance el protocolo y ya dispone de muchas de las
optimizaciones que se le pueden realizar para mejorar su desempeo. Por lo que lo
ms razonable en el caso de querer implementar un protocolo propio sera, tomar
como base el protocolo de Firmata, eliminar lo que no se necesite o interfiera en lo
planificado y desarrollar a partir de ah.
Pgina 47

Santiago Reig Chiva
Memoria
Tabla 14 | Anlisis de protocolo propio
Ventajas
Totalmente adaptado a las necesidades
Desventajas
Tiempo de desarrollo
6.4. Comparativa de soluciones para el lenguaje

de programacin
La eleccin del lenguaje de programacin es posiblemente la que va a influir en
mayor medida durante el desarrollo del proyecto, por lo que habr que seleccionarlo
tras un buen anlisis de las opciones existentes.
En este anlisis solo se tendrn en cuenta los lenguajes de programacin para
la parte de software que funcionar en el lado del ordenador, la parte de
programacin 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 cdigo para tener que conseguirlo, ser un lenguaje conocido y estable y que el
desarrollo con l sea simple y verstil, con el que poder realizar todas las
funcionalidades del proyecto que se nos ocurran. Al deber ser multiplataforma la parte
de software, se descartarn de entrada la familia de lenguajes Visual y .NET de
Microsoft.
6.4.1. Anlisis de Java

Es un lenguaje orientado a objetos, toma mucha de la sintaxis de C++, pero con
un modelo de objetos ms simples, eliminando las herramientas de bajo nivel tales
como la manipulacin directa de punteros y memoria, que solan inducir a error.
Al contrario de muchos lenguajes, Java se compila a bytecode pudindose
tambin compilar tambin a cdigo mquina, pero estos suele realizarse por el
Pgina 48

Santiago Reig Chiva
Memoria
intrprete en tiempo real desde el cdigo en bytecode, que permite ejecutarse en

cualquier plataforma que tenga el intrprete adecuado.
La principal desventaja es la antigedad de la interfaz de usuario disponible con
y prcticamente sin actualizaciones en los ltimos aos, siendo esta adems un
compleja para el desarrollo, que sigue los estilos de programacin del momento en el
que se lanz.
Tabla 15 | Anlisis de Java
Ventajas
Gran comunidad de usuarios
Gran cantidad de ejemplos
Elimina las complejidades de C++
Desventajas
Librera para interfaces de usuario incluida muy antigua
6.4.2. Anlisis de Qt
Est basado en C++ y su punto fuerte es la capa de abstraccin que han creado
encima de este para aadir caractersticas multiplataforma, tanto de escritorio como
mviles (Windows, Linux, Mac OS, Symbian, and Maemo), incluye libreras para
desarrollar interfaces de usuario con ventanas y est acompaado por una gran
cantidad de herramientas potentes y una extensa y bien organizada documentacin.
Hace una temporada tuvo un futuro incierto, ya que ste lenguaje de
programacin pertenece a Nokia, que no pas por unos aos muy buenos y su
existencia peligraba, pero hace poco decidieron liberar el lenguaje de programacin
con sus libreras, por lo que se asienta su futuro; habiendo aparecido durante el
desarrollo de este proyecto de una revisin menor y la casi finalizacin de una revisin
mayor.
Pgina 49

Santiago Reig Chiva
Memoria
Tabla 16 | Anlisis de Qt
Ventajas
Basado en C++
Gran calidad de la documentacin
Herramientas de desarrollo muy completas e integradas
Libreras para interfaces de usuario de gran calidad
Desventajas
Futuro algo incierto
6.4.3. Anlisis de Python

Es un lenguaje de alto nivel y de propsito general, cuya filosofa se centra en la
legibilidad, notable potencia y una muy clara sintaxis, con una biblioteca estndar
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 da son lo
suficientemente potentes como para poder con esta sobrecarga. La ventaja es que se
pueden probar trozos de cdigo directamente en la consola de ejecucin para su
prueba, pero con la desventaja de que los fallos de programacin no aparecen hasta
que el intrprete ejecuta la instruccin errnea, pudiendo pasarse por alto en las
revisiones de cdigo.
Al igual que Java, Python es interpretado y tambin puede ser compilado a
bytecode, aunque no a cdigo mquina, pero si que puede ser ejecutado con el cdigo
fuente, realizando el propio intrprete la compilacin a bytecode antes de ejecutarlo.
Python viene por defecto con la librera 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 libreras que enlazan con proyectos
como Qt, wxWidgets o GTK+, con una excelente apariencia y mayor facilidad de uso.
Uno de los problemas es que la creacin de paquetes de distribucin en Python
no est muy documentada, por lo que en principio se hace casi imprescindible el uso
de libreras que facilitan su uso, pero no son todo lo completas que se desearan.
Pgina 50

Santiago Reig Chiva
Memoria
Tabla 17 | Anlisis de Python
Ventajas
Sencillez de desarrollo
Cantidad de libreras
Gran comunidad de usurarios
Desventajas
Librera para interfaces de usuario incluida muy antigua
Pgina 51

Santiago Reig Chiva
7. Descripcion
adoptada
Memoria
de
la
solucion
7.1. Descripcin de la placa de interfaz adoptada

En el proyecto utilizaremos la placa Arduino, por su alta disponibilidad y
cantidad de documentacin disponible. Es una placa con entradas y salidas digitales y
salidas de PWM, entradas analgicas, pudiendo conectarla a una gran cantidad de
perifricos como leds, sensores resistivos o de voltaje, servomotores, dimmers, etc.
Al estar todo lo que necesitamos de esa plataforma (hardware, libreras,
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. Descripcin del medio de comunicacin

adoptado
Debido a que la placa Arduino posee un puerto USB por el que es posible
realizar una comunicacin serie, se utilizar este medio de comunicacin. Adems el
USB es un estndar implementado en prcticamente cualquier ordenador en su
versin 2.0 desde hace ms de una dcada, por lo que se asegura una compatibilidad
prcticamente total.
Al estar la comunicacin serie encapsulada en el protocolo USB, se pueden
llegar a utilizar velocidades mucho mayores que a travs 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 comunicacin,
Pgina 52

Santiago Reig Chiva
Memoria
pero debido a la gran cantidad de documentacin existente sobre este tema y su

sencillez no se tendr en cuenta como un problema mayor.
De todas maneras, se podr utilizar cualquier solucin de comunicacin 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 lnea de cdigo
del firmware contenido en el Arduino.
7.3. Descripcin del protocolo de comunicacin

adoptado
El protocolo utilizado para la comunicacin 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 implementacin, no tiene
sentido implementar un protocolo dedicado para este proyecto cuando su
funcionamiento sera similar en un 90%.
Su evolucin es constante y con visos a dar compatibilidad a los nuevos
modelos de Arduino, tambin a hacer las adaptaciones correspondientes para permitir
ser utilizado a travs de Ethernet u otros medios de comunicacin.
7.4. Descripcin del lenguaje adoptado

Python ha sido el lenguaje escogido para la programacin de la interfaz de
usuario, ya que es multiplataforma y permite un desarrollo rpido de aplicaciones.
Para suplir las deficiencias de la librera estndar de Python se har uso de las
siguientes libreras adicionales:
PyQt: para la parte de interfaz de usuario se usarn las libreras de Qt para

Python, por lo que tambin se tendr a disposicin todo el poder de este
lenguaje, tanto con los tipos de datos como la creacin de interfaces de
usuario, todo ello tambin compatible con cualquier plataforma. Qt tiene
una interfaz de usuario multiplataforma que imita muy bien la apariencia de
Pgina 53

Santiago Reig Chiva
Memoria
las aplicaciones nativas, por lo que el usuario se sentir familiar con la

forma de sta, dejando tambin la opcin al desarrollador de modificarlo a
su gusto.
PyQwt: es una librera que aade elementos grficos cientficos tales como
grficas, sliders con medida, etc. Se basa en la librera Qwt desarrollada
para Qt.
PySerial: librera que se ocupa de las comunicaciones desde Python con el

puerto serie, ya sea real o virtual (a travs de USB). Su interfaz es muy
simple y de fcil uso.
PyFirmata: se encarga del protocolo de comunicacin y en conjuncin con

PySerial, realiza la transmisin de datos con la placa de interfaz mediante el
protocolo Firmata a travs del puerto serie. No es una librera muy comn,
por lo que presenta algunos fallos que tuvieron que ser solucionados.
cx_Freeze: una vez terminado el proyecto debe ser empaquetado para su

distribucin de forma sencilla por los usuarios. Al ser la interfaz de
empaquetamiento de Python un poco compleja, esta librera hace de
intermediario facilitando su uso. Nos permite crear instaladores para
cualquiera de las plataformas ms conocidas.
Tanto el lenguaje de programacin, como las libreras listadas anteriormente

son de uso sin restricciones para proyectos de cdigo abierto, por lo que no se tendr
ningn problema en este sentido.
Pgina 54

Santiago Reig Chiva
Memoria
8. Desarrollo
8.1. Diseo general
Una vez ya conocidas las tecnologas a utilizar en el proyecto, conocemos
cuales van a ser las caractersticas y lmites que nos vamos a encontrar. El proyecto va
a constar de cuatro partes diferenciadas, las cuales son:
Aplicacin software: es el centro de control de los perifricos de la placa a

la que est conectado. Se comunica con la placa para configurarla segn se
ha indicado por el usuario y muestra la informacin 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 seal USB procedente

del PC a serie estndar. 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 comunicacin
tambin 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.
Alimentacin: si no se van a conectar grandes cargas al Arduino que

superen los 500mA, se podr usar la alimentacin 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 tensin
continua de 5 a 9V y se enchufar al conector provisto para esto.
Pgina 55

Santiago Reig Chiva
Memoria
Ilustracin 18 | Diagrama de conexiones
8.2. Anlisis del protocolo Firmata

8.2.1. Introduccin
Firmata es un protocolo de comunicacin entre un ordenador y un
microcontrolador que apareci en los inicios de la historia de Arduino, por lo que las
caractersticas de este protocolo estn muy centradas en las capacidades del Arduino.
Es un protocolo de comunicacin genrico para controlar los perifricos de un
microcontrolador desde un software en un ordenador. Est diseado para ser incluido
en cualquier software y hardware, ya que es de sencilla implementacin.
ste protocolo soporta las placas Arduino tanto Uno, Duemilanove, Diecimila
como las Mega, aunque en el proyecto se ha decidido soportar la placa ms comn y
utilizada que es la Uno.
Firmata realiza el intercambio de informacin a travs del puerto serie y
codificado en binario en vez de en ASCII como puede ocurrir con otros, por lo que se
Pgina 56

Santiago Reig Chiva
Memoria
aumenta bastante la cantidad de informacin 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 analgicas (con control de velocidad de muestreo)
PWM
Control de servomotores
I2C
8.2.2. Descripcin del protocolo

Durante la realizacin 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 intrpretes MIDI sin problemas, aunque
algunos datos de los mensajes son utilizados de forma diferente al estndar.
8.2.2.1. Mensajes
El protocolo est formado por mensajes, que consisten en una serie de 8 bits.
Cada mensaje tiene su funcin asignada. Algunos mensajes consisten en un solo byte,
mientras que otros pueden llegar a tener 2 3 bytes. Tambin existe un mensaje con
el que poder enviar un nmero ilimitado de bytes. Algo que todos los mensajes tienen
en comn 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
Pgina 57

Santiago Reig Chiva
Memoria
puede deducir entonces que los bytes de estado estn en el rango 0x800xFF, por lo
que el nmero de stos est limitado a 127 y el resto de los bytes del mensaje, los de
datos si es que existen, estarn en el rango 0x000x7F.
Tabla 18 | Comparacin mensajes MIDI y Firmata
Comando
Significado
0x90
Activar nota
0x90
I/O digital
Parmetros
Parmetro 1
MIDI
2
nota
Firmata
2
LSB (bits 06)
Parmetro 2
fuerza
MSB (bits 713)
8.2.3. Descripcin de la comunicacin

El firmware de Firmata para las placas Arduino, realiza la comunicacin por la
USART de ste, por lo que abre un gran abanico de posibilidades de comunicacin a
travs de diversos medios.
En el caso ms comn, se realizara la conexin al PC utilizando el propio
conversor serie-USB disponible en la propia placa Arduino, tambin podra conectarse
al puerto serie del PC usando un adaptador de niveles serie de TTL a RS-232, que
permitira distanciar la placa del PC decenas de metros gracias a la robustez del medio
de transmisin. En caso de disponer de los conversores adecuados y desear la
comunicacin de esta manera, puede realizarse a travs de redes XBee, Bluetooth,
radiofrecuencia, Ethernet, Internet y otros muchos.
La comunicacin es bidireccional ya que la placa necesita enviar al PC su estado
(lecturas digitales y analgicas, estado de los pines, etc.) y el PC enviar los comandos
necesarios para configurar la placa segn requiera el usuario del software; y si el
medio lo permite (en la implementacin en Arduino se puede) ser una comunicacin
totalmente full-duplex.
Las transferencias se realizan en paquetes de 1 byte, utilizndose los 7 bits de
menos peso para datos y el octavo para indicar si es un comando. Los mensajes estn
formados por una cantidad de 1 a 3 bytes segn sea, pero en el caso de que
necesitemos enviar una mayor cantidad de informacin puede extenderse a cualquier
longitud utilizando el comando SysEx.
Pgina 58

Santiago Reig Chiva
Memoria
La configuracin de la comunicacin 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 transmisin por USB puede llegarse a sobrepasar el milln de baudios en
el caso de ser estrictamente necesario.
El paquete de transmisin se compone de:
1. Idle: en ausencia de comunicacin, la lnea tendr una seal mantenida a
nivel alto (break).
2. Inicio: antes de recibir la trama de informacin, se transmitir un bit a nivel
bajo (space) para indicar la transmisin de la trama.
3. Trama: informacin 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
informacin. Este bit debe estar siempre activo en el primer byte de
un mensaje.
2. Informacin: los 7 bits restantes son el comando o los datos
transferidos, segn 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).
Despus de esto pueden ocurrir dos cosas, o se deja de recibir/transmitir y la
lnea se deja a nivel alto (break) o se vuelve a transmitir otro byte en el caso de
mensajes de 2 o ms bytes, por lo que se volver a comenzar en el punto nmero 1.
Pgina 59

Santiago Reig Chiva
Memoria
La plantilla para interpretar una transmisin sera la siguiente:
Bits de datos
Idle o
segundo byte
Trama
Mensaje
8.2.4. Mejoras en la implementacin del protocolo

El firmware de Firmata para Arduino (en su actual versin 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
degradacin prematura del silicio que en el caso extremo podra llegar a su
inutilizacin, pudiendo tambin afectar al sensor o circuito conectado.
Gracias a que este firmware es de cdigo abierto, se procedi a aadir 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 solucin adecuada al anterior problema.
Pgina 60

Santiago Reig Chiva
Memoria
Tambin se modific el orden de inicio de las funciones de Firmata, ya que

segn estaba implementado, se necesitaba alrededor de dos segundos como mnimo
de espera hasta poder realizar la conexin de la placa.
8.2.5. Descripcin de la capa fsica

La capa fsica no viene definida por el protocolo, aunque indirectamente se
prev que por su campo de aplicacin en microcontroladores sea la transmisin
mediante transmisin serie asncrona (USART) a niveles de tensin TTL a 5V en la
mayora de los casos y a 3.3V en una minora, que es como viene diseado 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 implementacin en
Arduino, la capa de procesamiento del protocolo est completamente desacoplada de
la de transmisin, facilitando inmensamente esta tarea.
8.2.6. Descripcin de los conectores

Desde el punto de vista del usuario, el medio de transmisin va a ser el USB,
por lo que ser este el que se analizar en este apartado.
Las conexiones son extremadamente simples, ya que debido a la forma que
poseen los conectores, es prcticamente imposible conectarlos de forma errnea. Se
recomienda el uso de cables de al menos 1m. de largo y apantallados.
El conector tipo A ser el que se conecte al ordenador y el tipo B a la placa
Arduino, aunque los nuevos modelos estn siendo lanzados con el conector micro-B y
otras placas compatibles con la Arduino UNO realizadas por otros fabricantes suelen
llevar el conector mini-B.
Pgina 61

Santiago Reig Chiva
Memoria
Ilustracin 19 | Conectores USB
La asignacin de pines para el estndar USB, es el siguiente:
Pin 1: Vcc, lnea de alimentacin para los dispositivos conectados, la tensin

es de 5V y 0,5A de corriente mxima. El color habitual es el rojo.
Pin 2: Data-, seal de transmisin invertida a -3,3V a nivel bajo, polo

negativo. El color habitual es el blanco.
Pin 3: Data+, seal de transmisin no invertida a 3,3V a nivel alto. El color

habitual es el verde.
Pin 4: referencia, retorno de la alimentacin y conexin al mallado del

cable. El color habitual es el negro.
El quinto pin existente en las versiones de los conectores micro y mini puede
estar desconectado o referenciado a masa.
Pgina 62

Santiago Reig Chiva
Memoria
8.2.7. Descripcin del cableado

El estndar USB utiliza un cable de 4 conductores, uno para alimentacin, otro
para la tensin de referencia y otros dos para transmisin de datos. stos ltimos son
diferenciales y los cables estn trenzados, por lo que poseen una gran inmunidad al
ruido.
Ilustracin 20 | Lneas de datos
El cable debe tener una cobertura exterior de

policloruro de vinilo (PVC), una proteccin contra
ruido externo que conste de una malla de cobre
estaado entrelazado, una capa de proteccin
interna de polister metalizado de aluminio, los
cables de datos con una seccin mnima 28 AWG,
que segn el estndar al que hace referencia,
equivaldra a un dimetro de 0,38 mm y 23,20
ohmios mximo por 100 m y de 28 a 20 AWG para la
lnea de alimentacin que sera de 0,32 mm a 0,89
mm y de 23,20 a 3,58 ohmios mximo por 100 m.
Ilustracin 21 | Cable USB A-B
La capacitancia del bus con un dispositivo esclavo conectado a un cable USB, no

debe ser menor a 200 pF o mayor a 450 pF en las lneas D- o D+.
8.2.8. Distancias y terminaciones

La terminacin de los buses, es decir, las resistencias de terminacin para evitar
la reflexin de la seal en el final del cable y que rebote volviendo a aparecer en el bus,
no es necesario aadirlas, ya que est diseado de forma transparente al usuario,
estando ya incluidas en el driver.
La longitud mxima de transmisin viene dada por la atenuacin de la seal y el
tiempo de propagacin, aunque como regla general se recomienda no exceder los 5
metros de cable
Pgina 63

Santiago Reig Chiva
Memoria
8.3. Anlisis de la aplicacin software

8.3.1. Introduccin
Considerando lo anteriormente citado sobre software ya disponible, se procede
a la realizacin de un software de control visual de la placa de interfaz.
Para dicho efecto, se va a realizar una aplicacin multiplataforma compatible
con Windows, Linux y Mac con un nico cdigo fuente, sin necesidad de rescribir la
aplicacin para cada uno de ellos.
Ilustracin 22 | Proyecto ejecutado en Windows 7
Pgina 64

Santiago Reig Chiva
Memoria
Ilustracin 23 | Proyecto ejecutado en Linux Ubuntu 12.04
Ilustracin 24 | Proyecto ejecutado en Mac OS X Lion
Pgina 65

Santiago Reig Chiva
Memoria
Uno de los requisitos que se va a tener en cuenta a la hora de su elaboracin,

es que se trate de un programa sencillo e intuitivo, de modo que personas no
especializadas en la electrnica puedan ser capaces de aprovechar todas sus
posibilidades. Tambin se disear de forma que sea sencillo aadir, por parte de
cualquier usuario o desarrollador, nuevos mdulos al programa que extiendan su
funcionalidad.
La aplicacin mandar por el cable USB las modificaciones de los valores que
realicemos y mostrar la informacin del estado de la placa de interfaz.
8.3.2. Entorno de trabajo utilizado para el desarrollo

Para el desarrollo de la aplicacin se ha escogido Eric IDE, el cual es un entorno
de desarrollo integrado.
El entorno de desarrollo contiene mltiples ventanas y da acceso a variada
funcionalidad, por lo es denominado como entorno de desarrollo integrado (integrated
development enviroment, IDE).
Ilustracin 25 | Eric IDE
Pgina 66

Santiago Reig Chiva
Memoria
Soporta los lenguajes de programacin Ruby y Python, siendo ste ltimo el

elegido para la programacin de la parte de software del proyecto. Se ha escogido este
entorno de desarrollo, aparte de por ser compatible con el desarrollo en Python, por
estar centrado principalmente en el desarrollo con PyQt, que es una de las libreras
que ms se utilizarn durante la programacin. Las principales caractersticas son,
coloreado de cdigo, depurador, visualizador de variables, ejecucin paso a paso, muy
integrado con PyQt, lo que permite realizar de forma automtica tareas que de otra
forma se deberan realizar de forma manual y es multiplataforma, por lo que se podr
desarrollar el software tanto en Windows como en Linux o Mac, aunque la principal
plataforma de este desarrollo ser Windows.
Para que la aplicacin se ejecute correctamente, es necesario que las libreras
que se han detallado anteriormente (PyQt, pySerial, pyFirmata y PyQwt) estn
instaladas. Si se ejecuta el programa usando el instalador provisto en el CD adjunto, no
ser necesaria ninguna accin adicional, ya que se instalan automticamente, dejando
el programa listo para utilizar.
8.3.3. Descripcin del cdigo fuente

El cdigo fuente est programado en Python como se ha mencionado
anteriormente, es un lenguaje sencillo, potente, interpretado y multiplataforma.
Debido a la extensin del cdigo, se van a describir slo las partes ms
importantes de ste. Una versin ms extendida del cdigo puede encontrarse en los
anexos y la totalidad de ste en el CD que se adjunta con este documento.
8.3.3.1. Inicializacin de los mdulos

Como se ha comentado a lo largo del documento, el programa est formado
por distintos mdulos que realizan cada uno una funcin distinta.
Una vez se ha terminado de arrancar el subsistema que d el soporte a la
aplicacin para ejecutarse, se importarn las clases de los mdulos indicados para
poder ser luego inicializados y accedidos.
from selectportdlg import SelectPortDlg
Pgina 67

Santiago Reig Chiva
from
from
from
from
from
from
from
Memoria
mode import ModeTab

analog import AnalogTab
digital import DigitalTab
pwm import PWMTab
servo import ServoTab
motor import MotorTab
sequencer import SequencerTab
Estas lneas cargan los archivos .py existentes en la carpeta ui y dan acceso a las
clases que controlan la interfaz de usuario de cada mdulo.
Se puede observar que tambin se carga la ventana de seleccin del puerto
serie, que ser lo primero que le aparezca al usuario.
Una vez se haya seleccionado el puerto serie, se inicializarn los mdulos
llamando a los constructores de las clases que hemos importado. De esta manera se
acelera el arranque del programa, en vez de cargarlos desde el primer momento,
cuando incluso puede que el usuario cierre el programa directamente y no llegue a
usarlo.
self.tabs
=
(ModeTab(self),
DigitalTab(self),
AnalogTab(self),
PWMTab(self), ServoTab(self), MotorTab(self), SequencerTab(self))
De esta forma se inicializa la interfaz de usuario con los valores por defecto y
configuracin adecuada.
Para aadir o quitar mdulos slo hace falta hacer modificaciones en los dos
grupos de cdigo anteriores, por lo que es muy sencillo y rpido.
Las clases tienen que tener dos mtodos que se llamarn cuando se entre o se
salga de la pestaa a la que corresponde esa clase, de esta forma se pueden liberar
pines, iniciar la captura de datos, etc. de forma automtica al cambiar de pestaa y sin
tener que realizar continuamente transmisiones de datos para representar
informacin que se dibuja en una pestaa oculta.
self.tabs[self.lastIndex].exitTab()
Pgina 68

Santiago Reig Chiva
Memoria
self.tabs[index].enterTab()
8.3.3.2. Seleccin del puerto serie

En el dilogo de seleccin del puerto serie, se muestran los puertos serie
disponibles en el sistema. Es el conjunto de los disponibles en hardware, es decir, con
conector hembra DB-9 y protocolo RS-232 y los virtuales a travs de USB.
La estrategia seguida para encontrar los puertos disponibles en Linux y Mac
vara con la de Windows:
ports = list()
if POSIX:
ports
+=
glob.glob("/dev/ttyACM*")
glob.glob("/dev/ttyUSB*")
+
glob.glob("/dev/tty.usb*")
glob.glob("/dev/tty.serial*")
for i in xrange(256):
try:
s = serial.Serial(i)
ports.append(s.portstr)
s.close()
except serial.SerialException:
pass
+
+
En Windows slo se miran uno a uno cada puerto serie del 1 al 256 si existen y
son accesibles y tambin en Linux y Mac, pero los puerto series virtuales a travs de
USB, se deben buscar en la ruta /dev.
Una vez se haya seleccionado un puerto serie, se crea un objeto que representa
el Arduino, y se comunica con el a travs del protocolo Firmata por el puerto serie.
board = Board(self.portsCmb.currentText(), BOARDS['arduino'])
Una vez comprobada que la placa Arduino se comunica correctamente con el

software, se inician las pestaas como se ha indicado en el punto anterior.
Pgina 69

Santiago Reig Chiva
Memoria
8.3.3.3. Programacin del Arduino

Para comunicarse con la placa Arduino mediante Firmata, debe estar
programada con el firmware adecuado que pueda realizar dicha comunicacin. Debido
a que es comn que una placa Arduino sea reprogramada para otros usos, la inclusin
de un programador del firmware en la pantalla de bienvenida era una caracterstica
obligatoria.
Para descargar el firmware en la placa Arduino se utiliza el programador
avrdude, un proyecto de cdigo abierto que programa infinidad de microcontroladores
de Atmel en conjunto con un programador compatible con ellos, en este caso el
programador va incluido en el bootloader del Arduino, por lo que no hace falta un
programador externo.
La llamada al programador fue una parte problemtica ya que cada sistema
operativo tiene una forma distinta de llamar a los ejecutables y de tratar las rutas de
archivos con espacios entre medios, por lo que para no ensuciar el cdigo con partes
distintas para cada S.O., se busc una solucin compatible a todos ellos.
executable = os.path.join(appdir, "avrdude", "avrdude")
configuration = os.path.join(appdir, "avrdude", "avrdude.conf")
hexadecimal = os.path.join(appdir, "avrdude", "PlatexFirmata.hex")
command = "\""+executable+"\" -q -V -C \""+configuration+"\" -p
atmega328p -c arduino -P "+self.portsCmb.currentText()+" -b 115200 -D -U
flash:w:\""+hexadecimal+"\":i"
Una vez lista la llamada al ejecutable del programador con todos los
parmetros listos, se iniciaba la programacin.
self.program.start(command)
Una vez terminada la programacin se comprueba el resultado de esta y se

informa el usuario, apareciendo una ventana de aviso si se ha producido algn fallo.
Otra parte muy problemtica fue la de encontrar la ruta de los archivos del
proyecto, ya que es una tarea relativamente sencilla si se ejecuta desde el cdigo
Pgina 70

Santiago Reig Chiva
Memoria
fuente, pero una vez es empaquetado en forma de instalador, la estructura del

programa cambia completamente, habiendo casos en los que el ejecutable y los
archivos del proyecto se instalan en rutas distintas, por lo que el algoritmo para
encontrar dichos ficheros se complic en gran medida debiendo tener en cuenta todas
las posibles combinaciones de empaquetado que se realizan para cada uno de los
sistemas operativos.
isfrozen = getattr(sys, 'frozen', False)
if isfrozen:
if not sys.path or not sys.path[0]:
raise
RuntimeError('Cannot
determine
sys.path[0] is empty!')
else:
entry = sys.path[0]
else:
if not sys.argv or not sys.argv[0]:
entry = '<interpreter>'
else:
entry = sys.argv[0]
app
path
because
entry = os.path.realpath(entry)
appdir = os.path.dirname(entry)
8.3.3.4. Comunicacin con Firmata

El proyecto hace uso de una librera para la comunicacin siguiendo el
protocolo Firmata a travs del puerto serie. Esta librera fue desarrollada por Tino de
Bruijn, desarrollador residente en los Pases Bajos y que liber su cdigo fuente para
uso no comercial.
Es una librera que aunque funcional, se le han realizado una serie de
modificaciones para mejorar la velocidad de respuesta, arreglar una serie de bugs,
aumentar la funcionalidad e integrarla con la estructura del proyecto.
La configuracin de pines para limitar las funciones que podemos asignar a
cada pin pueden est definido en un archivo de configuracin.
BOARDS = {
'arduino' : {
Pgina 71

Santiago Reig Chiva
Memoria
'digital' : tuple(x for x in range(24)),

'analog' : tuple(x for x in range(14, 20)),
'pwm' : (3, 5, 6, 9, 10, 11),
'use_ports' : True,
'disabled' : (0, 1, 20, 21, 22, 23) # Rx, Tx, Crystal
},
'arduino_mega' : {
'digital' : tuple(x for x in range(54)),
'analog' : tuple(x for x in range(16)),
'pwm' : tuple(x for x in range(2,14)),
'use_ports' : True,
'disabled' : (0, 1, 14, 15) # Rx, Tx, Crystal
}
}
Cada funcin tiene asignados determinados pines tanto de forma paramtrica

como individualmente. En el proyecto slo se har uso de la placa Arduino normal, por
lo que la configuracin de la versin Mega no se utilizar.
El archivo de configuracin ha sido modificado con respecto al original debido a
que no permita utilizar las caractersticas digitales que los pines analgicos tambin
poseen. Tambin se modific la numeracin de los pines analgicos para hacerla
correlativa con respecto a los digitales y poder hacer uso de ellos tanto de forma
digital como analgica.
Una vez se ha seleccionado el puerto serie como se ha indicado en el apartado
anterior, se inicia un iterador que mira continuamente si ha llegado algn byte a travs
del puerto serie para procesarlo y esto se realiza de forma paralela al programa en
otro hilo de ejecucin.
self.it = util.Iterator(self.board)
self.it.start()
Una vez recibida una trama se proceder a comprobar si se trata de una trama
vlida. Para ello se comprobarn que las transmisiones que se estn recibiendo siguen
las especificaciones del protocolo que se han marcado.
byte = self.sp.read()
Pgina 72

Santiago Reig Chiva
Memoria
if not byte:
return
data = ord(byte)
received_data = []
handler = None
if data < START_SYSEX:
try:
handler = self._command_handlers[data & 0xF0]
except KeyError:
return
received_data.append(data & 0x0F)
while len(received_data) < handler.bytes_needed:
received_data.append(ord(self.sp.read()))
elif data == START_SYSEX:
data = ord(self.sp.read())
handler = self._command_handlers.get(data)
if not handler:
return
while data != END_SYSEX:
received_data.append(data)
else:
try:
handler = self._command_handlers[data]
except KeyError:
return
while len(received_data) < handler.bytes_needed:
received_data.append(ord(self.sp.read()))
try:
handler(*received_data)
except ValueError:
pass
Se discrimina segn el tipo de dato que se haya recibido para ser procesado de
la forma que se debe hacer, una vez identificado el tipo de dato, y separado el
comando de los datos, se llama a la funcin que debe procesarlos pasndole una
referencia de los datos recibidos.
El envo de tramas se realiza de forma individual para cada caso, por ejemplo si
se desea cambiar el tiempo de muestreo de los pines analgicos se utiliza la siguiente
funcin para mandar los tiempos a la placa Arduino:
def sampling_interval(self, interval=19):
Pgina 73

Santiago Reig Chiva
Memoria
if interval < 19: inteval = 19

elif interval > 16383: interval = 16383
self.send_sysex(SAMPLING_INTERVAL, to_two_bytes(interval))
El dato de tiempo de muestreo se enva a travs del mensaje extendido SysEx,

ya que no tiene asignado un comando directamente. En la transmisin van incluidas el
identificador de tiempo de muestreo y el propio tiempo de muestreo que en este caso
se ha decidido mandarlo en un mximo de 14 bits, que equivalen a dos bytes de
transmisin a travs de Firmata.
En los casos en los que existe un comando para la accin a realizar, por
ejemplo, para cambiar el modo de funcionamiento de un pin, el cdigo sera algo
distinto:
command = chr(SET_PIN_MODE)
command += chr(self.pin_number)
command += chr(mode)
self.board.sp.write(command)
8.4. Anlisis de la placa de interfaz

8.4.1. Introduccin
Como se ha estipulado anteriormente, la placa de interfaz estar basada en la
plataforma Arduino.
Ilustracin 26 | Logo Arduino
Pgina 74

Santiago Reig Chiva
Memoria
Arduino es una plataforma de electrnica abierta, centrada en la creacin de

prototipos, basada en hardware y software libre fciles de usar, ya que el usuario final
para el que se dise eran artistas, diseadores y aficionados.
Arduino toma informacin del entorno a travs de sus pines de entrada por los
que se puede conectar una gran variedad de sensores y puede interactuar con lo que
le rodea a travs de actuadores tales como luces, motores, etc.
El microcontrolador existente en la placa Arduino se programa en C/C++
haciendo uso de las libreras de Arduino, aunque tambin es posible programar sin
utilizarlas utilizando slo las libreras estndares de avrlibc o hacindolo directamente
en ensamblador.
Los proyectos hechos con Arduino pueden ejecutarse sin necesidad de estar
conectados a un ordenador, el cdigo es grabado en la memoria flash de la placa y su
ejecucin comienza automticamente al alimentar la placa.
El proyecto Arduino est basado en otros proyectos de cdigo abierto y libres
tales como Wiring para las libreras del microcontrolador y Processing para el entorno
de desarrollo. El propio proyecto Arduino tambin es de cdigo abierto y libre, tanto
para la parte de hardware como para la de software, por lo que las placas pueden ser
fabricadas a mano o compradas a travs de los distribuidores existentes, pudiendo
descargar los ficheros de diseo con la posibilidad de modificarlos para adaptarlos a la
aplicacin que se desee.
Ilustracin 27 | Arduino UNO R2
Pgina 75

Santiago Reig Chiva
Memoria
El proyecto se ha desarrollado utilizando la placa Arduino UNO R2, aunque es

compatible tanto con las revisiones 1 y 3 de la misma placa como con la Arduino
Duemilanove y Diecimila. La compatibilidad con la Arduino Leonardo debera ser total
una vez se asiente la recin salida placa.
8.4.2. Caractersticas principales

El Arduino UNO es una placa electrnica basada en el Atmega328 de Atmel.
Este integrado se intenta en la medida de lo posible que sea en la versin PDIP para
poder cambiar el chip fcilmente y sin herramientas por cualquier usuario, en caso de
que falle o se rompa, aunque este tipo de empaquetado est tendiendo a desparecer,
en favor del montaje superficial mucho ms difcil de sustituir, pero ms barato de
fabricar y montar.
Ilustracin 28 | ATmega328P
Dicho microcontrolador cuenta con 20 entradas/salidas digitales, de los cuales

6 pueden ser utilizados como salidas PWM y otros 6 como entradas analgicas, un
cristal de 16Mhz, una conexin serie a la que se puede acceder tambin por puerto
serie como se explicar en el siguiente apartado, un conector ICSP para conectar un
programador, un botn de reseteo, un conector jack para alimentacin externa y un
conversor USB-Serie.
Tabla 19 | Caractersticas del Arduino UNO
Caracterstica
Microcontrolador
Voltaje de funcionamiento
Voltaje de entrada (recomendado)
Nombre
ATmega328
5V
7-12V
Pgina 76

Santiago Reig Chiva
Voltaje de entrada (lmites)

Pines digitales I/O
Pines de entrada analgica
Corriente continua de los pines I/O
Corriente continua del pin de 3,3 V
Memoria Flash
SRAM
EEPROM
Velocidad de reloj
Memoria
6-20V
14 (6 de las cuales proporcionan
una salida PWM)
6
40 mA
50 mA
32 KB (ATmega328) de los
cuales 0,5 KB utilizado por
gestor de arranque
2 KB (ATmega328)
1 KB (ATmega328)
16 MHz
8.4.3. Formas de alimentacin elctrica

La placa puede ser alimentada a travs de la conexin USB o con una fuente de
alimentacin externa. La fuente de la alimentacin es escogida automticamente
mediante la electrnica integrada en la placa, dando prioridad a la alimentacin
externa que probablemente tenga una capacidad mucho mayor a la del USB.
La alimentacin externa puede ser introducida a la placa por el conector jack de
2,1mm existente en la placa o mediante cables sueltos conectndolos a GND y Vin.
La tensin mnima recomendada para alimentar la placa de forma externa es de
7V, ya que hay cadas de tensin tanto en el regulador de tensin para obtener los 5V
como en las distintas protecciones elctricas como la de conexin inversa, que crean
pequeas cadas de tensin. Como mximo se recomienda utilizar 9V, aunque es
posible alimentar con 12V, el regulador de tensin se sobrecalentar excesivamente,
pudiendo llegar a apagarse por sobrepasar la temperatura mxima de funcionamiento.
Los pines relativos a la alimentacin que podemos encontrar en la placa son:
Vin: es la entrada de voltaje no regulado a la placa de alimentacin, est

conectado a la entrada de alimentacin externa por el jack. Este pin puede
Pgina 77

Santiago Reig Chiva
Memoria
ser usado tanto como entrada como salida de alimentacin, pero slo si se
est alimentando externamente.
5V: este pin est conectado a la salida del regulador de tensin que
transforma la tensin de Vin en 5V, tambin est conectado al pin de 5V del
conector USB. La mxima intensidad que se puede obtener de este pin es
de 500mA. En caso de alimentarlo por USB, en caso de alimentacin
externa es difcil de determinar ya que depende en gran medida de la
tensin de entrada, cuanto mayor sea la tensin, menor ser la intensidad
mxima que se pueda obtener.
3V3: es una tensin de 3.3V obtenida por un regulador de tensin a partir

de ral de 5V. La mxima intensidad que se puede obtener de este pin es de
120mA en las nuevas versiones y 50mA en las antiguas.
GND: tensin de referencia, masa.
8.4.4. Anlisis de la memoria

El Atmega328 tiene 32KB de memoria flash, que permite una rpida descarga
del programa en el microcontrolador. De los 32KB, 0,5KB son utilizados por el
bootloader.
Tambin posee 2KB de memoria RAM esttica y 1KB de memoria EEPROM, que
a esta ltima no se le dar uso en el proyecto, aunque en el plan de ruta del protocolo
Firmata se usar para guardar el estado de la placa entre usos aunque esta haya sido
desconectada de la alimentacin.
8.4.5. Anlisis de las entradas y salidas

Cada una de los 20 pines digitales del Arduino puede ser usado como entrada o
salida, usando las funciones adecuadas. Todos los pines funcionan a 5V, por lo que si
se les conecta a una tensin mayor puede que dejen de funcionar permanentemente.
Cada pin tiene una salida de intensidad de 40mA mximo y una resistencia de pull-up
integrada de unos 20-50 kOhms.
Pgina 78

Santiago Reig Chiva
Memoria
Adems, algunos pines tienen alguna funcin adicional:
Serie: 0 (RX) y 1 (TX). Se usan para recibir y transmitir datos serializados con
niveles TTL. Estos pines estn conectados al conversor USB-Serie para
comunicarse con el ordenador. En el proyecto se utilizar esta
comunicacin por lo que su uso como pines digitales no estar disponible.
Interrupciones externas: 2 y 3, pueden ser configurados para interrumpir la

ejecucin del cdigo y realizar otra tarea. Pueden ser configurados para
interrumpir por nivel, por flanco o por cambio de valor.
PWM: seis pines marcados en la placa con el smbolo ~, pueden proveer

una salida de PWM con una precisin de 8 bits y con una frecuencia en el
orden de kilohercios.
SPI: protocolo de comunicacin serie mediante 4 hilos muy utilizado para

comunicacin de corto alcance entre microcontroladores. Suele ser
utilizado tambin para programar el microcontrolador Atmel mediante un
programador compatible.
I2C: protocolo de comunicacin serie mediante 2 hilos muy utilizado para la

comunicacin de corto alcance con sensores inteligentes.
8.4.6. Anlisis de la Interfaz USB-Serie

La comunicacin de la placa de interfaz con el software se realizar a travs de
USB, pero el microcontrolador con el que se comunica slo tiene interfaz serie, por lo
que habr que realizar dicha conversin externamente, utilizando para ello un circuito
integrado que haga de conversor entre ambos protocolos.
PC
Conversor USB-Serie
Micro
Ilustracin 29 | Interfaz USB-Serie
Pgina 79

Santiago Reig Chiva
Memoria
8.4.6.1. Chip FTDI

Los primeros modelos de placas Arduino contenan un chip denominado
FT232R fabricado por Future Technology Devices International (FTDI) que est hecho a
medida y est centrado en la conversin del protocolo serie a USB, emulando un
puerto serie en el lado del ordenador al que se ha conectado.
Ilustracin 30 | Arduino Duemilanove
El nivel de soporte de drivers existente es bastante bueno y se han desarrollado

tanto para los principales sistemas operativos como para otros no tan conocidos,
existiendo tambin versiones para 32 y 64 bits.
La principal ventaja de esta alternativa es que el chip no necesita configuracin
y no se tiene que tener conocimiento alguno del protocolo USB para realizar dicha
conversin.
El precio no es excesivamente alto y la cantidad de componentes externos se
limita a unos pocos condensadores y a unos leds en el caso de que se desee una
visualizacin de la actividad del puerto serie.
8.4.6.2. Chip Atmel

Las siguientes revisiones de las placas Arduino, cambiaron el chip conversor
USB-Serie FTDI por un chip de Atmel (el Atmega16u2) con un mdulo USB, de esta
manera se mantena el chip principal de Arduino intacto sin tener que desarrollar
nuevas libreras y el chip FTDI, de un precio algo elevado, era sustituido por el Atmel.
Pgina 80

Santiago Reig Chiva
Memoria
Se desarroll un firmware que hiciera

exactamente la misma funcin que l FTDI al
que reemplaza. Para ello se utiliz la
especificacin Communication Device Class
(CDC), que entre los varios tipos de interfaces
existentes, permite emular un puerto serie
siguiendo las especificaciones del protocolo
Ilustracin 31 | Arduino UNO
USB. Al estar en las especificaciones y tratarse
el USB de un estndar de comunicaciones
bastante extendido, no se necesita la instalacin de drivers en los sistemas operativos
Linux y Mac OS, aunque en Windows si que siguen siendo necesarios.
Como defecto, se necesita ms espacio en placa, ya que el microcontrolador
necesita de un cristal externo para mantener la precisin en la comunicacin USB,
aparte del conector ICSP de programacin.
Una ventaja de estos chips es que reprogramndolos se puede emular otros
tipos de dispositivos USB, tales como teclados, ratones, etc.
8.4.6.3. Sin chip

El ltimo modelo de la placa Arduino,
denominada Leonardo, no necesita este chip conversor
de USB a serie ya que el nuevo chip de Atmel que incluye
(el Atmega32u4) contiene un mdulo USB, por lo que
permite eliminar el conversor intermedio al poder recibir
el mismo la trama USB, procesarla y comunicarse.
Ilustracin 32 | Arduino
Leonardo
En el paquete de software de Arduino, se

incluyen las libreras necesarias para configurar dicho
mdulo de la forma adecuada, de manera que emule un puerto serie tanto para el
sistema operativo al que se conecta como para el programador de la placa.
La principal ventaja de esta solucin es que no es necesaria la instalacin de
drivers en las plataformas Linux y Mac OS y elimina el chip conversor que tena un peso
importante en el precio de venta final.
Pgina 81

Santiago Reig Chiva
Memoria
Cualquier solucin, de las citadas anteriormente, utilizada en las placas es

compatible con la parte de software del proyecto.
8.4.7. Anlisis de los mtodos de programacin

El Arduino UNO puede ser programado desde el software de Arduino,
seleccionando el modelo adecuado de la placa y el puerto serie al que est conectado.
El Atmega328 incluido en las placas Arduino, viene pregrabado con un
bootloader que emula el protocolo del programador STK500, por lo que es compatible
con variedad de software de programacin adems del software de Arduino.
Tambin existe la posibilidad de programar el Atmega328 a travs del conector
ICSP de seis pines, mediante el uso de un programador ICSP. Habr que utilizar uno de
los modelos soportados por el software Arduino o utilizar un software externo para
realizar la operacin de descarga del software.
8.4.8. Anlisis del entorno de trabajo

El software de Arduino est basado en Java, por lo que posee compatibilidad
multiplataforma.
Pgina 82

Santiago Reig Chiva
Memoria
Ilustracin 33 | Software Arduino en Windows 7
Es un entorno de desarrollo muy simple, aunque esa es su principal baza, que lo

hace muy fcil de usar al no tener nada que configurar. Tiene una ventana principal
donde se edita el cdigo con coloreado de funciones y una inferior en la que aparecen
los mensajes de error de los procesos de compilado y programacin del
microcontrolador.
Ilustracin 34 | Botones de verificacin y carga
Tiene dos botones principales, que son los que realizan la tarea de verificar el
cdigo escrito mediante la compilacin de ste y el segundo el de compilacin y carga
del cdigo en la placa Arduino a travs del puerto serie.
Tambin lleva integrado un simple monitor serie, con el que poder depurar el
cdigo mandando mensajes a travs del puerto serie, o directamente interactuar con
un programa que tenga su interfaz de usuario a travs de este protocolo.
Pgina 83

Santiago Reig Chiva
Memoria
Lleva incluida una toolchain para los AVR basada en avr-gcc, que es compilador
que toma cdigo en lenguaje C/C++ de alto nivel o ensamblador y crea un archivo
binario que se pueda programar en un AVR. Tcnicamente avr-gcc es slo un
compilador, portado de GCC (GNU Compiler Collection) para la familia de AVR de
Atmel, pero las mayoras de referencias a avr-gcc se refieren a todo el toolchain.
El paquete de software tambin lleva incluido un programador para los AVR
llamado avrdude, que es un programa de lnea de comandos, ideal para automatizar.
Es compatible con el programador STK500 a travs del puerto serie, que es el
programador que emulan los chips con el bootloader de Arduino para grabar en la
flash el archivo binario del programa desde el propio microcontrolador.
Tanto la toolchain de compilacin para los AVR, como el programado, son de
cdigo abierto y libres y adems estn incluidos en el paquete de software, por lo que
est listo para ser ejecutado en cualquier ordenador con slo necesitar la instalacin
de la mquina virtual de Java. De esta manera se elimina la dependencia de libreras
externas que solan traer problemas debido a la gran variedad de versiones que los
usuarios podan tener instaladas, tanto muy nuevas y con fallos de cdigo no
descubiertos como muy antiguas con caractersticas no implementadas.
Pgina 84
ANEXOS
DOCUMENTO N 2

Santiago Reig Chiva
Anexos
ndice de los anexos

9.
Anexo I: Diseo y programacin de la aplicacin..................................... 91
9.1.
Cdigo inicializacin aplicacin: platex.pyw ............................................ 91
9.2.
Cdigo de la pantalla principal: mainwindow.py ..................................... 92
9.3.
Cdigo ventana seleccin puerto serie: selectportdlg.py ........................ 94
9.4.
Mdulo configuracin pines: mode.py .................................................... 99
9.5.
Mdulo control pines digitales: digital.py .............................................. 101
9.6.
Mdulo lectura analgica: analog.py ..................................................... 103
9.7.
Mdulo control de PWM: pwm.py ......................................................... 107
9.8.
Mdulo control de servomotores: servo.py ........................................... 109
9.9.
Mdulo control de motores DC: motor.py ............................................. 113
9.10.
Mdulo secuenciador: sequencer.py ................................................. 117
9.11.
Cdigo para crear instalador: setup.py............................................... 122
9.12.
Script de compilacin para Linux: build-linux.sh ................................ 123
9.13.
Script de compilacin para Mac: build-mac.sh ................................... 127
10.
Anexo II: Instalacin del dispositivo USB ................................................ 132
11.
Anexo III: Manual de usuario de Platex .................................................. 137
11.1.
Instalacin ........................................................................................... 137
11.1.1. Microsoft Windows ........................................................................ 137
Pgina 86

Santiago Reig Chiva
Anexos
11.1.2. Linux Ubuntu .................................................................................. 139

11.1.3. Mac OS X ........................................................................................ 141
11.2.
Ventana inicial..................................................................................... 142
11.3.
Ventana principal ................................................................................ 143
11.3.1. Configuracin ................................................................................. 144

11.3.2. Digital.............................................................................................. 146
11.3.3. Analgico ........................................................................................ 147
11.3.4. PWM ............................................................................................... 149
11.3.5. Servo ............................................................................................... 150
11.3.6. Motores .......................................................................................... 152
11.3.7. Secuenciador .................................................................................. 154
12.
Anexo IV: Compilacin y distribucin del software................................ 157
12.1.
Windows ............................................................................................. 157
12.2.
Linux .................................................................................................... 160
12.3.
Mac OS ................................................................................................ 162
Pgina 87

Santiago Reig Chiva
Anexos
Ilustracin 35 | Nuevo hardware encontrado ................................................. 132
Ilustracin 36 | Seleccin de mtodo de bsqueda alternativa ...................... 133
Ilustracin 37 | Ubicacin donde buscar los controladores............................. 134
Ilustracin 38 | Instalando los controladores .................................................. 135
Ilustracin 39 | Los controladores no estn firmados ..................................... 135
Ilustracin 40 | El controlador se instal correctamente ................................ 136
Ilustracin 41 | Ruta de instalacin por defecto .............................................. 138
Ilustracin 42 | Aviso de modificacin del equipo ........................................... 138
Ilustracin 43 | Centro de Software de Ubuntu ............................................... 139
Ilustracin 44 | Se proporcionan los permisos de administrador .................... 140
Ilustracin 45 | Instalacin finalizada correctamente ...................................... 140
Ilustracin 46 | Permisos insuficientes............................................................. 141
Ilustracin 47 | Ventana inicial ......................................................................... 142
Ilustracin 48 | Mdulo de configuracin ........................................................ 144
Ilustracin 49 | Lista de modos ........................................................................ 145
Ilustracin 50 | Algunos pines configurados .................................................... 145
Ilustracin 51 | Mdulo digital ......................................................................... 146
Ilustracin 52 | Estado de activacin ............................................................... 147
Pgina 88

Santiago Reig Chiva
Anexos
Ilustracin 53 | Mdulo analgico ................................................................... 148

Ilustracin 54 | Traza analgica oculta ............................................................. 149
Ilustracin 55 | Mdulo PWM .......................................................................... 150
Ilustracin 56 | Servomotor de hobby ............................................................. 151
Ilustracin 57 | Mdulo servos......................................................................... 151
Ilustracin 58 | Activacin de servos................................................................ 152
Ilustracin 59 | Mdulo motores ..................................................................... 153
Ilustracin 60 | Motor Shield 3.0...................................................................... 154
Ilustracin 61 | Motor Shield R3 ...................................................................... 154
Ilustracin 62 | Mdulo secuenciador ............................................................. 155
Ilustracin 63 | Controles especficos .............................................................. 156
Ilustracin 64 | Activar salida del compilador .................................................. 159
Ilustracin 65 | Botn de verificar cdigo ........................................................ 159
Ilustracin 66 | Localizacin del firmware ....................................................... 160
Ilustracin 67 | Comando en una terminal de Linux Ubuntu ........................... 161
Ilustracin 68 | Comando en una terminal de Mac OS X Lion ......................... 163
Pgina 89

Santiago Reig Chiva
Anexos
ndice de tablas
Tabla 20 | Asignacin de pines ......................................................................... 154
Pgina 90

Santiago Reig Chiva
Anexos
9. Anexo : Diseno y programacion

de la aplicacion
9.1. Cdigo inicializacin aplicacin: platex.pyw
#!/usr/bin/env python
# -*- coding: utf-8 -*import sip
sip.setapi('QString', 2)
from PyQt4 import QtCore, QtGui
import sys, logging, os
from ui.mainwindow import MainWindow
import resources_rc
if __name__ == "__main__":
logging.basicConfig(format="%(levelname)-8s %(asctime)s %(module)12s %(message)s", level=logging.DEBUG)
logger = logging.getLogger(__name__)
app = QtGui.QApplication(sys.argv)
app.setOrganizationName("Universidad de La Rioja")
app.setOrganizationDomain("unirioja.es")
app.setApplicationName("Platex")
main = MainWindow()
main.show()
sys.exit(app.exec_())
Pgina 91

Santiago Reig Chiva
Anexos
9.2. Cdigo de la pantalla principal:

mainwindow.py
# -*- coding: utf-8 -*"""
This module contains the class MainWindow.
"""
import logging
from PyQt4.QtGui import QMainWindow, QPushButton, QMenu, QActionGroup
from PyQt4.QtCore import QTimer, pyqtSlot
from pyfirmata import Arduino, util
from
from
from
from
from
from
from
from
from
Ui_mainwindow import Ui_mainWindow

selectportdlg import SelectPortDlg
mode import ModeTab
analog import AnalogTab
digital import DigitalTab
pwm import PWMTab
servo import ServoTab
motor import MotorTab
sequencer import SequencerTab
class MainWindow(QMainWindow, Ui_mainWindow):
"""
MainWindow: this is the class that manages all the funcionality of
receiving input from the user.
"""
def __init__(self, parent=None):
"""
Default Constructor. It can receive a top window as parent.
"""
QMainWindow.__init__(self, parent)
logger.debug("Created MainWindow")
self.setupUi(self)
for x in xrange(2, 20):
eval("self.pin%02d"
{padding:0px}")
self.board = None
self.lastIndex = 0
(x)).setStyleSheet("*
QTimer.singleShot(0, self.selectPort)
Pgina 92

Santiago Reig Chiva
Anexos
def selectPort(self):
dialog = SelectPortDlg(self)
dialog.exec_()
# If empty object is returned, we exit
self.board = dialog.getBoard()
if not self.board:
self.close()
else:
self.tabs
=
(ModeTab(self),
AnalogTab(self),
PWMTab(self),
ServoTab(self),
SequencerTab(self))
self.tabs[0].enterTab()
DigitalTab(self),
MotorTab(self),
self.it = util.Iterator(self.board)
self.it.start()
@pyqtSlot(int)
def on_tabWidget_currentChanged(self, index):
"""
Slot documentation goes here.
"""
self.tabs[self.lastIndex].exitTab()
self.tabs[index].enterTab()
self.lastIndex = index
def closeEvent(self, event):
if hasattr(self.board, "exit"):
self.board.exit()
event.accept()
Pgina 93

Santiago Reig Chiva
Anexos
9.3. Cdigo ventana seleccin puerto serie:

selectportdlg.py
# -*- coding: utf-8 -*import logging, serial, os, sys
from PyQt4.QtGui import QDialog, QPushButton, QComboBox,
QStackedWidget, QHBoxLayout, QVBoxLayout, QWidget, QMessageBox
from PyQt4.QtCore import QTimer, pyqtSlot, QProcess
QLabel,
from pyfirmata import Board

from pyfirmata.boards import BOARDS
POSIX = False
if os.name == "posix":
import glob
POSIX = True
# Code for getting app folder
if isfrozen:
raise
determine
else:
entry = sys.path[0]
else:
else:
entry = sys.argv[0]
app
path
because
class SelectPortDlg(QDialog):
QDialog.__init__(self, parent)
logger.debug("Port selection dialog created")
statusLbl = QLabel("Programando el Arduino...")
self.connectBtn = QPushButton("&Conectar")
self.programBtn = QPushButton("&Programar")
exitBtn = QPushButton("Salir")
multiLbl = QLabel("&Selecciona la placa:")
self.portsCmb = QComboBox()
Pgina 94

Santiago Reig Chiva
Anexos
multiLbl.setBuddy(self.portsCmb)
self.stackedWidget = QStackedWidget()
mainWidget = QWidget()
mainLayout = QHBoxLayout()
mainLayout.addWidget(multiLbl)
mainLayout.addWidget(self.portsCmb)
mainWidget.setLayout(mainLayout)
self.stackedWidget.addWidget(mainWidget)
progWidget = QWidget()
progLayout = QHBoxLayout()
progLayout.addWidget(statusLbl)
progLayout.addStretch()
progWidget.setLayout(progLayout)
self.stackedWidget.addWidget(progWidget)
buttonLayout = QHBoxLayout()
buttonLayout.addWidget(self.connectBtn)
buttonLayout.addWidget(self.programBtn)
buttonLayout.addStretch()
buttonLayout.addWidget(exitBtn)
layout = QVBoxLayout()
layout.addWidget(self.stackedWidget)
layout.addLayout(buttonLayout)
self.setLayout(layout)
self.boards = list()
self.board = None
self.programBtn.clicked.connect(self.programBoard)
self.portsCmb.currentIndexChanged[int].connect(self.updatePorts)
self.connectBtn.clicked.connect(self.connectBoard)
exitBtn.clicked.connect(self.reject)
self.setWindowTitle(u"Iniciando comunicacin")
self.updatePorts(True)
logger.debug("Working dir: "+appdir)
@pyqtSlot()
def updatePorts(self, force=False):
# FIXME: Program button gets focus when opening QComboBox
if self.portsCmb.currentText() != "Actualizar" and not force:
return
logger.debug("Searching available serial ports")
self.connectBtn.setEnabled(False)
self.programBtn.setEnabled(False)
ports = list()
if POSIX:
Pgina 95

Santiago Reig Chiva
Anexos
ports
+=
+
+
+
try:
s.close()
pass
logger.debug("Found %d serial port(s): %s", len(ports), ports)
if not len(ports):
ports = [""]
self.portsCmb.clear()
self.portsCmb.addItems(ports)
self.portsCmb.addItem("Actualizar")
if self.portsCmb.currentText() != "":
self.connectBtn.setEnabled(True)
self.programBtn.setEnabled(True)
self.connectBtn.setFocus()
@pyqtSlot()
def connectBoard(self):
try:
logger.debug("Connecting
to
Arduino
board
on
port
"+self.portsCmb.currentText())
board
=
Board(self.portsCmb.currentText(),
BOARDS['arduino'])
except ValueError, e:
logger.warning(e)
QMessageBox.warning(self, u"!Atencin", unicode(e))
except TypeError, e:
logger.debug(e)
except serial.serialutil.SerialException, e:
logger.warning(e)
else:
logger.debug("Using
Arduino
board
on
port
"+board.sp.portstr)
self.board = board
self.accept()
@pyqtSlot()
def programBoard(self):
if
not
os.path.exists(os.path.join(appdir,
"PlatexFirmata.hex")):
"avrdude",
Pgina 96

Santiago Reig Chiva
Anexos
logger.error("Hexadecimal file not found")

QMessageBox.warning(self, u"Atencin!", u"No se pudo
encontrar el fichero a programar")
return
self.stackedWidget.setCurrentIndex(1)
logger.debug("Programming
Arduino
board
on
configuration
=
os.path.join(appdir,
"avrdude",
"avrdude.conf")
hexadecimal
=
"avrdude",
"PlatexFirmata.hex")
self.program = QProcess()
#
avrdude
reference:
http://www.ladyada.net/learn/avr/avrdude.html
command = "\""+executable+"\" -q -V -C \""+configuration+"\" p atmega328p -c arduino -P "+self.portsCmb.currentText()+" -b 115200 -D -U
logger.debug("avrdude call: "+command)
self.program.finished.connect(self.programFinished)
@pyqtSlot()
def programFinished(self):
output = str(self.program.readAllStandardError())
if output.find("flash written") == -1: # avrdude: xxxx bytes
of flash written
if output.find("Expected signature") != -1: # avrdude:
Expected signature for ATMEGA328P is 1E 95 0F
error = u"La placa conectada no tiene un chip
compatible."
elif output.find("not in sync: resp=0x00") != -1: #
avrdude: stk500_getsync(): not in sync: resp=0x00
error = u"No parece que haya ninguna placa conectada
al puerto."
elif output.find("ser_send()") != -1: # ser_send(): write
error: sorry no info avail
error = u"Se produjo un error durante la comunicacin
con la placa.\nAsegrate de que est correctamente conectada."
elif output.find("ser_open()") != -1: # ser_open(): ....
error = u"El puerto no se pudo abrir.\nAsegrate de
que ningn programa lo est usando."
else:
error = u"Se produjo un error al programar la
placa.\nComprueba el conexionado."
logger.warning("avrdude output: "+output)
logger.warning("An error ocurred: "+error)
QMessageBox.warning(self, u"Atencin!", error)
Pgina 97

Santiago Reig Chiva
Anexos
else:
logger.debug("Programmed successfully")
def getBoard(self):
return self.board
Pgina 98

Santiago Reig Chiva
Anexos
9.4. Mdulo configuracin pines: mode.py

# -*- coding: utf-8 -*import logging
from PyQt4.QtCore import pyqtSlot
from PyQt4.QtGui import QMenu, QActionGroup
class ModeTab(object):
def __init__(self, mwHandle):
self.mw = mwHandle
pin = eval("self.mw.pin%02d" % (x))
menu = QMenu(pin)
modeGroup = QActionGroup(self.mw)
modeGroup.setExclusive(True)
none = menu.addAction("&None")
modeGroup.addAction(none)
none.triggered.connect(self.clickNone)
none.setCheckable(True)
none.setChecked(True)
input = menu.addAction("&Input")
modeGroup.addAction(input)
input.triggered.connect(self.clickInput)
input.setCheckable(True)
output = menu.addAction("&Output")
modeGroup.addAction(output)
output.triggered.connect(self.clickOutput)
output.setCheckable(True)
if self.mw.board.pins[x].PWM_CAPABLE:
pwm = menu.addAction("&PWM")
modeGroup.addAction(pwm)
pwm.triggered.connect(self.clickPWM)
pwm.setCheckable(True)
if self.mw.board.pins[x].type == 2:
analogic = menu.addAction(u"&Analgico")
modeGroup.addAction(analogic)
analogic.triggered.connect(self.clickAnalog)
analogic.setCheckable(True)
pin.setMenu(menu)
pin.setStyleSheet("/* */") # force stylesheet update
def enterTab(self):
logger.debug("Entering mode tab")
Pgina 99

Santiago Reig Chiva
Anexos
def exitTab(self):
logger.debug("Exiting mode tab")
@pyqtSlot()
def clickNone(self):
self._changeMode(self.mw.sender(), 7)
@pyqtSlot()
def clickInput(self):
@pyqtSlot()
def clickOutput(self):
@pyqtSlot()
def clickPWM(self):
@pyqtSlot()
def clickAnalog(self):
def _changeMode(self, action, mode):
pin = action.parentWidget().parentWidget()
text = ['I', 'O', 'A', 'P', '', '', '', 'N']
pin.setText(text[mode])
pin.setStyleSheet("/* */") # force stylesheet update
number = int(pin.property("objectName").toString()[-2:])
self.mw.board.pins[number].mode = mode
if mode == 2:
self.mw.board.pins[number].disable_reporting()
logger.debug("Changed
pin
%d
mode
to
'%s'",
number,
pin.text())
Pgina 100

Santiago Reig Chiva
Anexos
9.5. Mdulo control pines digitales: digital.py

class DigitalTab(object):
self.mw = mwHandle
for x in self.mw.board.ports:
x.pinChanged.connect(self.updatePin)
@pyqtSlot(int, bool)
def updatePin(self, number, state):
logger.debug("Input pin "+str(number)+" changed its state to
"+str(state))
eval("self.mw.di%02d" % (number)).setChecked(state)
def enterTab(self):
logger.debug("Entering digital tab")
digPin = eval("self.mw.d%02d" % (x))
digInPin = eval("self.mw.di%02d" % (x))
digPin.setVisible(False)
digInPin.setVisible(False)
mode = self.mw.board.pins[x].mode
if mode == 1:
digPin.clicked.connect(self.digPinClicked)
digPin.setVisible(True)
digPin.setChecked(self.mw.board.pins[x].read())
elif mode == 0:
digInPin.setVisible(True)
digInPin.setChecked(self.mw.board.pins[x].read())
self.mw.board.pins[x].enable_reporting()
def exitTab(self):
logger.debug("Exiting digital tab")
self.mw.board.pins[x].disable_reporting()
@pyqtSlot()
def digPinClicked(self):
pin = self.mw.sender()
Pgina 101

Santiago Reig Chiva
Anexos
number = int(pin.property("objectName").toString()[-2:])
if pin.isChecked():
self.mw.board.pins[number].write(1)
logger.debug("Changed output pin "+str(number)+" state to
True")
else:
self.mw.board.pins[number].write(0)
logger.debug("Changed output pin "+str(number)+" state to
False")
Pgina 102

Santiago Reig Chiva
Anexos
9.6. Mdulo lectura analgica: analog.py

from functools import partial
from PyQt4.Qwt5 import QwtPlotGrid, QwtPlotCurve, QwtPlot, QwtPlotItem
from PyQt4.Qt import Qt, QPen
HISTORY = 60
class AnalogTab(object):
self.mw = mwHandle
self.curves = list()
self.data = list()
self.bars = list()
for i in xrange(0, 6):
self.bars.append({ 'group' : eval("self.mw.gbAnalog%d" %
(i)),
'bar'
eval("self.mw.analogBar%d"
eval("self.mw.lbAnalog%d"
(i)),
'label'
(i)),
'active'
eval("self.mw.analogShow%d"
% (i)) })
eval("self.mw.analogShow%d"
(i)).stateChanged.connect(partial(self._channelVisible, i))
self.mw.analogPlot.setAutoReplot(False)
self.mw.analogPlot.plotLayout().setAlignCanvasToScales(True)
grid = QwtPlotGrid()
grid.enableXMin(True)
grid.enableYMin(True)
grid.attach(self.mw.analogPlot)
grid.setPen(QPen(Qt.black, 0, Qt.DotLine))
grid.setMinPen(QPen(Qt.lightGray, 0, Qt.DotLine))
self.mw.analogPlot.setAxisScale(QwtPlot.xBottom, 0, HISTORY)
self.mw.analogPlot.setAxisScale(QwtPlot.yLeft, 0, 5)
self.mw.analogUnits.insertItems(0, ("Voltios", "Cuentas"))
self.mw.board.updateAnalog.connect(self._newSample)
self.mw.analogUnits.currentIndexChanged.connect(self._changedUnits)
Pgina 103

Santiago Reig Chiva
Anexos
self.mw.analogUnitsTime.currentIndexChanged.connect(self._changedUnitsTime)
self.mw.analogTime.valueChanged[int].connect(self._changedTime)
colors
=
(Qt.blue,
Qt.red,
Qt.black,
Qt.darkCyan, Qt.magenta)
for i in xrange(0, 6):
curve = QwtPlotCurve()
curve.setPen(QPen(colors[i], 2))
curve.attach(self.mw.analogPlot)
self.curves.append(curve)
self.data.append(self._zeros(HISTORY+1))
self.bars[i]['bar'].setFillBrush(colors[i])
Qt.darkGreen,
self.mw.analogPlot.replot()
@pyqtSlot(int, int)
def _newSample(self, channel, value):
if self.mw.analogUnits.currentIndex() is 0:
value = round(float(value*5) / 1023, 2)
self.data[channel] = self.data[channel][1:]
self.data[channel].append(value)
self.curves[channel].setData(range(0,
self.data[channel])
self._updatePlot(channel)
HISTORY+1),
def _updatePlot(self, channel):

if self.mw.analogUnits.currentIndex() is 0:
self.bars[channel]['bar'].setValue(round(self.data[channel][HISTORY], 1))
self.bars[channel]['label'].setText(str(round(self.data[channel][HISTORY],
1)))
else:
self.bars[channel]['bar'].setValue(int(self.data[channel][HISTORY]))
self.bars[channel]['label'].setText(str(int(self.data[channel][HISTORY])))
def enterTab(self):
logger.debug("Entering analog tab")
self._changedTime(self.mw.analogTime.value())
for pin in self.mw.board.pins:
if pin.type is 2:
channel = pin.pin_number-14
if pin.mode is 2:
pin.enable_reporting()
Pgina 104

Santiago Reig Chiva
Anexos
logger.debug("Enabled analog reporting of analog

pin "+str(channel))
self.curves[channel].setVisible(self.bars[channel]['active'].isChecked())
self.bars[channel]['group'].setEnabled(True)
else:
self.curves[channel].setVisible(False)
self.bars[channel]['group'].setEnabled(False)
self.bars[channel]['bar'].setValue(0)
self.bars[channel]['label'].setText(str(0))
self.data[channel] = self._zeros(HISTORY+1)
HISTORY+1),
self.data[channel])
def exitTab(self):
logger.debug("Exiting analog tab")
for pin in self.mw.board.pins:
if pin.type is 2 and pin.mode is 2:
channel = pin.pin_number-14
logger.debug("Disabled analog reporting of analog pin
"+str(channel))
pin.disable_reporting()
self.data[channel] = self._zeros(HISTORY+1)
self.mw.board.sampling_interval()
def _zeros(self, length):
x = list()
for i in xrange(0, length):
x.append(0)
return x
def _resizeHistory(self, factor):
for channel in xrange(0, len(self.data)):
for sample in xrange(0, len(self.data[channel])):
self.data[channel][sample] *= factor
HISTORY+1),
self.data[channel])
@pyqtSlot(int)
def _changedUnits(self, index):
if index is 0:
logger.debug("Changed analog units to volts")
self._resizeHistory(5.0/1024)
for bar in self.bars:
bar['bar'].setRange(0, 5)
else:
Pgina 105

Santiago Reig Chiva
Anexos
logger.debug("Changed analog units to counts")

self._resizeHistory(1024.0/5)
for bar in self.bars:
bar['bar'].setRange(0, 1024)
@pyqtSlot(int, int)
def _channelVisible(self, channel, state):
self.curves[channel].setVisible(state)
@pyqtSlot(int)
def _changedUnitsTime(self, index):
value = self.mw.analogTime.value()
self.mw.analogTime.blockSignals(True)
if index is 0:
self.mw.analogTime.setRange(19, 16383)
self.mw.analogTime.setValue(value*1000)
else:
self.mw.analogTime.setRange(0, 16)
self.mw.analogTime.setValue(value/1000)
self.mw.analogTime.blockSignals(False)
@pyqtSlot(int)
def _changedTime(self, time):
if self.mw.analogUnitsTime.currentIndex() is 0:
self.mw.board.sampling_interval(time)
else:
self.mw.board.sampling_interval(time*1000)
Pgina 106

Santiago Reig Chiva
Anexos
9.7. Mdulo control de PWM: pwm.py

class PWMTab(object):
self.mw = mwHandle
self.sliders = list()
for x in self.mw.board.pins:
if x.PWM_CAPABLE:
slider = eval("self.mw.pwmBar%02d" % x.pin_number)
slider.valueChanged.connect(self.updatePwm)
self.sliders.append(slider)
self.mw.cbPwmUnit.insertItems(0, ("Porcentaje", "Cuentas"))
self.mw.cbPwmUnit.currentIndexChanged.connect(self.changedUnits)
@pyqtSlot(int)
def updatePwm(self, value):
if self.mw.cbPwmUnit.currentIndex() is 0:
number
int(self.mw.sender().property("objectName").toString()[-2:])
logger.debug("PWM
value
pin
"+str(number)+"
set
"+str(int(value))+"%")
self.mw.board.pins[number].write(value/100)
else:
number
int(self.mw.sender().property("objectName").toString()[-2:])
logger.debug("PWM
value
pin
"+str(number)+"
set
"+str(int(value)))
self.mw.board.pins[number].write(round(value/1023, 2))
def enterTab(self):
logger.debug("Entering PWM tab")
if x.PWM_CAPABLE:
slider = eval("self.mw.pwmBar%02d" % x.pin_number)
slider.blockSignals(True)
eval("self.mw.gbPwm%02d"
x.pin_number).setEnabled(x.mode is 3)
=
to
=
to
Pgina 107

Santiago Reig Chiva
Anexos
slider.setValid(x.mode is 3)
slider.blockSignals(False)
def exitTab(self):
logger.debug("Exiting PWM tab")
@pyqtSlot(int)
def changedUnits(self, index):
if index is 0:
logger.debug("Changed PWM units to percentage")
for slider in self.sliders:
value = slider.value()
slider.setRange(0, 100, 1)
slider.setValue(round(value*100/1023))
else:
logger.debug("Changed PWM units to counts")
for slider in self.sliders:
value = slider.value()
slider.setValue(round(value*1023/100))
Pgina 108

Santiago Reig Chiva
Anexos
9.8. Mdulo control de servomotores: servo.py

class ServoTab(object):
self.mw = mwHandle
self.sliders = list()
self.selected = [0 for x in range(0, 6)]
slider = eval("self.mw.servoBar%d" % x)
spinBox = eval("self.mw.servoBox%d" % x)
self.sliders.append(slider)
self._groupEnabled(x, False)
self._disableCheckBox(x)
slider.valueChanged.connect(spinBox.setValue)
spinBox.valueChanged[int].connect(slider.setValue)
spinBox.valueChanged[int].connect(partial(self._updateServo, x))
eval("self.mw.servoCmb%d"
x).currentIndexChanged[str].connect(partial(self._pinSelected, x))
eval("self.mw.servoCb%d"
x).stateChanged[int].connect(partial(self._activated, x))
eval("self.mw.servoBut%d"
x).clicked.connect(partial(self._zero, x-1))
self.mw.servoBut0.clicked.connect(self._allZero)
%
%
%
def enterTab(self):
logger.debug("Entering servo tab")
self._updateAvailable()
def exitTab(self):
logger.debug("Exiting servo tab")
@pyqtSlot(int)
def _zero(self, slider):
if self.sliders[slider].isValid():
self.sliders[slider].setValue(0)
Pgina 109

Santiago Reig Chiva
Anexos
@pyqtSlot()
def _allZero(self):
for x in xrange(0, len(self.sliders)):
self._zero(x)
@pyqtSlot(int, int)
def _activated(self, group, status):
if status:
self._groupEnabled(group, True)
pin
=
int(eval("self.mw.servoCmb%d"
group).currentText())
logger.debug("Pin "+str(pin)+" set to Servo mode")
self.selected[group-1] = pin
self.mw.board.pins[pin].mode = 4
else:
self._groupEnabled(group, False)
pin = self.selected[group-1]
logger.debug("Pin "+str(pin)+" restored to Output mode")
self.selected[group-1] = 0
self.mw.board.pins[pin].mode = 1
self.mw.board.pins[pin].write(0)
def _groupEnabled(self, group, state):

eval("self.mw.servoBar%d" % group).setEnabled(state)
eval("self.mw.servoBar%d" % group).setValid(state)
eval("self.mw.servoBox%d" % group).setEnabled(state)
eval("self.mw.servoBut%d" % group).setEnabled(state)
def _disableCheckBox(self, group):
eval("self.mw.servoCb%d" % group).setChecked(False)
eval("self.mw.servoCb%d" % group).setEnabled(False)
@pyqtSlot(str)
def _pinSelected(self, group, pin):
if pin:
try:
self.suitables.remove(int(pin))
eval("self.mw.servoCb%d" % group).setEnabled(True)
except ValueError:
pass
else:
eval("self.mw.servoBox%d" % group).blockSignals(True)
eval("self.mw.servoBar%d" % group).setValue(0)
eval("self.mw.servoBox%d" % group).blockSignals(False)
self._groupEnabled(group, False)
self._disableCheckBox(group)
def _updateAvailable(self):
Pgina 110

Santiago Reig Chiva
Anexos
self.suitables = list()
# Search for pins set as output or servo modes
if x.mode in (1, 4):
self.suitables.append(x.pin_number)
# Search for non used pins
combo = eval("self.mw.servoCmb%d" % x)
try:
number = int(combo.currentText())
if number in self.suitables:
# If pin is on available list, remove it, we are
already using it
self.suitables.remove(number)
continue
except ValueError:
# If combobox content is not a number, is empty,
ignore
pass
# Create custom list for each combobox
# Made from available pin list plus the selected pin in the
combobox
combo = eval("self.mw.servoCmb%d" % x)
items = self.suitables[:]
number = 0
try:
number = int(combo.currentText())
items.append(number)
# copy list
# no pin selected
# add pin selected
in combobox
items.sort()
except ValueError:
pass
combo.blockSignals(True)
combo.clear()
combo.addItem("")
if len(items):
for pin in items:
combo.addItem(str(pin))
if number:
combo.setCurrentIndex(items.index(number)+1)
#eval("self.mw.servoCb%d" % x).setChecked(True)
combo.blockSignals(False)
@pyqtSlot(int, int)
def _updateServo(self, group, angle):
pin = int(eval("self.mw.servoCmb%d" % group).currentText())
Pgina 111

Santiago Reig Chiva
logger.debug("Moved
servo
on
"+str(angle)+"")
self.mw.board.pins[pin].write(angle)
Anexos
pin
"+str(pin)+"
to
Pgina 112

Santiago Reig Chiva
Anexos
9.9. Mdulo control de motores DC: motor.py

class MotorTab(object):
self.mw = mwHandle
for page in xrange(0, 3):
eval("self.mw.motorBut%d"
%
page).clicked.connect(partial(self.mw.motorSw.setCurrentIndex, page))
eval("self.mw.motorSAll%d"
%
page).clicked.connect(partial(self._allZero, page))
eval("self.mw.motorBut%d"
%
page).clicked.connect(partial(self._changedPage, page))
for section in ("A", "B"):
eval("self.mw.motorStop%s%d"
%
(section,
page)).clicked.connect(partial(self._zero, section, page))
eval("self.mw.motorPer%s%d"
%
(section,
page)).valueChanged[int].connect(partial(self._updateMotor, section, page))
eval("self.mw.motorAct%s%d"
%
(section,
page)).clicked.connect(partial(self._activated, section, page))
self._groupEnabled(section, page, False)
if page is 3:
eval("self.mw.motorPwm%s%d"
%
(section,
page)).currentIndexChanged[str].connect(partial(self._pinSelected, section))
eval("self.mw.motorDir%s%d" % (section, page))
def enterTab(self):
logger.debug("Entering motor tab")
for page in xrange(0, 3):
try:
pin1 = int(eval("self.mw.motorPwm%s%d" % (section,
page)).currentText())
pin2 = int(eval("self.mw.motorDir%s%d" % (section,
state = self.mw.board.pins[pin1].mode is 3 and
self.mw.board.pins[pin2].mode is 1
except ValueError:
Pgina 113

Santiago Reig Chiva
state = False
page)).setEnabled(state)
Anexos
(section,
def exitTab(self):
logger.debug("Exiting motor tab")
@pyqtSlot(int)
def _zero(self, section, page):
if eval("self.mw.motorAct"+section+str(page)).isChecked():
eval("self.mw.motorPer"+section+str(page)).setValue(0)
@pyqtSlot()
def _allZero(self, page):
self._zero(section, page)
@pyqtSlot(str, int, bool)
def _activated(self, section, page, status):
pin
=
int(eval("self.mw.motorPwm%s%d"
%
(section,
self._groupEnabled(section, page, status)
if status:
logger.debug("Activating
motor
"+section+"
in
pin
"+str(pin))
else:
logger.debug("Deactivating
motor
"+section+"
in
pin
"+str(pin))
eval("self.mw.motorPer%s%d" % (section, page)).setValue(0)
def _groupEnabled(self, section, page, state):
eval("self.mw.motorSli%s%d"
%
eval("self.mw.motorPer%s%d"
%
eval("self.mw.motorStop%s%d"
%
(section,
(section,
(section,
@pyqtSlot(str, str)
def _pinSelected(self, section, pin):
try:
pwm = eval("self.mw.motorPwm%s2" % section).currentText()
dir = eval("self.mw.motorDir%s2" % section).currentText()
eval("self.mw.servoCb%d" % group).setEnabled(True)
except ValueError:
pass
def _updateAvailable(self):
Pgina 114

Santiago Reig Chiva
Anexos
self.suitableDir = list()
self.suitablePwm = list()
# Search for pins set as output or servo modes
if x.mode is 1:
self.suitableDir.append(x.pin_number)
elif x.mode is 3:
self.suitablePwm.append(x.pin_number)
# Remove used pins in active configurations of page 2
try:
pwm
=
int(eval("self.mw.motorPwm%s2"
%
section).currentText())
dir
=
int(eval("self.mw.motorDir%s2"
%
section).currentText())
if eval("self.mw.motorAct%s2" % section).isChecked():
if pwm in self.suitablePwm:
self.suitablePwm.remove(pwm)
if dir in self.suitableDir:
self.suitableDir.remove(dir)
except ValueError:
pass
# Create custom list for each combobox
for type in ("Pwm", "Dir"):
combo = eval("self.mw.motor%s%s2" % (type, section))
if
not
eval("self.mw.motorAct%s2"
%
section).isChecked():
items = eval("self.suitable%s" % type)[:]
else:
items = [int(eval("self.mw.motor%s%s2" % (type,
section)).currentText())]
combo.blockSignals(True)
combo.clear()
if len(items):
for pin in items:
combo.addItem(str(pin))
combo.blockSignals(False)
@pyqtSlot(str, int, int)
def _updateMotor(self, section, page, speed):
pin
=
int(eval("self.mw.motorDir%s%d"
pwm
=
int(eval("self.mw.motorPwm%s%d"
logger.debug("Changed
motor
"+section+"
"+str(speed)+"%")
(section,
(section,
speed
to
Pgina 115

Santiago Reig Chiva
Anexos
self.mw.board.pins[pin].write(1 if speed > 0 else 0)

self.mw.board.pins[pwm].write(abs(speed)/100.0)
@pyqtSlot(int)
def _changedPage(self, page):
eval("self.mw.motorBut%d" % page).setChecked(True)
for x in [y for y in range(0,3) if y is not page]:
eval("self.mw.motorBut%d" % x).setChecked(False)
if
%
x)).isChecked():
%
x)).setChecked(False)
self._activated(section, page, False)
(section,
(section,
Pgina 116

Santiago Reig Chiva
Anexos
9.10. Mdulo secuenciador: sequencer.py

# -*- coding: utf-8 -*import logging, serial, os, sys
from PyQt4.QtGui import QDialog, QPushButton, QComboBox,
QStackedWidget, QHBoxLayout, QVBoxLayout, QWidget, QMessageBox
from PyQt4.QtCore import QTimer, pyqtSlot, QProcess
QLabel,
from pyfirmata import Board

from pyfirmata.boards import BOARDS
POSIX = False
if os.name == "posix":
import glob
POSIX = True
# Code for getting app folder
if isfrozen:
raise
determine
else:
entry = sys.path[0]
else:
else:
entry = sys.argv[0]
app
path
because
class SelectPortDlg(QDialog):
QDialog.__init__(self, parent)
logger.debug("Port selection dialog created")
statusLbl = QLabel("Programando el Arduino...")
self.connectBtn = QPushButton("&Conectar")
self.programBtn = QPushButton("&Programar")
exitBtn = QPushButton("Salir")
multiLbl = QLabel("&Selecciona la placa:")
self.portsCmb = QComboBox()
multiLbl.setBuddy(self.portsCmb)
Pgina 117

Santiago Reig Chiva
Anexos
self.stackedWidget = QStackedWidget()
mainWidget = QWidget()
mainLayout = QHBoxLayout()
mainLayout.addWidget(multiLbl)
mainLayout.addWidget(self.portsCmb)
mainWidget.setLayout(mainLayout)
self.stackedWidget.addWidget(mainWidget)
progWidget = QWidget()
progLayout = QHBoxLayout()
progLayout.addWidget(statusLbl)
progLayout.addStretch()
progWidget.setLayout(progLayout)
self.stackedWidget.addWidget(progWidget)
buttonLayout = QHBoxLayout()
buttonLayout.addWidget(self.connectBtn)
buttonLayout.addWidget(self.programBtn)
buttonLayout.addStretch()
buttonLayout.addWidget(exitBtn)
layout = QVBoxLayout()
layout.addWidget(self.stackedWidget)
layout.addLayout(buttonLayout)
self.setLayout(layout)
self.boards = list()
self.board = None
self.programBtn.clicked.connect(self.programBoard)
self.portsCmb.currentIndexChanged[int].connect(self.updatePorts)
self.connectBtn.clicked.connect(self.connectBoard)
exitBtn.clicked.connect(self.reject)
self.setWindowTitle(u"Iniciando comunicacin")
logger.debug("Working dir: "+appdir)
@pyqtSlot()
def updatePorts(self, force=False):
# FIXME: Program button gets focus when opening QComboBox
if self.portsCmb.currentText() != "Actualizar" and not force:
return
logger.debug("Searching available serial ports")
ports = list()
if POSIX:
ports
+=
+
+
+
Pgina 118

Santiago Reig Chiva
Anexos
try:
s.close()
pass
logger.debug("Found %d serial port(s): %s", len(ports), ports)
if not len(ports):
ports = [""]
self.portsCmb.clear()
self.portsCmb.addItems(ports)
self.portsCmb.addItem("Actualizar")
if self.portsCmb.currentText() != "":
@pyqtSlot()
def connectBoard(self):
try:
logger.debug("Connecting
to
Arduino
board
on
port
board
=
Board(self.portsCmb.currentText(),
BOARDS['arduino'])
except ValueError, e:
logger.warning(e)
except TypeError, e:
logger.debug(e)
except serial.serialutil.SerialException, e:
logger.warning(e)
else:
logger.debug("Using
Arduino
board
on
port
"+board.sp.portstr)
self.board = board
self.accept()
@pyqtSlot()
def programBoard(self):
if
not
os.path.exists(os.path.join(appdir,
"avrdude",
"PlatexFirmata.hex")):
logger.error("Hexadecimal file not found")
QMessageBox.warning(self, u"Atencin!", u"No se pudo
encontrar el fichero a programar")
Pgina 119

Santiago Reig Chiva
Anexos
return
logger.debug("Programming
Arduino
board
on
configuration
=
"avrdude",
"avrdude.conf")
hexadecimal
=
"avrdude",
"PlatexFirmata.hex")
self.program = QProcess()
#
avrdude
reference:
http://www.ladyada.net/learn/avr/avrdude.html
command = "\""+executable+"\" -q -V -C \""+configuration+"\" p atmega328p -c arduino -P "+self.portsCmb.currentText()+" -b 57600 -D -U
logger.debug("avrdude call: "+command)
self.program.finished.connect(self.programFinished)
@pyqtSlot()
def programFinished(self):
output = str(self.program.readAllStandardError())
if output.find("flash written") == -1: # avrdude: xxxx bytes
of flash written
if output.find("Expected signature") != -1: # avrdude:
Expected signature for ATMEGA328P is 1E 95 0F
error = u"La placa conectada no tiene un chip
compatible."
elif output.find("not in sync: resp=0x00") != -1: #
avrdude: stk500_getsync(): not in sync: resp=0x00
error = u"No parece que haya ninguna placa conectada
al puerto."
elif output.find("ser_send()") != -1: # ser_send(): write
error: sorry no info avail
error = u"Se produjo un error durante la comunicacin
con la placa.\nAsegrate de que est correctamente conectada."
elif output.find("ser_open()") != -1: # ser_open(): ....
error = u"El puerto no se pudo abrir.\nAsegrate de
que ningn programa lo est usando."
else:
error = u"Se produjo un error al programar la
placa.\nComprueba el conexionado."
logger.warning("avrdude output: "+output)
logger.warning("An error ocurred: "+error)
QMessageBox.warning(self, u"Atencin!", error)
else:
logger.debug("Programmed successfully")
Pgina 120

Santiago Reig Chiva
Anexos
def getBoard(self):
return self.board
Pgina 121

Santiago Reig Chiva
Anexos
9.11. Cdigo para crear instalador: setup.py

# http://cx_freeze.readthedocs.org/en/latest/distutils.html#distutils
import sys, os
from cx_Freeze import setup, Executable
base = None
targetName = "platex"
includes = []
if sys.platform == "win32":
base = "Win32GUI"
targetName = "platex.exe"
includes.extend(['numpy.core.multiarray', 'serial.win32'])
Platex_Target = Executable( script = "platex.pyw",
initScript = None,
base = base,
targetName = targetName,
compress = True,
copyDependentFiles = True,
appendScriptToExe = False,
appendScriptToLibrary = False,
shortcutName = "Platex",
shortcutDir = "ProgramMenuFolder")
include_files = ['avrdude/']
build_exe_options = {"packages": [],
"includes": includes,
"excludes": [],
"include_files": include_files}
setup(
name = "Platex",
version = "0.1",
description = "Control Arduino from your computer",
options = {"build_exe": build_exe_options},
executables = [Platex_Target])
Pgina 122

Santiago Reig Chiva
Anexos
9.12. Script de compilacin para Linux: buildlinux.sh

#!/bin/bash
asterisks ()
{
echo "*********************************************"
}
header ()
{
echo
asterisks
echo "$1"
asterisks
echo
}
remove()
{
if [ -d $1 ]; then
rm -rf $1
fi
}
create()
{
if [ ! -d $1 ]; then
mkdir -p $1
fi
}
remove_and_create()
{
remove $1
create $1
}
copy()
{
echo "COPYING [$1] TO [$2]"
cp $1 $2
}
PYQWT=5.2.0
ARDUINO=1.0
PROJECT=Platex
Pgina 123

Santiago Reig Chiva
Anexos
CXFREEZE=4.2.3
# Comprobar si tenemos permisos
if [ "$(id -u)" != "0" ]; then
echo "Uso: sudo $0"
exit 6
fi
#######
header \
"DO NOT RUN THIS SCRIPT ON A PRODUCTION COMPUTER
IT MAY END UP BREAKING THINGS
Press Ctrl+C to exit"
for i in {15..1}; do echo -ne "$i.." && sleep 1; done; echo
#######
#######
header "Creating build folder"
#######
remove_and_create build
cd build
#######
header "Installing libraries available in repositories"
#######
apt-get update
apt-get -y install git avrdude python-qt4 pyqt4-dev-tools python-pip
qt4-qmake g++ libqt4-dev python-sip-dev python-qt4-dev arduino-core alien rpm
pip install pyserial --upgrade
#######
header "Installing cx_Freeze $CXFREEZE"
#######
wget
--trust-server-name
http://prdownloads.sourceforge.net/cxfreeze/cx_Freeze-$CXFREEZE.tar.gz || exit 1
tar -zxvf cx_Freeze-$CXFREEZE.tar.gz
pushd cx_Freeze-$CXFREEZE
python setup.py install
popd
#######
header "Installing PyQwt $PYQWT"
#######
wget
--trust-server-name
http://prdownloads.sourceforge.net/pyqwt/PyQwt-$PYQWT.tar.gz || exit 1
tar -zxvf PyQwt-$PYQWT.tar.gz
Pgina 124

Santiago Reig Chiva
pushd PyQwt-$PYQWT/configure
python configure.py -Q
disable-numeric --disable-numpy
make
make install
popd
Anexos
../qwt-5.2
--qt4
--disable-numarray
--
#######
header "Downloading Arduino IDE $ARDUINO"
#######
wget http://arduino.googlecode.com/files/arduino-$ARDUINO-linux.tgz ||
exit 1
tar -zxvf arduino-$ARDUINO-linux.tgz
#######
header "Downloading and compiling $PROJECT source code"
#######
git clone https://github.com/chiva/$PROJECT.git
pushd $PROJECT
python mkpyqt.py -b -r
mkdir avrdude
pushd avrdude
cp `which avrdude` .
cp /etc/avrdude.conf .
popd
pushd firmware
pushd ${PROJECT}Firmata
make -f Makefile-linux
mv applet/${PROJECT}Firmata.hex ../../avrdude/
popd
popd
popd
#######
header "Creating distribution files"
#######
pushd $PROJECT
python setup.py bdist_rpm
pushd dist
alien -d $PROJECT-*.i386.rpm
popd
popd
#######
header "Cleaning workspace"
#######
Pgina 125

Santiago Reig Chiva
Anexos
mv $PROJECT/dist ../$PROJECT-dist
cd ..
remove build
rm "$0"
#######
header "Done!"
#######
Pgina 126

Santiago Reig Chiva
Anexos
9.13. Script de compilacin para Mac: buildmac.sh

#!/bin/bash
asterisks ()
{
echo "*********************************************"
}
header ()
{
echo
asterisks
echo "$1"
asterisks
echo
}
remove()
{
if [ -d $1 ]; then
rm -rfv $1
fi
}
create()
{
if [ ! -d $1 ]; then
mkdir -p $1
fi
}
remove_and_create()
{
remove $1
create $1
}
copy()
{
echo "COPYING [$1] TO [$2]"
cp $1 $2
}
PROJECT=Platex
GCC=10.7-v2
GIT=1.7.8.3
Pgina 127

Santiago Reig Chiva
Anexos
PYTHON=2.7.2
QT=4.7.4
SIP=4.13.2
PYQT=4.9.1
PYQWT=5.2.0
AVRDUDE=5.11.1
ARDUINO=1.0
CXFREEZE=4.2.3
#######
header \
"DO NOT RUN THIS SCRIPT ON A PRODUCTION COMPUTER
IT MAY END UP BREAKING THINGS
RUN WITH SUDO
Press Ctrl+C to exit"
for i in {15..1}; do echo -ne "$i.." && sleep 1; done; echo
#######
#######
header "Creating build folder"
#######
remove_and_create build
cd build
#######
header "Installing GCC $GCC"
#######
curl -fLO --retry 20 https://github.com/downloads/kennethreitz/osxgcc-installer/GCC-$GCC.pkg || exit 1
installer -pkg GCC-$GCC.pkg -target "/"
#######
header "Installing Git $GIT"
#######
curl -fO --retry 20 http://git-osx-installer.googlecode.com/files/git$GIT-intel-universal-snow-leopard.dmg || exit 1
hdiutil attach git-$GIT-intel-universal-snow-leopard.dmg
installer
-pkg
/Volumes/Git\
$GIT\
Snow\
Leopard\
Intel\
Universal/git-$GIT-intel-universal-snow-leopard.pkg -target "/"
hdiutil detach /Volumes/Git\ $GIT\ Snow\ Leopard\ Intel\ Universal
#######
header "Installing Python $PYTHON"
#######
Pgina 128

Santiago Reig Chiva
Anexos
curl
-fO
--retry
20
http://python.org/ftp/python/$PYTHON/python$PYTHON-macosx10.6.dmg || exit 1
hdiutil attach python-$PYTHON-macosx10.6.dmg
installer -pkg /Volumes/Python\ $PYTHON/Python.mpkg -target "/"
hdiutil detach /Volumes/Python\ $PYTHON/
PATH="/Library/Frameworks/Python.framework/Versions/Current/bin:${PATH
}"
export PATH
#######
header "Installing Qt $QT"
#######
curl
-fO
--retry
20
http://get.qt.nokia.com/qt/source/qt-macopensource-$QT.dmg || exit 1
hdiutil attach qt-mac-opensource-$QT.dmg
installer -pkg /Volumes/Qt\ $QT/Qt.mpkg -target "/"
hdiutil detach /Volumes/Qt\ $QT
#######
header "Installing SIP $SIP"
#######
curl
-fO
--retry
http://www.riverbankcomputing.co.uk/static/Downloads/sip4/sip-$SIP.tar.gz
exit 1
tar -zxvf sip-$SIP.tar.gz
pushd sip-$SIP
python configure.py
make
make install
popd
20
||
#######
header "Installing PyQt $PYQT"
#######
curl
-fO
--retry
http://www.riverbankcomputing.co.uk/static/Downloads/PyQt4/PyQt-mac-gpl$PYQT.tar.gz || exit 1
tar -zxvf PyQt-mac-gpl-$PYQT.tar.gz
pushd PyQt-mac-gpl-$PYQT
echo "yes" | python configure.py
make
make install
popd
20
#######
header "Installing PyQwt $PYQWT"
#######
Pgina 129

Santiago Reig Chiva
Anexos
MIN_PYQWT=`echo "$PYQWT" | cut -d. -f 1-2`

curl -fLO --retry 20 http://prdownloads.sourceforge.net/pyqwt/PyQwt$PYQWT.tar.gz || exit 1
ln /usr/bin/qmake /bin/qmake
tar -zxvf PyQwt-$PYQWT.tar.gz
pushd PyQwt-$PYQWT/configure
python configure.py -Q ../qwt-$MIN_PYQWT --qt4 --disable-numarray
--disable-numeric --disable-numpy
make
make install
popd
#######
header "Installing pySerial"
#######
easy_install pip
pip install pyserial
#######
header "Installing cx_Freeze $CXFREEZE"
#######
curl
-fLO
--retry
20
http://prdownloads.sourceforge.net/cxfreeze/cx_Freeze-$CXFREEZE.tar.gz || exit 1
tar -zxvf cx_Freeze-$CXFREEZE.tar.gz
pushd cx_Freeze-$CXFREEZE
python setup.py install
popd
#######
header "Installing avrdude $AVRDUDE"
#######
curl
-fLO
--retry
http://download.savannah.gnu.org/releases/avrdude/avrdude-$AVRDUDE.tar.gz
exit 1
tar -zxvf avrdude-$AVRDUDE.tar.gz
pushd avrdude-$AVRDUDE
./configure
make
make install
popd
20
||
#######
header "Downloading Arduino IDE $ARDUINO"
#######
Pgina 130

Santiago Reig Chiva
Anexos
curl
-fO
--retry
20
http://arduino.googlecode.com/files/arduino$ARDUINO-macosx.zip || exit 1
unzip arduino-$ARDUINO-macosx.zip
#######
header "Downloading and compiling $PROJECT source code"
#######
git clone https://github.com/chiva/$PROJECT.git
pushd $PROJECT
python mkpyqt.py -b -r
mkdir avrdude
pushd avrdude
cp `which avrdude` .
cp /usr/local/etc/avrdude.conf .
popd
pushd firmware
pushd ${PROJECT}Firmata
make -f Makefile-mac
mv applet/${PROJECT}Firmata.hex ../../avrdude/
popd
popd
popd
#######
header "Creating distribution files"
#######
pushd $PROJECT
python setup.py bdist_dmg
popd
#######
header "Cleaning workspace"
#######
mv $PROJECT/dist ../$PROJECT-dist
cd ..
remove build
rm "$0"
#######
header "Done!"
#######
Pgina 131

Santiago Reig Chiva
Anexos
10. Anexo : nstalacion del

dispositivo USB
Al ser el medio de comunicacin escogido a travs del Arduino y el ordenador,
el puerto serie emulado a travs de USB, puede que debamos instalar los drivers
adecuados para que el sistema operativo reconozca este perifrico y se pueda utilizar
con el proyecto.
En las plataformas Linux y Mac OS X se instalarn los drivers automticamente
pasados unos segundos tras conectar la placa, por lo que no hay que realizar ninguna
accin ms.
En Linux el puerto serie aparecer listado como ttyACMxx, mientras que en
Mac OS X aparecer como tty.usbserialxxxx.
Si por el contrario, se desea trabajar bajo una plataforma Windows, se
requieren realizar unos pasos adicionales.
El primer paso es descargar el software de Arduino, que trae consigo los
controladores necesarios para la correcta identificacin de la placa por el sistema
operativo. Se puede obtener de la seccin Downloads de la pgina oficial de Arduino
(www.arduino.cc), archivo que deber descomprimirse para permitir el acceso a su
contenido.
Al realizar la conexin de la placa de interfaz Arduino al ordenador por primera
vez, aparecer el siguiente aviso en la barra de tareas, indicando que se estn
buscando los drivers adecuados.
Ilustracin 35 | Nuevo hardware encontrado
Pgina 132

Santiago Reig Chiva
Anexos
Transcurridos unos segundos, nos aparecer una nueva ventana para

seleccionar la localizacin driver manualmente, ya que el asistente no pudo
encontrarlos por si mismo. Hacemos clic en 'Buscar software de controlador en el
equipo' para continuar con el proceso de instalacin.
Ilustracin 36 | Seleccin de mtodo de bsqueda alternativa
Le indicamos la ubicacin donde estn los drivers de Arduino, que ser la

carpeta 'drivers' dentro de la carpeta del software de Arduino que nos hemos
descargado anteriormente. Es importante que la opcin de buscar en subcarpetas est
activada. Hacemos clic en 'Siguiente' para que inicie la bsqueda.
Pgina 133

Santiago Reig Chiva
Anexos
Ilustracin 37 | Ubicacin donde buscar los controladores
El asistente comprobar si existen los drivers adecuados para el Arduino dentro

de las carpetas indicadas.
Pgina 134

Santiago Reig Chiva
Anexos
Ilustracin 38 | Instalando los controladores
Puede que durante el proceso se te pida autorizar a Windows el instalar unos

drivers no firmados, selecciona la segunda opcin para poder continuar con la
instalacin. Este aviso solo sale con las placas de la ltima generacin, por lo que es
posible que no te aparezca.
Ilustracin 39 | Los controladores no estn firmados
La placa Arduino ya est lista para ser usada con Platex.
Pgina 135

Santiago Reig Chiva
Anexos
Ilustracin 40 | El controlador se instal correctamente
El puerto serie aparecer listado como cualquier otro, siguiendo la

nomenclatura de COMxx.
Pgina 136

Santiago Reig Chiva
Anexos
11. Anexo : Manual de usuario

de Platex
11.1. Instalacin
Debido a que los usuarios a los que va dirigidos el proyecto, probablemente no
dispongan de conocimientos avanzados sobre Python, sus libreras y la compatibilidad
con los principales sistemas operativos, se ha decidido crear una serie de instaladores
para la mayora de los sistemas operativos que un usuario normal use.
El instalador posee los ficheros del proyecto, las libreras de las que ste hace
uso y el intrprete de Python sobre el que se haya creado el instalador, por lo que para
el usuario, no tiene diferencia alguna la instalacin de este software a otros muchos de
los que hayan pasado por sus manos, dejando todo listo para su uso y sin requisitos
previos de software algunos.
11.1.1. Microsoft Windows

El desarrollo del programa fue realizado sobre este sistema operativo,
concretamente sobre Windows 7, por lo que es el que se recomienda para disfrutar de
la mejor experiencia de usuario posible. La compatibilidad del programa sobre
Windows XP tambin fue tenida en cuenta, aadiendo los ficheros necesarios para la
correcta ejecucin del proyecto sobre dicho sistema operativo.
El instalador disponible para la plataforma Windows es compatible tanto con
XP, como con Vista y 7 (y probablemente con las siguientes versiones mientras se
mantenga la interfaz).
Al abrir el instalador, tras configurarse, nos mostrar la ruta por defecto para la
instalacin. Se aconseja dejar esta ruta por defecto. La instalacin requiere de
permisos de administrador, para realizar las modificaciones necesarias al sistema.
Pgina 137

Santiago Reig Chiva
Anexos
Ilustracin 41 | Ruta de instalacin por defecto
Una vez iniciada la instalacin, nos aparecer la ventana pidiendo permisos de

administrador para continuar con la instalacin.
Ilustracin 42 | Aviso de modificacin del equipo
Una vez finalizada la instalacin y cerrado el asistente, podremos entrar a la

aplicacin a travs del acceso directo creado en el men de inicio.
Pgina 138

Santiago Reig Chiva
Anexos
11.1.2. Linux Ubuntu

Las pruebas de compatibilidad y el paquete de instalacin fueron creados sobre
Linux Ubuntu 11.10, asegurando, como mnimo, la completa funcionalidad del
proyecto bajo esta versin. Aunque segn las pruebas realizadas tambin se puede
realizar la instalacin en Linux Ubuntu 12.04 sin problema alguno.
Tambin se han incluido los paquetes de instalacin para otras distribuciones,
aunque no se garantiza su funcionamiento debido a la gran diversidad de
configuraciones que pueden existir.
Para instalar el proyecto en Linux Ubuntu 11.10, se deber utilizar el paquete
de instalacin con la extensin de archivo .deb. Una vez se disponga de este archivo
en el sistema, se ejecutar haciendo doble clic sobre l, abriendo el Centro de
Software de Ubuntu que asistir la instalacin.
Ilustracin 43 | Centro de Software de Ubuntu
Para iniciar la instalacin se pinchar sobre Instalar, que ejecutar la

instalacin del paquete en segundo plano.
Antes de iniciar la instalacin se nos requerir dar permisos de administrador,
para que as el instalador pueda realizar todas las tareas satisfactoriamente.
Pgina 139

Santiago Reig Chiva
Anexos
Ilustracin 44 | Se proporcionan los permisos de administrador
Una vez se haya instalado correctamente el software, se nos darn las

instrucciones de como ejecutar el programa instalado.
Ilustracin 45 | Instalacin finalizada correctamente
Como se puede observar, se debe ejecutar platex en la terminal de Ubuntu.

Si al ejecutar el programa nos aparece una ventana de error, que nos avisa de
que ha sido imposible abrir el puerto serie, significa que no tenemos los permisos
suficientes par ello, por lo que deberemos aadir nuestro usuario al grupo adecuado
para poder realizar esta operacin.
Pgina 140

Santiago Reig Chiva
Anexos
Ilustracin 46 | Permisos insuficientes
Para solucionar este problema se deber ejecutar en una terminal:

$ usermod a G dialout USUARIO
Donde USUARIO es el nombre del usuario con el que se haya iniciado sesin en
el sistema. Para que se hagan efectivos los cambios, se deber cerrar la sesin y volver
a entrar.
11.1.3. Mac OS X
Durante el desarrollo del proyecto, la compatibilidad de la librera encargada de
realizar el empaquetamiento e instalador no estaba completada, por lo que ha sido
imposible realizar el paquete de instalacin de este proyecto para la plataforma Mac.
Una vez se solucione este problema, la instalacin se realizar de la misma
forma que cualquier otra aplicacin.
Como solucin para correr el software bajo este sistema operativo, se deber
realizar con la ayuda del script de compilacin del proyecto para Mac, que aunque est
preparado para no interferir con el normal funcionamiento del ordenador en su uso
diario, no es recomendable realizarlo sin conocimiento del funcionamiento. La gua
para la utilizacin de este script viene adjuntada en el siguiente anexo.
Pgina 141

Santiago Reig Chiva
Anexos
11.2. Ventana inicial

El resto del manual de uso, al ser un programa multiplataforma que se muestra
y funciona de forma similar en todas ellas, slo se realizar la explicacin en una de
ellas. En esta explicacin se utilizar la ejecucin en Windows, al haber sido la
plataforma donde se ha realizado la mayor parte del desarrollo.
Al ejecutar el programa se nos mostrar una ventana con la que podemos
realizar varias operaciones.
Ilustracin 47 | Ventana inicial
Primero deberemos seleccionar el puerto serie al que est conectada la placa

Arduino que se desea utilizar con el programa. Si todava no est conectada, se puede
realizar la conexin y luego repetir la bsqueda de puertos serie activos desplegando la
lista y seleccionando Actualizar. Si no aparece la placa en la lista, se deber comprobar
que los drivers estn correctamente instalados y el puerto serie aparezca en los
recursos del sistema.
Una vez seleccionado el puerto serie, podemos realizar tres operaciones:
Conectar: se inicia la comunicacin con la placa que se haya indicado y si

est con el firmware adecuado y no hay problemas de comunicacin, se
podr empezar a usar el programa en todo su potencial.
Programar: las placas Arduino son reprogramables, por lo que no siempre

tendrn el firmware adecuado para realizar la comunicacin con el
software. Por ello se da la opcin de descargar el firmware adecuado a la
placa con un nico clic de ratn.
Pgina 142

Santiago Reig Chiva
Anexos
Salir: se cierra el programa, para esta opcin no es necesario tener

seleccionado un puerto serie.
Para poder acceder a la ventana principal del programa deberemos

conectarnos a la placa una vez tenga el firmware adecuado.
11.3. Ventana principal

En la ventana principal del programa podremos ver los distintos mdulos de los
que se compone ste. Cada mdulo corresponde a una pestaa y en el momento de la
realizacin de este documento, existen los siete siguientes:
Configuracin
Digital
Analgico
PWM
Servo
Motores
Secuenciador
El programa se abrir por defecto con el mdulo de configuracin en primer

plano, ya que no es posible realizar ninguna accin sin primero configurar alguno de
los pines.
A continuacin se explicarn el motivo por el que se han incluido y su
funcionamiento.
Pgina 143

Santiago Reig Chiva
Anexos
11.3.1. Configuracin
Este mdulo nos muestra una representacin del Arduino en pantalla,
pudiendo seleccionar individualmente en cada pin de la placa el modo en el que
queremos hacerlo funcionar. Cada modo tiene un color asignado, que facilitar la
comprobacin del modo seleccionado por el usuario.
Ilustracin 48 | Mdulo de configuracin
Existen los siguientes modos de funcionamiento:
None: el pin no tiene ninguna funcin, se configura como entrada y se

desactivan las resistencias internas de pull-up.
Input: el pin se utilizar para realizar lecturas digitales (1 0).
Output: el pin se utilizar como salida con niveles lgicos (1 0). Bajo este
modo se podr hacer tambin control de servomotores de radiocontrol.
Pgina 144

Santiago Reig Chiva
Anexos
PWM: el pin se utilizar como salida de ancho de pulso modulado, til para
reguladores, dimmers y otros elementos que necesiten una forma de
control ms precisa que el todo o nada de la lgica digital.
Analgico: el pin se utilizar como entrada analgica con una resolucin de

lectura de 10 bits.
Para cambiar el modo de un pin se deber pinchar sobre el que queremos

realizar la operacin, desplegndose una lista con todos los posibles modos de
funcionamiento compatibles con el pin seleccionado, para realizar el cambio slo se
deber seleccionar de entre los modos disponibles. Los cambios de modo realizados
son aplicados instantneamente tras realizar la seleccin.
Ilustracin 49 | Lista de modos
Ilustracin 50 | Algunos pines configurados
Los pines analgicos tambin pueden ser usados tanto como entradas como salidas
digitales, por lo que se ha dado la opcin de configurarlos como tales en el software.
Pgina 145

Santiago Reig Chiva
Anexos
Los pines 0 y 1 no estn disponibles para su uso ya que se utilizan para realizar
la comunicacin entre el software y la propia placa, son los encargados de realizar la
comunicacin por el puerto serie.
11.3.2. Digital
Este mdulo tambin muestra la representacin de un Arduino en pantalla y
slo se muestran los pines que se hayan configurado anteriormente como entrada o
salidas.
Ilustracin 51 | Mdulo digital
Las entradas vienen designadas por un crculo verde oscuro encima del pin,
intentando asemejarse a un led verde, y de color ms claro al detectar un nivel alto en
l.
Las salidas se muestran como un cuadrado, similar a los existentes en el
mdulo de configuracin, de un color azul grisceo cuando la salida est desactivada y
Pgina 146

Santiago Reig Chiva
Anexos
un amarillo dorado cuando se haya activado. Para cambiar de estado la salida slo hay
que pinchar con el ratn encima de l.
Ilustracin 52 | Estado de activacin
Si la entrada parpadea rpidamente, probablemente signifique que el pin

correspondiente esta al aire leyendo ruido, sin ninguna tensin aplicada.
11.3.3. Analgico
La finalidad de ste mdulo es la de mostrar la tensin existente en los pines
analgicos que se hayan configurado como tales.
Pgina 147

Santiago Reig Chiva
Anexos
Ilustracin 53 | Mdulo analgico
El valor de la tensin analgica en el pin se muestra en forma de texto y

grficamente en forma de barra, de forma individual de cada pin. Tambin se muestra
en una grfica a travs del tiempo de forma que se puede ver la evolucin de la
tensin. Esta grfica es comn a todos los pines, por lo que se puede realizar
comparaciones de tensiones de forma sencilla y rpida y mediante los selectores en
cada uno de los pines, se puede indicar si se desea o no que se grafique la tensin de
dicho pin en la grfica general. Cada pin analgico tiene asignado un color, por lo que
es fcil relacionar el pin con la tensin que se dibuja en la grfica comn a todos ellos.
Pgina 148

Santiago Reig Chiva
Anexos
Ilustracin 54 | Traza analgica oculta
Hay que tener en cuenta que el voltaje se muestra mediante una simple regla
de 3 desde el valor en cuentas, es decir, de 0 a 1023 se convierte de 0 a 5V. Esto
tcnica de conversin, aunque sencilla, tiene un problema, ya que las cuentas son el
valor del voltaje con respecto a la tensin de alimentacin, por lo que una lectura de
1023, no es la misma a 3V que a 5V, representando 3V y 5V respectivamente. En el
software se ha supuesto que se utiliza el Arduino tal y como es recomendado, a 5V,
aunque pueden existir pequeas desviaciones de la tensin del orden de unos pocos
cientos de milivoltios, que se suman a los errores de conversin de los ADC del
Arduino.
11.3.4. PWM
Con este mdulo podremos sacar una seal de PWM en los pines que tengan
capacidad para ello, los cuales tienen el texto PWM junto a ellos en el mdulo de
configuracin.
Pgina 149

Santiago Reig Chiva
Anexos
Los deslizadores solo se activarn si el pin correspondiente est configurado

como PWM y permiten modificar el ancho de pulso tanto en porcentaje (0100%)
como en cuentas de 8 bits (0256). Siendo el 0% una salida continua a nivel bajo y al
100% una salida a nivel alto, que en este caso seran los 5V de alimentacin.
Ilustracin 55 | Mdulo PWM
11.3.5. Servo
Este mdulo est creado para controlar la posicin de servomotores de hobby,
que pueden ser controlados para moverse a una determinada posicin en grados de 0
a 180.
Pgina 150

Santiago Reig Chiva
Anexos
Ilustracin 56 | Servomotor de hobby
Se pueden controlar hasta un mximo de seis servos simultneamente,

pudiendo activarse, desactivarse y cambiar la asignacin de pines en cualquier
momento.
Ilustracin 57 | Mdulo servos
Pgina 151

Santiago Reig Chiva
Anexos
En la lista podremos seleccionar uno de los pines que estn configurados como
entradas (Input) y al seleccionar Activar se configurar en modo servo, por lo que
estar listo para controlar dichos motores.
Ilustracin 58 | Activacin de servos
El ngulo de giro de los servos puede ser controlado tanto con la barra
deslizadora como introduciendo manualmente el valor en grados en la caja numrica.
Se han incluido botones para devolver al origen los motores tanto individualmente
como de forma general a todos ellos.
Si se desea volver a utilizar ese pin para otras funciones, se deber desmarcar la
casilla de Activar, volviendo a configurarse el pin como entrada, listo para poder ser
usado en otros mdulos.
11.3.6. Motores
Con este mdulo se podr realizar el control de motores de continua, tanto
pequeos como grandes; la limitacin vendr dada por el hardware, en concreto, por
el lmite tanto de tensin como de intensidad del driver de motores utilizado.
Pgina 152

Santiago Reig Chiva
Anexos
Ilustracin 59 | Mdulo motores
Por defecto se incluyen la configuracin para las shields de control de motores

oficiales de Arduino, que son la Motor Shield 3.0 y la Motor Shield R3. La shield de
Sparkfun Ardumoto, que aunque no es oficial, es compatible con la configuracin de la
Motor Shield R3, ya que est diseada con el mismo hardware y la misma asignacin
de pines.
Pgina 153

Santiago Reig Chiva
Anexos
Ilustracin 60 | Motor Shield 3.0
Ilustracin 61 | Motor Shield R3
Tabla 20 | Asignacin de pines
Motor Shield 3.0
Motor Shield R3
Canal A
Canal B
Canal A
Canal B
Direccin
12
13
12
13
Velocidad
10
11
11
Tambin se incluye la posibilidad de definir manualmente los pines en el modo

Personalizado para poder utilizar placas creadas por otros fabricantes o por el mismo
usuario. El control est pensado para los drivers L293D y L298 de Texas Instruments,
pero tambin podra utilizarse con otros drivers de otros fabricantes que tengan una
interfaz de control similar o con un puente en H discreto con la circuitera de interfaz
adecuada.
Para comenzar el control se deber activar cada canal de la placa marcando la
casilla de Activar y para empezar a mover el motor, se podr deslizar la barra a la
izquierda para moverlo en un sentido o hacia la derecha para moverlo en el contrario
(el control de sentido de giro se hace automticamente). Tambin se podr realizar el
control introduciendo el valor en porcentaje de velocidad del motor de 0 a 100 y con el
signo adecuado para el sentido de giro que se desee. En este mdulo tambin se han
incluido botones de paro tanto individuales para cada canal, como globales.
11.3.7. Secuenciador
Se podra decir que este es el mdulo ms complejo, completo y til de todos
los incluidos hasta el momento, ya que contiene una parte de casi todos los mdulos,
permitiendo adems preparar una secuencia de pasos en los que se realizarn las
acciones indicadas por el usuario.
Pgina 154

Santiago Reig Chiva
Anexos
Ilustracin 62 | Mdulo secuenciador
Debido al limitado espacio existente en pantalla, se han limitado las opciones

para que la usabilidad del mismo no se reduzca considerablemente.
Se han incluido en este mdulo, seis salidas digitales, tres pines para controlar
servos y 3 salidas de PWM. Los pines a los que estn asignados cada funcin son fijos y
no modificables, estando indicados por el nmero encima de cada control. Los
controles solo estarn activos si el pin al que estn asignados est configurado de
forma que sea compatible con la funcin que desempean en este mdulo.
La utilizacin de los controles es similar a la que se encuentra en cada uno de
los mdulos por separado, por lo que no es necesaria repetir su explicacin, siendo
ms importante centrarse en los nuevos y especficos encontrados slo en este
mdulo.
Pgina 155

Santiago Reig Chiva
Anexos
Ilustracin 63 | Controles especficos
La primera caja numrica controla los pasos del secuenciador, los cambios que
se realicen en los controles se aplicarn al paso que aparezca en esta caja. Al cambiar
el nmero de paso se guardaran los valores de los controles y se cargarn los del paso
que se haya elegido. Por defecto se inicia con un solo paso y se podrn aadir ms
como se explica ms adelante.
En la segunda caja, se podr indicar el tiempo en milisegundos durante que
estar activo el paso actual. Se puede introducir los valores manualmente o usando las
flechas en el borde derecho y puede tomar valores desde 1 ms a 10000 ms (10
segundos).
Los botones con los smbolos + y sirven para aadir un paso a continuacin
del actual o para eliminar el paso actual, respectivamente.
El botn Iniciar, comenzar con la ejecucin en secuencia de los pasos,
realizando las acciones que se hayan indicado en cada uno de ellos y durante el tiempo
establecido. Una vez iniciada la secuencia no es posible pararla ni realizar ninguna otra
accin en el programa, hasta que no se haya finalizado el ltimo paso.
Pgina 156

Santiago Reig Chiva
Anexos
12. Anexo V: Compilacion y

distribucion del software
Al estar todo el software del proyecto licenciado bajo GPL, el acceso y la
redistribucin del cdigo fuente de este proyecto es libre, por lo que no sera extrao
que se diera el caso de que una persona necesitara rehacer el instalador desde el
cdigo fuente tras haber realizado una serie de cambios, ya sea para mejorar, adaptar
o cualquier otra razn. Para ello se indicarn los pasos a realizar en cada plataforma
con los que pasar del cdigo fuente al instalador, listo para distribuir e instalar de
manera sencilla para el usuario final.
El cdigo fuente al completo puede encontrarse en el CD que acompaa este
documento, aunque las herramientas de creacin del instalador estn preparadas para
obtenerlo desde la copia que se mantiene actualizada en un servidor de control de
versiones: https://github.com/chiva/Platex
12.1. Windows
Debido al bajo nmero de herramientas de automatizacin de tareas existentes
o su alta dificultad de uso o poca difusin, se ha optado por realizar una parte de ella
manualmente.
La primera tarea a realizar ser instalar una versin del intrprete de Python, el
proyecto se ha desarrollado usando la versin 2.7.2, por lo que es la que se
recomienda instalar, tambin hay una alta probabilidad de que sea compatible con las
siguientes revisiones de esta versin, tales como 2.7.3 (que ya est lanzada y es
compatible), la futura 2.7.4, etc. mientras que la subversin siga siendo la 2.7. Como
tambin se deben instalar otras libreras necesarias para el proyecto y existe un
instalador de Python enfocado desarrollo por cientficos e ingenieros con una gran
cantidad de libreras numricas y anlisis y visualizacin de datos llamada Python(x,y),
se recomienda el uso de esta, ya que contiene todas las libreras que se necesitarn y
permite instalarlas de una manera sencilla y cmoda, evitando as realizar compilacin
Pgina 157

Santiago Reig Chiva
Anexos
alguna. Para ello se realizar la descarga del paquete de instalacin desde la seccin de
descargas de su pgina web.
Una vez descargado el paquete se proceder a su instalacin siguiendo el
asistente, cuando se alcance la seccin de seleccin de componentes se debern
seleccionar como mnimo los siguientes:
Python 2.7.X
Python
o PyQt
o PyQwt
o PySerial
Obtener el cdigo fuente, del CD que acompaa a este documento

(probablemente no sea la ltima versin existente a la fecha de lectura de este
documento), del repositorio (puede contener cdigo inestable) o de la seccin de
descargas de la pgina del proyecto (recomendado, sera descargar el fichero con
extensin .tar.gz). Este paso no sera necesario si ya se tiene o se han realizado
modificaciones a ste.
Seguidamente se proceder a convertir los ficheros de Qt a PyQt, ejecutando
en una terminal de comandos dentro de la carpeta del cdigo fuente:
> mkpyqt.py -b -r
Se realizar la descarga del paquete de software de Arduino, que se encuentra
en la seccin de descargas de su pgina oficial. Una vez descargado se descomprimir
para poder acceder a su contenido. Este paquete de software nos permitir realizar la
compilacin del firmware de Firmata, para poder luego descargarlo en una placa
Arduino con el programador que lleva incorporado.
Se deber crear una carpeta nueva llamada avrdude, donde se copiarn los
ficheros avrdude.exe y avrdude.conf, existentes en la descarga de Arduino que hemos
descargado anteriormente. Para aumentar la fiabilidad del programador (avrdude) en
Pgina 158

Santiago Reig Chiva
Anexos
todos los ordenadores y hacerlo compatible con Windows XP, se deber aadir
tambin el fichero libusb0.dll, tambin existente en la descarga de Arduino.
Para crear el firmware de la placa Arduino es necesario compilarlo desde el
software, por lo que abriremos el fichero firmware/PlatexFirmata/PlatexFIrmata.ino,
existente en la carpeta del cdigo fuente. Arduino almacena los programas compilados
en una carpeta temporal, por lo que se deber conocer su localizacin, para ello se
activar la salida del compilador en la ventana de depuracin. Esta opcin se activa en
la ventana de preferencias, accesible en el men de herramientas Archivo>Preferencias.
Ilustracin 64 | Activar salida del compilador
Ahora se compilar el cdigo pulsando el botn de verificar.
Ilustracin 65 | Botn de verificar cdigo
Una vez terminada la compilacin, aparecer la localizacin del fichero .hex en

la parte inferior del programa. Hay que tener en cuenta que es posible que la ruta pase
por carpetas ocultas, por lo que se deber activar la visibilidad de stas en la
configuracin de Windows.
Pgina 159

Santiago Reig Chiva
Anexos
Ilustracin 66 | Localizacin del firmware
El archivo PlatexFirmata.cpp.hex resultante, se deber copiar en la carpeta

avrdude con nombre PlatexFirmata.hex.
Finalmente se crear el instalador:
> python setup.py bdist_rpm
Una vez finalizado el proceso, dentro de la carpeta del cdigo fuente, aparecer
una nueva carpeta llamada dist, donde estar el instalador con extensin .msi listo
para usar y distribuir.
12.2. Linux
La creacin del instalador en Linux est totalmente automatizada, por lo que
para iniciar la creacin del instalador slo es necesario ejecutar la siguiente lnea en
una terminal:
$ sudo bash -c "wget https://raw.github.com/gist/1427486/buildlinux.sh && bash build-linux.sh"
Pgina 160

Santiago Reig Chiva
Anexos
Ilustracin 67 | Comando en una terminal de Linux Ubuntu
Durante el proceso, se va mostrando la salida de los comandos que se van

ejecutando, apareciendo al finalizar la tarea Done!, cuando aparecer la carpeta
Platex-dist, donde dentro de ella aparecern los instaladores .deb y .rpm para los
distintas distribuciones de Linux. Hay que tener en cuenta que las libreras cambian de
una distribucin Linux a otra, es probable que el instalador no sea compatible, por lo
que habra que crearlo en la propia distribucin sobre la que se va a usar para asegurar
totalmente su compatibilidad.
El script se va actualizando para mantener al da las versiones de los paquetes a
descargar, ya que las versiones antiguas se suelen borrar y no son accesibles para la
descarga y suelen aparecer nuevas versiones con cierta asiduidad, por lo que es
posible que el script falle al descargar alguna de las libreras, debiendo fijarse en cual
ha sido y comprobar la versin que se ha intentado bajar con la que aparece en la
pgina oficial de la librera, si es distinta se deber actualizar el script con dicha versin
en las definiciones al principio de ste y ejecutando de nuevo el script como se indica a
ms adelante.
El comando anterior, sirve para realizar el instalador con el cdigo original, si se
desea crear el instalador con un cdigo que haya sido modificado por otra persona, se
deber descargar manualmente el archivo build-linux.sh y modificar las rutas para
tomar la que se desea. Una vez realizado esto se ejecutar el script:
$ sudo bash build-linux.sh
El proceso que realiza el script de creacin del instalador es el siguiente:
Se crea la carpeta temporal build donde guardar los ficheros necesarios en

el proceso.
Pgina 161

Santiago Reig Chiva
Anexos
Se instalan y actualizan las libreras existentes en los repositorios.
Se descargan, compilan e instalan las libreras no existentes en los

repositorios.
Se descargar el IDE de Arduino.
Se compila el firmware para la placa Arduino.
Se descarga y compila el cdigo fuente del proyecto.
Se crean los archivos de distribucin (instaladores).
Se borra la carpeta temporal y el propio script.
El script de creacin del instalador se recomienda ejecutarlo en un entorno de

desarrollo para evitar problemas tanto cara al script como para el usuario al modificar
e instalar nuevos paquetes de software. De todas maneras, el script est pensado para
minimizar su impacto, manteniendo la configuracin del entorno intacta.
12.3. Mac OS
El script para crear el instalador en Mac OS es muy similar al de Linux, debido a
su similar naturaleza, aunque como es lgico difiere bastante en algunos puntos.
La creacin del script en Mac OS tambin est completamente automatizada,
por lo que para iniciar la creacin del instalador slo es necesario ejecutar la siguiente
lnea en una terminal:
$ sudo bash -c "curl -O
https://raw.github.com/gist/1427486/build-mac.sh && bash buildmac.sh"
Pgina 162

Santiago Reig Chiva
Anexos
Ilustracin 68 | Comando en una terminal de Mac OS X Lion
Durante el proceso, se va mostrando la salida de los comandos que se van

ejecutando, apareciendo al finalizar la tarea Done!, cuando aparecer la carpeta
Platex-dist, donde dentro de ella aparecer el instalador .dmg. El script slo est
preparado para crear instaladores para ordenadores Mac con arquitectura Intel.
La compatibilidad del instalador con las distintas versiones de Mac es probable
que sea alta, ya que el instalador contiene dentro de l todas las libreras que necesita
el software para funcionar, dependiendo de la compatibilidad de las propias libreras.
El script se va actualizando para mantener al da las versiones de los paquetes a
descargar, ya que las versiones antiguas se suelen borrar y no son accesibles para la
descarga y suelen aparecer nuevas versiones con cierta asiduidad, por lo que es
posible que el script falle al descargar alguna de las libreras, debiendo fijarse en cual
ha sido y comprobar la versin que se ha intentado bajar con la que aparece en la
pgina oficial de la librera, si es distinta se deber actualizar el script con dicha versin
en las definiciones al principio de ste y ejecutando de nuevo el script como se indica a
ms adelante.
El comando anterior, sirve para realizar el instalador con el cdigo original, si se
desea crear el instalador con un cdigo que haya sido modificado por otra persona, se
deber descargar manualmente el archivo build-mac.sh y modificar las rutas para
tomar la que se desea. Una vez realizado esto se ejecutar el script:
$ sudo bash build-mac.sh
En el momento de la realizacin del documento, la compatibilidad del software
de creacin del instalador con Mac OS estaba rota, por lo que el ltimo paso de
creacin del script dar error, pero se ha dejado para que cuando se solucione el
Pgina 163

Santiago Reig Chiva
Anexos
problema funcione de manera correcta. Aunque el script falle en ese punto se podr
ejecutar el programa, ya que todas las libreras estn ya instaladas, para ello y para
ejecutar el programa desde la lnea de comandos, habr que ejecutar la siguiente lnea
dentro de la carpeta build/Platex que existir en la carpeta donde ejecutaste el
script:
$
/Library/Frameworks/Python.framework/Versions/Current/bin/python
platex.pyw
El proceso que realiza el script de creacin del instalador es el siguiente:
Se crea la carpeta temporal build donde guardar los ficheros necesarios

en el proceso.
Se descargan, compilan e instalan las libreras no existentes en los

repositorios.
Se descargar el IDE de Arduino.
Se compila el firmware para la placa Arduino.
Se descarga y compila el cdigo fuente del proyecto.
Se crean los archivos de distribucin (instaladores).
Se borra la carpeta temporal y el propio script.
Pgina 164
PLIEGO DE CONDICIONES
DOCUMENTO N 3

Santiago Reig Chiva
Pliego de condiciones
ndice del pliego de condiciones

13.
Introduccin al pliego de condiciones .................................................... 169
14.
Condiciones generales ............................................................................ 169
15.
Normas, leyes y reglamentos ................................................................. 170
16.
Condiciones facultativas ......................................................................... 172
16.1.
Direccin ............................................................................................. 172
16.2.
Libro de rdenes ................................................................................. 173
17.
Condiciones de ejecucin y montaje ...................................................... 173
17.1.
Condiciones de fabricacin del circuito impreso ................................ 173
17.2.
Pruebas y ensayos del montaje de la placa ........................................ 173
17.2.1. Prueba de alimentacin ................................................................. 174

17.2.2. Prueba de la placa .......................................................................... 174
17.2.3. Conexionado de los circuitos ......................................................... 175
17.3.
Instalacin y uso de las aplicaciones .................................................. 175
17.4.
Conservacin....................................................................................... 176
17.5.
Funcionamiento normal del equipo ................................................... 176
18.
Condiciones de materiales y equipo ...................................................... 176
18.1.
Condiciones tcnicas de los materiales .............................................. 176
18.2.
Condiciones tcnicas del material informtico .................................. 177
Pgina 166

Santiago Reig Chiva
18.3.
Condiciones tcnicas de los circuitos impresos .................................. 178
18.4.
Condiciones tcnicas de los elementos pasivos ................................. 179
19.
Condiciones econmicas ........................................................................ 179
19.1.
Errores en el proyecto ........................................................................ 179
19.2.
Jornadas y salarios .............................................................................. 179
19.3.
Liquidacin .......................................................................................... 180
20.
Disposicin final ...................................................................................... 181
Pgina 167

Santiago Reig Chiva
Ilustracin 69 | Localizacin del ejemplo Blink ................................................ 175
Ilustracin 70 | Led L ........................................................................................ 175
Pgina 168

Santiago Reig Chiva
13. ntroduccion al pliego de

condiciones
Las caractersticas y la descripcin del diseo del proyecto Plataforma de
experimentacin para prototipado de diseos mediante Arduino, los componentes
que intervienen, el cableado y conexionado elctrico y control del funcionamiento del
mismo se detallan en el documento de la memoria y en los correspondientes planos
del documento.
En este documento se exponen todas las condiciones tcnicas de montaje,
especificaciones a cumplir por los elementos y materiales normalizados y comerciales
que se deben considerar a la hora de llevar a cabo la realizacin del proyecto.
En caso de no realizarse segn las condiciones tal y como se presentan en este
documento, el proyectista no se responsabilizar de los posibles fallos y averas
propios del funcionamiento, repercutindose todo el peso del problema sobre terceras
personas.
Todas las modificaciones de las que pueda ser susceptible el proyecto, debern
ser aprobadas por el ingeniero o proyectista.
14.
Condiciones generales
La realizacin del presente proyecto titulado Plataforma de experimentacin

para prototipado de diseos mediante Arduino, se enmarca bajo la designacin del
proyecto final de carrera, y tiene como propsito terminar con xito los estudios de
Ingeniera Tcnica Industrial en la especialidad de Electrnica.
El autor del proyecto ha cursado los estudios en la Universidad de La Rioja,
cumpliendo en su elaboracin con las directrices especificadas por dicho centro, en la
normativa del proyecto de fin de carrera, aprobada por el Consejo de Gobierno el 15
de abril de 2005.
Pgina 169

Santiago Reig Chiva
Este proyecto se ajusta en su desarrollo a los reglamentos y disposiciones

electrnicas vigentes.
Atendiendo a esto, una vez se haya aprobado por el Ministerio de Industria,
tendr carcter de obligado cumplimiento.
Una vez realizado el proyecto, se podrn realizar diversas modificaciones
siempre bajo la supervisin del ingeniero o proyectista.
En caso de efectuarse alguna modificacin, el correspondiente proyecto
modificado se considera como parte integrante del proyecto definitivo y como tal,
sujeto a las condiciones y especificaciones citadas y aprobadas por el Ministerio.
La empresa adjudicataria suscribir contrato ante notario donde se har
constar, a parte de trminos legales obligatorios, plazos de entrega y la conformidad
con la sancin cuyo incumplimiento pueda acarrear consigo.
15.
Normas, leyes y reglamentos
La realizacin del proyecto se regir por la Ordenanza General de Seguridad e

Higiene en el Trabajo del 7 de abril de 1970 y posteriores revisiones.
As mismo, se regir por el Reglamento Electrotcnico de Baja Tensin, en el
que se tendr en cuenta las siguientes normativas:
M.I. B.T.029, la cual se refiere a instalaciones de pequeas tensiones,

menores de 50 voltios.
M.I. B.T.031, la cual se refiere a las condiciones generales de

instalacin, de utilizacin, as como de los requisitos a cumplir a la hora
del diseo.
El proyecto cumple tambin con las siguientes normativas DIN y UNE:
Pgina 170

Santiago Reig Chiva
Los materiales que pueden ser utilizados para la realizacin de placas de

circuito impreso UNE 20-621-85/3.
Los espesores de los materiales con recubrimiento metlico y sus

tolerancias especificadas en la norma UNE 20-621-84/3.
La norma UNE 20552 especifica las tolerancias sobre el espesor total en

la zona de contactos.
En cuanto a la anchura de las pistas, segn la intensidad que circule por

el material conductor, se referir a la norma UNE 20-621.
Los dimetros de los taladros estn especificados en la norma UNE 20621-84/3.
La norma UNE 20-612/2 recoge varios tipos de ensayos que pueden

realizarse y los materiales, como pueden ser los ensayos de espesor,
adherencia, porosidad, etc.
En las distancias entre taladros para la colocacin de componentes, se

seguir lo indicado en la norma UNE 20-524/1, UNE 20-524/2 y UNE 20524/3.
Reglas de seguridad para los aparatos electrnicos de norma UNE 20514-82.
DIN 40801, referente a circuitos impresos, fundamentos, orificios y

espesores.
DIN 40803, referente a circuitos impresos, placas y documentacin.
DIN 40804, referente a circuitos impresos, conceptos.
DIN41494, referente a las formas de construccin para dispositivos

electrnicos.
Pgina 171

Santiago Reig Chiva
Reglas para el diseo y utilizacin de placas de circuito impresas UNE

20-621-3.
Especificacin para la realizacin de placas de simple o doble cara con

agujeros no metalizados y metalizados UNE 20-621-4 y UNE 20-621-5.
Especificacin para las placas impresas multicapas UNE 20-621-6.
UNE 20902 que hace referencia a la tcnica de circuitos impresos,

terminologa.
UNE-EN 60249 en la cual se citan los materiales base para circuitos

impresos.
Este proyecto debido a sus caractersticas se encuentra recogido dentro del

reglamento elctrico de baja tensin.
Se calificar como instalacin elctrica de baja tensin todo conjunto de
aparatos y circuitos asociados en previsin de un fin particular, produccin,
conversin, transformacin, distribucin, o utilizacin de la energa elctrica,
cuyas tensiones nominales sean iguales o inferiores a 1000 voltios para
corriente alterna y 1500 voltios para corrientes continuas.
16.
Condiciones facultativas
16.1. Direccin
La direccin del montaje estar realizada en su totalidad por el ingeniero o
proyectista o por otra persona que sta delegue atendiendo a la capacidad de dicha
persona para realizar este trabajo.
Una vez realizado el montaje, su utilizacin podr ser realizada por cualquier
persona con conocimientos suficientes demostrables sobre el proyecto, la tecnologa
Pgina 172

Santiago Reig Chiva
en l implicada y su funcionamiento. En caso de avera o prdida de datos por

incorrecta utilizacin, el proyectista queda exento de culpa.
16.2. Libro de rdenes

El montaje de los elementos del proyecto se realizar atendiendo a los
documentos y planos del mismo.
Si es necesario realizar una modificacin, se realizar bajo el pertinente
consentimiento del propio ingeniero o proyectista.
17. Condiciones de ejecucion y

montaje
17.1. Condiciones de fabricacin del circuito
impreso
Si se decide por la fabricacin de una placa de interfaz Arduino propia, a partir
de los diseos de referencia disponibles en la pgina web de Arduino, la fabricacin del
circuito impreso deber regirse por la norma UNE-621-80, en la cual se especifican los
ensayos a los que debe ser sometido el circuito impreso, as como los mtodos para la
ejecucin de dichos ensayos.
17.2. Pruebas y ensayos del montaje de la placa

Una vez montados todos los componentes y estn soldados correctamente a la
placa, se proceder a efectuar los siguientes ensayos:
Pgina 173

Santiago Reig Chiva
17.2.1. Prueba de alimentacin

Para verificar el correcto funcionamiento de cada placa, se debe alimentar con
un transformador de 230V a 712V o a travs de los 5V del USB.
Se deber comprobar que al conectar ambas tensiones no se produzca ningn
tipo de fallo tal y como un cortocircuito entre las alimentaciones.
Si se ha conectado la alimentacin externa, se comprobar que en el pin
marcado como Vin, se tiene la misma tensin que la que saca el transformador.
Independientemente del modo en el que est alimentado, deben aparecer 5V en el pin
marcado como 5V y 3,3V en el pin marcado como 3V3.
Las placas disponen de un LED de color verde el cual se ilumina cuando la placa
est siendo alimentada correctamente. Si este LED se desvanece lentamente al realizar
alguna conexin es el principal indicativo de que se est produciendo un cortocircuito
y el limitador de corriente est realizando su trabajo.
17.2.2. Prueba de la placa

Para realizar el ensayo de la puesta en marcha de la placa, se deber utilizar el
IDE de Arduino.
Se har uso del programa de ejemplo denominado Blink que hace parpadear
intermitentemente cada segundo el LED que la placa de interfaz tiene conectada al pin
13, que se puede identificar en la placa por estar marcado con una L. Este ejemplo es
el ms simple de todos, ideal para asegurar que si se produce algn fallo sea de
hardware y no est siendo enmascarado por un fallo de software.
Pgina 174

Santiago Reig Chiva
Ilustracin 69 | Localizacin del ejemplo Blink
Ilustracin 70 | Led L
Una vez probada la placa, puede ser probada con ms
17.2.3. Conexionado de los circuitos

El conexionado de los circuitos que intervienen en el sistema se realiza
siguiendo las instrucciones provistas por el fabricante del hardware.
17.3. Instalacin y uso de las aplicaciones

Para el correcto funcionamiento de todo el sistema, se debe instalar el
controlador de la placa de interfaz en el caso de que sea necesario para su
funcionamiento y la aplicacin siguiendo las instrucciones que se encuentran en los
anexos.
Pgina 175

Santiago Reig Chiva
Para el manejo de la aplicacin se puede consultar el Manual de Usuario, Anexo

IV y para la instalacin de los controladores en el caso de que fuera necesario se puede
consultar el manual correspondiente en el Anexo III.
17.4. Conservacin
Si para el montaje y puesta en marcha de los equipos y materiales que
componen la placa de interfaz se siguen todas las indicaciones, recomendaciones y se
cumplen las especificaciones que se dan en el pliego de condiciones, anexos y
memoria, la vida til de los elementos estar supeditada a aquella que de el fabricante
siguiendo sus recomendaciones de mantenimiento.
17.5. Funcionamiento normal del equipo

Una vez realizados todos los pasos anteriores, el equipo estar listo para
funcionar permanentemente.
El equipo no necesita de un mantenimiento riguroso, siempre que su uso se
realice dentro de los lmites especificados para cada componente.
El deterioro de los materiales puede ser debido al propio envejecimiento del
material con el paso del tiempo.
18. Condiciones de materiales y

equipo
18.1. Condiciones tcnicas de los materiales
Lo materiales a emplear en este proyecto debern cumplimentar todas y cada
una de las normas descritas en el presente documento y podrn ser sometidos a
diferentes pruebas y ensayos para asegurarse as de su correcto funcionamiento. En
Pgina 176

Santiago Reig Chiva
caso de no realizarse dichas pruebas y ensayos, el proyectista quedar exento de

responsabilidad en el posible deterioro de los elementos durante su utilizacin.
Estos materiales deben cumplir las especificaciones citadas para cada uno de
ellos. Si son reemplazados por unos nuevos, estos deben tener las mismas
caractersticas que los que reemplazan, inhibindose de cualquier responsabilidad por
fallo si estos requisitos no son cumplidos.
18.2. Condiciones tcnicas del material

informtico
Los requisitos mnimos del sistema informtico necesario para poder ejecutar el
software diseado, son los siguientes:
Ordenador personal con procesador Intel Pentium IV a 2.0 GHz o

equivalente.
512 MB de memoria RAM DDR.
Un puerto USB libre para la conexin de la placa de interfaz.
100 MB de espacio en disco duro para la instalacin del software.
Microsoft Windows XP, Linux Ubuntu 11.10, Mac OS X Snow Leopard o

posterior.
Para la realizacin del presente proyecto se ha utilizado la siguiente

configuracin de hardware y software:
Ordenador personal con procesador Intel i5 520M a 2,4 GHz, 4096MB

de memoria RAM DDR2, disco duro de 500 GB, tarjeta de sonido
integrada y conexin a Internet.
Sistema operativo Microsoft Windows 7 Home Premium, Linux Ubuntu

12.04 LTS y Mac OS X Lion.
Pgina 177

Santiago Reig Chiva
Navegador de Internet Google Chrome
Eric 4 IDE
Adobe Acrobat Reader X
Paint .NET
TinyGrab
Microsoft Word 2011
Microsoft Visio 2011
IDE de Arduino
Intrprete de Python
VMware Workstation 8
18.3. Condiciones tcnicas de los circuitos

impresos
Las placas de los circuitos impresos sern de fibra de vidrio y tendrn un
espesor no inferior a 750 m. Siendo una vez atacadas con cido las placas para crear
las pistas, cubiertas con un barniz protector fotosensible de manera que el proceso no
oculte las zonas donde se debern realizar la soldadura de los componentes.
Se deber tener especial cuidado en el proceso de soldadura de ciertos
componentes tales como los semiconductores, tratando de reducir en la medida de lo
posible el tiempo del proceso, ya que debido a la sensibilidad de stos a la
temperatura se podran producir daos por sobrecalentamiento.
Pgina 178

Santiago Reig Chiva
18.4. Condiciones tcnicas de los elementos

pasivos
Las resistencias y condensadores tendrn unas tolerancias o mrgenes de error
permisibles.
En el caso de las resistencias se considerar aceptable un error de hasta el 5%,
siendo tolerable para los condensadores un valor del 20%.
19.
Condiciones economicas
19.1. Errores en el proyecto

En el caso de existir errores materiales o de cualquier otra ndole en el
proyecto, se dar cuenta de ello lo ms rpidamente posible al proyectista. De no
realizar este protocolo de seguimiento del desarrollo, el proyectista quedar libre de
culpa o sancin por los posibles errores.
19.2. Jornadas y salarios

Las jornadas y salarios corrern a cargo de la empresa contratista del proyecto,
as como de los gastos producidos durante el proceso de montaje hasta que se realice
la entrega del proyecto finalizado.
Corrern a cargo de la empresa los derechos de alta del proyecto en la
delegacin provincial del Ministerio de Industria y organismo competente en el lugar
donde se desarrolle el proyecto.
Para llevar a cabo la ejecucin del proyecto, debern estar abonados lo
honorarios del proyectista, pudiendo recaer cargos sobre ello si esta parte no es
cumplimentada para su desarrollo.
Pgina 179

Santiago Reig Chiva
19.3. Liquidacin
Terminada la elaboracin del proyecto se proceder a la liquidacin final en la
que se incluye el importe de las unidades de realizacin, as como las posibles
modificaciones del proyecto que hayan sido aprobadas por la direccin tcnica.
Al suscribir el contrato, el contratante habr de abonar al adjudicatario el 80%
del total del presupuesto. El 20% quedar como garanta durante los seis primeros
mese a partir de la fecha de puesta en marcha o de ejecucin del mismo.
Si transcurrido ese plazo no se ha puesto en evidencia ningn defecto, se
abonar la cantidad que faltaba por entregar, y a partir de ese momento, se
considerarn completamente concluidos los compromisos entre ambas partes, a
excepcin del periodo de garanta que cubrir todo lo citado anteriormente.
Pgina 180

Santiago Reig Chiva
20.
Disposicion final
Las partes contratantes, direccin tcnica y empresa, se ratifican en el

contenido del siguiente pliego de condiciones, el cual tiene igual validez, a todos los
efectos, que una escritura pblica, prometiendo el fiel cumplimiento.
Fdo: Santiago Reig Chiva
Pgina 181
PLANOS
DOCUMENTO N 4

Santiago Reig Chiva
Planos
El presente proyecto no necesita de planos para su realizacin, por lo que est

seccin no contiene informacin.
Pgina 183
PRESUPUESTO
DOCUMENTO N 5

Santiago Reig Chiva
Presupuesto
ndice del presupuesto

21.
21.1.
Presupuesto parcial ................................................................................ 187

Materiales ........................................................................................... 187
21.1.1. Hardware del sistema..................................................................... 187

21.1.2. Placa de interfaz ............................................................................. 188
21.1.3. Alimentacin .................................................................................. 188
21.2.
Software del sistema........................................................................... 189
21.3.
Mano de obra...................................................................................... 190
22.
Presupuesto total ................................................................................... 192
Pgina 185

Santiago Reig Chiva
Presupuesto
ndice de tablas
Tabla 21 | Presupuesto de hardware del sistema ............................................ 187
Tabla 22 | Presupuesto de la placa de interfaz ................................................ 188
Tabla 23 | Presupuesto de alimentacin.......................................................... 188
Tabla 24 | Presupuesto de materiales.............................................................. 189
Tabla 25 | Presupuesto de software del sistema ............................................. 190
Tabla 26 | Presupuesto de mano de obra ........................................................ 191
Tabla 27 | Presupuesto total ............................................................................ 192
Pgina 186

Santiago Reig Chiva
21.
Presupuesto
Presupuesto parcial
21.1. Materiales
21.1.1. Hardware del sistema
Siguiendo las especificaciones que han sido descritas en el apartado de
condiciones tcnicas en el pliego de condiciones, se puede seleccionar cualquier
ordenador que cumpla los requisitos, ya sea sobremesa o porttil.
Debido a la facilidad de transporte se ha seleccionado un ordenador porttil
Tabla 21 | Presupuesto de hardware del sistema
Descripcin
HP g6-1214es
Subtotal 1.1
Unidades
Coste unitario
Precio total
485
485
485
Pgina 187

Santiago Reig Chiva
Presupuesto
21.1.2. Placa de interfaz

Tabla 22 | Presupuesto de la placa de interfaz
Descripcin
Unidades
Coste unitario
Precio total
Arduino UNO
20,63
20,63
Cable USB A-B
2,43
2,43
Subtotal 1.2
23,06
21.1.3. Alimentacin
Tabla 23 | Presupuesto de alimentacin
Descripcin
Fuente de alimentacin
Subtotal 1.3
Unidades
Coste unitario
Precio total
16,5
16,5
16,5
Pgina 188

Santiago Reig Chiva
Presupuesto
El presupuesto total de materiales es el siguiente:

Tabla 24 | Presupuesto de materiales
Descripcin
Precio total
Subtotal 1.1
485
Subtotal 1.2
23,06
Subtotal 1.3
16,5
Subtotal 1
524,56
El precio total de la partida de materiales asciende a los 524,56 (quinientos

veinticuatro euros con cincuenta y seis cntimos).
21.2. Software del sistema

En este apartado se desglosa el valor de las licencias de los programas
utilizados para la realizacin del proyecto.
Pgina 189

Santiago Reig Chiva
Presupuesto
Tabla 25 | Presupuesto de software del sistema
Descripcin
Unidades
Coste unitario
Precio total
87,95
87,95
Microsoft Office 2010
699
699
VMware Workstation 8
177,68
177,68
Mac OS X Lion
59
59
Windows 7 Home
Premium
Subtotal 2
1.023,63
El precio total de la partida de software asciende a 1.123,63 (mil veintitrs

con sesenta euros y tres cntimos).
21.3. Mano de obra

En este apartado se detallan los costes de mano de obra. Se desglosa en horas
requeridas, tarea realizada, precio por hora y precio total.
Pgina 190

Santiago Reig Chiva
Presupuesto
Tabla 26 | Presupuesto de mano de obra
Descripcin
Horas
Precio por hora
Precio total
Estudios previos
10
10
100
Programacin aplicacin
250
30
7.500
Programacin Arduino
15
50
750
20
30
600
40
15 e
600
Montaje y puesta en
marcha
Documentacin
Subtotal 3
9.550
El precio total de la partida de mano de obra asciende a 9.550 (nueve mil

quinientos cincuenta euros).
Pgina 191

Santiago Reig Chiva
22.
Presupuesto
Presupuesto total
Tabla 27 | Presupuesto total
Descripcin
Precio total
Subtotal 1
524,56
Subtotal 2
1.023,63
Subtotal 3
9.550
Total
IVA (18%)
Total (IVA incluido)
11.098,19
1997,67
13.095,86
Pgina 192

Santiago Reig Chiva
Presupuesto
El presupuesto total del sistema, incluyendo costes, honorarios e impuestos

asciende a TRECE MIL NOVEINTA Y CINCO EUROS CON OCHENTA Y SEIS CNTIMOS.
Fdo: Santiago Reig Chiva
Pgina 193
BIBLIOGRAFA
DOCUMENTO N 6

Santiago Reig Chiva
Bibliografa
ndice de la bibliografa
ndice de la bibliografa..................................................................................... 195
23.
Protocolo Firmata ................................................................................... 196
24.
Programacin software .......................................................................... 196
24.1.
C/C++ ................................................................................................... 196
24.2.
Python ................................................................................................. 196
25.
Arquitectura Atmel ................................................................................. 197
26.
Distribuidores ......................................................................................... 197
Pgina 195

Santiago Reig Chiva
Bibliografa
23. Protocolo Firmata
Detalles del protocolo:
http://firmata.org/wiki/Protocol
Limitaciones de diseo:
http://firmata.org/wiki/Design_Issues
Protocolo Midi:
https://ccrma.stanford.edu/~craig/articles/linuxmidi/misc/essenmidi.html
http://es.wikipedia.org/wiki/MIDI
24.
Programacion software
24.1. C/C++
Referencia de las libreras de Arduino.
http://arduino.cc/en/Reference/HomePage
Guas de C++
http://www.cplusplus.com/
24.2. Python
Rapid GUI Programming with Python and Qt, Mark Summerfield,

Prentice Hall, 2007.
Documentacin de Python:
Pgina 196

Santiago Reig Chiva
Bibliografa
http://docs.python.org/
Documentacin de Qt:
http://doc.qt.nokia.com/4.7/index.html
25.
Arquitectura Atmel
Documentacin ATmega328P:
http://www.atmel.com/devices/atmega328p.aspx?tab=documents
Pgina de Arduino:
http://arduino.cc
26.
Distribuidores
Tienda de componentes informticos:
http://www.pccomponentes.com
Distribuidor de componentes informticos Mouser:
http://www.mouser.com
Distribuidor de componentes informticos RS Amidata:
http://es.rs-online.com/web/
Pgina 197

Prototipado de Disenos Con Arduino PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Prototipado de Disenos Con Arduino PDF

Uploaded by

Copyright:

Available Formats

TRABAJO FIN DE ESTUDIOS

PROYECTO FIN DE CARRERA

Plataforma de experimentacin para prototipado de

Santiago Reig Chiva

Tutor: Carlos Alberto Rodrguez Gonzlez

Plataforma de experimentacin para prototipado de diseos mediante

PLATAFORMA DE EXPERIMENTACIN PARA

Santiago Reig Chiva

Carlos Alberto Rodrguez Gonzlez

Logroo, 20 de julio de 2012

Plataforma de experimentacin para prototipado de diseos mediante Arduino

Plataforma de experimentacin para prototipado de diseos mediante Arduino

Objetivo del proyecto ............................................................................... 14

Analizador lgico ...................................................................................... 21

Estudios previos al diseo ........................................................................ 23

Estudio de Bus Pirate ................................................................................ 25

Estudio de Little Wire ............................................................................... 28

Anlisis de soluciones ............................................................................... 30

Comparativa de soluciones para la placa de interfaz ............................... 31

Anlisis de la plataforma Atmel AVR................................................. 32

6.1.1.1. Anlisis de Arduino ...................................................................... 32

Anlisis de la plataforma Microchip PIC............................................ 33

Plataforma de experimentacin para prototipado de diseos mediante Arduino

6.1.2.1. Anlisis de Pingino ..................................................................... 33

Anlisis de la plataforma ARM .......................................................... 35

6.1.3.1. Anlisis de ST Micro ..................................................................... 36

Anlisis de la plataforma de Texas Instruments MSP430 ................. 38

6.1.4.1. Anlisis de Launchpad ................................................................. 38

Comparativa de soluciones para el medio de comunicacin ................... 40

Anlisis del puerto paralelo............................................................... 40

Anlisis del puerto serie .................................................................... 41

Anlisis del USB ................................................................................. 42

Anlisis del Bluetooth........................................................................ 42

Anlisis del XBee................................................................................ 43

Otras soluciones ................................................................................ 44

Comparativa de soluciones para el protocolo de comunicaciones .......... 45

Anlisis de Firmata ............................................................................ 45

Anlisis del protocolo de ArduLab .................................................... 47

Anlisis para la creacin de un protocolo propio ............................. 47

Comparativa de soluciones para el lenguaje de programacin ............... 48

Plataforma de experimentacin para prototipado de diseos mediante Arduino

Anlisis de Java .................................................................................. 48

Anlisis de Python ............................................................................. 50

Descripcin de la solucin adoptada ........................................................ 52

Descripcin de la placa de interfaz adoptada .......................................... 52

Descripcin del medio de comunicacin adoptado ................................. 52

Descripcin del protocolo de comunicacin adoptado ........................... 53

Descripcin del lenguaje adoptado .......................................................... 53

Diseo general .......................................................................................... 55

Anlisis del protocolo Firmata .................................................................. 56

Descripcin del protocolo ................................................................. 57

8.2.2.1. Mensajes ...................................................................................... 57

Descripcin de la comunicacin ........................................................ 58

Mejoras en la implementacin del protocolo ................................... 60

Descripcin de la capa fsica.............................................................. 61

Descripcin de los conectores........................................................... 61

Descripcin del cableado .................................................................. 63

Plataforma de experimentacin para prototipado de diseos mediante Arduino

Anlisis de la aplicacin software ............................................................. 64

Entorno de trabajo utilizado para el desarrollo ................................ 66

Descripcin del cdigo fuente........................................................... 67

8.3.3.1. Inicializacin de los mdulos ....................................................... 67

Anlisis de la placa de interfaz ................................................................. 74