Protocol Documentation

Table of Contents

commands.proto

Top

ProtobufQuestNavCommand

Main command message sent to the QuestNav system.

This is the primary message type used to send commands from external systems

(like robot code) to the Quest headset. Each command includes a type identifier,

a unique tracking ID, and optional payload data specific to the command type.

The command system is designed for asynchronous operation - commands are sent

and responses are received separately, matched by the command_id field.

Message Flow:

1. Client creates command with unique command_id

2. Client sets appropriate type and payload

3. Client sends command to Quest

4. Quest processes command and sends response with matching command_id

FieldTypeLabelDescription
type QuestNavCommandType

The type of command being sent. This field determines which payload (if any) should be populated and how the Quest should process the command. See QuestNavCommandType enum for available command types.

command_id uint32

Unique identifier for this command instance. This ID is used to match commands with their responses in asynchronous communication. The client should generate unique IDs for each command to avoid confusion. The Quest will echo this ID in the response message. Recommended: Use incrementing integers or timestamps for uniqueness. Note: For FRC users, the vendor dependency will handle this automatically.

pose_reset_payload ProtobufQuestNavPoseResetPayload

Payload for POSE_RESET commands. Set this field when type = POSE_RESET.

ProtobufQuestNavCommandResponse

Response message sent back after processing a command.

This message is sent by the Quest back to the client after processing

a ProtobufQuestNavCommand. It provides status information about whether

the command was executed successfully and any error details if it failed.

The response is matched to the original command using the command_id field,

allowing for proper asynchronous command handling even when multiple

commands are in flight simultaneously.

Response Timing:

- Responses are sent after command processing completes

- Some commands may take time to execute (e.g., pose reset with validation)

- Clients should implement timeouts for command responses

Note: For FRC users, the vendor dependency will handle response matching automatically.

FieldTypeLabelDescription
command_id uint32

Command ID that matches the original command. This field echoes the command_id from the original ProtobufQuestNavCommand that this response corresponds to. Clients use this to match responses with their original commands in asynchronous communication.

success bool

Indicates whether the command was executed successfully. true: Command completed successfully false: Command failed (see error_message for details) Note: A successful response means the command was processed, but doesn't necessarily guarantee the desired outcome (e.g., pose reset might succeed but tracking could still be poor due to environmental conditions).

error_message string

Human-readable error message when success = false. This field provides detailed information about why a command failed. It should be empty or ignored when success = true. Error messages are intended for debugging and logging purposes. They may include technical details about the failure cause. Examples: - "Invalid pose coordinates: x value out of field bounds" - "Tracking system not initialized" - "Unknown command type"

ProtobufQuestNavPoseResetPayload

Payload message for the POSE_RESET command.

This message contains the data needed to execute a pose reset operation.

The pose reset command allows external systems to correct the Quest's

understanding of the robot's position and orientation on the field.

Coordinate System:

- Uses WPILib field-relative coordinate system

- X-axis: Forward (towards opposing alliance)

- Y-axis: Left (when facing forward)

- Rotation: Counter-clockwise positive (standard mathematical convention)

- Origin: Typically at one corner of the field (see field layout documentation)

FieldTypeLabelDescription
target_pose wpi.proto.ProtobufPose2d

The target pose to reset the robot to. This should represent the robot's actual position and orientation on the field in the WPILib coordinate system. The Quest will update its internal tracking to match this pose, effectively correcting any accumulated drift. Units: - Translation: meters - Rotation: radians

QuestNavCommandType

Enumeration of available command types in the QuestNav system.

This enum defines all the different types of commands that can be sent to

the Quest headset. The enum is designed to be extensible - new command types

can be added without breaking existing clients.

Design Notes:

- Values start from 0 as required by proto3

- UNSPECIFIED value (0) is reserved for error handling

- Command values should be assigned incrementally for clarity

NameNumberDescription
COMMAND_TYPE_UNSPECIFIED 0

Default/invalid command type (required by proto3)

POSE_RESET 1

