Archivo de la categoría: Puerto Serie

UART y USB en Arduino

Ya hemos visto  anteriormente que la UART o USART es el puerto serie hardware que todos los microcontroladores tienen al menos uno y la comunicación serie es la base de casi cualquiera de las comunicaciones de los microcontroladores.

El “Bus Universal en Serie”, en inglés: Universal Serial Bus más conocido por la sigla USB, es un bus estándar industrial que define los cables, conectores y protocolos usados en un bus para conectar, comunicar y proveer de alimentación eléctrica entre computadores, periféricos y dispositivos electrónicos.

Su desarrollo partió de un grupo de empresas del sector que buscaban unificar la forma de conectar periféricos a sus equipos, por aquella época poco compatibles entre si, entre las que estaban Intel, Microsoft, IBM, Compaq, DEC, NEC y Nortel. La primera especificación completa 1.0 se publicó en 1996, pero en 1998 con la especificación 1.1 comenzó a usarse de forma masiva.

La forma que tenemos de comunicar Arduino con el ordenador y para programarlo es mediante el USB. Casi todos los Arduinos y compatibles tienen un interfaz USB y sino usaremos un cable FTDI que nos hará la función de convertirnos el interfaz serie de la UART de Arduino a un interfaz USB. No confundir con lo visto anteriormente de uso del ICSP para programar, puesto que en ese caso programamos directamente la MCU sin necesidad de un bootloader.

El interfaz USB en el ordenador nos permite tener un puerto serie virtual que usamos para conectar con Arduino. Además de comunicación, USB es un interfaz de alimentación.

Físicamente un  USB tiene 4 pines:

Pin 1=> Alimentación con un voltaje de 5V DC
Pin 2 y 3 => Sirven para la transmisión de datos del BUS
Pin 4 = Masa o tierra

Aunque la mayoría de pc’s ya ofrecen protección interna se incorpora un fusible rearmable de intensidad máxima 500mA con la intención de proteger tanto la placa Arduino como el bus USB de sobrecargas y cortocircuitos. Si circula una intensidad mayor a 500mA por el bus USB (Intensidad máxima de funcionamiento), el fusible salta rompiendo la conexión de la alimentación. Podemos probar esto cortocircuitando GND y 5V en Arduino.

En el caso del USB el 0 y 1 se distingue por la diferencia de voltaje entre D+ y D-

Más información de USB:

Y para saber todo sobre USB ver “USB in a nutshell”: http://www.beyondlogic.org/usbnutshell/usb1.shtml

Para que un Arduino tenga un interfaz USB, necesita de un chip que ofrezca un interfaz USB, en algunos casos el propio microcontrolador ya dispone de ese interfaz y en otros caso utiliza un segundo microcontrolador con interfaz USB.

Tutorial USB:

Cuando conectamos un USB al ordenador, necesitamos un driver o trozo de software que nos  implemente la comunicación con el USB y nos monte un puerto serie virtual. Estos drivers deben estar certificados por http://www.usb.org/home y pagar las correspondientes licencias de uso. En el caso de Arduino los drivers ya están incluidos desde windows 8.1 y tienen su licencia de uso, por ese motivo cuando conectamos Arduino, automáticamente nos reconoce el dispositivo.

Todos los dispositivos USB tienen un USB vendor ID (VID) que identifica al fabricante y que es otorgado por http://www.usb.org/developers/vendor/ y un product ID (PID) que identifica el producto de ese vendedor. De esta forma es posible identificar un dispositivo USB por el ordenador. Más información: http://www.oshwa.org/2013/11/19/new-faq-on-usb-vendor-id-and-product-id/

Listado de VID:

Como sabemos hay dos Arduinos (arduino.cc y arduino.org) y por lo tanto hay dos VID para Arduino:

  • 2a03  dog hunter AG (arduino.org)
  • 2341  Arduino SA (arduino.cc)

Ejemplo de problemas con el uso de los drivers USB según el chip que lleve Arduino: http://blog.make-a-tronik.com/instalando-drivers-usb-serial-ch340g-para-arduino/

Cada dispositivo necesita tener unico product id y vendor id. Los VID son vendidos a los fabricantes y los PID son elegidos por cada compañía. Por ejemplo FTDI es el propietadior del VID #0403 y ellos dan a sus chips los IDs entre #0000 y #FFFF (65536 PIDs). Arduino tiene su propio VID y para el Arduino UNO el PID es el #0001

Si quisiéramos hacer cuenta propia placa compatible con Arduino hay varias opciones:

  • Usar un chip FTDI en lugar del 16u4 que ya tiene un VID
  • Si quieres hacer más de una placa y comercializar, tendrás que comprar un VID a usb.org en http://www.usb.org/developers/vendor/ y pagar la licencia
  • Si es para hacer una placa como experimento, puedes elegir un VID/PID que no interfiera con ninguno de los dispositivos del ordenador.
  • También es posible comprar licencias para un VID/PID de empresas que desarrollen dispositivos USB.

Sin embargo no es posible usar el VID de Arduino cuando quieres distribuir tu propia placa compatible con Arduino. Leer: http://electronics.stackexchange.com/questions/16665/arduino-uno-usb-vid-pid

En linux es posible ver mejor el proceso de reconocimiento de un dispositivo USB, leer: http://playground.arduino.cc/Linux/All

Tester de VID y PID basado en Arduino: https://learn.adafruit.com/simple-arduino-based-usb-vid-and-pid-tester/lets-do-this-thing

Para actualizar el firmware del Atmega16u2 que nos hace de interfaz entre el USB y el microcontrolador principal del Arduino UNO, seguir este procedimiento: http://arduino.cc/en/Hacking/DFUProgramming8U2.

Para comprobar la versión de firmware ir al gestor de dispositivos en Windows y buscar el Arduino, luego botón derecho y propiedades y buscar en driver details el VID, PID y el revision number.

La última versión del firmware está en https://github.com/arduino/Arduino/tree/master/hardware/arduino/avr/firmwares/atmegaxxu2 y usar un programador DFU como flip http://www.atmel.com/tools/flip.aspx para cargar el nuevo firmware.

Cuando usamos un Arduino basado en el microcontrolador ATmega32u4 como el leonardo, nos encontramos con que se hace una re-enumeración del puerto serie en el reset.

