Robot-Specific Python#

Introduction #

The Hero Bot, Flex, includes a Claw Motor, an Arm Motor, an AI Vision Sensor, a Distance Sensor, and a Game Positioning System (GPS) Sensor.

All standard VEXcode VR methods are available for use in the V5 26-27 Override Playground.

Below is a list of all available Robot-specific methods:

Drivetrain – Move and turn the robot.

Actions
- drive — Moves the robot forward or reverse forever.
- drive_for — Moves the robot forward or reverse for a specific distance.
- turn — Turns the robot left or right forever.
- turn_for — Turns the robot left or right for a specific number of degrees.
- turn_to_heading — Turns the robot to face a specific heading from -359 to 359 degrees.
- turn_to_rotation — Turns the robot to a specific rotation.
- stop — Stops the robot’s movement.
Mutators
- set_heading — Changes the robot’s current heading to a new heading.
- set_rotation — Changes the robot’s current rotation to a new rotation.
- set_timeout — Sets how much time the robot will try to finish a movement.
- set_drive_velocity — Tells the robot how fast to drive.
- set_turn_velocity — Tells the robot how fast to turn.
Getters
- heading — Returns the robot’s current heading from 0 to 359.99 degrees.
- rotation — Returns the robot’s current rotation.
- is_done — Returns whether the robot is finished moving, as a Boolean value.
- is_moving — Returns whether the robot is moving, as a Boolean value.
- velocity — Returns how fast the robot is driving.

Motion – Move and track the robot’s motors.

Actions
- spin — Spins a motor forward or reverse forever.
- spin_for — Spins a motor for a specific distance.
- spin_to_position — Spins a motor to a specific position.
- stop — Stops a motor from spinning.
Mutators
- set_position — Changes the motor’s current position to a new value.
- set_velocity — Tells a motor how fast to spin.
- set_timeout — Sets how much time a motor will try to finish a movement.
Getters
- is_done — Returns whether the motor is finished moving, as a Boolean value.
- is_spinning — Returns whether the motor is spinning, as a Boolean value.
- position — Returns the motor’s current position.
- velocity — Returns how fast the motor is spinning.

AI Vision – Capture and analyze objects using the AI Vision Sensor.

Getters
- take_snapshot – Returns a tuple of detected objects for a specific signature.
Properties
- .width – Width of the detected object in pixels.
- .height – Height of the detected object in pixels.
- .centerX – X position of the object’s center in pixels.
- .centerY – Y position of the object’s center in pixels.
- .originX – X position of the object’s top-left corner in pixels.
- .originY – Y position of the object’s top-left corner in pixels.
- .id – Classification ID of the detected object.

Console – Print to the Console and monitor values.

Print
- brain.screen.print — Displays text, numbers, or variable values in the Console.
- brain.screen.next_row — Moves the Console cursor to the start of the next row.
- brain.screen.clear_screen — Clears all rows from the Console.
Monitor
- monitor_variable — Adds one or more predefined variables to the Monitor tab.
- monitor_sensor — Adds one or more sensor values to the Monitor tab.

Sensing – Utilize the robot’s various sensors.

Distance
- found_object – Returns whether the Distance Sensor detects an object within range.
- object_distance – Returns the distance between the Distance Sensor and the nearest detected object.
GPS
- x_position – Returns the current x-coordinate of the GPS Sensor on the field.
- y_position – Returns the current y-coordinate of the GPS Sensor on the field.
- heading – Returns the heading the robot is currently facing based on the GPS Sensor.

The examples on this page use Starting Location C from the Playground’s Pre-Match checklist.

Drivetrain #

The drivetrain controls how the VR Robot drives and turns. The drivetrain can move forward or reverse, turn left or right, turn to headings, and track its rotation.

Actions #

drive #

drive moves the robot forward or reverse forever. The robot will continue to move until it is given another action, like turning or stopping.

Usage:
drivetrain.drive(direction)

Parameters	Description
`direction`	The direction the robot moves: `FORWARD` or `REVERSE`.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive(FORWARD)
    wait(0.5, SECONDS)
    drivetrain.stop()
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

drive_for #

drive_for moves the robot forward or reverse for a specific distance. The project will wait until the robot is done moving before the next line of code runs.

Usage:
drivetrain.drive_for(direction, distance, units, wait)

