The list of different benefits these two offerings is long, but what if you need both?

Modbus TCP is an excellent way to transfer data between the two programs. Modbus is an easy to deploy protocol that enables multiple devices on the same network to communicate. To set up Modbus Communication in TIA Portal, drag an “MB_Server” block to the Main[OB1]. This will be the only rung you need in Main [OB1].

You will need to create a data block for holding registers, which contain the information you are trying to send and receive. Mine is named “dbHoldingRegisters” and I filled it with an array of random values to send to LabVIEW.

You will also need space in a data block to save configuration information to connect using Modbus. The data block should be of type TCON_IP_v4, which includes all address parameters required for establishing a connection. Details on how to populate this are listed below.

• InterfaceID: This references hardware identifier number, found in “Devices and Networks”, pictured below.
  

  

• ID: A unique ID for the connection within the CPU ranging from 1 to 4095. If you have multiple “MB_Server” blocks, they will each need unique numbers.
• Connection Type: 11 is for TCP connections
• Active Established: Select false for passive connection establishment.
• Remote Address: The default address is 0.0.0.0 (any IP address), but you can enter a specific IP address so that the server only responds to requests from this address. For example, if the IP address of my computer is 192.168.0.73, the addresses will be.
  • addr[1] = 192
  • addr[2] = 168
  • addr[3] = 0
  • addr[4] = 73
• Remote Port: This is the incoming tunnel port number of the remote connection partner (value range: 1 to 49151) or 0 for any.
• Local Port: This is the outgoing port number of the local connection partner (value range: 1 to 49151), 502 is the default. A Modbus client (LabVIEW) sends its messages on the port 502, and a Modbus server (PLC) receives messages on 502.

On the LabVIEW side, the code is straightforward. All VIs are taken from the Modbus Master.lvclass and are listed below. You will need to create a TCP connection to the IP address of the PLC as well as use the same local port number (502) in your “serverData” data block. Then, you can write and read registers as you choose. As always, make sure to close the connection when you are done.

In this example, the value 999 was written to address 0, and then all the holding register values were read and populated in the “register values” indicator. And Voila! The random array of values we sent from the PLC has been transmitted successfully. You are now reading and writing data from LabVIEW to a PLC.

Happy programming!

Learn more about DMC's LabVIEW Programming services and contact us with any project inquiries!

The post Communicating Between a Siemens PLC and LabVIEW Using Modbus TCP appeared first on DMC, Inc..

Easy, right? Many PLCs already support RS485 and Modbus communication and only require a few functions blocks.

There is a twist, however. The devices with which the PLC is communicating are Arduinos. Lots of them.

So, how can you program an Arduino to act as a Modbus device?

Turns out the answer is easy.

In this post, I’ll talk about adding an Arduino to an RS485 network and programming it to function as a Modbus slave device.

How an Arduino can Speak over an RS485

First, let’s talk about Arduino and RS485.

Although Arduino supports serial communication through its built-in UART (Universally Asynchronous Receiver/Transmitter), it uses TTL (Transistor-Transistor Logic), not RS485. Both signaling types use serial communication. Serial communication means data is sent one bit at a time at a specified BAUD rate (bits per second). 

However, TTL is single-ended, whereas RS485 relies on a differential signal (what’s the difference?). This is far more useful in an industrial setting where signals can be influenced by electrical noise, and devices can be separated dozens or hundreds of meters.

To allow an Arduino to speak over an RS485 network, an additional device must be used to convert TTL to RS485. There are several devices on the market that do this, but I used this RS485 Transceiver Breakout Board.

Hardware Set-Up and Serial Ports

This picture shows my hardware setup.

Because I’m using an Arduino Mega, 4 serial ports available. If you are unsure how many ports you have, the Arduino website provides a description of serial ports on all board models.

Did you run out of Serial ports? Don’t forget about Software Serial!

Great! Your Arduino is now networked to the PLC (or another master device) and other non-master devices.

Installing Arduino IDE

Next is software. I’ll be using the Arduino IDE for software development.

Although Modbus was developed in 1979, it has stood the test of time and is proven to still a reliable industrial communication protocol. You may choose to write your own C++ library implementation of Modbus, but I opted to use a prewritten library.

A quick Google search yields several options. I chose this one.

Include ModbusRtu Library

The first step is to include the ModbusRtu library in your sketch.

The Modbus constructor takes three parameters:

1. Slave Address – this is the Modbus address that the master device will use to make specific queries. In other words, it’s how other devices in the network know who is talking. The address can be any number between 1 and 247; address 0 is reserved for the master. It’s important to ensure there are no duplicate addresses on the network.

