Stream Motion overview

Stream Motion (option J519) lets an external application give the position of the robot at every communication cycle (2, 4 or 8 ms depending on the controller). The robot follows these positions in real time. Typical uses:

• trajectories computed outside the robot (path planning, CAD/CAM, simulation)
• sensor guided motion: vision, force sensor, seam tracking
• teleoperation with a joystick or a haptic device

The SDK does the real-time part for you: it synchronizes the positions with the status of the robot, keeps a few positions in advance, stops the robot smoothly if your application stops giving positions, and provides a motion planner that respects the velocity, acceleration and jerk limits of the robot.

Stream Motion or RMI?

Requirements on the robot

• Option J519 Stream Motion. Check it with Features.HasStreamMotion (FTP diagnostics).
• A TP program with the instructions IBGN start[n] and IBGN end[n] (see below), run in AUTO mode at 100% override.
• $PARAM_GROUP[1].$SV_OFF_ENB[*] set to FALSE, otherwise the robot raises MOTN-615.
• Resume offset disabled, otherwise the robot raises MOTN-623.
• Only motion group 1 is controlled (robot and up to 3 extended axes).
• The robot listens on UDP port 60015 on the Ethernet port set in $STMO.$PHYS_PORT.

TP program

The robot only accepts positions while a program waits on IBGN start[n]. When your application finishes the session, the program continues after IBGN end[n]. This program loops, so each loop is a new session:

/PROG  START_STREAM_MOTION_J519
/ATTR
OWNER		= MNEDITOR;
PROTECT		= READ_WRITE;
TCD:  STACK_SIZE	= 0,
      TASK_PRIORITY	= 50,
      TIME_SLICE	= 0,
      BUSY_LAMP_OFF	= 0,
      ABORT_REQUEST	= 0,
      PAUSE_REQUEST	= 0;
DEFAULT_GROUP	= 1,*,*,*,*;
CONTROL_CODE	= 00000000 00000000;
/MN
   1:  LBL[1] ;
   2:  IBGN start[1] ;
   3:  IBGN end[1] ;
   4:  JMP LBL[1] ;
/POS
/END

You can add your own instructions before IBGN start or after IBGN end, for example to set an output or to wait for a signal. The program can be started from the teach pendant, or remotely (see Run a program remotely).

IBGN start and IBGN end instructions are located in the ASCII INTERFACE section of the TP program editor. If you don't see this section, please ensure J519 Stream Motion is enabled.

Quick start

This example moves J1 by 10 degrees and back, with a smooth motion planned within the limits of the robot:

robot.Connect(parameters);
var sm = robot.StreamMotion;
// Read the limits of the robot and start to receive its status
sm.StartMonitoring();

// Plan a smooth joint motion: J1 +10 degrees then back, at 20% of the velocity limits
JointsPosition start = sm.QueueEndJointPosition;
var target = new JointsPosition(start.Values) { J1 = start.J1 + 10 };
var planner = new MotionPlanner(sm.JointLimits, null);
Trajectory trajectory = planner.CreateJointPath(FanucMotion.ToJointValues(start))
    .MoveJoint(FanucMotion.ToJointValues(target), 20, FanucMotion.Cnt(100))
    .MoveJoint(FanucMotion.ToJointValues(start), 20, FanucMotion.Fine())
    .Build();

// The motion starts when the TP program reaches IBGN start
int motionId = sm.Enqueue(trajectory);
sm.WaitForMotion(motionId, 60000);

// Release the TP program: it continues after IBGN end
sm.Finish(10000);
robot.Disconnect();
}

Try it in the Showcase app

The Showcase demo application (Windows, WinForms) has a Stream Motion page to test this feature without writing code. Download it from the download page.

Connect to your robot or to a ROBOGUIDE virtual robot, start the monitoring, then run the TP program described above. Once the robot reaches IBGN start, a session starts and the page shows:

• the client state, the cycle time measured on the robot, the protocol version and the number of active sessions
• the robot status at each cycle: joint and Cartesian position, and whether the robot is moving
• two demo motions built with the motion planner: a joint move of J1 back and forth, and a horizontal circle in Cartesian space
• pause, resume, abort and override applied to the current session
• a log of the sessions and motions, with counters for lost status messages and underruns

The C# source of this page is in the StreamMotionControl.cs file of the Fanuc.NET repository.

How it works

1. StartMonitoring() reads the limits of the robot, starts the status output of the robot and measures the communication cycle.
2. When the TP program reaches IBGN start, the client state becomes Ready.
3. As soon as positions are available, a session starts. Positions come from one source at a time:
   • a queue of trajectories (Enqueue), see Send trajectories
   • a target that the robot follows (StartTracking), see Real-time control
   • your own callback, called at each cycle (StartCallbackStreaming)
4. Finish() waits until the robot is at rest, then the TP program continues after IBGN end.

Trajectories are created with the motion planner of the SDK, described in the Motion section.

During a session, the robot sends its status at every cycle and the SDK answers with the next position. The positions are sent a little in advance (BufferLeadTime), so that a late answer of the PC does not stop the robot:

Protocol versions

Set the version in ConnectionParameters.StreamMotion.ProtocolVersion. It must not be higher than the system variable $STMO.$USABLE_VER (this variable does not exist on older software, which only support version 1).

A version 4 exists on some recent controllers for ROS 2 only. It is not supported.

Useful system variables

These variables can be read with CGTP, SNPX or Telnet.

Next steps

• Connection, status & session: connect, read the status and the limits, run several sessions.
• Send trajectories: queue trajectories, override, pause and abort.
• Real-time control: follow a target, or compute each position.
• I/O during motion: read and write I/O synchronized with the motion.
• Troubleshooting: alarms and best practices.

API reference