In this documentation

port : The smartport this device is attached to
gears (optional) : The gear cartridge installed in the motor, default is the green 18_1
reverse (optional) : Should the motor's spin direction be reversed, default is False

Returns:

A new Motor object.

Examples:

motor1 = Motor(Ports.PORT1)\
motor2 = Motor(Ports.PORT2, GearSetting.RATIO_36_1)\
motor3 = Motor(Ports.PORT3, True)\
motor4 = Motor(Ports.PORT4, GearSetting.RATIO_6_1, True)

Source code in vex.py

class Motor:
    '''### Motor class - use this to create an instance of a V5 smart motor

    #### Arguments:
        port : The smartport this device is attached to
        gears (optional) : The gear cartridge installed in the motor, default is the green 18_1
        reverse (optional) : Should the motor's spin direction be reversed, default is False

    #### Returns:
        A new Motor object.

    #### Examples:
        motor1 = Motor(Ports.PORT1)\\
        motor2 = Motor(Ports.PORT2, GearSetting.RATIO_36_1)\\
        motor3 = Motor(Ports.PORT3, True)\\
        motor4 = Motor(Ports.PORT4, GearSetting.RATIO_6_1, True)
    '''
    def __init__(self, port: int, *args):
        self._index = port

        self._timeout = 10000
        self._velocity = 50
        self._mode = BrakeType.COAST
        self._brakeMode = BrakeType.COAST
        self._spinMode = False

    def installed(self):
        '''### Check for device connection

        #### Arguments:
            None

        #### Returns:
            True or False
        '''
        return True

    def timestamp(self):
        '''### Request the timestamp of last received message from the motor

        #### Arguments:
            None

        #### Returns:
            timestamp of the last status packet in mS
        '''
        return 0

    def set_velocity(self, value: vexnumber, units: VelocityPercentUnits=VelocityUnits.RPM):
        '''### Set default velocity for the motor
        This will be the velocity used for subsequent calls to spin if a velocity is not provided
        to that function.

        #### Arguments:
            value : The new velocity
            units : The units for the supplied velocity, the default is RPM

        #### Returns:
            None
        '''
        self._velocity = value

    def set_reversed(self, value: bool):
        '''### Set the reverse flag for the motor
        Setting the reverse flag will cause spin commands to run the motor in reverse.

        #### Arguments:
            value : Reverse flag, True or False

        #### Returns:
            None
        '''
        pass

    def set_stopping(self, value: BrakeType.BrakeType):
        '''### Set the stopping mode of the motor
        Setting the action for the motor when stopped.

        #### Arguments:
            value : The stopping mode, COAST, BRAKE or HOLD

        #### Returns:
            None
        '''
        pass

    def reset_position(self):
        '''### Reset the motor position to 0

        #### Arguments:
            None

        #### Returns:
            None
        '''
        pass

    def set_position(self, value: vexnumber, units=RotationUnits.DEG):
        '''### Set the current position of the motor
        The position returned by the position() function is set to this value.

        #### Arguments:
            value : The new position
            units : The units for the provided position, the default is DEGREES

        #### Returns:
            None
        '''
        pass

    def set_timeout(self, value: vexnumber, units=TimeUnits.MSEC):
        '''### Set the timeout value used by the motor
        The timeout value is used when performing spin_to_position and spin_for commands.  If timeout is
         reached and the motor has not completed moving, then the spin... function will return False.

        #### Arguments:
            value : The new timeout
            units : The units for the provided timeout, the default is MSEC

        #### Returns:
            None
        '''
        self._timeout = value

    def get_timeout(self):
        '''### Returns the current value of motor timeout

        #### Arguments:
            None

        #### Returns:
            The current timeout value
        '''
        return self._timeout

    def spin(self, direction: DirectionType.DirectionType, *args, **kwargs):
        '''### Spin the motor using the provided arguments

        #### Arguments:
            direction : The direction to spin the motor, FORWARD or REVERSE
            velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
            units (optional) : The units of the provided velocity, default is RPM

        #### Returns:
            None

        #### Examples:
            # spin motor forward at velocity set with set_velocity\\
            motor1.spin(FORWARD)\n
            # spin motor forward at 50 rpm\\
            motor1.spin(FORWARD, 50)\n
            # spin with negative velocity, ie. backwards\\
            motor1.spin(FORWARD, -20)\n
            # spin motor forwards with 100% velocity\\
            motor1.spin(FORWARD, 100, PERCENT)\n
            # spin motor forwards at 50 rpm\\
            motor1.spin(FORWARD, 50, RPM)\n
            # spin motor forwards at 360 dps\\
            motor1.spin(FORWARD, 360.0, VelocityUnits.DPS)
        '''
        pass

    def spin_to_position(self, rotation: vexnumber, *args, **kwargs):
        '''### Spin the motor to an absolute position using the provided arguments
        Move the motor to the requested position.\\
        This function supports keyword arguments.

        #### Arguments:
            rotation : The position to spin the motor to
            units (optional) : The units for the provided position, the default is DEGREES
            velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
            units_v (optional) : The units of the provided velocity, default is RPM
            wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

        #### Returns:
            None

        #### Examples:
            # spin to 180 degrees\\
            motor1.spin_to_position(180)\n
            # spin to 2 TURNS (revolutions)\\
            motor1.spin_to_position(2, TURNS) \n
            # spin to 180 degrees at 25 rpm\\
            motor1.spin_to_position(180, DEGREES, 25, RPM)\n
            # spin to 180 degrees and do not wait for completion\\
            motor1.spin_to_position(180, DEGREES, False)\n
            # spin to 180 degrees and do not wait for completion\\
            motor1.spin_to_position(180, DEGREES, wait=False)
        '''
        pass

    def spin_for(self, direction: DirectionType.DirectionType, rot_or_time: vexnumber, *args, **kwargs):
        '''### Spin the motor to a relative position using the provided arguments
        Move the motor to the requested position or for the specified amount of time.\\
        The position is relative (ie. an offset) to the current position\\
        This function supports keyword arguments.

        #### Arguments:
            dir : The direction to spin the motor, FORWARD or REVERSE
            rot_or_time : The relative position to spin the motor to or tha amount of time to spin for
            units (optional) : The units for the provided position or time, the default is DEGREES or MSEC
            velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
            units_v (optional) : The units of the provided velocity, default is RPM
            wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

        #### Returns:
            None

        #### Examples:
            # spin 180 degrees from the current position\\
            motor1.spin_for(FORWARD, 180)\n
            # spin reverse 2 TURNS (revolutions) from the current position\\
            motor1.spin_for(REVERSE, 2, TURNS)\n
            # spin 180 degrees from the current position at 25 rpm\\
            motor1.spin_for(FORWARD, 180, DEGREES, 25, RPM)\n
            # spin 180 degrees  from the current position and do not wait for completion\\
            motor1.spin_for(FORWARD, 180, DEGREES, False)\n
            # spin 180 degrees  from the current position and do not wait for completion\\
            motor1.spin_for(FORWARD, 180, DEGREES, wait=False)
        '''
        pass

    def is_spinning(self):
        '''### Returns the current status of the spin_to_position or spin_for command
        This function is used when False has been passed as the wait parameter to spin_to_position or spin_for\\
        It will return True if the motor is still spinning or False if it has completed the move or a timeout occurred.

        #### Arguments:
            None

        #### Returns:
            The current spin_to_position or spin_for status
        '''
        return True

    def is_done(self):
        '''### Returns the current status of the spin_to_position or spin_for command
        This function is used when False has been passed as the wait parameter to spin_to_position or spin_for\\
        It will return False if the motor is still spinning or True if it has completed the move or a timeout occurred.

        #### Arguments:
            None

        #### Returns:
            The current spin_to_position or spin_for status
        '''
        return True

    def is_spinning_mode(self):
        return False

    def stop(self, mode=None):
        '''### Stop the motor, set to 0 velocity and set current stopping_mode
        The motor will be stopped and set to COAST, BRAKE or HOLD

        #### Arguments:
            None

        #### Returns:
            None
        '''
        pass

    def set_max_torque(self, value, units: TorquePercentCurrentUnits):
        '''### Set the maximum torque the motor will use
        The torque can be set as torque, current or percent of maximum.

        #### Arguments:
            value : the new maximum torque to use
            units : the units that value is passed in

        #### Returns:
            None

        #### Examples:
            # set maximum torque to 2 Nm\\
            motor1.set_max_torque(2, TorqueUnits.NM)\n
            # set maximum torque to 1 Amp\\
            motor1.set_max_torque(1, CurrentUnits.AMP)\n
            # set maximum torque to 20 percent\\
            motor1.set_max_torque(20, PERCENT)
        '''
        pass

    def direction(self):
        '''### Returns the current direction the motor is spinning in

        #### Arguments:
            None

        #### Returns:
            The spin direction, FORWARD, REVERSE or UNDEFINED
        '''
        return DirectionType.FORWARD

    def position(self, *args):
        '''### Returns the position of the motor

        #### Arguments:
            units (optional) : The units for the returned position, the default is DEGREES

        #### Returns:
            The motor position in provided units
        '''
        return 20

    def velocity(self, *args):
        '''### Returns the velocity of the motor

        #### Arguments:
            units (optional) : The units for the returned velocity, the default is RPM

        #### Returns:
            The motor velocity in provided units
        '''
        return 2

    def current(self, *args):
        '''### Returns the current the motor is using

        #### Arguments:
            units (optional) : The units for the returned current, the default is AMP

        #### Returns:
            The motor current in provided units
        '''
        return 1

    def power(self, *args):
        '''### Returns the power the motor is providing

        #### Arguments:
            units (optional) : The units for the returned power, the default is WATT

        #### Returns:
            The motor power in provided units
        '''
        return 1

    def torque(self, *args):
        '''### Returns the torque the motor is providing

        #### Arguments:
            units (optional) : The units for the returned torque, the default is NM

        #### Returns:
            The motor torque in provided units
        '''
        return 1

    def efficiency(self, *args):
        '''### Returns the efficiency of the motor

        #### Arguments:
            units (optional) : The units for the efficiency, the only valid value is PERCENT

        #### Returns:
            The motor efficiency in percent
        '''
        return 1

    def temperature(self, *args):
        '''### Returns the temperature of the motor

        #### Arguments:
            units (optional) : The units for the returned temperature, the default is CELSIUS

        #### Returns:
            The motor temperature in provided units
        '''
        return 1

    def command(self, *args):
        '''### Returns the last velocity sent to the motor

        #### Arguments:
            units (optional) : The units for the returned velocity, the default is RPM

        #### Returns:
            The motor command velocity in provided units
        '''
        return self._velocity

`command(*args)`

Returns the last velocity sent to the motor

Arguments:

units (optional) : The units for the returned velocity, the default is RPM

Returns:

The motor command velocity in provided units

Source code in vex.py

def command(self, *args):
    '''### Returns the last velocity sent to the motor

    #### Arguments:
        units (optional) : The units for the returned velocity, the default is RPM

    #### Returns:
        The motor command velocity in provided units
    '''
    return self._velocity

`current(*args)`

Returns the current the motor is using

Arguments:

units (optional) : The units for the returned current, the default is AMP

Returns:

The motor current in provided units

Source code in vex.py

def current(self, *args):
    '''### Returns the current the motor is using

    #### Arguments:
        units (optional) : The units for the returned current, the default is AMP

    #### Returns:
        The motor current in provided units
    '''
    return 1

`direction()`

Returns the current direction the motor is spinning in

Arguments:

None

Returns:

The spin direction, FORWARD, REVERSE or UNDEFINED

Source code in vex.py

def direction(self):
    '''### Returns the current direction the motor is spinning in

    #### Arguments:
        None

    #### Returns:
        The spin direction, FORWARD, REVERSE or UNDEFINED
    '''
    return DirectionType.FORWARD

`efficiency(*args)`

Returns the efficiency of the motor

Arguments:

units (optional) : The units for the efficiency, the only valid value is PERCENT

Returns:

The motor efficiency in percent

Source code in vex.py

def efficiency(self, *args):
    '''### Returns the efficiency of the motor

    #### Arguments:
        units (optional) : The units for the efficiency, the only valid value is PERCENT

    #### Returns:
        The motor efficiency in percent
    '''
    return 1

`get_timeout()`

Returns the current value of motor timeout

Arguments:

None

Returns:

The current timeout value

Source code in vex.py

def get_timeout(self):
    '''### Returns the current value of motor timeout

    #### Arguments:
        None

    #### Returns:
        The current timeout value
    '''
    return self._timeout

`installed()`

Check for device connection

Arguments:

None

Returns:

True or False

Source code in vex.py

def installed(self):
    '''### Check for device connection

    #### Arguments:
        None

    #### Returns:
        True or False
    '''
    return True

`is_done()`

Returns the current status of the spin_to_position or spin_for command

This function is used when False has been passed as the wait parameter to spin_to_position or spin_for\ It will return False if the motor is still spinning or True if it has completed the move or a timeout occurred.

Arguments:

None

Returns:

The current spin_to_position or spin_for status

Source code in vex.py

def is_done(self):
    '''### Returns the current status of the spin_to_position or spin_for command
    This function is used when False has been passed as the wait parameter to spin_to_position or spin_for\\
    It will return False if the motor is still spinning or True if it has completed the move or a timeout occurred.

    #### Arguments:
        None

    #### Returns:
        The current spin_to_position or spin_for status
    '''
    return True

`is_spinning()`

Returns the current status of the spin_to_position or spin_for command

This function is used when False has been passed as the wait parameter to spin_to_position or spin_for\ It will return True if the motor is still spinning or False if it has completed the move or a timeout occurred.

Arguments:

None

Returns:

The current spin_to_position or spin_for status

Source code in vex.py

def is_spinning(self):
    '''### Returns the current status of the spin_to_position or spin_for command
    This function is used when False has been passed as the wait parameter to spin_to_position or spin_for\\
    It will return True if the motor is still spinning or False if it has completed the move or a timeout occurred.

    #### Arguments:
        None

    #### Returns:
        The current spin_to_position or spin_for status
    '''
    return True

`position(*args)`

Returns the position of the motor

Arguments:

units (optional) : The units for the returned position, the default is DEGREES

Returns:

The motor position in provided units

Source code in vex.py

def position(self, *args):
    '''### Returns the position of the motor

    #### Arguments:
        units (optional) : The units for the returned position, the default is DEGREES

    #### Returns:
        The motor position in provided units
    '''
    return 20

`power(*args)`

Returns the power the motor is providing

Arguments:

units (optional) : The units for the returned power, the default is WATT

Returns:

The motor power in provided units

Source code in vex.py

def power(self, *args):
    '''### Returns the power the motor is providing

    #### Arguments:
        units (optional) : The units for the returned power, the default is WATT

    #### Returns:
        The motor power in provided units
    '''
    return 1

`reset_position()`

Reset the motor position to 0

Arguments:

None

Returns:

None

Source code in vex.py

def reset_position(self):
    '''### Reset the motor position to 0

    #### Arguments:
        None

    #### Returns:
        None
    '''
    pass

`set_max_torque(value, units)`

Set the maximum torque the motor will use

The torque can be set as torque, current or percent of maximum.

Arguments:

value : the new maximum torque to use
units : the units that value is passed in

Returns:

None

Examples:

# set maximum torque to 2 Nm\
motor1.set_max_torque(2, TorqueUnits.NM)

# set maximum torque to 1 Amp\
motor1.set_max_torque(1, CurrentUnits.AMP)

# set maximum torque to 20 percent\
motor1.set_max_torque(20, PERCENT)

Source code in vex.py

def set_max_torque(self, value, units: TorquePercentCurrentUnits):
    '''### Set the maximum torque the motor will use
    The torque can be set as torque, current or percent of maximum.

    #### Arguments:
        value : the new maximum torque to use
        units : the units that value is passed in

    #### Returns:
        None

    #### Examples:
        # set maximum torque to 2 Nm\\
        motor1.set_max_torque(2, TorqueUnits.NM)\n
        # set maximum torque to 1 Amp\\
        motor1.set_max_torque(1, CurrentUnits.AMP)\n
        # set maximum torque to 20 percent\\
        motor1.set_max_torque(20, PERCENT)
    '''
    pass