Puesto que estas placas no tienen un chip dedicado para manejar la comunicación serie y tienen un interfaz USB integrado, eso significa que el puerto serie es virtual, es una implementación software tanto en el ordenador como en la placa. Así como el ordenador crea una instancia del puerto serie cuando lo enchufas, el Arduino Leonardo crea una instancia serie cuando se ejecuta el bootloader. La placa es una instancia de un USB driver Connected Device Class (CDC), esto significa que cada vez que reseteas la placa, la conexión USB serie es rota y restablecida de nuevo. La placa desaparecerá de la lista de puertos serie y la lista se re-enumerará. Cualquier programa que tenga una conexión serie abierta con el Arduino Leonardo perderá su conexión. En el caso del Arduino cuando se resetea la placa se está reseteando el procesador principal ATmega328p sin cerrar la conexión USB que es mantenida por el microcontrolador secundario ATmega16u2. Esta diferencia de comportamiento tiene implicaciones en la carga y comunicación con el microcontrolador.

Los Arduinos basados en el ATmega32u4 aparecen también como un dispositivo genérico USB de teclado y ratón, y puede ser programado para controlar estos dispositivos usando las clases MouseKeyboard https://www.arduino.cc/en/Reference/MouseKeyboard, de forma que Arduino puede conportarse como un teclado u un ratón.

Más información: https://en.wikipedia.org/wiki/USB_communications_device_class

Cuando usamos un Arduino basado en el ATmega32u4 debemos usar la función if(serial) https://www.arduino.cc/en/Serial/IfSerial que indica si el puerto serie está preparado y en el caso del Leonardo, indica si la USB CDC serial connection está abierta. De esta  forma nos aseguramos que arranca el programa de Arduino cuando ya hay conexión entre el Arduino y el ordenador, sino podríamos perder los primeros envíos del Arduino al ordenador.

En el Arduino Leonardo, la clase Serial se refiere a la comunicación USB CDC, para la comunicación por TTL en los pines 0 y 1, se debe usar la clase Serial1.

En los Arduino basados en Atmega32u4 como el Arduino Leonardo usar:

void setup() { 
 //Initialize serial and wait for port to open:
  Serial.begin(9600); 
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB
  }
} 

V_USB es una implementación software de un dispositivo USB para microcontroladores USB, haciendo posible construir hardware USB con casi cualquier MCU AVR, sin necesidad de un chip adicional. Se trata de un puerto USB software. Más información:

USART Arduino

La USART es el puerto serie de los microcontroladores que en el caso de Arduino están conectadas a los pines 0 y 1.

UART: http://es.wikipedia.org/wiki/Universal_Asynchronous_Receiver-Transmitter. Las funciones principales de la UART son de manejar las interrupciones de los dispositivos conectados al puerto serie y de convertir los datos en formato paralelo, transmitidos al bus de sistema, a datos en formato serie, para que puedan ser transmitidos a través de los puertos y viceversa.

Arduino se conecta a nuestro ordenador a través del puerto USB, pero el puerto USB se debe conectar al microcontrolador a través del puerto serie, por ello debemos entender cómo están relacionados el puerto USB y el puerto serie.

En un Arduino usamos el puerto USB para tres funciones: cargar nuestro programa ya compilado en la memoria flash, conectarnos al puerto Serie (UART) predefinido en cada Arduino para comunicarnos durante la ejecución del programa y adicionalmente alimentar a Arduino. Todo ello se puede hacer sin la necesidad del puerto USB, pero dada la facilidad de uso y que todos los ordenadores disponen de un puerto USB, nos facilita mucho hacer estas operaciones.

El puerto serie conectado al USB lo usamos como puerto de consola o puerto de debug.

La UART normalmente no genera o recibe directamente las señales externas entre los diferentes módulos del equipo. Usualmente se usan dispositivos de interfaz separados para convertir las señales de nivel lógico del UART hacia y desde los niveles de señalización externos, como puede ser RS232 o RS485. Una UART está normalmente en un circuito integrado usado para comunicaciones serie sobre un ordenador u otro dispositivo periférico.

Los microcontroladores como el ATmega328p tiene USART (Universal Syncronous Asyncronous Receiver Transmitter). Una USART puede trabajar igual que una UART, pero tiene la capacidad adicional de actuar como síncrona, esto significa que los datos van sincronizados con una señal de reloj. El reloj es recuperado desde los propios datos o enviado como como una señal externa. En ese caso no se usan los bits de start y stop, lo que permite una velocidad en baudios mayor al operar en modo síncrono porque la temporización de los bits tienen una cierta garantía y más bits pueden ser usados para datos en lugar de cabeceras.

Por el contrario la UART dispone de una señal de reloj interno y los datos en el bus pueden tener una temporización más irregular. Las UART requieren bits de start y stop y los datos asíncronos sólo se sincronizan con los bits de start y stop. La palabra asíncrono indica que la UART recupera la temporización de los caracteres desde el flujo de datos, usando el bit de start y el de stop para indicar el marco de cada carácter.

En la transmisión síncrona, la señal de reloj es recuperada de forma separada del stream de datos, esto mejora la eficiencia de la transmisión al haber más bits de datos en la transmisión. Una conexión asíncrona no manda nada cuando el dispositivo que transmite no tiene nada que mandar, pero un interfaz síncrono debe mandar caracteres para mantener el sincronismo entre emisor y receptor, normalmente el carácter ASCII “SYN” se encarga de rellenar este hueco y esto puede ser hecho automáticamente por el dispositivo transmisor.

Diferencia entre UART y USART:

Para saber todo sobre la USART de Arduino y la comunicación serie ver:

La configuración de la UART de los microcontroladores AVR necesita acceder a unos registros:

  • USART Band Rate Register – UBRRH &UBRRL
  • USART Control and Status Register A – UCSRA
  • USART Control and Status Register B – UCSRB
  • USART Control and Status Register C – UCSRC
  • USART Data Buffer Register – UDA

UART es un módulo de hardware que traduce los datos de paralelo a serial para ser transmitidos, las UARTs son usadas comúnmente en conjunto con estándares de comunicación como EIA, RS-232, RS-422 o RS-485. la designación “universal” indica que el formato de los datos y las velocidades de transmisión pueden ser configuradas.

UART es normalmente un circuito integrado individual usado para comunicaciones de un sistema de cómputo, son normalmente incluidas en microcontroladores. Actualmente estos circuitos pueden comunicarse de manera sincrónica y asincrónica y son conocidos como USART. Las funciones principales de chip UART son: manejar las interrupciones de los dispositivos conectados al puerto serie y convertir los datos en formato paralelo, transmitidos al bus de sistema, a datos en formato serie, para que puedan ser transmitidos a través de los puertos y viceversa.

