Author: <Baekseok Kim> Email: kimb52@unlv.nevada.edu
Date: Last modified on <01/20/23>
Keywords: RB5 manipulator, RB5 Programming, collaborative robot

The cooperative robot RB series can be operated for various environments and purposes. It can be used in conjunction with multiple RB series or other systems. In conjunction with the vision system, movement coordinates can be changed in real time, or used as part of a user's existing system.

Users can control the robot with teaching pendant (tablet UI), but it provides a way to control the robot from any external controller for user’s convenience or operation.

The RB series receives script commands by default and executes those commands. The task of writing a motion using the teaching pendant (tablet UI) and executing the script of the file in order is a general operation method. The following method described in this document is an alternative method of receiving a command script from another external device to control a robot of the RB series.

The control syntax provided in the teaching pendant / tablet UI can be implemented by the user directly from the external control device, and the robot operation commands / IO control commands are sent according to the user’s use case.

The following document describes an example of driving a robot with the above concepts.

*API Commands

In order to use external control, the external computer must be connected to the control box. The connection uses TCP / IP communication and the corresponding IP address can be set in the pendant. The result is displayed on the screen on control panel. Ports 5000 and 5001 open for external control. Port 5000 is a port for receiving commands, and port 5001 is a port for requesting and sending data indicating robot status. For convenience, port 5000 is called the command port and port 5001 is called the data port.

Users can send the script command described above to the command port. The command port has a filter for the first command, so if the start is not a script command as described above, such as “jointall”, “movetcp”, “mc”, “pgmode”, etc., the response is “The command is not allowed”. If the command starts with a normal command and passes the input statement to the parser, the response is “The command was executed”.

When the command “reqdata” is sent to the data port, robot status information is sent to the data port in response. The format of the data is shown below.

The format of the data is shown below. Depending on the system version, the size of the data may be different. However, the order is consistent, please refer to the table below.

reqdata format

* Print out the RB5's current Position using script command.

* Print out the RB5's current Joint angle using script command.

* Move RB5 from joint angle(0,0,0,0,0,0) to angle(10,20,30,40,50,60), speed 30% using script command.

* Move RB5 from joint Position(0.4,0,0.4,0,0,0) to Position(0.2,0.2,0.5,0,0,0), speed 30% using script command.

This is simple code for connect External Computer with RB5 Controller.

import socket
RB5_ip = "10.0.2.7"
 
def sendCommand(cmd):
    global cmd_socket
    send_cmd=cmd.encode()
    cmd_socket.send(send_cmd)
 
def initRobot():
    sendCommand("mc jall init")
    time.sleep(1)
 
#  <ProgramMode_Real>
#  change to 'real robot' mode -- robot will move
def setRealMode():
    sendCommand("pgmode real")
    time.sleep(1)
 
# <ProgramMode_Simulation>
# change to 'simulation' mode -- robot will not move except teaching
def setSimulationMode():
    sendCommand("pgmode simulation")
    time.sleep(1)
 
if __name__ == "__main__":  
    host = RB5_ip
    data_port = 5001
    cmd_port = 5000
 
    ###### Initializing #######
    if len(sys.argv)>1:
        host = sys.argv[1]
    data_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    cmd_socket  = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        data_socket.connect((host, data_port))
        cmd_socket.connect((host, cmd_port))
 
        print("start")
 
        initRobot()
        print("init")
 
        setRealMode()
        print("set_real_mode")
 
    except KeyboardInterrupt:
        pass
    finally:
        os._exit(0) # not call close() ** workaround for native dead

This is Example code for get RB5 data from RB5 Controller using Multi-thread. you can make main program to control RB5 with RB5 data.

from queue import Queue 
import threading
 
import socket
import sys
import struct
 
####### RB5 API #######
#RB5 API to control RB5 Robot, 
#This RB5 API is based on RB5 manual
 
def Rb5_decode(data):
    decode_data=[]
    for i in range(26):
        data_4byte=struct.unpack('f',data[i*4:i*4+4])[0]   
        decode_data.append(data_4byte)
    return decode_data
 
def Rb5_getdata(sock):
    bufsize = 4096
    msg='reqdata'
    sdata=msg.encode()
    sock.send(sdata)
    data = sock.recv(bufsize)
    res=Rb5_decode(data)
 
    return res
 
def get_data_thread(sock, q_in, q_out):
    print('start')
    while True:
        cmd=q_in.get()
        if cmd == 1:
            rb5_data_ = Rb5_getdata(sock)
            q_out.put(rb5_data_)
 
def sendCommand(cmd):
    global cmd_socket
    send_cmd=cmd.encode()
    cmd_socket.send(send_cmd)
 
def waitUntilMotionDone():
    usleep(10)
    # while(isMotionIdle() != True):
    #     print(isMotionIdle())
    #     usleep(10)
 
def initRobot():
    sendCommand("mc jall init")
    time.sleep(1)
 
#  <ProgramMode_Real>
#  change to 'real robot' mode -- robot will move
def setRealMode():
    sendCommand("pgmode real")
    time.sleep(1)
    # return *this;
 
# <ProgramMode_Simulation>
# change to 'simulation' mode -- robot will not move except teaching
def setSimulationMode():
    sendCommand("pgmode simulation")
    time.sleep(1)
    # return *this;
 
if __name__ == "__main__":
    q_in =Queue(1)
    q_out =Queue(2)
    global rb5_data
    global cmd_jnt
    global cmd_pose
 
    host = RB5_ip
    data_port = 5001
    cmd_port = 5000
    ###### Initializing #######
    if len(sys.argv)>1:
        host = sys.argv[1]
 
    data_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    cmd_socket  = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        data_socket.connect((host, data_port))
        cmd_socket.connect((host, cmd_port))
 
        print("start")
 
        ###### Start daemon thread to get RB5 data  #######
        t1 = threading.Thread(target=get_data_thread, args=(data_socket, q_in, q_out))
        t1.daemon = True 
        t1.start()
        print("start_tread")
 
        initRobot()
        print("init")
        setRealMode()
        print("set_real_mode")
 
        while True:
            time.sleep(step_time)
            q_in.put(1)
            rb5_data=q_out.get()
            get_robot_param()
 
        print("### End ###")
 
    except KeyboardInterrupt:
        pass
    finally:
        os._exit(0) # not call close() ** workaround for native dead

The following commands are actual motion commands to move the robot. Each one contains an example string that matches how a user would control the robot from an external application.

The following commands are for initialization, termination, operation mode change, and speed change.

1) mc

2) shutdown

3) pgmode

4) sdw

The following commands are five operation commands.

1) jointall

2) movetcp

3) movecircle

4) blend_jnt

5) blend_tcp

The following commands are commands to control the output values of the digital and analog ports of switchboards and tool flanges. There are three commands.

1) digital_out

2) analog_out

3) tool_out

For questions, clarifications, etc, Email: kimb52@unlv.nevada.edu