`set_position(value, units=RotationUnits.DEG)`

Set the current position of the motor

The position returned by the position() function is set to this value.

Arguments:

value : The new position
units : The units for the provided position, the default is DEGREES

Returns:

None

Source code in vex.py

def set_position(self, value: vexnumber, units=RotationUnits.DEG):
    '''### Set the current position of the motor
    The position returned by the position() function is set to this value.

    #### Arguments:
        value : The new position
        units : The units for the provided position, the default is DEGREES

    #### Returns:
        None
    '''
    pass

`set_reversed(value)`

Set the reverse flag for the motor

Setting the reverse flag will cause spin commands to run the motor in reverse.

Arguments:

value : Reverse flag, True or False

Returns:

None

Source code in vex.py

def set_reversed(self, value: bool):
    '''### Set the reverse flag for the motor
    Setting the reverse flag will cause spin commands to run the motor in reverse.

    #### Arguments:
        value : Reverse flag, True or False

    #### Returns:
        None
    '''
    pass

`set_stopping(value)`

Set the stopping mode of the motor

Setting the action for the motor when stopped.

Arguments:

value : The stopping mode, COAST, BRAKE or HOLD

Returns:

None

Source code in vex.py

def set_stopping(self, value: BrakeType.BrakeType):
    '''### Set the stopping mode of the motor
    Setting the action for the motor when stopped.

    #### Arguments:
        value : The stopping mode, COAST, BRAKE or HOLD

    #### Returns:
        None
    '''
    pass

`set_timeout(value, units=TimeUnits.MSEC)`

Set the timeout value used by the motor

The timeout value is used when performing spin_to_position and spin_for commands. If timeout is reached and the motor has not completed moving, then the spin... function will return False.

Arguments:

value : The new timeout
units : The units for the provided timeout, the default is MSEC

Returns:

None

Source code in vex.py

def set_timeout(self, value: vexnumber, units=TimeUnits.MSEC):
    '''### Set the timeout value used by the motor
    The timeout value is used when performing spin_to_position and spin_for commands.  If timeout is
     reached and the motor has not completed moving, then the spin... function will return False.

    #### Arguments:
        value : The new timeout
        units : The units for the provided timeout, the default is MSEC

    #### Returns:
        None
    '''
    self._timeout = value

`set_velocity(value, units=VelocityUnits.RPM)`

Set default velocity for the motor

This will be the velocity used for subsequent calls to spin if a velocity is not provided to that function.

Arguments:

value : The new velocity
units : The units for the supplied velocity, the default is RPM

Returns:

None

Source code in vex.py

def set_velocity(self, value: vexnumber, units: VelocityPercentUnits=VelocityUnits.RPM):
    '''### Set default velocity for the motor
    This will be the velocity used for subsequent calls to spin if a velocity is not provided
    to that function.

    #### Arguments:
        value : The new velocity
        units : The units for the supplied velocity, the default is RPM

    #### Returns:
        None
    '''
    self._velocity = value

`spin(direction, *args, **kwargs)`

Spin the motor using the provided arguments

Arguments:

direction : The direction to spin the motor, FORWARD or REVERSE
velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
units (optional) : The units of the provided velocity, default is RPM

Returns:

None

Examples:

# spin motor forward at velocity set with set_velocity\
motor1.spin(FORWARD)

# spin motor forward at 50 rpm\
motor1.spin(FORWARD, 50)

# spin with negative velocity, ie. backwards\
motor1.spin(FORWARD, -20)

# spin motor forwards with 100% velocity\
motor1.spin(FORWARD, 100, PERCENT)

# spin motor forwards at 50 rpm\
motor1.spin(FORWARD, 50, RPM)

# spin motor forwards at 360 dps\
motor1.spin(FORWARD, 360.0, VelocityUnits.DPS)

Source code in vex.py

def spin(self, direction: DirectionType.DirectionType, *args, **kwargs):
    '''### Spin the motor using the provided arguments

    #### Arguments:
        direction : The direction to spin the motor, FORWARD or REVERSE
        velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
        units (optional) : The units of the provided velocity, default is RPM

    #### Returns:
        None

    #### Examples:
        # spin motor forward at velocity set with set_velocity\\
        motor1.spin(FORWARD)\n
        # spin motor forward at 50 rpm\\
        motor1.spin(FORWARD, 50)\n
        # spin with negative velocity, ie. backwards\\
        motor1.spin(FORWARD, -20)\n
        # spin motor forwards with 100% velocity\\
        motor1.spin(FORWARD, 100, PERCENT)\n
        # spin motor forwards at 50 rpm\\
        motor1.spin(FORWARD, 50, RPM)\n
        # spin motor forwards at 360 dps\\
        motor1.spin(FORWARD, 360.0, VelocityUnits.DPS)
    '''
    pass

`spin_for(direction, rot_or_time, *args, **kwargs)`

Spin the motor to a relative position using the provided arguments

Move the motor to the requested position or for the specified amount of time.\ The position is relative (ie. an offset) to the current position\ This function supports keyword arguments.

Arguments:

dir : The direction to spin the motor, FORWARD or REVERSE
rot_or_time : The relative position to spin the motor to or tha amount of time to spin for
units (optional) : The units for the provided position or time, the default is DEGREES or MSEC
velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
units_v (optional) : The units of the provided velocity, default is RPM
wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

Returns:

None

Examples:

# spin 180 degrees from the current position\
motor1.spin_for(FORWARD, 180)

# spin reverse 2 TURNS (revolutions) from the current position\
motor1.spin_for(REVERSE, 2, TURNS)

# spin 180 degrees from the current position at 25 rpm\
motor1.spin_for(FORWARD, 180, DEGREES, 25, RPM)

# spin 180 degrees  from the current position and do not wait for completion\
motor1.spin_for(FORWARD, 180, DEGREES, False)

# spin 180 degrees  from the current position and do not wait for completion\
motor1.spin_for(FORWARD, 180, DEGREES, wait=False)

Source code in vex.py

def spin_for(self, direction: DirectionType.DirectionType, rot_or_time: vexnumber, *args, **kwargs):
    '''### Spin the motor to a relative position using the provided arguments
    Move the motor to the requested position or for the specified amount of time.\\
    The position is relative (ie. an offset) to the current position\\
    This function supports keyword arguments.

    #### Arguments:
        dir : The direction to spin the motor, FORWARD or REVERSE
        rot_or_time : The relative position to spin the motor to or tha amount of time to spin for
        units (optional) : The units for the provided position or time, the default is DEGREES or MSEC
        velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
        units_v (optional) : The units of the provided velocity, default is RPM
        wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

    #### Returns:
        None

    #### Examples:
        # spin 180 degrees from the current position\\
        motor1.spin_for(FORWARD, 180)\n
        # spin reverse 2 TURNS (revolutions) from the current position\\
        motor1.spin_for(REVERSE, 2, TURNS)\n
        # spin 180 degrees from the current position at 25 rpm\\
        motor1.spin_for(FORWARD, 180, DEGREES, 25, RPM)\n
        # spin 180 degrees  from the current position and do not wait for completion\\
        motor1.spin_for(FORWARD, 180, DEGREES, False)\n
        # spin 180 degrees  from the current position and do not wait for completion\\
        motor1.spin_for(FORWARD, 180, DEGREES, wait=False)
    '''
    pass

`spin_to_position(rotation, *args, **kwargs)`

Spin the motor to an absolute position using the provided arguments

Move the motor to the requested position.\ This function supports keyword arguments.

Arguments:

rotation : The position to spin the motor to
units (optional) : The units for the provided position, the default is DEGREES
velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
units_v (optional) : The units of the provided velocity, default is RPM
wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

Returns:

None

Examples:

# spin to 180 degrees\
motor1.spin_to_position(180)

# spin to 2 TURNS (revolutions)\
motor1.spin_to_position(2, TURNS)

# spin to 180 degrees at 25 rpm\
motor1.spin_to_position(180, DEGREES, 25, RPM)

# spin to 180 degrees and do not wait for completion\
motor1.spin_to_position(180, DEGREES, False)

# spin to 180 degrees and do not wait for completion\
motor1.spin_to_position(180, DEGREES, wait=False)

Source code in vex.py

def spin_to_position(self, rotation: vexnumber, *args, **kwargs):
    '''### Spin the motor to an absolute position using the provided arguments
    Move the motor to the requested position.\\
    This function supports keyword arguments.

    #### Arguments:
        rotation : The position to spin the motor to
        units (optional) : The units for the provided position, the default is DEGREES
        velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
        units_v (optional) : The units of the provided velocity, default is RPM
        wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

    #### Returns:
        None

    #### Examples:
        # spin to 180 degrees\\
        motor1.spin_to_position(180)\n
        # spin to 2 TURNS (revolutions)\\
        motor1.spin_to_position(2, TURNS) \n
        # spin to 180 degrees at 25 rpm\\
        motor1.spin_to_position(180, DEGREES, 25, RPM)\n
        # spin to 180 degrees and do not wait for completion\\
        motor1.spin_to_position(180, DEGREES, False)\n
        # spin to 180 degrees and do not wait for completion\\
        motor1.spin_to_position(180, DEGREES, wait=False)
    '''
    pass

`stop(mode=None)`

Stop the motor, set to 0 velocity and set current stopping_mode

The motor will be stopped and set to COAST, BRAKE or HOLD

Arguments:

None

Returns:

None

Source code in vex.py

def stop(self, mode=None):
    '''### Stop the motor, set to 0 velocity and set current stopping_mode
    The motor will be stopped and set to COAST, BRAKE or HOLD

    #### Arguments:
        None

    #### Returns:
        None
    '''
    pass

`temperature(*args)`

Returns the temperature of the motor

Arguments:

units (optional) : The units for the returned temperature, the default is CELSIUS

Returns:

The motor temperature in provided units

Source code in vex.py

def temperature(self, *args):
    '''### Returns the temperature of the motor

    #### Arguments:
        units (optional) : The units for the returned temperature, the default is CELSIUS

    #### Returns:
        The motor temperature in provided units
    '''
    return 1

`timestamp()`

Request the timestamp of last received message from the motor

Arguments:

None

Returns:

timestamp of the last status packet in mS

Source code in vex.py

def timestamp(self):
    '''### Request the timestamp of last received message from the motor

    #### Arguments:
        None

    #### Returns:
        timestamp of the last status packet in mS
    '''
    return 0

`torque(*args)`

Returns the torque the motor is providing

Arguments:

units (optional) : The units for the returned torque, the default is NM

Returns:

The motor torque in provided units

Source code in vex.py

def torque(self, *args):
    '''### Returns the torque the motor is providing

    #### Arguments:
        units (optional) : The units for the returned torque, the default is NM

    #### Returns:
        The motor torque in provided units
    '''
    return 1

`velocity(*args)`

Returns the velocity of the motor

Arguments:

units (optional) : The units for the returned velocity, the default is RPM

Returns:

The motor velocity in provided units

Source code in vex.py

def velocity(self, *args):
    '''### Returns the velocity of the motor

    #### Arguments:
        units (optional) : The units for the returned velocity, the default is RPM

    #### Returns:
        The motor velocity in provided units
    '''
    return 2

MotorGroup

`vex.MotorGroup`

MotorGroup class - use this to create a group of motors

Arguments:

One or more Motor class instances

Returns:

A new MotorGroup object.

Examples:

motor1 = Motor(Ports.PORT1)\
motor2 = Motor(Ports.PORT2)\
mg1 = MotorGroup(motor1, motor2)

Source code in vex.py

class MotorGroup:
    '''### MotorGroup class - use this to create a group of motors

    #### Arguments:
        One or more Motor class instances

    #### Returns:
        A new MotorGroup object.

    #### Examples:
        motor1 = Motor(Ports.PORT1)\\
        motor2 = Motor(Ports.PORT2)\\
        mg1 = MotorGroup(motor1, motor2)
    '''
    def __init__(self, *argv):
        self._motors = list()

        for arg in argv:
            if isinstance(arg, Motor):
                self._motors.append(arg)

        self._timeout = sys.maxsize

# ----------------------------------------------------------------------------
    def count(self):
        '''### return the number of motors in the group

        #### Arguments:
            None

        #### Returns:
            The number of motors in the group
        '''
        return len(self._motors)

# ----------------------------------------------------------------------------
    def set_velocity(self, velocity, units=None):
        '''### Set default velocity for all motors in the group
        This will be the velocity used for subsequent calls to spin if a velocity is not provided
        to that function.

        #### Arguments:
            velocity : The new velocity
            units : The units for the supplied velocity, the default is RPM

        #### Returns:
            None
        '''
        for m in self._motors:
            m.set_velocity(velocity, units)

# ----------------------------------------------------------------------------
    def set_stopping(self, mode=BrakeType.COAST):
        '''### Set the stopping mode for all motors in the group
        Setting the action for the motor when stopped.

        #### Arguments:
            mode : The stopping mode, COAST, BRAKE or HOLD

        #### Returns:
            None
        '''
        for m in self._motors:
            m.set_stopping(mode)

# ----------------------------------------------------------------------------
    def reset_position(self):
        '''### Reset the motor position to 0 for all motors in the group

        #### Arguments:
            None

        #### Returns:
            None
        '''
        for m in self._motors:
            m.reset_position()

# ----------------------------------------------------------------------------
    def set_position(self, value, units=None):
        '''### Set the current position for all motors in the group
        The position returned by the position() function is set to this value.

        #### Arguments:
            value : The new position
            units : The units for the provided position, the default is DEGREES

        #### Returns:
            None
        '''
        for m in self._motors:
            m.set_position(value, units)

# ----------------------------------------------------------------------------
    def set_timeout(self, timeout, units=TimeUnits.MSEC):
        '''### Set the timeout value used for all motors in the group
        The timeout value is used when performing spin_to_position and spin_for commands.  If timeout is
         reached and the motor has not completed moving, then the spin... function will return False.

        #### Arguments:
            timeout : The new timeout
            units : The units for the provided timeout, the default is MSEC

        #### Returns:
            None
        '''
        if units == TimeUnits.SECONDS and timeout > 0:
            if timeout > 100000:
                timeout = 100000
            self._timeout = timeout * 1000
        elif timeout <= 0:
            self._timeout = sys.maxsize
        else:
            self._timeout = timeout

        for m in self._motors:
            m.set_timeout(timeout, units)

# ----------------------------------------------------------------------------
    def spin(self, direction, velocity=None, units:VelocityPercentUnits=VelocityUnits.RPM):
        '''### Spin all motors in the group using the provided arguments

        #### Arguments:
            direction : The direction to spin the motor, FORWARD or REVERSE
            velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
            units (optional) : The units of the provided velocity, default is RPM

        #### Returns:
            None

        #### Examples:
            # spin motors forward at velocity set with set_velocity\\
            mg1.spin(FORWARD)\n
            # spin motors forward at 50 rpm\\
            mg1.spin(FORWARD, 50)\n
            # spin with negative velocity, ie. backwards\\
            mg1.spin(FORWARD, -20)\n
            # spin motors forwards with 100% velocity\\
            mg1.spin(FORWARD, 100, PERCENT)\n
            # spin motors forwards at 50 rpm\\
            mg1.spin(FORWARD, 50, RPM)\n
            # spin motors forwards at 360 dps\\
            mg1.spin(FORWARD, 360.0, VelocityUnits.DPS)
        '''
        for m in self._motors:
            m.spin(direction, velocity, units)

