make_robot("<name>") returns a RemoteRobot. Its attributes are the methods and subcomponents below, and every call runs on the robot; the driver behind it is Go2. Connecting neither starts nor moves the robot — it attaches to one that is already up. A method that fails on the robot arrives as RuntimeError naming the original error in its message. The client packages this page uses are preinstalled in every GRID session workspace and in the Python environment the GRID CLI prepares when you run a program with skill run; there is nothing to install.
Methods on the robot
Called asrobot.<method>(...).
commandJointsPD()
Signature
setJointAngles.
Motors named by joint_indices (SDK order) get the position PD
command; every other motor is parked at the firmware’s position and
velocity stop values with zero gains, so it is not actuated.
required
SDK motor indices to drive.
required
Target joint positions (rad), aligned to
joint_indices.required
Per-joint position gains, aligned to
joint_indices.required
Per-joint damping gains, aligned to
joint_indices.getBatteryState()
Signature
getControlState()
Signature
base_lin_vel is absent and
a policy consuming that term is rejected at driver construction.
Returns:
The latest control-loop state.
Raises:
RuntimeError: If no low-level state has been received yet.
getFootForce()
Signature
getIMU()
Signature
getImage()
Signature
str
default:"''"
name of the camera. May be omitted when the robot has exactly one camera.
str
default:"''"
supported image types depend on camera, for the built-in
front camera only “rgb” is supportedgetLidarPointCloud()
Signature
str
default:"''"
Name of the lidar. If empty, uses the first available lidar.
getLowLevelState()
Signature
getMotorState()
Signature
getOrientation()
Signature
optional, str
unused
getPosition()
Signature
optional, str
unused
getState()
Signature
_local_state, and the walk composes the per-component
results into one nested mapping. Subclasses must not replace
this method — per-component state belongs in _local_state.
With no keys, returns this component’s local state merged
with one nested node per subcomponent name — the tree structure
is the nesting itself, and the names mirror subcomponents
(and therefore serialize() and edge introspection): a
two-arm rig returns {"left_arm": {"joint_positions": ...}, "right_arm": {...}}, and a leaf component returns its local
state alone. A component whose state could not be read (dead
telemetry, not yet started, already shut down) carries an
"error" entry — {"error": "<ExceptionType>: <message>"},
with its children still nested alongside — instead of its state
keys. Errors are contained per node: one failing component never
loses the rest of the snapshot, and the walk still descends into
the failing component’s children. "error" is reserved for
that purpose, and local state keys must not collide with
subcomponent names; a hook violating either is reported as that
node’s error.
With keys, returns a flat mapping with one entry per match.
Each key is a /-separated path through the component tree:
every segment names a subcomponent, and the final segment may
instead name an entry in that component’s local state. Because
structure is the nesting, a literal path is the same as plain
indexing — getState(["left_arm/joint_positions"]) returns
the value of getState()["left_arm"]["joint_positions"] — and
a path ending on a subcomponent yields that component’s full
nested node. Segments may use shell-style wildcards over
subcomponent names — * matches within one chunk and **
matches any chain of chunks — so "*_arm/joint_positions"
fans out to one entry per arm, keyed by the concrete matched
path. Wildcards never match state entries; only a literal final
segment does. A key that matches nothing raises, so a typo is
loud rather than silently absent. A matched component whose
state read failed yields {"error": "..."} at its path.
Keyed reads are lazy: a hook runs only where a key lands — a
literal path executes the final component’s hook alone (not the
nodes traversed on the way), a glob executes only the matched
nodes, and each component’s hook runs at most once per call
however many keys reach it. Components with a selective-read
hook (_local_state_entries — every Robot with
registered state getters) go further and execute only the getters a key names, so
a ** glob probes their registries without touching
hardware. The caller pays only for the state actually
requested; ** and the no-keys form visit the whole tree
because that is the request.
State is cheap by convention: local state carries kinematics,
status, and health — never bulk sensor payloads (camera frames,
point clouds, scans), which stay in their dedicated methods
(getImage, getPointCloud, …). Callable on a stopped
tree — reading state after a soft e-stop is when it matters most
— and on a partially started one, where unstarted components
report a per-node error instead of failing the call.
State paths to read, or None for the full nested snapshot. A single string is shorthand for a one-element list.
keys is None, otherwise a
flat mapping of matched path to state value or nested node.
Raises:
TypeError: If keys is neither None, a string, nor a
list/tuple of strings.
ValueError: If a key is empty, has an empty path segment, or
matches no subcomponent path or state entry.
getWirelessRemoteState()
Signature
wireless_remote byte buffer from the latest LowState_.
Raises:
RuntimeError: If no low-level state has been received yet.
lieDown()
Signature
self.client does not exist — it interpolates every motor from
its measured position to GO2_LIEDOWN_POSE at the hold gains, so
the robot settles rather than collapsing.
default:"4.0"
Seconds to spend on the descent (low-level only). Slower is gentler.
moveByVelocity()
Signature
v × t would predict (observed ~40–60% over a one-second
window). Re-issue at high rate (e.g. 10 Hz) for sustained motion
past about a second.
Body-frame z linear and x/y angular components are discarded —
the Go2 cannot translate vertically nor roll/pitch on demand.
Velocity
required
Body-frame linear velocity.
x_vel (forward, m/s), y_vel (left, m/s); z_vel is discarded.Velocity
required
Body-frame angular velocity.
z_vel (yaw rate, rad/s); x_vel and y_vel are discarded.optional, str
default:"'body'"
Reference frame of the command. Defaults to
"body". "world" is not supported.rl_locomotion configured the command is latched for the
policy instead of sent to the built-in controller, so a caller — a
teleop script or the nav stack — drives a learned gait through this
same contract without knowing a policy is running. The policy tracks
the command continuously, so the decay and ramping described above do
not apply.
Raises:
NotImplementedError: If low_level_control was enabled on
construction without an RL policy (only the high-level
controller implements this), or if frame="world" is
requested.
setDamping()
Signature
default:"8.0"
Damping gain applied to every leg motor.
setDefaultJointAngles()
Signature
required
Value of the joint position.
setDefaultJointVelocities()
Signature
required
Value of the joint velocity.
setJointAngles()
Signature
dict
required
Dictionary mapping joint names to target positions
setJointTorques()
Signature
dict
required
Dictionary mapping joint names to target torques
setJointVelocities()
Signature
dict
required
Dictionary mapping joint names to target velocities
setZeroTorque()
Signature
standUp()
Signature
stop()
Signature
subcomponents insertion order), then this
component’s own _stop_self hook runs. The walk is
best-effort — a failing component never prevents the rest of the
tree from being stopped; failures are collected and raised
together after the walk completes. Components (and their
subtrees) that have already been shut down are skipped. Safe to
call repeatedly: stopping an already-stopped tree re-runs the
hooks, which must tolerate that. Blocks until every hook has
returned.
Stops motion only; resources stay live and the component remains
usable — telemetry and every other public method keep working on a
stopped tree. Use shutdown to release resources. Stopping
re-arms each visited component, so a later start re-runs
the bring-up hooks — that is the stop-then-start restart path —
but it does not revoke callability: only shutdown does
that.
Subclasses must not replace this method — per-component stop
behavior belongs in _stop_self. An override may only
extend the walk (adding a driver-specific mode, as UR5e does
with its immediate escape hatch) and must delegate to
super().stop() for the normal path; it must never
re-implement the recursion.
Raises:
ComponentStopError: If one or more stop hooks raised. The
walk still visited every component; the exception carries
every (component_path, exception) pair.
Properties on the robot
Read asrobot.<property>; each read runs the getter on the robot.
Dict[str, PolicyDriver]
The robot’s registered policy drivers, keyed by name.Empty on a robot constructed without RL. Lazily created, so the mixin
needs no cooperation from the host robot’s
__init__.robot.front — camera
Reached asrobot.front; its methods are Go2Camera’s and run on the robot.
The Go2’s front camera, read over the Unitree DDS video client.
Methods inherited from the component base are shown in brief here; their full descriptions are under Methods on the robot above.
front.getCameraExtrinsics()
Signature
front.getCameraIntrinsics()
Signature
front.getCameraSettings()
Signature
front.getData()
Signature
front.getImage()
Signature
compressed=False to get a decoded RGB ndarray
instead — pays a JPEG decode on every call, but matches the
legacy API for callers that expect ndarrays.
str | None, optional
no effect for Go2Camera — only JPEG is supported. Kept for API compatibility.
bool, optional
default:"True"
when True (default) return the raw JPEG bytes via
Image(..., encoding_format="jpeg"). When False, decode to an RGB ndarray and return Image(rgb_ndarray).compressed. None if the SDK call fails.
front.getState()
Signature
front.recordCalibration()
Signature
front.reloadCalibration()
Signature
front.setCameraExtrinsics()
Signature
front.setCameraIntrinsics()
Signature
front.setCameraSettings()
Signature
front.stop()
Signature
robot.go2_lidar — lidar
Reached asrobot.go2_lidar; its methods are Go2Lidar’s and run on the robot.
Bridge the Go2’s onboard LiDAR into the GRID Lidar interface.
Methods inherited from the component base are shown in brief here; their full descriptions are under Methods on the robot above.
go2_lidar.getData()
Signature
go2_lidar.getPointCloud()
Signature
None.
default:"LIDAR_SOURCE_HEIGHT_MAP"
Which LiDAR product to return.
"height_map" (default) converts Unitree’s fused elevation grid to one point per observed cell, robot-centred with +x forward. "cloud" returns the raw LiDAR returns of the most recent message, in the sensor’s own frame. The class docstring sets out how the two differ in dimensionality, extent, freshness and frame.PointCloud, or None if the messages it
needs have not arrived yet or hold no usable points. The
"height_map" source needs both a height map and a robot
pose, each no older than HEIGHT_MAP_MAX_AGE_S, so it
returns None until each has arrived and again once either
stops — which is what the Go2 does with the height map the
moment it sits or lies down. Each distinct reason is logged
once rather than once per call.
Raises:
ValueError: If source is neither "height_map" nor
"cloud".
go2_lidar.getState()
Signature
go2_lidar.stop()
Signature
Not implemented on this robot
Declared by the interface, raisesNotImplementedError here: getJointAngles.
Lifecycle and configuration
The driver’s own bring-up and configuration hooks. The edge runs them when the robot comes up; do not call them from a program. Note thatrobot.shutdown() on the proxy is not the method below — it is RemoteRobot.shutdown(), which closes your connection and leaves the robot as it was.
addPolicy()— Register a policy driver under a name.addSensor()— Add an external sensor to the robot.addSubcomponent()— Attach a child component under a name.builtin_subcomponents()— Declare thefrontcamera every Go2 ships with.configHash()— Hash this component’s serialized config subtree.config_schema()from_config()— Construct this component and its config-declared subtree.getIdentity()— Get this component’s own hardware identity (serial, model, version, MAC).getRobotId()— Stable, readable identifier for a robot or rig, for a database key.isPolicyAlive()— Return whether a policy control loop is currently running.raiseForPolicyError()— Re-raise the exception that killed a policy control loop, if any.serialize()— Serialize this component tree back to its config envelope.setup_shutdown_handlers()— Register the process-wide atexit and signal handlers for safe teardown.shutdown()— Shut down this component’s tree, halting motion and releasing resources.start()— Bring this component’s tree online (connect, enable, arm).startPolicy()— Run the policy startup handshake, then begin closed-loop control.stopAllPolicies()— Stop every registered policy control loop.stopPolicy()— Stop a policy control loop.
Image — call decode() for an ndarray). You reach the robot through make_robot.