POSE_RESET: Resets the robot's pose estimation to a specified target pose. This command is used to correct drift in the tracking system by setting the robot's position and orientation to known values. Typically used when the robot is placed at a known location on the field. Requires: ProtobufQuestNavPoseResetPayload

data.proto

Top

ProtobufQuestNavDeviceData

Lower-frequency device status data sent from Quest to external systems.

This message contains device health and status information that doesn't need

to be sent as frequently as tracking data. It's sent at 3 Hz (every 333 milliseconds)

to provide monitoring and diagnostic information without consuming excessive

bandwidth.

This data helps external systems:

- Monitor Quest device health

- Detect tracking system issues

- Implement failsafe behaviors

- Provide user feedback about system status

The information is useful for both autonomous operation and debugging/

troubleshooting scenarios.

FieldTypeLabelDescription
tracking_lost_counter int32

Count of tracking loss events since app startup. This counter increments each time the Quest's tracking system loses tracking after having established it. Tracking loss can occur due to: - Poor lighting conditions - Lack of visual features in environment - Rapid motion or acceleration - Occlusion of cameras - Hardware issues A high or rapidly increasing counter may indicate: - Environmental issues (lighting, features) - Quest mounting problems (vibration, obstruction) - Hardware degradation This metric helps assess tracking system reliability and can trigger alerts or fallback behaviors in robot code.

currently_tracking bool

Current tracking status of the Quest device. true: Quest is actively tracking and pose data is reliable false: Quest has lost tracking and pose data should not be trusted When tracking is lost: - Pose data becomes stale and unreliable - Robot should switch to alternative localization methods - Movement should be limited or stopped for safety Tracking can be recovered by: - Improving lighting conditions - Moving to area with more visual features - Reducing motion to allow system to re-initialize - Performing pose reset when tracking recovers External systems should monitor this field and implement appropriate fallback behaviors when tracking is lost.

battery_percent int32

Quest device battery level as a percentage (0-100). This provides the current battery charge level of the Quest headset, allowing external systems to: - Monitor power status during operation - Implement low-battery warnings or behaviors - Plan operation duration and charging needs - Trigger graceful shutdown procedures Battery Level Guidelines: - 100%: Fully charged - 50-100%: Normal operation - 20-50%: Consider charging soon - 10-20%: Low battery warning recommended - 0-10%: Critical - plan immediate shutdown/charging Note: Battery drain rate depends on: - Processing load (tracking complexity) - Display usage (if any) - Wireless communication activity - Environmental temperature

ProtobufQuestNavFrameData

High-frequency tracking data sent from Quest to external systems.

This message contains the core tracking information that external systems

(like robot code) need for real-time localization and navigation. It's sent

at 100 Hz (every 10 milliseconds) to provide smooth, responsive tracking.

The data represents the Quest's position and orientation on the field,

derived from visual-inertial odometry using the Quest's cameras and IMU sensors.

Coordinate System:

- Uses WPILib field-relative coordinate system

- Origin and axes depend on field setup and calibration

- Pose represents the Quest's position; mounting offset to get robot position

is applied in end user code

FieldTypeLabelDescription
frame_count int32

Sequential frame counter for this tracking session. This counter increments with each frame processed by the Quest's tracking system. It can be used to: - Detect dropped messages - Calculate effective frame rate - Synchronize with other data streams The counter resets to 0 when the QuestNav app starts and increments continuously during operation. Frame drops in transmission will create gaps in the sequence.

timestamp double

Timestamp in seconds since QuestNav app startup. This provides timing information for the tracking data, allowing external systems to: - Calculate data age and latency - Interpolate or extrapolate poses for prediction - Synchronize with other sensor data - Implement timeout detection The timestamp is relative to app startup, not system time, to avoid clock synchronization issues between devices. Resolution: Typically sub-millisecond precision

pose2d wpi.proto.ProtobufPose2d

Quest's 2D pose on the field in WPILib coordinates. This represents the Quest's position and orientation as determined by the Quest's tracking system. The pose accounts for: - Coordinate system transformation to WPILib standard - Any calibration offsets applied Note: This is the Quest's position; end user code applies mounting offset to get the robot's position. Coordinate System Details: - X: Forward direction (towards opposing alliance) - Y: Left direction (when facing forward) - Rotation: Counter-clockwise positive (radians) - Units: meters for translation, radians for rotation Accuracy depends on: - Environmental lighting and features - Quest tracking quality - Calibration accuracy - Time since last pose reset