# ----------------------------------------------------------------------------
    def spin_to_position(self, rotation, units=RotationUnits.DEG,
                         velocity=None, units_v:VelocityPercentUnits=VelocityUnits.RPM, wait=True):
        '''### Spin all motors in the group to an absolute position using the provided arguments
        Move the motor to the requested position.\\
        This function supports keyword arguments.

        #### Arguments:
            rotation : The position to spin the motor to
            units (optional) : The units for the provided position, the default is DEGREES
            velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
            units_v (optional) : The units of the provided velocity, default is RPM
            wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

        #### Returns:
            None

        #### Examples:
            # spin to 180 degrees\\
            mg1.spin_to_position(180)\n
            # spin to 2 TURNS (revolutions)\\
            mg1.spin_to_position(2, TURNS) \n
            # spin to 180 degrees at 25 rpm\\
            mg1.spin_to_position(180, DEGREES, 25, RPM)\n
            # spin to 180 degrees and do not wait for completion\\
            mg1.spin_to_position(180, DEGREES, False)\n
            # spin to 180 degrees and do not wait for completion\\
            mg1.spin_to_position(180, DEGREES, wait=False)
        '''
        for m in self._motors:
            m.spin_to_position(rotation, units, velocity, units_v, False)

        if wait:
            return self.__waitForCompletionAll()

        return False

# ----------------------------------------------------------------------------
    def __spin_for_distance(self, direction, rotation, units,
                            velocity, units_v, wait):
        for m in self._motors:
            m.spin_for(direction, rotation, units, velocity, units_v, False)

        if wait:
            return self.__waitForCompletionAll()

        return False

# ----------------------------------------------------------------------------
    def __spin_for_time(self, direction, time, units, velocity, units_v):
        for m in self._motors:
            if m == self._motors[-1]:
                m.spin_for(direction, time, units, velocity, units_v)
            else:
                m.spin(direction, velocity, units_v)

        self.stop()

# ----------------------------------------------------------------------------
    def spin_for(self, direction, rotation, units:RotationTimeUnits=RotationUnits.DEG,
                 velocity=None, units_v:VelocityPercentUnits=VelocityUnits.RPM, wait=True):
        '''### Spin all motors in the group to a relative position using the provided arguments
        Move the motor to the requested position or for the specified amount of time.\\
        The position is relative (ie. an offset) to the current position\\
        This function supports keyword arguments.

        #### Arguments:
            direction : The direction to spin the motor, FORWARD or REVERSE
            rotation : The relative position to spin the motor to or tha amount of time to spin for
            units (optional) : The units for the provided position or time, the default is DEGREES or MSEC
            velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
            units_v (optional) : The units of the provided velocity, default is RPM
            wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

        #### Returns:
            None

        #### Examples:
            # spin 180 degrees from the current position\\
            mg1.spin_for(FORWARD, 180)\n
            # spin reverse 2 TURNS (revolutions) from the current position\\
            mg1.spin_for(REVERSE, 2, TURNS)\n
            # spin 180 degrees from the current position at 25 rpm\\
            mg1.spin_for(FORWARD, 180, DEGREES, 25, RPM)\n
            # spin 180 degrees  from the current position and do not wait for completion\\
            mg1.spin_for(FORWARD, 180, DEGREES, False)\n
            # spin 180 degrees  from the current position and do not wait for completion\\
            mg1.spin_for(FORWARD, 180, DEGREES, wait=False)
        '''
        if isinstance(units, TimeUnits):
            time = rotation
            self.__spin_for_time(direction, time, units, velocity, units_v)
        else:
            self.__spin_for_distance(
                direction, rotation, units, velocity, units_v, wait)

# ----------------------------------------------------------------------------
    def is_spinning(self):
        '''### Returns the current status of the spin_to_position or spin_for command
        This function is used when False has been passed as the wait parameter to spin_to_position or spin_for\\
        It will return True if any motor is still spinning or False if they have completed the move or a timeout occurred.

        #### Arguments:
            None

        #### Returns:
            The current spin_to_position or spin_for status
        '''
        isAnyMotorSpinning = False
        for m in self._motors:
            isAnyMotorSpinning = isAnyMotorSpinning or m.is_spinning()
        return isAnyMotorSpinning

# ----------------------------------------------------------------------------
    def is_spinning_mode(self):
        isAnyMotorSpinningMode = False
        for m in self._motors:
            isAnyMotorSpinningMode = isAnyMotorSpinningMode or m.is_spinning_mode()
        return isAnyMotorSpinningMode

# ----------------------------------------------------------------------------
    def is_done(self):
        '''### Returns the current status of the spin_to_position or spin_for command
        This function is used when False has been passed as the wait parameter to spin_to_position or spin_for\\
        It will return False if any motor is still spinning or True if they have completed the move or a timeout occurred.

        #### Arguments:
            None

        #### Returns:
            The current spin_to_position or spin_for status
        '''
        return not self.is_spinning()

# ----------------------------------------------------------------------------
    def stop(self, mode=None):
        '''### Stop all motors in the group, set to 0 velocity and set current stopping_mode
        The motor will be stopped and set to COAST, BRAKE or HOLD

        #### Arguments:
            None

        #### Returns:
            None
        '''
        for m in self._motors:
            m.stop(mode)

# ----------------------------------------------------------------------------
    def set_max_torque(self, value, units:TorquePercentCurrentUnits=TorqueUnits.NM):
        '''### Set the maximum torque all motors in the group will use
        The torque can be set as torque, current or percent of maximum.

        #### Arguments:
            value : the new maximum torque to use
            units : the units that value is passed in

        #### Returns:
            None

        #### Examples:
            # set maximum torque to 2 Nm\\
            motor1.set_max_torque(2, TorqueUnits.NM)\n
            # set maximum torque to 1 Amp\\
            motor1.set_max_torque(1, CurrentUnits.AMP)\n
            # set maximum torque to 20 percent\\
            motor1.set_max_torque(20, PERCENT)
        '''
        for m in self._motors:
            m.set_max_torque(value, units)

# ----------------------------------------------------------------------------
    def direction(self):
        '''### Returns the current direction the first motor is spinning in

        #### Arguments:
            None

        #### Returns:
            The spin direction, FORWARD, REVERSE or UNDEFINED
        '''
        return self._motors[0].direction()

# ----------------------------------------------------------------------------
    def position(self, units=RotationUnits.DEG):
        '''### Returns the position of the first motor

        #### Arguments:
            units (optional) : The units for the returned position, the default is DEGREES

        #### Returns:
            The motor position in provided units
        '''
        return self._motors[0].position(units)

# ----------------------------------------------------------------------------
    def velocity(self, units:VelocityPercentUnits=VelocityUnits.RPM):
        '''### Returns the velocity of the first motor

        #### Arguments:
            units (optional) : The units for the returned velocity, the default is RPM

        #### Returns:
            The motor velocity in provided units
        '''
        return self._motors[0].velocity(units)

# ----------------------------------------------------------------------------
    def current(self, units=CurrentUnits.AMP):
        '''### Returns the total current all motors are using

        #### Arguments:
            units (optional) : The units for the returned current, the default is AMP

        #### Returns:
            The motor current in provided units
        '''
        total_current = 0
        for m in self._motors:
            total_current += m.current(units)
        return total_current

# ----------------------------------------------------------------------------
    def power(self, units=PowerUnits.WATT):
        '''### Returns the power the first motor is providing

        #### Arguments:
            units (optional) : The units for the returned power, the default is WATT

        #### Returns:
            The motor power in provided units
        '''
        return self._motors[0].power(units)

# ----------------------------------------------------------------------------
    def torque(self, units:TorquePercentCurrentUnits=TorqueUnits.NM):
        '''### Returns the torque the first motor is providing

        #### Arguments:
            units (optional) : The units for the returned torque, the default is NM

        #### Returns:
            The motor torque in provided units
        '''
        return self._motors[0].torque(units)

# ----------------------------------------------------------------------------
    def efficiency(self, units=PercentUnits.PERCENT):
        '''### Returns the efficiency of the first motor

        #### Arguments:
            units (optional) : The units for the efficiency, the only valid value is PERCENT

        #### Returns:
            The motor efficiency in percent
        '''
        return self._motors[0].efficiency(units)

# ----------------------------------------------------------------------------
    def temperature(self, units=TemperatureUnits.CELSIUS):
        '''### Returns the temperature of the first motor

        #### Arguments:
            units (optional) : The units for the returned temperature, the default is CELSIUS

        #### Returns:
            The motor temperature in provided units
        '''
        return self._motors[0].temperature(units)

# ----------------------------------------------------------------------------
    def __waitForCompletionAll(self):
        t = self._timeout
        while t > 0 and self.is_spinning():
            t -= 10
            sleep(10)

        done = self.is_done()
        if not done:
            self.stop()

        return done

`count()`

return the number of motors in the group

Arguments:

None

Returns:

The number of motors in the group

Source code in vex.py

def count(self):
    '''### return the number of motors in the group

    #### Arguments:
        None

    #### Returns:
        The number of motors in the group
    '''
    return len(self._motors)

`current(units=CurrentUnits.AMP)`

Returns the total current all motors are using

Arguments:

units (optional) : The units for the returned current, the default is AMP

Returns:

The motor current in provided units

Source code in vex.py

def current(self, units=CurrentUnits.AMP):
    '''### Returns the total current all motors are using

    #### Arguments:
        units (optional) : The units for the returned current, the default is AMP

    #### Returns:
        The motor current in provided units
    '''
    total_current = 0
    for m in self._motors:
        total_current += m.current(units)
    return total_current

`direction()`

Returns the current direction the first motor is spinning in

Arguments:

None

Returns:

The spin direction, FORWARD, REVERSE or UNDEFINED

Source code in vex.py

def direction(self):
    '''### Returns the current direction the first motor is spinning in

    #### Arguments:
        None

    #### Returns:
        The spin direction, FORWARD, REVERSE or UNDEFINED
    '''
    return self._motors[0].direction()

`efficiency(units=PercentUnits.PERCENT)`

Returns the efficiency of the first motor

Arguments:

units (optional) : The units for the efficiency, the only valid value is PERCENT

Returns:

The motor efficiency in percent

Source code in vex.py

def efficiency(self, units=PercentUnits.PERCENT):
    '''### Returns the efficiency of the first motor

    #### Arguments:
        units (optional) : The units for the efficiency, the only valid value is PERCENT

    #### Returns:
        The motor efficiency in percent
    '''
    return self._motors[0].efficiency(units)

`is_done()`

Returns the current status of the spin_to_position or spin_for command

This function is used when False has been passed as the wait parameter to spin_to_position or spin_for\ It will return False if any motor is still spinning or True if they have completed the move or a timeout occurred.

Arguments:

None

Returns:

The current spin_to_position or spin_for status

Source code in vex.py

def is_done(self):
    '''### Returns the current status of the spin_to_position or spin_for command
    This function is used when False has been passed as the wait parameter to spin_to_position or spin_for\\
    It will return False if any motor is still spinning or True if they have completed the move or a timeout occurred.

    #### Arguments:
        None

    #### Returns:
        The current spin_to_position or spin_for status
    '''
    return not self.is_spinning()

`is_spinning()`

Returns the current status of the spin_to_position or spin_for command

This function is used when False has been passed as the wait parameter to spin_to_position or spin_for\ It will return True if any motor is still spinning or False if they have completed the move or a timeout occurred.

Arguments:

None

Returns:

The current spin_to_position or spin_for status

Source code in vex.py

def is_spinning(self):
    '''### Returns the current status of the spin_to_position or spin_for command
    This function is used when False has been passed as the wait parameter to spin_to_position or spin_for\\
    It will return True if any motor is still spinning or False if they have completed the move or a timeout occurred.

    #### Arguments:
        None

    #### Returns:
        The current spin_to_position or spin_for status
    '''
    isAnyMotorSpinning = False
    for m in self._motors:
        isAnyMotorSpinning = isAnyMotorSpinning or m.is_spinning()
    return isAnyMotorSpinning

`position(units=RotationUnits.DEG)`

Returns the position of the first motor

Arguments:

units (optional) : The units for the returned position, the default is DEGREES

Returns:

The motor position in provided units

Source code in vex.py

def position(self, units=RotationUnits.DEG):
    '''### Returns the position of the first motor

    #### Arguments:
        units (optional) : The units for the returned position, the default is DEGREES

    #### Returns:
        The motor position in provided units
    '''
    return self._motors[0].position(units)

`power(units=PowerUnits.WATT)`

Returns the power the first motor is providing

Arguments:

units (optional) : The units for the returned power, the default is WATT

Returns:

The motor power in provided units

Source code in vex.py

def power(self, units=PowerUnits.WATT):
    '''### Returns the power the first motor is providing

    #### Arguments:
        units (optional) : The units for the returned power, the default is WATT

    #### Returns:
        The motor power in provided units
    '''
    return self._motors[0].power(units)

`reset_position()`

Reset the motor position to 0 for all motors in the group

Arguments:

None

Returns:

None

Source code in vex.py

def reset_position(self):
    '''### Reset the motor position to 0 for all motors in the group

    #### Arguments:
        None

    #### Returns:
        None
    '''
    for m in self._motors:
        m.reset_position()

`set_max_torque(value, units=TorqueUnits.NM)`

Set the maximum torque all motors in the group will use

The torque can be set as torque, current or percent of maximum.

Arguments:

value : the new maximum torque to use
units : the units that value is passed in

Returns:

None

Examples:

# set maximum torque to 2 Nm\
motor1.set_max_torque(2, TorqueUnits.NM)

# set maximum torque to 1 Amp\
motor1.set_max_torque(1, CurrentUnits.AMP)

# set maximum torque to 20 percent\
motor1.set_max_torque(20, PERCENT)

Source code in vex.py

def set_max_torque(self, value, units:TorquePercentCurrentUnits=TorqueUnits.NM):
    '''### Set the maximum torque all motors in the group will use
    The torque can be set as torque, current or percent of maximum.

    #### Arguments:
        value : the new maximum torque to use
        units : the units that value is passed in

    #### Returns:
        None

    #### Examples:
        # set maximum torque to 2 Nm\\
        motor1.set_max_torque(2, TorqueUnits.NM)\n
        # set maximum torque to 1 Amp\\
        motor1.set_max_torque(1, CurrentUnits.AMP)\n
        # set maximum torque to 20 percent\\
        motor1.set_max_torque(20, PERCENT)
    '''
    for m in self._motors:
        m.set_max_torque(value, units)

`set_position(value, units=None)`

Set the current position for all motors in the group

The position returned by the position() function is set to this value.

Arguments:

value : The new position
units : The units for the provided position, the default is DEGREES

Returns:

None

Source code in vex.py

def set_position(self, value, units=None):
    '''### Set the current position for all motors in the group
    The position returned by the position() function is set to this value.

    #### Arguments:
        value : The new position
        units : The units for the provided position, the default is DEGREES

    #### Returns:
        None
    '''
    for m in self._motors:
        m.set_position(value, units)

`set_stopping(mode=BrakeType.COAST)`

Set the stopping mode for all motors in the group

Setting the action for the motor when stopped.

Arguments:

mode : The stopping mode, COAST, BRAKE or HOLD

Returns:

None

Source code in vex.py

def set_stopping(self, mode=BrakeType.COAST):
    '''### Set the stopping mode for all motors in the group
    Setting the action for the motor when stopped.

    #### Arguments:
        mode : The stopping mode, COAST, BRAKE or HOLD

    #### Returns:
        None
    '''
    for m in self._motors:
        m.set_stopping(mode)

`set_timeout(timeout, units=TimeUnits.MSEC)`

Set the timeout value used for all motors in the group

The timeout value is used when performing spin_to_position and spin_for commands. If timeout is reached and the motor has not completed moving, then the spin... function will return False.

Arguments:

timeout : The new timeout
units : The units for the provided timeout, the default is MSEC

Returns:

None

Source code in vex.py

def set_timeout(self, timeout, units=TimeUnits.MSEC):
    '''### Set the timeout value used for all motors in the group
    The timeout value is used when performing spin_to_position and spin_for commands.  If timeout is
     reached and the motor has not completed moving, then the spin... function will return False.

    #### Arguments:
        timeout : The new timeout
        units : The units for the provided timeout, the default is MSEC

    #### Returns:
        None
    '''
    if units == TimeUnits.SECONDS and timeout > 0:
        if timeout > 100000:
            timeout = 100000
        self._timeout = timeout * 1000
    elif timeout <= 0:
        self._timeout = sys.maxsize
    else:
        self._timeout = timeout

    for m in self._motors:
        m.set_timeout(timeout, units)

