Comunicación Serie Arduino

La comunicación serie es muy importante porque gran parte de 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 para comunicar el Arduino con el Ordenador a través del cable USB.

Para manejar el puerto serie en Arduino, debemos leer a fondo la referencia de Arduino:  http://arduino.cc/en/Reference/Serial que son las funciones que tenemos disponibles para trabajar con el puerto serie.

Todas las placas Arduino tienen al menos un puerto serie disponible en los pines digitales 0 (RX) y 1 (TX) compartido con el USB. Por lo tanto no es posible usar estos pines como entradas/salidas digitales.

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 pero con niveles de 3.3V TTL.

Comunicación serie:

La funciones más importantes que debemos conocer para manejar el puerto serie son: begin(), read(), write(), print() y available())

• begin() – establece la velocidad de la UART en baudios para la transmisión serie, también es posible configurar el número de bits de datos, la paridad y los bits de stop, por defecto es 8 bits de datos, sin paridad y un bit de stop. https://www.arduino.cc/en/Serial/Begin
• read() – lee el primer byte entrante del buffer serie. https://www.arduino.cc/en/Serial/Read
• write() – escribe datos en binario sobre el puerto serie. El dato es enviado como un byte o serie de bytes.
• print() – imprime datos al puerto serie como texto ASCII, también permite imprimir en otros formatos. https://www.arduino.cc/en/Serial/Print
• available() – da el número de bytes (caracteres) disponibles para leer en el puerto serie, son datos que han llegado y se almacenan en el buffer serie que tiene un tamaño de 64 bytes. https://www.arduino.cc/en/Serial/Available
• end() – deshabilita la comunicación serie permitiendo a los pines RX y TX ser usado como pines digitales. https://www.arduino.cc/en/Serial/End
• if(Serial) – especifica si el puerto serie está listo. https://www.arduino.cc/en/Serial/IfSerial
• find() – lee datos del buffer serie hasta encontrar el string buscado. https://www.arduino.cc/en/Serial/Find
• parseInt() – busca el siguiente entero válido en el stream de datos del puerto serie. https://www.arduino.cc/en/Serial/ParseInt
• readBytes() – lee datos del buffer serie y lo guarda en una variable buffer. https://www.arduino.cc/en/Serial/ReadBytes
• setTimeout() – configura el máximo de milisegundos de espera para la lectura del puerto serie. Por defecto es un segundo. https://www.arduino.cc/en/Serial/SetTimeout
• readBytesUntil() – lee caracteres del buffer serie y los guarda en un array de caracteres, la función termina si el carácter terminados es encontrado o la longitud determinada se a leído o ha alcanzado el timeout. https://www.arduino.cc/en/Serial/ReadBytesUntil
• serialEvent() – llamado cuando hay datos disponibles. https://www.arduino.cc/en/Reference/SerialEvent
• flush() – espera hasta la transmisión completa de los datos salientes. https://www.arduino.cc/en/Serial/Flush
• peek() – devuelve el siguiente carácter del buffer serie pero sin borrarlo de él. https://www.arduino.cc/en/Serial/Peek
• readString() – lee caracteres del buffer serie y los guarda en un string. La función termina cuando se produce un timeout. https://www.arduino.cc/en/Serial/ReadString

El código de la librería Serial se encuentra en el core del IDE de Arduino: https://github.com/arduino/Arduino/tree/master/hardware/arduino/avr/cores/arduino. Puede verse en el  código el tamaño del buffer de entrada y salida.

Otra técnica en lugar de usar las funciones “until” o similares, es almacenar en una variable String lo recibido como si fuera un buffer y luego analizarlo con las funciones de String.

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

En el playground de Arduino tenemos más explicaciones y ejemplos de como funcional el puerto serie en Arduino: http://playground.arduino.cc/ArduinoNotebookTraduccion/Serial

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

Para ampliar información:

• Explicación de comunicación serie: http://en.wikipedia.org/wiki/Serial_communication
• http://www.jmnlab.com/usart/usart.html
• http://www.arduinoos.com/2010/05/serial-comm-ports-for-ever-and-ever/
• http://www.oxgadgets.com/2011/07/arduino-serial-communication.html

Software Serial

¿Y si necesitas más puertos serie que los disponibles en un Arduino? 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.

Ver funciones, limitaciones y ejemplos de la librería software serial en: http://arduino.cc/en/Reference/SoftwareSerial

Ejemplo de comunicación serie para comunicar con un shield GSM y mandar SMSs, usando el hw serial sin usar librerías o el sw serial usando librerías: http://arduinoguruji.blogspot.com.es/p/blog-page.html

Terminal Serie

Una vez visto cómo manejar el puerto serie en Arduino, si queremos comunicarnos con Arduino a través del puerto serie desde un ordenador debemos usar un emulador de terminal, el propio IDE de Arduino trae uno, pero existen otros más completos.

Terminales serie:

• Una buena alternativa muy completa es el btaru terminal: https://sites.google.com/site/terminalbpp/
• Tera Term: https://ttssh2.osdn.jp/ y https://en.wikipedia.org/wiki/Tera_Term
• Real Term http://realterm.sourceforge.net/  y https://learn.sparkfun.com/tutorials/terminal-basics/real-term-windows
• Real term + roomba: http://www.robotappstore.com/Knowledge-Base/2-How-to-Use-a-RealTerm-Terminal/16.html
• KST para dibujar datos del puerto serie: https://kst-plot.kde.org/ y https://en.wikipedia.org/wiki/Kst_(software)

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

En MAC usando el terminal con la utilidad screen:

• https://software.intel.com/en-us/articles/getting-started-with-the-intel-galileo-board-on-mac#terminal
• https://software.intel.com/en-us/setting-up-serial-terminal-on-system-with-mac-os-x

ls /dev/tty.* (note the .*at the end) command to list all connected devices

screen /dev/xx.usbserial-XXXXXXXX 115200 –L