1. Home
  2. Knowledge Base
  3. MODBUS registers Input and Output handling via port 502.

MODBUS registers Input and Output handling via port 502

 

Application Description:
This example shows the use of internal MODBUS Input-Output registers on the Universal-Robots.

The application uses the MODBUS server running at port 502 on the Universal-Robots. The MODBUS server has a range of register available with dedicated content and register 128 to 255 are for general purpose use. In this example register 0 (Inputs) and register 1 (Outputs) will be used.

A list of the MODBUS and register can be found at this link UR Modbus page

The commands are send from a external host with Python code.

 

Function description:
The external host (PC) is connected to the UR via Ethernet and access the MODBUS registers on the UR on TCP port 502.

 

Program description:
The external host first reads the physical hardware inputs and outputs on the UR and displays the results on the host screen.
Then the host sets all outputs on the UR to 0 and wait 1 second.
Then the host set output number 2 (bit 3 i.e. value 04 = 0100) to high.

 

Program code:
There is no program on UR. Instead the inputs and outputs are set to a random value in order to test the result on the host.

In this case Input 0, 1 and 7 is set to high. And out put 2 is set to high. Rest is set to zero.

universal-robots-zacobria-modbus-input-output-handling-1

 

Host program in Python code.

import socket
import time
import binascii

HOST = "192.168.0.9"            # The Robot IP address
PORT_502 = 502                  # The MODBUS Port on the robot

print "Starting Program"
count = 0
program_run = 0