`set_velocity(velocity, units=None)`

Set default velocity for all motors in the group

This will be the velocity used for subsequent calls to spin if a velocity is not provided to that function.

Arguments:

velocity : The new velocity
units : The units for the supplied velocity, the default is RPM

Returns:

None

Source code in vex.py

def set_velocity(self, velocity, units=None):
    '''### Set default velocity for all motors in the group
    This will be the velocity used for subsequent calls to spin if a velocity is not provided
    to that function.

    #### Arguments:
        velocity : The new velocity
        units : The units for the supplied velocity, the default is RPM

    #### Returns:
        None
    '''
    for m in self._motors:
        m.set_velocity(velocity, units)

`spin(direction, velocity=None, units=VelocityUnits.RPM)`

Spin all motors in the group using the provided arguments

Arguments:

direction : The direction to spin the motor, FORWARD or REVERSE
velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
units (optional) : The units of the provided velocity, default is RPM

Returns:

None

Examples:

# spin motors forward at velocity set with set_velocity\
mg1.spin(FORWARD)

# spin motors forward at 50 rpm\
mg1.spin(FORWARD, 50)

# spin with negative velocity, ie. backwards\
mg1.spin(FORWARD, -20)

# spin motors forwards with 100% velocity\
mg1.spin(FORWARD, 100, PERCENT)

# spin motors forwards at 50 rpm\
mg1.spin(FORWARD, 50, RPM)

# spin motors forwards at 360 dps\
mg1.spin(FORWARD, 360.0, VelocityUnits.DPS)

Source code in vex.py

def spin(self, direction, velocity=None, units:VelocityPercentUnits=VelocityUnits.RPM):
    '''### Spin all motors in the group using the provided arguments

    #### Arguments:
        direction : The direction to spin the motor, FORWARD or REVERSE
        velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
        units (optional) : The units of the provided velocity, default is RPM

    #### Returns:
        None

    #### Examples:
        # spin motors forward at velocity set with set_velocity\\
        mg1.spin(FORWARD)\n
        # spin motors forward at 50 rpm\\
        mg1.spin(FORWARD, 50)\n
        # spin with negative velocity, ie. backwards\\
        mg1.spin(FORWARD, -20)\n
        # spin motors forwards with 100% velocity\\
        mg1.spin(FORWARD, 100, PERCENT)\n
        # spin motors forwards at 50 rpm\\
        mg1.spin(FORWARD, 50, RPM)\n
        # spin motors forwards at 360 dps\\
        mg1.spin(FORWARD, 360.0, VelocityUnits.DPS)
    '''
    for m in self._motors:
        m.spin(direction, velocity, units)

`spin_for(direction, rotation, units=RotationUnits.DEG, velocity=None, units_v=VelocityUnits.RPM, wait=True)`

Spin all motors in the group to a relative position using the provided arguments

Move the motor to the requested position or for the specified amount of time.\ The position is relative (ie. an offset) to the current position\ This function supports keyword arguments.

Arguments:

direction : The direction to spin the motor, FORWARD or REVERSE
rotation : The relative position to spin the motor to or tha amount of time to spin for
units (optional) : The units for the provided position or time, the default is DEGREES or MSEC
velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
units_v (optional) : The units of the provided velocity, default is RPM
wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

Returns:

None

Examples:

# spin 180 degrees from the current position\
mg1.spin_for(FORWARD, 180)

# spin reverse 2 TURNS (revolutions) from the current position\
mg1.spin_for(REVERSE, 2, TURNS)

# spin 180 degrees from the current position at 25 rpm\
mg1.spin_for(FORWARD, 180, DEGREES, 25, RPM)

# spin 180 degrees  from the current position and do not wait for completion\
mg1.spin_for(FORWARD, 180, DEGREES, False)

# spin 180 degrees  from the current position and do not wait for completion\
mg1.spin_for(FORWARD, 180, DEGREES, wait=False)

Source code in vex.py

def spin_for(self, direction, rotation, units:RotationTimeUnits=RotationUnits.DEG,
             velocity=None, units_v:VelocityPercentUnits=VelocityUnits.RPM, wait=True):
    '''### Spin all motors in the group to a relative position using the provided arguments
    Move the motor to the requested position or for the specified amount of time.\\
    The position is relative (ie. an offset) to the current position\\
    This function supports keyword arguments.

    #### Arguments:
        direction : The direction to spin the motor, FORWARD or REVERSE
        rotation : The relative position to spin the motor to or tha amount of time to spin for
        units (optional) : The units for the provided position or time, the default is DEGREES or MSEC
        velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
        units_v (optional) : The units of the provided velocity, default is RPM
        wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

    #### Returns:
        None

    #### Examples:
        # spin 180 degrees from the current position\\
        mg1.spin_for(FORWARD, 180)\n
        # spin reverse 2 TURNS (revolutions) from the current position\\
        mg1.spin_for(REVERSE, 2, TURNS)\n
        # spin 180 degrees from the current position at 25 rpm\\
        mg1.spin_for(FORWARD, 180, DEGREES, 25, RPM)\n
        # spin 180 degrees  from the current position and do not wait for completion\\
        mg1.spin_for(FORWARD, 180, DEGREES, False)\n
        # spin 180 degrees  from the current position and do not wait for completion\\
        mg1.spin_for(FORWARD, 180, DEGREES, wait=False)
    '''
    if isinstance(units, TimeUnits):
        time = rotation
        self.__spin_for_time(direction, time, units, velocity, units_v)
    else:
        self.__spin_for_distance(
            direction, rotation, units, velocity, units_v, wait)

`spin_to_position(rotation, units=RotationUnits.DEG, velocity=None, units_v=VelocityUnits.RPM, wait=True)`

Spin all motors in the group to an absolute position using the provided arguments

Move the motor to the requested position.\ This function supports keyword arguments.

Arguments:

rotation : The position to spin the motor to
units (optional) : The units for the provided position, the default is DEGREES
velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
units_v (optional) : The units of the provided velocity, default is RPM
wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

Returns:

None

Examples:

# spin to 180 degrees\
mg1.spin_to_position(180)

# spin to 2 TURNS (revolutions)\
mg1.spin_to_position(2, TURNS)

# spin to 180 degrees at 25 rpm\
mg1.spin_to_position(180, DEGREES, 25, RPM)

# spin to 180 degrees and do not wait for completion\
mg1.spin_to_position(180, DEGREES, False)

# spin to 180 degrees and do not wait for completion\
mg1.spin_to_position(180, DEGREES, wait=False)

Source code in vex.py

def spin_to_position(self, rotation, units=RotationUnits.DEG,
                     velocity=None, units_v:VelocityPercentUnits=VelocityUnits.RPM, wait=True):
    '''### Spin all motors in the group to an absolute position using the provided arguments
    Move the motor to the requested position.\\
    This function supports keyword arguments.

    #### Arguments:
        rotation : The position to spin the motor to
        units (optional) : The units for the provided position, the default is DEGREES
        velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
        units_v (optional) : The units of the provided velocity, default is RPM
        wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

    #### Returns:
        None

    #### Examples:
        # spin to 180 degrees\\
        mg1.spin_to_position(180)\n
        # spin to 2 TURNS (revolutions)\\
        mg1.spin_to_position(2, TURNS) \n
        # spin to 180 degrees at 25 rpm\\
        mg1.spin_to_position(180, DEGREES, 25, RPM)\n
        # spin to 180 degrees and do not wait for completion\\
        mg1.spin_to_position(180, DEGREES, False)\n
        # spin to 180 degrees and do not wait for completion\\
        mg1.spin_to_position(180, DEGREES, wait=False)
    '''
    for m in self._motors:
        m.spin_to_position(rotation, units, velocity, units_v, False)

    if wait:
        return self.__waitForCompletionAll()

    return False

`stop(mode=None)`

Stop all motors in the group, set to 0 velocity and set current stopping_mode

The motor will be stopped and set to COAST, BRAKE or HOLD

Arguments:

None

Returns:

None

Source code in vex.py

def stop(self, mode=None):
    '''### Stop all motors in the group, set to 0 velocity and set current stopping_mode
    The motor will be stopped and set to COAST, BRAKE or HOLD

    #### Arguments:
        None

    #### Returns:
        None
    '''
    for m in self._motors:
        m.stop(mode)

`temperature(units=TemperatureUnits.CELSIUS)`

Returns the temperature of the first motor

Arguments:

units (optional) : The units for the returned temperature, the default is CELSIUS

Returns:

The motor temperature in provided units

Source code in vex.py

def temperature(self, units=TemperatureUnits.CELSIUS):
    '''### Returns the temperature of the first motor

    #### Arguments:
        units (optional) : The units for the returned temperature, the default is CELSIUS

    #### Returns:
        The motor temperature in provided units
    '''
    return self._motors[0].temperature(units)

`torque(units=TorqueUnits.NM)`

Returns the torque the first motor is providing

Arguments:

units (optional) : The units for the returned torque, the default is NM

Returns:

The motor torque in provided units

Source code in vex.py

def torque(self, units:TorquePercentCurrentUnits=TorqueUnits.NM):
    '''### Returns the torque the first motor is providing

    #### Arguments:
        units (optional) : The units for the returned torque, the default is NM

    #### Returns:
        The motor torque in provided units
    '''
    return self._motors[0].torque(units)

`velocity(units=VelocityUnits.RPM)`

Returns the velocity of the first motor

Arguments:

units (optional) : The units for the returned velocity, the default is RPM

Returns:

The motor velocity in provided units

Source code in vex.py

def velocity(self, units:VelocityPercentUnits=VelocityUnits.RPM):
    '''### Returns the velocity of the first motor

    #### Arguments:
        units (optional) : The units for the returned velocity, the default is RPM

    #### Returns:
        The motor velocity in provided units
    '''
    return self._motors[0].velocity(units)

DriveTrain

`vex.DriveTrain`

DriveTrain class - use this to create a simple drivetrain

Arguments:

lm : Left motor or motorgroup
rm : Right motor or motorgroup
wheelTravel (optional) : The circumference of the driven wheels, default is 300 mm
trackWidth (optional) : The trackwidth of the drivetrain, default is 320 mm
wheelBase (optional) : The wheelBase of the drivetrain, default is 320 mm
units (optional) : The units that wheelTravel, trackWidth and wheelBase are specified in, default is MM.
externalGearRatio (optional) : An optional gear ratio used to compensate drive distances if gearing is used.

Returns:

A new DriveTrain object.

Examples:

# A simple two motor drivetrain using default values\
motor1 = Motor(Ports.PORT1)\
motor2 = Motor(Ports.PORT2, True)\
drive1 = DriveTrain(motor1, motor2)

# A four motor drivetrain using custom values\
motor1 = Motor(Ports.PORT1)\
motor2 = Motor(Ports.PORT2)\
motor3 = Motor(Ports.PORT3, True)\
motor4 = Motor(Ports.PORT4, True)\
mgl = MotorGroup(motor1, motor3)\
mgr = MotorGroup(motor2, motor4)\
drive1 = DriveTrain(mgl, mgr, 8.6, 10, 12, INCHES)

Source code in vex.py

class DriveTrain:
    '''### DriveTrain class - use this to create a simple drivetrain

    #### Arguments:
        lm : Left motor or motorgroup
        rm : Right motor or motorgroup
        wheelTravel (optional) : The circumference of the driven wheels, default is 300 mm
        trackWidth (optional) : The trackwidth of the drivetrain, default is 320 mm
        wheelBase (optional) : The wheelBase of the drivetrain, default is 320 mm
        units (optional) : The units that wheelTravel, trackWidth and wheelBase are specified in, default is MM.
        externalGearRatio (optional) : An optional gear ratio used to compensate drive distances if gearing is used.

    #### Returns:
        A new DriveTrain object.

    #### Examples:
        # A simple two motor drivetrain using default values\\
        motor1 = Motor(Ports.PORT1)\\
        motor2 = Motor(Ports.PORT2, True)\\
        drive1 = DriveTrain(motor1, motor2)

        # A four motor drivetrain using custom values\\
        motor1 = Motor(Ports.PORT1)\\
        motor2 = Motor(Ports.PORT2)\\
        motor3 = Motor(Ports.PORT3, True)\\
        motor4 = Motor(Ports.PORT4, True)\\
        mgl = MotorGroup(motor1, motor3)\\
        mgr = MotorGroup(motor2, motor4)\\
        drive1 = DriveTrain(mgl, mgr, 8.6, 10, 12, INCHES)
    '''
    def __init__(self, lm, rm, wheelTravel:vexnumber=300, trackWidth:vexnumber=320, wheelBase:vexnumber=320,
                 units=DistanceUnits.MM, externalGearRatio=1.0):
        if(not (isinstance(lm, Motor) or isinstance(lm, MotorGroup)) or
           not (isinstance(rm, Motor) or isinstance(rm, MotorGroup))):
            raise TypeError('must pass two motors or motor groups')

        # motors or motor groups
        self.lm = lm
        self.rm = rm

# ----------------------------------------------------------------------------
    def set_drive_velocity(self, velocity, units:VelocityPercentUnits=VelocityUnits.RPM):
        '''### Set default velocity for drive commands
        This will be the velocity used for subsequent calls to drive if a velocity is not provided
        to that function.

        #### Arguments:
            velocity : The new velocity
            units : The units for the supplied velocity, the default is RPM

        #### Returns:
            None
        '''
        pass
# ----------------------------------------------------------------------------

    def set_turn_velocity(self, velocity, units:VelocityPercentUnits=VelocityUnits.RPM):
        '''### Set default velocity for turn commands
        This will be the velocity used for subsequent calls to turn if a velocity is not provided
        to that function.

        #### Arguments:
            velocity : The new velocity
            units : The units for the supplied velocity, the default is RPM

        #### Returns:
            None
        '''
        pass

# ----------------------------------------------------------------------------
    def set_stopping(self, mode=BrakeType.COAST):
        '''### Set the stopping mode for all motors on the drivetrain
        Setting the action for the motors when stopped.

        #### Arguments:
            mode : The stopping mode, COAST, BRAKE or HOLD

        #### Returns:
            None
        '''
        pass

# ----------------------------------------------------------------------------
    def set_timeout(self, timeout, units=TimeUnits.MSEC):
        '''### Set the timeout value used all motors on the drivetrain
        The timeout value is used when performing drive_for and turn_for commands.  If timeout is
         reached and the motor has not completed moving, then the function will return False.

        #### Arguments:
            timeout : The new timeout
            units : The units for the provided timeout, the default is MSEC

        #### Returns:
            None
        '''
        pass

# ----------------------------------------------------------------------------
    def get_timeout(self):
        '''### Get the current timeout value used by the drivetrain

        #### Arguments:
            None

        #### Returns:
            Timeout value in mS
        '''
        return 1000

# ----------------------------------------------------------------------------
    def drive(self, direction, velocity=None, units:VelocityPercentUnits=VelocityUnits.RPM):
        '''### drive the drivetrain using the provided arguments

        The drive command is similar to the motor spin command.\\
        all drive motors are commanded using the provided parameters.

        #### Arguments:
            direction : The direction to drive, FORWARD or REVERSE
            velocity (optional) : spin the motors using this velocity, the default velocity set by set_velocity will be used if not provided.
            units (optional) : The units of the provided velocity, default is RPM

        #### Returns:
            None

        #### Examples:
            # drive forward at velocity set with set_velocity\\
            drive1.drive(FORWARD)\n
            # drive forward at 50 rpm\\
            drive1.drive(FORWARD, 50)\n
            # drive with negative velocity, ie. backwards\\
            drive1.drive(FORWARD, -20)\n
            # drive forwards with 100% velocity\\
            drive1.drive(FORWARD, 100, PERCENT)\n
            # drive forwards at 50 rpm\\
            drive1.drive(FORWARD, 50, RPM)\n
            # drive forwards at 360 dps\\
            drive1.drive(FORWARD, 360.0, VelocityUnits.DPS)
        '''
        pass

