Skip to content

29 ARCS Modbus User Guide ​

1. Modbus Protocol Introduction ​

  • Modbus is a serial communication protocol originally designed by Modicon (now Schneider Electric) in 1979 for automation equipment using programmable logic controllers (PLCs). Modbus has become the de facto standard for industrial communication protocols. The Modbus protocol includes Modbus RTU and Modbus TCP.

  • Modbus RTU (Remote Terminal Unit) is a binary communication protocol based on serial lines such as RS-485, RS-422, and RS-232. In Modbus RTU, data is transmitted in binary form, and each byte is represented by two hexadecimal characters. Modbus RTU is mainly used in industrial and system automation applications where the communication distance between devices is relatively long.

  • Modbus TCP (Transmission Control Protocol) is an Ethernet-based communication protocol. Modbus TCP uses TCP/IP for communication and therefore can use existing Ethernet infrastructure. Compared with Modbus RTU, Modbus TCP supports more device connections and provides a higher communication speed.

  • Main differences between Modbus RTU and Modbus TCP:

    • Modbus RTU uses serial communication, such as an RS-485 interface, and its transmission rate is limited by the performance of the serial interface.

    • Modbus TCP uses the TCP/IP protocol stack to transmit data over a network and supports a higher transmission rate.

2. Modbus Master ​

2.1 Master Introduction ​

In a Modbus communication network, the master station is the device that initiates communication. It controls and coordinates communication with slave stations. The master actively requests data from slave stations or sends commands to them to manage the network and exchange data.

2.2 Master Applications ​

  • When a robot acts as the master during welding, handling, assembly, or other operations, it requests data from or sends commands to a PLC slave station according to its task flow and operating state.

    • Example: During automotive component assembly, the robot can obtain component position information from the PLC so that it can accurately pick up and install the components.
  • A robot acting as the master generally has a high level of intelligence. It can analyze and process the received data and make appropriate decisions.

    • Example: Based on equipment status information provided by the PLC on the production line, the robot can adjust its operating pace and motion sequence to coordinate with other equipment.

2.3 Modbus Entry ​

Open the home page of AUBO STUDIO, then click Configuration > Fieldbus > Modbus in the left navigation bar to open the Modbus Client I/O Settings page.

2.4 Master Modbus TCP ​

  • Unit page: On the Modbus Client I/O Settings page, click Unit > Add Modbus Unit > TCP Mode.

  • Modbus TCP device: The device uses a TCP/IP connection and does not require checksum calculation. You can configure Device, Name, Slave Number, IP Address, Port, and Operation. After configuring the IP address, click Test. A successful test indicates that the target device can communicate with the robot. If the test fails, check whether the robot and target device are on the same network segment, whether the firewall is disabled, and whether other network settings are correct.

    Note

    Make sure that the TCP device and the target device are on the same network segment.

  • Signal page: On the Modbus Client I/O Settings page, click Signal > Add Modbus Signal.

    • COIL STATUS: Reads and controls the switching status of a remote device, and is commonly used to control switching devices such as relays.
    • INPUT STATUS: Reads the input status of a remote device, and is commonly used to read the status of input devices such as sensors.
    • HOLDING REGISTER: Stores and reads data from a remote device, and is commonly used to store control parameters and device status.
    • INPUT REGISTER: Stores input data from a remote device, and is commonly used to store data from sensors and other input devices.
    • Green indicates normal communication. Gray and red indicate no communication. The red response codes are as follows:
      • E1: Illegal function (0x01). The function code received in the query is not an operation allowed by the server (or slave).
      • E2: Illegal data address (0x02). The data address received in the query is not an address allowed by the server (or slave). Check whether the configured signal address matches the settings of the remote MODBUS server.
      • E3: Illegal data value (0x03). The data field contains a value that is not allowed by the server (or slave). Check whether the signal value is valid for the specified address on the remote MODBUS server.
      • E4: Slave device failure (0x04). An unrecoverable error occurred while the server (or slave) attempted to execute the requested operation. Check whether the device or wiring is damaged, and try restarting the device.
      • E5: Acknowledge (0x05). This code is used with a programming command sent to the remote MODBUS unit.
      • E6: Slave device busy (0x06). This code is used with a programming command sent to the remote MODBUS unit and indicates that the device (server) cannot respond at this time. Wait or try reconnecting. Also check whether the robot IP address conflicts with the IP address of another device on the same local network.