while (True):
    if 1 == 1:
        if program_run == 0:
            try:
                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                s.settimeout(10)
                s.connect((HOST, PORT_502))
                time.sleep(0.05)
                print ""
                print "Modbus Read inputs"
                print "Sending: x00 x01 x00 x00 x00 x06 x00 x03 x00 x00 x00 x01"
                s.send ("\x00\x01\x00\x00\x00\x06\x00\x03\x00\x00\x00\x01")

                msg = s.recv(1024)
                print "Raw received data = ", msg
                print "Received data as x format = ", repr(msg)         #Print the receive data in \x hex format (notice that data above 32 hex will be represented by the ascii code e.g. 50 will show P
                print ""
                msg = msg.encode("hex") #Convert the data from \x hex format to plain hex
                print "Hex data received = ", msg

                print "Strip downto last two bytes"
                byte_1_in = msg[21]
                byte_2_in = msg[20]
                print "byte_1_in = ", byte_1_in
                print "byte_2_in = ", byte_2_in

                byte_1_bin_in = bin(int(byte_1_in, 16))     #convert hex to bin
                print "Binary value of input byte 1 = ", byte_1_bin_in
                byte_1_bin_in = byte_1_bin_in[2:].zfill(4)  #get rid of the 0b and fill with zeros so byte take 4 positions
                print "Remove 0b and make byte occupie 4 positions = ", byte_1_bin_in
                byte_2_bin_in = bin(int(byte_2_in, 16))     #convert hex to bin
                print "Binary value of input byte 2 = ", byte_2_bin_in
                byte_2_bin_in = byte_2_bin_in[2:].zfill(4)  #get rid of the 0b and fill with zeros so byte take 4 positions
                print "Remove 0b and make byte occupie 4 positions = ", byte_2_bin_in
                print ""
                print "Input 0 = ", byte_1_bin_in[3]
                print "Input 1 = ", byte_1_bin_in[2]
                print "Input 2 = ", byte_1_bin_in[1]
                print "Input 3 = ", byte_1_bin_in[0]
                print "Input 4 = ", byte_2_bin_in[3]
                print "Input 5 = ", byte_2_bin_in[2]
                print "Input 6 = ", byte_2_bin_in[1]
                print "Input 7 = ", byte_2_bin_in[0]


                print ""
                print "Modbus Read Outputs"
                print "Sending: x00 x01 x00 x00 x00 x06 x00 x03 x00 x01 x00 x01"
                s.send ("\x00\x01\x00\x00\x00\x06\x00\x03\x00\x01\x00\x01")

                msg = s.recv(1024)
                print "Raw received data = ", msg
                print "Received data as x format = ", repr(msg)         #Print the receive data in \x hex format (notice that data above 32 hex will be represented by the ascii code e.g. 50 will show P
                print ""
                msg = msg.encode("hex") #Convert the data from \x hex format to plain hex
                print "Hex data received = ", msg

                print "Strip downto last two bytes"
                byte_1_out = msg[21]
                byte_2_out = msg[20]
                print "byte_1_out = ", byte_1_out
                print "byte_2_out = ", byte_2_out

                byte_1_bin_out = bin(int(byte_1_out, 16))       #convert hex to bin
                print "Binary value of Output byte 1 = ", byte_1_bin_out
                byte_1_bin_out = byte_1_bin_out[2:].zfill(4)    #get rid of the 0b and fill with zeros so byte take 4 positions
                print "Remove 0b and make byte occupie 4 positions = ",byte_1_bin_out
                byte_2_bin_out = bin(int(byte_2_out, 16))       #convert hex to bin
                print "Binary value of Output byte 2 = ", byte_2_bin_out
                byte_2_bin_out = byte_2_bin_out[2:].zfill(4)    #get rid of the 0b and fill with zeros so byte take 4 positions
                print "Remove 0b and make output byte occupie 4 positions = ", byte_2_bin_out
                print ""
                print "Output 0 = ", byte_1_bin_out[3]
                print "Output 1 = ", byte_1_bin_out[2]
                print "Output 2 = ", byte_1_bin_out[1]
                print "Output 3 = ", byte_1_bin_out[0]
                print "Output 4 = ", byte_2_bin_out[3]
                print "Output 5 = ", byte_2_bin_out[2]
                print "Output 6 = ", byte_2_bin_out[1]
                print "Output 7 = ", byte_2_bin_out[0]
                                

                time.sleep(10.00)                               #Give time to read the read result before change output

                print ""
                print "Modbus set Outputs to 00"
                print "Sending: x00 x01 x00 x00 x00 x06 x00 x06 x00 x01 x00 x00"
                s.send ("\x00\x01\x00\x00\x00\x06\x00\x06\x00\x01\x00\x00")
                time.sleep(1.00)
                print ""
                print "Modbus set Outputs to 04 i.e. set output 2 on (third bit)"
                print "Sending: x00 x01 x00 x00 x00 x06 x00 x06 x00 x01 x00 x04"
                s.send ("\x00\x01\x00\x00\x00\x06\x00\x06\x00\x01\x00\x04")
                time.sleep(1.00)
                s.close()
                program_run = 0
            except socket.error as socketerror:
                print("Error: ", socketerror)
print "Program finish"

 

Program run:

 

>>> 
Starting Program

Modbus Read inputs
Sending: x00 x01 x00 x00 x00 x06 x00 x03 x00 x00 x00 x01
Raw received data = ####
Received data as x format =  '\x00\x01\x00\x00\x00\x05\x00\x03\x02\x00\x83'

Hex data received =  0001000000050003020083
Strip downto last two bytes
byte_1_in =  3
byte_2_in =  8
Binary value of input byte 1 =  0b11
Remove 0b and make byte occupie 4 positions =  0011
Binary value of input byte 2 =  0b1000
Remove 0b and make byte occupie 4 positions =  1000

Input 0 =  1
Input 1 =  1
Input 2 =  0
Input 3 =  0
Input 4 =  0
Input 5 =  0
Input 6 =  0
Input 7 =  1

Modbus Read Outputs
Sending: x00 x01 x00 x00 x00 x06 x00 x03 x00 x01 x00 x01
Raw received data = ####
Received data as x format =  '\x00\x01\x00\x00\x00\x05\x00\x03\x02\x00\x04'

