Component reference

CIR (CIR)

Arc move: curves from where it is, through a middle (via) plane, to an end plane, like drawing a circle through three points. Use for rounded paths the robot should sweep, not corner.

"Lite6 CIR", Cartesian circular/arc motion through a via plane to an end plane. The arc is uniquely determined by start (current TCP), via, and end. xArm SDK: arm.move_circle(via, end, percent). For simulation, only the END pose's joint angles are computed (the arc path is not visualized in v0.7, wire multiple intermediate PTP/LIN poses to a single Sim to see the trajectory as discrete poses).

Inputs

Outputs

Cartesian Target (CartTgt)

Build a Cartesian target by typing the TCP pose, X Y Z (mm) + Roll Pitch Yaw (deg), as in uFactory Studio. IK resolves it to joints. Like Pose, but in Cartesian coords. Feed into Live Jog / Stage / Code.

"Cartesian Target", build a Cartesian RobotTarget by typing the TCP pose: X Y Z (mm) + Roll Pitch Yaw (deg), exactly as uFactory Studio shows it. Like a Pose, but in Cartesian/tool coordinates instead of joint angles. IK resolves it to joints (same solver as PTP). Feed it into Live Jog (Cartesian jog), Stage, Code, or any target input, moving X moves the tool in X.

Inputs

Outputs

LIN (LIN)

Straight-line move to a target plane: the tool travels in a straight line in space (Cartesian). Use for approaches, retracts, and any path that must stay straight, e.g. inserting a part or following an edge.

"Lite6 LIN", Cartesian linear motion. Takes a target TCP Plane and resolves it to joint angles via IK (for simulation), but the code-gen emits arm.set_position(x, y, z, roll, pitch, yaw) so the robot moves in a straight line in Cartesian space (not joint-interpolated).

Inputs

Outputs

Load Traj (LoadTraj)

Read a .ltraj JSON file into a RobotTarget list.

"Lite6 Load Traj", read a .ltraj JSON file written by Lite6 Save Traj and output the RobotTarget list. Schema is the minimal hand-rolled format from the save side; missing fields fall back to defaults.

Inputs

Outputs

PTP (PTP)

Point-to-point move to a target plane: the fastest way there, joints take the quickest route, so the tool path is NOT straight. Works out the joint angles for you (IK). Use for free-space moves where the exact path doesn't matter.

"Lite6 PTP", Cartesian point-to-point. Takes a target TCP Plane and resolves it to joint angles via numerical IK (damped least squares in Lite6Kinematics.Inverse). Outputs a RobotTarget with MotionType.PTP, which flows into Stage and Code unchanged.

Inputs

Outputs

Pose (Pose)

The simplest target: type or slide the joint angles (in degrees) to pose the arm directly, no inverse kinematics. Uses J1 through however many joints the robot has: xArm 5 uses J1, J5, Lite 6 / xArm 6 / UF 850 use J1, J6, xArm 7 uses J1, J7. Extra joints are ignored (with a warning). The component face shows the active range.

"Lite6 Pose", takes 6 joint angles in DEGREES (more intuitive than radians for Grasshopper sliders) plus motion type and speed, outputs a RobotTarget.

Inputs

Outputs

G-Code Import (GIn)

Parse slicer 3D-printing G-code into a sequence of robot motion targets.

"Lite6 G-Code Import", reads slicer-flavored G-code (PrusaSlicer, Cura, Slic3r, generic 3D-printer dialect) and converts it into a RobotTarget sequence. Aimed at 3D printing (FDM extruder, syringe deposition, pumpkin carving G-code, or any 2.5D/3D toolpath authored as G-code). 3D Printing. Parsed commands: G0 X Y Z F → PTP (rapid, no extrusion) G1 X Y Z E F → LIN (feed); E delta optionally triggers a digital output G90 / G91 → absolute / relative XYZ positioning M82 / M83 → absolute / relative extruder positioning G92 X Y Z E → set current position without moving G28 → home, ignored with a one-time warning M104/M106/M107/M109/M140/M190 → temperature & fan, ignored with one-time warnings ; ... → comments stripped Tool orientation convention: each emitted target plane has its +Z aligned with the NEGATIVE of Print Frame's Z axis, i.e. tool +Z points INTO the print frame, the way a nozzle/syringe sits over a bed. To attach a real tool offset, chain through Lite6 Custom Tool or Lite6 Tool (TCP) downstream. E (extruder) handling: when "Use Extruder" is true, transitions in E behavior emit DIGITAL_OUT targets on the supplied pin (high when E increased on the prior move, low otherwise). Useful for syringe-dispenser valves, FDM extruder enable pins, laser cutters, plasma cutters, etc. Default off keeps the output to motion only. Pure E-only moves (no XYZ change) are skipped on the motion path but still drive extrusion state.

Inputs

Outputs

Import (Import)

Parse slicer 3D-print G-code or CAM 5-axis NC toolpaths into a RobotTarget sequence. Pick the source with the Dialect input.

"Import", unified toolpath importer that parses either slicer-flavored 3D-print G-code OR CAM-flavored 5-axis NC G-code into a RobotTarget sequence, selected by a Dialect dropdown. Supersedes the separate "G-Code Import" (Slicer) and "NC Import" (CAM) components, which are kept hidden for backward compatibility with old .ghx files. Dialect = "Slicer" (default): Parses PrusaSlicer/Cura/Slic3r/generic 3D-printer G-code. Each emitted target's +Z points INTO the Print/Work Frame's -Z (nozzle/syringe over a bed). The E (extruder) axis can drive a DIGITAL_OUT pin (see Use Extruder / Extruder Pin). G0/G1 X Y Z E F, G90/G91, M82/M83, G92, G28, M104/M106/M107/M109/M140/M190. Dialect = "CAM": Parses Fanuc-style 5-axis NC (Fusion 360/HSMWorks/Mastercam post or hand-written). Orientation comes from A/B/C Euler (A=Rx, B=Ry, C=Rz); when A/B/C are absent the Tool Down plane orientation is used. G0/G1/G2/G3, G17/18/19, G54-G59, G90/G91, G20/G21, T/M6, M3/M5, M8/M9. Inputs not relevant to the chosen dialect are ignored (Extruder Pin / Use Extruder apply to Slicer only; Tool Down applies to CAM only).

Inputs

Outputs

NC Import (NC)

Parse 5-axis CAM NC G-code into a RobotTarget sequence.