Parameters	Description
`direction`	The direction the robot moves: `FORWARD` or `REVERSE`.
`distance`	The distance the robot drives. This can be an `integer` or decimal (`float`).
`units`	Optional. The distance unit: `INCHES` (default) or `MM` (millimeters).
`wait`	Optional. `wait=True` (default) makes the project wait until the robot is done moving before the next line of code runs. `wait=False` makes the next line of code run right away.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

turn #

turn turns the robot left or right forever. The robot will continue to turn until it is given another action, like driving or stopping.

Usage:
drivetrain.turn(direction)

Parameters	Description
`direction`	The direction the robot turns: `LEFT` or `RIGHT`.

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn(LEFT)
    wait(0.78, SECONDS)
    drivetrain.stop()
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

turn_for turns the robot left or right for a specific number of degrees. The turn is relative to the current position of the robot. The project will wait until the robot is done turning before the next line of code runs.

Usage:
drivetrain.turn_for(direction, angle, units, wait)

Parameters	Description
`direction`	The direction the robot turns: `LEFT` or `RIGHT`.
`angle`	The number of degrees the robot turns. This can be an `integer` or decimal (`float`).
`units`	Optional. The angle unit: `DEGREES` (default).
`wait`	Optional. `wait=True` (default) makes the project wait until the robot is done turning before the next line of code runs. `wait=False` makes the next line of code run right away.

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

turn_to_heading #

A heading is the direction the robot is facing, measured in degrees. turn_to_heading turns the robot to face a specific heading from -359 to 359 degrees. The robot will turn the shortest direction to reach the target heading.

The starting heading is 0 degrees.

Usage:
drivetrain.turn_to_heading(heading, units, wait)

