Firmata es un protocolo genérico para la comunicación con microcontroladores desde software instalado en un ordenador. Este protocolo se puede implementar en cualquier arquitectura de microcontroladores, así como en cualquier paquete de software.
El objetivo de firmata es permitir controlar completamente Arduino desde software instalado en un ordenador, sin escribir una sola línea de código de Arduino.
Por ejemplo, cuando se dice que Windows 10 puede usarse con Arduino o incluso se puede leer en algunos artículos “Como instalar windows 10 en Arduino”, realmente lo que significa es que puedes controlar un Arduino desde Windows 10, mediante la comunicación con el protocolo firmata entre Windows 10 y Arduino. Windows 10 implementa este protocolo de forma nativa.
Enlaces Windows 10 y Arduino:
Explicación de Windows + Arduino:
La librería: https://github.com/ms-iot/remote-wiring
Esto permite instalar un programa en windows 10 con soporte nativo de .NET para comunicarse con un Arduino y hacer que encienda un led, mueva un motor o lea la temperatura de un sensor conectado al Arduino sin tener que programar el Microcontrolador.
Más adelante entraremos a fondo en como usar Arduino con Windows 10.
Para comprobar fácilmente cómo funciona firmata, disponemos de un programa que funciona en Windows, Linux, Mac OS-X y necesita la version 2.2 o superior de la librería Firmata para Arduino (actualmente está en la 2.5). Este programa se llama “Firmata Test Program” y está disponible en: http://firmata.org/wiki/Main_Page#Firmata_Test_Program
Para implementar el protocolo firmata en Arduino debemos usar el sketch StandardFirmata que está incluido en el IDE de Arduino: https://github.com/firmata/arduino/tree/master/examples/StandardFirmata
La última versión de la librería Firmata para Arduino está en: https://github.com/firmata/arduino
Hay dos modos de uso de firmata. Un modelo es usar los métodos ofrecidos por la librería firmata dentro del sketch para enviar y recibir datos entre el Arduino y el software ejecutándose en el ordenador. Por ejemplo, mandar el valor leído de una entrada analógica.
El segundo modelo y más común es cargar en Arduino el sketch de propósito general llamado “StandardFirmata” o alguna de sus variaciones como “StandardFirmataPlus” o “StandardFirmataEthernet” y usar el software en el ordenador para interactuar con Arduino.
Un listado de los clientes de firmata para diversos lenguajes de programación se puede encontrar en: https://github.com/firmata/arduino#firmata-client-libraries
En caso que deseemos contribuir en el desarrollo o mejorar en la implementación de firmata en Arduino ver: https://github.com/firmata/arduino#contributing
Y cualquier problema sobre el desarrollo se puede seguir en el hilo de gitter: https://gitter.im/firmata/arduino y en los problemas de diseño: http://firmata.org/wiki/Design_Issues
Se debe tener en cuenta que debido a la limitada memoria de Arduino, el número de funcionalidades que se puede añadir es limitada.
Práctica: Probar como funciona el protocolo firmata en Arduino.
- Descargar el programa “Firmata Test Program” para sistema operativo correspondiente de http://www.pjrc.com/teensy/firmata_test/
- Cargar el sketch “StandardFirmata” en Arduino: Archivo -> Ejemplos -> Firmata -> StandardFirmata.
- Probar que funciona encendiendo Leds y leyendo valores de los pines analógicos y digitales.
Detalles del protocolo
El estándar del protocolo firmata se puede encontrar en: https://github.com/firmata/protocol, donde disponemos de las espcificaciones del protocolo standard, así como las implementaciones para comunicar con dispositivos i2c, onewire, soporte para encoders, servos, motores paso a paso, etc…
La anterior web oficial del protocolo firmata es http://firmata.org/wiki/Main_Page que se mantiene a efectos de documentación
Firmata está basado en el formato de mensaje de midi: http://www.midi.org/techspecs/midimessages.php en el que los comandos se mandan en 8 bits y los datos en 7 bits. En Midi System Exclusive (Sysex http://www.2writers.com/eddie/tutsysex.htm), los mensajes pueden tener cualquier longitud y se usa de forma más extensiva en el protocolo firmata.
El núcleo del protocolo está descrito en: https://github.com/firmata/protocol/blob/master/protocol.md
La implementación del protocolo firmata para Arduino se encuentra en https://github.com/firmata/arduino aunque este protocolo se podría implementar en cualquier otro microcontrolador.
La versión actual del protocolo firmata es la 2.5. Se trata de un protocolo serie a una velocidad de 57600 baudios.
Comandos
Los comandos (primer byte del protocolo), se descomponen en el primer nibble (el más significativo) es el propio comando y el segundo nibble del byte (el menos significativo) que en algunos casos aparece como 0 y da el número de puerto o de pin.
Los comandos son:
- 0x90 – datos del pin digital (un puerto son hasta 8 pines digitales que se almacenan en en los “port registers” que permiten una manipulación a bajo nivel más rápida. Cada puerto es controlado por 3 registros. Más información en https://www.arduino.cc/en/Reference/PortManipulation o en el capítulo del Tema 3 “Microcontroladores. Registros de memoria”.
- 0xE0 – datos del pin analógico
- 0xF4 – Configurar el modo del pin
- 0xF5 – configurar el valor del pin digital
- 0xC0 – configurar reporte del pin digital (una vez habilitado, el valor del pin debe ser reportado a la aplicación cliente)
- 0xD0 – configurar reporte del pin analógico (una vez habilitado, el valor del pin debe ser reportado a la aplicación cliente)
- 0xF9 – versión del protocolo
En esta tabla se ve el mensaje utilizado y los bytes de datos usados:
| type |
command |
MIDI channel |
first byte |
second byte |
| analog I/O message |
0xE0 |
pin # |
LSB(bits 0-6) |
MSB(bits 7-13) |
| digital I/O message |
0x90 |
port |
LSB(bits 0-6) |
MSB(bits 7-13) |
| report analog pin |
0xC0 |
pin # |
disable/enable(0/1) |
– n/a – |
| report digital port |
0xD0 |
port |
disable/enable(0/1) |
– n/a – |
| start sysex |
0xF0 |
|
|
|
| set pin mode(I/O) |
0xF4 |
|
pin # (0-127) |
pin state(0=in) |
| set digital pin value |
0xF5 |
|
pin # (0-127) |
pin value(0/1) |
| sysex end |
0xF7 |
|
|
|
| protocol version |
0xF9 |
|
major version |
minor version |
Comandos sysex: la idea de estos comandos es disponer de un espacio para un segundo comando usando el primer byte después del SysEx start byte (0xF0). La diferencia es que los datos pueden tener cualquier tamaño al contrario que los mensajes MIDI standard que tienen 2 bytes)
- 0x71 – string
- 0x79 – nombre/versión del firmware
- 0xF7 – fin de Sysex
Más información en: https://github.com/firmata/protocol/blob/master/protocol.md#sysex-message-format
Más información del protocolo en: https://github.com/firmata/protocol/blob/master/protocol.md
La librería Firmata para Arduino
La librería Firmata de Arduino implementa el protocolo Firmata visto anteriormente para comunicar el Arduino con el software ejecutado en un ordenador
La última versión de la librería firmata para Arduino se encuentra en: https://github.com/firmata/arduino
La referencia de la librería Firmata para Arduino se encuentra en: https://www.arduino.cc/en/Reference/Firmata
Los métodos disponibles en la librería son:
- begin(long) – Comienza la librería, es posible poner otra velocidad diferente a la velocidad por defecto que es 57600 baudios. También es posible iniciar el protocolo firmata desde otro Stream que no sea el que viene por defecto que es Serial
- printVersion() – envía la versión del protocolo al ordenador
- blinkVersion() – parpadea la versión de protocolo en el “build in LED”, generalmente el pin 13.
- printFirmwareVersion() . envía la versión de firmware y su versión al ordenador
- setFirmwareVersion(byte major, byte minor) – Configura la versión del firmware
- setFirmwareNameAndVersion(const char *name, byte major, byte minor) – Configura nombre y versión del firmware
Métodos de envío de mensajes:
- sendAnalog(byte pin, int value) – Manda el valor del pin analógico
- sendDigitalPort(byte portNumber, int portData) – Manda el valor de un puerto digital de 8 bits.
- sendString(const char* string) – Manda un string a un ordenador.
- sendString(byte command, byte bytec, byte *bytev) – Manda un string al ordenador usando un tipo de comando
- sendSysex(byte command, byte bytec, byte* bytev) – Manda un comando un con array de bytes
- write(byte c) – Manda un byte al stream de datos.
Métodos de recepción de mensajes.
- available() – Comprueba si hay algún mensaje entrante en el buffer
- processInput() – Procesar los mensajes entrantes que hay en el buffer, mandado los datos a cualquiera de las funciones de callback registradas.
- attach(byte command, callbackFunction myFunction) – Registrar una función a un tipo de mensaje entrante.
- detach(byte command) – desregistrar la función del tipo de mensaje
Otros métodos:
- sendValueAsTwo7bitBytes(int value) – Escribe el valor como 2 bytes
- startSysex(void) – Comenzar mensaje sysex
- endSysex(void) – Finalizar mensaje sysex
Para asociar una función de callback a un tipo de mensaje de Firmata, la función debe cumplir el estándar de “callback function”. Hay varios tipos de funciones de respuesta en Firmata:
- genérica: void callbackFunction(byte pin, int value);
- reset del sistema: void systemResetCallbackFunction(void);
- string: void stringCallbackFunction(char *myString);
- sysex: void sysexCallbackFunction(byte command, byte byteCount, byte *arrayPointer);
Hay varios tipos de mensajes que se pueden asociar a las funciones de callback:
- ANALOG_MESSAGE //the analog value for a single pin // Comando (0xE0)
- DIGITAL_MESSAGE //8-bits of digital pin data (one port) // Comando (0x90)
- REPORT_ANALOG //enable/disable the reporting of an analog pin // Comando (0xC0)
- REPORT_DIGITAL //enable/disable the reporting of a digital port // Comando (0xD0)
- SET_PIN_MODE //change the pin mode between INPUT/OUTPUT/PWM/etc. // Comando (0xF4)
- STRING_DATA //C-style strings, uses stringCallbackFunction for the function type // Comando (0x71)
- SYSEX_START //generic, arbitrary length messages (via MIDI SysEx protocol), uses sysexCallbackFunction for the function type // Comando (0xF0)
- SYSTEM_RESET //message to reset firmware to its default state, uses systemResetCallbackFunction for the function type
Para instalar Standard Firmata en Arduino, se puede serguir este tutorial: http://www.instructables.com/id/Arduino-Installing-Standard-Firmata/?ALLSTEPS
Veamos el sketch que implementa firmata en Arduino llamado StandardFirmata.ino y es muy usado por aplicaciones para ordenador y móvil. Código: https://github.com/firmata/arduino/blob/master/examples/StandardFirmata/StandardFirmata.ino
Detalles:
- Implementa control de servos (librería servo.h), dispositivos I2C (librería wire.h)
- En línea 96, implementa la función wireWrite y wireRead para que funcione con todo tipo de versiones de IDE Arduino al compilar.
- En línea 747 setup: inicializa la versión de firmware y asocia las funciones de callback a los mensajes de entrada. La implementación de cada función se hace en las líneas anteriores. Luego resetea a la configuración por defecto de los pines.
- En línea 777 loop: en cada loop primero comprueba el cambio de estado de las entradas digitales. Luego busca mensajes entrantes firmata y los procesa si es necesario. Por último lee las entradas analógicas según el intervalo de muestreo configurado y manda datos a los dispositivos I2C con modo de lectura continua activado.
Y también tenemos estas otras implementaciones de firmata en Arduino:
Existen implementaciones específicas otras plataforma de desarrollo como spark que se puede ver en: https://github.com/firmata/spark
Ejercicio38 – Entendiendo Firmata:
Para poder ver los mensajes enviados por el protocolo firmata y entender cómo funciona, vamos a ejecutar un sketch que manda las lecturas de todos los puertos analógicos por el puerto serie con firmata.
Dado que los mensajes son en hexadecimal no es posible ver los mensajes con el terminal proporcionado por el IDE de Arduino y para ello se puede usar esta otra aplicación de terminal: https://sites.google.com/site/terminalbpp/
Pasos a seguir:
- Cargar en Arduino el sketch del ejercicio38 Entendiendo_Firmata: https://github.com/jecrespo/Aprendiendo-Arduino/blob/master/Ejercicio38-Firmata/Entendiendo_Firmata/Entendiendo_Firmata.ino
- Entender que hacer este sketch
- Abrir el programa de Terminal y configurarlo con:
- Baud rate = 57600
- Receive en HEX
- Habilitar las pantallas Dec, Hex y Bin
- Ejecutar el programa y capturar lo que envía Arduino en Hexadecimal.
En cada loop manda FFFF que nos indica que inica un loop, luego manda para el caso de un Arduino UNO manda las lecturas de los 6 puertos analógicos con el comando ANALOG_MESSAGE E0, E1, E2, etc… y luego el valor leído
Para entender lo que muestra, hay que ver cómo está implementado el protocolo para el comando ANALOG_MESSAGE en https://github.com/firmata/protocol/blob/master/protocol.md
| type |
command |
MIDI channel |
first byte |
second byte |
| analog I/O message |
0xE0 |
pin # |
LSB(bits 0-6) |
MSB(bits 7-13) |
E1 — Pin analógico 1
7D — 01111101
07 — 00000111
Valor = 00001111111101 = 1021
También manda en valor en decimal para comprobar con el Serial.println
Avanzado: Ver los ejemplos que trae la librería firmata de Arduino, entender y comprobar cómo funciona.
- SimpleAnalogFirmata
- SimpleDigitalFirmata
Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio38-Firmata
Firmata para controlar buses
Firmata no solo nos permite leer y escribir en puertos analógicos y digitales, también es posible manejar diferentes buses.
Firmata y Arduino en Windows 10
Microsoft ha entrado en el IoT con Windows 10 IoT Core que es una versión de Windows 10 optimizada para pequeños dispositivos como Raspberry Pi 2 y que usa la API de Universal Windows Platform (UWP) para construir aplicaciones.
En Abril de 2015 Microsoft anuncia Windows 10 IoT Core y la participación con Arduino: https://blogs.windows.com/buildingapps/2015/04/29/microsoft-brings-windows-10-to-makers/
Windows 10 IoT Core también soporta la API Arduino-Wiring usada en los sketches y librerías para un acceso directo al hardware desde Windows 10. Para programar Arduino Microsoft nos propone su IDE Visual Studio. Esto facilita a la gente familiarizada con la programación en .NET entrar en el mundo Arduino.
Más información en:
Para empezar con Windows IoT, solo hay que seguir las instrucciones de: http://ms-iot.github.io/content/en-US/GetStarted.htm en el apartado de Arduino y Windows 10.
- Arduino Wiring junto con Windows IoT Lightning functionality nos permite copiar y pegar sketches de Arduino y librerías de Arduino en el IDE (zona de Arduino Wiring Projects) y ejecutarlos en cualquiera de los dispositivos IoT Core como Raspberry Pi.
Guia de uso: http://ms-iot.github.io/content/en-US/win10/Lightning.htm
Ejemplo de Arduino Wiring con el blink: http://ms-iot.github.io/content/en-US/win10/samples/arduino-wiring/HelloBlinky.htm
Guia para portar a Arduino Wiring: http://ms-iot.github.io/content/en-US/win10/ArduinoWiringPortingGuide.htm
- Windows Remote Arduino, es una librería que permite controlar Arduino a través de Bluetooth, USB, Wi-Fi o Ethernet. Permite incluir los sensores de Arduino a los proyectos desarrollados con aplicaciones Windows.
La librería Windows Remote Arduino es una librería open source que conecta cualquier dispositivo Windows 10 como un Windows Phone, Surface, PC, o incluso una Raspberry Pi 2 con un Arduino que esté corriendo el StandardFirmata visto anteriormente. De esta forma es posible controlar remotamente un Arduino con el software desarrollado con esta librería.
- Windows Virtual Shields, es una librería open source para Arduino UNO que comunica con una aplicación corriendo en Windows 10 de forma que expone los sensores de los teléfonos Lumia o cualquier dispositivo corriendo Windows 10 a un Arduino.
Para conseguir esto se intercambian mensajes en formato JSON.
En nuestro caso el apartado que nos interesa para comunicar una aplicación desarrollada en Windows con Arduino es el Windows Remote Arduino.
Básicamente esta librería open source une un dispositivo con Windows 10 y Arduino mediante el protocolo firmata de forma sencilla.
Ejemplo para hacer blink con Windows Remote: https://www.hackster.io/windowsiot/basic-windows-remote-arduino-47eeb9
Esta imagen explica el funcionamiento de Windows Remote Arduino:
Una muy buena explicación de Windows Remote Arduino: https://blogs.windows.com/buildingapps/2016/02/04/what-is-windows-remote-arduino-and-what-can-it-do/
También es posible hacer aplicaciones .NET sin tener windows 10 usando una librería de firmata: http://www.acraigie.com/programming/firmatavb/
Es posible encontrar más proyectos de Windows 10 + Arduino en: https://microsoft.hackster.io/en-US/search?q=arduino
Otros enlaces:
Firmata y Arduino con Python
Una forma sencilla de comunicar Arduino con el ordenador mediante software open source es usar python. Hay disponibles varias librerías de firmata para python que facilitan el interfaz entre Arduino y el programa hecho en python.
Dado que Python es posible usarlo en multitud de Sistemas Operativos e incluso en Raspberry Pi o similares, tenemos una herramienta potente con Firmata + Python para comunicar Arduino con cualquier otro dispositivo.
Una buena guía para usar Arduino con python se encuentra en el playground de Arduino: http://playground.arduino.cc/Interfacing/Python
Para comunicar por puerto serie el ordenador ejecutando python, la mejor opción es usar la librería pyserial de python:
No solo es posible interactuar con Arduino por el puerto serie, sería similar hacerlo vía bluetooth, ethernet, etc… con las librerías adecuadas disponibles en python.
Librerías de Firmata para python:
Un artículo que explica perfectamente y en un lenguaje muy sencillo cómo controlar un Arduino a través de un programa de ordenador mediante firmata se puede leer en: http://edupython.blogspot.com.es/2014/06/como-programar-tu-arduino.html
Al usar firmata en Arduino y correr los programas en un ordenador tenemos unas serie de ventajas y desventajas respecto a cargar el sketch en el propio Arduino. Dependiendo del objetivo de nuestro proyecto puede ser más útil una estrategia u otra.
Ventajas:
- Nuestro programa no está limitado por la memoria RAM y Flash de Arduino
- El software de control se puede programar en cualquier lenguaje, no solo C++, siempre que tenga soporte para firmata. Por ejemplo: Firmata: Processing, Visual Basic, Perl, C#, PHP, Java, JavaScript, Ruby y por su puesto Python.
Desventajas:
- Programas más restringidos, es posible que algunas operaciones complejas no sea posible hacerlas. Por ejemplo el uso de interrupciones.
- Al arduino siempre debe estar conectado al ordenador. Debe tener comunicación para poder ejecutar acciones.
Ejercicio 38 – Blink (Arduino + Python + Firmata)
Vamos a probar varios programas para controlar Arduino desde programas corriendo en el ordenador hechos en python.
Preparar entorno para python:
- Descargar Python para el sistema operativo correspondiente: https://www.python.org/downloads/
- Instalar Python: https://docs.python.org/3/using/windows.html
- Instalar dependiencias python: http://code.rancidbacon.com/LearningAboutArduinoandPython
Preparar Arduino:
- Cargar el sketch StandardFirmata en Arduino.
Ejecutar el programa desde el ordenador usando la librería PyMata:
- Ejecutar el ejemplo blink.py: https://github.com/jecrespo/Aprendiendo-Arduino/blob/master/Ejercicio38-Firmata/Python_Firmata/blink.py
- Para conocer algo más de PyMata, ver los ejemplos de https://github.com/MrYsLab/PyMata/tree/master/examples
Para entender a fondo la librería PyMata ver la documentación de la API: http://htmlpreview.github.io/?https://github.com/MrYsLab/PyMata/blob/master/documentation/html/PyMata.pymata.PyMata-class.html
Ejercicio 38 – Medidor de luz con Firmata
Vamos a hacer un medidor de luz controlado por una fotoresistencia LDR pero usando firmata.
Hagamos este ejemplo sencillo pero sin programar una sola línea en el Arduino y controlarlo desde el ordenador: http://www.geekfactory.mx/tutoriales/tutoriales-arduino/tutorial-arduino-con-fotoresistencia-ldr/
Se trata de encender los LEDs en función de la intensidad de luz. Leer el código del ejemplo original y trasladarlo a un programa en python con firmata.
El esquema de conexiones es:
En este caso vamos a usar la librería pyFirmata que ya tenemos instalada y en Arduino ya está instalado el standardFirmata.
Ejecutar el ejemplo Medidor_Luz.py de https://github.com/jecrespo/Aprendiendo-Arduino/blob/master/Ejercicio38-Firmata/Python_Firmata/Medidor_Luz.py
Más información de pyFirmata en: https://github.com/tino/pyFirmata
Solución a los ejercicios: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio38-Firmata
Otro ejemplo explicado similar está en http://edupython.blogspot.com.es/2014/06/como-programar-tu-arduino.html
Avanzado: ejemplos con pyFirmata más complejos en: https://bitbucket.org/fab/pyfirmata/src/96116e877527/examples/, incluso hay un programa con una interfaz gráfica que funciona en linux.
Implementaciones de firmata en otros lenguajes
Como hemos visto, podemos controlar Arduino desde el ordenador mediante el protocolo firmata programando con cualquier lenguaje de programación que tenga implementado firmata o hagamos nosotros mismos la implementación. Podemos usar diversas librerías en función del lenguaje de programación que queramos usar:
Cuando se habla que programar Arduino con tal o cual lenguaje se refiere a hacer el control desde un ordenador que da órdenes a un Arduino corriendo standardFirmata.
En esta web tenemos múchos ejemplos de software/librerías para programar un Arduino desde un ordenador: http://firmata.org/wiki/Download (alternativa https://web.archive.org/web/20150911005414/http://firmata.org/wiki/Download)
Ejemplos interesantes:
Como ya se ha dicho, firmata no solo puede usarse por el puerto serie sino por cualquier otro medio. Ejemplo de uso de firmata con bluetooth para comunicar arduino + beaglebone: http://www.instructables.com/id/Wireless-Arduino-Control-Using-the-BeagleBone-Blac/
Firmata Builder
Firmata Builder es un módulo que nos permite generar un sketch de Arduino desde una selección de características de firmata.
Más información en:
Firmata Builder nos permite crear un sketch StandardFirmata reducido para nuestras necesidades y añadir otras funcionalidades propias.
ConfigurableFirmata es una versión de Firmata que separa las características del protocolo en clases individuales, haciendo más sencillo mezclar las características estándar del protocolo con otras personalizadas. La forma más sencilla de usar ConfigurableFirmata es usando FirmataBuilder.
Proyecto en github: https://github.com/firmata/ConfigurableFirmata
Fuente de ConfigurableFirmata: https://github.com/firmata/ConfigurableFirmata/tree/master/src
Librerías cliente que soportan ConfigurableFirmata: https://github.com/firmata/ConfigurableFirmata#firmata-client-libraries
Ejemplo: https://github.com/firmata/ConfigurableFirmata/blob/master/examples/ConfigurableFirmata/ConfigurableFirmata.ino
Aprendiendo Arduino 