"Lite6 NC Import", parses CAM-flavored 5-axis NC G-code (Fanuc-style) and converts it into a RobotTarget sequence. Companion to Lite6 G-Code Import (which targets 3D-printer slicer dialects). Use this for Fusion 360 post, HSMWorks, Mastercam, or hand-written 5-axis NC. Parsed commands: G0 X Y Z A B C F → PTP (rapid) G1 X Y Z A B C F → LIN (feed) G2 / G3 → currently emitted as 2× LIN (start → end). True arc with I/J/K decomposition is a future cycle. G17 / G18 / G19 → plane select (acknowledged via comment; arc decomp would use these) G54 - G59 → work coordinate system select (treated as identity) G90 / G91 → absolute / relative G20 / G21 → inch warning / metric default T<n> / M6 → tool change (emitted as comment) M3 / M5 → spindle on/off (emitted as comment) M8 / M9 → coolant on/off (emitted as comment) Orientation: A around X, B around Y, C around Z (Fanuc convention). When all three are present, target plane is built as the rotation Rz(C)*Ry(B)*Rx(A) applied to the work-frame's WorldXY. When A/B/C are missing, falls back to the Tool Orientation input (default WorldXY with Z flipped, tool points down).

Inputs

Outputs

Path Curve (PCv)

Sample a Rhino curve as a sequence of LIN targets at uniform arc length.

"Path Curve", sample any Rhino curve as a sequence of LIN targets. Lighter-weight than SPLine (which builds its own interpolated curve from N control planes). Use when you already have a Rhino curve from Brep edges, projected paths, or a CAD spline. Orientation: tool +Z follows the orientation plane's normal by default. Default plane = WorldXY → tool points down. Override for tilted milling / curved-surface following / aim-at-feature workflows (pair with `Orient Plane` upstream). Seed handling: the first IK solve uses the optional `Seed` input (joint angles in degrees), if not wired, defaults to home (all zeros). Each subsequent IK uses the previous sample's joints as its seed, so motion stays continuous through the path. If you see a "wrist flip detected" warning, the IK escaped to a different branch between two adjacent samples, wire a Seed that matches the configuration you want the path to live in (e.g., [-90, 100, 26, 0, -75, -90] for an arm reaching to the -Y side of base).

Inputs

Outputs

Reduce (Red)

Collapse consecutive collinear Cartesian targets within angle + position tolerance.

