MEMORIA TECNICA SOLICITUD 2014 PEC - aiju.info · Intel Edison ... C/C++ ... Eclipse ...

API4Toys Desarrollo e incorporación de elementos interactivos basados en el

internet de los juguetes para el aprendizaje adaptativo mediante el juego.

Nº Expediente: IMDECA/2015/8

PROGRAMA: PROYECTOS EN COLABORACIÓN

ACTUACIÓN: IMDECA - Proyecto de I+D en colaboración

Fecha de concesión: 23/10/2015

Entregable 2.1 (E2.1)

Informe de análisis de tecnología y aplicabilidad versión inicial.

Perteneciente al paquete de trabajo: PT2

Participante responsable: ITI

Mes estimado de entrega: Mes 10

ENTREGABLE 2.1 PÁGINA 2 de 54

Tabla de Contenidos

1. Introducción ................................................................................................................................. 6

1.1. Objetivos del paquete de trabajo 2 ............................................................................................. 6

1.2. Objetivo del presente documento (E2.1) ..................................................................................... 6

2. Hardware existente ...................................................................................................................... 6

2.1. Arduino ........................................................................................................................................ 7

2.1.1. Arduino UNO ...................................................................................................................... 7

2.1.2. Arduino TRE ........................................................................................................................ 8

2.1.3. Arduino ZERO ..................................................................................................................... 8

2.1.4. Arduino LEONARDO ........................................................................................................... 9

2.1.5. Arduino YUN ..................................................................................................................... 10

2.1.6. Arduino DUE ..................................................................................................................... 10

2.1.7. Arduino MEGA .................................................................................................................. 11

2.1.8. Arduino ETHERNET ........................................................................................................... 12

2.1.9. Arduino FIO ...................................................................................................................... 12

2.1.10. Arduino NANO .................................................................................................................. 13

2.1.11. Arduino LILYPAD ............................................................................................................... 13

2.1.12. Arduino PRO ..................................................................................................................... 14

2.1.13. Arduino ESPLORA ............................................................................................................. 14

2.1.14. Arduino MICRO ................................................................................................................ 15

2.1.15. Arduino BT ........................................................................................................................ 15

2.1.16. Arduino Shields ................................................................................................................ 16

2.1.17. Sensores ........................................................................................................................... 18

2.1.18. Actuadores ....................................................................................................................... 18

2.2. Intel Galileo ............................................................................................................................... 19

2.3. Intel Edison ................................................................................................................................ 20

2.4. Raspberry Pi .............................................................................................................................. 21


2.5. Touch Board .............................................................................................................................. 21

2.6. Adafruit Trinket ......................................................................................................................... 22

2.7. NextThing CHIP ....................................................................................................................... 23

3. Interfaces hardware de comunicación ........................................................................................ 23

3.1. Tecnologías RFID y NFC ............................................................................................................. 23

3.2. ZIGBEE ....................................................................................................................................... 24

3.3. WIFI ........................................................................................................................................... 25

3.4. Bluetooth................................................................................................................................... 25

4. Paradigmas y tecnologías básicas ............................................................................................... 26

5. Sistemas operativos .................................................................................................................... 30

5.1. ArdOS ........................................................................................................................................ 31

5.2. DuinOS ...................................................................................................................................... 31

5.3. FemtoOS .................................................................................................................................... 31

5.4. RTuinOS ..................................................................................................................................... 31

5.5. Raspbian ................................................................................................................................... 32

5.6. Windows 10 IoT Core ................................................................................................................ 32

5.7. Arch Linux ARM ......................................................................................................................... 32

5.8. TinyOS ....................................................................................................................................... 32

5.9. Contiki ....................................................................................................................................... 32

5.10. LiteOS ........................................................................................................................................ 33

5.11. BertOS ....................................................................................................................................... 33

6. Lenguajes de programación ........................................................................................................ 33

6.1. Arduino ...................................................................................................................................... 33

6.1.1. Processing/Wiring ............................................................................................................ 34

6.1.2. C/C++ para Arduino .......................................................................................................... 35

6.1.3. Otras alternativas ............................................................................................................. 35

6.2. Raspberry Pi .............................................................................................................................. 36


6.2.1. Python .............................................................................................................................. 36

6.2.2. C/C++ ................................................................................................................................ 37

6.2.3. LAMP (Linux, Apache, MySQL, PHP) ................................................................................. 37

6.2.4. Lua .................................................................................................................................... 38

7. Entornos de desarrollo ............................................................................................................... 39

7.1. Processing ................................................................................................................................. 39

7.2. Eclipse ....................................................................................................................................... 40

7.3. Geany IDE .................................................................................................................................. 41

7.4. CodeBlocks IDE .......................................................................................................................... 42

8. Librerías ...................................................................................................................................... 42

8.1. Comunicaciones ........................................................................................................................ 42

8.1.1. Arduino ............................................................................................................................. 42

8.1.2. Raspberry Pi ..................................................................................................................... 43

8.2. APIs ........................................................................................................................................... 45

8.2.1. WiringPi ............................................................................................................................ 45

8.2.2. Pi4J ................................................................................................................................... 45

8.2.3. Firmata ............................................................................................................................. 45

8.2.4. Device I/O ......................................................................................................................... 46

8.2.5. Ardulink ............................................................................................................................ 46

8.2.6. Blynk ................................................................................................................................. 46

8.2.7. iArduino ............................................................................................................................ 47

8.2.8. Chrome Web Bluetooh ..................................................................................................... 47

8.3. Servicios, frameworks y plataformas ........................................................................................ 47

8.3.1. Temboo ............................................................................................................................ 47

8.3.2. SpaceBrew ........................................................................................................................ 48

8.3.3. Xively ................................................................................................................................ 48

8.3.4. ZettaJS .............................................................................................................................. 49


8.3.5. ThingPlus .......................................................................................................................... 49

8.3.6. ThingSpeak ....................................................................................................................... 50

8.4. Reglas ........................................................................................................................................ 50

8.4.1. Drools ............................................................................................................................... 50

8.4.2. Easy Rules ......................................................................................................................... 51

8.4.3. Jess Rules .......................................................................................................................... 51

9. Referencias bibliográficas ........................................................................................................... 52


1. Introducción

1.1. Objetivos del paquete de trabajo 2

Este paquete se centrará en realizar un estado del arte y un análisis de mercado que permita identificar los elementos tecnológicos existentes que pueden ser de interés dentro de los objetivos del proyecto. En él se incluye la revisión de soluciones hardware basadas en micro-controladores, sensores y comunicaciones, junto con herramientas para el diseño y desarrollo de aplicaciones sobre los mismos. Se analizarán diferentes aspectos como la facilidad de integración, coste, capacidades y facilidad para el desarrollo de soluciones. El principal objetivo es determinar cuáles de las tecnologías revisadas pueden ser potencialmente aplicadas e integradas en los juguetes. Debido a la rápida evolución de este campo, se realizará un análisis periódico para encontrar y reseñar las nuevas soluciones que vayan apareciendo. Además se buscarán soluciones adecuadas como equipos para incorporar la arquitectura de sensibilidad al contexto (computadores, dispositivos móviles, etcétera) que permita a los desarrolladores de juguetes crear diseños que reaccionen ante el modo de uso del mismo.

Los objetivos específicos de este paquete de trabajo son:

Realizar un estudio de mercado de las soluciones Hardware existentes tanto para el juguete como para dar soporte a la plataforma de sensibilidad al contexto

Realizar un estudio de mercado de las soluciones software para la programación del hardware existente.

Realizar un análisis de aquellas soluciones encontradas que puedan ser potencialmente empleadas para los objetivos del proyecto.

1.2. Objetivo del presente documento (E2.1)

Informe que recoge el estudio de la tecnología existente en hardware (tanto para el juguete como para los equipos que integren el módulo de sensibilidad al contexto) y software junto con un análisis de la idoneidad de aplicación a los objetivos del proyecto en una primera versión en base a los trabajos realizados durante las tareas T2.1, T2.2 y T2.3.

2. Hardware existente

Para el prototipado y desarrollo de juguetes con capacidad de comunicación, interacción y actuación se hacen necesarios componentes hardware en los cuales puedan ser integrados diferentes sensores y actuadores que permitan la dinamicidad del juguete. Ademas deben poder incorporar interfaces de comunicación que habiliten el tránsito de datos entre los diferentes elementos que conformen el sistema (juguetes y dispositivos móviles). Esto se vertebra a través de placas y microcontroladores. Para ello se hace un pequeño repaso a continuación a algunos de los más populares existentes en el mercado con potencialidad a ser empleados en el proyecto.


2.1. Arduino

Arduino [Arduino] es una plataforma de desarrollo de hardware libre, basada en una placa con un microcontrolador y un entorno de desarrollo para la programación del mismo. La plataforma está pensada para poder facilitar el uso de la electrónica en proyectos multidisciplinares, bien sean de ámbito profesional o amateur. El modelo básico consiste en una pequeña placa que integra un microcontrolador. Dependiendo de las características de la misma este microcontrolador puede ser desde un modelo económico de 8 bits hasta uno más potente de 32 bits. A nivel de programación el código es totalmente compatible a través del propio entorno de desarrollo. Además, se incorporan multitud de entradas y salidas que dotan de una gran versatilidad a los proyectos que pueden realizarse con el mismo. Dependiendo de las características, precio y posibilidades de las placas pueden encontrarse una gran variedad de modelos. Debido a la configuración libre, existen en el mercado muchas placas basadas en la arquitectura que ofrecen diferentes prestaciones y precios en aras de adecuarse mejor a los prototipos y diseños de los desarrolladores [ArduinoAnalisisPlacas]. A continuación hacemos mención a algunas potenciales opciones para el presente proyecto, con un breve listado de sus características más destacadas.

2.1.1. Arduino UNO

Características principales:

Microcontrolador Atmel ATmega320 de 8 bits a 16MHz.

Voltaje de 5V.

Memoria Flash 32KB (0.5KB reservados para el bootloader).

SRAM de 2KB.

EEPROM de 1KB.

Las salidas de la placa pueden trabajar a voltajes superiores, de entre 6 y 20v, pero se recomienda una tensión de trabajo de entre 7 y 12v.

Contiene 14 pines digitales, 6 de ellos se pueden emplear como PWM.

Ilustración 1. Arduino UNO


Cuenta con 6 pines analógicos, los cuales pueden trabajar con intensidades de hasta 40mA.

2.1.2. Arduino TRE


Microcontrolador Texas Instrument Sitara AM335x a 1GHz con ARM Cortex A8 con 512MB de DDR3L.

Memoria Flash 32KB.

SRAM de 2.5KB.

EEPROM de 1KB.


Cuenta con 6 pines analógicos.

Su parte SBC cuenta con HDMI, USB, microSD, soporte para conector LCD, entre otros.

2.1.3. Arduino ZERO

Ilustración 2. Arduino TRE

Ilustración 3. Arduino Zero



Microcontrolador Atmel SAMD21 MCU de 48Mhz con ARM Cortex M0 de 32 bits.

Memoria Flash 256KB.

SRAM de 32KB.

EEPROM de 16KB.

Opera en el intervalo de voltaje entre 3v3 y 5v (7mA).

Contiene 14 pines digitales, 12 de ellos se pueden emplear como PWM y/o UART.

Cuenta con 6 pines analógicos para un canal ADC de 12 bits y una salida analógica para DAC de 10 bits.

2.1.4. Arduino LEONARDO


Microcontrolador ATmega32u4 a 16MHz.

Memoria Flash 32KB (4KB para el bootloader).

SRAM de 2.5KB.

EEPROM de 1KB.



En vez de tener puerto USB, cuenta con puerto mini-USB.

Ilustración 4. Arduino Leornado


2.1.5. Arduino YUN


Microcontrolador ATmega32u4 de 16MHz a 5v y Atheros AR9331 (que controla el host USB, el puerto para micro-SD y la red Ethernet/WiFi).


SRAM de 2.5KB.

EEPROM de 1KB.



En vez de tener puerto USB, cuenta con puerto mini-USB.

Se puede se complementa con el chip AR9331 a 400Mhz basado en MIPS y trabajando a 3v3. Este chip además contiene RAM DDR2 de 64MB y 16MB flash para un sistema Linux embebido.

2.1.6. Arduino DUE

Ilustración 5. Arduino Yun

Ilustración 6. Arduino DUE



Microcontrolador Atmel SAM3X8E ARM Cortex-M3 de 32 bits a 84MHZ (3,3v).

Memoria Flash 96KB .

SRAM de 512kb.


El amperaje de los pines se extiende hasta los 130-800mA (3v3 y 5v).

Cuenta con 12 pines analógicos y 4 UARTs.

Capacidad de conexión USB OTG, dos conexiones DAC (conversión digital a analógico), 2 TWI, un power jack, SPI y JTAG.

2.1.7. Arduino MEGA


Microcontrolador ATmega2560 a 16MHz y con un voltaje de 5v.

De 8 bits.


SRAM de 8KB.

EEPROM de 4KB.



Ilustración 7. Arduino Mega


2.1.8. Arduino ETHERNET


