Redes Industriales

12 de Junio del 2019

UNIVERSIDAD DE LAS FUERZAS

ARMADAS ESPE

CARRERA: MECATRÓNICA

TEMA :
Arquitectura maestro/esclavo con Modbus TCP/IP

INTEGRANTES:

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. Modbus TCP/IP...........................................................................................................................3
3.2. RS-485.........................................................................................................................................4
3.3. Adaptador USB a RS-485............................................................................................................4
3.4. Acceso a características del protocolo MODBUS........................................................................5
4. MATERIALES....................................................................................................................................6
5. DESARROLLO...................................................................................................................................6
6. CONCLUSIONES...............................................................................................................................8
7. BIBLIOGRAFÍA.................................................................................................................................9
8. ANEXOS...........................................................................................................................................10
8.1. Programación Arduino:..............................................................................................................10
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. Modbus TCP/IP

MODBUS TCP / IP es una variante de la familia MODBUS de protocolos de

comunicación simples y neutrales para la supervisión y el control de equipos de
automatización. Específicamente, cubre el uso de mensajes MODBUS en un entorno de
'Intranet' o 'Internet' utilizando los protocolos TCP / IP, como un estándar de
automatización ("de facto"). Dado que MODBUS ya es ampliamente conocido, debe
haber poca información en este documento que no pueda obtenerse en otro lugar. Sin
embargo, se ha intentado aclarar qué funciones dentro de MODBUS tienen valor para la
interoperabilidad del equipo de automatización general y qué partes son "equipaje" del
uso alternativo de MODBUS como protocolo de programación para PLC[ CITATION
Nat18 \l 12298 ]
 Figura 1. Funcionamiento Modbus TCP/IP en la industria

3.2. 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.3. 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 2. Comunicación RS-485 y Modbus

3.4. 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

5. DESARROLLO
En la figura 3, se muestra el diagrama de comunicación maestro/esclavo por medio de
dos arduinos en donde el maestro en este caso será el PC va 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 software en el computador, se debe configurar la
dirección IP del equipo para comunicación por Wifi.

Figura 3. Diagrama de comunicación maestro/esclavo

 Se ha define una estructura genérica para la trama del protocolo conocida como
PDU.
 Se encapsula la PDU en una red TCP/IP.
 Realizar un usuario cuando usa Modbus TCP, asignando una dirección IP del
equipo y adicional la dirección del esclavo con el que se va a comunicar.
 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
 En Modbus TCP/IP es la estructura de la trama se hacen algunos ajustes propios
de las nuevas capas del modelo OSI que se están incluyendo.
 Al encapsularse sobre TCP/IP aparece en la trama un campo nuevo MBAP
Header.
 Modbus lleva mucho tiempo desde su creación y ha sufrido una evolución
evidente hasta tener una versión basada en Ethernet, es tan popular en el
ambiente industrial que no creo que pierda su posición dominante en un futuro
 Es un Protocolo abierto con el cual se pueden obtener competencias genéricas
acerca del funcionamiento de las redes industrial.
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
National Instruments. (2018). Obtenido de https://www.ni.com/es-es/innovations/white-
papers/14/the-modbus-protocol-in-depth.html
8. ANEXOS
8.1. Programación Arduino:
#include <LiquidCrystal.h> char SMS2[5];
#include <String.h> char received[200];
#include <stdio.h>
#include <stdlib.h> #include <SimpleModbusSlave.h>
//#include <SoftwareSerial.h> enum{
LiquidCrystal lcd(26, 27, 28, 29, 30, 31); REG1,
//SoftwareSerial mySerial(9, 10); // RX, TX REG2,
TOTAL_ERRORS,
int dato=0,inByte=0; TOTAL_REGS_SIZE
char datoc=0; };
unsigned int registros[ TOTAL_REGS_SIZE ];
char SMS[200];
char SMS1[5]; #define SLAVE_ID 2
char SMS2[5]; #define SLAVE_EN 2
char received[200];
void setup()
#include <SimpleModbusSlave.h> {
enum{ modbus_configure( 9600, SLAVE_ID, SLAVE_EN,
REG1, TOTAL_REGS_SIZE, 0 );//modbus_configure( 9600, 2, 2,
REG2, TOTAL_REGS_SIZE, 0 );
TOTAL_ERRORS, }
TOTAL_REGS_SIZE
}; int t1=0,t2=0;
unsigned int registros[ TOTAL_REGS_SIZE ];
void loop(){
#define SLAVE_ID 1
#define SLAVE_EN 2 if(digitalRead(8)==HIGH){
t1=1;
void setup() }else{
{ t1=0;
}
pinMode(8,OUTPUT); //int pot = map(analogRead(0),0,1024,0,255);
modbus_configure( 9600, SLAVE_ID, SLAVE_EN, //int pot1 = map(analogRead(1),0,1024,0,255);
TOTAL_REGS_SIZE, 0 );//modbus_configure( 9600, 2, 2,
TOTAL_REGS_SIZE, 0 ); registros[ TOTAL_ERRORS ] = modbus_update( registros
} );
registros[ REG1 ] = t1;//registros[ REG1 ] = t1;
int t1=0,t2=0; registros[ REG2 ] = 125;//registros[ REG2 ] = t2;
}
void loop(){ #include <LiquidCrystal.h>
#define MAX485_EN 2
#include <ModbusMaster.h>
if (digitalRead(9) == HIGH){ ModbusMaster esclavo1, esclavo2;
t2=1;
digitalWrite(8,HIGH);
}else{ const int rs = 6, en = 7, d4 = 8, d5 = 9, d6 = 10, d7 = 11;
digitalWrite(8,LOW); LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
t2=0; uint8_t switch1;
}
void preTransmission(){
digitalWrite(MAX485_EN, 1);
}

registros[ TOTAL_ERRORS ] = modbus_update( registros void postTransmission(){

); digitalWrite(MAX485_EN, 0);
registros[ REG1 ] = analogRead(A0);//registros[ REG1 ] = }
t1;
registros[ REG2 ] = t2;//registros[ REG2 ] = t2; void setup(){
}

#include <LiquidCrystal.h> lcd.begin(16, 2);

#include <String.h> // Print a message to the LCD.
#include <stdio.h> lcd.print("hello, world!");
#include <stdlib.h>
LiquidCrystal lcd(26, 27, 28, 29, 30, 31); pinMode(3,OUTPUT);
pinMode(MAX485_EN, OUTPUT);
int dato=0,inByte=0; // Init in receive mode
char datoc=0; digitalWrite(MAX485_EN, 0);

char SMS[200]; // Modbus communication runs at 9600 baud

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

} delay(50);
else{ //lcd.setCursor(8,0);
Serial.write( 'e' ); Serial.print( result ); Serial.println( 'x' ); //lcd.print(" ");
} }
lcd.setCursor(0,0);