2.5 Master Modbus RTU ​

  • Unit page: On the Modbus Client I/O Settings page, click Unit > Add Modbus Unit > RTU Mode.

  • Modbus RTU device: Configure Device Name, Slave Number, Serial Port, Baud Rate, Parity, Data Bits, and Stop Bits.

    Note: Modbus RTU uses serial communication, and its transmission rate is limited by the performance of the RS-485 serial interface. If communication is unstable and the signal status flashes, reduce the baud rate. If there is no communication, check whether the selected serial port is correct. You can use a Modbus serial port assistant for troubleshooting. For details, see:

    78 RS485 Test

    79 Modbus RTU Serial Communication Test

  • Modbus RTU communication depends on the RS-485 serial communication of the controller or robot end. Refer to the following information when selecting the Modbus serial port:

  • Configure the RS-485 serial port number. The controller RS-485 ports include the end-effector RS485 port and USB485.

2.6 Using Modbus Signals as I/O in Configuration ​

On the Configuration page, click General > I/O Settings to configure I/O input actions. Except for drag teaching, the other signals must be triggered in linked mode to execute the signal action. You can also use the OEM customization function to make the signals take effect in manual mode or automatic mode.

Before configuring this function, click Fieldbus > Modbus > Signal on the Configuration page and add a Modbus signal whose type is Register Input or Digital Input.

  1. Configure the input action for the corresponding Modbus signal.

  2. Configure the output action for the corresponding Modbus signal.

  3. Click I/O > Modbus in the left navigation bar to view changes to signal registers and digital signals.

2.7 Using Modbus Signals in a Program ​

  • Set node: Set the Modbus signal's Digital Output and Register Output, as well as the single-pulse parameters of digital signals.

    Tip

    In most cases, use a Wait for Signal node for verification. Make sure that the signal is set successfully before the program continues with the subsequent process.

  • Wait node: Uses a Modbus signal as the condition. The program continues only after the signal meets the condition. This node is commonly used with the Set node.

  • Assignment node: Assigns the Modbus signal value to a variable for use in subsequent processes.

  • If node: Uses a Modbus signal as the condition. When the signal meets the requirement, the program enters the conditional flow.

  • Loop node: Uses a Modbus signal as the loop trigger. When the signal meets the condition, the program enters the loop flow.

  • Click I/O > Modbus in the left navigation bar to view changes to signal registers and digital signals.

3. Modbus Slave ​

3.1 Slave Introduction ​

The main function of a Modbus slave is to respond to requests from the master and perform the corresponding operations. In practical applications, it can connect to and control various devices on a production line to exchange information and transmit control commands between devices.

3.2 Applications of the ARCS Slave ​

  • Respond to requests from the master and send the robot status information to the master in real time.

  • Respond to requests from the master and send controller information to the master.

  • Provide data during testing and debugging:

    • Transmit changes in the robot I/O signals to the master in real time.
    • Transmit custom signals from the master to the robot in real time.

Note

Using an ARCS master to connect to a slave may cause signal delays. Use this method only during debugging; do not use it in a program. To read and write slave registers in a program, refer to the general register read/write example in Section 3.6.

3.3 Location for Updating the Slave Address Table ​

The Modbus slave address table is updated in Dingpan - Team Files > ARCS > External Files > Modbus Slave. If you are a customer, contact the company's technical service personnel to obtain it. Technical service personnel can obtain it directly.