geometry2d.proto

Top

ProtobufEllipse2d

Represents a 2D ellipse with arbitrary orientation.

This message defines an elliptical region in 2D space using a center pose

and semi-axis lengths. The ellipse can be rotated to any orientation

based on the center pose's rotation component.

Geometric Properties:

- Center point and orientation defined by pose

- Major/minor axes aligned with pose's local coordinate frame

- X semi-axis extends along pose's X-axis (local forward direction)

- Y semi-axis extends along pose's Y-axis (local left direction)

- Total area = π * xSemiAxis * ySemiAxis

Applications:

- Uncertainty ellipses for localization

- Smooth obstacle representations

- Robot operating regions

- Sensor coverage areas

- Path planning with uncertainty

Special Cases:

- Circle: xSemiAxis = ySemiAxis

- Degenerate ellipse: one semi-axis approaches zero (becomes a line)

FieldTypeLabelDescription
center ProtobufPose2d

Center pose of the ellipse. The translation component specifies the center point of the ellipse in the coordinate system. The rotation component specifies the orientation of the ellipse's local coordinate frame. The ellipse's axes are aligned with this local coordinate frame: - X semi-axis extends along local X-axis (rotated forward direction) - Y semi-axis extends along local Y-axis (rotated left direction)

xSemiAxis double

Semi-axis length along the ellipse's local X-axis. This is half the width of the ellipse in the direction of the center pose's forward direction (after rotation). The ellipse extends ±xSemiAxis from the center along this axis. Units: meters Must be positive Note: This is the semi-axis, not the full width. The full width along this axis is 2 * xSemiAxis.

ySemiAxis double

Semi-axis length along the ellipse's local Y-axis. This is half the height of the ellipse in the direction of the center pose's left direction (after rotation). The ellipse extends ±ySemiAxis from the center along this axis. Units: meters Must be positive Note: This is the semi-axis, not the full height. The full height along this axis is 2 * ySemiAxis.

ProtobufPose2d

Represents a complete 2D pose (position and orientation).

This message combines a 2D position (translation) with a 2D orientation

(rotation) to fully describe an object's pose in the 2D plane. This is

the fundamental representation for robot poses in WPILib and QuestNav.

A pose answers two questions:

1. Where is the object? (translation component)

2. Which direction is it facing? (rotation component)

Applications:

- Robot pose on field (primary use in QuestNav)

- Waypoint targets for path following

- Relative poses between objects

- Initial poses for localization

The pose represents the robot's coordinate frame relative to the field

coordinate frame, allowing transformation of points between the two systems.

FieldTypeLabelDescription
translation ProtobufTranslation2d

Position component of the pose. This specifies where the robot is located on the field using the field coordinate system. The translation represents the position of the robot's coordinate frame origin (typically the robot center).

rotation ProtobufRotation2d

Orientation component of the pose. This specifies which direction the robot is facing on the field. The rotation represents the angle between the robot's forward direction and the field's positive X-axis (forward direction). Combined with translation, this fully defines the robot's pose and allows for coordinate transformations between robot and field frames.

ProtobufRectangle2d

Represents a 2D rectangle with arbitrary orientation.

This message defines a rectangular region in 2D space using a center pose

and width/height dimensions. The rectangle can be rotated to any orientation

based on the center pose's rotation component.

Geometric Properties:

- Center point and orientation defined by pose

- Width extends along the pose's X-axis (local forward direction)

- Height extends along the pose's Y-axis (local left direction)

- Total area = xWidth * yWidth

Applications:

- Robot footprint representation

- Obstacle and keep-out zone definitions

- Field element boundaries

- Collision detection regions

- Path planning constraints

FieldTypeLabelDescription
center ProtobufPose2d

