Redes Industriales

12 de Junio del 2019

UNIVERSIDAD DE LAS FUERZAS

ARMADAS ESPE

CARRERA: MECATRÓNICA

TEMA :
Arquitectura maestro/esclavo con adaptador USB a RS485 Modbus

NIVEL : OCTAVO
PARALELO : B

MARZO 2019 – JULIO 2019

CONTENIDO

1. TEMA.................................................................................................................................................3
2. OBJETIVOS........................................................................................................................................3
2.2. Objetivos específicos...................................................................................................................3
3. MARCO TEÓRICO............................................................................................................................3
3.1. RS-485.........................................................................................................................................3
3.2. Adaptador USB a RS-485............................................................................................................3
3.3. Acceso a características del protocolo MODBUS........................................................................4
4. MATERIALES....................................................................................................................................5
5. DESARROLLO...................................................................................................................................6
6. CONCLUSIONES...............................................................................................................................7
7. BIBLIOGRAFÍA.................................................................................................................................8
8. ANEXOS.............................................................................................................................................9
8.1. Programación Arduino:................................................................................................................9
1. TEMA

Arquitectura maestro/esclavo con adaptador USB a RS485 Modbus

2. OBJETIVOS

2.1. Objetivo general

Realizar una comunicación maestro/esclavo entre arduinos utilizando el protocolo

Modbus, con un adaptador USB a RS485

2.2. Objetivos específicos

 Investigar sobre el protocolo de comunicación Modbus.

 Investigar sobre el adaptador USB a RS485.
 Realizar una comunicación maestro y dos arduinos esclavo utilizando el
protocolo de comunicación Modbus y un adaptador USB a RS485.

3. MARCO TEÓRICO

3.1. RS-485

El estándar RS-485 define un bus para la transmisión serie multipunto, donde, en un

instante, puede haber un equipo transmitiendo y varios recibiendo. La comunicación es
semiduplex, de forma un equipo puede enviar y recibir, pero no a la vez. El cableado
básico consiste en un par de hilos de cobre trenzados sobre el que se transmite una señal
diferencial para enviar los bits de datos, que es bastante inmune a las interferencias y
admite largas distancias. Además del par trenzado para datos, pueden usarse líneas de
0V y 5V para alimentar dispositivos del bus. Los bits se transmiten mediante una trama
asíncrona.[ CITATION Nay16 \l 12298 ]
3.2. Adaptador USB a RS-485

El conversor USB a RS485 integra un conversor USB a serial TTL (CH340) y un chip
serial a RS485 (MAX485). El conversor USB a RS485 permite establecer
comunicación entre una PC (USB).
El estándar RS485 también llamado EIA-485 es muy utilizado por equipos industriales
de instrumentación y control: Variadores de velocidad, PLC, Pirómetros. El
estándar RS485 está definido como un sistema de comunicación en bus de transmisión
multipunto diferencial, es ideal para transmitir a velocidades medianas 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 al emplear voltajes diferenciales reduce los ruidos eléctricos que
aparecen en la línea de transmisión. El medio físico de transmisión (cableado) es el
cable par trenzado que admite hasta 32 estaciones en 1 solo bus, con una longitud
máxima de 1200 metros operando entre 300 y 19200 bit/s bajo comunicación half-
duplex (semiduplex).[ CITATION Nor12 \l 12298 ]

Figura 1. Comunicación RS-485 y Modbus

3.3. Acceso a características del protocolo MODBUS

 Si se desea acceder a toda la información de estado de un canal E/S del PLC, es

necesario definir una variable IODDT.
 A través de los campos de esa variable se pude acceder al estado del canal, para
detectar posibles errores, o para cambiar alguna configuración durante la
ejecución del programa.
 Es necesario recurrir a un acceso directo e inmediato a las variables del módulo.
 Para realizar un intercambio explícito en un M340, se dispone de dos funciones:
READ_STS para lectura de palabras de estado y WRITE_CMD para escritura
de palabras de comando.
 Las instrucciones READ_STS y WRITE_CMD se ejecutan al mismo tiempo
que la tarea que las llama y siempre correctamente, y su resultado queda
disponible automáticamente después de su ejecución.[ CITATION Ele15 \l 12298 ]
4. MATERIALES

Tabla 1.Materiales y descripción

Material Descripción Gráfico

Placa electrónica basada

Arduino en el microcontrolador
ATmega328.

Placa de pruebas en los

que se pueden insertar
Protoboard
elementos electrónicos
y cables.

Diseñado para
introducir
una resistencia eléctrica
Resistencia determinada entre dos
puntos de un circuito
eléctrico.

Instrumento para medir

Potenciómetro las diferencias de
potencial eléctrico.

Un interruptor eléctrico 
es un dispositivo que
Switch permite desviar o
interrumpir el curso de
una corriente eléctrica.

