feathersdk.robot.actuator_systems.navigation_system Module

class feathersdk.robot.actuator_systems.navigation_system.NavigationSystemConfig(*, module_name='navigation_system', requires_urdf=False, safe_stop_policy=SafeStopPolicy.CANNOT_ENTER_SAFE_STOP, operating_frequency=30.0, actuators_share_same_endpoint=True, multithreaded_calibration=True)

Bases: ActuatorSystemConfig

Parameters:
module_name: str

The name of the navigation system.

safe_stop_policy: SafeStopPolicy

The safe stop policy to use when encountering a dangerous state.

operating_frequency: float

The operating frequency of the navigation system.

multithreaded_calibration: bool

Whether to calibrate the motors in a multi-threaded manner.

model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class feathersdk.robot.actuator_systems.navigation_system.TNavigationSystemConfig

The type of the navigation system configuration.

alias of TypeVar(‘TNavigationSystemConfig’, bound=NavigationSystemConfig)

class feathersdk.robot.actuator_systems.navigation_system.NavigationSystem(config, *args, **kwargs)

Bases: ActuatorSystem[TNavigationSystemConfig, TActuator], Generic[TNavigationSystemConfig, TActuator]

Controls the navigation of the robot.

Parameters:
class feathersdk.robot.actuator_systems.navigation_system.ThreeWheelHolonomicRobstrideNavigationSystemConfig(*, module_name='navigation_system', requires_urdf=False, safe_stop_policy=SafeStopPolicy.CANNOT_ENTER_SAFE_STOP, operating_frequency=30.0, actuators_share_same_endpoint=True, multithreaded_calibration=True, turning_center_motor, turning_right_motor, turning_left_motor, drive_center_motor, drive_right_motor, drive_left_motor, rotation_tolerance=0.02, wheel_radius=0.0, wheel_positions=[])

Bases: NavigationSystemConfig

Parameters:
turning_center_motor: RobstrideMotorConfig

The configuration for the turning center motor.

turning_right_motor: RobstrideMotorConfig

The configuration for the turning right motor.

turning_left_motor: RobstrideMotorConfig

The configuration for the turning left motor.

drive_center_motor: RobstrideMotorConfig

The configuration for the drive center motor.

drive_right_motor: RobstrideMotorConfig

The configuration for the drive right motor.

drive_left_motor: RobstrideMotorConfig

The configuration for the drive left motor.

rotation_tolerance: float

The absolute tolerance in radians for turning motors to be considered at the target position.

wheel_radius: float

The radius of the wheels in meters. If 0, the mean drive-wheel radius is read from the URDF.

wheel_positions: List[Tuple[float, float]]

Drive-wheel (x, y) in the robot frame, meters, parallel to drive motors (center, right, left). +X forward, +Y left. If empty, positions are read from the URDF.

model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class feathersdk.robot.actuator_systems.navigation_system.ThreeWheelHolonomicRobstrideNavigationSystem(config, *args, **kwargs)

Bases: NavigationSystem[ThreeWheelHolonomicRobstrideNavigationSystemConfig, RobstrideMotor]

Controls the navigation of the robot using a three-wheel holonomic platform.

Parameters:
turning_center_motor: RobstrideMotor

The center turning motor. Turning motors control the angle the wheels are facing (yaw).

turning_right_motor: RobstrideMotor

The right turning motor. Turning motors control the angle the wheels are facing (yaw).

turning_left_motor: RobstrideMotor

The left turning motor. Turning motors control the angle the wheels are facing (yaw).

drive_center_motor: RobstrideMotor

The center drive motor. Drive motors control the speed of the robot.

drive_right_motor: RobstrideMotor

The right drive motor. Drive motors control the speed of the robot.

drive_left_motor: RobstrideMotor

The left drive motor. Drive motors control the speed of the robot.

recalibrate(allow_load=None)

Recalibrate the navigation system.

Parameters:

allow_load (bool | None) – If True, allow the system to load calibration state from file instead of recalibrating. If None, use the per-actuator config’s allow_load_calibration value.

Return type:

None

set_velocity(vx, vy, omega, orient_only=False)

Command a holonomic body-frame velocity on the three-wheel swerve.

Robot / IMU frame: +X forward, +Y left, yaw positive counter-clockwise. Translation is in m/s; omega is in rad/s. Drive motors are commanded in rad/s via motor_velocity = wheel_linear_speed / wheel_radius.

Inverse kinematics for module i at (x_i, y_i) from config.wheel_positions (center, right, left; not assumed equal):

wheel_vx = vx - omega * y_i wheel_vy = vy + omega * x_i

Steering motors are clockwise-positive (0 = forward, +pi/2 = right), so the steer command is -atan2(wheel_vy, wheel_vx) folded into [-pi/2, +pi/2]. Headings outside that range reverse the drive motor instead of clamping. Between (angle, speed) and (angle ± pi, -speed), the representation closest to the wheel’s current steer angle is used. The last command is kept unless the other equivalent is closer by more than 20 deg, so live encoder noise does not chatter between ±90. When strict steering is off, each drive speed is also scaled by max(0, cos(steer_error)) so a large heading change does not shove the chassis sideways while the module is still rotating.

If any drive motor would exceed its configured max_velocity, all three wheel speeds are scaled by the same factor so the commanded body-velocity direction is preserved.

Parameters:

  • vx (float) – Robot-frame X velocity in m/s. +X is forward.

  • vy (float) – Robot-frame Y velocity in m/s. +Y is left.

  • omega (float) – Yaw rate in rad/s. Positive is counter-clockwise.

  • orient_only (bool) – If True, only orient the robot as if it would perform the velocity commands, but set the actual drive velocities to 0.

Return type:

None

set_strict_directions(value)

Wait for steering to reach the commanded heading before spinning the drive wheels.

True (default) matches the original behavior: drive motors are held at 0 until all turning motors are within rotation_tolerance of their targets. False applies drive velocity immediately so small joystick heading changes do not stop the robot.

Parameters:

value (bool)

Return type:

None

get_strict_directions()

Return whether drive wheels wait for steering to reach the commanded heading.

Return type:

bool

disable()

Disable the motors

Return type:

None

enable()

Enable the navigation system.

Return type:

None