# ----------------------------------------------------------------------------
    def drive_for(self, direction, distance, units=DistanceUnits.IN,
                  velocity=None, units_v:VelocityPercentUnits=VelocityUnits.RPM, wait=True):
        '''### move the drivetrain using the provided arguments

        The drive_for command is similar to the motor spin_for command,\\
        however, the drivetrain is commanded to move a distance.

        #### Arguments:
            direction : The direction to drive
            distance : The distance to drive
            units (optional) : The units for the provided distance, the default is INCHES
            velocity (optional) : drive using this velocity, the default velocity set by set_drive_velocity will be used if not provided.
            units_v (optional) : The units of the provided velocity, default is RPM
            wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

        #### Returns:
            None or if wait is True then completion success or failure

        #### Examples:
            # drive forward 10 inches from the current position\\
            drive1.drive_for(FORWARD, 10, INCHES)\n
            # drive reverse 1000mm from the current position with motors at 50 rpm\\
            drive1.drive_for(REVERSE, 10000, MM, 50, RPM)
        '''
        pass

# ----------------------------------------------------------------------------
    def turn(self, direction, velocity=None, units:VelocityPercentUnits=VelocityUnits.RPM):
        '''### turn the drivetrain using the provided arguments

        The drive command is similar to the motor spin command.\\
        all drive motors are commanded using the provided parameters.

        #### Arguments:
            direction : The turn direction, LEFT or RIGHT
            velocity (optional) : spin the motors using this velocity, the default velocity set by set_turn_velocity will be used if not provided.
            units (optional) : The units of the provided velocity, default is RPM

        #### Returns:
            None

        #### Examples:
            # turn left at velocity set with set_turn_velocity\\
            drive1.turn(LEFT)\n
            # drive right at 50 rpm\\
            drive1.turn(RIGHT, 50)\n
            # turn right with 100% velocity\\
            drive1.turn(RIGHT, 100, PERCENT)\n
            # turn right at 50 rpm\\
            drive1.turn(RIGHT, 50, RPM)\n
            # turn right at 360 dps\\
            drive1.turn(RIGHT, 360.0, VelocityUnits.DPS)
        '''
        pass

# ----------------------------------------------------------------------------
    def turn_for(self, direction, angle, units=RotationUnits.DEG,
                 velocity=None, units_v:VelocityPercentUnits=VelocityUnits.RPM, wait=True):
        '''### turn the drivetrain using the provided arguments

        The turn_for command is similar to the motor spin_for command,\\
        however, the drivetrain is commanded to turn a specified angle.

        #### Arguments:
            direction : The direction to turn, LEFT or RIGHT
            angle : The angle to turn
            units (optional) : The units for the provided angle, the default is DEGREES
            velocity (optional) : drive using this velocity, the default velocity set by set_drive_velocity will be used if not provided.
            units_v (optional) : The units of the provided velocity, default is RPM
            wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

        #### Returns:
            None or if wait is True then completion success or failure

        #### Examples:
            # turn right 90 degrees\\
            drive1.turn_for(RIGHT, 90, DEGREES)\n
            # turn left 180 degrees with motors at 50 rpm\\
            drive1.turn_for(LEFT, 180, DEGREES, 50, RPM)
        '''
        pass

# ----------------------------------------------------------------------------
    def is_moving(self):
        '''### Returns the current status of the drive_for or turn_for command
        This function is used when False has been passed as the wait parameter to drive_for or turn_for\\
        It will return True if the drivetrain is still moving or False if it has completed the move or a timeout occurred.

        #### Arguments:
            None

        #### Returns:
            The current drive_for or turn_for status
        '''
        return False

# ----------------------------------------------------------------------------
    def is_done(self):
        '''### Returns the current status of the drive_for or turn_for command
        This function is used when False has been passed as the wait parameter to drive_for or turn_for\\
        It will return False if the drivetrain is still moving or True if it has completed the move or a timeout occurred.

        #### Arguments:
            None

        #### Returns:
            The current drive_for or turn_for status
        '''
        return True

# ----------------------------------------------------------------------------

    def stop(self, mode=None):
        '''### Stop the drivetrain, set to 0 velocity and set current stopping_mode
        The motors will be stopped and set to COAST, BRAKE or HOLD

        #### Arguments:
            None

        #### Returns:
            None
        '''
        pass

# ----------------------------------------------------------------------------
    def velocity(self, units:VelocityPercentUnits=VelocityUnits.RPM):
        '''### Returns average velocity of the left and right motors

        #### Arguments:
            units (optional) : The units for the returned velocity, the default is RPM

        #### Returns:
            The drivetrain velocity in provided units
        '''
        return 0

# ----------------------------------------------------------------------------
    def current(self, units=CurrentUnits.AMP):
        '''### Returns the total current all drivetrain motors are using

        #### Arguments:
            units (optional) : The units for the returned current, the default is AMP

        #### Returns:
            The drivetrain current in provided units
        '''
        return 0

# ----------------------------------------------------------------------------
    def power(self, units=PowerUnits.WATT):
        '''### Returns the total power all drivetrain motors are using

        This command only considers the first motor for left and right sides of the drive.

        #### Arguments:
            units (optional) : The units for the returned power, the default is WATT

        #### Returns:
            The drivetrain power in provided units
        '''
        return 0

# ----------------------------------------------------------------------------
    def torque(self, units=TorqueUnits.NM):
        '''### Returns the total torque all drivetrain motors are using

        This command only considers the first motor for left and right sides of the drive.

        #### Arguments:
            units (optional) : The units for the returned torque, the default is NM

        #### Returns:
            The motor torque in provided units
        '''
        return 0

# ----------------------------------------------------------------------------
    def efficiency(self, units=PercentUnits.PERCENT):
        '''### Returns the average efficiency of the left and right motors

        This command only considers the first motor for left and right sides of the drive.

        #### Arguments:
            units (optional) : The units for the efficiency, the only valid value is PERCENT

        #### Returns:
            The motor efficiency in percent
        '''
        return 0

# ----------------------------------------------------------------------------
    def temperature(self, units=TemperatureUnits.CELSIUS):
        '''### Returns the average temperature of the left and right motors

        This command only considers the first motor for left and right sides of the drive.

        #### Arguments:
            units (optional) : The units for the returned temperature, the default is CELSIUS

        #### Returns:
            The motor temperature in provided units
        '''
        return 0

`current(units=CurrentUnits.AMP)`

Returns the total current all drivetrain motors are using

Arguments:

units (optional) : The units for the returned current, the default is AMP

Returns:

The drivetrain current in provided units

Source code in vex.py

def current(self, units=CurrentUnits.AMP):
    '''### Returns the total current all drivetrain motors are using

    #### Arguments:
        units (optional) : The units for the returned current, the default is AMP

    #### Returns:
        The drivetrain current in provided units
    '''
    return 0

`drive(direction, velocity=None, units=VelocityUnits.RPM)`

drive the drivetrain using the provided arguments

The drive command is similar to the motor spin command.\ all drive motors are commanded using the provided parameters.

Arguments:

direction : The direction to drive, FORWARD or REVERSE
velocity (optional) : spin the motors using this velocity, the default velocity set by set_velocity will be used if not provided.
units (optional) : The units of the provided velocity, default is RPM

Returns:

None

Examples:

# drive forward at velocity set with set_velocity\
drive1.drive(FORWARD)

# drive forward at 50 rpm\
drive1.drive(FORWARD, 50)

# drive with negative velocity, ie. backwards\
drive1.drive(FORWARD, -20)

# drive forwards with 100% velocity\
drive1.drive(FORWARD, 100, PERCENT)

# drive forwards at 50 rpm\
drive1.drive(FORWARD, 50, RPM)

# drive forwards at 360 dps\
drive1.drive(FORWARD, 360.0, VelocityUnits.DPS)

Source code in vex.py

def drive(self, direction, velocity=None, units:VelocityPercentUnits=VelocityUnits.RPM):
    '''### drive the drivetrain using the provided arguments

    The drive command is similar to the motor spin command.\\
    all drive motors are commanded using the provided parameters.

    #### Arguments:
        direction : The direction to drive, FORWARD or REVERSE
        velocity (optional) : spin the motors using this velocity, the default velocity set by set_velocity will be used if not provided.
        units (optional) : The units of the provided velocity, default is RPM

    #### Returns:
        None

    #### Examples:
        # drive forward at velocity set with set_velocity\\
        drive1.drive(FORWARD)\n
        # drive forward at 50 rpm\\
        drive1.drive(FORWARD, 50)\n
        # drive with negative velocity, ie. backwards\\
        drive1.drive(FORWARD, -20)\n
        # drive forwards with 100% velocity\\
        drive1.drive(FORWARD, 100, PERCENT)\n
        # drive forwards at 50 rpm\\
        drive1.drive(FORWARD, 50, RPM)\n
        # drive forwards at 360 dps\\
        drive1.drive(FORWARD, 360.0, VelocityUnits.DPS)
    '''
    pass

`drive_for(direction, distance, units=DistanceUnits.IN, velocity=None, units_v=VelocityUnits.RPM, wait=True)`

move the drivetrain using the provided arguments

The drive_for command is similar to the motor spin_for command,\ however, the drivetrain is commanded to move a distance.

Arguments:

direction : The direction to drive
distance : The distance to drive
units (optional) : The units for the provided distance, the default is INCHES
velocity (optional) : drive using this velocity, the default velocity set by set_drive_velocity will be used if not provided.
units_v (optional) : The units of the provided velocity, default is RPM
wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

Returns:

None or if wait is True then completion success or failure

Examples:

# drive forward 10 inches from the current position\
drive1.drive_for(FORWARD, 10, INCHES)

# drive reverse 1000mm from the current position with motors at 50 rpm\
drive1.drive_for(REVERSE, 10000, MM, 50, RPM)

Source code in vex.py

def drive_for(self, direction, distance, units=DistanceUnits.IN,
              velocity=None, units_v:VelocityPercentUnits=VelocityUnits.RPM, wait=True):
    '''### move the drivetrain using the provided arguments

    The drive_for command is similar to the motor spin_for command,\\
    however, the drivetrain is commanded to move a distance.

    #### Arguments:
        direction : The direction to drive
        distance : The distance to drive
        units (optional) : The units for the provided distance, the default is INCHES
        velocity (optional) : drive using this velocity, the default velocity set by set_drive_velocity will be used if not provided.
        units_v (optional) : The units of the provided velocity, default is RPM
        wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

    #### Returns:
        None or if wait is True then completion success or failure

    #### Examples:
        # drive forward 10 inches from the current position\\
        drive1.drive_for(FORWARD, 10, INCHES)\n
        # drive reverse 1000mm from the current position with motors at 50 rpm\\
        drive1.drive_for(REVERSE, 10000, MM, 50, RPM)
    '''
    pass

`efficiency(units=PercentUnits.PERCENT)`

Returns the average efficiency of the left and right motors

This command only considers the first motor for left and right sides of the drive.

Arguments:

units (optional) : The units for the efficiency, the only valid value is PERCENT

Returns:

The motor efficiency in percent

Source code in vex.py

def efficiency(self, units=PercentUnits.PERCENT):
    '''### Returns the average efficiency of the left and right motors

    This command only considers the first motor for left and right sides of the drive.

    #### Arguments:
        units (optional) : The units for the efficiency, the only valid value is PERCENT

    #### Returns:
        The motor efficiency in percent
    '''
    return 0

`get_timeout()`

Get the current timeout value used by the drivetrain

Arguments:

None

Returns:

Timeout value in mS

Source code in vex.py

def get_timeout(self):
    '''### Get the current timeout value used by the drivetrain

    #### Arguments:
        None

    #### Returns:
        Timeout value in mS
    '''
    return 1000

`is_done()`

Returns the current status of the drive_for or turn_for command

This function is used when False has been passed as the wait parameter to drive_for or turn_for\ It will return False if the drivetrain is still moving or True if it has completed the move or a timeout occurred.

Arguments:

None

Returns:

The current drive_for or turn_for status

Source code in vex.py

def is_done(self):
    '''### Returns the current status of the drive_for or turn_for command
    This function is used when False has been passed as the wait parameter to drive_for or turn_for\\
    It will return False if the drivetrain is still moving or True if it has completed the move or a timeout occurred.

    #### Arguments:
        None

    #### Returns:
        The current drive_for or turn_for status
    '''
    return True

`is_moving()`

Returns the current status of the drive_for or turn_for command

This function is used when False has been passed as the wait parameter to drive_for or turn_for\ It will return True if the drivetrain is still moving or False if it has completed the move or a timeout occurred.

Arguments:

None

Returns:

The current drive_for or turn_for status

Source code in vex.py

def is_moving(self):
    '''### Returns the current status of the drive_for or turn_for command
    This function is used when False has been passed as the wait parameter to drive_for or turn_for\\
    It will return True if the drivetrain is still moving or False if it has completed the move or a timeout occurred.

    #### Arguments:
        None

    #### Returns:
        The current drive_for or turn_for status
    '''
    return False

`power(units=PowerUnits.WATT)`

Returns the total power all drivetrain motors are using

This command only considers the first motor for left and right sides of the drive.

Arguments:

units (optional) : The units for the returned power, the default is WATT

Returns:

The drivetrain power in provided units

Source code in vex.py

def power(self, units=PowerUnits.WATT):
    '''### Returns the total power all drivetrain motors are using

    This command only considers the first motor for left and right sides of the drive.

    #### Arguments:
        units (optional) : The units for the returned power, the default is WATT

    #### Returns:
        The drivetrain power in provided units
    '''
    return 0

`set_drive_velocity(velocity, units=VelocityUnits.RPM)`

Set default velocity for drive commands

This will be the velocity used for subsequent calls to drive if a velocity is not provided to that function.

Arguments:

velocity : The new velocity
units : The units for the supplied velocity, the default is RPM

Returns:

None

Source code in vex.py

def set_drive_velocity(self, velocity, units:VelocityPercentUnits=VelocityUnits.RPM):
    '''### Set default velocity for drive commands
    This will be the velocity used for subsequent calls to drive if a velocity is not provided
    to that function.

    #### Arguments:
        velocity : The new velocity
        units : The units for the supplied velocity, the default is RPM

    #### Returns:
        None
    '''
    pass

`set_stopping(mode=BrakeType.COAST)`

Set the stopping mode for all motors on the drivetrain

Setting the action for the motors when stopped.

Arguments:

mode : The stopping mode, COAST, BRAKE or HOLD

Returns:

None

Source code in vex.py

def set_stopping(self, mode=BrakeType.COAST):
    '''### Set the stopping mode for all motors on the drivetrain
    Setting the action for the motors when stopped.

    #### Arguments:
        mode : The stopping mode, COAST, BRAKE or HOLD

    #### Returns:
        None
    '''
    pass

`set_timeout(timeout, units=TimeUnits.MSEC)`

Set the timeout value used all motors on the drivetrain

The timeout value is used when performing drive_for and turn_for commands. If timeout is reached and the motor has not completed moving, then the function will return False.

Arguments:

timeout : The new timeout
units : The units for the provided timeout, the default is MSEC

Returns:

None

Source code in vex.py

def set_timeout(self, timeout, units=TimeUnits.MSEC):
    '''### Set the timeout value used all motors on the drivetrain
    The timeout value is used when performing drive_for and turn_for commands.  If timeout is
     reached and the motor has not completed moving, then the function will return False.

    #### Arguments:
        timeout : The new timeout
        units : The units for the provided timeout, the default is MSEC

    #### Returns:
        None
    '''
    pass

`set_turn_velocity(velocity, units=VelocityUnits.RPM)`

Set default velocity for turn commands

This will be the velocity used for subsequent calls to turn if a velocity is not provided to that function.

Arguments:

velocity : The new velocity
units : The units for the supplied velocity, the default is RPM

Returns:

None

Source code in vex.py

def set_turn_velocity(self, velocity, units:VelocityPercentUnits=VelocityUnits.RPM):
    '''### Set default velocity for turn commands
    This will be the velocity used for subsequent calls to turn if a velocity is not provided
    to that function.

    #### Arguments:
        velocity : The new velocity
        units : The units for the supplied velocity, the default is RPM

    #### Returns:
        None
    '''
    pass

`stop(mode=None)`

Stop the drivetrain, set to 0 velocity and set current stopping_mode

The motors will be stopped and set to COAST, BRAKE or HOLD

Arguments:

None

Returns:

None

Source code in vex.py

def stop(self, mode=None):
    '''### Stop the drivetrain, set to 0 velocity and set current stopping_mode
    The motors will be stopped and set to COAST, BRAKE or HOLD

    #### Arguments:
        None

    #### Returns:
        None
    '''
    pass

`temperature(units=TemperatureUnits.CELSIUS)`

Returns the average temperature of the left and right motors

This command only considers the first motor for left and right sides of the drive.

Arguments:

units (optional) : The units for the returned temperature, the default is CELSIUS

Returns:

The motor temperature in provided units

Source code in vex.py

def temperature(self, units=TemperatureUnits.CELSIUS):
    '''### Returns the average temperature of the left and right motors

    This command only considers the first motor for left and right sides of the drive.

    #### Arguments:
        units (optional) : The units for the returned temperature, the default is CELSIUS

    #### Returns:
        The motor temperature in provided units
    '''
    return 0

`torque(units=TorqueUnits.NM)`

Returns the total torque all drivetrain motors are using

This command only considers the first motor for left and right sides of the drive.

Arguments:

units (optional) : The units for the returned torque, the default is NM

Returns:

The motor torque in provided units

Source code in vex.py

def torque(self, units=TorqueUnits.NM):
    '''### Returns the total torque all drivetrain motors are using

    This command only considers the first motor for left and right sides of the drive.

    #### Arguments:
        units (optional) : The units for the returned torque, the default is NM

    #### Returns:
        The motor torque in provided units
    '''
    return 0

`turn(direction, velocity=None, units=VelocityUnits.RPM)`

turn the drivetrain using the provided arguments

The drive command is similar to the motor spin command.\ all drive motors are commanded using the provided parameters.

Arguments:

direction : The turn direction, LEFT or RIGHT
velocity (optional) : spin the motors using this velocity, the default velocity set by set_turn_velocity will be used if not provided.
units (optional) : The units of the provided velocity, default is RPM

Returns:

None

Examples:

# turn left at velocity set with set_turn_velocity\
drive1.turn(LEFT)

# drive right at 50 rpm\
drive1.turn(RIGHT, 50)

# turn right with 100% velocity\
drive1.turn(RIGHT, 100, PERCENT)

# turn right at 50 rpm\
drive1.turn(RIGHT, 50, RPM)

# turn right at 360 dps\
drive1.turn(RIGHT, 360.0, VelocityUnits.DPS)

Source code in vex.py

def turn(self, direction, velocity=None, units:VelocityPercentUnits=VelocityUnits.RPM):
    '''### turn the drivetrain using the provided arguments

    The drive command is similar to the motor spin command.\\
    all drive motors are commanded using the provided parameters.

    #### Arguments:
        direction : The turn direction, LEFT or RIGHT
        velocity (optional) : spin the motors using this velocity, the default velocity set by set_turn_velocity will be used if not provided.
        units (optional) : The units of the provided velocity, default is RPM

    #### Returns:
        None

    #### Examples:
        # turn left at velocity set with set_turn_velocity\\
        drive1.turn(LEFT)\n
        # drive right at 50 rpm\\
        drive1.turn(RIGHT, 50)\n
        # turn right with 100% velocity\\
        drive1.turn(RIGHT, 100, PERCENT)\n
        # turn right at 50 rpm\\
        drive1.turn(RIGHT, 50, RPM)\n
        # turn right at 360 dps\\
        drive1.turn(RIGHT, 360.0, VelocityUnits.DPS)
    '''
    pass

`turn_for(direction, angle, units=RotationUnits.DEG, velocity=None, units_v=VelocityUnits.RPM, wait=True)`

turn the drivetrain using the provided arguments

The turn_for command is similar to the motor spin_for command,\ however, the drivetrain is commanded to turn a specified angle.

Arguments:

direction : The direction to turn, LEFT or RIGHT
angle : The angle to turn
units (optional) : The units for the provided angle, the default is DEGREES
velocity (optional) : drive using this velocity, the default velocity set by set_drive_velocity will be used if not provided.
units_v (optional) : The units of the provided velocity, default is RPM
wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

Returns:

None or if wait is True then completion success or failure

Examples:

# turn right 90 degrees\
drive1.turn_for(RIGHT, 90, DEGREES)

# turn left 180 degrees with motors at 50 rpm\
drive1.turn_for(LEFT, 180, DEGREES, 50, RPM)

Source code in vex.py

def turn_for(self, direction, angle, units=RotationUnits.DEG,
             velocity=None, units_v:VelocityPercentUnits=VelocityUnits.RPM, wait=True):
    '''### turn the drivetrain using the provided arguments

    The turn_for command is similar to the motor spin_for command,\\
    however, the drivetrain is commanded to turn a specified angle.

    #### Arguments:
        direction : The direction to turn, LEFT or RIGHT
        angle : The angle to turn
        units (optional) : The units for the provided angle, the default is DEGREES
        velocity (optional) : drive using this velocity, the default velocity set by set_drive_velocity will be used if not provided.
        units_v (optional) : The units of the provided velocity, default is RPM
        wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

    #### Returns:
        None or if wait is True then completion success or failure

    #### Examples:
        # turn right 90 degrees\\
        drive1.turn_for(RIGHT, 90, DEGREES)\n
        # turn left 180 degrees with motors at 50 rpm\\
        drive1.turn_for(LEFT, 180, DEGREES, 50, RPM)
    '''
    pass

`velocity(units=VelocityUnits.RPM)`

Returns average velocity of the left and right motors

Arguments:

units (optional) : The units for the returned velocity, the default is RPM

Returns:

The drivetrain velocity in provided units

Source code in vex.py

def velocity(self, units:VelocityPercentUnits=VelocityUnits.RPM):
    '''### Returns average velocity of the left and right motors

    #### Arguments:
        units (optional) : The units for the returned velocity, the default is RPM

    #### Returns:
        The drivetrain velocity in provided units
    '''
    return 0

SmartDrive

`vex.SmartDrive`

Bases: DriveTrain

SmartDrive class - use this to create a smart drivetrain

A smart drivetrain uses a gyro or similar sensor to turn more accurately.\ The smartdrive inherits all drivetrain functions.

Arguments:

lm : Left motor or motorgroup
rm : Right motor or motorgroup
g : The gyro, inertial sensor or gps to use for turns
wheelTravel (optional) : The circumference of the driven wheels, default is 300 mm
trackWidth (optional) : The trackwidth of the drivetrain, default is 320 mm
wheelBase (optional) : The wheelBase of the drivetrain, default is 320 mm
units (optional) : The units that wheelTravel, trackWidth and wheelBase are specified in, default is MM.
externalGearRatio (optional) : An optional gear ratio used to compensate drive distances if gearing is used.

Returns:

A new SmartDrive object.

Examples:

# A simple two motor smart drivetrain using default values\
motor1 = Motor(Ports.PORT1)\
motor2 = Motor(Ports.PORT2, True)\
imu1 = Inertial(Ports.PORT9)\
smart1 = SmartDrive(motor1, motor2, imu1)

# A four motor smart drivetrain using custom values\
motor1 = Motor(Ports.PORT1)\
motor2 = Motor(Ports.PORT2)\
motor3 = Motor(Ports.PORT3, True)\
motor4 = Motor(Ports.PORT4, True)\
imu1 = Inertial(Ports.PORT9)\
mgl = MotorGroup(motor1, motor3)\
mgr = MotorGroup(motor2, motor4)\
smart1 = SmartDrive(mgl, mgr, imu1, 8.6, 10, 12, INCHES)

Source code in vex.py

class SmartDrive(DriveTrain):
    '''### SmartDrive class - use this to create a smart drivetrain

    A smart drivetrain uses a gyro or similar sensor to turn more accurately.\\
    The smartdrive inherits all drivetrain functions.

    #### Arguments:
        lm : Left motor or motorgroup
        rm : Right motor or motorgroup
        g : The gyro, inertial sensor or gps to use for turns
        wheelTravel (optional) : The circumference of the driven wheels, default is 300 mm
        trackWidth (optional) : The trackwidth of the drivetrain, default is 320 mm
        wheelBase (optional) : The wheelBase of the drivetrain, default is 320 mm
        units (optional) : The units that wheelTravel, trackWidth and wheelBase are specified in, default is MM.
        externalGearRatio (optional) : An optional gear ratio used to compensate drive distances if gearing is used.

    #### Returns:
        A new SmartDrive object.

    #### Examples:
        # A simple two motor smart drivetrain using default values\\
        motor1 = Motor(Ports.PORT1)\\
        motor2 = Motor(Ports.PORT2, True)\\
        imu1 = Inertial(Ports.PORT9)\\
        smart1 = SmartDrive(motor1, motor2, imu1)

        # A four motor smart drivetrain using custom values\\
        motor1 = Motor(Ports.PORT1)\\
        motor2 = Motor(Ports.PORT2)\\
        motor3 = Motor(Ports.PORT3, True)\\
        motor4 = Motor(Ports.PORT4, True)\\
        imu1 = Inertial(Ports.PORT9)\\
        mgl = MotorGroup(motor1, motor3)\\
        mgr = MotorGroup(motor2, motor4)\\
        smart1 = SmartDrive(mgl, mgr, imu1, 8.6, 10, 12, INCHES)
    '''
    def __init__(self, lm, rm, g, wheelTravel:vexnumber=300, trackWidth:vexnumber=320,
                 wheelBase:vexnumber=320, units=DistanceUnits.MM,
                 externalGearRatio=1.0):

        if(not (isinstance(lm, Motor) or isinstance(lm, MotorGroup)) or
           not (isinstance(rm, Motor) or isinstance(rm, MotorGroup))):
            raise TypeError('must pass two motors or motor groups')

        if not (isinstance(g, Gyro) or isinstance(g, Inertial) or isinstance(g, Gps)):
            raise TypeError('must pass Gyro, Inertial or Gps instance')

        DriveTrain.__init__(self, lm, rm, wheelTravel,
                            trackWidth, wheelBase, units, externalGearRatio)
        self.g = g

# ----------------------------------------------------------
    def set_turn_threshold(self, value):
        '''### Set the turning threshold for the smartdrive

        This is the threshold value used to determine that turns are complete.\\
        If this is too large then turns will not be accurate, if too small then turns ma\\
        not complete.

        #### Arguments:
            value : The new turn threshold in degrees, the default for a smartdrive is 1 degree

        #### Returns:
            None
        '''
        pass

# ----------------------------------------------------------
    def set_turn_constant(self, value):
        '''### Set the turning constant for the smartdrive

        The smartdrive uses a simple P controller when doing turns.\\
        This constant, generally known as kp, is the gain used in the equation that\\
        turns angular error into motor velocity.

        #### Arguments:
            value : The new turn constant in the range 0.1 - 4.0, the default is 1.0

        #### Returns:
            None
        '''
        pass

# ----------------------------------------------------------
    def set_turn_direction_reverse(self, value):
        '''### Set the expected turn direction for positive heading change

        #### Arguments:
            value : True or False

        #### Returns:
            None
        '''
        pass

# ----------------------------------------------------------
    def set_heading(self, value, units=RotationUnits.DEG):
        '''### set the smartdrive heading to a new value

        The new value for heading should be in the range 0 - 359.99 degrees.

        #### Arguments:
            value : The new value to use for heading.
            units (optional) : The rotation units type for value, the default is DEGREES

        #### Returns:
            None

        #### Examples:
            # set the value of heading to 180 degrees\\
            smart1.set_heading(180)
        '''
        pass
# ----------------------------------------------------------

    def heading(self, units=RotationUnits.DEG):
        '''### read the current heading of the smartdrive

        heading will be returned in the range 0 - 359.99 degrees

        #### Arguments:
            units (optional) : The units to return the heading in, default is DEGREES

        #### Returns:
            A value for heading in the range that is specified by the units.

        #### Examples:
            # get the current heading for the smartdrive\\
            value = smart1.heading()
        '''
        return 0

# ----------------------------------------------------------
    def set_rotation(self, value, units=RotationUnits.DEG):
        '''### set the smartdrive rotation to a new value

        #### Arguments:
            value : The new value to use for rotation.
            units (optional) : The rotation units type for value, the default is DEGREES

        #### Returns:
            None

        #### Examples:
            # set the value of rotation to 180 degrees\\
            smart1.set_rotation(180)
        '''
        pass

# ----------------------------------------------------------
    def rotation(self, units=RotationUnits.DEG):
        '''### read the current rotation of the smartdrive

        rotation is not limited, it can be both positive and negative and shows the absolute angle of the gyro.

        #### Arguments:
            units (optional) : The units to return the rotation in, default is DEGREES

        #### Returns:
            A value for heading in the range that is specified by the units.

        #### Examples:
            # get the current rotation for the smartdrive\\
            value = smart1.rotation()
        '''
        return self.g.rotation(units)

# ----------------------------------------------------------
    def turn_to_heading(self, angle, units=RotationUnits.DEG,
                        velocity=None, units_v:VelocityPercentUnits=VelocityUnits.RPM, wait=True):
        '''### turn the smartdrive to an absolute position using the provided arguments

        The turn_to_heading command is similar to the motor spin_to_position command,\\
        however, the smartdrive is commanded to turn to a specified angle.\\
        This function uses the value of heading() when turning the smartdrive\\
        This function supports keyword arguments.

        #### Arguments:
            angle : The angle to turn to
            units (optional) : The units for the provided angle, the default is DEGREES
            velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
            units_v (optional) : The units of the provided velocity, default is RPM
            wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

        #### Returns:
            None

        #### Examples:
            # turn to heading 180 degrees\\
            smart1.turn_to_heading(180)\n
            # turn to heading 180 degrees at 25 rpm\\
            smart1.turn_to_heading(180, DEGREES, 25, RPM)\n
            # turn to heading 180 degrees and do not wait for completion\\
            smart1.turn_to_heading(180, DEGREES, False)\n
            # turn to heading 180 degrees and do not wait for completion\\
            smart1.turn_to_heading(180, DEGREES, wait=False)
        '''
        return True

# ----------------------------------------------------------
    def turn_to_rotation(self, angle, units=RotationUnits.DEG,
                         velocity=None, units_v:VelocityPercentUnits=VelocityUnits.RPM, wait=True):
        '''### turn the smartdrive to an absolute position using the provided arguments

        The turn_to_rotation command is similar to the motor spin_to_position command,\\
        however, the smartdrive is commanded to turn to a specified angle.\\
        This function uses the value of rotation() when turning the smartdrive\\
        This function supports keyword arguments.

        #### Arguments:
            angle : The angle to turn to
            units (optional) : The units for the provided angle, the default is DEGREES
            velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
            units_v (optional) : The units of the provided velocity, default is RPM
            wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

        #### Returns:
            None

        #### Examples:
            # turn to rotation 180 degrees\\
            smart1.turn_to_rotation(180)\n
            # turn to rotation 400 degrees at 25 rpm\\
            smart1.turn_to_rotation(400, DEGREES, 25, RPM)\n
            # turn to rotation 180 degrees and do not wait for completion\\
            smart1.turn_to_rotation(180, DEGREES, False)\n
            # turn to rotation 180 degrees and do not wait for completion\\
            smart1.turn_to_rotation(180, DEGREES, wait=False)
        '''
        return True