LED Un diodo emisor de luz.

Interconectar entre sí los

Cables de conexión
componentes

Módulo para realizar la

Módulo 485 conexión entre las
tarjetas

Convertidor de USB a
Adaptador USB
RS-485
5. DESARROLLO
En la figura 2, se muestra el diagrama de comunicación maestro/esclavo por medio de
tres arduinos en donde el maestro va a enviar distintas condiciones a cada uno de los
arduinos esclavos, el esclavo 1 tendrá un potenciómetro y un switch, esclavo 2 indicará
el estado de un led, la variación del potenciómetro y el estado del switch será mostrado
por medio de un PC, conectado por medio de un adaptador USB a RS485

Figura 2. Diagrama de comunicación maestro/esclavo

Realizar la programación para el maestro, esclavo 1 y esclavo 2 en Arduino.

Ingresar las variables en el programa KEPServerEX 6

Crear un nuevo proyecto en Labview

Realizar el HMI en el Labview, programando el block diagram y realizando la
visualización en el panel frontal.

6. CONCLUSIONES
 Modbus es un Protocolo monomestro, es decir que a pesar de tener 32 equipos
solo puede estar un maestro al tiempo estableciendo la comunicación con el
esclavo que él seleccione.
 Utilizando RS485 como capa física es posible implementar un bus de campo
industrial tipo MODBUS para comunicación entre equipos industriales o DMX
para el control de luces entre otras aplicaciones.
 El módulo permite usar el estándar RS-485 y MODBUS para comunicarse con
otros dispositivos que lo soporten,: usando un par de cobre trenzado conectado a
la bornera o usando un cable DB9.
7. BIBLIOGRAFÍA

Normas de comunicación en serie. (2012). Obtenido de

http://www.unilibre.edu.co/revistaingeniolibre/revista-11/art13.pdf
Electronilab. (2015). Obtenido de https://electronilab.co/tienda/convertidor-usb-rs485/
Naylap. (2016). Obtenido de https://naylampmechatronics.com/conversores-ttl/230-
conversor-usb-rs485.html
8. ANEXOS
8.1. Programación Arduino:
Maestro

#include <LiquidCrystal.h> uint8_t result;

#define MAX485_EN 2
#include <ModbusMaster.h> // Read 2 registers starting at 0x0000)
ModbusMaster esclavo1, esclavo2; result = esclavo1.readHoldingRegisters( 0x0000,
const int rs = 6, en = 7, d4 = 8, d5 = 9, d6 = 10, d7 = 2 );
11; Serial.write( 'a' ); Serial.write( '\t' );
LiquidCrystal lcd(rs, en, d4, d5, d6, d7); if( result == esclavo1.ku8MBSuccess ){
uint8_t switch1; Serial.write( 'a' );
Serial.print( esclavo1.getResponseBuffer( 0x00 ));
void preTransmission(){ Serial.write( '\t' );
digitalWrite(MAX485_EN, 1); Serial.write( 'b' );
} Serial.print( esclavo1.getResponseBuffer( 0x01 ));
void postTransmission(){ Serial.println( 'x' );
digitalWrite(MAX485_EN, 0); }
} else{
Serial.write( 'e' ); Serial.print( result );
void setup(){ Serial.println( 'x' );
lcd.begin(16, 2); }
// Print a message to the LCD.
lcd.print("hello, world!"); delay(50);

pinMode(3,OUTPUT); // Read 2 registers starting at 0x0000)

pinMode(MAX485_EN, OUTPUT); result = esclavo2.readHoldingRegisters( 0x000, 2 );
// Init in receive mode Serial.write( 'b' ); Serial.write( '\t' );
digitalWrite(MAX485_EN, 0); if( result == esclavo2.ku8MBSuccess ){
Serial.write( 'a' );
// Modbus communication runs at 9600 baud Serial.print( esclavo2.getResponseBuffer( 0x00 ));
Serial.begin( 9600 ); Serial.write( '\t' );
// Serial3.begin( 9600 ); Serial.write( 'b' );
//Serial2.begin(9600); Serial.print( esclavo2.getResponseBuffer( 0x01 ));
Serial.println( 'x' );
// Modbus slave ID 1 switch1 = esclavo2.getResponseBuffer( 0x00 );
esclavo1.begin(1, Serial); if(switch1==1){
esclavo2.begin(2, Serial); digitalWrite(3,HIGH);
}else{
digitalWrite(3,LOW);
// Callbacks allow us to configure the RS485
}
transceiver correctly
esclavo1.preTransmission(preTransmission);
esclavo1.postTransmission(postTransmission); }
esclavo2.preTransmission(preTransmission); else{
esclavo2.postTransmission(postTransmission); Serial.write( 'e' ); Serial.print( result );
lcd.clear(); Serial.println( 'x' );
} }
lcd.setCursor(0,0);
void loop(){ lcd.print("pote= ");
//lcd.clear(); //lcd.setCursor(7,0);
 //lcd.print(esclavo1.getResponseBuffer( 0x00 )); //lcd.print(esclavo1.getResponseBuffer( 0x01 ));
if(esclavo1.getResponseBuffer( 0x00 )<10){ if(switch1==1){
lcd.setCursor(5,0); lcd.setCursor(15,0);
lcd.print("000"); lcd.print(" ");
lcd.print(esclavo1.getResponseBuffer( 0x0 lcd.setCursor(13,0);
0 )); lcd.print("on");
} }else{
if(esclavo1.getResponseBuffer( 0x00 )>9 lcd.setCursor(13,0);
&& esclavo1.getResponseBuffer( 0x00 )<100 ){ lcd.print("off");
lcd.setCursor(5,0); }
lcd.print("00"); //=====================
lcd.print(esclavo1.getResponseBuffer( 0x0 lcd.setCursor(0,1);
0 )); lcd.print(" Button= ");
} lcd.setCursor(9,1);
if(switch1==1){
if(esclavo1.getResponseBuffer( 0x00 )>100 //lcd.setCursor(,1);
&& esclavo1.getResponseBuffer( 0x00 )<1000 ){ //lcd.print(" ");
lcd.setCursor(5,0);
lcd.print("0"); //lcd.setCursor(13,1);
lcd.print(esclavo1.getResponseBuffer( 0x0 lcd.print("yes");
0 )); }else{
} //lcd.setCursor(13,1);
if(esclavo1.getResponseBuffer( 0x00 ) lcd.print("no");
>1000){ }
lcd.setCursor(5,0); //===========================
lcd.print(esclavo1.getResponseBuffer( 0x0
0 )); delay(50);
} //lcd.setCursor(8,0);
//lcd.print(" ");
lcd.setCursor(9,0); }
lcd.print("led= ");