Center pose of the rectangle. The translation component specifies the center point of the rectangle in the coordinate system. The rotation component specifies the orientation of the rectangle's local coordinate frame. The rectangle's edges are aligned with this local coordinate frame: - Width extends along local X-axis (rotated forward direction) - Height extends along local Y-axis (rotated left direction)

xWidth double

Width of the rectangle along its local X-axis. This is the dimension of the rectangle in the direction of the center pose's forward direction (after rotation). The rectangle extends ±xWidth/2 from the center along this axis. Units: meters Must be positive

yWidth double

Height of the rectangle along its local Y-axis. This is the dimension of the rectangle in the direction of the center pose's left direction (after rotation). The rectangle extends ±yWidth/2 from the center along this axis. Units: meters Must be positive

ProtobufRotation2d

Represents a 2D rotation angle.

This message encodes a rotation in the 2D plane using a single angle value.

It follows the standard mathematical convention for angle measurement and

is used to represent orientations and rotational displacements.

Applications:

- Robot heading/orientation on field

- Rotational component of poses and transforms

- Angular displacement between orientations

- Waypoint headings

Angle Convention:

- 0 radians: Facing positive X direction (forward on field)

- π/2 radians: Facing positive Y direction (left on field)

- π radians: Facing negative X direction (backward on field)

- 3π/2 radians: Facing negative Y direction (right on field)

- Counter-clockwise rotation is positive

FieldTypeLabelDescription
value double

Rotation angle in radians. The angle is measured counter-clockwise from the positive X-axis. Range: Typically -π to π, but can represent any angle value. Examples: - 0.0: Facing forward (positive X) - π/2: Facing left (positive Y) - π: Facing backward (negative X) - -π/2 or 3π/2: Facing right (negative Y) Units: radians

ProtobufTransform2d

Represents a 2D coordinate transformation.

This message describes how to transform coordinates from one 2D coordinate

frame to another. It combines a translation and rotation to define the

relationship between two coordinate systems.

Mathematical Interpretation:

Given a point P in frame A, the corresponding point in frame B is:

P_B = Transform2d * P_A = Rotation * P_A + Translation

Applications:

- Transform between robot and field coordinate frames

- Relative positioning between objects

- Coordinate frame conversions in path planning

- Sensor calibration and mounting offsets

The transform represents "how to get from frame A to frame B" and can be

inverted to get the reverse transformation.

FieldTypeLabelDescription
translation ProtobufTranslation2d

Translation component of the transformation. This represents the displacement between the origins of the two coordinate frames. It specifies how far and in which direction the target frame's origin is from the source frame's origin.

rotation ProtobufRotation2d

Rotation component of the transformation. This represents the angular difference between the two coordinate frames. It specifies how much the target frame is rotated relative to the source frame. The rotation is applied before the translation in the transformation sequence (standard mathematical convention).

ProtobufTranslation2d

Represents a 2D translation (displacement) vector.

This message encodes a 2D displacement or position vector using Cartesian

coordinates. It's used as a building block for more complex geometric

representations like poses and transforms.

Applications:

- Robot position on field

- Displacement between two points

- Velocity vectors (when representing change in position)

- Waypoint coordinates

Coordinate System:

- X: Forward/backward displacement (positive = forward)

- Y: Left/right displacement (positive = left)

- Units: meters

FieldTypeLabelDescription
x double

X-coordinate (forward/backward displacement). Positive values indicate forward direction (towards opposing alliance). Negative values indicate backward direction. Units: meters

y double

Y-coordinate (left/right displacement). Positive values indicate leftward direction (when facing forward). Negative values indicate rightward direction. Units: meters

ProtobufTwist2d

Represents a 2D twist (velocity in 2D space).

This message encodes the instantaneous velocity of an object in 2D space,

including both linear and angular velocity components. It describes how

an object's pose is changing over time.

Mathematical Interpretation:

The twist represents the time derivative of pose:

- dx/dt: Rate of change in X position

- dy/dt: Rate of change in Y position

- dθ/dt: Rate of change in orientation

Applications:

- Robot velocity commands for motion control

- Velocity feedback from odometry systems

- Velocity constraints in path planning