Microcontrolador ATMega328 a 16MHz y con un voltaje de 5v.

Memoria Flash 32KB.

SRAM de 2KB.

EEPROM de 1KB.



2.1.9. Arduino FIO


Microcontrolador ATmega328p a 8MHz.

Memoria Flash 32KB.

SRAM de 2KB.

EEPROM de 1KB.

Ilustración 8. Arduino Ethernet

Ilustración 9. Arduino FIO


Ilustración 10. Arduino NANO



2.1.10. Arduino NANO


Microcontrolador ATmega168 a 16MHz.

Sus dimensiones son 18,5 × 43.2mm.

Memoria Flash 16KB.

SRAM de 1KB.

EEPROM de 512B.



2.1.11. Arduino LILYPAD


Microcontrolador ATmega328V a 16MHz y con un voltaje de 5.5v.

Memoria Flash 16KB.

SRAM de 1KB.

EEPROM de 512B.


Ilustración 11. Arduino LilyPad



2.1.12. Arduino PRO


Microcontrolador ATmega328 a 16MHz y con un voltaje de 5v.

Memoria Flash 32KB.

SRAM de 1KB.

EEPROM de 512B.



2.1.13. Arduino ESPLORA


Microcontrolador ATmega32u4 a 16MHz y con un voltaje de 5v.

Ilustración 12. Arduino PRO

Ilustración 13. Arduino Esplora


Memoria Flash 32KB (4KB reservados para el bootloader).

SRAM de 2.5KB.

EEPROM de 512B.

2.1.14. Arduino MICRO


Microcontrolador ATmega32u4 a 16MHz.

Memoria Flash 32KB.

SRAM de 2KB.

EEPROM de 1KB.



2.1.15. Arduino BT


Microcontrolador ATmega328 a 16MHz.

Placa Arduino con Bluetooth incorporado.

Ilustración 14. Arduino Micro

Ilustración 15. Arduino BT


2.1.16. Arduino Shields

Los shields son módulos de extensión que permiten añadir nuevas funcionalidades y capacidades a las placas Arduino. Es muy usual utilizar este tipo de componentes para integrar interfaces de comunicación, añadir nuevos sensores y/o actuadores, etcétera. Debido a la gran cantidad de elementos de este tipo que pueden encontrarse en el mercado, realizamos a continuación un pequeño listado de algunos de ellos describiendo algunas de sus características:

4x4 Driver Shield: este shield incorpora 16 controladores MOSFET, capaces de manejar tensiones de hasta 30VDC. Permite ser utilizado como un controlador gradual unipolar para el manejo de hasta un máximo de cuatro motores por tarjeta. Además incorpora un interfaz SPI bus para ser empleado en un Arduino Uno, lo que le permite utilizarlo con la librería ShiftPWM. (http://www.logos-electro.com/store/4x4-driver-shield)

Adafruit GPS & Datalogging Shield: en el cual se integra un módulo GPSque permite registrar la ubicación, fecha / hora, así como los datos del sensor a una tarjeta de memoria flash SD. (http://www.ladyada.net/make/gpsshield/)

Adafruit Wave Shield: que permite reproducir archivos de audio de 22 kHz. Dicho archivo puede estar alojado en una tarjeta de memoria SD desde la cual el shield accede directamente.

Adafruit XPort/Ethernet Shield: permite incorporar un módulo XPort para la conexión a Internet como un cliente o servidor. (http://www.ladyada.net/make/eshield/)

Annikken Andee: permite emplear y conectar fácilmente un smartphone para monitorizar y controlar el Arduino de forma inalámbrica a través de Bluetooth. Incorpora una librería que permite personalizar fácilmente la interfaz de usuario del smartphone a través de Arduino IDE. (http://www.annikken.com/)

Battery Shield: permite conectar a la parte posterior del Arduino, una batería de iones de litio-USB recargable que puede alimentar un Arduino entre 14 y 28 horas dependiendo del circuito y las demandas del software. (http://www.liquidware.com/)

ButtonShield: que es un shield que cuenta con 32 botones, dos botones de tipo disparo (A y B), una barra espaciadora permitiendo convertir el Arduino en un portátil, ordenador portátil de microcontrolador, o gadget. (http://antipastohw.blogspot.com.es/2009/06/live-footage-of-buttonshield-in-wild.html)

Cosmo GSM Connect: Shield GSM que permite habilitar una comunicación M2M para el envío de datos a un servidor remoto. Se caracteriza por soportar protocolos TCP / IP, capacidad de mantener una conexión a un servidor TCP / UDP a través de GPRS, el soporte a interfaces y la posibilidad de ser configurado a través de un interfaz de comandos. (http://jt5.ru/shields/cosmo-gsm/)

Cosmo USB Host: Shield que permite habilitar un interfaz USB Host con chip MAX3421E (http://jt5.ru/shields/usb-host/). Esto habilita la conexión de dispositivos como:

o Cámaras digitales. o Dispositivos HID (teclados, ratones, joysticks, etc). o USB a convertidores de serie.

Cosmo WiFi Connect: este shield integra un interfaz de red WiFi 802.11b/g. Presenta compatibilidad total con el protocolo, teniendo una velocidad de 54 Mbps y 25Mbpsen

http://www.logos-electro.com/store/4x4-driver-shield

http://www.ladyada.net/make/gpsshield/

http://www.ladyada.net/make/eshield/

http://www.annikken.com/

http://www.liquidware.com/

http://antipastohw.blogspot.com.es/2009/06/live-footage-of-buttonshield-in-wild.html

http://antipastohw.blogspot.com.es/2009/06/live-footage-of-buttonshield-in-wild.html

http://jt5.ru/shields/cosmo-gsm/ç

http://jt5.ru/shields/usb-host/


Streaming. Puede gestionarse su configuración través de HTTP, Telnet, serie, UDP con un alcance de hasta 150-200 metros. (http://jt5.ru/shields/cosmo-wifi/)

Critical Velocity LCD Shield: shield de código abierto que permite conectar fácilmente una pantalla LCD al Arduino. También incluye un altavoz, un pulsador y un pequeño tablero de prototipado. (http://www.criticalvelocity.com/item.php?itemid=shield9)

FabScan-Shield: shield empleado para la construcción de scanners 3D. (https://github.com/watterott/FabScan-Shield)

HacroCam VGA Camera Shield: shield que cuenta con una cámara VGA. Puede transferir imágenes a través de I2C o en serie, conectar varias cámaras en paralelo y hacer time lapse de tiempo.

IR Remote Shield 1v09 and IR Remote Shield 2v14J: shield que integra diferentes periféricos e interfaces. Permite incorporar micrófono, RGB LED, sensor de luz, joystick, botones y reset. (http://krazatchu.ca/2014/01/17/ir-r3m0c0n-1v09-multi-purpose-arduino-shield-with-ir/), (http://krazatchu.ca/2014/01/15/ir-r3m0c0n-2v14j-multi-purpose-arduino-shield-with-ir/)

MEGA Battery Pack: Shield Arduino Mega que proporciona una batería de litio de hasta 27 horas de duración y que es recargable a través de USB. (http://www.liquidware.com/shop/show/BPM/Mega+Backpack)

mSD-Shield: shield que facilita un puerto microSD y una pantalla táctil de 2,8” (MI0283QT: 240x320 16bit color). (https://github.com/watterott/mSD-Shield)

Open-Electronics.org WiFi Shield: proporciona a Arduino la capacidad de conectarse a una red inalámbrica de tipo WiFi. Destaca su microchip MRF24WB0MA con antena integrada. (http://www.open-electronics.org/arduino-wifi-shield/)

Phi-2 Shield: shield que integra diferentes periféricos e interfaces. Ofrece una amplia variedad de funciones, pantalla LCD, 6 botones, EEPROM, reloj DS1307 en tiempo real, conector GPS, timbre, LED, etc. (https://liudr.wordpress.com/shields/phi-2-shield/)

PlainDSP Audio Kit: Kit de procesamiento de audio. Incorpora un micrófono, así como conectores jack para entradas de micrófono y de línea externa. La señal de estas entradas de audio son amplificadas por un amplificador multi-etapa permitiendo hacer frente a una amplia gama de niveles de potencia. (http://www.plaindsp.com/product/audio-kit/)

Rugged Circuits Gadget Shield: que integra un acelerómetro de 3 ejes, detector de IR, emisor de IR, RGB LED de alto brillo, 2 potenciómetros, 2 pulsadores, 4 de LED, sensor de luz visible. (http://www.rugged-circuits.com/html/gadget_shield.html)

Shield High Power Led Driver per 4 canali: controlador de cuatro canales de alta potencia LED (350mAmps cada canal). (http://www.ethermania.com/shop/index.php?main_page=product_info&cPath=91_104&products_id=1176)

SMARTGPU TFT LCD Shield-SMARTGPU: shield que integra un procesador gráfico y una pantalla LCD a color con controlador táctil. No necesita ninguna configuración o programación en sí. Es un dispositivo esclavo que sólo recibe órdenes de serie, reduciendo y facilitando considerablemente el tamaño del código, la complejidad y la carga de procesamiento en el procesador principal. El objetivo principal de SMARTGPU es facilitar al usuario la experiencia en el manejo de LCDs y algoritmos gráficos. Contiene

http://jt5.ru/shields/cosmo-wifi/

http://www.criticalvelocity.com/item.php?itemid=shield9

https://github.com/watterott/FabScan-Shield

http://krazatchu.ca/2014/01/17/ir-r3m0c0n-1v09-multi-purpose-arduino-shield-with-ir/

http://krazatchu.ca/2014/01/17/ir-r3m0c0n-1v09-multi-purpose-arduino-shield-with-ir/

http://krazatchu.ca/2014/01/15/ir-r3m0c0n-2v14j-multi-purpose-arduino-shield-with-ir/

http://krazatchu.ca/2014/01/15/ir-r3m0c0n-2v14j-multi-purpose-arduino-shield-with-ir/

http://www.liquidware.com/shop/show/BPM/Mega+Backpack

https://github.com/watterott/mSD-Shield

http://www.open-electronics.org/arduino-wifi-shield/

https://liudr.wordpress.com/shields/phi-2-shield/

http://www.plaindsp.com/product/audio-kit/

http://www.rugged-circuits.com/html/gadget_shield.html

http://www.ethermania.com/shop/index.php?main_page=product_info&cPath=91_104&products_id=1176

http://www.ethermania.com/shop/index.php?main_page=product_info&cPath=91_104&products_id=1176


una ranura para tarjetas microSD que soporta hasta 4 GB de almacenamiento. (http://www.vizictechnologies.com/#/development/4554296549)

Tune MP3 Decoder: shield que permite a Arduino reproducir música. Reproduce MP3 con capacidad para manejar listas de reproducción y ajuste de bajos y agudos. Además permite ser compatible con control remoto de infrarrojos. (http://snootlab.com/shields-snootlab/815-.html)

Z-WeatherShield: shield que integra diferentes sensores para la medición del tiempo atmosférico. Mide la presión, temperatura, humedad relativa y otras variables. (http://tinkr.de/blog/arduino-weather-shield-schematics-layout-code-everything-you-need/)

2.1.17. Sensores

Arduino posee una amplia variedad de sensores que se pueden ser integrados a través de sus múltiples pins de entrada y salida. Un pequeño listado de los tipos de sensores que podemos encontrar es el siguiente:

Acelerómetros y giroscopios.

Switches y entradas físicas.

Cámaras de visión.

Sensores de distancia y detección de objetos.

Sensores de movimiento.

Sensores de corriente y voltaje.

Sensores de ambientales.

Sensores de rotación.

Sensores de humo.

Sensores de sonido.

Sensores de golpe.

Sensores de color.

Sensores de lector de huellas.

Etcétera.

Podemos encontrar un listado con la descripción de estos y muchos más de ellos en el siguiente enlace: http://www.trossenrobotics.com/c/arduino-sensors.aspx

2.1.18. Actuadores

La plataforma Arduino cuenta además con muchos actuadores disponibles [ActuadoresArduino]. A continuación se resumen algunos de ellos.

Motor DC: Los motores DC, para poder ser controlados desde Arduino, deberán de utilizar un driver que sea capaz de proporcionar más corriente al motor, ya que Arduino sólo ofrece 40mA. De esta forma, con el driver podremos alimentar el motor con una fuente de alimentación externa. Para ello, el driver L293D (posee dos puentes H, proporciona 600mA al motor y soporta entre 4.5V y 36V de voltaje) tiene la capacidad

http://www.vizictechnologies.com/#/development/4554296549

http://snootlab.com/shields-snootlab/815-.html

http://tinkr.de/blog/arduino-weather-shield-schematics-layout-code-everything-you-need/

http://tinkr.de/blog/arduino-weather-shield-schematics-layout-code-everything-you-need/

http://www.trossenrobotics.com/c/arduino-sensors.aspx


de controlar los motores DC que utilicen el sistema de puente H. El L293D permite controlar el sentido de giro usando cuatro transistores.

Servomotor: Aunque es similar a un motor de corriente continua, tiene la capacidad de posicionarse en una determinada posición y/o permanecer fija si se desea. Normalmente el ángulo es de 0 a 180 grados, siempre y cuando la alimentación sea de 5 voltios como mínimo. Se encuentra formado por un motor de corriente continua, una caja reductora, un juego de engranajes, un potenciómetro y un circuito de control. La mejor forma de utilizar un servo es la utilización de un PWM (Pulse Width Modulation – Modulación por ancho de pulsos). Trabaja en una frecuencia de 50 Hz (20ms). Cuando se manda un pulso, la anchura de este determina la posición angular del servo. La anchura varía según el servomotor pero normalmente se encuentra 0,5ms y 2,5ms.

Motor Paso a Paso: Un motor paso a paso (también llamado stepper) es un dispositivo electromagnético que convierte impulsos eléctricos en movimientos mecánicos de rotación. La principal característica de estos motores es que se mueven un paso por cada impulso que reciben. Normalmente los pasos pueden ser de 1,8º a 90º por paso, dependiendo del motor. Son motores con mucha precisión, que permiten quedar fijos en una posición (como un servomotor) y también son capaces de girar libremente en un sentido u otro (como un motor DC).

2.2. Intel Galileo

Intel Galileo [IntelGalileo] es un microcontrolador que incorpora un procesador Intel® Quark SoC X1000, un procesador similar a los Intel Pentium pero con un tamaño más reducido. Es un procesador de bajo consumo, de 32 bits, y trabaja a 400 MHz. Galileo está diseñado para

Ilustración 16. Intel Galileo


respaldar shields de Arduino que trabajen a 3.3v o 5v. Aunque Galileo funcione a 3.3v, se le puede aplicar un puente a la placa para que el voltaje llegue a los 5v en los pines de E/S, en caso de ser necesario.

El microcontrolador Galileo incorpora PCI Express, ACPI, Ethernet 10/100 Mb, puerto para dispositivos USB 2.0 y EHCI/OHCI USB, UART de alta velocidad, puerto serie RS-232, lector SD, flash NOR programable de 8MB y un puerto JTAG para una mejor depuración del software. También destacar que contiene 13 pines digitales y 5 pines analógicos.

2.3. Intel Edison

Intel Edison [IntelEdison], considerado como un PC completo del tamaño de una tarjeta SD o un sello de correos, 32x24x2.1mm, incorpora un SoC Quark de doble núcleo, de 32 bits que trabaja a 400MHz. Edison está constituido por una memoria RAM LPDDR2 de 1GB y 4GB de almacenamiento, además de Bluetooth LTE y conectividad WiFi integrada. También cabe la posibilidad de añadir sensores. Intel Edison incorpora 20 pines digitales de E/S, de los cuáles 4 se emplean para PWM, y 6 pines analógicos. Cuenta con un puerto UART, otro I2C y un ICSP, además de micro-USB. También incorpora conector a tarjeta SD y conector de alimentación DC (entre 7v y 15v).

Ilustración 17. Intel Edison


2.4. Raspberry Pi

Raspberry [RaspberryPi] incluye un system-on-a-chip Broadcom BCM2835, cuyo procesador es un ARM1176JZF-S que trabaja hasta 1GHz, el procesador gráfico trata de VideoCore IV que puede reproducir hasta 1080p y cuenta con 512 bytes de memoria RAM LPDDR. Para el almacenamiento permanente se utiliza una tarjeta SD. La placa cuenta con salida de vídeo y audio a través de HDMI y minijack. La conexión Ethernet es 10/100 y aunque no posee WiFi, se puede incluir un WiFi USB gracias a dos puertos USB que integra dicha placa. Para alimentar Raspberry Pi necesitaremos una corriente de 750mA como mínimo.

2.5. Touch Board

Ilustración 18. Raspberry Pi

Ilustración 19. Touch Board


Touch Board [TouchBoard] permite convertir cualquier superficie en interactiva, utilizando los sensores táctiles, de movimiento y de distancia que incorpora. Para poder crear una superficie interactiva, se puede utilizar pintura conductora, hilo conductor, papel de aluminio o cobre entre otros, lo que permitirá crear nuevas interfaces y ser asociadas a una acción. Touch Board es compatible con Arduino. Las especificaciones técnicas son:

Microprocesador Atmel ATMega32U4 trabajando a 5v.

Memoria Flash de 32KB, de los cuales 4KB están reservados para el bootloader.

SRAM de 2.5KB.

Como procesador de audio cuenta con VLSI VS1053B.

Interfaz táctil dedicada MPR121.

Cuenta con 20 pines digitales de E/S y 12 pines analógicos.

De serie preprogramación MP3 y facilidad de programación como MIDI.

Incluye cargador batería LiPo y conector de audio de 3.5mm.

Posibilidad de incorporar tarjeta microSD de hasta 32GB.

2.6. Adafruit Trinket

Adafruit Trinket [AdafruitTrinket] es un mini microcontrolador cuyo procesador es Atmel ATtiny85, que cuenta con 8K de flash (2.75K reservados para el bootloader) y 5 pins de E/S, 3 para entradas analógicas y 2 para salidas PWM analógicas. Existen dos versiones de Adafruit Trinket, una que trabaja a 3v (8MHz) y otra a 5v (8MHz o 16MHz). Cuenta con 512B de SRAM y 512B de EEPROM. También incluye un regulador de potencia de 3.3v a 5v, con capacidad de salida de 150mA y ultra-low drop-out, además de protección de límite de corriente. Aunque Trinket permite su programación mediante Arduino IDE, no es compatible al 100% con Arduino, ya que no posee una conexión de puerto serie para efectuar la depuración y no podrá enviar o recibir datos. No es compatible con puertos USB 3.0, ya que no todos los dispositivos reconocen el bootloader de Trinket, por tanto, habrá que utilizar USB 2.0. Adafruit Trinket cuenta con conector Mini-USB para la alimentación y/o carga USB.

Ilustración 20. Adafruit Trinket


2.7. NextThing CHIP

NextThing CHIP [NextThingCHIP] es un microcontrolador de muy bajo coste (se ofrece a un precio de 9 dólares) que integra multitud de interfaces de comunicación integradas. La salida comercial para este microcontrolador está estipulada para Junio de 2016. Entre sus características cabe destacar las siguientes:

Interfaz WiFI con soporte para los estándares b/g/n.

Interfaz Bluetooth 4.0 integrado.

Procesador R8 a 1GHz de velocidad.

Integra 512MB de memoria RAM.

Integra una memoria de almacenamiento interna de 4GB.

Ofrece un interfaz de salida gráfico compatible con HDMI y VGA.

Alimentación a través de USB o batería externa.

Estas prestaciones le hacen ideal para el desarrollo de pequeños prototipos y proyectos que requieran de un hardware con capacidades de comunicación y almacenamiento integradas.

3. Interfaces hardware de comunicación

Actualmente existen en el mercado un amplio abanico de posibles soluciones para dotar de capacidades de comunicación a los elementos teniendo cada una de estas diversas posibilidades, ventajas e inconvenientes frente al resto. En los siguientes apartados se comentarán algunas de las posibles tecnologías existentes que pueden emplearse para realizar la comunicación e intercambio de información entre elementos.

3.1. Tecnologías RFID y NFC

RFID [RFID] es el acrónimo de “Radio Frequency IDentification”. Esta tecnología emplea tags o etiquetas que permiten almacenar y recuperar información. Las etiquetas son pequeños elementos de tamaño reducido que son adheridas a ciertos elementos y que integran una pequeña antena que les permite recibir y contestar a las peticiones que a través de radio

Ilustración 21. NextThing CHIP


frecuencia realiza un emisor-receptor de RFID. La etiqueta contiene un pequeño chip donde se alberga la información de la propia etiqueta. Se distinguen dos tipos de etiquetas:

Pasivas: estas no requieren de ninguna fuente de alimentación interna ya que son capaces de obtener energía al ser activadas por el lector de energía, mediante la inducción de una pequeña corriente eléctrica en la propia etiqueta. Sin embargo su alcance práctico de detección-funcionamiento puede llegar hasta unos pocos metros.

Activas: estas necesitan de algún tipo de fuente de alimentación adicional, usualmente una pequeña pila de botón. Las etiquetas activas presentan mejoras significativas en comparación con las pasivas, en particular en cuanto a funcionamiento en entornos ambientales difíciles como puede ser su implantación en materiales metálicos y su alcance de detección que puede llegar a varios centenares de metros garantizando así una mejor y mayor fiabilidad.

Si bien las etiquetas activas si permiten la recepción y envío de datos, esta tecnología no es la adecuada para el intercambio masivo de información entre dos elementos. Por otra parte, NFC es el acrónimo de “Near Field Communication”. Este estándar es realmente un subconjunto de las posibilidades que ofrece RFID que limita el rango de alcance a unos 10 centímetros, limitando así los potenciales problemas de seguridad que adolecen a RFID. De forma similar, NFC ofrece dos modos de funcionamiento:

Activo: en el cual los dos dispositivos que desean intercambiar información generan su energía y campo electromagnético que les permite transmitir y recibir los datos.

Pasivo: en el cual solo un dispositivo en la comunicación es capaz de inducir energía. El elemento pasivo pues transfiere la información al elemento inductor.

Este protocolo permite transmitir pequeñas cantidades de datos a velocidades de hasta 848 Kbit/s, aunque previamente ambos dispositivos deben ponerse de acuerdo en la velocidad de trabajo y comunicación.

3.2. ZIGBEE

ZigBee [Zigbee] es un sistema de comunicación inalámbrico ideado para la comunicación entre dispositivos con restricciones energéticas, teniendo una velocidad de transferencia de datos relativamente baja, consiguiendo así ahorrar un gran consumo energético. Es una tecnología basada en el estándar IEEE 802.15.4 de WPAN, que emplea la banda ISM y trabaja a 2.4GHz. Destaca por su sencillez y bajo coste pudiendo compararse con Bluetooth. Algunas de sus características son:

Una red ZigBee puede contener de un máximo de 65535 nodos distribuidos en subredes de 255 nodos.

ZigBee consume 30mA en transmisión y 3 μA en reposo con la posibilidad de quedarse en un modo stand-by que supone un grandísimo ahorro energético.

ZigBee tiene una velocidad de hasta 250KB/.

ZigBee permite crear un sistema en 3 diferentes topologías: en estrella, árbol y malla posibilitando seleccionar aquella que se aproxime más a nuestras necesidades.


3.3. WIFI

Bajo el nombre de WiFi [WiFiAlliance] se abarca la especificación IEEE 802.11 (ISO/IEC 8802-11) para el estándar internacional que define y especifica las características para la formación de redes de área local inalámbrica (WLAN). Paralelamente existe la entidad de certificación Wi-Fi Alliance [WiFiAlliance] para garantizar la compatibilidad entre diferentes dispositivos que utilizan este estándar. Cuando se habla de una red Wi-Fi se trata pues de una red que cumple con el estándar 802.11. Wi-Fi especifica los niveles inferiores del modelo OSI en conexiones inalámbricas, es decir la capa física que define las características de señalización para la transmisión de datos y la capa de enlace de datos que define entre el equipo y la capa física siguiendo un método de acceso similar al utilizado en el estándar Ethernet. Bajo el estándar 802.11 varias modificaciones y versiones para dotar de nuevas características al mismo:

802.11b: hasta 11 Mbps y con un alcance de hasta 300 metros en espacio abierto. Trabaja en la frecuencia de los 2.4GHz.

802.11g: hasta 54Mbps manteniendo compatibilidad con el 802.11b. Trabaja en la frecuencia de los 2.4GHz.

802.11n: una nueva revisión del estándar para alcanzar una velocidad de hasta 600Mbps basándose en la utilización de varias antenas y canales de transmisión para enviar y recibir datos. Permite trabajar en las frecuencias de 2.4GHz y 5GHz manteniendo compatibilidad entre las especificaciones 802.11b, 802.11g y 802.11a.

3.4. Bluetooth

Bluetooth [Bluetooth] es una especificación para la creación de redes inalámbricas de área personal (WPAN). Está especialmente indicada para la transmisión de voz y datos entre

Ilustración 22. Módulo antena Zigbee


diferentes dispositivos, facilitando las comunicaciones entre equipos móviles en especial el emparejamiento y comunicación entre periféricos. Esta especificación actúa en la banda de los 2.4GHz y tiene como objetivo permitir la comunicación de dispositivos con un bajo consumo en un corto alcance de emisión. Además, los transceptores están definidos para que tengan un bajo costo y sea fácil su implantación en diferentes sistemas. La especificación es capaz de definir diferentes clases de dispositivos en base a su potencia de. Bluetooth utiliza en el concepto de “Profiles” o perfiles. Los perfiles ofrecen servicios que a su vez tienen características que definen que valores se intercambian. Básicamente un perfil es un catálogo de recursos para una aplicación determinada. La última especificación del estándar, Bluetooth 4.0, soporta un modo especial para ser utilizado con dispositivos con restricciones energéticas que lo hace especialmente adecuado para ser usado con aquellos que son alimentados por baterías o pilas.

4. Paradigmas y tecnologías básicas

A la hora de crear una arquitectura que permita la comunicación entre los componentes del sistema, deben estudiarse las tecnologías base sobre las cuales se apoyarán los distintos diseños e implementaciones que se realicen sobre el mismo, en especial a los paradigmas de comunicación empleados.

La opción básica es utilizar un protocolo de intercambio de mensajes propio definido por el propio desarrollador de aplicaciones. En este caso el paradigma utilizado viene determinado por una estructura cliente-servidor o un establecimiento de comunicación punto a punto en el cual desde la propia lógica del software implementado se produce un intercambio de datos según la lógica y secuencia de programación. Si bien esto puede dar cierta flexibilidad al desarrollo al controlar explícitamente el flujo de datos en la comunicación presenta grandes inconvenientes en cuanto al mantenimiento y la interoperabilidad posterior de las comunicaciones ya que se tratará de un método no estándar. Además, la depuración de las aplicaciones puede dificultarse enormemente al no contar con herramientas y procedimientos que sí se encuentran disponibles para los paradigmas ampliamente aceptados y establecidos. Es por ello que actualmente la tendencia tecnológica en interfaces y mecanismos para el intercambio de datos se decanta por dos sistemas diferenciados: Publish/Subscribe o Web Services. Ambas soluciones permiten la interoperabilidad entre equipos, el tratamiento asíncrono de datos y los eventos asociados a los mismos y lo que es más importante, facilitan el desarrollo de aplicaciones.

El paradigma de comunicación Publish/Subscribe gestiona transparentemente todo el proceso de envío y recepción de datos de forma asíncrona en redes de una manera muy eficiente. La información generada se cataloga en base a un tema que permite diferenciar cuáles serán los destinatarios interesados en los datos que contiene realizando así su entrega a aquellas únicas entidades con interés en el tema publicado. Básicamente se diferencian en el sistema tres tipos de componentes:

Publishers o generadores de información: que son aquellas entidades que generan datos que serán publicados para su tratamiento por parte de otras entidades interesadas.


Subscribers o receptores de información: que son aquellas entidades que solicitan recibir información catalogada bajo ciertos temas de interés.

Brókers o servidores: que son aquellas entidades que articulan y gestionan la comunicación y entrega de mensajes de forma correcta.

Ilustración 23. Ejemplo de arquitectura Publish/Subscribe

Los Brokers o servidores hacen totalmente transparente al sistema la gestión de conexiones y desconexiones de elementos y la entrega de los mensajes a los destinatarios. Sin embargo, la existencia de este propio elemento hace necesario de agregar un tercer componente que puede afectar negativamente a la interoperabilidad entre sistemas.

Por otra parte, los servicios web no necesitan de nodos o elementos intermedios para gestionar el control y enrutamiento entre los diferentes participantes, facilitando de este modo la interoperabilidad entre todos los componentes y entidades al estar basado en la definición de interfaces públicas. Actualmente existen dos técnicas básicas para la creación de este tipo de servicios:

Servicios web basados en SOAP (Simple Object Access Protocol). Este tipo de servicios requiere de un gran esfuerzo en la fase inicial de diseño y especificación del API a publicar, con el objetivo de dar una normativa clara y completamente definida de lo que hace, se espera, recibe, etcétera. El intercambio de mensajes se realiza basándose en el intercambio de mensajes en formato XML empleando el protocolo HTTP como transporte, siguiente así un esquema clásico de request/response. El principal objetivo de SOAP es habilitar una plataforma de computación distribuida para interoperar siguiendo los mismos principios que los protocolos web: simplicidad, flexibilidad, firewall-friendliness y no dependiente de plataforma. Para conseguir esto, SOAP se basa en la definición de diferentes documentos como el DTD (Document Type Definition, para la definición del tipo de documento) o el WSDL (Web Services Description Language, para la definición de las interfaces web). Sin embargo, el necesario uso de tantos documentos de definición hacen que la implantación y proceso de este tipo de servicios introduzcan sobrecarga en ambos lados de la comunicación.


Servicios web RESTFUL. Este tipo de servicios representa en cierta forma el caso contrario a los servicios web basados en SOAP, ya que son mucho más fáciles de implantar debido a que no es tan estricto en los procesos e intercambio de información del interfaz. RESTFUL define más un estilo de arquitectura y no es un estándar, aunque está basado en protocolos y convenciones estándar como son HTTP, URI y JSON. Para el nivel de red y transporte se utilizan los protocolos TCP/IP y HTTP. Apoyándose en el tipo de método de request de HTTP (get, post, update, read y delete) los servicios RESTFUL proporcionan soporte a las operaciones CRUD (Create, Read, Update, Delete) sobre objetos, de tal forma que implícitamente se está especificando la acción que desea realizarse sobre la misma invocación del servicio. Así cada recurso tiene establecido un identificador global que es conocido a través de su URI, definiendo la acción a realizar con el objeto a través del propio método HTTP. RESTFUL permite ofrecer ventajas interesantes como independencia de lenguaje, plataforma y arquitectura. Al apoyarse en protocolos estándar estos pueden aplicarse en entornos y arquitecturas complejas (presencias de firewalls, nodos de procesamiento intermedio, etcétera). Los recursos pueden ser representados en cualquier formato, como por ejemplo HTML, XML, GIF, PDF, etcétera.

Ilustración 24. Símil operaciones CRUD SQL y REST.

Websockets proporciona otra solución para la comunicación e intercambio de información entre entidades. Esta técnica se basa en mantener una conexión permanente entre ambos lados de la comunicación, permitiendo de este modo la comunicación dual entre ambos extremos de la conexión. Para ello se basa en la apertura de una conexión simple TCP entre el cliente y el servidor (el rol dependerá de la comunicación o el tipo de entidad en cada extremo). Con esta técnica se elimina la necesidad de usar técnicas Push para la solicitud implícita de información ya que ambos extremos pueden solicitar datos al canal. Esta técnica es todavía una tecnología joven que no ofrece soporte para todas las arquitecturas y servidores, por lo que su uso se limita a aquellos entornos que garanticen ese soporte.

Una vez se establecen los mecanismos y protocolos que permiten el envío de paquetes de datos entre dispositivos se debe establecer el tipo de información que se intercambia entre los propios dispositivos. Aquí de nuevo nos encontramos con varias alternativas, entre las que se destacan:


Estructura de campos fija en el paquete: en el que se inserta el contenido binario o hexadecimal de los objetos o valores que desean comunicarse por medio de posiciones fijas dentro del paquete, de tal forma que se establecen campos delimitados en tamaños de byte para contener la información. Se hace necesario establecer un acuerdo entre los extremos de la comunicación sobre la delimitación y significado de cada campo realizando estas separaciones a nivel bajo, es decir, se hace necesario delimitar cada campo en unidades de bit o byte. La principal ventaja de este sistema es que permite un alto nivel de compactación de la información ya que apenas se introduce información superflua que sobrecargue el mensaje. Sin embargo se necesita una correcta especificación de la delimitación de cada campo introduciendo problemas cuando el formato de este contenido es alterado debido al posible cambio del posicionamiento de cada campo, pudiendo incluso generar problemas en el intercambio de información entre arquitecturas big-little endian si no se tienen en cuenta estas condiciones de tratamiento. La legibilidad de los paquetes es nula con lo que el trabajo con estos datos dificultan el análisis y depuración de los mismos para el administrador y desarrollador de aplicaciones.

Valores separados por carácter de escape: en este caso cada campo es separado por un carácter especial. Este método es muy popular para el intercambio de información sencilla entre aplicaciones. Básicamente se insertan los valores de cada campo y se separan con un carácter de escape (generalmente una coma o punto y coma). Esto presenta la ventaja de la fácil extracción y tratamiento de cada campo ya que el delimitador es fijo y conocido. Además muchas aplicaciones pueden trabajar con colecciones de estos datos (como pueden ser hojas de cálculo, bases de datos, etcétera) por lo que pueden facilitar la integración con otros sistemas y aplicaciones. La legibilidad de los datos es bastante buena de cara al trabajo y depuración de los propios datos. Por el contrario al no especificarse claramente el posicionamiento y significado de cada campo pueden introducirse errores en su tratamiento:

o Si el posicionamiento de los campos varía o es reorganizado la información será

tratada incorrectamente.

o La falta de contenido de un campo puede introducir errores en el propio

tratamiento y extracción del contenido.

o La gestión del carácter de escape dentro del propio contenido de un campo

puede hacerse dificultosa.

o Cuando se tiene un número grande campos, el conteo y delimitación de la

información puede llevar a la introducción de errores de posicionamiento en los

propios campos.

XML es un estándar que está especialmente diseñado para la definición de lenguajes de marcado que faciliten la interoperabilidad entre equipos. Con él puede diseñarse un lenguaje propio que determine y delimite cada contenido de la información entre etiquetas. Las etiquetas actúan como delimitadores del propio contenido. Además el nombre o identificador empleado con cada etiqueta introduce cierto valor semántico al propio contenido. El lenguaje además define el orden, anidamiento y estructura del


propio documento por lo que implícitamente en la definición ya se están dando las normas de extracción de la información del documento. XML ofrece la ventaja que con la publicación de la definición de estructura del documento se permite conocer cómo debe tratarse y extraer la información, facilitando la interoperabilidad entre aplicaciones simplemente adoptando la norma. El documento además refleja cómo deben formarse y construirse los documentos por lo que no se deja margen a errores de interpretación o tratamiento. La legibilidad del documento es muy buena, pudiendo dar una idea e imagen del contenido a simple vista de un usuario. La adición de nuevos contenidos puede realizarse de una manera sencilla con la introducción de nuevas etiquetas y estructuras manteniendo la compatibilidad con el diseño anterior (si este no es alterado en su base). Finalmente, a nivel de aplicación existen muchas librerías y utilidades para el manejo de estos documentos de cara al desarrollador de aplicaciones. Por el contrario XML presenta los inconvenientes de una excesiva notación en la definición y estructuración del documento. Las etiquetas deben abrirse y cerrarse, se deben introducir ciertas cabeceras estándar, etcétera que sobrecargan de por sí el contenido. Si además el documento incluye secciones anidadas esta sobrecarga se incrementa. El tratamiento de estos documentos requiere también de cierto tiempo y recursos computacionales que en algunas aplicaciones o sistemas limitados pueden no disponer. Puesto que XML es un estándar de marcado, aun deberían de definir los tipos de mensaje y contenidos que se intercambiarían en formato XML.

JSON (JavaScript Object Notation) es un estándar para el intercambio de información que actualmente está en auge. Este lenguaje presenta un compromiso eficiente entre las diferentes soluciones existentes y actualmente pueden encontrarse multitud de herramientas, servicios y aplicaciones que se basan en él como medio de definición de los paquetes intercambiados. Entre sus ventajas se encuentra:

o Propone una sintaxis clara, sencilla y estándar. o Permite definir estructuras complejas. o Presenta una menor sobrecarga de etiquetado y delimitación de caracteres que

XML. o El contenido puede ser leído e interpretado fácilmente tanto por aplicaciones

como por usuarios. o Puede embeber contenido binario. o Existen diversas utilidades y librerías de terceros para su uso y manejo. o Diversos protocolos, paradigmas y formas de trabajo usan o se basan en él para

su funcionamiento.

5. Sistemas operativos

Dentro de las distintas plataformas existentes pueden encontrarse sistemas operativos que faciliten la programación y manejo de la propia arquitectura. Estos permiten proveer de ciertas abstracciones que pueden facilitan el acceso a ciertos recursos. Dependiendo de la arquitectura y el propio tipo de sistema operativo estos ofrecerán desde simples abstracciones y pequeñas utilidades hasta gestión completa del dispositivo introducción multi-tarea, soporte a protocolos de comunicación y gestión de almacenamiento y memoria. A continuación se comentan algunos de los sistemas operativos más populares para las principales plataformas.


5.1. ArdOS

ArdOS [ArdOS] es un pequeño sistema operativo desarrollado para los microcontroladores de tipo Arduino que usan los chips de ATMega 168, 328, 1280 y 2560. Este sistema operativo facilita el desarrollo de aplicaciones multitareas integrando una librería para el acceso a las funcionalidades que este ofrece a través del propio lenguaje Processing. Se basa en un planificador multitarea basado en prioridades que permite el desarrollo de aplicaciones de tiempo real. Además, se proveen mecanismos para el acceso a recursos y secciones críticas como son semáforos y mutex. Implementa un mecanismo de colas de mensajes, de tal forma que puede ser usado para transferir mensajes entre tareas de una forma sincronizada y estableciendo diferentes niveles de prioridad entre las mismas. Finalmente, el sistema permite ser configurado seleccionando aquellos componentes del kernel que desean instalarse en el dispositivo, con el objetivo de optimizar el rendimiento y el uso de recursos.

5.2. DuinOS

DuniOS [DuinOS] es un sistema operativo que añade multitarea apropiativa o preemptive a las aplicaciones que se desarrollan bajo Arduino. Se trata de un proyecto de código abierto en el cual se amplia y modifica el sistema operativo FreeRTOS pero especialmente adaptado para la plataforma Arduino. Actualmente el proyecto sigue en desarrollo y mejora. Al distribuirse bajo código abierto pueden realizarse diferentes mejoras sobre él para adaptarlo a las necesidades del sistema que se debe desarrollar.

5.3. FemtoOS

FemtoOS [FemtoOS] es un sistema operativo de tiempo real especialmente optimizado para sistemas embebidos. Utiliza multitarea preemptive en el planificador para la gestión de los distintos procesos en ejecución. El uso de recursos es mínimos ya que puede ser integrado incluso en equipos con pocos kilobytes de memoria flash y trabaja con pocos recursos de memoria RAM. Es capaz de funcionar en la mayoría de microcontroladores ATMega por lo que puede aplicarse a la plataforma Arduino. Entre sus ventajas presenta que pude manejar hasta un máximo de 16 tareas concurrentes estableciendo diferentes prioridades entre ellas. Para ajustarse mejor a las necesidades y requerimientos de recursos de la aplicación el sistema operativo presenta una estructura modular que permite añadir o eliminar componentes y abstracciones del sistema según se necesite.

5.4. RTuinOS

RTuinOS [RTuinOS] es un sistema operativo de tiempo real desarrollado especialmente para la plataforma Arduino. El sistema se integra dentro del lenguaje de programación Arduino y proporciona diferentes primitivas para el control y comunicación de procesos pseudo-concurrentes (ya que el microcontrolador de Arduino no soporta la multitarea real). El planificador asigna diferentes tiempos de ejecución a los procesos mezclando una política de ejecución de los procesos de tipo Round Robin.


5.5. Raspbian

Raspbian [Raspbian] es una distribución del sistema operativo Linux especialmente diseñada, configurada y optimizada para Raspberry Pi. Está basada en un Debian Wheezy Linux y ofrece las mismas funcionalidades básicas que cualquier distribución básica de Linux para escritorio. La versión inicial cuenta con unos 35000 paquetes de aplicaciones y programas optimizados para la plataforma, incorporando día a día más paquetes. Es por defecto la distribución estándar y más empleada en esta plataforma. Como añadido cuenta con una aplicación gráfica que permite configurar el sistema y la instalación, lo que facilita su rápida implantación. El sistema puede instalarse tanto red como por medio de una imagen grabada en pen-drive.

5.6. Windows 10 IoT Core

Windows 10 IoT Core [Windows10IoT] es un sistema operativo que presenta una solución completa para el desarrollo integral de aplicaciones sobre Internet of Things. Windows 10 IoT permite instalar en un dispositivo Raspberry o similar un mini-sistema operativo con ciertas funcionalidades para poder integrar código de programación que realiza tomas y capturas de sensorización para posteriormente ser enviadas a un dispositivo servidor o a la nube. Si bien no da una flexibilidad total al programador en el desarrollo de la aplicación, si ofrece ayudas que agilizan el desarrollo de las propias aplicaciones de sensorización, presentando una infraestructura consolidada para realizarlas.

5.7. Arch Linux ARM

Arch Linux ARM [ARchLinuxARM] es una distribución de Linux optimizada para computadores con el chip ARM basada en la distribución Arch Linux. Su principal diferencia con respecto a otras distribuciones de Linux es que trata de mantener la sencillez y simplicidad. Las actualizaciones del sistema incluyen la revisión de todos los componentes del sistema con lo que se evita la actualización de los componentes por separado y evitando la incompatibilidad entre los mismos. Esta versión está especialmente optimizada para trabajar sobre microcontroladores ARM. Para ello se basa en un conjunto de componentes estándar mínimos, por lo que el consumo de recursos también se minimiza.

5.8. TinyOS

TinyOS [TinyOS] es un sistema operativo de libre distribución diseñado especialmente para dispositivos inalámbricos con bajos consumo energético. Ofrece diferentes abstracciones de los componentes de la máquina como almacenamiento en las memorias basado en bloques y sectores. Sobre todo destaca por ofrecer diferentes soportes a la comunicación inalámbrica como los basados en 802.15.4, Zigbee y 6LoWPAN/RPL. Su planificador opera en de modo FIFO siendo las aplicaciones que se desarrollan las encargas de devolver el control de ejecución de los propios procesos al sistema operativo.

5.9. Contiki

Contiki [Contiki] es un sistema operativo de código abierto especialmente optimizado para su implantación en microcontroladores con capacidades de comunicación. Su mayor ventaja es que


ofrece un planificador multitarea y una pila completa de soporte a TCP/IP ocupando muy pocos kilobytes en memoria flash (40KB) y unos cientos de bytes en memoria RAM (2KB). Dentro del sistema los procesos pueden comunicarse entre sí mediante la técnica del paso de mensajes. Incorpora una pila ligera para soportar TCP/IP con extensión a soporte a IPv6 y 6LoWPAN. Como añadidos, Contiki ofrece diversos componentes como son un interfaz de gestión visual de ventanas, un servidor web y un navegador web muy ligero.

5.10. LiteOS

LiteOS [LiteOS] es un sistema operativo de código abierto de tipo UNIX que está especialmente diseñado para su uso en redes de sensores. La mayor ventaja que ofrece es que permite trabajar simultáneamente con varios interfaces de redes de comunicaciones permitiendo el paso de mensajes entre ellos de una forma fácil. Es un sistema operativo de tiempo real con soporte a hilos de ejecución. El sistema puede ser compilado y adaptado para su trabajo con distintos tipos de motes y de plataformas incluyendo las basadas en chips ATmega128 y ATmega1281.

5.11. BertOS

BertOS [BertOS] es un sistema operativo de tiempo real especialmente diseñado para sistemas embebidos. Está distribuido bajo licencia GPL pero con ciertas restricciones para usos comerciales. Su ventaja es que presenta un diseño modular que permite la configuración y optimización total del mismo según el entorno donde vaya a ejecutarse, por lo que pude aplicarse desde pequeños microcontroladores de 8 bits hasta sistemas de 32 bits de arquitecturas ARM. Su planificador soporta multitarea apropiativa proporcionando diferentes abstracciones para la intercomunicación entre procesos, entre las que se encuentran señales, semáforos y el paso de mensajes. Otra característica adicional es que ofrece una capa de abstracción de hardware sobre diversos periféricos y sensores que permite al desarrollador una mayor facilidad de manejo. Finalmente, este sistema integra soporte a muchos protocolos de red, incluido TCP/IP.

6. Lenguajes de programación

Esta sección realiza una descripción de los principales lenguajes de programación más utilizados para las principales arquitecturas hardware. Si bien actualmente pueden programarse los dispositivos prácticamente en cualquier lenguaje, ya sea mediante compilación directa a lenguaje máquina del dispositivo o bien mediante compilación cruzada, aquí se describirán aquellos que son considerados como los estándares para el desarrollo en las mismas.

6.1. Arduino

La plataforma Arduino [Arduino] ha desarrollado un lenguaje especial para su programación que permite a usuarios con pocos conocimientos el desarrollo de aplicaciones para ella siendo conocido este como Processing. Adicionalmente también puede utilizarse el lenguaje de programación C++.


6.1.1. Processing/Wiring

Processing/Wiring es por defecto el lenguaje empleado para la programación de las placas tipo Arduino [Processing]. Además y bajo el mismo nombre se incluye un entorno de desarrollo para el propio lenguaje. Originalmente este lenguaje fue diseñado con un lenguaje Open Source basado en Java para facilitar el aprendizaje de programación desde un contexto visual, en especial a diseñadores gráficos y artistas ya que proporciona facilidades para la creación y tratamiento de objetos gráficos. Este lenguaje está construido sobre Java pero utiliza una sintaxis muy simplificada para facilitar la programación, teniendo un aspecto muy similar a los programas creados en C/C++. Los programas creados en este lenguaje son posteriormente traducidos a Java pero añadiendo la posibilidad de crear ejecutables directos para las principales plataformas como son Mac OS, Linux y Windows. Cada programa o librería es denominado skecth. Diferentes skecthes pueden ser combinados para formar programas más complejos.

Ilustración 25. Ejemplo de lenguaje Processing/Wiring

Debido a su facilidad para su aprendizaje este fue adoptado como lenguaje oficial para la programación de la plataforma Arduino, con el objetivo de universalizar la programación de microcontroladores a cualquier tipo de usuario y pasándose a ser denominado Processing/Wiring.


Las principales ventajas de este lenguaje de programación son:

Facilidad de aprendizaje ya que pueden crearse los primeros programas o sketches en pocos minutos.

Dispone de un IDE propio especialmente diseñado para la programación del lenguaje.

Permite desarrollar aplicaciones complejas.

Permite combinar el propio lenguaje Processing con Java nativo y sus propias librerías.

Proporciona facilidades para la programación estructurada y para la programación orientada a objetos, según las necesidades del programa y el usuario.

Las aplicaciones pueden ejecutarse en Internet (como Java applets) e incluso en dispositivos móviles.

Existe un gran abanico de librerías disponibles de diverso tipo.

6.1.2. C/C++ para Arduino

El lenguaje de programación desde el cual se apoya cualquier desarrollo que no emplea Processin/Wiring para la plataforma Arduino es C/C++. De hecho el propio lenguaje Processing/Wiring es un subconjunto de propio de C/C++. Para la programación se necesita el compilador “avr-gcc” que genera código para arquitecturas ATMEL AVR además de la herramienta “avrdude” que permite posteriormente subir y grabar el binario en la propia placa.

La principal ventaja del uso del lenguaje de programación C/C++ es la capacidad de poder diseñar e implementar un código mucho más optimizado generando así programas de un tamaño mucho más reducido. Esto es especialmente importante en aquellas aplicaciones críticas o que construidas para ser lo más eficientes posibles ya que hay que tener en cuenta que las características limitadas de muchas de las placas Arduino.

6.1.3. Otras alternativas

Dentro del desarrollo de programas para Arduino existen otras opciones que pueden ser tenidas en cuenta según las necesidades de implementación o las características del proyecto. Repasamos brevemente algunas de ellas:

.NET: en el cual se permite la programación en Microsoft Visual C# para las placas de tipo Netduino [Netduino] que son compatibles con Arduino pero con unas características mucho más potentes. Esto habilita el uso de un completo IDE como es Microsoft Visual C# para el desarrollo de aplicaciones que incorpora la posibilidad de depuración en línea.

Uso de Firmata [Firmata] y una máquina externa: en el cual se utiliza el protocolo de comunicación Firmata que permite comunicar microcontroladores con software que se ejecuta en un computador. Realmente no se trata de crear un programa para la placa


Arduino en sí, sino que se registra el protocolo en la propia placa que facilita un canal de comunicación entre esta y un ordenador. De este modo desde cualquier lenguaje de programación en el ordenador que tenga soporte a este protocolo pueden crearse aplicaciones que manden y reciban ordenes hacía la placa Arduino. Esto facilita la programación de la propia placa ya que no se necesitan de entornos especiales de programación ni conocimiento de los lenguajes particulares para la propia placa. Actualmente existe soporte para la programación a través de Firmdata para los siguientes lenguajes de programación: Processing, Python, PERL, Ruby, Clojure, Javascript, NodeJS, Java, .NET, Flash, PHP, Haskell, , iOS, Dart, Max/MSP.

6.2. Raspberry Pi

Raspberry Pi tiene una potencia computacional que le permite instalar en ella un sistema operativo completo y sobre este poder utilizar cualquier lenguaje de programación.

6.2.1. Python

El lenguaje de programación por excelencia de la plataforma Raspberry Pi es Python [Python]. De hecho el nombre de “Pi” es un juego de palabras que hace referencia “Py-thon”. Python presenta la ventaja de que tiene una sintaxis muy limpia debido a su rigidez para la escritura de programas que está incluida en la definición del propio lenguaje. Esto produce un código muy legible basado en palabras términos en ingles comunes, si bien durante su aprendizaje exige un esfuerzo mayor al programador. De hecho este lenguaje se fundamenta en las siguientes normas para la escritura de código y buenas prácticas [PEP20]:

Bonito es mejor que feo. (Beautiful is better than ugly).

Explícito mejor que implícito. (Explicit is better than implicit).

Simple es mejor que complejo. (Simple is better than complex).

Complejo es mejor que complicado. (Complex is better than complicated).

La legibilidad es importante. (Readability counts).

Debido a su popularidad en este entorno se facilitan diversas librerías listas para ser empleadas que acceden al hardware de la plataforma Raspberry mediante la GPIO (General Purpose Input Output). Su mayor ventaja es que es un lenguaje interpretado pero a su vez muy eficiente y está especialmente indicado para la construcción de scripts. Además permite la construcción modular de aplicaciones, definiendo pequeños módulos que posteriormente son enlazados para la formar la aplicación principal.


Ilustración 26. Ejemplo de programa en Python

Actualmente se encuentran dos versiones del lenguaje disponibles: Python 2 y Python 3. Python 2 está siendo mantenida solo por compatibilidad con programas antiguos que necesitan soporte a ciertas librerías que todavía no han sido portadas a la nueva versión del lenguaje.

6.2.2. C/C++

Si existe un lenguaje que permite la generación de programas altamente eficientes y compactos es C/C++. Su principal ventaja es las diversas facilidades que proporciona para el trabajo y acceso al hardware y la programación de “bajo nivel”. Se tienen disponibles librerías para el acceso a los componentes hardware de la propia placa. Para la compilación de los programas simplemente basta con tener instalado el compilador “gcc” con el soporte para la generación de código para el propio dispositivo Raspberry Pi. En el caso de trabajar sobre la propia placa a través del sistema operativo instalado en ella no será necesario ninguna herramienta adicional.

La mayor ventaja de este lenguaje es la posibilidad de acceso a los recursos de la máquina, teniendo capacidad incluso de embeber código ensamblador dentro del propio programa para aquellas aplicaciones que necesiten un control total optimizado de los recursos.

6.2.3. LAMP (Linux, Apache, MySQL, PHP)

Debido a la proliferación de aplicaciones que se reflejan en el ofrecimiento de servicios a través de web, el desarrollo de software usando el framework LAMP (Linux, Apache, MySQL, PHP). Bajo estas siglas se esconde el software que se ejecuta sobre un entorno Linux y que se ofrece a través de servicios web que se instalan bajo un servidor web Apache. Adicionalmente, la información es persistida o almacenada en una base de datos MySQL. Los servicios son implementados a través del lenguaje de script PHP. La popularización del uso de estas herramientas de trabajo que en un principio no estaban pensados para su trabajo conjunto viene de su facilidad y bajo coste de adquisición, viniendo todo este software ya preinstalado por defecto en la mayoría de distribuciones de Linux.

PHP [PHP] es un lenguaje de script multiplataforma muy potente y flexible originalmente diseñado para el desarrollo de aplicaciones web de contenido dinámico en el lado del servidor. Este lenguaje posee grandes similitudes con lenguajes clásicos de programación estructurada como son C y Perl, pero teniendo un curva de aprendizaje mucho más corta. Las mayores


ventajas que aporta PHP es la gran flexibilidad que ofrece para el desarrollo de software ya que no impone un número conjunto de reglas en la definición del propio lenguaje. Además, debido a su estado de madurez y su amplio uso pueden encontrarse multitud de librerías y extensiones que hacen que el desarrollo de aplicaciones sea muy rápido. Finalmente, para el acceso a al hardware de la placa Raspberry puede utilizarse PHP como puente entre los servicios web ofrecidos y el software escrito en C/C++/Python que accede a los recursos internos de la placa Raspberry Pi.

6.2.4. Lua

Lua [Lua] es un lenguaje que está ganando popularidad recientemente gracias a sus interesantes características. Se trata de un lenguaje interpretado al estilo de Python o Perl pero que permite a su propia semántica ser extendida con nuevas funcionalidades. Los programas Lua no son interpretados de forma directa, sino que son compilados a bytecode para posteriormente ser ejecutados por la propia máquina virtual de Lua. Este proceso de compilación es totalmente transparente al usuario y realizado en tiempo de ejecución, pero con anticipación para aumentar el rendimiento. La mayor característica de Lua es que proporciona muchas “meta-características”, esto es que permite extender el lenguaje tal y como se necesite para la aplicación particular a desarrollar. Por ejemplo no integra facilidades directamente la programación orientada a objetos pero pueden definirse extensiones para dar soporte a la misma. Lua solamente soporta un conjunto limitado de tipos y estructuras de datos (booleanos, números, cadenas y tablas). La definición de datos y estructuras complejas se hace a partir de meta-tablas que pueden ser redefinidas para dar la funcionalidad deseada.

El bytecode generado por Lua es altamente eficiente y está optimizado para evitar la copia excesiva de valores en memoria con la consiguiente reducción del número de instrucciones en el código. Además, incorpora múltiples facilidades para incorporar código Lua dentro de código escrito en lenguaje C.

Ilustración 27. Ejemplo de lenguaje Lua


Con estos aspectos se tiene como resultado un lenguaje base muy simple y ligero y que es fácilmente adaptable a un amplio rango de aplicaciones. Por ejemplo un uso muy claro es la aplicación de Lua para la generación de scripts. Sin embargo, para poder usar todas las características del lenguaje y obtener su máximo rendimiento se requiere de una curva de aprendizaje algo elevada

7. Entornos de desarrollo

Esta sección realiza un repaso a los principales entornos de desarrollo para las principales plataformas y arquitecturas. Se hace una descripción general de los que son considerados por defecto los lenguajes de programación estándar para las diferentes arquitecturas.

7.1. Processing

Processing [Processing] comparte nombre con el lenguaje de programación de mismo nombre. Este entorno de desarrollo está especialmente desarrollado para crear aplicaciones para la plataforma Arduino. Se trata de un entorno muy básico y con pocas opciones pero de facilidad de edición. Este entorno divide cada módulo del software en “sketches” o esquemas que son presentados en diferentes pestañas del propio entorno. Todos los “sketches” que se encuentran en un mismo directorio o carpeta forman parte del mismo proyecto software, facilitando así la descomposición modula del software que se implementa. Este entorno de desarrollo es de libre distribución y permite ser configurada y adaptado para soportar nuevas palabras y estructuras reservadas por el lenguaje o que hayan sido definidas por el propio usuario. Para la programación de Arduino este software se instala sobre una computadora y ofrece una ventana de consola sobre el puerto serie (donde usualmente es conectado un dispositivo de tipo Arduino) para poder realizar labores de visualización de mensajes. Además el propio entorno permite la compilación y portado del código generado a la memoria de código del dispositivo Arduino sin tener que depender de herramientas o procesos externos.


Ilustración 28. Vista del Arduino Processing IDE

7.2. Eclipse

Eclipse [Eclipse] es uno de los entornos de desarrollo integrados más populares que existen en el mercado. Es altamente configurable, soporta multitud de lenguajes de programación, ofrece herramientas adicionales y personalizadas según el tipo de proyecto. Además este entorno es de libre distribución y está disponible para múltiples plataformas. No podía ser menos que este ofreciera soporte para la programación de Raspberry Pi y Arduino. De esta forma podemos programar en un potente computador de escritorio y transferir posteriormente el programa compilado a los dispositivos.

Para el caso de la programación de Raspberry Pi en lenguaje de programación C/C++ se deberá instalar adicionalmente el soporte para la generación de código nativo para Raspberry Pi mediante el compilador arm-linux-gnuebihf-gcc. Configurando el entorno y estableciendo que el compilador por defecto a utilizar en proyectos C/C++ es el que hemos descargado, Eclipse será capaz de compilar nuestros programas en código ejecutable para ARM. Si no se desea realizar estas configuraciones manualmente, Eclipse tiene disponible el plug-in AVR-Eclipse que realiza


de forma automática la instalación y configuración del entorno para la programación. Podemos seguir el mismo proceso de instalación manual comentado anteriormente para utilizar Eclipse como entorno de desarrollo para la programación de Arduino con lenguaje C/C++.

Ilustración 29. Pantalla principal de Eclipse IDE

En ambos casos, para la programación de estos dispositivos es necesario un compilador cruzado que soporte arquitecturas ARM.

7.3. Geany IDE

Geany IDE [Geany] es uno de los entornos de programación existentes actualmente más potentes que permite ser ejecutado en la propia máquina Raspberry Pi sin que se vea penalizado por la limitación de recursos del dispositivo. Ofrece soporte para el trabajo con la mayoría de lenguajes de programación existentes, entre los que se encuentran Python y C/C++ que son los más empleados para la programación de la placa Raspberry Pi. Entre sus principales características se encuentran:

El resaltado de sintaxis según el lenguaje de programación.

Posibilidad de plegado/extensión de código para facilitar la lectura.

Autocompletado de código y cierre automática de etiquetas en lenguajes de marcado.

Capacidad para mostrar consejos sobre los errores de sintaxis y ofreciendo ayuda.

Listado de símbolos y objetos.

Creación de scripts para integrar herramientas de compilación y ejecución de código.

Características para gestión de proyectos.

Soporte y extensión a base de plugins.


Soporte a los lenguajes de programación más populares: C/C++, Java, PHP, Python, Perl, Pascal, HTML/XML, etcétera.

7.4. CodeBlocks IDE

CodeBlocks IDE [CodeBlocks] es un entorno de desarrollo para lenguaje C/C++ de libre distribución muy popular. Su diseño permite que el propio entorno sea altamente configurable y extensible con nuevas funcionalidades mediante plugins. Permite ser configurado para generar código ejecutable para distintas plataformas y arquitecturas, entre las que se encuentra Raspberry Pi. Entre sus principales características se encuentran:

Resaltado de sintaxis que permite además ser personalizado y configurado según las necesidades del usuario.

Gestión de estructura de directorios/archivos según el tipo de proyecto a desarrollar.

Capacidad para el auto-completado de código.

Diferentes ventanas y pantallas para obtener listados de información sobre el código, como son listas de clases, de símbolos, de variables, etcétera.

Identación inteligente instantánea.

Gestión automática de secciones de código “To do”.

Extensibilidad total por medio de plugins.

8. Librerías

Esta sección realiza un repaso a diferentes librerías, servicios y ayudas para el diseño e implementación de aplicaciones sobre estás arquitecturas.

8.1. Comunicaciones

Esta sección presenta algunas de las alternativas y librerías que pueden utilizarse en las diferentes arquitecturas para facilitar la comunicación con distintos protocolos.

8.1.1. Arduino

Debido a la propia descripción de la arquitectura Arduino las comunicaciones se realizan a través del puerto serie que se integra en el chip UART o puerto serie que permite recibir los datos incluso aunque el procesador este ocupado ya que mantiene un buffer de 64 bytes para almacenar esta información. A partir de este hardware se adaptan diversos interfaces de comunicación para diferentes protocolos como BlueTooth o Zigbee. La programación y configuración de estos interfaces también se realiza mediante comandos y parámetros AT por lo que la programación de aplicaciones que utilicen una comunicación básica se limita a conocer la librería que permite enviar y recibir datos a través del puerto serie.

La librería estándar de comunicación para Arduino en lenguaje Processing es SoftwareSerial [SoftwareSerialArduinoLibrary]. Esta librería contiene un conjunto básico de comandos para


configurar, enviar, recibir y consultar datos sobre el puerto serie y su buffer de recepción y envío de mensajes.

Adicionalmente y para facilitar el trabajo de las configuraciones del interfaz de red se facilitan librerías adicionales que hacen transparente el envío de los comandos de configuración al puerto serie para estos interfaces. Así mediante funciones o métodos se engloban varios envíos de comunicación para el interfaz.

Para el resto de lenguajes de programación que pueden emplearse para programar la placa ocurre algo similar ya que pueden utilizarse las librerías específicas de cada uno de estos lenguajes para el acceso al puerto serie.

Sin embargo, para el trabajo con interfaces de red como Ethernet o WiFI se produce en el Arduino mediante la conexión a otro de los buses internos de los que dispone, en este caso el bus SPI (Serial Peripheral Interface). Es por ello que se facilitan para el lenguaje Processing de Arduino las librerías Ethernet [EthernetArduinoLibrary] y WiFi Library [WiFiArduinoLibrary]. Al igual que todas las librerías para el lenguaje Processing, estas se basan en un conjunto muy reducido de primitivas básicas de configuración, lectura, escritura y consulta de datos (muy similar a la presente para el trabajo con el puerto serie) pero añadiendo algunas funciones adicionales para el trabajo con estos protocolos.

Por el contrario, para la programación de Ethernet y Wifi con otros lenguajes de programación se requieren de librerías específicas que permiten enmascarar el trabajo de bajo nivel con el bus SPI y la configuración particular de la placa. Una de las librerías más empleadas en C++ para la comunicación WiFi es la librería SFE_CC300_Library [SFECC3000Library].

8.1.2. Raspberry Pi

Para la programación de comunicaciones en Raspberry Pi ya no estamos sujetos a grandes restricciones en cuanto al hardware por lo que podemos utilizar las librerías que los diferentes lenguajes incorporan. Para el caso de la programación con Bluetooth podemos abrir el dispositivo para trabajar con él como si fuera un puerto serie al igual que se realiza en la plataforma Arduino, si bien aquí el interfaz de red puede ser de tipo USB o bien mediante un shield de ampliación.

Para el lenguaje de programación Python bastaría con instalar la librería de soporte (python-serial) puede realizarse la aplicación de gestión de paquetes de la siguiente forma:

$sudo apt-get install python-serial


Un programa de ejemplo en Python sería:

En caso de utilizar otro lenguaje para la programación a través de Bluetooth se procedería de forma similar mediante la apertura del puerto serie correspondiente a ese interfaz. Pueden hacer falta algunas librerías adicionales en el sistema operativo como BlueZ [BlueZ] que es el software que proporciona el soporte a este protocolo en sistemas operativos Linux. Con la instalación de este software se permite la programación en lenguaje C/C++ mediante sockets, facilitando el trabajo de mediante esta norma.

Al igual que ocurre con el soporte a Bluetooth, dentro de la arquitectura Raspberry Pi existen diferentes librerías estándar integradas en los lenguajes distintos lenguajes de programación soportados para el trabajo con el protocolo WiFi. El soporte a WiFi se hace a través del propio sistema operativo instalado, que lo muestra como un dispositivo más dentro de los integrados en la arquitectura, pudiendo realizarse el acceso a su programación a través del mismo mediante la apertura de sockets sobre el interfaz de red adecuado.

Ilustración 30. Ejemplo de programación con Bluetooth en Python

#! /usr/bin/python

import serial

from time import sleep

bluetoothSerial = serial.Serial(“/dev/rfcomm1”, baudrate=9600)

count = None

while count == None:

try:

count = int(raw_input(“Introduce un número “)

except:

pass

bluetoothSerial.write(str(count))

print bluetoothSerial.readline()


8.2. APIs

Esta sección describe diferentes APIs que permiten el trabajo con los dispositivos, ya sea para la abstracción del manejo de alguno de sus componentes o bien la comunicación entre estos dispositivos y otros equipos informáticos.

8.2.1. WiringPi

WiringPi [WiringPi] es una librería para lenguaje de programación C/C++ que pude ser empleada por otros lenguajes de programación por medio de wrappers. Esta librería permite el acceso a la entrada y salida ofrecida por la placa Raspberry Pi utilizando una sintaxis y procedimientos similares a las que se usan en el lenguaje de programación para Arduino Processing/Wiring. La librería permite el acceso a los diferentes pins de la GPIO, además de permitir el acceso a los interfaces series UART, I2C y SPI. Una de las ventajas de la librería es que permite la expansión con nuevos módulos personalizados para el trabajo a bajo nivel, simplificando mucho la programación de aplicaciones.

Adicionalmente se integra un conjunto de utilidades para línea de comando que permiten programar y acceder a la GPIO de la placa.

8.2.2. Pi4J

Pi4J [Pi4J] es un proyecto que proporciona una API para acceder a las capacidades de entrada y salida que ofrece Raspberry Pi para el lenguaje de programación Java. El objetivo es abstraer totalmente al programador del trabajo a bajo nivel, tanto en el acceso a los puertos como en el manejo de las diferentes interrupciones mediante una librería para Java. Se trata de un proyecto todavía en desarrollo, aunque las versiones liberadas son muy estables. Entre sus características más destacadas se destacan:

Permite realizar operaciones de bajo nivel con la GPIO de la placa, tales como configuración, lectura, escritura, establecimiento de los flancos de estado para los pines, etcétera.

Permite establecer listeners o métodos que son invocados cada vez que un valor de un pin es cambiado.

Proporciona soporte a las comunicaciones mediante el puerto serie RS232, I2C y SPI.

Ofrece un puente para el acceso y manejo a la librería WiringPi [WiringPi].

8.2.3. Firmata

Firmata [Firmata] establece una librería que implemente el propio protocolo Firmata que permite a un software instalado en un equipo interactuar con las placas Arduino o Raspberry Pi sin tener que establecer y crear un protocolo propio. La ventaja de este protocolo es que puede ser implementado tanto en cualquier arquitectura de microcontrolador como en cualquier software y lenguaje de computadora (clientes). Actualmente, la implementación más avanzada del protocolo se encuentra disponible para la arquitectura Arduino. Por otra parte se encuentran implementadas versiones cliente para los siguientes lenguajes: Processing, Python, Perl, Ruby,


Clojure, JavaScript, Java, .NET, PHP. El protocolo Firmata está basado en el formato de mensajes empleado por los equipos MIDI.

8.2.4. Device I/O

Device I/O [DeviceIO] proporciona un API para el acceso a los distingos periféricos y hardware que se integran en dispositivos embebidos. La librería da soporte a: GPIO, I2C, UART, puertos serie, etecétera. La librería para Java que está siendo desarrollada bajo el grupo de desarrollo OpenJDK. Se trata de una librería de software libre. Su principal objetivo es hacer transparente el trabajo con cualquier tipo de periférico independientemente del tipo y plataforma que sea. Si bien existen otras librerías mucho más maduras y completas, el objetivo que persigue Device I/O es el de unificar el manejo de cualquier periférico bajo un único framework.

8.2.5. Ardulink

Ardulink [Ardulink] es una solución para lenguaje de programación Java que habilita y permite el control y coordinación de placas Arduino mediante la definición de un protocolo y un interfaz de comunicación que puede ser ampliado. Este protocolo está basado en un paradigma cliente/servidor. Como característica adicional añade diferentes componentes Java Swing integrables en los proyectos a desarrollar en los dispositivos maestros (computadores o dispositivos móviles) de tal forma que pueden integrarse en el interfaz gráfico diferentes controles para el manejo de la placa Arduino como controles tipo potenciómetro, switches, interruptores, etcétera. Se incluyen diferentes pre-configuraciones para algunos componentes de tal forma que facilitan el propio desarrollo de nuevas aplicaciones.

Además proporciona un programa de tipo consola que permite depurar las aplicaciones desarrolladas.

8.2.6. Blynk

Blynk [Blynk] es una plataforma de desarrollo de aplicaciones de control y monitorización entre dispositivos móviles y diversas plataformas de hardware a través de Internet. Actualmente se da soporte a dispositivos móviles para iOS y Android mientras que para las plataformas hardware se tiene soporte para Raspberry Pi y Arduino. Este sistema se divide en tres componentes esenciales:

Blynk Apps: que son las aplicaciones en los dispositivos móviles. La plataforma proporciona librerías para el acceso además de componentes gráficos visuales que permiten ser integrados en las interfaces gráficas de las aplicaciones.

Blynk Server: es el responsable de gestionar las comunicaciones entre los dispositivos móviles y los microcontroladores. Puede utilizarse un servidor ubicado en la nube o bien realizar una instalación en la que se habilite un servidor privado. El servidor es libre y consume muy pocos recursos por lo que puede instalarse incluso en una máquina Raspberry Pi. Los mensajes pasan a través de este servidor consiguiendo hacer transparente la comunicación entre los dispositivos, ya que mantiene una tabla de


gestión y mapeo de dispositivos y microcontroladores que permiten encaminar los paquetes desde el origen hasta su destino correctamente.

Blynk Libraries: que son librerías para las principales plataformas de hardware que gestionan la comunicación con el servidor y procesan los mensajes adecuadamente.

La comunicación entre el servidor y los equipos se realiza mediante protocolos que puedan conectar a internet, como Ethernet, WiFi o 3G.

8.2.7. iArduino

iArduino [iArduino] es una aplicación para dispositivos iOS que permite controlar una placa Arduino desde una red WiFi. La aplicación permite controlar los pines de entrada/salida de forma individual. Tiene compatibilidad con placas Arduino Uno y Arduino Mega. La aplicación permite desarrollar pantallas gráficas con componentes que manejan las entradas y salidas de la propia placa.

8.2.8. Chrome Web Bluetooh

Chrome Web Bluetooth [WebBluetooth] es una librería que cuenta con el apoyo en el desarrollo de Google que permite a través de JavaScript al uso y manejo de Bluetooth. La mayor ventaja que presenta el uso de JavaScript es la teórica independencia de plataforma, ya que no se realiza código específico para cada una de las arquitecturas. Para ello se realizan aplicaciones web que tengan soporte a este lenguaje y se incorpora la librería al desarrollo. Esta API es de reciente desarrollo y publicación (Noviembre de 2015) por lo que se encuentra en su fase inicial de publicación de la especificación junto con una implementación básica. Sin embargo ya se encuentra facilitado el acceso a Bluetooth LE con el uso del perfil GATT para el descubrimiento de dispositivos y servicios. Además, al estar fuertemente apoyado por Google es de esperar que su desarrollo y ampliación se realice de forma rápida.

8.3. Servicios, frameworks y plataformas

Esta sección describe algunos frameworks y plataformas que sirven para de una forma integral dar soporte a la construcción de aplicaciones Internet of Things. La mayoría de estas soluciones se basan en proporcionar por medio de una arquitectura Cloud el proceso integral de análisis, visualización y toma de acciones. Para ello se habilitan diferentes APIs desde las cuales los sensores pueden enviar la información pertinente a estas plataformas.

8.3.1. Temboo

Temboo [Temboo] es un servicio en la nube que facilita la conexión entre diferentes aplicaciones Web integrando a su vez distintas plataformas para que estas se comuniquen entre sí. Habilita que placas Arduino puedan usar las APIs de muchos de los más populares servicios de internet como Twitter, Facebook, Instagram, YouTube, Xively, etcétera. La plataforma está basada en Choreos, que permite interpretar, transformar y generar los mensajes adecuados para cada uno de los servicios a los cuales se tiene soporte.


El esquema de funcionamiento se basa en la creación de una cuenta de usuario dentro de la plataforma Teembo desde la cual generamos una clave de aplicación. A partir de esta, y utilizando el API facilitado por la misma plataforma podremos programar el dispositivo Arduino. La librería se encargará de las conexiones con el servicio Cloud. El código insertado en el microcontrolador únicamente debe encargarse de obtener las medidas y valores deseados y establecer el servicio al cual quiere enviarse esta información consiguiendo hacer totalmente transparente el trabajo con estos.

El único requerimiento necesario es disponer de una conexión Internet, ya sea a través de Ethernet o WiFi. Por ello el soporte a Arduino se hace solamente con modelos de tipo Arduino Yun o bien utilizando este como pasarela entre tipos de Arduino más básicos.

8.3.2. SpaceBrew

SpaceBrew [SpaceBrew] es un framework que ofrece un servicio y un kit de desarrollo para orquestar y coordinar diferentes espacios y elementos interactivos. Si bien el objetivo principal de esta plataforma no es el de dotar de soporte al trabajo con tecnología relacionadas con el Internet of Things, sí puede ser empleado como parte de desarrollo de ciertas aplicaciones. El sistema es capaz de realizar el enrutamiento a través de cualquier elemento conectado a Internet (y con capacidad para manejar WebSockets). El sistema se basa en un paradigma publish-subscribe para el envío de mensajes. De esta forma pueden crearse fácilmente desde su interfaz web las conexiones entre diferentes elementos (como pueden ser microcontroladores y equipos) realizando cierta lógica de conexión, es decir, en función de los tipos y valores de los mensajes intercambiados se permite interactuar distintamente entre entidades. El concepto básico es extender y dotar de funcionalidad añadida a un paradigma de comunicación publish/subscribe facilitando el desarrollo de aplicaciones que usen este mismo paradigma.

El ejemplo más claro de utilización de este framework es la creación de entornos interactivos en el cual un microcontrolador con diferentes sensores (botones, interruptores, etcéteras) permite enviar órdenes a una aplicación que se ejecuta en otro equipo. Suele ser utilizado por artistas gráficos para crear arte interactivo.

8.3.3. Xively

Xively [Xively] es la continuación y ampliación de la plataforma Pachube. Xively ofrece un servicio online para la publicación de información que es obtenida por la diferente sensorización de un sistema, generando gráficas en tiempo real y análisis de información accesible a través de Internet. Por tanto esta plataforma ofrece servicios en la nube.

El modo de funcionamiento es similar al empleado por plataformas similares, en el cual el usuario debe crear una cuenta en el sistema. Una vez obtenida la pertinente autorización podemos comenzar a registrar los diferentes dispositivos que tengamos desde los cuales queremos publicar su información recibiendo una clave de dispositivo y otra de aplicación. Desde la propia página web del servicio pueden configurarse y gestionarse opciones avanzadas del dispositivo.


Xively proporciona librerías de programación para algunas plataformas y lenguajes de programación que gestionan de forma de transparente la comunicación y envío de datos hacia el propio servicio, entre los que se incluye el soporte a Arduino y Raspberry Pi. Una vez creado el código de captura y envío de información la arquitectura gestiona automáticamente la publicación en la propia web de Xively permitiendo crear un Dashboard de las distintas medidas y valores que se van obteniendo en el sistema.

8.3.4. ZettaJS

ZettaJS [ZettaJS] es una plataforma Open Source construida sobre el lenguaje Node.js y cuyo objetivo es dotar a cada dispositivo de la red de una serie de servicios basados en RESTful para el acceso a los recursos y acciones. Debido a las características implícitas del propio lenguaje utilizado es ideal para su aplicación en sistemas asíncronos basados en programación reactiva, es decir, que todos los componentes del sistema se comunican mediante la activación de algún servicio del API.

El principal componente en el que está basado es el de Zetta Server que puede ser ubicado en cualquier tipo de dispositivo que tenga capacidad para ejecutar Node.js, es decir, desde un PC hasta una Raspberry Pi, siendo usual ubicarlos en aquellos dispositivos destinados a ser hardware hubs dentro del sistema. Los servidores facilitan la comunicación con los distintos nodos y sensores tipo Arduino o Spark Core proporcionándoles un API REST tanto de forma local como en el Cloud. Además, es este propio componente el que se encarga de mantener y establecer las conexiones entre los diferentes servidores presentes en el sistema. Otro servidor Zetta existirá en el Cloud y mantiene todas las APIs que han creado y gestionado los servidores instalados en los diferentes hubs del sistema.

Los servidores mantienen unos objetos denominados como Drivers, que son los encargados de modelar los distintos dispositivos y hacer transparente el acceso al nivel físico de los mismo proporcionando una serie de APIs para los mismos. Además, la plataforma proporciona soporte para establecer unos mecanismos para el descubrimiento de dispositivos que pueden estar en la propia red.

De cara al desarrollo de aplicaciones se facilitan abstracciones para incrementar la productividad, de tal forma que se enmascara y se simplifica el trabajo con los protocolos de nivel inferior y el acceso a las particularidades de ciertos sensores y actuadores.

Básicamente los servidores Zetta instalados en el hub o coordinador de la red ofrecen los servicios para el acceso a los distintos dispositivos que están conectados a él, haciendo accesible a su vez a través de un servidor general ubicado en el Cloud.

8.3.5. ThingPlus

ThingPlus [ThingPlus] es una plataforma que integra varios servicios en la nube desde la cual se puede capturar y enviar información proveniente de varios tipos de dispositivos físicos como sensores y realizar diversas tareas de análisis y representación gráfica de la misma. Dispone de diversas herramientas para la gestión y configuración de los sensores y las pasarelas que actúan de transformación de los paquetes de datos provenientes de los propios sensores hacia el


formato unificado con el que trabaja la arquitectura. Se ofrece un middleware al desarrollador de aplicaciones para poder realizar el envío de la información. Además dispone de la posibilidad de establecer sensores virtuales que proveen información desde aplicaciones software y fuentes de datos públicas. Dentro de los servicios en la nube se encuentra la posibilidad de integrar un sistema de reglas que permite activar diferentes tareas en el caso de cumplirse alguno de los patrones definidos. La arquitectura es completamente escalable y es independiente de cualquier infraestructura Cloud donde se despliegue. Finalmente, el sistema habilita APIs para la consulta de información y que pueden ser utilizadas para crear aplicaciones que hagan uso de estos servicios.

8.3.6. ThingSpeak

ThingSpeak [ThingSpeak] es una plataforma para el envío de información de sensorización hacia una arquitectura en la nube. Dentro de ella se ofrecen diversas herramientas para el análisis de información y representación de la información, además un sistema de gestión de acciones que permite reaccionar antes determinados eventos. La arquitectura es completamente compatible con dispositivos Arduino y Raspberry Pi por lo que pueden crearse aplicaciones de una forma rápida. Uno de sus puntos fuertes es que permite integrarse con el software matemático MATLAB para la programación y análisis de modelos que pueden ser utilizados para lanzar alertas y eventos en función del mismo.

8.4. Reglas

En esta sección se describen algunas librerías y frameworks que facilitan la construcción de aplicaciones que se basan en reglas para la detección y actuación ante patrones sensible al contexto.

8.4.1. Drools

Drools [Drools] es un BRMS (Business Rule Management System) de libre distribución. Este tipo de sistemas permite codificar la lógica en forma de reglas a las cuales se les puede asignar código que será ejecutado cuando estas se cumplen. Drools implementa la especificación JSR94 (Java Rule Engine API).

Las reglas son definidas en el propio lenguaje que facilita el framework y que es llamado DRL (Drools Rule Language). Estas se guardan en ficheros de texto con extensión .drl y permiten ser cambiadas y modificadas. Cuando se ejecuta el motor de inferencia para comprobar cuál es el actual contexto, todas las reglas en las cuales sus condiciones se cumplen pasan a la agenda como reglas activas. Una vez el motor ha finalizado, Drools va seleccionando las reglas activas para ir ejecutándolas una a una (el orden dependerá de algunos patrones ejecutados). Drools permite establecer atributos para las reglas tales como las fechas de validez de las reglas, la prioridad de las mismas, la capacidad o no de establecer bucles reglas, etcétera. Además se permiten crear asociaciones o grupos de reglas, de tal manera que pueden construirse a partir de células sencillas reglas mucho más complejas.


8.4.2. Easy Rules

Easy Rules [EasyRules] es un motor de reglas sencillo escrito en Java. Su objetivo como marca su nombre es la simplicidad de tal forma que pueda ser contenido en una única librería de tamaño pequeño y con pocas dependencias, pudiendo ser portado a equipos con una capacidad de cómputo limitada. Entre sus características da soporte a la composición de reglas complejas a partir de otras más simples y la posibilidad de poder configurar dinámicamente el motor. Permite además establecer prioridades entre reglas de tal forma que estás sean evaluadas con preferencia. Las reglas se definen en lenguaje Java mediante la extensión de clases bases. De cara a la ayuda al programador, se permite la definición de reglas mediante anotaciones para facilitar la construcción de las mismas.

8.4.3. Jess Rules

Jess Rules [JessRules] es un sistema de reglas Open Source que incluye un entorno de ejecución de scripts desarrollado en Java. Jess permite construir software Java con capacidad para el razonamiento mediante la declaración de reglas. Las reglas y acciones se escriben en un lenguaje muy similar a CLIPS denominado como el propio motor. En este lenguaje se definen los diferentes hechos y reglas del sistema, siendo los hechos los que determinan que reglas de las escritas se pueden activar o disparar. Para trabajar y activar el motor de inferencia desde el propio código Java se facilitan diversos interfaces que interconectan el propio programa implementando en Java con el intérprete de Jess. El hecho de requerir de la escritura de las reglas en el propio lenguaje Jess hace que sea dificultoso el trabajo con esta librería.


9. Referencias bibliográficas

[ArduinoAnalisisPlacas] Análisis de los diferentes tipos de Arduino. http://comohacer.eu/analisis-comparativo-placas-arduino-oficiales-compatibles/

[ActuadoresArduino] Listado de actuadores para la plataforma Arduino. https://aprendiendoarduino.wordpress.com/2015/03/31/actuadores-y-perifericos-de-salida/

[IntelGalileo] Información sobre Intel Galileo. https://www.arduino.cc/en/ArduinoCertified/IntelGalileo

[IntelEdison] Información sobre Intel Edison.

http://www.xataka.com/eventos/intel-edison-el-triunfo-de-la-miniaturizacion-y-la-nueva-era-de-los-wearables

[RaspberryPi] Información sobre Rasberry Pi. https://es.wikipedia.org/wiki/Raspberry_Pi#Accesorios

http://www.xataka.com/tag/raspberry-pi

[TouchBoard] Información sobre Touch Board.

http://www.bareconductive.com/shop/touch-board/

[ZigBee] Información sobre Zigbee.

https://es.wikipedia.org/wiki/ZigBee#ZigBee_vs_Bluetooth

[Trinket] Información sobre Adafruit Trinket.

https://www.adafruit.com/products/1500

[NextThingCHIP] Página oficial de NextThing CHIP. http://nextthing.co/pages/chip

[RFID] Página oficial de la alianza Rain RFID – http://rainrfid.org

[WiFiAlliance] Página oficial de la entidad de certificación Wi-Fi Alliance – http://www.wi-fi.org

[Bluetooth] Página oficial de Bluetooth – http://www.bluetooth.com

[Arduino] Página oficial de Arduino – http://www.arduino.cc

[Processing] Página oficial de Processing – http://www.processing.org

[Netduino] Página oficial de Netduino – http://www.netduino.com

[Firmata-Arduino] Página oficial para la implementación de Firmata para Arduino – http://github.com/firmata/arduino

http://comohacer.eu/analisis-comparativo-placas-arduino-oficiales-compatibles/

https://aprendiendoarduino.wordpress.com/2015/03/31/actuadores-y-perifericos-de-salida/

https://www.arduino.cc/en/ArduinoCertified/IntelGalileo



https://es.wikipedia.org/wiki/Raspberry_Pi#Accesorios

http://www.xataka.com/tag/raspberry-pi

http://www.bareconductive.com/shop/touch-board/

https://es.wikipedia.org/wiki/ZigBee#ZigBee_vs_Bluetooth

https://www.adafruit.com/products/1500

http://nextthing.co/pages/chip

http://rainrfid.org/

http://www.wi-fi.org/

http://www.bluetooth.com/

http://www.arduino.cc/

http://www.processing.org/

http://www.netduino.com/

http://github.com/firmata/arduino


[Python] Página oficial de Python – https://www.python.org

[PEP20] The Zen of Python página oficial – http://legacy.python.org/dev/peps/pep-0020/

[Lua] Página oficial de Lua – http://www.lua.org

[PHP] Página oficial de PHP – http://php.net

[Eclipse] Página oficial de Eclipse – http://www.eclipse.org

[Geany] Página oficial de Geany – http://www.geany.org

[CodeBlocks] Página oficial de Code Blocks – http://www.codeblocks.org

[SoftwareSerialArduinoLibrary] Página de referencia – http://www.arduino.cc/en/Reference/SoftwareSerial

[EthernetArduinoLibrary] Página de referencia – http://www.arduino.cc/en/Reference/Ethernet

[WiFiLibraryArduinoLibrary] Página de referencia – http://www.arduino.cc/en/Reference/WiFi

[SFECC3000Library] Página de descarga – https://github.com/sparkfun/SFE_CC3000_Library

[BlueZ] Página oficial de BlueZ – http://www.bluez.org/about

[Pi4J] Página oficial de Pi4J – http://pi4j.com

[WiringPi] Página oficial de WiringPi – http://wiringpi.com

[DeviceIO] Página oficial de Device I/O – http://openjdk.java.net/projects/dio

[Ardulink] Página oficial de Ardulink – http://www.ardulink.org

[Blynk] Página oficial de Blynk – http://www.blynk.cc

[iArduino] Página oficial de iArduino – http://i-arduino.blogspot.com.es

[WebBluetooth] Página oficial de Web Bluetooth – http://webbluetoothcg.github.io/web-bluetooth/

[Temboo] Página oficial de Temboo – http://temboo.com

[Xively] Página oficial de Xively – http://xively.com

[SpaceBrew] Página oficial de SpaceBrew – http://docs.spacebrew.cc

[ZettaJS] Página oficial de ZettaJS – http://www.zettajs.org

[Drools] Página oficial de Drools – http://www.drools.org

https://www.python.org/

http://legacy.python.org/dev/peps/pep-0020/

http://www.lua.org/

http://php.net/

http://www.eclipse.org/

http://www.geany.org/

http://www.codeblocks.org/

http://www.arduino.cc/en/Reference/SoftwareSerial

http://www.arduino.cc/en/Reference/Ethernet

http://www.arduino.cc/en/Reference/WiFi

https://github.com/sparkfun/SFE_CC3000_Library

http://www.bluez.org/about

http://pi4j.com/

http://wiringpi.com/

http://openjdk.java.net/projects/dio

http://www.ardulink.org/

http://www.blynk.cc/

http://i-arduino.blogspot.com.es/

http://webbluetoothcg.github.io/web-bluetooth/

http://webbluetoothcg.github.io/web-bluetooth/

http://temboo.com/

http://xively.com/

http://docs.spacebrew.cc/

http://www.zettajs.org/

http://www.drools.org/


[EasyRules] Página oficial de Easy Rules – http://www.easyrules.org

[JessRules] Página oficial de Jess Rules – http://www.jessrules.com

[ArdOS] Página con información sobre el sistema operativo ArdOS – https://bitbucket.org/ctank/ardos-ide/wiki/Home

[DuinOS] Página de descarga del sistema operativo – https://github.com/DuinOS/DuinOS

[FemtoOS] Página oficial del sistema operativo – https://www.femtoos.org

[RTuinOS] Página oficial del sistema operativo – https://github.com/PeterVranken/RTuinOS

[Raspbian] Página oficial del sistema operativo – https://www.raspbian.org

[Windows10IoT] Página oficial de Windows 10 IoT – https://dev.windows.com/es-es/iot

[ArchLinuxARM] Página oficial de Arch Linux ARM – http://archlinuxarm.org

[TinyOS] Página oficial de TinyOS – http://www.tinyos.net

[Contiki] Página oficial de Contiki – http://www.contiki-os.org

[LiteOS] Página oficial de LiteOS – http://www.liteos.net

[BertOS] Página oficial de BertOS – http://github.com/develersrl/bertos

[ThingPlus] Página oficial de ThingPlus – https://thingplus.net/en/

[ThingSpeak] Página oficial de ThingSpeak – https://thingspeak.com

http://www.easyrules.org/

http://www.jessrules.com/

https://bitbucket.org/ctank/ardos-ide/wiki/Home

https://github.com/DuinOS/DuinOS

https://www.femtoos.org/

https://github.com/PeterVranken/RTuinOS

https://www.raspbian.org/

https://dev.windows.com/es-es/iot

http://archlinuxarm.org/

http://www.tinyos.net/

http://www.contiki-os.org/

http://www.liteos.net/

http://github.com/develersrl/bertos

https://thingplus.net/en/

https://thingspeak.com/

MEMORIA TECNICA SOLICITUD 2014 PEC - aiju.info · Intel Edison ... C/C++ ... Eclipse ...

Documents

Transcript of MEMORIA TECNICA SOLICITUD 2014 PEC - aiju.info · Intel Edison ... C/C++ ... Eclipse ...