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 generalmente para comunicar el Arduino con el Ordenador.

Para manejar el puerto serie en Arduino, debemos leer a fondo la referencia de Arduino:  http://arduino.cc/en/Reference/Serial

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 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() – estable 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. Ver en el  código el tamaño del buffer de entrada y salida.

Otra técnica en lugar de usar estas funciones 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

Por ejemplo la función begin() de Serial, podemos ver  como se hace en C o en ensamblador en la página 175-176.

La función write() podemos verla en la página 176-177 y la función read() en la página 179-180.

Una descripción de los registros usados por el microcontrolador en la comunicación serie se pueden ver en la página 191.

NOTA: las funciones de serial que usamos valen para cualquier arduino soportado por el IDE que estamos usando, pero luego cada microcontrolador internamente usa unos registros y operaciones diferentes, por lo que si usamos las funciones a bajo nivel vistas, sólo funcionarán con Arduino UNO.

Entrar en temas más complejos como los vistos tiene dos objetivos, saber que tenemos toda la documentación disponible para entrar a fondo en el conocimiento del microcontrolador y sobre todo que todas esas funciones que usamos de una forma sencilla, detrás de ellas hay mucha más complejidad de la que pueda parecer. Arduino nos facilita un lenguaje de programación y unas funciones sencillas para manejar unas serie de microcontroladores diferentes.

Interesante artículo de la diferencia entre usar y no usar flush: https://www.baldengineer.com/when-do-you-use-the-arduinos-to-use-serial-flush.html

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 11520 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

Uso RS232 y RS485 en Arduino

Para usar RS232 con Arduino necesito un driver receptor para poder usarlo: http://arduino.cc/en/pmwiki.php?n=Tutorial/ArduinoSoftwareRS232. Lo mismo pasa con el RS485.

Para comunicar RS232 con Arduino:

• https://www.sparkfun.com/datasheets/Components/General/sp3222_3232e.pdf
• https://www.exar.com/connectivity/transceiver/rs232/sp213e/
• max232:http://www.ti.com/lit/ds/symlink/max232.pdf

Y también hay disponible un Shield para RS232: https://www.sparkfun.com/products/13029

Presentación RS232 y RS485: http://docencia.ac.upc.es/EPSC/SED/Apuntes/RS-232%20Y%20RS-485.ppt

Tutorial para comunicar por RS232 un arduino con un Ordenador: http://arduino.cc/en/Tutorial/ArduinoSoftwareRS232

RS485

RS-485 Es un estándar de comunicaciones en bus de la capa física del Modelo OSI. Está definido como un sistema de bus diferencial multipunto, es ideal para transmitir a altas velocidades sobre largas distancias (35 Mbit/s hasta 10 metros y 100 kbit/s en 1200 metros) y a través de canales ruidosos, ya que el par trenzado reduce los ruidos que se inducen en la línea de transmisión. El medio físico de transmisión es un par trenzado que admite 32, 128 o 254 estaciones en 1 solo par, con una longitud máxima de 1200 metros operando entre 300 y 19 200 bit/s y la comunicación half-duplex (semiduplex) dependiendo del consumo de cada driver. La transmisión diferencial permite alcanzar mayor distancia con una notable inmunidad al ruido, siempre que el bus de comunicación conserve las características de bus balanceado dando la posibilidad de una configuración multipunto.

Más información sobre RS485:

• https://es.wikipedia.org/wiki/RS-485
• https://en.wikipedia.org/wiki/RS-485
• http://www.lammertbies.nl/comm/info/RS-485.html
• Protocolo RS485: http://www.i-micro.com/pdf/articulos/rs-485.pdf
• Especificaciones RS485: http://www.rs485.com/rs485spec.html

Para usar RS485 sobre Arduino es necesario un transceiver que adapte los niveles de señal del RS485 como:

• MAX485:
  • https://www.maximintegrated.com/en/products/interface/transceivers/MAX485.html
  • datasheet: http://datasheets.maximintegrated.com/en/ds/MAX1487-MAX491.pdf
• SN75176BP:
  • datsheet: http://www.ti.com.cn/cn/lit/ds/symlink/sn75176b.pdf

Módulo RS485 para Arduino: https://arduino-info.wikispaces.com/RS485-Modules

Shields RS485 para Arduino:

• https://www.sparkfun.com/products/12965
• http://www.dfrobot.com/wiki/index.php/RS485_Shield
• http://store.linksprite.com/rs485-shield-for-arduino-v2-1/

Y puede usarse la librería: https://github.com/Protoneer/RS485-Arduino-Library

Modbus suele ir sobre RS485. Modbus un protocolo de comunicaciones situado en el nivel 7 del Modelo OSI, basado en la arquitectura maestro/esclavo (RTU) o cliente/servidor (TCP/IP), diseñado en 1979 por Modicon para su gama de controladores lógicos programables (PLCs). Convertido en un protocolo de comunicaciones estándar de facto en la industria, es el que goza de mayor disponibilidad para la conexión de dispositivos electrónicos industriales. Las razones por las cuales el uso de Modbus es superior a otros protocolos de comunicaciones es:

• Es público
• Su implementación es fácil y requiere poco desarrollo
• Maneja bloques de datos sin suponer restricciones

Por lo tanto al ser modbus con protocolo de capa 7, su implementación se deba hacer en el software de Arduino ya sea hecha por uno mismo o usando una librería como:

• ModbusMaster: https://github.com/4-20ma/ModbusMaster
• ModbusSlave: https://github.com/yaacov/ArduinoModbusSlave
• Modbus master – slave for Arduino: https://github.com/smarmengol/Modbus-Master-Slave-for-Arduino
• libmodbus: https://github.com/stephane/libmodbus

Tutorial de uso de módulo RS485 https://www.cooking-hacks.com/documentation/tutorials/rs-485-module-shield-tutorial-for-arduino-raspberry-pi-intel-galileo/   

Ejemplo de uso de comunicación serie RS485 con Arduino https://arduino-info.wikispaces.com/SoftwareSerialRS485Example

Ejemplo de uso de bus de campo sobre una red RS-485 (bus serie) para comunicar con una sonda HygroClip 2 (HC2) Probe with AirChip 3000: https://github.com/jecrespo/AirChip_3000

La sonda tiene un chip AirChip 3000:

• Tipo de interface  (por defecto) : UART (Receptor-Transmisor Asíncrono Universal)
• Organización : Diálogo, dúplex
• Configuración por defecto: Baud rate : 19200  
• Paridad: Ninguna
• bits de datos: 8
• bits de parada: 1
• Flow Control: none
• Tolerancia: 3 %
• Configuración de Baud rate: No
• Niveles lógicos Lógica 0: < = 0.3V * VDD
• Lógica 1: > = 0.8V * VDD
• Longitud máxima del cable: 5 m (Sin amplificador de señal)

Protocolo de HC2: ver pdf de HC2 y pdf de Hygroclyp en https://github.com/jecrespo/AirChip_3000/tree/master/Doc

Sondas on airchip 3000: http://www.rotronic.com/catalogsearch/result/?q=airchip+3000

Sonda utilizada: http://www.rotronic.com/hc2-ldp.html e información adicional: http://www.lesmaninst.com/unleashd/catalog/analytical/Rotronic-HygroClip2/Intro-to-Rotronic-HC2-Probes.pdf

Otro ejemplo de uso de RS485 con Arduino: http://electronics.stackexchange.com/questions/49097/arduino-as-modbus-master-with-max485-doesnt-get-any-response