- Dynamic modeling and simulation

Coordinate Frame:

The twist can be expressed in different coordinate frames (robot-relative

or field-relative) depending on the application context.

FieldTypeLabelDescription
dx double

Linear velocity in X direction. Rate of change of X position over time. In field coordinates, this represents forward/backward velocity. Positive values: Moving in positive X direction (forward) Negative values: Moving in negative X direction (backward) Units: meters per second

dy double

Linear velocity in Y direction. Rate of change of Y position over time. In field coordinates, this represents left/right velocity (strafing). Positive values: Moving in positive Y direction (left) Negative values: Moving in negative Y direction (right) Units: meters per second

dtheta double

Angular velocity (rate of rotation). Rate of change of orientation over time. This represents how fast the object is rotating in the 2D plane. Positive values: Counter-clockwise rotation Negative values: Clockwise rotation Units: radians per second

geometry3d.proto

Top

ProtobufPose3d

Represents a complete 3D pose (position and orientation).

This message combines a 3D position (translation) with a 3D orientation

(rotation) to fully describe an object's pose in 3D space. This extends

the 2D pose concept into three dimensions for applications requiring

full spatial representation.

A 3D pose answers two fundamental questions:

1. Where is the object in 3D space? (translation component)

2. How is it oriented in 3D space? (rotation component)

Applications:

- Camera poses for vision processing

- AprilTag poses in 3D space

- Robotic arm end-effector poses

- Drone/UAV poses (position and attitude)

- 3D object tracking and localization

- Sensor mounting positions and orientations

The pose represents the object's coordinate frame relative to a reference

coordinate frame, enabling transformation of points and vectors between

the two coordinate systems.

Coordinate Frame Transformation:

Given a point P in the object's local frame, the corresponding point

in the reference frame is: P_ref = rotation * P_local + translation

FieldTypeLabelDescription
translation ProtobufTranslation3d

Position component of the 3D pose. This specifies where the object is located in 3D space using the reference coordinate system. The translation represents the position of the object's coordinate frame origin relative to the reference frame.

rotation ProtobufRotation3d

Orientation component of the 3D pose. This specifies how the object is oriented in 3D space relative to the reference coordinate system. The rotation represents the orientation of the object's coordinate frame relative to the reference frame. Combined with translation, this fully defines the object's pose and allows for coordinate transformations between object and reference frames.

ProtobufQuaternion

Represents a quaternion for 3D rotation.

Quaternions provide a mathematically robust way to represent 3D rotations

without the singularities (gimbal lock) that can occur with Euler angles.

They are the preferred representation for 3D rotations in robotics.

Mathematical Properties:

- Unit quaternion: w² + x² + y² + z² = 1

- Represents rotation around axis (x,y,z) by angle θ:

w = cos(θ/2), (x,y,z) = sin(θ/2) * unit_axis

- Identity rotation: (w=1, x=0, y=0, z=0)

- Conjugate: (w, -x, -y, -z) represents inverse rotation

Applications:

- 3D object orientations

- IMU/gyroscope data representation

- Camera pose orientations

- Robotic arm joint orientations

- Smooth rotation interpolation (SLERP)

Advantages over Euler angles:

- No gimbal lock singularities

- Smooth interpolation

- Efficient composition of rotations

- Numerically stable

FieldTypeLabelDescription
w double

W component (scalar/real part) of the quaternion. This is the "real" or "scalar" component of the quaternion. For a rotation by angle θ around an axis, w = cos(θ/2). Range: [-1, 1] for unit quaternions Identity rotation: w = 1

x double

X component (i coefficient) of the quaternion. This is the coefficient of the i basis quaternion. For a rotation by angle θ around axis (ax, ay, az), x = sin(θ/2) * ax (where (ax, ay, az) is unit length). Range: [-1, 1] for unit quaternions

y double

Y component (j coefficient) of the quaternion. This is the coefficient of the j basis quaternion. For a rotation by angle θ around axis (ax, ay, az), y = sin(θ/2) * ay (where (ax, ay, az) is unit length). Range: [-1, 1] for unit quaternions

z double