# ----------------------------------------------------------
    def turn_for(self, direction, angle, units=RotationUnits.DEG,
                 velocity=None, units_v:VelocityPercentUnits=VelocityUnits.RPM, wait=True):
        '''### turn the smartdrive using the provided arguments

        The turn_for command is similar to the motor spin_for command,\\
        however, the smartdrive is commanded to turn a specified angle.

        #### Arguments:
            direction : The direction to turn, LEFT or RIGHT
            angle : The angle to turn
            units (optional) : The units for the provided angle, the default is DEGREES
            velocity (optional) : drive using this velocity, the default velocity set by set_drive_velocity will be used if not provided.
            units_v (optional) : The units of the provided velocity, default is RPM
            wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

        #### Returns:
            None or if wait is True then completion success or failure

        #### Examples:
            # turn right 90 degrees\\
            smart1.turn_for(RIGHT, 90, DEGREES)\n
            # turn left 180 degrees with motors at 50 rpm\\
            smart1.turn_for(LEFT, 180, DEGREES, 50, RPM)
        '''
        return True

# ----------------------------------------------------------
    def is_turning(self):
        '''### Returns the current status of the turn_to_heading, turn_to_rotation or turn_for command
        This function is used when False has been passed as the wait parameter to turn_to_heading or turn_for\\
        It will return True if the drivetrain is still moving or False if it has completed the move or a timeout occurred.

        #### Arguments:
            None

        #### Returns:
            The current turn_to_heading, turn_to_rotation or turn_for status
        '''
        return False

# ----------------------------------------------------------
    def is_moving(self):
        '''### Returns the current status of the drive_for command
        This function is used when False has been passed as the wait parameter to drive_for\\
        It will return True if the drivetrain is still moving or False if it has completed the move or a timeout occurred.

        #### Arguments:
            None

        #### Returns:
            The current drive_for status
        '''
        return False

`heading(units=RotationUnits.DEG)`

read the current heading of the smartdrive

heading will be returned in the range 0 - 359.99 degrees

Arguments:

units (optional) : The units to return the heading in, default is DEGREES

Returns:

A value for heading in the range that is specified by the units.

Examples:

# get the current heading for the smartdrive\
value = smart1.heading()

Source code in vex.py

def heading(self, units=RotationUnits.DEG):
    '''### read the current heading of the smartdrive

    heading will be returned in the range 0 - 359.99 degrees

    #### Arguments:
        units (optional) : The units to return the heading in, default is DEGREES

    #### Returns:
        A value for heading in the range that is specified by the units.

    #### Examples:
        # get the current heading for the smartdrive\\
        value = smart1.heading()
    '''
    return 0

`is_moving()`

Returns the current status of the drive_for command

This function is used when False has been passed as the wait parameter to drive_for\ It will return True if the drivetrain is still moving or False if it has completed the move or a timeout occurred.

Arguments:

None

Returns:

The current drive_for status

Source code in vex.py

def is_moving(self):
    '''### Returns the current status of the drive_for command
    This function is used when False has been passed as the wait parameter to drive_for\\
    It will return True if the drivetrain is still moving or False if it has completed the move or a timeout occurred.

    #### Arguments:
        None

    #### Returns:
        The current drive_for status
    '''
    return False

`is_turning()`

Returns the current status of the turn_to_heading, turn_to_rotation or turn_for command

This function is used when False has been passed as the wait parameter to turn_to_heading or turn_for\ It will return True if the drivetrain is still moving or False if it has completed the move or a timeout occurred.

Arguments:

None

Returns:

The current turn_to_heading, turn_to_rotation or turn_for status

Source code in vex.py

def is_turning(self):
    '''### Returns the current status of the turn_to_heading, turn_to_rotation or turn_for command
    This function is used when False has been passed as the wait parameter to turn_to_heading or turn_for\\
    It will return True if the drivetrain is still moving or False if it has completed the move or a timeout occurred.

    #### Arguments:
        None

    #### Returns:
        The current turn_to_heading, turn_to_rotation or turn_for status
    '''
    return False

`rotation(units=RotationUnits.DEG)`

read the current rotation of the smartdrive

rotation is not limited, it can be both positive and negative and shows the absolute angle of the gyro.

Arguments:

units (optional) : The units to return the rotation in, default is DEGREES

Returns:

A value for heading in the range that is specified by the units.

Examples:

# get the current rotation for the smartdrive\
value = smart1.rotation()

Source code in vex.py

def rotation(self, units=RotationUnits.DEG):
    '''### read the current rotation of the smartdrive

    rotation is not limited, it can be both positive and negative and shows the absolute angle of the gyro.

    #### Arguments:
        units (optional) : The units to return the rotation in, default is DEGREES

    #### Returns:
        A value for heading in the range that is specified by the units.

    #### Examples:
        # get the current rotation for the smartdrive\\
        value = smart1.rotation()
    '''
    return self.g.rotation(units)

`set_heading(value, units=RotationUnits.DEG)`

set the smartdrive heading to a new value

The new value for heading should be in the range 0 - 359.99 degrees.

Arguments:

value : The new value to use for heading.
units (optional) : The rotation units type for value, the default is DEGREES

Returns:

None

Examples:

# set the value of heading to 180 degrees\
smart1.set_heading(180)

Source code in vex.py

def set_heading(self, value, units=RotationUnits.DEG):
    '''### set the smartdrive heading to a new value

    The new value for heading should be in the range 0 - 359.99 degrees.

    #### Arguments:
        value : The new value to use for heading.
        units (optional) : The rotation units type for value, the default is DEGREES

    #### Returns:
        None

    #### Examples:
        # set the value of heading to 180 degrees\\
        smart1.set_heading(180)
    '''
    pass

`set_rotation(value, units=RotationUnits.DEG)`

set the smartdrive rotation to a new value

Arguments:

value : The new value to use for rotation.
units (optional) : The rotation units type for value, the default is DEGREES

Returns:

None

Examples:

# set the value of rotation to 180 degrees\
smart1.set_rotation(180)

Source code in vex.py

def set_rotation(self, value, units=RotationUnits.DEG):
    '''### set the smartdrive rotation to a new value

    #### Arguments:
        value : The new value to use for rotation.
        units (optional) : The rotation units type for value, the default is DEGREES

    #### Returns:
        None

    #### Examples:
        # set the value of rotation to 180 degrees\\
        smart1.set_rotation(180)
    '''
    pass

`set_turn_constant(value)`

Set the turning constant for the smartdrive

The smartdrive uses a simple P controller when doing turns.\ This constant, generally known as kp, is the gain used in the equation that\ turns angular error into motor velocity.

Arguments:

value : The new turn constant in the range 0.1 - 4.0, the default is 1.0

Returns:

None

Source code in vex.py

def set_turn_constant(self, value):
    '''### Set the turning constant for the smartdrive

    The smartdrive uses a simple P controller when doing turns.\\
    This constant, generally known as kp, is the gain used in the equation that\\
    turns angular error into motor velocity.

    #### Arguments:
        value : The new turn constant in the range 0.1 - 4.0, the default is 1.0

    #### Returns:
        None
    '''
    pass

`set_turn_direction_reverse(value)`

Set the expected turn direction for positive heading change

Arguments:

value : True or False

Returns:

None

Source code in vex.py

def set_turn_direction_reverse(self, value):
    '''### Set the expected turn direction for positive heading change

    #### Arguments:
        value : True or False

    #### Returns:
        None
    '''
    pass

`set_turn_threshold(value)`

Set the turning threshold for the smartdrive

This is the threshold value used to determine that turns are complete.\ If this is too large then turns will not be accurate, if too small then turns ma\ not complete.

Arguments:

value : The new turn threshold in degrees, the default for a smartdrive is 1 degree

Returns:

None

Source code in vex.py

def set_turn_threshold(self, value):
    '''### Set the turning threshold for the smartdrive

    This is the threshold value used to determine that turns are complete.\\
    If this is too large then turns will not be accurate, if too small then turns ma\\
    not complete.

    #### Arguments:
        value : The new turn threshold in degrees, the default for a smartdrive is 1 degree

    #### Returns:
        None
    '''
    pass

`turn_for(direction, angle, units=RotationUnits.DEG, velocity=None, units_v=VelocityUnits.RPM, wait=True)`

turn the smartdrive using the provided arguments

The turn_for command is similar to the motor spin_for command,\ however, the smartdrive is commanded to turn a specified angle.

Arguments:

direction : The direction to turn, LEFT or RIGHT
angle : The angle to turn
units (optional) : The units for the provided angle, the default is DEGREES
velocity (optional) : drive using this velocity, the default velocity set by set_drive_velocity will be used if not provided.
units_v (optional) : The units of the provided velocity, default is RPM
wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

Returns:

None or if wait is True then completion success or failure

Examples:

# turn right 90 degrees\
smart1.turn_for(RIGHT, 90, DEGREES)

# turn left 180 degrees with motors at 50 rpm\
smart1.turn_for(LEFT, 180, DEGREES, 50, RPM)

Source code in vex.py

def turn_for(self, direction, angle, units=RotationUnits.DEG,
             velocity=None, units_v:VelocityPercentUnits=VelocityUnits.RPM, wait=True):
    '''### turn the smartdrive using the provided arguments

    The turn_for command is similar to the motor spin_for command,\\
    however, the smartdrive is commanded to turn a specified angle.

    #### Arguments:
        direction : The direction to turn, LEFT or RIGHT
        angle : The angle to turn
        units (optional) : The units for the provided angle, the default is DEGREES
        velocity (optional) : drive using this velocity, the default velocity set by set_drive_velocity will be used if not provided.
        units_v (optional) : The units of the provided velocity, default is RPM
        wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

    #### Returns:
        None or if wait is True then completion success or failure

    #### Examples:
        # turn right 90 degrees\\
        smart1.turn_for(RIGHT, 90, DEGREES)\n
        # turn left 180 degrees with motors at 50 rpm\\
        smart1.turn_for(LEFT, 180, DEGREES, 50, RPM)
    '''
    return True

`turn_to_heading(angle, units=RotationUnits.DEG, velocity=None, units_v=VelocityUnits.RPM, wait=True)`

turn the smartdrive to an absolute position using the provided arguments

The turn_to_heading command is similar to the motor spin_to_position command,\ however, the smartdrive is commanded to turn to a specified angle.\ This function uses the value of heading() when turning the smartdrive\ This function supports keyword arguments.

Arguments:

angle : The angle to turn to
units (optional) : The units for the provided angle, the default is DEGREES
velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
units_v (optional) : The units of the provided velocity, default is RPM
wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

Returns:

None

Examples:

# turn to heading 180 degrees\
smart1.turn_to_heading(180)

# turn to heading 180 degrees at 25 rpm\
smart1.turn_to_heading(180, DEGREES, 25, RPM)

# turn to heading 180 degrees and do not wait for completion\
smart1.turn_to_heading(180, DEGREES, False)

# turn to heading 180 degrees and do not wait for completion\
smart1.turn_to_heading(180, DEGREES, wait=False)

Source code in vex.py

def turn_to_heading(self, angle, units=RotationUnits.DEG,
                    velocity=None, units_v:VelocityPercentUnits=VelocityUnits.RPM, wait=True):
    '''### turn the smartdrive to an absolute position using the provided arguments

    The turn_to_heading command is similar to the motor spin_to_position command,\\
    however, the smartdrive is commanded to turn to a specified angle.\\
    This function uses the value of heading() when turning the smartdrive\\
    This function supports keyword arguments.

    #### Arguments:
        angle : The angle to turn to
        units (optional) : The units for the provided angle, the default is DEGREES
        velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
        units_v (optional) : The units of the provided velocity, default is RPM
        wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

    #### Returns:
        None

    #### Examples:
        # turn to heading 180 degrees\\
        smart1.turn_to_heading(180)\n
        # turn to heading 180 degrees at 25 rpm\\
        smart1.turn_to_heading(180, DEGREES, 25, RPM)\n
        # turn to heading 180 degrees and do not wait for completion\\
        smart1.turn_to_heading(180, DEGREES, False)\n
        # turn to heading 180 degrees and do not wait for completion\\
        smart1.turn_to_heading(180, DEGREES, wait=False)
    '''
    return True

`turn_to_rotation(angle, units=RotationUnits.DEG, velocity=None, units_v=VelocityUnits.RPM, wait=True)`

turn the smartdrive to an absolute position using the provided arguments

The turn_to_rotation command is similar to the motor spin_to_position command,\ however, the smartdrive is commanded to turn to a specified angle.\ This function uses the value of rotation() when turning the smartdrive\ This function supports keyword arguments.

Arguments:

angle : The angle to turn to
units (optional) : The units for the provided angle, the default is DEGREES
velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
units_v (optional) : The units of the provided velocity, default is RPM
wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

Returns:

None

Examples:

# turn to rotation 180 degrees\
smart1.turn_to_rotation(180)

# turn to rotation 400 degrees at 25 rpm\
smart1.turn_to_rotation(400, DEGREES, 25, RPM)

# turn to rotation 180 degrees and do not wait for completion\
smart1.turn_to_rotation(180, DEGREES, False)

# turn to rotation 180 degrees and do not wait for completion\
smart1.turn_to_rotation(180, DEGREES, wait=False)

Source code in vex.py

def turn_to_rotation(self, angle, units=RotationUnits.DEG,
                     velocity=None, units_v:VelocityPercentUnits=VelocityUnits.RPM, wait=True):
    '''### turn the smartdrive to an absolute position using the provided arguments

    The turn_to_rotation command is similar to the motor spin_to_position command,\\
    however, the smartdrive is commanded to turn to a specified angle.\\
    This function uses the value of rotation() when turning the smartdrive\\
    This function supports keyword arguments.

    #### Arguments:
        angle : The angle to turn to
        units (optional) : The units for the provided angle, the default is DEGREES
        velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
        units_v (optional) : The units of the provided velocity, default is RPM
        wait (optional) : This indicates if the function should wait for the command to complete or return immediately, default is True.

    #### Returns:
        None

    #### Examples:
        # turn to rotation 180 degrees\\
        smart1.turn_to_rotation(180)\n
        # turn to rotation 400 degrees at 25 rpm\\
        smart1.turn_to_rotation(400, DEGREES, 25, RPM)\n
        # turn to rotation 180 degrees and do not wait for completion\\
        smart1.turn_to_rotation(180, DEGREES, False)\n
        # turn to rotation 180 degrees and do not wait for completion\\
        smart1.turn_to_rotation(180, DEGREES, wait=False)
    '''
    return True

Motor29

`vex.Motor29`

Motor29 class - create a new pwm motor output

The Motor29 class will create raw RC style pwm waveform.\ This is primarily for use with the VEX MC29 motor controller\ To minimize current draw, new values sent to the motor will have slew rate control applied

Arguments:

port : The 3wire port to use for the motor controller
reverse_flag (optional) : set reverse flag for this motor, spin commands will cause opposite rotation if set True.  default is False.

Returns:

An instance of the Motor29 class

Examples:

motor1 = Motor29(brain.three_wire_port.a)

Source code in vex.py