Hex data received =  0001000000050003020004
Strip downto last two bytes
byte_1_out =  4
byte_2_out =  0
Binary value of Output byte 1 =  0b100
Remove 0b and make byte occupie 4 positions =  0100
Binary value of Output byte 2 =  0b0
Remove 0b and make output byte occupie 4 positions =  0000

Output 0 =  0
Output 1 =  0
Output 2 =  1
Output 3 =  0
Output 4 =  0
Output 5 =  0
Output 6 =  0
Output 7 =  0

Modbus set Outputs to 00
Sending: x00 x01 x00 x00 x00 x06 x00 x06 x00 x01 x00 x00

Modbus set Outputs to 04 i.e. set output 2 on (third bit)
Sending: x00 x01 x00 x00 x00 x06 x00 x06 x00 x01 x00 x04

 

Notes:
Data exchange using the Python program with Modbus Data send to UR to read and write UR register.

 

First request is to read inputs.

Data send
\x00\x01\x00\x00\x00\x06\x00\x03\x00\x00\x00\x01

Which is the same as
00 01 00 00 00 06 00 03 00 00 00 01

 

Meaning:
00 01 is the sequence number Modbus TCP follows (Sequence no = Transaction identifier (serial no)
00 00 is protocol indentifier
00 06 messages length – means 6 bytes will follow
00 Unit identifier – or slave address
03 is the function code for read
00 00 The address of the first register requested                 (register 00hex = 0 dec which are inputs).
00 01 The total number of register to read

 

Data received from UR:

(Notice the data received from the UR is in hex format which might have values below 32 which maybe does not display on the screen depending on the data value because such data below 32 can be control characters. Therefore the data is formatted by the python program to readable data).

 

First readable poll received:  0001000000050003020083

Meaning:
00 01 is the sequence number that Modbus TCP follow (same as in the request send i.e. replied to)
00 00 Protocol identifier
00 05 messages length – means 5 bytes will follow
03 was the function code requested
02 registers are read
00 83 is data value received. (83 is the interesting data where 3 belongs to first byte of inputs and 8 belongs to second byte of inputs).

Value 3 = 0011 for first byte which means bit 0 and bit 1 has the value “high”.

Value 8 = 1000 for second byte which means bit 7 has the value “high”.

This is correct according to physical current state of the inputs as shown above in the I/O window on the UR.

Then the python program strips the hex values down to bit value for each inputs and present on the screen.

Input 0 =  1
Input 1 =  1
Input 2 =  0
Input 3 =  0
Input 4 =  0
Input 5 =  0
Input 6 =  0
Input 7 =  1

 

Second request is to read outputs.

Data send
\x00\x01\x00\x00\x00\x06\x00\x03\x00\x01\x00\x01

Which is the same as
00 01 00 00 00 06 00 03 00 01 00 01

 

Meaning:
00 01 is the sequence number Modbus TCP follows (Sequence no = Transaction identifier (serial no)
00 00 is protocol indentifier
00 06 messages length – means 6 bytes will follow
00 Unit identifier – or slave address
03 is the function code for read
00 01 The address of the second register requested                 (register 01hex = 1 dec which are outputs).
00 01 The total number of register to read

 

Data received from UR:

(Notice the data received from the UR is in hex format which might have values below 32 which maybe does not display on the screen depending on the data value because such data below 32 can be control characters. Therefore the data is formatted by the python program to readable data).

 

Second readable poll received:  0001000000050003020004

Meaning:
00 01 is the sequence number that Modbus TCP follow (same as in the request send i.e. replied to)
00 00 Protocol identifier
00 05 messages length – means 5 bytes will follow
03 was the function code requested
02 registers are read
00 04 is data value received. (04 is the interesting data where 4 belongs to first byte of outputs and 0 belongs to second byte of outputs).

Value 4 = 0100 for first byte which means bit 2 has the value “high”.

Value 0 = 0000 for second byte which means all bits has the value “low”.

This is correct according to physical current state of the inputs as shown above in the I/O window on the UR.

Then the python program strips the hex values down to bit value for each inputs and present on the screen.

Output 0 =  0
Output 1 =  0
Output 2 =  1
Output 3 =  0
Output 4 =  0
Output 5 =  0
Output 6 =  0
Output 7 =  0

 

First request to write to set output.

Data send.
\x00\x01\x00\x00\x00\x06\x00\x06\x00\x01\x00\x00

Which is the same as
00 01 00 00 00 06 00 06 00 01 00 00

 

Meaning:
00 01 is the sequence number Modbus TCP follows (Sequence no = Transaction identifier (serial no)
00 00 is protocol indentifier
00 06 messages length – means 6 bytes will follow
00 Unit identifier – or slave address
06 is the function code for write
00 01 The data address of the first register to set                 (register 01hex = 1 dec).
00 00 The value to set into the register                                   (set value to 0 – this sets all outputs low)

 

Then the program wait 1 second.

 

Second request to write.

Data send.
\x00\x01\x00\x00\x00\x06\x00\x06\x00\x01\x00\x04

Which is the same as
00 01 00 00 00 06 00 06 00 01 00 04

 

Meaning:
00 01 is the sequence number Modbus TCP follows (Sequence no = Transaction identifier (serial no)
00 00 is protocol indentifier
00 06 messages length – means 6 bytes will follow
00 Unit identifier – or slave address
06 is the function code for write
00 01 The data address of the first register to set                 (register 01hex = 1 dec).
00 04 The value to set into the register                                   (set value to 4 – this sets output 3 high)

 

Disclaimer: While the Zacobria Pte. Ltd. believes that information and guidance provided is correct, parties must rely upon their skill and judgement when making use of them. Zacobria Pte. Ltd. assumes no liability for loss or damage caused by error or omission, whether such an error or omission is the result of negligence or any other cause. Where reference is made to legislation it is not to be considered as legal advice. Any and all such liability is disclaimed.

If you need specific advice (for example, medical, legal, financial or risk management), please seek a professional who is licensed or knowledgeable in that area.

Author:
By Zacobria Lars Skovsgaard
Accredited Universal Robots support Centre and Forum.

Also check out the CB3 forum



Was this article helpful?

4 comments

  1. Hi,

    Sorry to ask Dashboard Server, can it read robot’s state, positions, temperatures, etc. Just like Primary, Secondary and Realtime client and Modbus?

    1. Hi

      Thanks for the question.

      The Dashboard server can proveid the robot state, but not positions and temperatures. More information about the Dashboard server at this link

      https://www.universal-robots.com/how-tos-and-faqs/how-to/ur-how-tos/dashboard-server-port-29999-15690/

      Author:
      By Zacobria Lars Skovsgaard
      Accredited Universal Robots support Centre and Forum.

      Also check out the CB3 forum



  2. Hi I would like to ask why 00 01 is the sequence number Modbus TCP follows (Sequence no = Transaction identifier (serial no)

    Shouldn’t Transcation identifier be 00 00

    I am also try to communicate with UR through Modbus TCP/IP from PC. I writing my software from C/C++. Therefore I would like to ask the spacing between each bytes does it request to do that?
    As I using char array to store my byte Hex value. Example:
    char MBAP[7];
    MBAP[0] = 0x00;
    MBAP[1] = 0x00;
    MBAP[2] = 0x00;
    MBAP[3] = 0x00;
    MBAP[4] = 0x00;
    MBAP[5] = 0x06;
    MBAP[6] = 0x00;
    This will give 0000060.
    Am I right to do that?

    1. Hi Sun

      Thanks for the question.

      The sequence number is a counter to keep track of the handshake – so the number might be different. It is for the server to reply with the sequence number the client use in order to keep track on the communication.

      I am not familiar with C++, but normally there is no spacing in between the bytes.

      Author:
      By Zacobria Lars Skovsgaard
      Accredited Universal Robots support Centre and Forum.



Leave a Reply

Your email address will not be published. Required fields are marked *