Modbus VersionARCS VersionModification DateChanges
1.0.40.29.2-beta.102024-08-191. Added control project.
2. Added project running status.
1.0.70.31.0-beta.3
0.32.0-alpha.23
2024-12-26Updated robot series and robot submodels.
1.0.80.29.4-rc.6
0.31.0-beta.5
0.32.0-alpha.32
2025-01-09Added Modbus slave output operation mode and heartbeat.
1.0.90.29.5-rc.10
0.31.0-rc.12
0.32.0-alpha.73
2025-03-04Added read/write support for the project running speed percentage.
1.0.110.29.5-rc.21
0.31.0-rc.26
0.31.1-beta.7
0.32.0-alpha.117
2025-04-25Added Modbus slave release of protective stop.
1.0.120.29.5-rc.22
0.29.6-rc.1
0.31.0-rc.28
0.32.0-alpha.136
2025-05-12Added Modbus slave clearing of error pop-ups, including releasing protective stop and resetting the interface board.
1.0.130.31.1-beta.9
0.32.0-alpha.131
2025-05-15Added Boolean registers.
1.140.31.1-beta.10
0.32.0-alpha.139
2025-05-21Added project switching.
1.140.31.1-beta.10
0.32.0-alpha.140
2025-05-221. Added support for outputting linked mode in the operation mode.
2. Added output of the Modbus version number.

3.4 Slave Modbus TCP ​

On the Modbus Client I/O Settings page, click Slave and turn on the Modbus TCP switch.

After the slave is enabled, a master device such as a PLC or Modscan can connect to it. Refer to the Modbus slave protocol definition for the slave address.

3.5 Slave Modbus RTU ​

  • On the Modbus Client I/O Settings page, click Slave and turn on the Modbus RTU switch.

    Note

    • Configure the serial port parameters before enabling the Modbus RTU slave.
    • After the slave is enabled, its serial port parameters cannot be modified. Turn it off before modifying the parameters.

  • Modbus RTU communication depends on the RS-485 serial communication of the controller or robot end. Refer to the following information for the serial port parameters of different devices:

    Note: Modbus RTU uses serial communication, and its transmission rate is limited by the performance of the RS-485 serial interface. If communication is unstable and the signal status flashes, reduce the baud rate. If there is no communication, check whether the selected serial port is correct. You can use a Modbus serial port assistant for troubleshooting. For details, see:

    78 RS485 Test

    79 Modbus RTU Serial Communication Test

  • Configure the RS-485 serial port number. The controller RS-485 ports include the end-effector RS485 port and USB485.

3.6 Application Example: Reading and Writing Modbus Slave General Registers ​

3.6.1 Introduction to Modbus Slave General Registers ​

To allow users to use custom signals for communication between a PLC (master) and the controller, the Modbus slave provides dedicated readable and writable general registers. The addresses of the general registers are 300 to 525.

There are two typical general-register read/write methods:

  • Use SDK interfaces to read and write the general register at the specified address.
  • Use a project (Lua) script to read and write the general register at the specified address.

3.6.2 Reading and Writing General Registers Through Modbus TCP ​

Test environment:

The test uses Modbus TCP communication and Modbus Poll to simulate communication between a PLC master and the Modbus TCP slave. The relevant address signal settings in Modbus Poll are shown below:

3.6.2.1 Reading and Writing General Registers Through the SDK ​
  • Reading a general register:

    • Core steps for reading a Modbus signal through the SDK:

      1. Call modbusAddSignal to add a signal at the specified address.
      2. Call modbusGetSignalStatus to obtain the signal value at the specified address.
      3. Call modbusDeleteSignal to delete the signal.
    • Example: Use the SDK to read the general registers at addresses 300, 301, and 303 in the Modbus slave. The code is as follows:

      c++
      // Read general registers
      void exampleModbusSlaveRead(RpcClientPtr impl)
      {
          // Create a holding-register signal at the specified slave address
          impl->getRegisterControl()->modbusAddSignal(
              MODBUS_SLAVE_IP, 1, 300, 0x03, "READ_HOLDING_REGISTER_300", true);
          impl->getRegisterControl()->modbusSetSignalUpdateFrequency(
              "READ_HOLDING_REGISTER_300", 10);
      
          impl->getRegisterControl()->modbusAddSignal(
              MODBUS_SLAVE_IP, 1, 301, 0x03, "READ_HOLDING_REGISTER_301", true);
          impl->getRegisterControl()->modbusSetSignalUpdateFrequency(
              "READ_HOLDING_REGISTER_301", 10);
      
          impl->getRegisterControl()->modbusAddSignal(
              MODBUS_SLAVE_IP, 1, 303, 0x03, "READ_HOLDING_REGISTER_303", true);
          impl->getRegisterControl()->modbusSetSignalUpdateFrequency(
              "READ_HOLDING_REGISTER_303", 10);
      
          std::this_thread::sleep_for(std::chrono::seconds(1));
      
          int i = 30;
          while (i--) {
              // Get the value of the holding-register signal at the specified address
              auto ret0 = impl->getRegisterControl()->modbusGetSignalStatus(
                  "READ_HOLDING_REGISTER_300");
              std::cout << "READ_HOLDING_REGISTER_300:" << ret0 << std::endl;
      
              auto ret1 = impl->getRegisterControl()->modbusGetSignalStatus(
                  "READ_HOLDING_REGISTER_301");
              std::cout << "READ_HOLDING_REGISTER_301:" << ret1 << std::endl;
      
              auto ret3 = impl->getRegisterControl()->modbusGetSignalStatus(
                  "READ_HOLDING_REGISTER_303");
              std::cout << "READ_HOLDING_REGISTER_303:" << ret3 << std::endl;
      
              std::this_thread::sleep_for(std::chrono::seconds(1));
          }
          // Delete the signals when finished
          impl->getRegisterControl()->modbusDeleteSignal("READ_HOLDING_REGISTER_300");
          impl->getRegisterControl()->modbusDeleteSignal("READ_HOLDING_REGISTER_301");
          impl->getRegisterControl()->modbusDeleteSignal("READ_HOLDING_REGISTER_303");
      }
    • The read result is shown below:

  • Writing a general register:

    • Steps for writing a Modbus general register through the SDK:

      1. Call modbusAddSignal through the SDK to add a signal at the specified address.
      2. Call modbusSetOutputSignal to write the signal value at the specified address.
      3. Call modbusDeleteSignal to delete the signal.
    • Example: Use the SDK to write to the general register at address 302 in the Modbus slave. The code is as follows:

      c++
      // Write a holding register
      void exampleModbusSlaveWrite(RpcClientPtr impl)
      {
          // Create a holding-register signal at the specified slave address
          impl->getRegisterControl()->modbusAddSignal(
              MODBUS_SLAVE_IP, 1, 302, 0x03, "WRITE_HOLDING_REGISTER_302", true);
      
          std::this_thread::sleep_for(std::chrono::seconds(1));
      
          // Write a value to the holding register at the specified address
          impl->getRegisterControl()->modbusSetOutputSignal(
              "WRITE_HOLDING_REGISTER_302", 25);
      
          std::this_thread::sleep_for(std::chrono::seconds(1));
      
          // Delete the signal when finished
          impl->getRegisterControl()->modbusDeleteSignal(
              "WRITE_HOLDING_REGISTER_302");
      }
    • Result:

3.6.2.2 Reading and Writing General Registers Through a Project Script ​
  • Reading a general register:

    • Objective: Use Modbus Poll to set the value of the general register at address 300 in the Modbus slave to 10.

    • Example code:

      lua
      -- Create a Modbus signal (IP, slave number, register start address, function code, name, word)
      modbusAddSignal("127.0.0.1,502", 1, 300, 0x03, "READ_HOLDING_REGISTER_300", true)
      -- Get the Modbus register value and assign it to a variable for viewing on the teach pendant
      tmp0 = modbusGetSignalStatus("READ_HOLDING_REGISTER_300")
      -- Delete the signal with the specified name
      modbusDeleteSignal("READ_HOLDING_REGISTER_300")
    • Result: Write a script on the teach pendant to obtain the value of the signal at address 300. The value of tmp0 is 10.

  • Writing a general register:

    • Objective: Write a script on the teach pendant to set the signal value at address 302 to 88.

    • Example code:

      lua
      -- Create a Modbus signal (IP, slave number, register start address, function code, name, word)
      modbusAddSignal("127.0.0.1,502", 1, 302, 0x03, "WRITE_HOLDING_REGISTER_302", true)
      -- Write the Modbus value and assign it to a variable for viewing on the teach pendant
      tmp0 = modbusSetOutputSignal("WRITE_HOLDING_REGISTER_302", 88)
      -- Delete the signal with the specified name
      modbusDeleteSignal("WRITE_HOLDING_REGISTER_302")
    • Result: Use Modbus Poll to verify that the value of the general register at address 302 is 88.

3.6.3 Reading and Writing General Registers Through Modbus RTU ​

Test environment:

  • The test uses Modbus RTU communication and calls the programming interface to communicate with the Modbus RTU slave.

    Because a Modbus RTU slave does not support simultaneous connections from multiple Modbus masters during serial communication, this test does not use Modbus Poll. Instead, it calls the interface to obtain the signal value at the specified address and checks whether the signal changes correctly.

  • Select two serial port numbers that can communicate. This test uses /dev/ttyS0 and /dev/ttyS1. /dev/ttyS1 is assigned to the Modbus RTU slave, and /dev/ttyS0 is used by the programming interface.

  • Enable the Modbus RTU slave. The relevant configuration is shown below:

Important

  • During serial communication, make sure that both serial ports can communicate normally. You can use a debugging assistant such as CuteCom to verify the connection.

  • A serial port number cannot be used by multiple masters or slaves at the same time.

3.6.3.1 Reading and Writing General Registers Through the SDK ​
  • Example flow for reading and writing a general register through the SDK:

    1. Call modbusAddSignal to add a signal at the specified address.
    2. Call modbusGetSignalStatus to read the signal value at the specified address and view its initial value.
    3. Call modbusSetOutputSignal to write a signal value at the specified address.
    4. Call modbusGetSignalStatus to read the signal value at the specified address.
    5. Call modbusDeleteSignal to delete the signal when finished.
  • The following example reads and writes the general register at address 302 in the Modbus slave through the SDK:

    c++
    // Read and write a holding register through Modbus RTU
    #define MODBUS_SERIAL_PORT "/dev/ttyS0,115200,N,8,1"
    void exampleModbusRtu(RpcClientPtr impl)
    {
        // Create a holding-register signal at the specified slave address
        impl->getRegisterControl()->modbusAddSignal(
            MODBUS_SERIAL_PORT, 1, 302, 0x03, "HOLDING_REGISTER_302", true);
    
        std::this_thread::sleep_for(std::chrono::seconds(1));
    
        // Get the value of the holding-register signal at the specified address
        auto ret0 = impl->getRegisterControl()->modbusGetSignalStatus(
            "HOLDING_REGISTER_302");
        std::cout << "Read --> HOLDING_REGISTER_302:" << ret0 << std::endl;
    
        // Write a value to the holding register at the specified address
        impl->getRegisterControl()->modbusSetOutputSignal("HOLDING_REGISTER_302",
                                                          66);
        std::cout << "Write 66 to HOLDING_REGISTER_302" << std::endl;
    
        std::this_thread::sleep_for(std::chrono::seconds(1));
    
        // Get the value of the holding-register signal at the specified address
        auto ret1 = impl->getRegisterControl()->modbusGetSignalStatus(
            "HOLDING_REGISTER_302");
        std::cout << "Read --> HOLDING_REGISTER_302:" << ret1 << std::endl;
    
        std::this_thread::sleep_for(std::chrono::seconds(1));
    
        // Write a value to the holding register at the specified address
        impl->getRegisterControl()->modbusSetOutputSignal("HOLDING_REGISTER_302",
                                                          88);
        std::cout << "Write 88 to HOLDING_REGISTER_302" << std::endl;
    
        std::this_thread::sleep_for(std::chrono::seconds(1));
    
        // Get the value of the holding-register signal at the specified address
        auto ret2 = impl->getRegisterControl()->modbusGetSignalStatus(
            "HOLDING_REGISTER_302");
        std::cout << "Read --> HOLDING_REGISTER_302:" << ret2 << std::endl;
    
        std::this_thread::sleep_for(std::chrono::seconds(1));
    
        // Delete the signal when finished
        impl->getRegisterControl()->modbusDeleteSignal(
            "HOLDING_REGISTER_302");
    }
  • The output shows that the initial value of the general register at address 302 is 0. After writing 66, the read value is 66. After writing 88, the read value is 88. This indicates that the SDK can read and write the general register in the Modbus slave normally.