"Lite6 Reduce Toolpath", collapses consecutive Cartesian targets that lie (nearly) on a straight line within an angle tolerance. Drops the middle target when the turn angle at it is small enough that the robot wouldn't meaningfully change direction. Big win for slicer-generated paths (G-Code Import + dense SPLine outputs) where consecutive moves often deviate by less than 1°. Algorithm: sliding window of 3 (prev, mid, next). If both the position deviation (mid's perpendicular distance from the prev→next line) and the orientation deviation (angle between mid's Z axis and the interpolated Z axis at the same arc-fraction) are within tolerances, drop mid. Non-Cartesian targets (WAIT/IO/etc.) and waypoints with no TargetPlane are always kept (acting as anchors).

Inputs

Outputs

SPLine (Spl)

Interpolate a smooth toolpath through a list of planes; emit as dense LIN targets.

"Lite6 SPLine Movement", interpolates a smooth path through a list of input planes and emits it as a dense sequence of Lite6 LIN targets. SPLine Movement. The position curve is a Rhino interpolated curve through the plane origins. The orientation at each sample is interpolated by quaternion SLERP between the two surrounding input planes (parameterized by chord-length t). Each output target's joints come from IK with the previous target's joints as seed, giving continuous motion without surprise reconfigurations. Density is controlled by Step Length (mm). Default 5 mm = good for typical surface-following / 3D-printing / pumpkin-carving work. Lower for tighter curvature, higher for straight runs. Falls back gracefully: if any IK sample fails, that target is skipped with a warning; remaining targets continue.

Inputs

Outputs

Toolpath Optimizer (Optimize)

PREMIUM. Relieve singularities, smooth posture, avoid obstacles (beta), reorder for cycle time.

"Toolpath Optimizer" (PREMIUM), post-processes a RobotTarget list so it runs cleaner on the real arm. Four toggle-able tiers, applied in the order D → A+B → C: D. Optimize order, reorder moveable targets (nearest-neighbor + 2-opt) to cut travel. Non-motion steps (gripper/wait/IO) pin in place as fences, so a pick/place program is reordered only WITHIN each fence segment (it never scrambles a pick away from its place). A. Relieve singular, for each target, pick the IK branch farthest from the wrist singularity (|J5|→0); if the pose is inherently flat-wristed, tilt the tool the minimum amount (up to Max Tilt) to clear it. A round vacuum cup tolerates a few degrees of tilt for free. B. Smooth posture, choose IK branches that minimize joint travel between consecutive targets, so the wrist stops flopping between approach and pick. C. Avoid obstacles, BETA. Detect TCP-path collisions with obstacle meshes and insert a lift-and-detour over them. Detection covers the TOOL-TIP PATH ONLY, not the swept arm body, treat as an assist, validate before trusting. License-gated: on the free tier it passes targets through unchanged with a notice. A and B share one forward pass (both are IK-branch selection); their costs are combined.

Inputs

Outputs

3Pt Plane (3Pt)

Build a Plane from three points (origin, +X reference, +Y reference).

"Lite6 3Pt Plane", builds a Plane from three points: origin, a point along the desired +X axis, and a point in the +Y half-plane (used to orient Y).

Inputs

Outputs

Analog Output (AO)

Drive an analog output pin to a voltage (controller or tool side).

"Lite6 Analog Output", emits a single ANALOG_OUT target that drives a controller or tool analog output pin to a voltage. Pin range and voltage range are controller-dependent. On uFactory Lite 6, controller analog outputs (cGPIO) typically accept 0-10V; tool analog outputs (tGPIO) are usually 0-5V. The Pin Type input selects between the two. See xArm SDK set_cgpio_analog and set_tgpio_analog. Voltage is clamped to a sane [0, 10] range here; controller will further clamp to its actual hardware range.

Inputs

Outputs

Analysis (Anlz)

Per-target joint values + warnings for limits, singularities, and axis flips. Double-click for graphical view.

"Lite6 Analysis", exposes per-target joint values for plotting and flags toolpath problems that would cause the real robot to stop or misbehave. Analysis. Per-target checks: • **Joint limit**, Lite 6 joint values exceed the URDF-defined hardware ranges. • **Wrist singularity**, J5 close to 0 (J4 and J6 become coaxial; arm loses one DOF and IK becomes ill-conditioned, often causing axis-flip jumps). • **Elbow singularity**, J3 near full extension (cos(J3) close to 1, arm fully outstretched, Jacobian rank drops). • **Shoulder singularity**, TCP close to the J1 vertical axis (small XY radius from base), J1 becomes ill-defined and small Cartesian motions need huge J1 swings. Between-target check: • **Axis flip**, any joint changes by more than the Flip Threshold (degrees) between consecutive targets. Often signals an IK reconfiguration that the real arm can't follow at speed. Outputs joint values as six lists (one per joint, in degrees). Wire each into a Quick Graph for the classic per-axis plot, or use the Graph Curves output for an in-viewport preview polyline (joint deg vs target index, scaled to fit a unit box).

Inputs

Outputs

Approach / Retract (AppRet)

Insert LIN approach/retract moves at the path ends. Direction selects the offset source: Global (project onto a safe plane), Tool axis (along each target's local tool axis), or Path tangent (along the toolpath direction).

"Approach / Retract", inserts LIN approach/retract moves around the first/last Cartesian target of a toolpath. A single Direction selector chooses how the approach/retract offset vector is derived, consolidating three former components: • "Global" (formerly Safe Plane), projects the first/last TCP origin onto a single global safe plane. • "Tool axis" (formerly Tool Axis Offset), offsets along each target's local tool axis (its +Z, negated), so the move sits ABOVE the target. Respects per-target tool tilt. • "Path tangent" (formerly Tangential Offset), offsets along the local toolpath direction (first→second, prev→last), so entry/exit runs along the path (drag knife, welding lead-in, etc.). In every mode the inserted moves are LIN (straight-line Cartesian travel) and preserve the anchor target's orientation, SpeedPct and ToolOffset. IK is re-run with the anchor's joints as seed; if IK fails the move is dropped with a warning. Backward compatibility: the three original components still exist (hidden) so old .ghx files keep loading. New graphs should use this component.

Inputs

Outputs

Blend Radius (Blend)

Stamp a per-target blend radius (mm) for smooth continuous-velocity motion. Negative = stop at waypoint; 0 = sharp; >0 = arc blend.

"Lite6 Blend Radius", stamps a blend radius onto every target in a list, so the generated code emits set_position(..., radius=R) for continuous-velocity blending between waypoints. Semantics (from uFactory Studio motion characteristics): Radius < 0 → robot decelerates to zero at each waypoint (sharp stop) Radius = 0 → sharp corner, but continuous motion (no smoothing) Radius > 0 → circular blend with that radius, fastest smooth motion Recommended: 1-5 mm for tight toolpaths, 10-50 mm for sweeping paths.

Inputs

Outputs

Bounds (Bnd)

Safety filter: warn / clip / drop targets outside an XYZ workspace box.

"Lite6 Bounds", safety guardrail. Filter or clip Cartesian targets that fall outside a user-defined XYZ workspace box. Useful for hardware-protection, keep the tool away from the workpiece edge, keep the spindle off the fixture, etc. Modes: "warn", pass everything through, but warn for each violator (default). "clip", clamp the offending coordinate into the box, re-IK is NOT done (use Lite6 Cartesian Offset etc. to re-IK if needed). "drop", silently remove the violator from the output list.

Inputs

Outputs

Cartesian Offset (Off)

Translate all Cartesian target planes by a vector in base frame.

"Lite6 Cartesian Offset", translates every Cartesian target's TargetPlane and ViaPlane by a vector in robot base coordinates, and re-runs IK with prior joints as seed. Use cases: nudge an entire toolpath by a small delta (e.g. "everything 5mm higher in Z"), batch a stack of identical operations at different heights, or compensate for a measured fixture offset without re-authoring the path. Non-Cartesian targets (WAIT, WAIT_FOR_DI, DIGITAL_OUT, pure-joint PTP) pass through unchanged.

Inputs

Outputs

Collision (Col)

Flag targets where robot links collide with themselves or world meshes.

"Lite6 Collision", checks each target for likely robot self-collisions and (if you provide obstacle meshes) for collisions with the world. Conservative model: each link is a sphere chain along the kinematic frames; obstacles are treated as hard meshes via Mesh.ClosestPoint. False positives are possible (sphere model is rough); false negatives only occur when something escapes the sphere radius, pick a Link Radius that comfortably wraps the real link. Wire upstream of Lite6 Code / Live Send. If any target collides, the script downstream should NOT run unmodified. Use Lite6 Analysis alongside for joint- limit + singularity checks; both together catch most "shouldn't have moved there" classes.

Inputs

Outputs

Collision Sens (Coll)

Set the controllers collision-detection sensitivity (0=off, 5=highest). Place at the start of a sequence.

"Lite6 Collision Sens", emit arm.set_collision_sensitivity(level) once. xArm controllers accept 0-5: 0 = off (no protection), 1 = low (less likely to false trigger), 5 = high (very twitchy). uFactory recommends 3 as default; lower it if you're carrying load or doing fast moves that the SDK mis-reads as collisions.

Inputs

Outputs

Counter (Cnt)

Controller-side counter: reset / increment / read.

"Lite6 Counter", emit a counter command (reset / increment / read). Codegen emits the appropriate xArm SDK call. Useful for "do this N times" or "send signal every K cycles" patterns inside the controller without extra logic. RobotTarget storage: WaitDigitalPin = action code: 0 = reset to value, 1 = +1, 2 = no-op (read-only) WaitSeconds = initial value (for reset action)

Inputs

Outputs

Deconstruct Target (Decon)

Crack a RobotTarget open into parallel lists, TargetPlanes (the pose geometry), Motion type, joints, and Tag. The robot-target version of Grasshopper's Deconstruct; use it to draw/measure the target frames or feed their parts downstream.

"Lite6 Extract", pull planes / joints / motion type / tag out of a target list as parallel lists. Pairs with Lite6 Tag for "which one is the problem" debugging.

Inputs

Outputs

Digital Out (DO)

Drive a controller (default) or tool digital output pin to a value.

"Lite6 Digital Out", drive a digital output pin to a value. Defaults to the CONTROLLER box outputs (CO, set_cgpio_digital, pins 0-7); set Tool = true for the tool-flange outputs (DO, set_tgpio_digital, pins 0-1). For arbitrary I/O (relays, valves, lights, sensors); independent of the Pose component's gripper toggle. Code-gen: arm.set_cgpio_digital(pin, value) (controller) / set_tgpio_digital (tool). G-code: M62/M63 P<pin> (controller bank).

Inputs

Outputs

Frame (Frame)

Relocate a whole program to where your part actually sits: give the part's base plane and every target moves with it. Design once at the origin, then drop it onto the real fixture.

"Lite6 Frame", re-interprets a list of RobotTargets as if their plane targets had been authored in a local work-coordinate frame, and outputs new targets in robot base (world) coordinates. Typical workflow: the user designs a toolpath on a part (e.g. a hole pattern on a fixture) in its own coordinate system, then wires `[targets] → Lite6 Frame [base = where the part sits in robot world] → motion list`. Lets users physically reposition the fixture without re-authoring the toolpath. For Cartesian targets (PTP/LIN with a TargetPlane, or CIR with a ViaPlane), the planes are mapped from local→world via Transform.PlaneToPlane(WorldXY, Base), and IK is re-run with the previous joints as seed. Pure-joint targets (Pose-only PTP), WAIT, WAIT_FOR_DI, and DIGITAL_OUT are passed through unchanged, joint poses are not frame-dependent and utility commands have no spatial component. On IK failure for a transformed target: warns and KEEPS the original joints (so the script still emits SOMETHING and the user gets a clear error per-target, rather than the whole list silently breaking).

Inputs

Outputs

IO When (IoWhen)

Set a digital output when the TCP is within tolerance of a position. Controller-side trigger.

"Lite6 IO When", set digital IO when TCP is within tolerance of a target point. Controller-side trigger; fires once per pass through the position. uFactory Blockly equivalent: "Set I/O when (X, Y, Z, tolerance)". RobotTarget storage: TargetPlane.Origin = trigger XYZ WaitSeconds = tolerance in mm DigitalOutPin = IO pin DigitalOutValue = value when triggered WaitDigitalValue = tool side flag (true = tool, false = controller)

Inputs

Outputs

Info (Info)

Show the installed Egret plugin version, build date, and assembly path.

"Info", drop on any canvas to read the installed Egret version, build date, and assembly path. Useful for sanity-checking "is the new version actually loaded" after copying a new .gha into Grasshopper's Libraries folder and restarting Rhino.

Outputs

Orient Plane (Orient)

Rotate each plane around its origin so its -X axis aims at a target point.

"Lite6 Orient Plane", rotates each input plane around its origin so its -X axis points at a target point. Useful for milling, spraying, surface-following, and any process where the tool must aim at a feature. Convention: the -X axis of the plane (the "back" of the tool frame) is aimed at the target. Tool +Z (typically the tool axis) and tool +Y (typically the feed direction) are kept as orthogonal as possible to the original.

Inputs

Outputs

Path Optimizer (Opt)

Reorder LIN/PTP targets to minimize total travel distance (2-opt).

"Lite6 Path Optimizer", reorders a list of LIN/PTP targets to minimize total travel distance (and as a proxy, total program time). Nearest-neighbor seed followed by 2-opt improvement until no further reduction or budget hit. Cost model: Euclidean TCP-origin distance between consecutive targets (resolved via TargetPlane else Forward(joints)). Motion type and SpeedPct are ignored during optimization, the goal is shorter wire-distance, which corresponds well to shorter wall-clock for the dominant LIN-heavy case. Pair with `Lite6 Time Estimate` to compare before/after. Honors a Locked Range so commands that must stay in place (gripper actions, digital outputs, waits, start/end of program, tool changes) are not reordered. Anything OUTSIDE the optimization range is preserved at its original position; only the in-range targets are permuted. Non-motion commands (WAIT, DIGITAL_OUT, GRIPPER_CMD, etc.) inside the range also stay pinned at their original indices, only PTP/LIN/CIR are moved.

Inputs

Outputs

RPY Frame (RPY)

Build a coordinate frame (plane) from X/Y/Z (mm) + A/B/C (deg, uFactory Roll-Pitch-Yaw). Wire into a Robot's Root (mounting frame) OR a Frame's Base (work coordinate system).

"RPY Frame", builds a coordinate frame (plane) from typed X/Y/Z (mm) + A/B/C (deg), using the uFactory Roll-Pitch-Yaw convention. It is role-neutral: wire its output wherever you need a frame defined by numbers, the destination decides what it MEANS: • into a Robot's Root (Rt) → the robot MOUNTING frame (e.g. floor = 0/0, ceiling = A 180). • into a Frame's Base (B) → the WORK / base coordinate system (e.g. a 3-point touch-off origin like -275.2, -123.7, -30.53, 3.92°, 0, 0). A/B/C follow uFactory Roll-Pitch-Yaw (ZYX intrinsic Euler): A = roll about X, B = pitch about Y, C = yaw about Z, applied as Rz(C)·Ry(B)·Rx(A). Same convention the code generators and Custom Tool use, so the numbers you type here match the controller.

Inputs

Outputs

Repeat (Rep)

Concatenate N copies of a target list (e.g. run a sub-program once per piece). Same copying as Grasshopper's native Duplicate Data, the difference is the optional Tag Index (Idx), which suffixes each copy's Tag with _rep<i> so Deconstruct Target / Analysis / Code can tell the cycles apart. Without Idx, Duplicate Data does the same job.

"Lite6 Repeat", concatenate N copies of a target list. Trivial but commonly needed for production-line, per-piece, or per-segment patterns where the same sub-sequence runs multiple times. If Tag a copy index is on, each repetition gets its tag suffix '_rep' so downstream Extract / Analysis can distinguish copies.

Inputs

Outputs

Reverse (Rev)

Reverse a target list (for retrace / return-path workflows).

"Lite6 Reverse", return path generator. Reverses a target list so the robot retraces its steps. Useful for go-and-return patterns; pair with Lite6 Repeat for ping-pong cycles.

Inputs

Outputs

Safe Plane (Safe)

Prepend/append approach + retract LIN moves above the first/last Cartesian target.

"Lite6 Safe Plane", wraps a toolpath with approach/retract LIN moves so the robot enters and exits the workpiece from a known clear height. Behavior: finds the first Cartesian target with a TargetPlane and prepends a LIN move whose plane has the same orientation but origin projected onto the safe plane (along the safe plane's Z axis). Similarly appends a retract LIN after the last Cartesian target. Inserted moves carry the same SpeedPct as their neighbor, and IK is run with the neighbor's joints as seed. If there are NO Cartesian targets (e.g. all WAIT/joint), the component is a no-op, there's no TCP frame to project from.

Inputs

Outputs

Self Test (Test)

Run internal smoke checks (FK / IK roundtrip, mesh load, license state) and report pass/fail. Useful after install / upgrade / keypair rotation.

"Self Test", drop on any canvas to run a battery of internal smoke checks and surface a pass/fail report. Useful for verifying the install isn't broken after a Rhino upgrade, a .gha reinstall, or a keypair rotation. Checks (run on the wired robot model, default Lite 6): 1. Forward kinematics, FK at home pose returns a valid plane. 2. FK roundtrip, Forward(known joints) at a known config matches a manually-computed reference within ε. 3. IK convergence, Inverse on a workspace-center plane converges. 4. IK roundtrip, IK(FK(seed)) returns joints close to seed. 5. Joint-limit guard, WithinLimits correctly accepts in-range joints and rejects out-of-range. 6. Embedded mesh load, XArmMeshes.TryGetLinkMeshes returns non-null for the wired model. 7. License state, LicenseGate.GetStatus returns one of the expected states (FreeNoToken / Active / Expired / etc.), informational. 8. Document context, the picker walker (ResolveOrDocumentDefault) can find at least the default model. Outputs: Pass (P), bool, true if all CRITICAL checks pass. License state is informational and never fails the suite. Report (R), multi-line text summary suitable for piping into a Panel. Failed (F), number of failed checks (0 if all pass).

Inputs

Outputs

Tag (Tag)

Stamp a string tag onto every target in a list (or auto-number if Tag is empty).

"Lite6 Tag", stamp a string tag onto every target in a list. Lite6 Extract pulls the tags back out alongside the planes/joints for "which target was the problem" debugging. Auto-numbered tags if the Tag input is empty.

Inputs

Outputs

Tangential Offset (TanOff)

Insert LIN approach/retract moves along the toolpath tangent at the first/last Cartesian target. Use when the tool must enter / exit along the path direction (drag knife, welding lead-in, etc.) rather than perpendicular to the surface.

"Tangential Offset", inserts LIN approach/retract moves along the TOOLPATH TANGENT at the first/last Cartesian target. Differs from: • Safe Plane, offsets in a single global up direction (one shared normal for all approach/retract). • Tool Axis Offset, offsets along each target's local tool +Z (per-target normal). Used when the tool tilts across the path. • Tangential Offset, offsets along the local toolpath direction itself. Use cases: drag-knife cutting (entry/exit along the cut line, not above it), arc-welding lead-in / lead-out moves, threaded-tap entry, vibrating-blade laminar entry. Anywhere the tool must enter or exit "in the path direction" rather than perpendicular to the work surface. Tangent direction: • At first Cartesian target → vector from first to the next Cartesian target. Approach pose sits at (first.Origin − tangent × distance), preserving the first target's orientation. • At last Cartesian target → vector from the previous Cartesian target to last. Retract pose sits at (last.Origin + tangent × distance), preserving the last target's orientation. Inserted moves are LIN, straight-line travel in Cartesian space, so the tool enters/exits along a real geometric line, not the joint-space PTP arc.

Inputs

Outputs

Target Info (TInfo)

Break out one RobotTarget into its component fields (joints, plane, motion type, speed, tag, etc.). Companion to Stage.Tc, wire Stage's Current Target output here for live inspection while scrubbing.

"Target Info", inspector for a single RobotTarget. Pairs naturally with Stage's Current Target (Tc) output: wire a slider + Stage + Target Info to see exactly what target the scrubbed pose contains. Differs from Extract (which takes a LIST and returns parallel lists), this takes ONE target and surfaces the same fields as scalar outputs, plus a multi-line Summary text suitable for piping into a Panel.

Inputs

Outputs

Time Estimate (Time)

Estimate per-target and total program execution time in seconds.

"Lite6 Time Estimate", predicts execution time for a target list. Per-target seconds + program total + formatted H:MM:SS. Honors SpeedPct, MotionType, and BlendRadius (no settle when blending continues past a waypoint). LIN/CIR distances are computed from TargetPlane when present, else Forward(joints). Estimates ignore controller acceleration ramps, planning latency, and the real time uFactory takes to switch motion modes; treat them as lower bounds that get within ~10-20% of wall-clock for steady toolpaths. The Settle input is the per-stop pad that absorbs decel + comm, tune by comparing one real run. Useful for batch-cycle planning ("does this program fit in N seconds?") and for picking blend radii to hit a throughput target.

Inputs

Outputs

Wait (Wait)

Pause the program for a given number of seconds.

"Lite6 Wait", pause for a given number of seconds. Code-gen emits time.sleep(seconds). No robot motion. Use to dwell at a pose for curing, settling, photographing, etc.

Inputs

Outputs

Wait For DI (WaitDI)

Pause until a digital input pin reads the expected value.

"Lite6 Wait For Digital", block program execution until a digital input pin reads the expected value. Code-gen emits a polling loop on arm.get_tgpio_digital(pin).

Inputs

Outputs

BIO Gripper (Bio)

uFactory BIO gripper open/close command.

"Lite6 BIO Gripper", uFactory's pneumatic-style two-state gripper. Open or close via arm.set_bio_gripper_status. Suction-cup-friendly, fast cycle. Codegen emits the appropriate set_bio_gripper_status call. RobotTarget storage: WaitDigitalPin = 0 (encodes BIO type) WaitDigitalValue = true (open) / false (close)

Inputs

Outputs

Change Tool (Change)

Stamp the named state of a Multi-State Tool onto a target list.

"Lite6 Change Tool", stamps a named tool state onto every target in a list. Effectively a Custom Tool whose offset comes from a Multi-State Tool's named state.

Inputs

Outputs

Gripper (Grip)

Unified gripper command. Type = BIO / Robotiq / Vacuum; only that type's inputs apply. BIO: Open. Robotiq: Position(0=open,255=closed)/Force/Speed (untested on real hardware). Vacuum: On + Timeout.

"Gripper", unified gripper command. Pick the Type (BIO / Robotiq / Vacuum); only that type's inputs apply. Replaces the three separate gripper command components (which are now hidden). Same RobotTarget encoding as before (WaitDigitalPin 0/1/2 = BIO/Robotiq/Vacuum). BIO, Open (true=open, false=close). Robotiq, Position 0(open)-255(closed), Force 0-255, Speed 0-255. (UNTESTED on real hw.) Vacuum, On (true=suction, false=release), Timeout seconds (wait-stable).

Inputs

Outputs

Gripper Tool (GripTool)

Two-finger gripper preset: draws the tool on J6, sets the TCP at the jaw line, and stamps that offset onto your targets.

"Gripper Tool", a two-finger parallel-jaw gripper preset. Draws a body block plus two jaws on the flange, sets the TCP at the jaw line, and stamps that offset onto every target so downstream code/sim work at the grip point. Pair with the BIO Gripper command component (Open input) to actually open/close it on the real arm.

Inputs

Outputs

MS Tool (MSTool)

Define a tool with multiple named TCP states (e.g. open/closed gripper).

"Lite6 MS Tool", define a tool with multiple named states. Inputs are parallel lists: each state name + its TCP plane in the flange frame. Multi-State Tool.

Inputs

Outputs

Robotiq (Rq)

Robotiq gripper: position 0(open)-255(closed), force 0-255, speed 0-255. Codegen emits robotiq_reset + robotiq_set_activate (once) then robotiq_set_position per step. NOTE: built to the xArm SDK API but UNTESTED on real Robotiq hardware, verify before relying on it.

"Lite6 Robotiq Gripper", uFactory's Robotiq 2F-85 / 2F-140 adapter. Position 0-255 (0=fully open, 255=fully closed), force 0-255. arm.robotiq_set_position for jog moves; arm.robotiq_close() / arm.robotiq_open() for endpoints. RobotTarget storage: WaitDigitalPin = 1 (encodes Robotiq type) WaitSeconds = position (0-255) WaitDigitalValue = unused ToolOffset.OriginX = force (0-255), OriginY = speed (0-255)

Inputs

Outputs

TCP Load (TCPLoad)

Tell the controller the payload mass + center of gravity. Place at the start of a sequence.

"Lite6 TCP Load", emit a one-time arm.set_tcp_load(weight, [cog_x, cog_y, cog_z]) call. Place this target at the start of a sequence so the controller knows the payload mass + center of gravity. Improves motion smoothness and collision detection accuracy when the robot is carrying significant load. Weight is in kg (e.g. 0.5 for a 500g syringe + fixture). CoG xyz is in mm from the flange. uFactory Blockly equivalent: "Set TCP Load Weight and XYZ Offset". Overloads RobotTarget fields: WaitSeconds = weight (kg) WaitDigitalPin overloaded as int(WaitSeconds field is used only for weight here) (CoG xyz is packed via ToolOffset.Origin since we already have a Plane field.)

Inputs

Outputs

Tool (Tool)

Define a tool and stamp its TCP onto your targets. Type=Custom: type X Y Z (mm) + Roll Pitch Yaw (deg) from uFactory Studio's tool-coordinate field (for a straight tool just set Z). Type=Gripper / Vacuum: built-in presets with auto mesh, TCP and payload. Set Weight (kg) for set_tcp_load. Absorbs the old Gripper Tool / Vacuum Tool presets.

"Lite6 Custom Tool", defines a Tool Center Point offset (a Plane in the flange/link6 frame) and stamps it onto a list of RobotTargets. Inputs: - Targets: the list to stamp. - Tool Plane: the TCP in the flange frame. Default WorldXY = no offset. - Tool Meshes: optional mesh(es) representing the physical tool (in flange frame). Passed through unchanged; downstream the user transforms them with the flange pose from Lite6Sim. Sim does NOT auto-render them (next cycle could). Outputs: - Targets: same list with ToolOffset stamped on every target. - Tool Meshes: passthrough of the input meshes (so it's easy to wire into a Transform). - TCP Status: short description of what was applied. Behavior in downstream components: - Lite6Sim: TCP output becomes flange * ToolOffset instead of flange alone. - Lite6Code: emits arm.set_tcp_offset([x,y,z,roll,pitch,yaw]) once in the header when any target carries a non-null ToolOffset.

Inputs

Outputs

Tool (TCP) (ToolTCP)

Aim the TOOL TIP (not the wrist flange) at your target planes. Tell it how far the tool sticks out and it re-solves the moves so the tip lands on each plane. Use when you drew your path at the tip, the usual case for tools like pens, nozzles, or grippers.

"Lite6 Tool (TCP)", applies a Tool Center Point offset to a list of RobotTargets, treating each Cartesian target's TargetPlane as the desired TCP location (not the flange location). Re-runs IK so the FLANGE goes wherever it needs to in order for the TCP to land on the user-supplied plane. PTP/LIN/CIR work together when the user wires a Tool into a motion component. Contrast with Lite6 Custom Tool (the other component): - Custom Tool = "stamp only". TargetPlane stays as the flange pose; IK already targeted it. TCP = flange × tool offset for Sim and codegen output only. Use this when you authored flange poses directly. - Tool (TCP) = "re-target IK". TargetPlane is treated as the TCP target. New flange target = TargetPlane × inverse(toolOffset), IK re-runs against that. Use this when you authored TCP poses (most common in CAM-style workflows). Pure-joint targets, WAIT, WAIT_FOR_DI, and DIGITAL_OUT pass through unchanged (no Cartesian target to re-IK against).

Inputs

Outputs

Tool Axis Offset (ToolAx)

Insert LIN approach/retract moves offset along each target's local tool axis.

"Lite6 Tool Axis Offset", inserts LIN approach/retract moves offset along EACH target's local tool axis (its +Z by default, negated for approach). Unlike Safe Plane which projects onto a single global plane, this respects per-target tool orientation, critical when the tool tilts across the path (5-axis milling, spraying, deposition onto curved surfaces). Tool Axis Offset. Approach insertion: prepend a LIN move at first-target-plane + Offset × (-toolAxis). Retract insertion: append a LIN move at last-target-plane + Offset × (-toolAxis). Tool axis defaults to each target's local Z (the tool plane's normal); for a downward-pointing tool the offset puts the approach ABOVE the target.

Inputs

Outputs

Vacuum (Vac)

Vacuum gripper on/off with optional wait-until-stable timeout.

"Lite6 Vacuum", uFactory vacuum gripper (suction-cup) on/off. arm.set_vacuum_gripper with optional wait-until-stable timeout. RobotTarget storage: WaitDigitalPin = 2 (encodes Vacuum type) WaitDigitalValue = true (on) / false (off) WaitSeconds = wait-stable timeout in seconds (0 = no wait)

Inputs

Outputs

Vacuum Tool (VacTool)

Suction-cup preset: draws the cup on J6, sets the TCP at the cup face, and stamps that offset onto your targets.

"Vacuum Tool", a suction-cup preset on a stem. Draws the stem + cup on the flange, sets the TCP at the cup face, and stamps that offset onto every target. Pair with the Vacuum command component to switch suction on/off on the real arm.

Inputs

Outputs

Path Preview (PathPrev)

Draw the TCP toolpath in the viewport: a colored trail through every Cartesian target (PTP dotted, LIN solid, CIR arc), with optional direction arrows and tool frames. Outputs the path as a Polyline curve.

"Path Preview", draw the TCP toolpath in the Rhino viewport: a colored trail through every Cartesian target. PTP shows dotted/grey (rapid, joint- interpolated, the TCP does NOT follow this line), LIN solid/blue, CIR as the true arc/teal. Optional travel-direction arrows and per-target tool frames. Non-Cartesian commands (WAIT, DIGITAL_OUT, gripper) carry no pose and are skipped. Makes approach/retract and offset moves (Tangential / Tool Axis / Safe Plane) visible instead of inferring them from a target count. Also outputs the path as a Polyline curve you can bake.

Inputs

Outputs

Player (Play)

Scrub through a target list with a 0..1 slider for animation playback.

"Player", virtual playback. Drag a 0..1 slider (or animate it) and the output target scrubs through the input toolpath, lerping joint angles between adjacent motion waypoints. Wire output into Stage.T to watch the arm move through the program in the Rhino viewport. Modes: "interp", lerp joints between adjacent waypoints for smooth motion (default). "step", snap to the nearest pose-bearing target. Useful for verifying individual targets one at a time. Non-motion commands (WAIT, DIGITAL_OUT, gripper, etc.) carry no pose to interpolate. The player skips them, the arm holds the previous motion pose, matching how the real robot behaves during waits / IO. Use Time Estimate: when true, weights each segment by its estimated execution time (same model as the Time Estimate component) so slow segments take proportionally more slider travel, playback then mirrors real wall-clock proportions. When false, every segment is an equal slice of the 0..1 timeline (pure uniform-per-step playback).

Inputs

Outputs

Stage (Stage)

Visualize the robot, scrub the toolpath, see per-joint plots. Double-click for the Stage form. Outputs link meshes, TCP, and a passthrough Targets list.

"Stage", the canvas-level hub for visualizing a toolpath on the selected robot. Renders the arm at the last pose (or all poses overlaid, or a single scrubbed pose when its double-click form is open). Outputs link meshes, TCP plane, TCP orientation axes, status, and a passthrough Targets list for downstream Analysis / other consumers. Double-click on the canvas to open the Stage form: timeline scrubber, per-joint spark plots with limit lines, live TCP/joint readout, and (eventually) the license-activation panel.

Inputs

Outputs

Workspace (Work)

Show how far the robot can reach: a cloud of reachable tool points plus a bounding box. Use it to check a part fits inside the working envelope before you program moves.

"Lite6 Workspace", samples the reachable TCP positions for the selected robot by sweeping the first 3 joints (the shoulder/elbow that dominate position) across their hardware limits and computing forward kinematics. Wrist joints stay at 0. Output is a point cloud you can wire into a hull / Mesh from Points / point preview. Coarse but fast: default 8 samples per joint = 8^3 = 512 points. Bump to 16 for a denser envelope (~4k points, still sub-second).

Inputs

Outputs

Code (Code)

Turn your list of targets into a ready-to-run Python program for the robot (xArm Python SDK). Copy the output to a .py file and run it on a PC connected to the controller. Wire into a Panel to read it.

"Lite6 Code", takes a list of RobotTargets + robot IP + base speed, emits a Python script that uses xArm-Python-SDK to execute the sequence. The generated .py runs on a computer connected to the robot, NOT necessarily the machine running Rhino. Output is text, user saves to file or pipes.

Inputs

Outputs

G-Code Export (GCode)

Emit uFactory-dialect G-code (RS-274 / LinuxCNC-compatible) executable on any uFactory controller. (Exporter, not to be confused with the 'Import' component that reads G-code/NC in.)

"Lite6 G-Code", emits 6-axis G-code (X/Y/Z + A/B/C) from a list of RobotTargets. Output conforms to uFactory's G-code dialect (RS-274 / LinuxCNC-compatible) and runs natively on the Lite 6 controller via uFactory Studio's G-code panel. Reference: https://docs.ufactory.cc/user_manual/ufactoryStudio/6.gcode.html Mapping (uFactory-supported): PTP → G0 (rapid; X Y Z A B C) LIN → G1 (linear feed; X Y Z A B C F&lt;linear&gt;) CIR → two G1 segments (via, then end). G2/G3 with R or I/J/K are supported by uFactory but require a planar arc and a plane select (G17/G18/G19); non-planar 3-point robot arcs are decomposed into linear segments instead. WAIT → G4 P&lt;seconds&gt; WAIT_FOR_DI → emitted as a COMMENT only, uFactory G-code does not include M66 / wait-for-input. To gate on a digital input on the Lite 6, use Lite6 Code (Python) instead. DIGITAL_OUT → M62 P&lt;pin&gt; (on) / M63 P&lt;pin&gt; (off), synchronized with motion Gripper → M116 P&lt;type&gt; Q&lt;action&gt;, uFactory end-effector control, where P is the TYPE (1=Gripper, 2=Vacuum, 3=BIO), auto-set from the upstream gripper command. Vacuum: Q1=suction on, Q0=release. A/B/C are ZYX intrinsic Euler in degrees, matching xArm set_position. X/Y/Z are the target's TOOL TIP by default (so the controller's TCP/tool offset must be set to match), UNLESS "Bake Tool Offset" is on , then the tool offset is folded into X/Y/Z so they are the FLANGE and the program runs self-contained with the controller TCP at 0.

Inputs

Outputs

SavSave Code (SaveCode)

Write generated Code (Python) or G-Code text to a file. Overwrite guards an existing file.

"Lite6 Save Code", write generated program text to a file on a rising-edge Save trigger. Takes the text output of either the Code Gen (Python) or G-Code component and writes it to disk, so a toolpath can be saved straight from the canvas instead of copy-pasting. An Overwrite toggle guards an existing file: OFF (default) refuses to clobber it and reports it; ON replaces it. The parent folder is created if missing. Distinct from "Save Traj", which serializes the RobotTarget list to .ltraj for round-tripping back into Grasshopper; this saves the final program you actually run on the robot.

Inputs

Outputs

Save Traj (Save)

Write a RobotTarget list to a .ltraj JSON file.

"Lite6 Save Trajectory", write a RobotTarget list to a .ltraj JSON file on disk. Round-trips through Lite6 Load Trajectory. Useful for saving authored toolpaths between Rhino sessions, sharing with teammates, or feeding non-GH tools.

Inputs

Outputs

Connect (Conn)

Open a persistent TCP connection to a uFactory bridge process. Output handle wires into Live State / Live Send / Drag Mode / Record.

"Lite6 Connect", opens a persistent TCP connection to the Lite6 bridge process and outputs a connection handle for downstream live-control components (Lite6 Live State, Live Send, Drag Mode, Record Trajectory). The bridge is a small daemon (shipped as egret-bridge.exe) that sits between this plugin and the xArm Python SDK. When Host is local and Auto-start is on, Connect launches it automatically (see BridgeLauncher); default host/port is 127.0.0.1:65432.

Inputs

Outputs

Drag Mode (Drag)

Toggle robot manual / free-drive mode. Drag the arm by hand while Live State mirrors it in Rhino.

"Lite6 Drag Mode", toggles the robot's manual / free-drive mode (mode 2 on xArm-family controllers). When on, you can physically grab the arm and move it; the controller logs joint positions but does not actively drive. Pair with Lite6 Live State to see the arm position in Rhino as you move it. Sends bridge cmd "manual_drag" with on=bool. Bridge switches mode and returns the SDK code.

Inputs

Outputs

Enable (Enable)

Run motion_enable + set_mode(0) + set_state(0), clears state 4/5 safety stops and puts the controller back into sport (ready) state. Wire Connect.Connection into C and toggle Go to send. Status shows the per-step SDK codes.

"Enable", clears the controller out of an emergency-stop / safety state (state 4, 5, or any non-zero) and gets it back to the sport / ready state where motion commands work. Runs the standard xArm startup sequence: motion_enable(True) → set_mode(0) → set_state(0). Use this any time you see a status reply like "code=9: emergency stop / safety state" or "code=11: controller state error". Typical triggers: • Collision detection fired and stopped the arm. • You pressed the physical or virtual E-stop. • A previous motion command failed and the controller latched. • Just powered on; controller starts in state 4. Equivalent to the "Enable" / "Set Ready" button in the xArm Studio web UI.

Inputs

Outputs

Get IO (GetIO)

Read controller + tool digital/analog IO state via bridge.

"Lite6 Get IO", polls the bridge for current digital I/O + analog input states. Wire a Timer upstream for continuous monitoring. Outputs lists indexed by pin for easy graphing / threshold-trigger workflows.

Inputs

Outputs

Home (Home)

Send the robot to its home (all-zero joint) pose via the bridge.

"Lite6 Home", sends the robot to its zero/home pose (all joints 0°) via the bridge. Useful as the first command after enabling motion, or as a fixture- avoidance reset between operations.

Inputs

Outputs

Live Jog (Jog)

Stream a target to the robot in servo mode for smooth real-time following (bridge-side servo loop, velocity-clamped). Hold Jog true to follow.

"Lite6 Live Jog", smooth real-time following via xArm servo mode (mode 1). Unlike Live Send (discrete point-to-point set_position, which stutters when streamed), Live Jog hands the bridge a continuously-updated target; a servo loop ON THE BRIDGE feeds set_servo_cartesian at ~125 Hz, interpolating toward the latest target with a velocity clamp. The result tracks your hand in real time instead of move-stop-move. Wiring: Connection + Target + a Jog toggle (+ a GH Timer or a moving Target to drive re-solves). Hold Jog true to follow; set false to stop (returns the arm to position mode). Two modes, auto-detected from the target: a JOINT target (a Pose) jogs in joint space, each joint servos to its angle (move J1 -> only J1 moves); a CARTESIAN target (has a TargetPlane, e.g. from Cartesian Target / PTP / LIN) jogs the TCP. SAFETY: servo mode has NO acceleration limit on the controller side, the bridge's velocity clamp + 0.5s deadman + floor guard are what keep it safe. Start with a LOW Speed, e-stop in hand.

Inputs

Outputs

Live Send (Send)

Push a single RobotTarget to the bridge for immediate execution.

"Lite6 Live Send", pushes a single RobotTarget to the robot immediately via the bridge, no codegen step. Wire Connection + Target + a trigger. Returns the bridge's response code so you can chain "wait for completion" logic with downstream Lite6 Live State polls. PTP with joints-only → bridge cmd "move_joint" (set_servo_angle). PTP / LIN / CIR with TargetPlane → bridge cmd "move" (set_position). CIR via plane is currently sent as the END pose only (full move_circle from the bridge is a future cycle).

Inputs

Outputs

Live State (Live)

Poll the bridge for current robot joint/TCP/IO state. Wire a Timer upstream for continuous updates.

"Lite6 Live State", polls the bridge for the robot's current joint angles, TCP pose, and IO state. Wire a GH Timer upstream (e.g. 100ms) to get a continuously-updating digital twin in Rhino. Outputs are designed to flow into Stage (joints → see the real arm in viewport) and into Live Send (use current pose as a seed for next move).

Inputs

Outputs

Play Recording (Play)

Load + play a controller-recorded .traj by name (xArm native trajectory). Replays straight from Grasshopper.

"Lite6 Play Recording", load + play a controller-recorded .traj by name (the xArm native 250 Hz trajectory recorded via the Record component). The file lives on the CONTROLLER, not the PC, this replays it straight from Grasshopper instead of bouncing to uFactory Studio. Bridge: load_trajectory(file) + playback_trajectory(times, double_speed). Pairs with Record (which now persists via save_record_trajectory). SAFETY: this drives the real arm through the entire recorded path. Edge- triggered (fires once on Play rising edge), low/normal speed, e-stop in hand.

Inputs

Outputs

Record (Rec)

Start / stop the controller's onboard 250Hz trajectory recorder.

"Lite6 Record", start/stop the controller's onboard 250Hz trajectory recorder. Recorded files (.traj) live on the controller. Companion to Drag Mode: enable drag, hit Record start, move the arm by hand, hit stop, playback later via xArm Studio or your own bridge calls. xArm SDK convention: max ~5 minutes per recording.

Inputs

Outputs

Robot Info (RobotInfo)

Serial + firmware versions read from the controller via bridge.

"Lite6 Robot Info", fetch serial number + firmware versions from the controller via bridge. Mostly for confirming you're talking to the robot you think you are (fleet sanity), and for paste-into-bug-reports.

Inputs

Outputs

Set Mode (Mode)

Push controller mode change (0=position, 2=manual, 6=simulation, etc).

"Lite6 Set Mode", pushes arm.set_mode(N) via the bridge. 0 = position control (the default for codegen scripts) 1 = servo control (high-rate streaming, advanced) 2 = manual / free-drive (drag the arm by hand, same as Lite6 Drag Mode) 4 = joint motion (used for some streaming patterns) 6 = simulation (no physical motion)

Inputs

Outputs

Set Mode/State (ModeState)

Push controller mode and/or state. Mode: 0=position, 2=manual, 6=sim. State: 0=ready, 3=pause, 4=stop. Wire only the one you want, or neither for the standard init (0/0).

"Set Mode/State", push controller mode and/or state via the bridge in one step. Replaces the separate Set Mode + Set State components (now hidden). Wire only Mode to set mode, only State to set state, or neither to push the standard init (mode 0 + state 0 = position control, ready). Mode: 0=position (normal), 1=servo, 2=manual/free-drive, 4=joint, 6=simulation. State: 0=ready (motion allowed), 3=pause, 4=stop.

Inputs

Outputs

Set State (State)

Push controller state change (0=ready, 3=pause, 4=stop).

"Lite6 Set State", pushes arm.set_state(N) via the bridge. 0 = ready (motion allowed) 3 = pause 4 = stop

Inputs

Outputs

Stop (Stop)

SOFTWARE stop, halts motion now and sets the controller to Stop state (arm.emergency_stop). NOT a hardware e-stop: no power cut or lockout, and motion can be re-enabled (even from Studio). Use the physical red button for real emergencies.

"Lite6 Stop", a SOFTWARE stop. Sends arm.emergency_stop(): motion halts and the controller drops to Stop state. This is NOT a safety e-stop, it does not cut motor power or engage a lockout, and any client (Egret or Studio) can re-enable and drive again. For real emergencies use the PHYSICAL red button on the controller. Wire this to a panic toggle or a watchdog condition for a quick software halt.

Inputs

Outputs

Test Bridge (Ping)

Ping the bridge and measure round-trip latency.

"Lite6 Test Bridge", sends a ping to the bridge and reports round-trip latency. Useful for debugging connection issues, measuring polling overhead before wiring a fast Live State Timer, and confirming the bridge's robot connection is alive.

Inputs

Outputs

Mount (Mount)

Robot mounting frame from Tilt + Rotation (uFactory install). 0=floor, 90=wall, 180=ceiling. Orientation only, wire into a Robot's Root (Rt).

"Mount", the robot MOUNTING frame from just Tilt + Rotation, matching the uFactory install settings (which are two angles, not a full pose). Orientation ONLY, no position: the robot base stays at the origin and is reoriented. Where the WORK sits (including any Z offset to the part) belongs to the base coordinate system, i.e. the Frame component, NOT here. Output wires into a Robot's Root (Rt). Tilt: degrees from upright. 0 = floor (upright), 90 = wall, 180 = ceiling (inverted). Rotation: degrees of yaw about vertical, which way the mounted arm faces. Convention: Rz(rotation) · Rx(tilt). VERIFY against your robot's mounting on hardware at low speed.

Inputs

Outputs

Robot (Robot)

Pick a uFactory robot model via right-click. For per-model draggable pickers, use Lite 6 / xArm 5/6/7 / UF 850 in this same subcategory.

"Robot", drop on canvas, right-click to pick a uFactory model, outputs a robot reference that wires into the optional Robot input on every motion / utility / sim / codegen component. The selected model is shown on the component face (below the name) so you can see at a glance which arm the downstream graph is targeting. Selection persists on the GH document (Read/Write). Default = Lite 6 so the component behaves like the rest of the plugin out of the box when unwired.

Inputs

Outputs