class Motor29:
    '''### Motor29 class - create a new pwm motor output

    The Motor29 class will create raw RC style pwm waveform.\\
    This is primarily for use with the VEX MC29 motor controller\\
    To minimize current draw, new values sent to the motor will have slew rate control applied

    #### Arguments:
        port : The 3wire port to use for the motor controller
        reverse_flag (optional) : set reverse flag for this motor, spin commands will cause opposite rotation if set True.  default is False.

    #### Returns:
        An instance of the Motor29 class

    #### Examples:
        motor1 = Motor29(brain.three_wire_port.a)
    '''
    def __init__(self, port, reverse_flag=False):
        self._index = port
        self._velocity = 50

    def value(self):
        '''### Read the current raw motor controller pwm value.

        This is the raw internal pwm value\\
        A motor velocity of 0 will return 127\\
        A maximum positive motor velocity will return 255

        #### Arguments:
            None

        #### Returns:
            A value in the range 0 to 255.

        #### Examples:
            # get motor current pwm value\\
            value = motor1.value()
        '''
        return 0

    def type(self):
        return 0

    def set_velocity(self, value, units:VelocityPercentUnits=VelocityUnits.RPM):
        '''### Set default velocity for the motor
        This will be the velocity used for subsequent calls to spin of a velocity is not provided
        to that function.

        #### Arguments:
            value : The new velocity
            units : The units for the supplied velocity, the default is RPM

        #### Returns:
            None
        '''
        self._velocity = value

    def set_reversed(self, value):
        '''### Set the reversed flag for the motor

        #### Arguments:
            value : 1, 0, True or False

        #### Returns:
            None

        #### Examples:
            # set motor reversed flag True\\
            motor1.set_reversed(True)
        '''
        pass

    def spin(self, direction: DirectionType.DirectionType, velocity=None, units=None):
        '''### Spin the motor using the provided arguments

        The motor is assumed to have a maximum velocity of 100 rpm.

        #### Arguments:
            direction : The direction to spin the motor, FORWARD or REVERSE
            velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
            units (optional) : The units of the provided velocity, default is RPM

        #### Returns:
            None

        #### Examples:
            # spin motor forward at velocity set with set_velocity\\
            motor1.spin(FORWARD)\n
            # spin motor forward at 50 rpm\\
            motor1.spin(FORWARD, 50)\n
            # spin with negative velocity, ie. backwards\\
            motor1.spin(FORWARD, -20)\n
            # spin motor forwards with 100% velocity\\
            motor1.spin(FORWARD, 100, PERCENT)\n
            # spin motor forwards at 50 rpm\\
            motor1.spin(FORWARD, 50, RPM)\n
            # spin motor forwards at 360 dps\\
            motor1.spin(FORWARD, 360.0, VelocityUnits.DPS)
        '''
        pass

    def stop(self):
        '''### Stop the  motor, set to 0 velocity

        #### Arguments:
            None

        #### Returns:
            None
        '''
        pass

`set_reversed(value)`

Set the reversed flag for the motor

Arguments:

value : 1, 0, True or False

Returns:

None

Examples:

# set motor reversed flag True\
motor1.set_reversed(True)

Source code in vex.py

def set_reversed(self, value):
    '''### Set the reversed flag for the motor

    #### Arguments:
        value : 1, 0, True or False

    #### Returns:
        None

    #### Examples:
        # set motor reversed flag True\\
        motor1.set_reversed(True)
    '''
    pass

`set_velocity(value, units=VelocityUnits.RPM)`

Set default velocity for the motor

This will be the velocity used for subsequent calls to spin of a velocity is not provided to that function.

Arguments:

value : The new velocity
units : The units for the supplied velocity, the default is RPM

Returns:

None

Source code in vex.py

def set_velocity(self, value, units:VelocityPercentUnits=VelocityUnits.RPM):
    '''### Set default velocity for the motor
    This will be the velocity used for subsequent calls to spin of a velocity is not provided
    to that function.

    #### Arguments:
        value : The new velocity
        units : The units for the supplied velocity, the default is RPM

    #### Returns:
        None
    '''
    self._velocity = value

`spin(direction, velocity=None, units=None)`

Spin the motor using the provided arguments

The motor is assumed to have a maximum velocity of 100 rpm.

Arguments:

direction : The direction to spin the motor, FORWARD or REVERSE
velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
units (optional) : The units of the provided velocity, default is RPM

Returns:

None

Examples:

# spin motor forward at velocity set with set_velocity\
motor1.spin(FORWARD)

# spin motor forward at 50 rpm\
motor1.spin(FORWARD, 50)

# spin with negative velocity, ie. backwards\
motor1.spin(FORWARD, -20)

# spin motor forwards with 100% velocity\
motor1.spin(FORWARD, 100, PERCENT)

# spin motor forwards at 50 rpm\
motor1.spin(FORWARD, 50, RPM)

# spin motor forwards at 360 dps\
motor1.spin(FORWARD, 360.0, VelocityUnits.DPS)

Source code in vex.py

def spin(self, direction: DirectionType.DirectionType, velocity=None, units=None):
    '''### Spin the motor using the provided arguments

    The motor is assumed to have a maximum velocity of 100 rpm.

    #### Arguments:
        direction : The direction to spin the motor, FORWARD or REVERSE
        velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
        units (optional) : The units of the provided velocity, default is RPM

    #### Returns:
        None

    #### Examples:
        # spin motor forward at velocity set with set_velocity\\
        motor1.spin(FORWARD)\n
        # spin motor forward at 50 rpm\\
        motor1.spin(FORWARD, 50)\n
        # spin with negative velocity, ie. backwards\\
        motor1.spin(FORWARD, -20)\n
        # spin motor forwards with 100% velocity\\
        motor1.spin(FORWARD, 100, PERCENT)\n
        # spin motor forwards at 50 rpm\\
        motor1.spin(FORWARD, 50, RPM)\n
        # spin motor forwards at 360 dps\\
        motor1.spin(FORWARD, 360.0, VelocityUnits.DPS)
    '''
    pass

`stop()`

Stop the motor, set to 0 velocity

Arguments:

None

Returns:

None

Source code in vex.py

def stop(self):
    '''### Stop the  motor, set to 0 velocity

    #### Arguments:
        None

    #### Returns:
        None
    '''
    pass

`value()`

Read the current raw motor controller pwm value.

This is the raw internal pwm value\ A motor velocity of 0 will return 127\ A maximum positive motor velocity will return 255

Arguments:

None

Returns:

A value in the range 0 to 255.

Examples:

# get motor current pwm value\
value = motor1.value()

Source code in vex.py

def value(self):
    '''### Read the current raw motor controller pwm value.

    This is the raw internal pwm value\\
    A motor velocity of 0 will return 127\\
    A maximum positive motor velocity will return 255

    #### Arguments:
        None

    #### Returns:
        A value in the range 0 to 255.

    #### Examples:
        # get motor current pwm value\\
        value = motor1.value()
    '''
    return 0

MotorVictor

`vex.MotorVictor`

MotorVictor class - create a new pwm motor output

The MotorVictor class will create raw RC style pwm waveform.\ This is primarily for use with the VEX Victor motor controller\

Arguments:

port : The 3wire port to use for the motor controller
reverse_flag (optional) : set reverse flag for this motor, spin commands will cause opposite rotation if set True.  default is False.

Returns:

An instance of the MotorVictor class

Examples:

motor1 = MotorVictor(brain.three_wire_port.a)

Source code in vex.py

class MotorVictor:
    '''### MotorVictor class - create a new pwm motor output

    The MotorVictor class will create raw RC style pwm waveform.\\
    This is primarily for use with the VEX Victor motor controller\\

    #### Arguments:
        port : The 3wire port to use for the motor controller
        reverse_flag (optional) : set reverse flag for this motor, spin commands will cause opposite rotation if set True.  default is False.

    #### Returns:
        An instance of the MotorVictor class

    #### Examples:
        motor1 = MotorVictor(brain.three_wire_port.a)
    '''
    def __init__(self, port, reverse_flag=False):
        self._index = port
        self._velocity = 50

    def value(self):
        '''### Read the current raw motor controller pwm value.

        This is the raw internal pwm value\\
        A motor velocity of 0 will return 127\\
        A maximum positive motor velocity will return 255

        #### Arguments:
            None

        #### Returns:
            A value in the range 0 to 255.

        #### Examples:
            # get motor current pwm value\\
            value = motor1.value()
        '''
        return 0

    def type(self):
        return 0

    def set_velocity(self, value, units:VelocityPercentUnits=VelocityUnits.RPM):
        '''### Set default velocity for the motor
        This will be the velocity used for subsequent calls to spin of a velocity is not provided
        to that function.

        #### Arguments:
            value : The new velocity
            units : The units for the supplied velocity, the default is RPM

        #### Returns:
            None
        '''
        self._velocity = value

    def set_reversed(self, value):
        '''### Set the reversed flag for the motor

        #### Arguments:
            value : 1, 0, True or False

        #### Returns:
            None

        #### Examples:
            # set motor reversed flag True\\
            motor1.set_reversed(True)
        '''
        pass

    def spin(self, direction, velocity=None, units=None):
        '''### Spin the motor using the provided arguments

        The motor is assumed to have a maximum velocity of 100 rpm.

        #### Arguments:
            direction : The direction to spin the motor, FORWARD or REVERSE
            velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
            units (optional) : The units of the provided velocity, default is RPM

        #### Returns:
            None

        #### Examples:
            # spin motor forward at velocity set with set_velocity\\
            motor1.spin(FORWARD)\n
            # spin motor forward at 50 rpm\\
            motor1.spin(FORWARD, 50)\n
            # spin with negative velocity, ie. backwards\\
            motor1.spin(FORWARD, -20)\n
            # spin motor forwards with 100% velocity\\
            motor1.spin(FORWARD, 100, PERCENT)\n
            # spin motor forwards at 50 rpm\\
            motor1.spin(FORWARD, 50, RPM)\n
            # spin motor forwards at 360 dps\\
            motor1.spin(FORWARD, 360.0, VelocityUnits.DPS)
        '''
        pass

    def stop(self):
        '''### Stop the  motor, set to 0 velocity

        #### Arguments:
            None

        #### Returns:
            None
        '''
        pass

`set_reversed(value)`

Set the reversed flag for the motor

Arguments:

value : 1, 0, True or False

Returns:

None

Examples:

# set motor reversed flag True\
motor1.set_reversed(True)

Source code in vex.py

def set_reversed(self, value):
    '''### Set the reversed flag for the motor

    #### Arguments:
        value : 1, 0, True or False

    #### Returns:
        None

    #### Examples:
        # set motor reversed flag True\\
        motor1.set_reversed(True)
    '''
    pass

`set_velocity(value, units=VelocityUnits.RPM)`

Set default velocity for the motor

This will be the velocity used for subsequent calls to spin of a velocity is not provided to that function.

Arguments:

value : The new velocity
units : The units for the supplied velocity, the default is RPM

Returns:

None

Source code in vex.py

def set_velocity(self, value, units:VelocityPercentUnits=VelocityUnits.RPM):
    '''### Set default velocity for the motor
    This will be the velocity used for subsequent calls to spin of a velocity is not provided
    to that function.

    #### Arguments:
        value : The new velocity
        units : The units for the supplied velocity, the default is RPM

    #### Returns:
        None
    '''
    self._velocity = value

`spin(direction, velocity=None, units=None)`

Spin the motor using the provided arguments

The motor is assumed to have a maximum velocity of 100 rpm.

Arguments:

direction : The direction to spin the motor, FORWARD or REVERSE
velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
units (optional) : The units of the provided velocity, default is RPM

Returns:

None

Examples:

# spin motor forward at velocity set with set_velocity\
motor1.spin(FORWARD)

# spin motor forward at 50 rpm\
motor1.spin(FORWARD, 50)

# spin with negative velocity, ie. backwards\
motor1.spin(FORWARD, -20)

# spin motor forwards with 100% velocity\
motor1.spin(FORWARD, 100, PERCENT)

# spin motor forwards at 50 rpm\
motor1.spin(FORWARD, 50, RPM)

# spin motor forwards at 360 dps\
motor1.spin(FORWARD, 360.0, VelocityUnits.DPS)

Source code in vex.py

def spin(self, direction, velocity=None, units=None):
    '''### Spin the motor using the provided arguments

    The motor is assumed to have a maximum velocity of 100 rpm.

    #### Arguments:
        direction : The direction to spin the motor, FORWARD or REVERSE
        velocity (optional) : spin the motor using this velocity, the default velocity set by set_velocity will be used if not provided.
        units (optional) : The units of the provided velocity, default is RPM

    #### Returns:
        None

    #### Examples:
        # spin motor forward at velocity set with set_velocity\\
        motor1.spin(FORWARD)\n
        # spin motor forward at 50 rpm\\
        motor1.spin(FORWARD, 50)\n
        # spin with negative velocity, ie. backwards\\
        motor1.spin(FORWARD, -20)\n
        # spin motor forwards with 100% velocity\\
        motor1.spin(FORWARD, 100, PERCENT)\n
        # spin motor forwards at 50 rpm\\
        motor1.spin(FORWARD, 50, RPM)\n
        # spin motor forwards at 360 dps\\
        motor1.spin(FORWARD, 360.0, VelocityUnits.DPS)
    '''
    pass

`stop()`

Stop the motor, set to 0 velocity

Arguments:

None

Returns:

None

Source code in vex.py

def stop(self):
    '''### Stop the  motor, set to 0 velocity

    #### Arguments:
        None

    #### Returns:
        None
    '''
    pass

`value()`

Read the current raw motor controller pwm value.

This is the raw internal pwm value\ A motor velocity of 0 will return 127\ A maximum positive motor velocity will return 255

Arguments:

None

Returns:

A value in the range 0 to 255.

Examples:

# get motor current pwm value\
value = motor1.value()

Source code in vex.py

def value(self):
    '''### Read the current raw motor controller pwm value.

    This is the raw internal pwm value\\
    A motor velocity of 0 will return 127\\
    A maximum positive motor velocity will return 255

    #### Arguments:
        None

    #### Returns:
        A value in the range 0 to 255.

    #### Examples:
        # get motor current pwm value\\
        value = motor1.value()
    '''
    return 0

In this documentation

Table of Contents

Motors

Motor

vex.Motor

Motor class - use this to create an instance of a V5 smart motor

Arguments:

Returns:

Examples:

command(*args)

Returns the last velocity sent to the motor

Arguments:

Returns:

current(*args)

Returns the current the motor is using

Arguments:

Returns:

direction()

Returns the current direction the motor is spinning in

Arguments:

Returns:

efficiency(*args)

Returns the efficiency of the motor

Arguments:

Returns:

get_timeout()

Returns the current value of motor timeout

Arguments:

Returns:

installed()

Check for device connection

Arguments:

Returns:

is_done()

Returns the current status of the spin_to_position or spin_for command

Arguments:

Returns:

is_spinning()

Returns the current status of the spin_to_position or spin_for command

Arguments:

Returns:

position(*args)

Returns the position of the motor

Arguments:

Returns:

power(*args)

Returns the power the motor is providing

Arguments:

Returns:

reset_position()

Reset the motor position to 0

Arguments:

Returns:

set_max_torque(value, units)

Set the maximum torque the motor will use

Arguments:

Returns:

Examples:

set_position(value, units=RotationUnits.DEG)

Set the current position of the motor

Arguments:

Returns:

set_reversed(value)

Set the reverse flag for the motor

Arguments:

Returns:

set_stopping(value)

Set the stopping mode of the motor

Arguments:

Returns:

set_timeout(value, units=TimeUnits.MSEC)

Set the timeout value used by the motor

Arguments:

Returns:

set_velocity(value, units=VelocityUnits.RPM)

Set default velocity for the motor

Arguments:

Returns:

spin(direction, *args, **kwargs)

Spin the motor using the provided arguments

`vex.Motor`

`command(*args)`

`current(*args)`

`direction()`

`efficiency(*args)`

`get_timeout()`

`installed()`

`is_done()`

`is_spinning()`

`position(*args)`

`power(*args)`

`reset_position()`

`set_max_torque(value, units)`

`set_position(value, units=RotationUnits.DEG)`

`set_reversed(value)`

`set_stopping(value)`

`set_timeout(value, units=TimeUnits.MSEC)`

`set_velocity(value, units=VelocityUnits.RPM)`

`spin(direction, *args, **kwargs)`

`spin_for(direction, rot_or_time, *args, **kwargs)`

`spin_to_position(rotation, *args, **kwargs)`

`stop(mode=None)`

`temperature(*args)`

`timestamp()`

`torque(*args)`

`velocity(*args)`

`vex.MotorGroup`

`count()`

`current(units=CurrentUnits.AMP)`

`direction()`

`efficiency(units=PercentUnits.PERCENT)`

`is_done()`

`is_spinning()`

`position(units=RotationUnits.DEG)`

`power(units=PowerUnits.WATT)`