Crate vexide_motorgroup 

vexide-motorgroup

Missing MotorGroup from VEXCode or PROS? This is a simple implementation of a MotorGroup for vexide which allows you to group motors together and control them as one.

Installation

Add the following to your Cargo.toml:

[dependencies]
# ... other dependencies
vexide-motorgroup = "2.1.0"

Or if you prefer the command line:

cargo add vexide-motorgroup

Usage

Normally, you would have to set each motor’s target and other values individually even if the motors were physically connected in a drivetrain or similar, but with MotorGroup, you can control them as if they were one motor.

Just create a MotorGroup with a Vec of Motors and use the MotorGroup methods just like you would with a Motor. It’s that simple!

#![no_std]
#![no_main]

extern crate alloc;

use core::time::Duration;

use alloc::vec;
use vexide_motorgroup::*;

use vexide::prelude::*;

#[vexide::main]
async fn main(peripherals: Peripherals) {
    // Here's where the magic happens
    let mut motor_group = MotorGroup::new(vec![
        Motor::new(peripherals.port_1, Gearset::Green, Direction::Forward),
        Motor::new(peripherals.port_2, Gearset::Green, Direction::Forward),
    ]);

    // Set the motor group's target to a voltage as if it were a motor
    motor_group.set_voltage(5.0).unwrap();
    sleep(Duration::from_secs(1)).await;

    // Set the motor group's target to a position
    motor_group
        .set_position_target(Position::from_degrees(90.0), 200)
        .unwrap();
    sleep(Duration::from_secs(1)).await;

    // Set the motor group's target to a velocity
    motor_group.set_velocity(100).unwrap();
    sleep(Duration::from_secs(1)).await;

    // Brake the motor group
    motor_group.brake(BrakeMode::Hold).unwrap();
}

Error handling

Read errors

For functions returning values and reading data (i.e., those taking a read-only reference to self), upon encountering an error accessing any motor, the result will be a MotorGroupError that contains all the errors encountered during the operation. Using MotorGroupError::result will return the average of all the results that were successfully read.

Write errors

vexide-motorgroup provides two different strategies for handling write errors. Both of them will return an Err when any motor returns an error.

1. WriteErrorStrategy::Ignore (default): This strategy will ignore errors and continue writing to the other motors.
2. WriteErrorStrategy::Stop: This strategy will stop writing to the other motors and return the error immediately.

Macros

motor_group

A macro that creates a set of motors using MotorGroup.

shared_motors

A macro that creates a set of sharable motors.

Structs

MotorGroup

A group of motors that can be controlled together.

MotorGroupError

An error that occurs when controlling a motor group.

SharedMotors

Motors that can be cloned with interior mutability.

Enums

WriteErrorStrategy

The mode for handling errors when writing to a motor group.