Struct FrequentServerToRobot

pub struct FrequentServerToRobot {

    pub grid: StandardGrid,
    pub target_velocity: VelocityControl,
    pub motors_override: [Option<f32>; 3],
    pub pwm_override: [[Option<u16>; 2]; 3],
    pub motor_config: [[usize; 2]; 3],
    pub encoder_config: [(usize, bool); 3],
    pub dist_sensor_config: [usize; 4],
    pub pid: [f32; 3],
    pub cv_location: Option<Point2<i8>>,
    pub localization_algorithm: LocalizationAlgorithmSource,
    pub target_path: Vec<Point2<i8>, MAX_ROBOT_PATH_LENGTH>,
    pub follow_target_path: bool,
    pub angle_offset: f32,
    pub lookahead_dist: f32,
    pub robot_speed: f32,
    pub snapping_dist: f32,
    pub cv_error: f32,
    pub enable_imu: bool,
    pub enable_extra_imu_data: bool,
    pub enable_dists: bool,
    pub enable_battery_monitor: bool,
    pub enable_display: bool,
    pub enable_gamepad: bool,
    pub display_loop_interval: u64,
}

This is sent regularly and frequently to robots via ServerToRobotMessage::FrequentRobotItems

Holds information that may change often, or where low latency is critical. Its contents should be passed along as quickly as possible.

Fields

grid: StandardGrid

Which grid is currently in use

target_velocity: VelocityControl

Overall requested velocity of the robot, ex. using WASD or controller manual input

motors_override: [Option<f32>; 3]

Requested velocity for each individual motor, forwards (+) or backwards (-), for testing

pwm_override: [[Option<u16>; 2]; 3]

Requested output for each PWM pin, for testing

motor_config: [[usize; 2]; 3]

Which pwm pin corresponds to which motor

Example: for the config [[0, 1], [5, 4], [2, 3]]:

• Raising the first physical pin (denoted 0) causes motor 0 to turn clockwise
• Raising pin 1 causes motor 0 to turn counter-clockwise
• Raising pin 5 causes motor 1 to turn clockwise
• 4 -> motor 1 counter-clockwise
• 2 -> motor 2 clockwise
• 3 -> motor 2 counter-clockwise

encoder_config: [(usize, bool); 3]

Which encoder belongs to which motor, and whether the encoder is reversed

dist_sensor_config: [usize; 4]

The order of the distance sensors

pid: [f32; 3]

Basic parameters for the PID controller

cv_location: Option<Point2<i8>>

The grid cell the CV system thinks the robot is in

Not used when this struct functions as a configuration in server settings

localization_algorithm: LocalizationAlgorithmSource

What localization strategy the robot should use

target_path: Vec<Point2<i8>, MAX_ROBOT_PATH_LENGTH>

The points the robot should try to go to

follow_target_path: bool

Whether the robot should try to follow the target path (including maintaining heading 0)

angle_offset: f32

This angle should be considered angle 0

lookahead_dist: f32

robot_speed: f32

snapping_dist: f32

cv_error: f32

enable_imu: bool

enable_extra_imu_data: bool

enable_dists: bool

enable_battery_monitor: bool

enable_display: bool

enable_gamepad: bool

display_loop_interval: u64

Implementations

impl FrequentServerToRobot

pub fn new(robot: RobotName) -> Self

Create one with default parameters of the given robot

Trait Implementations

impl Clone for FrequentServerToRobot

fn clone(&self) -> FrequentServerToRobot

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FrequentServerToRobot

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FrequentServerToRobot

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for FrequentServerToRobot

fn eq(&self, other: &FrequentServerToRobot) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for FrequentServerToRobot

fn partial_cmp(&self, other: &FrequentServerToRobot) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for FrequentServerToRobot

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for FrequentServerToRobot