2. Serial Port – this tells the library which Serial port to use. Here is the list of options, depending on the number of ports available on your Arduino model:

   0 = Serial

   1 = Serial1

   2 = Serial2

   3 = Serial3

   4 = SoftwareSerial

3. TX Enable Pin – because this is a 2-wire RS485 network, it is only half duplex. Half duplex means that a device can only receive or transmit at a time. By default, the Arduino is in receive mode. Setting the TX enable pin high allows the Arduino to transmit data.

Modbus_array Example

Below is example code that shows how we can use our newly created RS485 network and Modbus library using a very simple (and probably unrealistic) scenario.

In this scenario, our Arduino is hooked up to a toggle switch and an LED. We have an operator who wants to know the state of the switch (on or off) and the ability to remotely toggle the LED. What should we do?

First, look at how the Modbus library function that allows for reading and writing:

Modbus::poll(uint16_t *regs, uint8_t u8size)

Modbus::poll(uint16_t *regs, uint8_t u8size)

*regs is a register table used for communication exchange, and u8size is the size of the register table.

This method checks if there is an incoming query in its serial buffer. If there is, the library will validate the message (check the device address, data length, and CRC) and subsequently perform the correct function.

In other words, to use this function, we must pass it an unsigned 16-bit integer array and its length. The array will contain the data that the master device is reading or writing over.

For this simple example, I created an array called modbus_array that contains two elements.

1. The first is a status bit for the LED. If the value of the first element is 0, the LED will turn off; otherwise, it will be on.
2. The second element will be the state of the switch.

Now, let’s look at this from the perspective of the master device.

Toggling the LED

1. To toggle the LED, it must send a Modbus message to slave address 1 that writes a single holding register (Modbus function #6) to the first element with a value of 0 or 1.
2. To read the toggle switch, it must send a message that reads holding registers (Modbus function #3) starting at the second element with a length of 1. The Arduino will respond with the second element.

// Includes
#include <ModbusRtu.h>

// Defines
#define LED_PIN 5
#define SWITCH_PIN 6

// Global variables
Modbus modbus_port;

// Modbus registers:
// [0] = LED control
// [1] = Switch state
uint16_t modbus_array[] = {0, 0};

void setup()
{
    // Create Modbus slave:
    // (slave ID = 1, serial port = 1, TX enable pin = 7)
    modbus_port = Modbus(1, 1, 7);

    // Start Modbus communication
    modbus_port.begin(9600);

    pinMode(LED_PIN, OUTPUT);
    pinMode(SWITCH_PIN, INPUT);
}

void loop()
{
    // Process Modbus requests
    modbus_port.poll(
        modbus_array,
        sizeof(modbus_array) / sizeof(modbus_array[0])
    );

    // Register 0 controls the LED
    if (modbus_array[0] == 0)
    {
        digitalWrite(LED_PIN, LOW);
    }
    else
    {
        digitalWrite(LED_PIN, HIGH);
    }

    // Register 1 reports the switch state
    modbus_array[1] = digitalRead(SWITCH_PIN);
}

// Includes
#include <ModbusRtu.h>

// Defines
#define LED_PIN 5
#define SWITCH_PIN 6

// Global variables
Modbus modbus_port;

// Modbus registers:
// [0] = LED control
// [1] = Switch state
uint16_t modbus_array[] = {0, 0};

void setup()
{
    // Create Modbus slave:
    // (slave ID = 1, serial port = 1, TX enable pin = 7)
    modbus_port = Modbus(1, 1, 7);

    // Start Modbus communication
    modbus_port.begin(9600);

    pinMode(LED_PIN, OUTPUT);
    pinMode(SWITCH_PIN, INPUT);
}

void loop()
{
    // Process Modbus requests
    modbus_port.poll(
        modbus_array,
        sizeof(modbus_array) / sizeof(modbus_array[0])
    );

    // Register 0 controls the LED
    if (modbus_array[0] == 0)
    {
        digitalWrite(LED_PIN, LOW);
    }
    else
    {
        digitalWrite(LED_PIN, HIGH);
    }

    // Register 1 reports the switch state
    modbus_array[1] = digitalRead(SWITCH_PIN);
}

Conclusion

Arduinos are usually confined to hobbyist and educational markets because of their low barrier to entry, but this also makes them ideal candidates for prototyping, even in the industrial automation space.

Do you have a low fidelity project that could use some low-cost microcontrollers? Check out our Embedded Development and Programming service area to find out if DMC could be good fit for you! Or, Contact Us to get started on a solution today.

The post Turning an Arduino into a Modbus Device appeared first on DMC, Inc..