La USART de Arduino es un puerto de comunicaciones muy versátil (UNIVERSAL SYNCHRONUS and ASYNCHRONUS serial RECEIVER and TRANSMITTER). Se puede configurar como síncrono o como asíncrono. Los pines de conexión de la placa UNO que se utilizan con este periférico interno son los siguientes:

  • PIN 0 (RXD)   – Puerto D del microcontrolador  PD0
  • PIN 1 (TXD)   – Puerto D del microcontrolador  PD1
  • PIN 13 (SCK) – Puerto B del microcontrolador  PB15 (Sólo para el modo síncrono)

Para poder realizar la comunicación, los dispositivos que se vayan a comunicar deben conocer varios aspectos de ésta. El primero es la velocidad a la que se va a realizar, es decir a qué baudios se va a realizar la transmisión.

La comunicación comienza con una señal de Start, seguida de los bits a enviar, y se pueden seleccionar entre 5 y 9 bits a mandar, después tenemos que seleccionar si va a haber un bit de paridad para comprobar errores y por último si tenemos uno o dos bits de Stop. Estos parámetros han de estar configurados de igual manera en los dos dispositivos que se van a comunicar.

En la placa UNO se utiliza la USART para que el Atmega328  se comunique con el otro microcontrolador ATmega16U2 que hace la interface al puerto USB. Los leds (TX LED y RX LED) parpadean para indicar actividad en el puerto serie a través de la USART.

El baudio es una unidad de medida utilizada en telecomunicaciones, que representa el número de símbolos por segundo en un medio de transmisión digital. Cada símbolo puede codificar 1 o más bits dependiendo del esquema de modulación, un bit siempre representa dos estados, por lo tanto baudios por segundo no siempre es equivalente a bits por segundo, los símbolos son las unidades de información estas se representan en bits, de manera que la tasa de bits será igual a la tasa de baudios sólo cuando sea 1 bit por símbolo.

Principales características del módulo USART, para mayor información ver datasheet del microcontrolador.

  • Full Duplex Operation (Independent Serial Receive and Transmit Registers)
  • Asynchronous or Synchronous Operation
  • Master or Slave Clocked Synchronous Operation
  • High Resolution Baud Rate Generator
  • Supports Serial Frames with 5, 6, 7, 8, or 9 Data bits and 1 or 2 Stop Bits.

Antes de continuar es importante resaltar que AVR UART y USART son totalmente compatibles en términos de registros, generación de tasa de baudios, operaciones de buffer y funcionalidad de buffer en el transmisor/receptor. A continuación un resumen rápido de la configuración del módulo UART.

  1. Establecer la velocidad de transmisión en emisor y receptor debe ser la misma para poder realizar la comunicación.
  2. Establecer el número de bits de datos que deben ser enviados.
  3. Mantener el buffer listo, si es una transmisión cargarlo con el dato a transmitir, si es una recepción almacenar el dato recibido para poder recibir mas datos sin perder información
  4. Por último habilitar el transmisor/receptor de acuerdo con el uso que se le desee dar.

En el caso de la transmisión sincrónica (USART) es necesario enviar el reloj del sistema el microcontrolador que envía esta señal se llama Maestro y el otro se denomina esclavo; para transmisión Asíncrona no se hace esta denominación para los transmisores/receptores.

La tasa de baudios se establece en el registro de 16 bits UBRR:

Más información: http://sistdig.wikidot.com/wiki:usart  

Más información sobre la USART del MCU ATmega328p, ver página 170 de http://www.atmel.com/images/Atmel-8271-8-bit-AVR-Microcontroller-ATmega48A-48PA-88A-88PA-168A-168PA-328-328P_datasheet_Complete.pdf

Estándares de comunicación serie que definen las características eléctricas de los drivers y los receptores:

Explicación de la diferencia entre comunicación RS232 y TTL: RS-232 vs. TTL Serial Communication y http://www.atmel.com/Images/doc4322.pdf

USB to Serial en Arduino

Cuando conectamos Arduino a un ordenador mediante un cable USB, el ordenador instala un puerto serie virtual (COM) desde el cual podemos acceder al puerto serie de Arduino. Por este motivo es necesario instalar en el ordenador los drivers de interfaz USB de los microcontroladores de Atmel, esto se hace automáticamente al instalar el IDE de Arduino.

Arduino UNO como otros Arduinos disponen de microcontroladores que no tienen un interfaz USB incorporado, por lo tanto no se pueden conectar directamente a un Ordenador. Para ello usan un segundo microcontrolador que hace de intermediario, generalmente un ATmega16u2 que dispone de un interfaz USB. Este microcontrolador dispone de un firmware especial que facilita la carga del programa en la flash del Arduino y comunicar posteriormente por el USB.

Este firmware y su código se puede ver en https://github.com/arduino/Arduino/tree/master/hardware/arduino/avr/firmwares/atmegaxxu2/arduino-usbserial

Los microcontroladores de 8 bits mega AVR con interfaz USB están configurados de fábrica con un bootloader USB, este permite hacer un In-System Programming desde el interfaz USB sin eliminar la parte del sistema o sin una aplicación preprogramada y sin un un interfaz externo de programación.

USB DFU (Device Firmware Update) Bootloader: http://www.atmel.com/Images/doc7618.pdf

Más información del microcontrolador en: http://www.atmel.com/Images/Atmel-7766-8-bit-AVR-ATmega16U4-32U4_Datasheet.pdf

Niveles lógicos

Los niveles lógicos de los microcontroladores, son los niveles físicos de voltaje por los que se interpreta un microcontrolador un 1 y un 0. Niveles lógicos: https://en.wikipedia.org/wiki/Logic_level

En el caso de los ATmega AVR usan Tecnología TTL: http://es.wikipedia.org/wiki/Tecnolog%C3%ADa_TTL. Su tensión de alimentación característica se halla comprendida entre los 4,75V y los 5,25V (como se ve, un rango muy estrecho). Normalmente TTL trabaja con 5V. Los niveles lógicos vienen definidos por el rango de tensión comprendida entre 0,0V y 0,8V para el estado L (bajo) y los 2,2V y Vcc para el estado H (alto). La velocidad de transmisión entre los estados lógicos es su mejor base, si bien esta característica le hace aumentar su consumo siendo su mayor enemigo. Motivo por el cual han aparecido diferentes versiones de TTL como FAST, LS, S, etc y últimamente los CMOS: HC, HCT y HCTLS. En algunos casos puede alcanzar poco más de los 400 MHz.

