The industrial_robot_client package contains various classes to implement industrial robot client nodes. The main functionalities that a client should have is, it can update the robot current state from the robot controller, and also it can send joint trajectories/joint position message to the controller.

There are two main nodes that are responsible for getting robot state and sending joint trajectory/position values.

• The robot_state node: This node is responsible for publishing the robot's current position, status, and so on
• The joint_trajectory node: This node subscribes the robot's command topic and sends the joint position commands to the robot controller via the simple message protocol

The following screenshot gives the list of APIs provided by the industrial robot client:

We can briefly go through these APIs and their functionalities as follows:

• RobotStateInterface: This class contains methods to publish the current robot position and status at regular intervals after receiving the position data from the robot controller.
• JointRelayHandler: The RobotStateInterface class is a wrapper around a class called MessageManager. What it does is, it listens to the simple_ message robot connection and processes each message handling using Messagehandlers. The JointRelayHandler functionality is a MessageHandler and its function is to publish the joint position in the joint_states topic.
• RobotStatusRelayHandler: This is another MessageHandler, which can publish the current robot status info in the robot_status topic.
• JointTrajectoryInterface: This class contains methods to send the robot's joint position to the controller when it receives a ROS trajectory command.
• JointTrajectoryDownloader: This class is derived from the JointTrajectoryInterface class, and it implements a method called send_to_robot(). This method sends an entire trajectory as a sequence of messages to the robot controller. The robot controller will execute the trajectory in the robot only after getting all sequences sent from the client.
• JointTrajectoryStreamer: This class is the same as the preceding class except in the implementation of the send_to_robot() method. This method sends independent joint values to the controller in separate threads. Each position command is sent only after the execution of the existing command. In the robot side, there will be a small buffer for receiving the position to make the motion smoother.

The list of nodes inside the industrial robot client are as follows:

• robot_state: This node is running based on RobotStateInterface,
  which can publish the current robot states
• motion_download_interface: This node runs JointTrajectoryDownloader, which will download trajectory in sequence to the controller
• motion_streaming_interface: This node runs JointTrajectoryStreamer, which will send the joint position in parallel using threading
• joint_trajectory_action: This node provides a basic actionlib interface