Z component (k coefficient) of the quaternion. This is the coefficient of the k basis quaternion. For a rotation by angle θ around axis (ax, ay, az), z = sin(θ/2) * az (where (ax, ay, az) is unit length). Range: [-1, 1] for unit quaternions

ProtobufRotation3d

Represents a 3D rotation using a quaternion.

This message wraps a quaternion to represent 3D rotations in a standardized

way. It provides a clean interface for 3D rotation operations while

leveraging the mathematical advantages of quaternions internally.

The rotation represents the orientation of a coordinate frame relative to

a reference frame, or the rotation needed to transform vectors from one

coordinate system to another.

Applications:

- Object orientations in 3D space

- Camera pose rotations

- IMU orientation data

- Robotic arm end-effector orientations

- Transformation between coordinate frames

Mathematical Operations:

- Composition: R3 = R2 * R1 (apply R1 first, then R2)

- Inverse: R^(-1) represents the opposite rotation

- Identity: No rotation (quaternion w=1, x=y=z=0)

FieldTypeLabelDescription
q ProtobufQuaternion

Quaternion representing the 3D rotation. This quaternion should be normalized (unit quaternion) to represent a valid rotation. Non-unit quaternions may lead to scaling effects in addition to rotation. The quaternion represents the rotation from the reference coordinate frame to the rotated coordinate frame.

ProtobufTransform3d

Represents a 3D coordinate transformation.

This message describes how to transform coordinates from one 3D coordinate

frame to another. It combines a 3D translation and rotation to define the

complete spatial relationship between two coordinate systems.

Mathematical Interpretation:

Given a point P in frame A, the corresponding point in frame B is:

P_B = Transform3d * P_A = Rotation * P_A + Translation

This follows the standard transformation sequence:

1. Apply rotation to the point

2. Add translation to the rotated point

Applications:

- Transform between robot and world coordinate frames

- Camera calibration and extrinsic parameters

- Sensor mounting transformations

- Relative positioning between 3D objects

- Coordinate frame conversions in 3D path planning

- Multi-robot relative localization

The transform represents "how to get from frame A to frame B" and can be

inverted to get the reverse transformation. Transforms can also be composed

to create transformation chains through multiple coordinate frames.

FieldTypeLabelDescription
translation ProtobufTranslation3d

Translation component of the 3D transformation. This represents the displacement between the origins of the two coordinate frames in 3D space. It specifies how far and in which direction the target frame's origin is from the source frame's origin.

rotation ProtobufRotation3d

Rotation component of the 3D transformation. This represents the angular difference between the two coordinate frames in 3D space. It specifies how the target frame is rotated relative to the source frame. The rotation is applied before the translation in the transformation sequence (standard mathematical convention for homogeneous transforms).

ProtobufTranslation3d

Represents a 3D translation (displacement) vector.

This message encodes a 3D displacement or position vector using Cartesian

coordinates. It extends the 2D translation concept into three dimensions

and serves as a building block for more complex 3D geometric representations.

Applications:

- 3D object positions in space

- Displacement vectors between 3D points

- 3D velocity vectors (when representing change in position)

- Camera/sensor positions relative to robot

- AprilTag positions in 3D space

Coordinate System:

- X: Forward/backward displacement (positive = forward)

- Y: Left/right displacement (positive = left)

- Z: Up/down displacement (positive = up)

- Units: meters

FieldTypeLabelDescription
x double

X-coordinate (forward/backward displacement). Positive values indicate forward direction. Negative values indicate backward direction. Units: meters

y double

Y-coordinate (left/right displacement). Positive values indicate leftward direction. Negative values indicate rightward direction. Units: meters

z double

Z-coordinate (up/down displacement). Positive values indicate upward direction. Negative values indicate downward direction. Units: meters

ProtobufTwist3d

Represents a 3D twist (velocity in 3D space).

This message encodes the instantaneous velocity of an object in 3D space,

including both linear and angular velocity components. It describes how

an object's 3D pose is changing over time, extending the 2D twist concept

into three dimensions.

Mathematical Interpretation:

The twist represents the time derivative of 3D pose:

