El estándar de comunicación RS-485 es uno de los más utilizados en el sector industrial. Gracias al circuito integrado MAX485 también se puede utilizar con Arduino.
Imagínate que tienes un PLC o cualquier máquina que se comunica a través de un bus RS-485. Sería relativamente sencillo poder interceptar las tramas y leerlas desde un Arduino.
En este tutorial aprenderás a utilizar el módulo MAX485 para poder comunicar entre dos Arduinos.
A parte de ser muy utilizado, el RS-485 es un sistema de comunicación muy robusto a interferencias lo que permite la transmisión a altas velocidades y largas distancias.
De todo esto y de cómo aplicarlo con Arduino, es de lo que voy a hablar en este tutorial.
Ponte cómodo que empezamos.
Indice de contenidos
¿Qué es RS-485?
Formalmente hablando: el estándar TIA/EIA-485 (popularmente conocido como RS-485) describe una interfaz de comunicación que opera sobre líneas diferenciales capaces de comunicarse con 32 unidades de carga.
Más o menos viene a decir que es un bus al que pueden conectarse hasta 32 dispositivos, aunque es posible conectar más con algunos ajustes.
Es probable que en este punto te estés preguntando ¿y qué es un bus?
Un bus o canal de transmisión es el medio por el cual se transfieren datos entre dos componentes electrónicos. Puedes verlo como una autopista o una carretera de información, donde los bits viajan como si fueran automóviles que van de una ciudad a otra.
Si la carretera tiene un único carril para cada sentido, los coches viajan uno tras de otro. Si tiene varios carriles, pueden viajar varios coches uno al lado del otro.
Con los buses de información pasa algo parecido.
Cuando es de varios carriles se dice que es un bus paralelo y cuando solo tiene un carril decimos que es serie.
Ojo, que un bus serie usualmente cuenta con varios cables. No confundas los términos carril y cables. El bus RS-485 pertenece a este último grupo.
Uno de los inconvenientes que tienen los buses de información es la poca inmunidad al ruido.
Debido a esto el bus USB y el RS232 solo pueden utilizar conductores o cables de unos cuantos metros y otros como SPI o I2C son peores aún permitiendo en algunos dispositivos solo unos pocos centímetros de cable.
Para solventar esos problemas se utilizan los buses diferenciales. Estos emplean dos conductores de forma tal que las corrientes y tensiones en ambos sean simétricas. Eso ofrece inmunidad al ruido, al contrario de lo que ocurre con los buses ordinarios tales como RS232 o SPI.
La verdad, los detalles físicos detrás de los buses diferenciales pueden ser un tanto complejos así que no entraremos en más detalles, aunque debes tener presente que estos permiten establecer comunicaciones a grandes distancias, en el orden de kilómetros.
El caso más conocido de bus diferencial es el cable UTP, conocido así por sus siglas en inglés: Unshielded Twisted Pair.
Es el empleado para conectarse a internet desde un ordenador. El típico cable Ethernet. Internamente está compuesto por 8 conductores que forman 4 buses diferenciales, marcados por sus colores tal y como se muestra en la figura siguiente.
El uso de este tipo de bus no solo reduce las interferencias, sino que además causan una menor radiación. Esto permite su implantación sin peligro de afectar a otro sistema.
Pero volviendo al tema, el RS-485 es sencillo, robusto y, a diferencia de otras tecnologías propietarias, su uso es libre. Por estos motivos, muchos sensores y actuadores, lo han adoptado como forma de comunicación, siendo muy frecuente encontrarlo en el ámbito industrial.
Puedes encontrar sensores de humedad, temperatura, presión y prácticamente de cualquier tipo que utilizan el protocolo RS-485.
Utilizando RS-485 puedes establecer comunicaciones de hasta 1200 metros y alcanzar velocidades en el orden de los cientos de kilobits por segundo en largas distancias.
Una de las grandes ventajas del RS-485 es que podemos transmitir los datos que queramos y como queramos. Por lo tanto, no es necesario un código complejo para implementar la comunicación. Después veremos varios ejemplos utilizando Arduino donde comprobarás por ti mismo su simpleza.
En otros casos, cómo los SCADAS que hay en las fábricas o parques fotovoltaicos, se suele utilizar el protocolo Modbus. Este protocolo permite establecer una comunicación fiable y simple en arquitecturas maestro-esclavo.
RS-485: modos de Comunicación
El bus permite implementar varios modos de comunicación: simplex, half-duplex y full-duplex. Estos modos se diferencian en cómo se comunican el maestro y los esclavos. Por lo tanto, dependiendo de la aplicación, deberás elegir uno u otro modo.
Veamos cada uno de ellos.
Simplex
En el modo simplex RS-485 hay un solo transmisor y pueden haber varios receptores. Es empleado cuando el sistema controlador (transmisor) solo interactúa con actuadores o dispositivos que no emitan respuestas.
Este tipo de comunicación es común cuando se controlan motores, relés, luces y cosas por el estilo. En pocas palabras, si lo que quieres es encender las luces del jardín o activar el sistema de riego, esta es una buena alternativa.
Este modo solo requiere el uso de un cable par trenzado como medio de comunicación.
Half-Duplex
En el modo RS-485 half-duplex, todos los dispositivos pueden transmitir y recibir pero no de forma simultánea me explico.
En este modo es necesario que uno de los dispositivos coordine la comunicación. Este dispositivo coordinador es denominado master o maestro.
El resto de los dispositivos son llamados slave o esclavos y estarán a la espera de instrucciones provenientes del maestro para iniciar su comunicación. Cada esclavo tiene asignado un identificador único dentro del bus RS-485 para poder comunicar con él de forma unívoca.
Es como si fuera su DNI o documento de identificación.
Es algo parecido a lo que sucede con el protocolo I2C donde cada sensor tiene su propia dirección única dentro del bus.
Este modo, al igual que el simplex ,solo requiere el uso de un par trenzado como medio de comunicación.
Full-Duplex
El modo full-duplex del protocolo RS-485, al igual que el half-duplex, puede presentar una arquitectura maestro-esclavo. Sin embargo, en este modo se utilizan dos pares trenzados es decir, uno para transmisión y otro para recepción. De esta forma dos dispositivos pueden comunicarse de forma simultánea, pueden enviar y recibir información al mismo tiempo.
Es importante aclarar que todo esclavo debe esperar la indicación proveniente del maestro para comenzar a transmitir. De lo contrario, es posible que ocurra una colisión que no es más que varios dispositivos intentando enviar datos al mismo tiempo.
Un caso particular de esta arquitectura es cuando solo existen dos dispositivos. En ese caso ambos pueden transmitir sin riesgo alguno. Esta configuración en particular es precisamente la que nos permite utilizar el RS-485 como una extensión del puerto serie de Arduino.
Más adelante veremos un ejemplo de todo esto.
Topologías de red RS-485
Si bien se trata de una red cableada con un bus compartido, la forma en que se distribuyen los cables y los nodos permiten definir algunas topologías.
La topología de red solo hay que tenerla en cuenta cuando la distancia entre los diferentes elementos (maestros y esclavos) es grande es decir, se necesita cables largos.
En el caso de distancias cortas, la topología de una red RS-485 no afecta tanto.
Estas son las topologías más comunes del protocolo RS-485.
Bus con derivaciones
Como se observa en la figura, esta topología está formada por un bus principal y varias ramificaciones.
Si bien este cableado no es recomendado, es tolerable siempre y cuando las ramificaciones sean mucho menores que el bus principal. Aun así, es posible que para largas distancias y muchos dispositivos se produzcan problemas de comunicación.
Anillo
Debe ser evitada a toda costa ya que el lazo que se forma en el bus induce a reflexiones de la señal transmitida provocando la posible pérdida de la misma. En pocas palabras: es impensable.
Estrella o bus con estrellas
Aunque estas topologías pueden ser utilizadas para redes RS-485 pequeñas es decir, con pocos dispositivos y distancias cortas, lo recomendable es evitarla. Además, las secciones de los conductores de las estrellas deben ser lo más cortos posibles.
Daisy chain (conexión en cadena)
Esta es la topología recomendada y utilizada por la gran mayoría de proveedores e instaladores de redes RS-485.
En esta topología los dispositivos están conectados directamente al bus principal y no existen ramales. Lo que significa que es necesario que el bus llegue hasta cada uno de los dispositivos, tal y como se muestra en la imagen.
Esta topología minimiza las reflexiones provocadas por los conductores en los procesos de transmisión. Es por eso que es la más recomendada.
Resistencias de terminación bus RS-485
Si tu red RS-485 excede los 100 metros y opera a una velocidad mayor de 19200 bps (bytes por segundo) es posible que la comunicación se vea afectada o totalmente imposibilitada. Eso se debe a las interferencias de alta frecuencia, las pérdidas que se producen en los conductores a larga distancia y problemas de desacople.
Para minimizar esos problemas se deben añadir resistencias de terminación. Estas son de uso casi obligatorio cuando las distancias son considerables o la velocidad elevada.
Estas resistencias no tienen nada de especial, son resistencias ordinarias iguales como las que vienen en los kit de Arduino o las que puedes comprar en Amazon.
Se diferencian en la función que hacen ya que lo que hacen es mejorar el acople de la red, minimizando las distorsiones o interferencias que pueden afectar a una señal de alta frecuencia.
En la figura anterior puedes observar que las resistencias de terminación se colocan en los extremos de la red. Eso significa que se coloca una cerca del primer dispositivo y otra próxima al último.
Ahora la duda es: ¿qué resistencia tengo que utilizar?
La regla es que su valor debe ser igual a la impedancia característica del conductor utilizado. Eso significa que su valor depende exclusivamente del tipo de cable. El caso más común es el del par trenzado cuya impedancia es de 120 ohmios.
Ojo, la resistencia de terminación solo es necesaria en el protocolo RS-485 cuando se trata de una red extensa de más de 100 metros o trabaje a una velocidad elevada mayor de 19200 bps.
Conexión a tierra
En algunas instalaciones industriales junto a los cables del bus se suele incluir un tercer cable de tierra. Este cable no interviene en la comunicación sin embargo, cuando el conductor a utilizar es de tipo apantallado como el cable STP (siglas en inglés de shielded twisted pair), el uso de la tierra reduce las interferencias externas sobre la comunicación.
Circuito integrado MAX485
El circuito integrado MAX485 es quizás el más conocido de los controladores RS-485. Este permite establecer comunicaciones half-duplex a velocidades de hasta 2,5 Mbps sobre una red de como mucho 32 dispositivos.
Este puede clasificarse como un conversor-serie a RS-485 lo que significa que es capaz de tomar una señal emitida con el módulo serial o con la librería SoftwareSerial de Arduino u otro dispositivo y transformarla al estándar RS-485.
Por supuesto, también realiza la acción inversa. Siendo capaz de tomar la señal RS-485 y traducirla para que el Arduino sea capaz de recibirla utilizando el puerto serie o la librería SoftwareSerial.
No puede realizar las dos operaciones al mismo tiempo.
El circuito integrado o chip, se puede adquirir dentro de un módulo para poder conectarlo a un Arduino de una forma muy sencilla. Normalmente se suele dar el mismo nombre al módulo que al circuito integrado MAX485.
Antes de entrar a ver las características técnicas del módulo, veamos las opciones de compra.
Dónde puedo comprar un MAX485
Como siempre, hay diferentes opciones para comprar un MAX485 y poder utilizar el bus RS-485 en nuestros proyectos con Arduino.
Si quieres algo rápido, fiable y cómodo Amazon es una buena opción. También puedes ir a BricoGeek o Aliexpress.
Si entras en Amazon y buscas MAX485 encontrarás multitud de tiendas que tienen módulos MAX485. A parte del típico módulo que ya hemos visto, cabe destacar un shield para Arduino compatible con RS-485 y Bus CAN.
El bus CAN, al igual que el RS-485, es un protocolo muy extendido en el sector industrial. Si tienes pensado utilizar los dos buses, te recomiendo este shield que hay en Amazon.
También hay un módulo MAX485 muy interesante que incluye un conector RJ-45. Algo muy práctico a la hora de conectar sensores y actuadores.
Características técnicas MAX485
En la tabla ABSOLUTE MAXIMUM RATINGS de la hoja de características técnicas del MAX485 están listados los valores límite de voltajes, potencia y temperatura que debemos respetar.
Podrás notar que su voltaje de alimentación máximo es de 12V. Sin embargo, se recomienda utilizar una alimentación 5V para conseguir un funcionamiento óptimo.
Si analizas los valores de temperatura de operación notarás que está pensado para todo tipo de ambientes. Con modelos que soportan temperaturas desde -55°C hasta 125°C.
En la siguiente figura puedes ver que su consumo en reposo es de tan solo 300 uA. Esto lo hace ideal para aplicaciones de bajo consumo.
En la tabla SWITCHING CHARACTERISTICS de la hoja de características técnicas se muestra un grupo de parámetros relacionados con los tiempos de transmisión y recepción. Aquí destaca la frecuencia máxima de comunicación con un valor de 2,5 Mbps.
Por otra parte, presenta un encapsulado simple y compacto de tan solo 8 pines. Eso lo convierte en una solución ideal a la hora de realizar proyectos de dimensiones reducidas.
Distribución de pines del MAX485
En la siguiente figura obtenida de la hoja de características se puede observar la distribución de pines del MAX485.
Veamos para qué se utiliza cada uno de esos pines:
- VCC: es el pin de alimentación y su voltaje debe estar entre los 4.75 y 5.25 voltios.
- GND: es el pin de tierra.
- A y B: son los pines del bus diferencial. Mediante estos pines se transmite la información a otro dispositivo RS-485.
- RE (Receiver Output Enable): permite habilitar o deshabilitar el modo de recepción. En pocas palabras si queremos recibir datos desde otro dispositivo es necesario poner este pin en estado bajo.
- RO (Receiver Output): es el pin por el cual se recibe la información enviada por otro módulo, usualmente es conectado al pin RX del Arduino. Para que la información sea recibida el pin RE debe estar en estado bajo.
- DE (Driver Output Enable): permite configurar el MAX485 en modo de transmisión. Para eso debe ser puesto en estado alto, en caso de querer desactivarlo debe ser puesto en estado bajo.
- DI (Driver Input): este pin es utilizado para transmitir información a otro dispositivo y por tanto usualmente es conectado al pin TX del Arduino. Es necesario que el pin DE esté configurado con un estado alto para poder transmitir.
En el módulo MAX485 podemos encontrar los mismos pines en un lado y en otro del componente.
Per la función de los pines es la misma.
Estructura interna del MAX485
En la siguiente imagen puedes ver la estructura interna del MAX485.
El triángulo denotado con la letra D es el conversor serie a RS-485. Como puedes ver en el diagrama, su entrada está conectada al pin DI y su salida a los pines A y B. Por lo tanto, toda señal que se transmita al pin DI es transformada y transferida a los pines A y B.
El otro triángulo, denotado con la letra R, es el conversor RS-485 a serie. Los pines A y B están conectados a su entrada y su salida con el pin RO. Eso implica que las señales RS-485 que lleguen por los pines A y B son transmitidas por el pin RO para que el Arduino las pueda recibir.
Como la salida de R y la entrada de D coinciden, sólo es posible utilizar uno a la vez, o salida o entrada. Para eso se utilizan los pines DE y RE.
A continuación vamos a ver cómo hay que conectar el módulo MAX485 con un Arduino.
Cómo conectar un MAX485 con Arduino
El esquema de conexión de Arduino y el módulo MAX485 dependerá de la función que tenga el microcontrolador. Hay dos posibles configuraciones:
- Arduino y MAX485 como transmisor o receptor
- Arduino y MAX485 como transmisor y receptor
Arduino y MAX485 como transmisor o receptor
Comencemos analizando un caso simple utilizando el MAX485 como un simple transmisor.
Este tipo de configuración es útil en una red tipo simplex donde, como ya te comenté, un dispositivo maestro actúa como transmisor sin recibir información del resto de los componentes de la red.
Para configurar el MAX485 como transmisor es necesario:
- Apagar el receptor: el pin RE tiene que ser puesto en estado alto.
- Encender el transmisor: el pin DE tiene que ser puesto en estado alto.
- Conectar el pin DI del MAX485 al pin TX del Arduino.
- Los pines A y B se conectan a los dispositivos receptores.
La conexión utilizando un Arduino UNO sería igual a la mostrada en la figura.
Con esta configuración todo lo que sea escrito mediante el Serial será enviado al bus RS-485.
El pin DI se ha conectado al pin TX para utilizar el módulo serie de Arduino. En caso de utilizar la librería SoftwareSerial, el pin DI tiene que ser conectado al pin de transmisión del SoftwareSerial.
Veamos ahora el caso contrario: configurar el MAX485 como solo receptor.
Esta configuración es útil a la hora de implementar un dispositivo esclavo en una red Simplex. Más adelante veremos un ejemplo de este tipo de red.
Para lograr esta configuración es necesario:
- Encender el receptor: el pin RE tiene que ser puesto en un estado bajo.
- Apagar el transmisor: el pin DE tiene que ser puesto en un estado bajo.
- Conectar el pin RO al pin RX del Arduino.
- Los pines A y B se conectan a los dispositivos receptores.
En la figura se muestra el circuito utilizando un Arduino UNO.
Con esta configuración todo lo que sea transmitido por el bus RS-485 será detectado por el Arduino y podrá ser leído mediante el Serial.
El pin RO se ha conectado al pin RX para utilizar el módulo serie de Arduino. En caso de utilizar SoftwareSerial, el pin RO tiene que ser conectado al pin de transmisión del SoftwareSerial.
Arduino y MAX485 como transmisor y receptor
Ya hemos visto como configurar el MAX485 como transmisor o receptor. Sin embargo, esto tiene muchas limitaciones: transmitir o recibir información.
Para que funcione como receptor y transmisor hay que controlar su modo de operación. Así podrá hacer las dos cosas a la vez: transmitir y recibir.
Para realizar esto es necesario conectar el Arduino como se muestra en la siguiente figura
Como puedes ver en este caso los pines TX y RX de Arduino se han conectado a los pines DI y RO del MAX485 como si fuera una combinación de los dos modos anteriores.
Por otra parte, los pines RE y DE se conectan al pin 2 de Arduino. Esto nos permite cambiar el modo de operación del MAX485 simplemente cambiando el estado de ese pin.
| Estado pin 2 | Modo MAX485 |
|---|---|
| HIGH | Transmisor |
| LOW | Receptor |
Aunque en el esquema veas que he utilizado el pin 2 para RE y DE, tú puedes utilizar el pin que quieras.
De momento solo hemos visto el esquema eléctrico para cada configuración pero no hemos visto nada de código. En la siguiente sección haremos un ejercicio práctico para comunicar dos Arduinos con el bus RS-485.
Conectar dos Arduino con el bus RS-485
Una vez que tienes claro cómo funciona el bus RS-485, cómo conectarlo a un Arduino y dónde comprar el MAX485, veamos cómo podemos conectar dos Arduinos para que se comuniquen entre sí.
Un detalle importante es que no es posible utilizar un MAX485 con placas que funcionan a 3.3 voltios. Por lo tanto, no se pueden emplear directamente con un ESP8266. En caso de que tu aplicación lo requiera siempre puedes utilizar un conversor de niveles para interconectar el ESP8266 y el MAX485.
A continuación veremos varios ejemplos utilizando placas de Arduino. Aquí tienes el listado de material que vas a necesitar:
- 2 x Arduino UNO *
- 2 x MAX485 **
- Protoboard
- Cables
* También puedes utilizar un Arduino UNO y un Arduino MEGA.
** Para el último ejemplo necesitarás 4 de estos módulos.
Antes de analizar los ejemplos quiero recordarte que el estándar RS-485 no establece una estructura para enviar los datos. Eso significa que puedes enviarlos a tu antojo y con el formato que tú decidas.
En los ejemplos se ha implementado un software muy simple que funciona para las arquitecturas maestro-esclavo. Ten en cuenta que es muy básica y solo permite enviar un byte de información útil.
Esa no es una limitación propia del RS-485. Con tu propia implementación podrías enviar más de un byte a la vez.
Comunicación simplex con Arduino y RS-485
Veamos primero el caso más sencillo: una comunicación simplex entre dos Arduinos o más.
En este ejemplo se consigue enviar órdenes desde un Arduino MEGA hasta un Arduino UNO utilizando dos módulos RS-485.
En este caso solo uno de los dispositivos envía información por el bus y los esclavos lo procesan.
En este caso solo se utiliza un esclavo, pero pueden utilizarse varios sin ningún problema.
El Arduino MEGA actúa como maestro y por tanto su módulo RS-485 está configurado como transmisor. La placa envía datos al pin DI del MAX485 mediante el pin TX3. Los datos son transmitidos por el bus a todos los dispositivos.
El Arduino UNO actúa como esclavo y su módulo RS-485 se ha configurado en modo recepción. Para la comunicación se ha utilizado un objeto de la librería SoftwareSerial que utiliza el pin 10 para recepción.
Podrás notar que el módulo RS-485 que utilizo es diferente a cualquier otro. Se trata de un módulo DIY diseñado y construido por un colega de cacharrero. Este módulo también utiliza el MAX485.
Código para cargar en el maestro
Este código se carga en el Arduino MEGA o Arduino UNO que haga la función de maestro.
Un problema con el bus RS-485 es que hay que indicar a qué esclavo va dirigido cada comando. Es por eso que se ha definido un formato de trama simple pero eficiente.
Esto solo es necesario cuando se tienen varios esclavos conectados. Si solo hay uno no será un problema.
La trama consta de 4 bytes organizados de la siguiente forma:
| Byte 0 | Byte 1 | Byte 2 | Byte 3 |
| Inicio de trama | ID de esclavo | comando | Fin de trama |
Un ejemplo de trama seria: {0xAA, 0x34, 0x01, 0xFE} donde:
- 0xAA → Inicio de Trama
- 0x23 → Id del esclavo al que va dirigido el mensaje
- 0x01 → comando a ejecutar por el esclavo
- 0xFE → fin de trama
Para este ejemplo se han definido constantes con los valores de inicio y fin de trama, dos posibles comandos y el identificador del esclavo al que se envía la información.
|
1 2 3 4 5 6 7 |
#define HEAD 0xAA // Inicio de trama #define TAIL 0xFE // Fin de trama #define CMD_LED_ON 0x01 // Encender led #define CMD_LED_OFF 0x02 // Apagar Led #define SLAVE_TARGET 0x23 // Esclavo al que se envia el comando |
La función setup() inicializa el Serial y el Serial3. Serial3 es empleado para enviar datos con el MAX485 y el Serial para recibir instrucciones desde el monitor serie.
|
1 2 3 4 5 6 7 8 9 10 |
void setup() { // Configurar Serial para utilizarlo como monitor Serial.begin(19200); pinMode(LED_BUILTIN, OUTPUT); digitalWrite(LED_BUILTIN, LOW); // Configurar Serial3 para el bus RS-485 Serial3.begin(9600); } |
La función comprueba continuamente si se ha recibido algún carácter desde el monitor serie utilizando la función Serial.available().
Si algún carácter está disponible este es leído y almacenado en la variable ch.
|
1 2 3 4 |
char ch = Serial.read(); Serial.print("recibido: "); Serial.println(ch); |
Luego se comprueba que carácter es:
- Si recibe una ‘A’ enviará un comando de apagar LED.
- Si recibe una ‘a’ enviará un comando de encender LED.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
if( ch == 'A' ){ Serial.println("Apagando leds"); trama[0] = HEAD; trama[1] = SLAVE_TARGET;// esclavo trama[2] = CMD_LED_OFF; // apagar led trama[3] = TAIL; Serial3.write( trama, 4 ); Serial.print( trama[0], HEX ); Serial.print( " " ); Serial.print( trama[1], HEX ); Serial.print( " " ); Serial.print( trama[2], HEX ); Serial.print( " " ); Serial.print( trama[3], HEX ); Serial.println( ); } else if ( ch == 'a' ){ Serial.println("Encendiendo leds"); trama[0] = HEAD; trama[1] = SLAVE_TARGET;// esclavo trama[2] = CMD_LED_ON; // apagar led trama[3] = TAIL; Serial3.write( trama, 4 ); Serial.print( trama[0], HEX ); Serial.print( " " ); Serial.print( trama[1], HEX ); Serial.print( " " ); Serial.print( trama[2], HEX ); Serial.print( " " ); Serial.print( trama[3], HEX ); Serial.println( ); } |
Como puedes observar, la trama a enviar es almacenada en el array trama y luego se envía utilizando la instrucción Serial3.write(trama, 4).
Aquí te dejo el código completo:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 |
/** * Ejemplo RS-485 con MAX485 y Arduino * * Comunicacion: Simplex * Roll: Master * Placa: Arduino MEGA 2560 */ #define HEAD 0xAA #define TAIL 0xFE #define CMD_LED_ON 0x01 #define CMD_LED_OFF 0x02 #define SLAVE_TARGET 0x23 // Esclavo al que se envia el comando // Formato de Trama: <HEAD> <SLAVE_ID> <CMD> <TAIL> // Ejemplo: 0xFF 0x34 0x01 0xFE -> Indica que el esclavo 0x34 debe ejecutar la orden 0x01 byte trama[5], idx; int last_millis = 0; char ch; void setup() { // Configurar Serial para utilizarlo como monitor Serial.begin(19200); pinMode(LED_BUILTIN, OUTPUT); digitalWrite(LED_BUILTIN, LOW); ch = 'a'; // Configurar Serial3 para el bus RS-485 Serial3.begin(9600); } void loop() { if( Serial.available() ){ delay(2000); digitalWrite( LED_BUILTIN, HIGH ); char ch = Serial.read(); Serial.print("recibido: "); Serial.println(ch); if( ch == 'A' ){ Serial.println("Apagando leds"); trama[0] = HEAD; trama[1] = 0x23; // esclavo trama[2] = CMD_LED_OFF; // apagar led trama[3] = TAIL; Serial3.write( trama, 4 ); Serial.print( trama[0], HEX ); Serial.print( " " ); Serial.print( trama[1], HEX ); Serial.print( " " ); Serial.print( trama[2], HEX ); Serial.print( " " ); Serial.print( trama[3], HEX ); Serial.println( ); } else if ( ch == 'a' ){ Serial.println("Encendiendo leds"); trama[0] = HEAD; trama[1] = 0x23; // esclavo trama[2] = CMD_LED_ON; // apagar led trama[3] = TAIL; Serial3.write( trama, 4 ); Serial.print( trama[0], HEX ); Serial.print( " " ); Serial.print( trama[1], HEX ); Serial.print( " " ); Serial.print( trama[2], HEX ); Serial.print( " " ); Serial.print( trama[3], HEX ); Serial.println( ); } } delay(1000); // esperar 1 segundo digitalWrite( LED_BUILTIN, LOW); } |
Código para cargar en el esclavo
Este código es el que se carga en el Arduino UNO o el Arduino que haga la función de esclavo.
El Arduino esclavo estará en todo momento esperando comandos provenientes del maestro. Una vez que detecte un comando, tendrá que averiguar que realmente ese comando es para él.
Eso lo hacemos filtrando por identificador de esclavo. Tengo que recalcar que un bus RS-485 es muy importante que cada esclavo tenga un identificador único dentro del bus de comunicación.
Imagina el resultado si en vez de Arduinos fueran brazos robóticos de una línea de ensamblaje y ejecutan una acción que no es para él, podría ser muy peligroso.
Para evitar este posible desastre, en el código del esclavo se declaran las mismas constantes que tiene el código del maestro. Si, aquellas que definen la trama y los posibles comandos: HEAD, TAIL, CMD_LED_OFF y CMD_LED_ON.
Además, se ha incluido la librería para Arduino SoftwareSerial y se ha declarado un objeto de ese tipo llamado rs485 para recibir los datos provenientes del MAX485 utilizando el pin digital 10.
La constante MY_SLAVE_ID, es el identificador único del esclavo dentro del bus RS-485. En el código del maestro se estableció un valor a SLAVE_TARGET igual a 0x23. La constante MY_SLAVE_ID debe tener el mismo valor.
|
1 2 3 4 5 6 7 8 9 10 |
#include <SoftwareSerial.h> #define HEAD 0xAA #define MY_SLAVE_ID 0x23 #define TAIL 0xFE #define CMD_LED_ON 0x01 #define CMD_LED_OFF 0x02 SoftwareSerial rs485(10, 11); // RX, TX |
En el programa se utilizan dos variables auxiliares, buff un array de bytes e idx una variable de tipo byte.
Estas variables se utilizan para almacenar los datos recibidos desde el bus RS-485 y comprobar si pertenecen a una trama válida.
|
1 |
byte buff[5], idx; |
La función setup() inicializa las clases Serial y rs485. También configura los pines digitales para controlar el LED de la placa e inicializa la variable idx a cero.
|
1 2 3 4 5 6 7 8 9 10 11 |
void setup() { // Configurar Serial a 9600 baudios Serial.begin(9600); rs485.begin(9600); pinMode( LED_BUILTIN, OUTPUT ); digitalWrite( LED_BUILTIN, LOW ); idx = 0; } |
En la función loop() se reciben y almacenan las tramas enviadas desde el dispositivo maestro:
- Para esto es necesario esperar a recibir un byte de inicio de trama.
- Se leen los 3 bytes siguientes.
- Se comprueba que el último byte sea el de fin de trama.
- Se ejecuta la función ejecutarComando().
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
void loop() { if( !rs485.available() ) return; byte incoming = rs485.read(); Serial.print("Recibido: "); Serial.println(incoming); if( idx == 0 ){ // principio de trama if( incoming != HEAD ) // trama incorrecta return; buff[idx] = incoming; idx++; } else if ( idx > 0 && idx < 4 ){ // buff[idx++] = incoming; // if ( idx == 4 ){ // fin de trama if( buff[3] == TAIL ) // verificar que termine bien ejecutarComando(); idx = 0; } } } |
La función ejecutarComando se encarga de identificar si la trama interpretada es para él y en caso afirmativo, ejecuta la instrucción correspondiente. Para determinar la acción a realizar se utiliza una estructura switch.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
void ejecutarComando(){ Serial.println("Ejectutando comando!!!"); if ( buff[1] != MY_SLAVE_ID ) // el mensaje es para otro esclavo return; switch( buff[2] ){ // ejecutar comando case CMD_LED_ON: // Encender Led digitalWrite( LED_BUILTIN, HIGH ); break; case CMD_LED_OFF: // Apagar Led digitalWrite( LED_BUILTIN, LOW ); break; default: // Comando Inva'lido break; } } |
Aquí te dejo el programa del esclavo completo y listo para cargar en tu Arduino UNO.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 |
/** * Ejemplo RS-485 con MAX485 y Arduino * * Comunicacion: Simplex * Roll: Slave * Placa: Arduino UNO R3 */ #include <SoftwareSerial.h> #define HEAD 0xAA #define MY_SLAVE_ID 0x23 #define TAIL 0xFE #define CMD_LED_ON 0x01 #define CMD_LED_OFF 0x02 SoftwareSerial rs485(10, 11); // RX, TX // Formato de Trama: <HEAD> <SLAVE_ID> <CMD> <TAIL> // Ejemplo: 0xFF 0x34 0x01 0xFE -> Indica que el esclavo 0x34 debe ejecutar la orden 0x01 byte buff[5], idx; void setup() { // Configurar Serial a 9600 baudios Serial.begin(9600); rs485.begin(9600); pinMode( LED_BUILTIN, OUTPUT ); digitalWrite( LED_BUILTIN, LOW ); idx = 0; } void ejecutarComando(){ Serial.println("Ejectutando comando!!!"); if ( buff[1] != MY_SLAVE_ID ) // el mensaje es para otro esclavo return; switch( buff[2] ){ // ejecutar comando case CMD_LED_ON: // Encender Led digitalWrite( LED_BUILTIN, HIGH ); break; case CMD_LED_OFF: // Apagar Led digitalWrite( LED_BUILTIN, LOW ); break; default: // Comando Inva'lido break; } } void loop() { if( !rs485.available() ) return; byte incoming = rs485.read(); Serial.print("Recibido: "); Serial.println(incoming); if( idx == 0 ){ // principio de trama if( incoming != HEAD ) // trama incorrecta return; buff[idx] = incoming; idx++; } else if ( idx > 0 && idx < 4 ){ // buff[idx++] = incoming; // if ( idx == 4 ){ // fin de trama if( buff[3] == TAIL ) // verificar que termine bien ejecutarComando(); idx = 0; } } } |
Comunicación half-duplex con Arduino y RS-485
En el ejemplo anterior se logró establecer comunicación unidireccional es decir, que solo el Arduino MEGA podía enviar información al Arduino UNO y no en sentido contrario. Lo que viene a decir que solo el maestro es capaz de enviar información a los esclavos.
Pero ¿cómo hacer que el esclavo responda o envíe información al maestro?
Imagina una arquitectura similar a la anterior pero donde algunos esclavos se les ha conectado sensores, un DHT11 por ejemplo. Y ahora, desde el maestro, queremos obtener la información de temperatura y humedad.
Ese es el típico caso para una comunicación half-duplex, donde las órdenes del maestro no solo indican una acción sino que generan una respuesta por parte del esclavo.
En estos casos, los MAX485 se deben conectar de forma tal que el Arduino sea capaz de controlar su modo de operación. Eso se debe a que tanto el maestro como los esclavos serán capaces de transmitir y recibir información del bus.
En la siguiente imagen puedes ver cómo quedaría el circuito.
El Arduino UNO, que actúa como esclavo, se ha conectado a los pines DI y RO del módulo MAX485 mediante los pines digitales 8 y 10 respectivamente.
Dichos pines son utilizados por un objeto SoftwareSerial y así implementar la comunicación con el bus. Además, el pin digital 9 se utiliza para determinar el modo de operación del módulo RS-485.
El DHT11 se ha conectado de tal forma que es necesario poner los pines digitales 4 y 2 en estado HIGH y LOW respectivamente para activarlo. Mientras que el pin 3 es utilizado para la comunicación.
El Arduino MEGA cumple el rol de maestro y utiliza el módulo Serial3 para comunicarse con el MAX485. Mientras el pin 25 es utilizado para establecer el modo de operación del MAX485 (receptor o transmisor).
Aquí te dejo las imágenes del montaje que realicé del circuito.
Código para cargar en el maestro
Este código tiene que ser cargado a la placa que cumpla la función de maestro. En este caso el rol de maestro lo tiene el Arduino MEGA.
El estilo de comunicación es similar al anterior ejemplo ya que se mantiene una arquitectura maestro-esclavo. La única diferencia es que ahora los esclavos también pueden responder a algunos comandos del maestro.
Es por eso que la mayoría de las constantes empleadas en el ejemplo anterior se mantienen.
|
1 2 3 4 5 6 7 8 9 10 11 |
#define HEAD 0xAA #define TAIL 0xFE // Comandos soportados #define CMD_LED_ON 0x01 #define CMD_LED_OFF 0x02 #define CMD_READ_TEMP 0x03 #define CMD_READ_HUMED 0x04 #define RS485_PIN_MODE 25 // HIGH -> Transmision; LOW-> recepcion |
Se agregan dos constantes que identifican a dos comandos nuevos:
- CMD_READ_TEMP que le pregunta a un esclavo por su temperatura.
- CMD_READ_HUMED que le pregunta a un esclavo por su humedad.
También se ha definido la constante RS485_PIN_MODE para identificar el pin que será utilizado para establecer el modo de operación del MAX485.
En la función setup() se configuran los puertos Serial y Serial3. También se configura el MAX485 en modo recepción poniendo el pin RS485_PIN_MODE en estado LOW.
|
1 2 3 4 5 6 7 8 9 10 11 |
void setup() { // Configurar Serial para utilizarlo como monitor Serial.begin(19200); pinMode( RS485_PIN_MODE, OUTPUT ); digitalWrite(RS485_PIN_MODE, LOW); // modo recepcion // Configurar Serial3 para el bus RS-485 Serial3.begin(9600); } |
La función loop() supervisa el puerto Serial esperando la llegada de algún dato proveniente del monitor serie. Cuando se detecta, es leído y mediante una estructura switch se determina qué comando debe enviar el maestro al esclavo.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
void loop() { if( Serial.available() ){ char c = Serial.read(); int h, t; switch(c){ case '0': enviarComando(SLAVE, CMD_LED_ON); break; case '1': enviarComando(SLAVE, CMD_LED_OFF); break; case '2': enviarComando(SLAVE, CMD_READ_TEMP); Serial.print("Temperatura: "); t = recibirRespuesta(SLAVE); if( t == -1 ) Serial.println( "No se recibio' respuesta" ); else Serial.println(t); break; case '3': enviarComando(SLAVE, CMD_READ_HUMED); Serial.print("Humedad: "); h = recibirRespuesta(SLAVE); if( h == -1 ) Serial.println( "No se recibio' respuesta" ); else Serial.println(h); break; default: break; } } } |
Los dos primeros casos ya se analizaron en el ejemplo anterior. Aunque en este caso se utiliza la función enviarComando. Esta rutina recibe como parámetros el identificador de esclavo y el comando a enviar.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
void enviarComando(byte esclavo, byte cmd){ trama[0] = HEAD; trama[1] = esclavo; trama[2] = cmd; trama[3] = TAIL; digitalWrite(RS485_PIN_MODE, HIGH); // modo tx // enviar trama Serial3.write(trama, 4); // esperar que todos los bytes se envien Serial3.flush(); digitalWrite(RS485_PIN_MODE, LOW); // modo rx } |
Para enviar la trama sigue el siguiente algoritmo:
- Almacenar trama en el array trama.
- Poner el MAX485 en modo transmisor.
- Enviar trama.
- Poner el MAX485 en modo receptor.
Es importante utilizar la función Serial3.flush() para garantizar que todos los bytes de la trama se envíen antes de cambiar el modo del MAX485.
Volviendo a la función loop()…
Los casos 2 y 3 son los que realmente dan sentido a este ejemplo.
En estos casos se ejecuta la rutina enviarComando y seguidamente se llama a la función recibirRespuesta. Esta función recibe como parámetro el esclavo del cual está esperando respuesta y devuelve el valor enviado por éste. Si la trama no es válida devuelve -1.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
int recibirRespuesta( byte esclavo ){ digitalWrite(RS485_PIN_MODE, LOW); // modo rx delay(2000); Serial3.readBytes( trama, 4 ); if( trama[0] != HEAD ) // error en la trama return -1; if( trama[1] != esclavo ) // respuesta de otro esclavo return -1; if( trama[3] != TAIL ) // error en trama return -1; return trama[2]; } |
La estructura de la trama de la respuesta del esclavo es similar a la que envía el maestro. La diferencia es que la respuesta se coloca en la posición que el maestro utiliza para especificar el comando es decir, el tercer byte de la trama.
Aquí tienes el código completo del maestro para que lo puedas probar tu mismo.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 |
/** * Ejemplo RS-485 con MAX485 y Arduino * * Comunicacion: Half-duplex * Roll: Master * Placa: Arduino MEGA 2560 */ #define HEAD 0xAA #define TAIL 0xFE // Comandos soportados #define CMD_LED_ON 0x01 #define CMD_LED_OFF 0x02 #define CMD_READ_TEMP 0x03 #define CMD_READ_HUMED 0x04 // Formato de Trama: <HEAD> <SLAVE_ID> <CMD> <TAIL> // Ejemplo: 0xFF 0x34 0x01 0xFE -> Indica que el esclavo 0x34 debe ejecutar la orden 0x01 #define RS485_PIN_MODE 25 // HIGH -> Transmision; LOW-> recepcion #define SLAVE 0x23 byte trama[5], idx; void enviarComando(byte esclavo, byte cmd){ trama[0] = HEAD; trama[1] = esclavo; trama[2] = cmd; trama[3] = TAIL; digitalWrite(RS485_PIN_MODE, HIGH); // modo tx Serial3.write(trama, 4); Serial3.flush(); digitalWrite(RS485_PIN_MODE, LOW); // modo rx } int recibirRespuesta( byte esclavo ){ digitalWrite(RS485_PIN_MODE, LOW); // modo rx delay(2000); Serial3.readBytes( trama, 4 ); if( trama[0] != HEAD ) // error en la trama return -1; if( trama[1] != esclavo ) // respuesta de otro esclavo return -1; if( trama[3] != TAIL ) // error en trama return -1; return trama[2]; } void setup() { // Configurar Serial para utilizarlo como monitor Serial.begin(19200); pinMode( RS485_PIN_MODE, OUTPUT ); digitalWrite(RS485_PIN_MODE, LOW); // modo recepcion // Configurar Serial3 para el bus RS-485 Serial3.begin(9600); } void loop() { if( Serial.available() ){ char c = Serial.read(); int h, t; switch(c){ case '0': enviarComando(SLAVE, CMD_LED_ON); break; case '1': enviarComando(SLAVE, CMD_LED_OFF); break; case '2': enviarComando(SLAVE, CMD_READ_TEMP); Serial.print("Temperatura: "); t = recibirRespuesta(SLAVE); if( t == -1 ) Serial.println( "No se recibio' respuesta" ); else Serial.println(t); break; case '3': enviarComando(SLAVE, CMD_READ_HUMED); Serial.print("Humedad: "); h = recibirRespuesta(SLAVE); if( h == -1 ) Serial.println( "No se recibio' respuesta" ); else Serial.println(h); break; default: break; } } } |
Código para cargar en el esclavo
Este código corresponde al dispositivo esclavo. Para este ejemplo estamos empleando un Arduino UNO.
En este ejemplo, hay un sensor DHT11 conectado al esclavo y esto hace que el código sea algo diferente al ejemplo anterior. Además, es capaz de enviar mensajes al maestro.
Ningún esclavo debe intentar comunicarse con el maestro por su cuenta. Solo pueden comunicarse cuando el maestro requiera alguna información.
Lo primero es incluir la librería DHT.h para la comunicación con el DHT11.
|
1 2 |
#include <SoftwareSerial.h> #include <DHT.h> |
También se han agregado constantes para los nuevos comandos disponibles y los pines del DHT11.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
// Trama maestro-esclavo #define HEAD 0xAA #define MY_SLAVE_ID 0x23 #define TAIL 0xFE //Comandos soportados #define CMD_LED_ON 0x01 #define CMD_LED_OFF 0x02 #define CMD_READ_TEMP 0x03 #define CMD_READ_HUMED 0x04 #define DHT_GND 2 // tierra dht11 #define DHT_VCC 4 // alimentacion dht11 #define DHT_PIN 3 // comunicacion dht11 #define RS485_PIN_MODE 9 // HIGH -> Transmision; LOW-> recepcion |
Hay que crear un objeto de la clase SoftwareSerial que utiliza los pines digitales 10 y 8 para comunicarse con el MAX485. También se crea un objeto DHT indicando el pin y el tipo de sensor.
|
1 2 |
SoftwareSerial RS485(10, 8); // RX, TX DHT dht(DHT_PIN, DHT11); |
En la función setup() se inicializan las clases Serial y RS485. También enciende el sensor configurando adecuadamente sus pines de alimentación.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
void setup() { // Configurar Serial a 19200 baudios (para el monitor serie) Serial.begin(19200); // Configurar para utilizar el bus 485 a 9600 RS485.begin(9600); // configrar pines pinMode( LED_BUILTIN, OUTPUT ); pinMode( RS485_PIN_MODE, OUTPUT ); pinMode( DHT_VCC, OUTPUT ); pinMode( DHT_GND, OUTPUT ); // encender dht11 digitalWrite( DHT_VCC, HIGH ); digitalWrite( DHT_GND, LOW ); digitalWrite( LED_BUILTIN, LOW ); // apagar led digitalWrite( RS485_PIN_MODE, LOW );// poner en modo de recepcion dht.begin(); idx = 0; } |
La función loop() no sufre cambios y se mantiene exactamente igual que en el caso de comunicación simplex.
El cambio realmente significativo ocurre en la función ejecutarComando.
Esta función se encarga de filtrar según el comando recibido. Dependiendo de este parámetro, ejecuta una acción u otro. En caso de que el comando requiera respuesta, ejecuta la función enviarRespuesta.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
void enviarRespuesta( float x ){ buff[0] = HEAD; buff[1] = MY_SLAVE_ID; buff[2] = (byte)x; buff[3] = TAIL; digitalWrite( RS485_PIN_MODE, HIGH ); // poner en modo Tx RS485.write( buff, 4 ); // transmitir mensaje RS485.flush(); digitalWrite( RS485_PIN_MODE, LOW); // poner en modo Rx } void ejecutarComando(){ Serial.println("Ejectutando comando!!!"); if ( buff[1] != MY_SLAVE_ID ) // el mensaje es para otro esclavo return; switch( buff[2] ){ // ejecutar comando case CMD_LED_ON: // Encender Led digitalWrite( LED_BUILTIN, HIGH ); break; case CMD_LED_OFF: // Apagar Led digitalWrite( LED_BUILTIN, LOW ); break; case CMD_READ_TEMP: temperatura = dht.readTemperature(); // grados Celcius enviarRespuesta( temperatura ); break; case CMD_READ_HUMED: humedad = dht.readHumidity(); enviarRespuesta( humedad ); break; default: // Comando Inva'lido break; } } |
La función enviarRespuesta recibe como parámetro el byte a enviar al maestro. El funcionamiento de esta función es similar al de la función enviarComando vista en el código del maestro.
Finalmente, aquí tienes todo el programa para que lo pruebes o adaptes a tu propio proyecto con Arduino.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 |
/** * Ejemplo RS-485 con MAX485 y Arduino * * Comunicacion: Half-duplex * Roll: Slave * Placa: Arduino UNO R3 * Comandos: 0x01 - Encender led * 0x02 - Apagar led * 0x03 - leer temperatura * 0x04 - leer humedad */ #include <SoftwareSerial.h> #include <DHT.h> // Trama maestro-esclavo #define HEAD 0xAA #define MY_SLAVE_ID 0x23 #define TAIL 0xFE //Comandos soportados #define CMD_LED_ON 0x01 #define CMD_LED_OFF 0x02 #define CMD_READ_TEMP 0x03 #define CMD_READ_HUMED 0x04 // Formato de Trama: <HEAD> <SLAVE_ID> <CMD> <TAIL> // Ejemplo: 0xFF 0x34 0x01 0xFE -> Indica que el esclavo 0x34 debe ejecutar la orden 0x01 #define DHT_GND 2 // tierra dht11 #define DHT_VCC 4 // alimentacion dht11 #define DHT_PIN 3 // comunicacion dht11 #define RS485_PIN_MODE 9 // HIGH -> Transmision; LOW-> recepcion SoftwareSerial RS485(10, 8); // RX, TX DHT dht(DHT_PIN, DHT11); byte buff[5], idx; float temperatura, humedad; void enviarRespuesta( float x ){ buff[0] = HEAD; buff[1] = MY_SLAVE_ID; buff[2] = (byte)x; buff[3] = TAIL; digitalWrite( RS485_PIN_MODE, HIGH ); // poner en modo Tx RS485.write( buff, 4 ); // transmitir mensaje RS485.flush(); digitalWrite( RS485_PIN_MODE, LOW); // poner en modo Rx } void ejecutarComando(){ Serial.println("Ejectutando comando!!!"); if ( buff[1] != MY_SLAVE_ID ) // el mensaje es para otro esclavo return; switch( buff[2] ){ // ejecutar comando case CMD_LED_ON: // Encender Led digitalWrite( LED_BUILTIN, HIGH ); break; case CMD_LED_OFF: // Apagar Led digitalWrite( LED_BUILTIN, LOW ); break; case CMD_READ_TEMP: temperatura = dht.readTemperature(); // grados Celcius enviarRespuesta( temperatura ); break; case CMD_READ_HUMED: humedad = dht.readHumidity(); enviarRespuesta( humedad ); break; default: // Comando Inva'lido break; } } void setup() { // Configurar Serial a 19200 baudios (para el monitor serie) Serial.begin(19200); // Configurar para utilizar el bus 485 a 9600 RS485.begin(9600); // configrar pines pinMode( LED_BUILTIN, OUTPUT ); pinMode( RS485_PIN_MODE, OUTPUT ); pinMode( DHT_VCC, OUTPUT ); pinMode( DHT_GND, OUTPUT ); // encender dht11 digitalWrite( DHT_VCC, HIGH ); digitalWrite( DHT_GND, LOW ); digitalWrite( LED_BUILTIN, LOW ); // apagar led digitalWrite( RS485_PIN_MODE, LOW );// poner en modo de recepcion dht.begin(); idx = 0; } void loop() { if( !RS485.available() ) return; byte incoming = RS485.read(); Serial.print("Recibido: "); Serial.println(incoming); if( idx == 0 ){ // principio de trama if( incoming != HEAD ) // trama incorrecta return; buff[idx] = incoming; idx++; } else if ( idx > 0 && idx < 4 ){ // buff[idx++] = incoming; // if ( idx == 4 ){ // fin de trama if( buff[3] == TAIL ) // verificar que termine bien ejecutarComando(); idx = 0; } } } |
En la siguiente imagen puedes ver el resultado obtenido en el monitor serie después de realizar algunas consultas de temperatura y humedad realizadas desde el maetro.
Comunicación full-duplex con Arduino y RS-485
Hay ocasiones donde se requiere que dos Arduinos se conecten entre ellos. Cuando es una aplicación simple donde solo intervienen dos Arduinos se puede hacer a través del puerto serie o incluso conectar dos Arduinos por I2C.
Esto es válido para cualquier Arduino: Arduino Nano, Arduino UNO, Arduino MEGA o el que sea.
Estas dos configuraciones son válidas si las placas están cerca una de otra. A grandes distancias la señal se ve afectada por interferencias en los cables.
Si lo que necesitas es comunicar a grandes distancias, una opción es utilizar el bus RS-485 en una configuración full-duplex.
Para esta configuración se necesitan 4 módulos MAX485, dos para cada Arduino. Se deben conectar tal y como se muestra en la siguiente imagen.
Como puedes ver, cada Arduino cuenta con dos módulos MAX485: uno configurado como transmisor y otro como receptor. Es importante destacar que esta variante además de utilizar 4 módulos MAX485 requiere del uso de dos pares trenzados.
Es necesario ser cuidadoso a la hora de conectar los cables que comunican un sistema con el otro:
- Lo primero a tener en cuenta es que los cables que salen del transmisor del primer sistema se conectan al receptor del segundo.
- Igualmente, los cables del receptor del primer sistema se conectan con el transmisor del segundo.
Como en esta configuración no existe maestro ni esclavo, no es necesario esperar ningún comando para comenzar a transmitir.
El siguiente código muestra cómo hacer que un dispositivo envíe al otro la lectura de la entrada analógica A1 cada 3 segundos.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
void setup() { Serial.begin(9600); } // the loop routine runs over and over again forever: void loop() { delay(3000); int raw = analogRead(A1); Serial.println(raw); } |
Más fácil imposible.
Y con esto damos por terminado este artículo sobre el RS-485, el módulo MAX485 y cómo utilizarlo con Arduino.
Resumen RS-485 y MAX485 comunicación serie entre Arduinos
El tutorial ha empezado explicando que es el bus RS-485. Se trata de un protocolo de comunicación serie que nos permite enviar y recibir información con diferentes configuraciones.
Los modos de comunicación que utiliza el RS-485 son:
- Simplex
- Half-duplex
- Full-duplex
El primer modo, el simplex, sólo permite enviar o recibir información. El segundo modo, el half-duplex permite enviar y recibir información pero no al mismo tiempo. El modo full-duplex permite enviar y recibir información al mismo tiempo.
También hemos visto las diferentes topologías de red que se pueden utilizar con el bus RS-485:
- Bus con derivaciones
- Anillo
- Estrella
- Daisy chain (conexión en cadena)
Elegir una u otra dependerá de cada aplicación.
Uno de los circuitos integrados más populares que se utilizan para implementar el bus RS-485 es el MAX485. Este chip es muy económico y normalmente lo encontrarás en un módulo listo para ser usado con Arduino.
Algo importante a tener en cuenta es que el MAX485 no es compatible con el ESP8266. Deberás utilizar un adaptador de niveles lógicos.
Por último, has visto diferentes códigos para trabajar con el bus RS-485 y Arduino y así poder conectar varias placas de Arduino en un mismo bus.
Espero haya sido entretenido y cualquier consulta en los comentarios de aquí abajo.