3.6.3.2 Reading and Writing General Registers Through a Project Script ​
  • Objective: Write a script on the teach pendant to perform the following flow. Assign each read value to tmp0:

    1. Call modbusGetSignalStatus to obtain the signal value at address 300.
    2. Call modbusSetOutputSignal to set the signal value at address 300 to 88.
    3. Call modbusGetSignalStatus to obtain the signal value at address 300.
    4. Call modbusSetOutputSignal to set the signal value at address 300 to 66.
  • Example code:

    lua
    -- Create a Modbus signal (device information, slave number, register start address, function code, name, word)
    modbusAddSignal("/dev/ttyS0,115200,N,8,1", 1, 300, 0x03, "HOLDING_REGISTER_300", true)
    -- Get the Modbus register value and assign it to a variable for viewing on the teach pendant
    tmp0 = modbusGetSignalStatus("HOLDING_REGISTER_300")
    -- Write the Modbus value
    modbusSetOutputSignal("HOLDING_REGISTER_300", 88)
    -- Get the Modbus register value and assign it to a variable for viewing on the teach pendant
    tmp0 = modbusGetSignalStatus("HOLDING_REGISTER_300")
    -- Write the Modbus value
    modbusSetOutputSignal("HOLDING_REGISTER_300", 66)
    -- Get the Modbus register value and assign it to a variable for viewing on the teach pendant
    tmp0 = modbusGetSignalStatus("HOLDING_REGISTER_300")
    -- Delete the signal with the specified name
    modbusDeleteSignal("HOLDING_REGISTER_300")
  • Result: The value of tmp0 changes between 66 and 88.

4. Interface Applications ​

4.1 modbusSendCustomCommand Function and Notes ​

  • Sends a user-specified command to the Modbus unit at the specified IP address.
  • Because no response is received, the function cannot be used to request data. Read function codes are not currently available.
  • The user is responsible for providing data that is meaningful for the specified function code.
  • The built-in function constructs the Modbus frame. You do not need to calculate the command length or enter CRC data.

4.2 Parameter Definitions and Formats ​

c++
// Interface definition
int modbusSendCustomCommand(const std::string &device_info, int slave_number,
                            int function_code, const std::vector<uint8_t> &data);