TTL logic levels: https://learn.sparkfun.com/tutorials/logic-levels/ttl-logic-levels

Interesante nota de TI sobre como elegir la solución más adecuada para la conversión de niveles lógicos.

Niveles lógicos de Arduino: https://learn.sparkfun.com/tutorials/logic-levels/arduino-logic-levels

A medida que la tecnología avanza se crean dispositivos que necesitan menor consumo eléctrico y usan un menor voltaje de base (Vcc = 3.3 V en lugar de 5V). La técnica de fabricación es también diferente para dispositivos de 3.3V que permiten una huella menor y costes más pequeños. Para asegurar la compatibilidad de los dispositivos a 3.3V, se puede ver que la mayoría de los niveles de voltaje son casi los mismos para dispositivos de 3.3V y los de 5V. Un dispositivo de 3.3V puede interactuar con uno de 5V sin componentes adicionales. Por ejemplo un 1 lógico (HIGH) de un dispositivo de 3.3V será al menos 2.4V, esto sigue siendo interpretado como un 1 lógico en un dispositivo de 5V porque está por encima  de VIH que es 2V.

Sin embargo hay que tener en cuenta que un dispositivo de 3.3V es tolerante a señales de 5V, esta especificación es el “maximum input voltage” del dispositivo. En ciertos dispositivos de 3.3V, cualquier voltaje supuerior a 3.6V provocará un daño permanente en el chip, para evitar esto se puede usar un simple divisor de tensión (https://learn.sparkfun.com/tutorials/voltage-dividers) como una resistencia de 1KΩ y una de 2KΩ para bajar los 5V o usar un logic level shifter como https://www.sparkfun.com/products/12009

Voltaje 5V vs 3.3V http://jeelabs.org/2010/12/16/voltage-3-3-vs-5/

Cable FTDI

Cable FTDI es la forma más fácil de conectar el microcontrolador a un ordenador por USB. Consiste en un chip de conversión USB a Serie. Como ocurre con Arduino cuando lo conectamos, necesitamos los drivers de windows, cuando conectamos un cable FTDI también necesita sus drivers. Los driver FTDI vienen integrados en el IDE de Arduino.

FTDI es el fabricante más popular de chips conversores de USB a serie.

Drivers: https://web.archive.org/web/20141005060035/http://www.ftdichip.com/Drivers/VCP.htm

Productos de FTDI:

Chip FTDI:

FT231X tiene un buffer de comunicación mayor comparado con el FT232R. El FT231X tiene los niveles lógicos de 3.3 V y con entradas tolerantes a 5V. FTDI provee de drivers para los dispositivos USB incluyendo driver certificados para Windows, incluido Windows 10.

Interesante artículo sobre la comunicación serie con MCUs AVR: http://www.evilmadscientist.com/2009/basics-serial-communication-with-avr-microcontrollers/

Cable par comunicar con dispositivos de 3.3V: https://www.sparkfun.com/products/9873

Al comprar un cable FTDI hay que estar atento al pineado que no es el que usan los Arduino Ethernet y otros elementos, es posible que para conectarlo a un Arduino haya que intercambiar algunos pines. Este es el pineado correcto y los colores de los cables para un FTDI para Arduino:

ftdi

Existen en el mercado cable con otros colores y el pineado desordenado. Estos son los colores del cable y a que corresponde:

  • Red wire: 5V
  • Black wire: GND
  • White wire: RXD
  • Green wire: TXD
  • Yellow wire: RTS
  • Blue wire: CTS

Y el pineado bueno para arduino queda así:

ftdi luis

Los pines CTS y RTS es el flow control (control de flujo). El pin RTS es una salida y debe conectarse al pin de entrada CTS del otro dispositivo de la conexión a la UART.

  • Si el pin RTS está a 0, indica que puede aceptar más datos en el pin RXD
  • Si el pin RTS está a 1, indica que no puede aceptar más datos.

Los cambios de estado del pin RTS ocurren cuando el buffer del chip alcanza los últimos 32 bytes de espacio para dejar tiempo al dispositivo externo para que pare el envío de datos.

El pin CTS es una entrada y debe ser conectado a la salida RTS del dispositivo al otro extremo.

  • Si el pin CTS está a 0, indica que el dispositivo externo puede aceptar más datos y transmitirá por el pin TXD.
  • Si el pin CTS está a 1, indica que el dispositivo externo no puede aceptar más datos y parará la transmisión de datos en los siguientes 0 – 3 caracteres, dependiendo de lo que haya en el buffer de salida. Se debe tener en cuenta que al ser un dispositivo USB opera en base a paquetes y no a bytes.

CTS y RTS en RS232: https://en.wikipedia.org/wiki/RS-232#RTS.2C_CTS.2C_and_RTR

También en algunos dispositivos serie nos podemos encontrar con el pin DTR que es el control de flujo https://en.wikipedia.org/wiki/Data_Terminal_Ready. El DTR permite a Arduino hacer el auto reset cuando un nuevo sketch es cargado a la memoria flash. Esto permite cargar un sketch sin tener que pulsar el botón de reset.

Una de las líneas del hardware flow control (DTR) del ATmega8U2/16U2, están conectadas a la línea de reset del MCU ATmega328P a través de un condensador de 100 nanofaradios. Cuando esta línea se pone a 0 V, es capaz de resetear el MCU de Arduino. El IDE de Arduino usa esta capacidad para permitir cargar código a Arduino simplemente presionando el botón upload y hace que el el timeout del bootloader pueda ser menor y estar mejor coordinado con el comienzo de la carga del sketch.

Cuando se detecta un flujo de datos a través del interfaz USB conectando un ordenador al Arduino, automáticamente se resetea la MCU de Arduino y durante el siguiente medio segundo, el bootloader se ejecuta en Arduino. Como el bootloader está programado para ignorar datos malformados (cualquier cosa que no sea nuevo código de un sketch), interceptará los primeros bytes de los datos enviados a la placa tras la conexión. Por este motivo si un sketch está programado para recibir una comunicación por el puerto serie tras iniciarse, hay que asegurarse que el software que manda esa información espera al menos un segundo después de que se abra la conexión hasta que se manden los primeros datos.

Ojo con los chips FTDI falsos: http://hackaday.com/2016/02/01/ftdi-drivers-break-fake-chips-again/

Diferencia entre programadores AVR o adaptadores FTDI:

  • Los programadores AVR son más poderosos puesto que permite programar cualquier AVR, incluso los que vienen son bootloader de fábrica, pero también significa que es posible brickear el chip. Usando un programador se debe tener en cuenta que se sobreescribirá el bootloader.
  • Los adaptadores FTDI pueden enviar cualquier dato por puerto serie, incluyendo programar AVRs con un bootloader en ellos.

Más información de uso de un FTDI: https://cdn-learn.adafruit.com/downloads/pdf/ftdi-friend.pdf

Para las prácticas del curso disponemos de esta placa FTDI para programar tanto dispositivos a 5v como a 3.3 (los que habitualmente hay dispobles suelen ser a 5V), con selector de voltaje: http://www.tinyosshop.com/index.php?route=product/product&product_id=600, además este tiene DTR para conectar al reset y poder programar un arduino.

El FTDI usado usa el chip FT232 con características:

  • Interfaz estándar compatible con el tipo de controlador oficial de Arduino
  • Chipset FT232 original, funcionamiento estable, indicador de transmisión y recepción.
  • opción de fuente de alimentación 5V/3.3V
  • Chip de FT232R es la solución de un solo chip, con oscilador de cristal

FT232R tiene algunas funciones útiles:

Los microcontroladores AVR de Arduino para programarlos directamente por puerto serie, van a 5V, aunque si se usa un programador de 3.3v funciona porque el rx de arduino toma 0 cuando el voltaje es inferior a 0.7V y 1 cuando es superior a 2,4V.

Tal y como indica en las características del Arduino UNO en https://www.arduino.cc/en/main/arduinoBoardUno: “The Uno has a number of facilities for communicating with a computer, another Uno board, or other microcontrollers. The ATmega328 provides UART TTL (5V) serial communication, which is available on digital pins 0 (RX) and 1 (TX).”

Pero no solo se puede programar Arduino mediante el USB o por el puerto ICSP, sino que también es posible hacerlo mediante un cable FTDI conectado al puerto serie de Arduino. Para programar con el adaptador FTDI, necesitaré de un bootloader, con ICSP no.

Comunicación Serie Arduino

La comunicación serie es muy importante porque casi todos los protocolos utilizados actualmente son serie y además muchos dispositivos de comunicación inalámbrica usan la comunicación serie para hablar con Arduino como los módulos bluetooth y los módulos Xbee. También la comunicación serie es la que se usa generalmente para comunicar el Arduino con el Ordenador.

Para manejar el puerto serie en Arduino, disponemos de la librería Serial http://arduino.cc/en/Reference/Serial que hereda los métodos de la librería Stream https://www.arduino.cc/en/Reference/Stream

Todas las placas Arduino tienen al menos un puerto serie disponible en los pines digitales 0 (RX) y 1 (TX) compartido con el USB. El Arduino mega dispone de tres puertos adicionales Serial1 on pins 19 (RX) and 18 (TX), Serial2 on pins 17 (RX) and 16 (TX), Serial3 on pins 15 (RX) and 14 (TX). Estos pines no están conectados al interfaz USB del Arduino.

El Arduino Due tiene tres puertos adicionales y todos los puestos serie tienen niveles de 3.3V TTL.

Métodos más importantes de la librería Serial:

Resto de funciones disponible para usar con el puerto serie y ejemplos de uso pueden verse en: https://www.arduino.cc/en/Reference/Seria

Buffer Serial: los puertos serie de los microcontroladores tienen un buffer que se va llenando hasta que nosotros lo vamos leyendo con la función read() que lo vamos vaciando, es una pila FIFO. El tamaño del buffer serie en el Arduino Uno es de 64 bytes, cuando se llena ese buffer el resto de elementos recibidos se pierden.

Toda la información del puerto seríe del microcontrolador del arduino UNO la tenemos en la página 170 de http://www.atmel.com/images/Atmel-8271-8-bit-AVR-Microcontroller-ATmega48A-48PA-88A-88PA-168A-168PA-328-328P_datasheet_Complete.pdf

Software Serial

Cada microcontrolador tiene un número de puertos serie hardware (UART), pero se ha desarrollado la librería SoftwareSerial para permitir la comunicación serie sobre otros pines digitales de Arduino, usando software para replicar las funcionalidades de la comunicación serie. Es posible tener varios puertos software serial con velocidades de hasta 115200 bps.

Reference de la librería Software Serial, limitaciones y ejemplos en: http://arduino.cc/en/Reference/SoftwareSerial

Práctica: Puerto Serie

Hacer esta práctica de un chat por el puerto serie entre dos ordenadores usando dos Arduinos: https://aprendiendoarduino.wordpress.com/2016/07/02/chat-serie/

Práctica: Menú interactivo con Arduino.

Para unir todo lo visto en una práctica, hacer un ejemplo de un menú interactivo donde se dan varias opciones y pulsando cada una de ellas se ejecuta una acción concreta. Si el valor pulsado no es ninguna de las opciones avisar y volver a mostrar el menú hasta que se pulse una opción correcta.

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio46-Estructuras_de_Control

Modificar el programa para que haga la pregunta de forma continua.

Primer proyecto: “blink”

En lugar del clásico “hola mundo” que es el primer programa que se hace cuando se aprende un lenguaje de programación, en Arduino el equivalente es el proyecto blink.

El primer programa o sketch será hacer parpadear el led integrado que lleva Arduino u otro led conectado a un pin digital a través de una resistencia.

NOTA: en caso de usar un led, no olvidar poner una resistencia con un valor entre 220 ohms y 1K ohms

Este es el esquema a usar:

Conexiones internas de la protoboard son así:

Como usar una protoboard o breadboard: https://learn.sparkfun.com/tutorials/how-to-use-a-breadboard

Pasos a seguir:

  • Abrir la aplicación Arduino
  • Abrir el ejemplo blink

  • Leer el programar y entender lo que está haciendo
  • Seleccionar la placa y el puerto adecuado

  • Cargar el programa pulsando el botón “subir”. El programa se compila y luego se verá parpadeando los leds Tx y Rx de Arduino, indicando que se está cargando el fichero binario (.hex) en la flash del Arduino. Cuando aparezca el mensaje “subido” habremos acabado.
  • Unos segundos después veremos el LED parpadeando.

Una explicación completa del proyecto y enlaces a las funciones usadas está en: http://arduino.cc/en/Tutorial/Blink

Probar a cambiar el valor de delay para hacer parpadear el led más rápido o más lento.

Práctica: Mejora blink con impresión en consola

Modificar el programa para que cada vez que encienda y apague imprima por el puerto serie la cadena “encendido”, “apagado” cuando corresponda. Luego guardarlo en nuestro entorno de trabajo.

Será necesario usar la librería Serial: http://arduino.cc/en/Reference/Serial

NOTA: Cuando programamos en cualquier lenguaje sobre un ordenador, para interaccionar con el programa usamos el standard input que generalmente es el teclado y el programa muestra los resultados por el standard output que en general es la pantalla. En Arduino esto no es así, sino que para interaccionar con el programa creado se hace a través de la comunicación del puerto serie entre arduino y el ordenador mediante el cable USB que hemos conectado. En este caso la salida del programa manda una cadena de texto por el puerto serie que podemos leer gracias al monitor serie.

Solución:  El código de la solución se encuentra en: https://github.com/jecrespo/Aprendiendo-Arduino/blob/master/Ejercicio01-Blink/Ejercicio01-Blink.ino

Práctica: Arduino Serial Plotter

Desde la versión 1.6.6 del IDE de Arduino disponemos de la herramienta Arduino Serial Plotter que hace la gráfica de los datos mandados por puerto serie.

Hacer la gráfica con Arduino Serial Plotter de la función y=x*x y otra con la lectura de una entrada analógica y ver la gráfica en el Serial Plotter.

Ver código en https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio45-Serial_Plotter

Práctica: Digital Read Serial

Monitorizar el estado de un botón (pulsado/no pulsado) con Arduino y mostrarlo por el monitor serie.

Revisar el código del programa DigitalReadSerial de los ejemplos en Basis. Cargar y ejecutar en Arduino.

Esquema de conexión:

Explicación completa de la práctica: http://arduino.cc/en/Tutorial/DigitalReadSerial

¿Que valores lee si dejo al aire la entrada digital 2?

Más prácticas

El IDE de Arduino trae muchos ejemplos que podemos ver y probar: https://www.arduino.cc/en/Tutorial/BuiltInExamples

Las 10 primeras cosas que debes hacer con tu arduino: http://antipastohw.blogspot.com.es/2009/12/first-10-things-everyone-does-with.html

Primer programa/sketch de Arduino

En lugar del clásico “hola mundo” que es el primer programa cuando se aprende un lenguaje de programación, en Arduino el equivalente es el sketch blink.

Nuestro primer programa será hacer parpadear el led integrado que lleva Arduino (built-in led).

Este es el esquema a usar, pero el led marcado como L está también conectado al pin 13 (en el caso del Arduino UNO) y no es necesario poner un led adicional.:

Pasos a seguir:

  • Abrir la aplicación Arduino
  • Abrir el ejemplo blink

blink

  • Seleccionar la placa y el puerto adecuado

blink2

  • Cargar el programa pulsando el botón “subir”. El programa se compilará y luego se verá parpadeando los leds Tx y Rx de Arduino, indicando que se está cargando el fichero binario (.hex) en la flash del Arduino. Cuando aparezca el mensaje “subido” habremos acabado.
  • Unos segundos después veremos el LED parpadeando.

Una explicación completa del proyecto y enlaces a las funciones usadas está en: http://arduino.cc/en/Tutorial/Blink

Constantes definidas en el IDE Arduino: https://www.arduino.cc/en/Reference/Constants

Demos un paso más y modifiquemos el sketch para que parpadee más rápido y más lento. Modificar el valor de delay y volver a compilar y subir a Arduino.

Vamos a ampliarlo y modificar el programa para que cada vez que encienda y apague saque por el puerto serie la cadena “encendido”, “apagado” cuando corresponda. Luego guardarlo en nuestro entorno de trabajo.

Será necesario usar la librería Serial: http://arduino.cc/en/Reference/Serial

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/blob/master/Ejercicio01-Blink/Ejercicio01-Blink.ino

El IDE trae muchos ejemplos que podemos ver y probar: https://www.arduino.cc/en/Tutorial/BuiltInExamples

Instalación del IDE Arduino

Descargar la última versión del IDE de Arduino desde: http://arduino.cc/en/Main/Software

Elegir la opción de Windows Installer, aunque también es posible descargar la versión comprimida en zip y se puede decir que es una versión portable o para aquellos que no tengan privilegios suficientes para instalar aplicaciones o simplemente se quiera hacer una instalación manual.

Para actualizar una versión anterior del IDE de Arduino, el procedimiento es el mismo que el de una instalación inicial, puesto que el instalador detecta una versión anterior y la desinstala manteniendo todas nuestras configuraciones, librerías y sketches anteriores.

En caso que queramos mantener varias versiones del IDE en el mismo ordenador, simplemente hacemos la instalación manual en directorios diferentes y las configuraciones, librerías y sketches son compartidas por las diferentes versiones del IDE instaladas.

Ejecutar el instalador descargado. Si existe una versión anterior el instalador nos avisa y nos desinstala. En el caso que hayamos hecho modificaciones en el directorio de instalación las perderemos.

2016-03-19

2016-03-19 (1)
Durante la instalación aceptamos el acuerdo de licencia.

2016-03-19 (2)
Marcar todas las opciones y elegir directorio de instalación, generalmente C:\Program Files (x86)\Arduino\:

instalacion1

Permitir instalar los drivers (si lo solicita):

instalacion2

instalacion3

Y ya está instalado:

instalacion4

En este momento ya tenemos instalado el IDE en nuestro ordenador. Con las nuevas versiones del IDE de Arduino no es necesario instalar los drivers en Windows al venir integrados en el IDE y estos tienen las firmas correspondientes.

Ejecutar la aplicación:

2016-03-19 (4)
Y este es el aspecto del IDE:

2016-03-19 (6)

El IDE de Arduino es multiplataforma y en caso de instalar el IDE Arduino en otros sistemas operativos estas son las instrucciones:

Conozcamos este nuevo entorno de trabajo:

instalacion6

Para conocer el entorno de programación a fondo ver: http://arduino.cc/en/Guide/Environment

Revisar cada uno de los menús y opciones que tiene, los más importantes ahora son.

  • Botones de Verificar y Subir
  • Botón Monitor Serie
  • Consola de Error
  • Menú herramientas Placa y Puerto
  • Menú de pestañas
  • Puerto y placa seleccionada
  • Menú preferencias
  • Proyecto/Sketch
  • Resaltado de palabras clave

Monitor serie

El monitor serie muestra los datos enviados por el Arduino a través del puerto serie también nos permite mandar datos al Arduino mediante el puerto serie.

instalacion7

Hay disponibles alternativas al monitor serie que en algunas circunstancias podemos necesitar puesto que el incluido en el IDE de Arduino es bastante sencillo.

Una buena alternativa muy completa es el bray’s terminal: https://sites.google.com/site/terminalbpp/

Otras alternativas al monitor serie: https://www.baldengineer.com/alternatives-to-arduinos-serial-monitor.html

Editor de Texto

El IDE de Arduino contiene un editor de texto para escribir nuestro sketch, una consola de error y un área con los menús y los botones que realizan las funciones más comunes.

El IDE también nos permite cargar en Arduino el programa ya compilado. Cuando cargamos un programa en Arduino, estamos usando el bootloader de Arduino, que es un pequeño programa cargado en el microcontrolador que permite subir el código sin usar hardware adicional. El bootloader está activo unos segundos cuando se resetea la placa, después comienza el programa que tenga cargado el Arduino en su memoria Flash. El led integrado en la placa (pin 13 en muchas placas) parpadea cuando el bootloader se ejecuta.

Las novedades de la nueva versión 1.6 del IDE:

  • Soporte multiplataforma de arduino
  • Detección automática de la placa conectada
  • Muestra memoria Flash y SRAM ocupada por un sketch o proyecto
  • Autoguardado al compilar y cargar sketch
  • Carga de sketch vía red (wifi o ethernet) para Arduino Yun.

Antes de empezar, lo primero es configurar el IDE para facilitar la edición de nuestros programas, que nos muestre toda la información de compilación y subida de programas a Arduino y que nos muestre por pantalla todos los warnings del compilador. Cuanta más información tengamos, más fácil será localizar un problema.

Para ello entrar en el menú de preferencias y activar:

  • Números de Línea
  • Mostrar salida detallada en la compilación y al subir un sketch
  • Configurar la ruta de nuestro workspace
  • Advertencia del compilador: Todos
  • Asociar extensión .ino a nuestro IDE
  • Habilitar plegado de código
  • Verificar el código después de subir

2016-03-19 (7)

Desde esta pantalla configuramos donde se guardan las preferencias, sketches y librerías, de forma que al instalar una actualización mantenemos todos los datos o si instalamos varios IDEs van a compartir estos datos.

  • Las preferencias se guardan en el directorio: C:\Users\nombre_usuario\AppData\Local\Arduino15\, así como el listado de librerías y placas disponibles desde el gestor de librerías y tarjetas.
  • Los sketches y librerías se guardan en C:\Users\nombre_usuario\Documentos\Arduino

El gestor de tarjetas disponible desde el menú herramientas → Placa → Gestor de tarjetas, nos muestra el soporte a qué tipo de placas Arduino tenemos y nos permite instalar el soporte para otro tipo de placas. Estas placas se refieren a la familia de tarjetas no a los modelos de Arduino soportados, para añadir otras placas de a misma familia se debe configurar desde otro fichero.

Por defecto tenemos instalado el soporte a las placas Arduino AVR que son la mayoría, pero desde este gestor podemos instalar el soporte para los Arduino con MCU ARM de 32 bits o las Intel como el Arduino 101.

2016-03-19 (9)

En este enlace explica como instalar nuevos cores: https://www.arduino.cc/en/Guide/Cores

Cuando tengamos algún problema, la primera opción es recurrir a la guía de Troubleshooting: http://arduino.cc/en/Guide/Troubleshooting

Instalación y configuración IDE arduino.org

Como ya se ha comentado anteriormente (Ver https://aprendiendoarduino.wordpress.com/2016/03/19/arduino-cc-y-arduino-org-los-dos-arduinos/), Arduino se dividió a principios de 2015 en dos compañías y el resultado además de dos páginas web: www.arduino.cc y www.arduino.org, tenemos dos IDEs.

Hemos visto el IDE original de arduino, pero el IDE de arduino.org se trata de un fork del IDE de arduino.cc que a su vez deriva de Wiring: http://wiring.org.co/. Este IDE de arduino.org no dispone de la gestión mejorada de librerías y placas.

Todos los cambios de las versiones se pueden ver en: http://labs.arduino.org/Arduino+IDE+Previous+Releases

Guía de inicio: http://labs.arduino.org/First+steps+with+Arduino+IDE+1.7.x+for+Windows

Código fuente: https://github.com/arduino-org/Arduino

Descargar la última versión del IDE de Arduino.org de http://www.arduino.org/software disponemos de una version con instalador y otra con instalación manual desde un zip.

IMPORTANTE: la versión del IDE de arduino.org es la 1.7.8, puede llevar a error y pensar que es una versión superior al IDE de arduino.cc que va por la version 1.6.8, pero no es cierto, se trata de un IDE difrente, es más, el IDE de arduino.org está menos evolucionado que el IDE de arduino.cc. Ver Issue: https://github.com/arduino-org/Arduino/issues/2

Como ya tenemos instalado el IDE de arduino.cc el instalador del IDE de arduino.org trata de desinstalarlo como si fuera una versión anterior, cuando realmente es un IDE diferente. Por este motivo es mejor hacer una instalación manual del IDE de arduino.org.

2016-03-19 (10)

Para proceder a la instalación manual, descargar la el fichero zip (for non-administrator install) y descomprimir el contenido por ejemplo en la ruta C:\Program Files (x86)\Arduino.org

Ejecutar arduino.exe y tenemos el IDE de arduino.org que su funcionamiento es similar al de arduino.cc pero carece los gestores de librerías y de tarjetas, también vemos que la tarjetas soportadas son algo difrentes al de arduino.cc.

La imagen al ejecutar el IDE es algo diferente pareciendose a la versión anterior del IDE de arduino.cc

2016-03-19 (11)

2016-03-19 (13)

Ambos IDEs son actualmente muy similares a simple vista, pero en el interior hay varias diferencias.

2016-03-19 (17)

La pantalla de preferencias es diferente:

2016-03-19 (14)

Desde esta pantalla configuramos donde se guardan las preferencias, sketches y librerías.

  • Las preferencias se guardan en: C:\Users\nombre_usuario\AppData\Roaming\Arduino15\preferences.txt, cuya ruta es diferente al IDE de arduino.cc y por lo tanto no comparten preferencias.
  • Los sketches y librerías se guardan en C:\Users\nombre_usuario\Documentos\Arduino, que lo comparte con el IDE de arduino.cc por lo que disponemos de los mismo sketches y librerías en ambos IDEs, pero podemos cambiar esta configuración para separar ambos IDEs.

Una consecuencia de esta división de los IDEs es que las placas de arduino.org pueden no funcionar en el IDE original de arduino.cc ni al reves. Pero si solo queremos usar un IDE o nos gusta uno más que otro, siempre se pueden hacer pequeñas configuraciones para poder usar las placas de un arduino en el IDE del otro arduino.

El listado de placas soportadas por cada IDE difiere un poco:

 

Placas IDE arduino.cc Placas IDE arduino.org
 2016-03-19 (20)

2016-03-19 (21)

 2016-03-19 (19)

Lo más probable es que haya problemas con los Arduinos nuevos que vayan saliendo que con los arduinos antiguos que tendrán soporte en ambos IDEs.

Es posible que cada uno de los IDEs de arduino.cc y arduino.org tengan versiones diferentes de las librerías que tienen incluidas, esto nos puede trear problemas al usar un sketch en un IDE o en otro.

También es posible que nos aparezcan avisos de placas no certificadas al usar un IDE diferente del fabricante de la placa como el que se añadió en: https://github.com/arduino/Arduino/commit/39d1dfc9995e75e858fa238c7c8881ee2d7679c6

Esto se debe a que arduino.cc y arduino.org tienen su propio identificador de USB (vendor ID) y lo detectan los IDEs. Esto también puede pasar con falsificaciones o clones de placas arduino. El vendor ID para arduino.cc es 0x2341 y por ejemplo para el Arduno UNO el product ID es 0x0001. El vendor ID para arduino.org es 0x2A03 que pertenece a Dog Hunter AG.

Entorno de Programación de Arduino (IDE)

IDE – entorno de desarrollo integrado, llamado IDE (sigla en inglés de integrated development environment), es un programa informático compuesto por un conjunto de herramientas de programación. Puede dedicarse en exclusiva a un solo lenguaje de programación o bien puede utilizarse para varios.

Un IDE es un entorno de programación que ha sido empaquetado como un programa de aplicación, es decir, que consiste en un editor de código, un compilador, un depurador y un constructor de interfaz gráfica (GUI). Además en el caso de Arduino incorpora las herramientas para cargar el programa ya compilado en la memoria flash del hardware a través del puerto serie.

Los programas de arduino están compuestos por un solo fichero con extensión “ino”, aunque es posible organizarlo en varios ficheros. El fichero principal siempre debe estar en una carpeta con el mismo nombre que el fichero.

Anteriormente a la versión 1.x de Arduino se usaba la extensión “pde”. Cuando se pasó a la versión 1.x hubo grandes cambios, que deben tenerse en cuenta si se usa código antiguo.

La última versión del IDE de Arduino es la 1.6.8. Los grandes cambio del IDE Arduino se produjo en el cambio de la versión 0.22 a la 1.0 y posteriormente en el cambio de la versión 1.0.6 a la 1.6.0 con grandes mejoras en el IDE de Arduino.

El el caso de la versión 1.6.0 los cambios han sido principalmente internos más que en el aspecto de la herramienta. También es destacable desde la aparición de la versión 1.6.2 la incorporación de la gestión de librerías y la gestión de placas, muy mejoradas respecto a la versiones anteriores y avisos de actualización de versiones de librerías y cores.

Todos lo cambios en la versiones pueden verse en: https://www.arduino.cc/en/Main/ReleaseNotes

Una guía de como migrar de versiones anteriores a la 1.0: http://www.engblaze.com/changes-in-the-arduino-1-0-release/

El IDE de Arduino va a ser nuestra herramienta de trabajo a partir de este momento.

Código fuente del IDE de Arduino está disponible en: https://github.com/arduino/Arduino/  y las instrucciones para construir el IDE desde código fuente pueden verse en: https://github.com/arduino/Arduino/wiki/Building-Arduino

Podemos ver los problemas detectados de la version actual y hacer un seguimiento de ellos: https://github.com/arduino/Arduino/issues y en http://forum.arduino.cc/index.php?board=2.0
Con la división de Arduino, no solo se ha producido una división en las placas sino también en los IDEs. Más información en: https://aprendiendoarduino.wordpress.com/2016/03/19/arduino-cc-y-arduino-org-los-dos-arduinos/

1_architecture

Firmata

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.

  1. Descargar el programa “Firmata Test Program” para sistema operativo correspondiente de http://www.pjrc.com/teensy/firmata_test/
  2. Cargar el sketch “StandardFirmata” en Arduino: Archivo -> Ejemplos -> Firmata -> StandardFirmata.
  3. Probar que funciona encendiendo Leds y leyendo valores de los pines analógicos y digitales.

Firmata_Test

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:

  1. Cargar en Arduino el sketch del ejercicio38 Entendiendo_Firmata: https://github.com/jecrespo/Aprendiendo-Arduino/blob/master/Ejercicio38-Firmata/Entendiendo_Firmata/Entendiendo_Firmata.ino
  2. Entender que hacer este sketch
  3. Abrir el programa de Terminal y configurarlo con:
    1. Baud rate = 57600
    2. Receive en HEX
    3. Habilitar las pantallas Dec, Hex y Bin
  4. Ejecutar el programa y capturar lo que envía Arduino en Hexadecimal.

Terminal_Firmata

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.

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:

1_architecture

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:

  1. Descargar Python para el sistema operativo correspondiente: https://www.python.org/downloads/
  2. Instalar Python: https://docs.python.org/3/using/windows.html
  3. Instalar dependiencias python: http://code.rancidbacon.com/LearningAboutArduinoandPython

Preparar Arduino:

  1. Cargar el sketch StandardFirmata en Arduino.

Ejecutar el programa desde el ordenador usando la librería PyMata:

  1. Ejecutar el ejemplo blink.py: https://github.com/jecrespo/Aprendiendo-Arduino/blob/master/Ejercicio38-Firmata/Python_Firmata/blink.py 
  2. 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:

arduino_con_fotoresistencia_ldr-510x322

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