- Linear velocity: (dx/dt, dy/dt, dz/dt)

- Angular velocity: (rx, ry, rz) as rotation rates about each axis

Applications:

- 3D robot velocity commands (drones, robotic arms)

- 3D velocity feedback from odometry systems

- Velocity constraints in 3D path planning

- Dynamic modeling and simulation in 3D

- IMU angular velocity data representation

- Camera motion estimation

Coordinate Frame:

The twist can be expressed in different coordinate frames (body-relative

or world-relative) depending on the application context. The angular

velocity components represent rotation rates about the coordinate axes.

FieldTypeLabelDescription
dx double

Linear velocity in X direction. Rate of change of X position over time. In world coordinates, this represents forward/backward velocity. Positive values: Moving in positive X direction (forward) Negative values: Moving in negative X direction (backward) Units: meters per second

dy double

Linear velocity in Y direction. Rate of change of Y position over time. In world coordinates, this represents left/right velocity (strafing). Positive values: Moving in positive Y direction (left) Negative values: Moving in negative Y direction (right) Units: meters per second

dz double

Linear velocity in Z direction. Rate of change of Z position over time. In world coordinates, this represents up/down velocity (climbing/descending). Positive values: Moving in positive Z direction (up) Negative values: Moving in negative Z direction (down) Units: meters per second

rx double

Angular velocity about X-axis (roll rate). Rate of rotation about the X-axis. This represents how fast the object is rolling (rotating around its forward axis). Positive values: Counter-clockwise rotation when looking down the positive X-axis Negative values: Clockwise rotation when looking down the positive X-axis Units: radians per second

ry double

Angular velocity about Y-axis (pitch rate). Rate of rotation about the Y-axis. This represents how fast the object is pitching (nose up/down motion). Positive values: Counter-clockwise rotation when looking down the positive Y-axis Negative values: Clockwise rotation when looking down the positive Y-axis Units: radians per second

rz double

Angular velocity about Z-axis (yaw rate). Rate of rotation about the Z-axis. This represents how fast the object is yawing (turning left/right). Positive values: Counter-clockwise rotation when looking down the positive Z-axis Negative values: Clockwise rotation when looking down the positive Z-axis Units: radians per second

Scalar Value Types

.proto TypeNotesC++JavaPythonGoC#PHPRuby
double double double float float64 double float Float
float float float float float32 float float Float
int32 Uses variable-length encoding. Inefficient for encoding negative numbers – if your field is likely to have negative values, use sint32 instead. int32 int int int32 int integer Bignum or Fixnum (as required)
int64 Uses variable-length encoding. Inefficient for encoding negative numbers – if your field is likely to have negative values, use sint64 instead. int64 long int/long int64 long integer/string Bignum
uint32 Uses variable-length encoding. uint32 int int/long uint32 uint integer Bignum or Fixnum (as required)
uint64 Uses variable-length encoding. uint64 long int/long uint64 ulong integer/string Bignum or Fixnum (as required)
sint32 Uses variable-length encoding. Signed int value. These more efficiently encode negative numbers than regular int32s. int32 int int int32 int integer Bignum or Fixnum (as required)
sint64 Uses variable-length encoding. Signed int value. These more efficiently encode negative numbers than regular int64s. int64 long int/long int64 long integer/string Bignum
fixed32 Always four bytes. More efficient than uint32 if values are often greater than 2^28. uint32 int int uint32 uint integer Bignum or Fixnum (as required)
fixed64 Always eight bytes. More efficient than uint64 if values are often greater than 2^56. uint64 long int/long uint64 ulong integer/string Bignum
sfixed32 Always four bytes. int32 int int int32 int integer Bignum or Fixnum (as required)
sfixed64 Always eight bytes. int64 long int/long int64 long integer/string Bignum
bool bool boolean boolean bool bool boolean TrueClass/FalseClass
string A string must always contain UTF-8 encoded or 7-bit ASCII text. string String str/unicode string string string String (UTF-8)
bytes May contain any arbitrary sequence of bytes. string ByteString str []byte ByteString string String (ASCII-8BIT)