// device_info: device information
     * RTU format:
     * "serial_port,baud,parity,data_bit,stop_bit"
     * (1) serial_port specifies the serial port name.
     *     For example, "/dev/ttyS0" or "/dev/ttyUSB0" on Linux,
     *     and "\\.\\COM10" on Windows.
     * (2) baud specifies the communication baud rate, such as 9600, 19200,
     *     57600, or 115200.
     * (3) parity specifies the parity mode. N means no parity, E means even
     *     parity, and O means odd parity.
     * (4) data_bit specifies the number of data bits. Valid values are 5, 6,
     *     7, and 8.
     * (5) stop_bit specifies the number of stop bits. Valid values are 1 and 2.
     *
     * TCP format: "ip address,port"
     * (1) ip address specifies the server IP address.
     * (2) port specifies the port on which the server listens.

// slave_number: slave number used for the custom command

// function_code: function code for the custom command
     * MODBUS_FC_READ_COILS                0x01   // Read coil registers
     * MODBUS_FC_READ_DISCRETE_INPUTS      0x02   // Read discrete input status
     * MODBUS_FC_READ_HOLDING_REGISTERS    0x03   // Read holding registers
     * MODBUS_FC_READ_INPUT_REGISTERS      0x04   // Read input registers
     * MODBUS_FC_WRITE_SINGLE_COIL         0x05   // Write a single coil
     * MODBUS_FC_WRITE_SINGLE_REGISTER     0x06   // Write a single register
     * MODBUS_FC_READ_EXCEPTION_STATUS     0x07   // Read exception status (serial line only)
     * MODBUS_FC_WRITE_MULTIPLE_COILS      0x0F   // Write multiple coils
     * MODBUS_FC_WRITE_MULTIPLE_REGISTERS  0x10   // Write multiple registers
     * MODBUS_FC_REPORT_SLAVE_ID           0x11   // Report slave ID (serial line only)
     * MODBUS_FC_MASK_WRITE_REGISTER       0x16   // Mask write register
     * MODBUS_FC_WRITE_AND_READ_REGISTERS  0x17   // Read and write registers

// data: valid byte values from 0 to 255
     * { 0x00, 0x02, 0x00, 0x0F }
     * { 0x06, 0x0A, 0x0F, 0x08, 0x00, 0x0F }

4.3 Calling Example ​

c++
// Define the IP address
#define MODBUS_IP          "172.16.3.111,502"
// Create the object
RpcClientPtr impl;
// Send custom data
impl->getRegisterControl()->modbusSendCustomCommand(
    MODBUS_IP, 1, 0x06, { 0x00, 0x02, 0x00, 0x0F });

5. Troubleshooting ​

5.1 Modbus TCP Signal Communication Failure ​

Follow these steps to troubleshoot the failure:

  • Check whether the network between the device and the robot can communicate normally. First check whether the device firewall is disabled, then use the ping command to check network communication.
  • Check whether the signal address created by the master exists in the slave. The address corresponding to the signal created by the master must exist in the slave for the signal to communicate normally.
  • Check whether the robot IP address conflicts with the IP address of another device on the same local network.

5.2 Modbus RTU Signal Communication Failure ​

  • Check whether serial communication between the device and the robot is normal. Use a serial port debugging assistant on the device and robot to test the serial communication status.
  • Check whether the signal address created by the master exists in the slave. The address corresponding to the signal created by the master must exist in the slave for the signal to communicate normally.

Operational steps:

  1. Install cutecom in the robot controller using the command.

  2. Open CuteCom and set the Serial Port, Baud Rate, Parity, Data Bits, and Stop Bits.

  3. If the device is a PLC, use CuteCom to connect directly to the PLC for testing. If the device is a local computer, install a serial port debugging assistant such as XCOM on the computer.

  4. If CuteCom and the PLC or XCOM can send data to each other, communication is normal and the serial communication wiring is not faulty. Otherwise, check the communication wiring.

6. Frequently Asked Questions ​

6.1 Q1. When using a wireless teach pendant with a router to bridge the network, the IP address can be reached by ping, but the Modbus master signal does not communicate. ​

Solution: Check whether port forwarding is configured on the router. If it is not configured, add the port used by Modbus TCP.