Esclavo 1
#include <LiquidCrystal.h> #define SLAVE_ID 1
#include <String.h> #define SLAVE_EN 2
#include <stdio.h> void setup()
#include <stdlib.h> {
//#include <SoftwareSerial.h> pinMode(8,OUTPUT);
LiquidCrystal lcd(26, 27, 28, 29, 30, 31); modbus_configure( 9600, SLAVE_ID, SLAVE_EN,
//SoftwareSerial mySerial(9, 10); // RX, TX TOTAL_REGS_SIZE, 0 );//modbus_configure( 9600, 2, 2,
TOTAL_REGS_SIZE, 0 );
int dato=0,inByte=0; }
char datoc=0; int t1=0,t2=0;
void loop(){
char SMS[200]; if (digitalRead(9) == HIGH){
char SMS1[5]; t2=1;
char SMS2[5]; digitalWrite(8,HIGH);
char received[200]; }else{
digitalWrite(8,LOW);
#include <SimpleModbusSlave.h> t2=0;
enum{ }
REG1, registros[ TOTAL_ERRORS ] = modbus_update( registros
REG2, );
TOTAL_ERRORS, registros[ REG1 ] = analogRead(A0);//registros[ REG1 ] =
TOTAL_REGS_SIZE t1;
}; registros[ REG2 ] = t2;//registros[ REG2 ] = t2;
unsigned int registros[ TOTAL_REGS_SIZE ]; }

Esclavo 2
#include <LiquidCrystal.h> char SMS[200];
#include <String.h> char SMS1[5];
#include <stdio.h> char SMS2[5];
#include <stdlib.h> char received[200];
LiquidCrystal lcd(26, 27, 28, 29, 30, 31);
#include <SimpleModbusSlave.h>
int dato=0,inByte=0; enum{
char datoc=0; REG1,
REG2,
 TOTAL_ERRORS,
TOTAL_REGS_SIZE
};
unsigned int registros[ TOTAL_REGS_SIZE ];
#define SLAVE_ID 2
#define SLAVE_EN 2

void setup()
{
modbus_configure( 9600, SLAVE_ID, SLAVE_EN,
TOTAL_REGS_SIZE, 0 );//modbus_configure( 9600, 2, 2,
TOTAL_REGS_SIZE, 0 );
}

int t1=0,t2=0;

void loop(){

if(digitalRead(8)==HIGH){
t1=1;
}else{
t1=0;
}
//int pot = map(analogRead(0),0,1024,0,255);
//int pot1 = map(analogRead(1),0,1024,0,255);

registros[ TOTAL_ERRORS ] = modbus_update( registros

);
registros[ REG1 ] = t1;//registros[ REG1 ] = t1;
registros[ REG2 ] = 125;//registros[ REG2 ] = t2;
}