Parameters	Description
`heading`	The heading the robot should face, from -359 to 359 degrees.
`units`	Optional. The angle unit: `DEGREES` (default).
`wait`	Optional. `wait=True` (default) makes the project wait until the robot is done turning before the next line of code runs. `wait=False` makes the next line of code run right away.

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_to_heading(-110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

turn_to_rotation #

turn_to_rotation turns the robot to a specific rotation.

Rotation is how much the robot has turned, measured in degrees. At the beginning of a project, the rotation value is set to 0 degrees. Turning right increases the rotation, and turning left decreases the rotation.

For example, if the robot starts at 0 degrees and turns to a rotation of 720 degrees, it will turn right twice. If it then turns to a rotation of 360 degrees, it will turn left once, because 360 is less than 720.

Usage:
drivetrain.turn_to_rotation(rotation, units, wait)

Parameters	Description
`rotation`	The rotation value, in degrees, that the robot will turn to. This can be an `integer` or decimal (`float`).
`units`	Optional. The angle unit: `DEGREES` (default).
`wait`	Optional. `wait=True` (default) makes the project wait until the robot is done turning before the next line of code runs. `wait=False` makes the next line of code run right away.

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_to_rotation(-110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

stop #

stop stops the robot’s movement.

Usage:
drivetrain.stop()

Parameters	Description
	This method has no parameters.

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn(LEFT)
    wait(0.78, SECONDS)
    drivetrain.stop()
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Mutators #

set_heading #

A heading is the direction the robot is facing, measured in degrees. set_heading changes the robot’s current heading to a new heading value.

For example, if the robot has turned to face right, setting the heading to 0 degrees makes that right-facing position the new 0 degrees. Then the robot can turn to other positions based on that new heading.

Usage:
drivetrain.set_heading(heading, units)

Parameters	Description
`heading`	The heading value, in degrees, to set for the robot.
`units`	Optional. The angle unit: `DEGREES` (default).

def main():
    # Make facing the Neutral Goal the new heading
    drivetrain.set_heading(110, DEGREES)
    drivetrain.turn_to_heading(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_rotation #

Rotation is how much the robot has turned, measured in degrees. set_rotation changes the robot’s current rotation to a new value.

Usage:
drivetrain.set_rotation(rotation, units)

Parameters	Description
`rotation`	The rotation value, in degrees, to set for the robot. This can be an `integer` or decimal (`float`).
`units`	Optional. The angle unit: `DEGREES` (default).

def main():
    # Make facing the Neutral Goal the new rotation
    drivetrain.set_rotation(110, DEGREES)
    drivetrain.turn_to_rotation(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_timeout #

set_timeout sets how many seconds the robot will try to finish a movement. If the robot cannot finish in that time it will stop trying and move on to the next line of code. This keeps the robot from getting stuck on a movement.

Usage:
drivetrain.set_timeout(time, units)

Parameters	Description
`time`	The number of seconds the robot can try to finish a movement. This can be a positive `integer` or decimal (`float`).
`units`	Optional. The time unit: `SECONDS` (default) or `MSEC`.

def main():
    # Turn to face the Neutral Goal
    drivetrain.set_timeout(0.8, SECONDS)
    drivetrain.turn_for(LEFT, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_drive_velocity #

set_drive_velocity tells the robot how fast to drive. A higher percentage makes the robot drive faster and a lower percentage makes the robot drive slower.

Every project begins with the robot driving at 50% velocity by default.

Note: A higher velocity makes the robot drive faster, but it may be less precise. A lower velocity makes the robot drive slower, but it can be more precise.

Usage:
drivetrain.set_drive_velocity(velocity, units)

Parameters	Description
`velocity`	The velocity to drive with from 0% to 100%. This can be an `integer` or decimal (`float`).
`units`	Optional. The velocity unit: `PERCENT` (default).

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.set_drive_velocity(100, PERCENT)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_turn_velocity #

set_turn_velocity tells the robot how fast to turn. A higher percentage makes the robot turn faster and a lower percentage makes the robot turn slower.

Every project begins with the robot turning at 50% velocity by default.

Note: A higher velocity makes the robot turn faster, but it may be less precise. A lower velocity makes the robot turn slower, but it can be more precise.

Usage:
drivetrain.set_turn_velocity(velocity, units)

Parameters	Description
`velocity`	The velocity to turn with from 0% to 100%. This can be an `integer` or decimal (`float`).
`units`	Optional. The velocity unit: `PERCENT` (default).

def main():
    # Turn to face the Neutral Goal faster
    drivetrain.set_turn_velocity(100, PERCENT)
    drivetrain.turn_for(LEFT, 110, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Getters #

heading #

A heading is the direction the robot is facing, measured in degrees. heading returns the robot’s current heading from 0 to 359.99 degrees.

The robot’s starting heading is 0 degrees.

Usage:
drivetrain.heading(units)

Parameters	Description
`units`	Optional. The heading unit: `DEGREES` (default).

def main():
    # Turn to the Goal, then show heading
    drivetrain.turn_for(LEFT, 110, DEGREES)
    brain.screen.print("Heading: ")
    brain.screen.print(drivetrain.heading(DEGREES))

# VR threads — Do not delete
vr_thread(main)

rotation #

Rotation is how much the robot has turned, measured in degrees. At the beginning of a project, the rotation value is set to 0 degrees. rotation returns the robot’s current rotation.

Turning right increases the rotation, and turning left decreases the rotation. For example, making two full turns to the right will return a rotation of 720 degrees.

Usage:
drivetrain.rotation(units)

Parameters	Description
`units`	Optional. The rotation unit: `DEGREES` (default).

def main():
    # Spin to find a Pin, then show rotation
    drivetrain.turn_for(RIGHT, 450, DEGREES)
    brain.screen.print("Rotation: ")
    brain.screen.print(drivetrain.rotation(DEGREES))

# VR threads — Do not delete
vr_thread(main)

is_done #

is_done returns whether the robot is finished moving, as a Boolean value. This can be used to control the timing of other behaviors based on the robot’s movement.

True — The robot is finished moving.
False — The robot is still moving.

This method works together with the following Drivetrain methods that have the wait parameter: drive_for, turn_for, turn_to_heading, and turn_to_rotation.

Usage:
drivetrain.is_done()

Parameters	Description
	This method has no parameters.

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES, wait=False)
    wait(0.5, SECONDS)
    while not drivetrain.is_done():
        wait(5, MSEC)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

is_moving #

is_moving returns whether the robot is moving, as a Boolean value. This can be used to control the timing of other behaviors based on the robot’s movement.

True — The robot is moving.
False — The robot is not moving.

Usage:
drivetrain.is_moving()

Parameters	Description
	This method has no parameters.

def main():
    # Raise the Arm once stopped near the Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES, wait=False)
    wait (0.5, SEC)
    while drivetrain.is_moving():
        wait(5, MSEC)
    arm_motor.spin_for(FORWARD, 800, DEGREES)

# VR threads — Do not delete
vr_thread(main)

velocity #

velocity returns how fast the robot is driving, as a percentage from -100% to 100%.

Usage:
drivetrain.velocity(units)

Parameters	Description
`units`	Optional. The velocity unit: `PERCENT` (default).

def main():
    # Show speed while driving to the Goal
    drivetrain.drive_for(FORWARD, 150, MM)
    brain.screen.print("Velocity: ")
    brain.screen.print(drivetrain.velocity(PERCENT))

# VR threads — Do not delete
vr_thread(main)

Motion #

Flex uses the Arm Motor to lift and lower the arm, and the Claw Motor to open and close the claw.

Each motor has its own direction behavior. The direction descriptions explain how each direction moves that motor on Flex.

Actions #

spin #

spin spins a motor in one of two directions forever. The motor will continue to spin until it is given another action, like spinning in a different direction or stopping.

Usage:
One of two available motor objects can be used with this method, as shown below:

motor	Command
`arm_motor`	`arm_motor.spin(direction)` — Arm Motor
`claw_motor`	`claw_motor.spin(direction)` — Claw Motor

Parameters

Description

direction

The direction the motor spins:

FORWARD — Moves the Arm Motor up or closes the Claw Motor.
REVERSE — Moves the Arm Motor down or opens the Claw Motor.

def main():
    # Raise the Arm before driving toward a Pin
    arm_motor.spin(FORWARD)
    wait(1, SECONDS)
    arm_motor.stop()

# VR threads — Do not delete
vr_thread(main)

spin_for #

spin_for spins a motor for a specific distance. The spin is relative to the current position of the motor. The project will wait until the motor is done spinning before the next line of code runs.

Usage:
One of two available motor objects can be used with this method, as shown below:

motor	Command
`arm_motor`	`arm_motor.spin_for(direction, distance, units, wait)` — Arm Motor
`claw_motor`	`claw_motor.spin_for(direction, distance, units, wait)` — Claw Motor

Parameters	Description
`direction`	The direction the motor spins: `FORWARD` — Moves the Arm Motor up or closes the Claw Motor. `REVERSE` — Moves the Arm Motor down or opens the Claw Motor.
`distance`	The distance the motor spins. `DEGREES` use integers. `TURNS` can use integers or decimals.
`units`	Optional. The distance unit: `DEGREES` (default) or `TURNS`.
`wait`	Optional. `wait=True` (default) — Makes the project wait until the motor is done spinning before the next line of code runs. `wait=False` — Makes the next line of code run right away.

def main():
    # Raise the Arm to carry the Pin to the Goal
    arm_motor.spin_for(FORWARD, 800, DEGREES)

# VR threads — Do not delete
vr_thread(main)

spin_to_position #

spin_to_position spins a motor to a specific position.

A motor’s position is how far it has spun, measured in DEGREES or TURNS. One turn is equal to 360 degrees. At the beginning of a project, the Arm Motor’s position is set to 0 degrees. The Claw Motor is the exception — it starts at 467 degrees (fully closed). The motor position can also be set using the set_position method.

Position values are absolute. This means the direction of the spin depends on the motor’s current position.

For example, if the motor starts at 0 degrees and spins to a position of 720 degrees, it will spin forward two turns. If it then spins to a position of 360 degrees, it will spin reverse one turn, because 360 is less than 720.

Usage:
One of two available motor objects can be used with this method, as shown below:

motor	Command
`arm_motor`	`arm_motor.spin_to_position(angle, units, wait=True)` — Arm Motor
`claw_motor`	`claw_motor.spin_to_position(angle, units, wait=True)` — Claw Motor

Parameters	Description
`angle`	The position value the motor will spin to. `DEGREES` use integers. `TURNS` can use integers or decimals.
`units`	Optional. The position unit: `DEGREES` (default) or `TURNS`.
`wait`	Optional. `wait=True` (default) — Makes the project wait until the motor is done spinning before the next line of code runs. `wait=False` — Makes the next line of code run right away.

Parameters

Description

angle

The position value the motor will spin to. DEGREES use integers. TURNS can use integers or decimals.

units

Optional. The position unit: DEGREES (default) or TURNS.

wait

Optional.

wait=True (default) — Makes the project wait until the motor is done spinning before the next line of code runs.
wait=False — Makes the next line of code run right away.

def main():
    # Raise the Arm, then release the Pin
    arm_motor.spin_to_position(800, DEGREES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

stop #

stop stops a motor from spinning.

Usage:
One of two available motor objects can be used with this method, as shown below:

motor	Command
`arm_motor`	`arm_motor.stop()` — Arm Motor
`claw_motor`	`claw_motor.stop()` — Claw Motor

Parameters	Description
	This method has no parameters.

def main():
    # Raise the Arm partway to hold the Pin
    arm_motor.spin(FORWARD)
    wait(1, SECONDS)
    arm_motor.stop()

# VR threads — Do not delete
vr_thread(main)

Mutators #

set_position #

A motor’s position is how far it has spun, measured in DEGREES or TURNS. One turn is equal to 360 degrees. set_position changes the motor’s current position to a new value.

For example, if a motor has spun to 180 degrees, setting the position to 0 degrees will reset that position from 180 to 0 degrees. Then the motor can spin to positions based on that new value.

Usage:
One of two available motor objects can be used with this method, as shown below:

motor	Command
`arm_motor`	`arm_motor.set_position(position, units)` — Arm Motor
`claw_motor`	`claw_motor.set_position(position, units)` — Claw Motor

Parameters	Description
`position`	The position value to set for the motor. `DEGREES` use integers. `TURNS` can use integers or decimals.
`units`	Optional. The position unit: `DEGREES` (default) or `TURNS`.

def main():
    # Reset encoder, raise Arm, place Pin
    arm_motor.set_position(0, DEGREES)
    arm_motor.spin_to_position(800, DEGREES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_velocity #

set_velocity tells a motor how fast to spin. A higher percentage makes the motor spin faster and a lower percentage makes the motor spin slower.

Every project begins with each motor spinning at 50% velocity by default.

Note: A higher velocity makes the motor spin faster, but it may be less precise. A lower velocity makes the motor spin slower, but it can be more precise.

Usage:
One of two available motor objects can be used with this method, as shown below:

motor	Command
`arm_motor`	`arm_motor.set_velocity(velocity, units)` — Arm Motor
`claw_motor`	`claw_motor.set_velocity(velocity, units)` — Claw Motor

Parameters	Description
`velocity`	The velocity to spin with from 0% to 100%. This can be an `integer` or decimal (`float`).
`units`	The velocity unit: `PERCENT`.

def main():
    # Raise the Arm fast to release the Pin
    arm_motor.set_velocity(100, PERCENT)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_timeout #

set_timeout sets how much time a motor will try to finish a movement. If the motor cannot finish in that time, it will stop trying and move on to the next line of code. This keeps the motor from getting stuck on a movement.

Usage:
One of two available motor objects can be used with this method, as shown below:

motor	Command
`arm_motor`	`arm_motor.set_timeout(value, units)` — Arm Motor
`claw_motor`	`claw_motor.set_timeout(value, units)` — Claw Motor

Parameters	Description
`value`	The amount of time the motor can try to finish a movement. This can be a positive `integer` or decimal (`float`).
`units`	The time unit: `SECONDS` or `MSEC` (milliseconds).

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    arm_motor.set_timeout(1, SECONDS)
    arm_motor.spin_for(FORWARD, 1800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Getters #

is_done #

is_done returns whether the motor is finished moving, as a Boolean value. This can be used to control the timing of other behaviors based on the motor’s movement.

True — The motor is finished moving.
False — The motor is still moving.

This method works together with the following Motion methods that have the wait parameter: spin_for and spin_to_position.

Usage:
One of two available motor objects can be used with this method, as shown below:

motor	Command
`arm_motor`	`arm_motor.is_done()` — Arm Motor
`claw_motor`	`claw_motor.is_done()` — Claw Motor

Parameters	Description
	This method has no parameters.

def main():
    # Raise the Arm while driving to the Goal
    arm_motor.spin_to_position(800, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while not arm_motor.is_done():
        drivetrain.drive(FORWARD)
        wait(5, MSEC)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

is_spinning #

is_spinning returns whether the motor is spinning, as a Boolean value. This can be used to control the timing of other behaviors based on the motor’s movement.

True — The motor is spinning.
False — The motor is not spinning.

This method works together with the following Motion methods that have the wait parameter: spin_for and spin_to_position.

Usage:
One of two available motor objects can be used with this method, as shown below:

motor	Command
`arm_motor`	`arm_motor.is_spinning()` — Arm Motor
`claw_motor`	`claw_motor.is_spinning()` — Claw Motor

Parameters	Description
	This method has no parameters.

def main():
    # Raise the Arm while driving to the Goal, then release the Pin
    arm_motor.spin_to_position(800, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while arm_motor.is_spinning():
        drivetrain.drive_for(FORWARD, 25, MM)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

position #

A motor’s position is how far it has spun, measured in DEGREES or TURNS. One turn is equal to 360 degrees. position returns the motor’s current position.

At the beginning of a project, the Arm Motor’s position is set to 0 degrees. The Claw Motor is the exception — it starts at 467 degrees (fully closed). If the motor spins one full turn forward, the position increases. If the motor spins the other direction, the position decreases.

Usage:
One of two available motor objects can be used with this method, as shown below:

motor	Command
`arm_motor`	`arm_motor.position(units)` — Arm Motor
`claw_motor`	`claw_motor.position(units)` — Claw Motor

Parameters	Description
`units`	The unit to return the motor position in: `DEGREES` or `TURNS`.

def main():
    # Raise the Arm, then release the Pin
    while arm_motor.position(DEGREES) < 800:
        arm_motor.spin(FORWARD)
        wait(2, MSEC)
    arm_motor.stop()
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

velocity #

velocity returns how fast the motor is spinning.

A positive value means the motor is spinning forward. A negative value means the motor is spinning in reverse.

Usage:
One of two available motor objects can be used with this method, as shown below:

motor	Command
`arm_motor`	`arm_motor.velocity(units)` — Arm Motor
`claw_motor`	`claw_motor.velocity(units)` — Claw Motor

Parameters	Description
`units`	The velocity unit to return: `PERCENT`.

def main():
    # Show Arm Motor velocity while raising
    arm_motor.set_velocity(100, PERCENT)
    arm_motor.spin_to_position(800, DEGREES, wait=False)
    wait(0.2, SECONDS)
    brain.screen.print(arm_motor.velocity(PERCENT))

# VR threads — Do not delete
vr_thread(main)

AI Vision #

Getters #

take_snapshot #

take_snapshot filters data from the AI Vision Sensor frame to a single signature — a saved description of something the sensor can recognize, such as a game element on the field — and returns a tuple.

The tuple stores objects ordered from largest to smallest by width, starting at index 0. Each object’s properties can be accessed using its index. An empty tuple is returned if no matching objects are detected.

Usage:
ai_vision.take_snapshot(signature)

Parameters	Description
`signature`	Filters the dataset to only include data of the given signature. Available signatures are: `AiVision.ALL_AIOBJS` - Detects all game elements. `GameElements.RED_BLUE_PIN` - Detects RedBluePin game elements. `GameElements.BLUE_YELLOW_PIN` - Detects BlueYellowPin game elements. `GameElements.RED_YELLOW_PIN` - Detects RedYellowPin game elements. `GameElements.YELLOW_PIN` - Detects YellowPin game elements. `GameElements.CUP` - Detects Cup game elements.

Parameters

Description

signature

Filters the dataset to only include data of the given signature. Available signatures are:

AiVision.ALL_AIOBJS - Detects all game elements.
GameElements.RED_BLUE_PIN - Detects RedBluePin game elements.
GameElements.BLUE_YELLOW_PIN - Detects BlueYellowPin game elements.
GameElements.RED_YELLOW_PIN - Detects RedYellowPin game elements.
GameElements.YELLOW_PIN - Detects YellowPin game elements.
GameElements.CUP - Detects Cup game elements.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Turn to face the Pin
    drivetrain.set_turn_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].centerX < 140:
                drivetrain.turn(LEFT)
            elif ai_objects[0].centerX > 180:
                drivetrain.turn(RIGHT)
            else:
                drivetrain.stop()
                break

# VR threads — Do not delete
vr_thread(main)

Properties #

There are seven properties that are included with each object stored in a tuple after take_snapshot is used.

All property values except .id describe the detected object’s position and size in the AI Vision Sensor’s view at the moment take_snapshot was used. These values are measured in pixels, based on the sensor’s 320 by 240 pixel resolution.

.width #

.width returns the width of the detected object in pixels, which is an integer between 1 and 320.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Approach the next Cup and Pin
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].width > 140:
                drivetrain.stop()
                break
            else:
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.height #

.height returns the height of the detected object in pixels, which is an integer between 1 and 240.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Approach the next Cup and Pin
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].height > 200:
                drivetrain.stop()
                break
            else:
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.centerX #

.centerX returns the x-coordinate of the detected object’s center in pixels, which is an integer between 0 and 320.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Turn and approach the next Cup and Pin
    drivetrain.set_turn_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].centerX < 140:
                drivetrain.turn_for(LEFT, 5, DEGREES)
            else: 
                drivetrain.drive_for(FORWARD, 25, INCHES)
                break

# VR threads — Do not delete
vr_thread(main)

.centerY #

.centerY returns the y-coordinate of the detected object’s center in pixels, which is an integer between 0 and 240.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Approach the next Cup and Pin
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].centerY > 230:
                drivetrain.stop()
                break
            else:
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.originX #

.originX returns the x-coordinate of the top-left corner of the detected object’s bounding box in pixels, which is an integer between 0 and 320.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Turn and approach the next Cup and Pin
    drivetrain.set_turn_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].originX < 100:
                drivetrain.turn_for(LEFT, 5, DEGREES)
            else:
                drivetrain.drive_for(FORWARD, 25, INCHES)
                break

# VR threads — Do not delete
vr_thread(main)

.originY #

.originY returns the y-coordinate of the top-left corner of the detected object’s bounding box in pixels, which is an integer between 0 and 240.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Approach the next Cup and Pin
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].originY > 140:
                drivetrain.stop()
                break
            else:
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.id #

.id returns the ID of the detected AI Classification as an integer.

AI Classification	id	Signature
RedBluePin	0	`GameElements.RED_BLUE_PIN`
BlueYellowPin	1	`GameElements.BLUE_YELLOW_PIN`
RedYellowPin	2	`GameElements.RED_YELLOW_PIN`
YellowPin	3	`GameElements.YELLOW_PIN`
Cup	4	`GameElements.CUP`

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Display the ID of the next closest object
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            brain.screen.print(ai_objects[0].id)
            break

# VR threads — Do not delete
vr_thread(main)

Console #

The Console displays text, numbers, and variable values while a project is running. Console methods can also move the cursor to a new row, clear the Console, and add variables or sensor values to the Monitor tab.

Print #

brain.screen.print #

brain.screen.print displays text, numbers, or variable values in the Console using the current cursor position.

Use brain.screen.next_row when you want the next printed value to start on a new row.

Usage:
brain.screen.print(value)

Parameters	Description
`value`	The text, number, or variable value to display in the Console.

def main():
    # Display a message in the Console
    brain.screen.print("Hello, robot!")

# VR threads — Do not delete
vr_thread(main)

brain.screen.next_row #

brain.screen.next_row moves the cursor to column 1 on the next row in the Console. The next value printed will appear on that row.

Usage:
brain.screen.next_row()

Parameters	Description
	This method has no parameters.

def main():
    # Print on two rows
    brain.screen.print("Row 1")
    brain.screen.next_row()
    brain.screen.print("Row 2")

# VR threads — Do not delete
vr_thread(main)

brain.screen.clear_screen #

brain.screen.clear_screen clears all rows from the Console and moves the cursor back to Row 1.

Usage:
brain.screen.clear_screen()

Parameters	Description
	This method has no parameters.

def main():
    # Display text, then clear it after two seconds
    brain.screen.print("This will disappear...")
    wait(2, SECONDS)
    brain.screen.clear_screen()

# VR threads — Do not delete
vr_thread(main)

Monitor #

monitor_variable #

monitor_variable adds one or more predefined variables to the Monitor tab in VEXcode. This lets you watch a variable’s value change while a project is running.

Variables must be global for monitor_variable to monitor them successfully. Provide each variable name as a string.

Usage:
monitor_variable(“variable”)
monitor_variable(“variable1”, “variable2”)

Parameters	Description
`variable`	The name of a predefined global variable to monitor, given as a string. To monitor more than one variable, separate each variable name with a comma.

def main():
    # Monitor the number of loops
    global loops
    monitor_variable("loops")

    # Turn in a full circle 3 times
    for loops in range(12):
        drivetrain.turn_for(RIGHT, 90, DEGREES)

# VR threads — Do not delete
vr_thread(main)

monitor_sensor #

monitor_sensor adds one or more sensor values to the Monitor tab in VEXcode. This lets you watch sensor values change while a project is running.

Provide each sensor value as a string.

Usage:
monitor_sensor(“sensor”)
monitor_sensor(“sensor1”, “sensor2”)

Parameters	Description
`sensor`	The sensor value to monitor, given as a string. To monitor more than one sensor value, separate each sensor value with a comma. Supported sensor identifiers include: Brain `brain.timer.time` Drivetrain `drivetrain.is_done` `drivetrain.is_moving` `drivetrain.heading` `drivetrain.rotation` `drivetrain.velocity` Arm Motor `arm_motor.is_done` `arm_motor.is_spinning` `arm_motor.position` `arm_motor.velocity` Claw Motor `claw_motor.is_done` `claw_motor.is_spinning` `claw_motor.position` `claw_motor.velocity` Distance Sensor `distance.is_object_detected` `distance.object_distance_mm` `distance.object_distance_inches` GPS Sensor `gps.position_mm` `gps.position_inches` `gps.heading` AI Vision Sensor `ai_vision.object_count` `ai_vision.height` `ai_vision.width` `ai_vision.centerX` `ai_vision.centerY` `ai_vision.originX` `ai_vision.originY` `ai_vision.id`

Parameters

Description

sensor

The sensor value to monitor, given as a string. To monitor more than one sensor value, separate each sensor value with a comma. Supported sensor identifiers include:

Brain
- brain.timer.time
Drivetrain
- drivetrain.is_done
- drivetrain.is_moving
- drivetrain.heading
- drivetrain.rotation
- drivetrain.velocity
Arm Motor
- arm_motor.is_done
- arm_motor.is_spinning
- arm_motor.position
- arm_motor.velocity
Claw Motor
- claw_motor.is_done
- claw_motor.is_spinning
- claw_motor.position
- claw_motor.velocity
Distance Sensor
- distance.is_object_detected
- distance.object_distance_mm
- distance.object_distance_inches
GPS Sensor
- gps.position_mm
- gps.position_inches
- gps.heading
AI Vision Sensor
- ai_vision.object_count
- ai_vision.height
- ai_vision.width
- ai_vision.centerX
- ai_vision.centerY
- ai_vision.originX
- ai_vision.originY
- ai_vision.id

def main():
    # Monitor the robot's heading
    monitor_sensor("drivetrain.heading")
    drivetrain.turn_for(RIGHT, 450, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Sensing #

Distance #

found_object #

found_object returns whether the Distance Sensor currently detects an object within 2000mm.

True — The Distance Sensor detects an object.
False — The Distance Sensor does not detect an object.

Usage:
distance.found_object()

Parameters	Description
	This method has no parameters.

def main():
    # Turn until something is detected, then release the Pin
    drivetrain.turn(RIGHT)
    while True:
        wait(5, MSEC)
        if distance.found_object():
            drivetrain.stop()
            break
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

object_distance #

object_distance returns the distance between the Distance Sensor and the nearest detected object.

Usage:
distance.object_distance(units)

Parameters	Description
`units`	The distance unit: `MM` or `INCHES`.

def main():
    # Drive until 200 mm from the Goal, then release the Pin
    while distance.object_distance(MM) > 200:
        wait(5, MSEC)
        drivetrain.drive(FORWARD)
    drivetrain.stop()
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

GPS #

x_position #

x_position returns the current x-coordinate of a GPS (Game Positioning System™) Sensor on the field.

Usage:
gps.x_position(units)

Parameters	Description
units	The unit of the offset value: `INCHES` or `MM`

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive(FORWARD)
    while not gps.x_position(MM) > -1370:
        wait(2, MSEC)
    drivetrain.stop()
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

y_position #

y_position returns the current y-coordinate of a GPS (Game Positioning System™) Sensor on the field.

Usage:
gps.y_position(units)

Parameters	Description
units	The unit of the offset value: `INCHES` or `MM`

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive(FORWARD)
    while not gps.y_position(MM) < -450:
        wait(2, MSEC)
    drivetrain.stop()
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

heading #

heading returns the heading that the robot is currently facing based on the GPS (Game Positioning System™) Sensor’s readings from 0 to 359 degrees.

Usage:
gps.heading()

Parameters	Description
	This method has no parameters.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    monitor_sensor("gps.heading")
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    # Turn left to face the Neutral Goal
    drivetrain.set_turn_velocity(30, PERCENT)
    drivetrain.turn(LEFT)
    while not gps.heading() < 18:
        wait(2, MSEC)
    drivetrain.stop()


# VR threads — Do not delete
vr_thread(main)