Robot Specific Python#

Introduction #

The V5RC 25-26 Push Back Playground features methods exclusive to the build designed for this Playground, including two motor options, AI Vision Sensor, Optical Sensor, and Game Positioning System (GPS) Sensor.

All standard VEXcode VR methods are available for use in the V5RC 25-26 Push Back Playground.

Below is a list of all available Playground specific methods:

Motion – Move and track the robot’s motors.

Actions
- spin – Spins the selected motor or motor group indefinitely.
- spin_for – Spins a motor or group for a specific distance in degrees or turns.
- spin_to_position – Spins a motor or motor group to a set position.
- stop – Stops a specific motor or motor group from spinning.
Mutators
- set_position – Sets the encoder value of a motor or motor group.
- set_velocity – Sets the speed of a motor or motor group as a percentage.
- set_timeout – Limits how long a motor block waits before giving up if movement is blocked.
Getters
- is_done – Returns a Boolean indicating whether the motor is no longer spinning.
- is_spinning – Returns a Boolean indicating whether the motor is currently spinning.
- position – Returns the motor’s current rotational position in degrees or turns.
- velocity – Returns the motor’s current velocity in % or rpm.

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

Getters
- take_snapshot – Returns a tuple of detected objects based on a given 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 or tag ID of the object.

Sensing - Utilize the robot’s various sensors.

Optical
- is_near_object – Returns whether a detected object is near the Optical Sensor.
- color – Returns the color detected from the Optical Sensor.
- brightness – Returns the brightness percentage detected by the sensor.
- hue – Returns the hue value of the detected color.
- object_detected – Registers a callback function for when the Optical Sensor detects an object.
- object_lost – Registers a callback function for when the Optical Sensor loses an object.
GPS
- x_position – Returns the current x coordinate of a GPS Sensor on the Field.
- y_position –Returns the current y coordinate of a GPS Sensor on the Field.
- heading – Returns the heading that the robot is currently facing based on the GPS Sensor’s readings from 0 to 359 degrees.

Motion #

Actions #

spin #

spin spins a motor or motor group in the specified direction indefinitely.

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

motor	Command
`intake_motor`	`intake_motor.spin(direction)` — The Intake Motor
`conveyor_motor`	`conveyor_motor.spin(direction)` — The Conveyor Motor

Parameters	Description
direction	The direction for the motor to spin: `FORWARD` – Spins the Conveyor up or the Intake in the intake direction. `REVERSE` – Spins the Conveyor down or the Intake in the outtake direction.

Parameters

Description

direction

The direction for the motor to spin:

FORWARD – Spins the Conveyor up or the Intake in the intake direction.
REVERSE – Spins the Conveyor down or the Intake in the outtake direction.

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 150, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)

spin_for #

spin_for spins a motor or motor group for a given amount of degrees or turns.

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

motor	Command
`intake_motor`	`intake_motor.spin_for(direction, distance, units, wait)` — The Intake Motor
`conveyor_motor`	`conveyor_motor.spin_for(direction, distance, units, wait)` — The Conveyor Motor

Parameters	Description
`direction`	The direction for the motor to spin: `FORWARD` – Spins the Conveyor up or the Intake in the intake direction. `REVERSE` – Spins the Conveyor down or the Intake in the outtake direction.
`distance`	The distance for the motor to spin as an integer.
`units`	The unit that represents the distance to rotate: `DEGREES` `TURNS`
`wait`	Optional. `wait=True` (default) - The robot waits until `spin_for` is complete before executing the next line of code. `wait=False` - The robot starts the action and moves on to the next line of code right away, without waiting for `spin_for` to finish.

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 150, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)

spin_to_position #

spin_to spins a motor or motor group to a given position.

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

motor	Command
`intake_motor`	`intake_motor.spin_to_position(angle, units, wait=True)` — The Intake Motor
`conveyor_motor`	`conveyor_motor.spin_to_position(angle, units, wait=True)` — The Conveyor Motor

Parameters	Description
`angle`	The specific angle or number of turns that the motor will spin to.
`units`	The unit that represents the angle to rotate to: `DEGREES` `TURNS`
`wait`	Optional. `wait=True` (default) - The robot waits until `spin_to_position` is complete before executing the next line of code. `wait=False` - The robot starts the action and moves on to the next line of code right away, without waiting for `spin_to_position` to finish.

Parameters

Description

angle

The specific angle or number of turns that the motor will spin to.

units

The unit that represents the angle to rotate to:

DEGREES
TURNS

wait

Optional.

wait=True (default) - The robot waits until spin_to_position is complete before executing the next line of code.
wait=False - The robot starts the action and moves on to the next line of code right away, without waiting for spin_to_position to finish.

def main():
    # Pick up a second Block
    conveyor_motor.spin_to_position(150, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)

stop #

stop stops a motor or motor group from spinning.

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

motor	Command
`intake_motor`	`intake_motor.stop()` — The Intake Motor
`conveyor_motor`	`conveyor_motor.stop()` — The Conveyor Motor

Parameters	Description
	This method has no parameters.

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 150, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)
    intake_motor.stop()

Mutators #

set_position #

set_position sets a motor’s or motor group’s encoder position to the given position value.

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

motor	Command
`intake_motor`	`intake_motor.set_position(position, units)` — The Intake Motor
`conveyor_motor`	`conveyor_motor.set_position(position, units)` — The Conveyor Motor

Parameters	Description
`position`	The specific integer for the motor’s encoder to be set to.
`units`	The unit that represents the angle to rotate to: `DEGREES` `TURNS`

Parameters

Description

position

The specific integer for the motor’s encoder to be set to.

units

The unit that represents the angle to rotate to:

DEGREES
TURNS

def main():
    # Pick up a second Block
    conveyor_motor.set_position(-150, DEGREES)
    conveyor_motor.spin_to_position(0, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)

set_velocity #

set_velocity sets the speed of a motor or motor group.

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

motor	Command
`intake_motor`	`intake_motor.set_velocity(velocity, units)` — The Intake Motor
`conveyor_motor`	`conveyor_motor.set_velocity(velocity, units)` — The Conveyor Motor

Parameters	Description
`velocity`	The speed that the V5 Motor will spin at, ranging from 0 to 100.
`units`	The unit that represents the new velocity: `PERCENT`

Parameters

Description

velocity

The speed that the V5 Motor will spin at, ranging from 0 to 100.

units

The unit that represents the new velocity:

PERCENT

def main():
    # Pick up a second Block
    conveyor_motor.set_velocity(90, PERCENT)
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 400, MM)

set_timeout #

set_timeout sets a time limit for a motor’s or motor group’s movement commands. This prevents Motion commands that do not reach their intended position from preventing subsequent commands from running.

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

motor	Command
`intake_motor`	`intake_motor.set_timeout(value, units)` — The Intake Motor
`conveyor_motor`	`conveyor_motor.set_timeout(value, units)` — The Conveyor Motor

Parameters	Description
`value`	The amount of time the motor will wait before stopping.
`units`	The unit to represent the timeout: `SECONDS` `MSEC` – milliseconds

Parameters

Description

value

The amount of time the motor will wait before stopping.

units

The unit to represent the timeout:

SECONDS
MSEC – milliseconds

def main():
    # Pick up a second Block
    conveyor_motor.set_timeout(0.5, SECONDS)
    conveyor_motor.spin_to_position(1000, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 400, MM)

Getters #

is_done #

is_done returns a Boolean indicating whether the specified motor or motor group is not spinning.

True – The specified motor is not spinning.
False – The specified motor is spinning.

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

motor	Command
`intake_motor`	`intake_motor.is_done()` — The Intake Motor
`conveyor_motor`	`conveyor_motor.is_done()` — The Conveyor Motor

Parameters	Description
	This method has no parameters.

def main():
    # Pick up a second Block
    conveyor_motor.spin_to_position(300, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while not conveyor_motor.is_done():
        drivetrain.drive(FORWARD)
        intake_motor.spin(FORWARD)
        wait(5, MSEC)
    drivetrain.stop()
    intake_motor.stop()

is_spinning #

is_spinning returns a Boolean indicating whether the specified motor or motor group is spinning.

True – The specified motor is spinning.
False – The specified motor is not spinning.

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

motor	Command
`intake_motor`	`intake_motor.is_spinning()` — The Intake Motor
`conveyor_motor`	`conveyor_motor.is_spinning()` — The Conveyor Motor

Parameters	Description
	This method has no parameters.

def main():
    # Pick up a second Block
    conveyor_motor.spin_to_position(300, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while conveyor_motor.is_spinning():
        drivetrain.drive_for(FORWARD, 200, MM)
        intake_motor.spin(FORWARD)

position #

position returns the total distance the specified motor or motor group has rotated.

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

motor	Command
`intake_motor`	`intake_motor.position(units)` — The Intake Motor
`conveyor_motor`	`conveyor_motor.position(units)` — The Conveyor Motor

Parameters	Description
`units`	The units that represent the motor’s position: `DEGREES` `TURNS`

Parameters

Description

units

The units that represent the motor’s position:

DEGREES
TURNS

def main():
    # Pick up a second Block
    while conveyor_motor.position(DEGREES) < 150:
        conveyor_motor.spin(FORWARD)
        wait(2, MSEC)
    conveyor_motor.stop()
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 400, MM)

velocity #

velocity returns the current rotational speed of the motor or motor group.

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

motor	Command
`intake_motor`	`intake_motor.velocity(units)` — The Intake Motor
`conveyor_motor`	`conveyor_motor.velocity(units)` — The Conveyor Motor

Parameters	Description
`units`	The unit that represent the motor’s position: `PERCENT`

Parameters

Description

units

The unit that represent the motor’s position:

PERCENT

def main():
    # Pick up a second block
    conveyor_motor.set_velocity(100, PERCENT)
    conveyor_motor.spin_to_position(300, DEGREES, wait=False)
    wait(0.2, SECONDS)
    brain.screen.print(conveyor_motor.velocity(PERCENT))
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 400, MM)

AI Vision #

Getters #

take_snapshot #

take_snapshot filters the data from the AI Vision Sensor frame to return 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`	Which signature to get data of. The only available signature is: `AiVision.ALL_AIOBJS` - Detects Red and Blue Blocks.

Parameters

Description

signature

Which signature to get data of. The only available signature is:

AiVision.ALL_AIOBJS - Detects Red and Blue Blocks.

def main():
    # If an object is detected, pick it up
    conveyor_motor.spin_for(FORWARD, 150, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            intake_motor.spin(FORWARD)
            drivetrain.drive(FORWARD)
            while not bumper.pressing():
                wait(2, MSEC)
            drivetrain.stop()
            break

Properties #

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

Some property values are based off of the detected object’s position in the AI Vision Sensor’s view at the time that take_snapshot was used. The AI Vision Sensor has a resolution of 320 by 240 pixels.

.width #

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

def main():
    # If an object is detected, approach and pick it up
    conveyor_motor.spin_for(FORWARD, 150, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].width > 65:
                drivetrain.stop()
                break
            else:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)

.height #

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

def main():
    # If an object is detected, approach and pick it up
    conveyor_motor.spin_for(FORWARD, 150, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].height > 55:
                drivetrain.stop()
                break
            else:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)

.centerX #

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

def main():
    # Pick up a Block from the top left group
    conveyor_motor.spin_for(FORWARD, 150, DEGREES)
    drivetrain.turn_for(LEFT, 80, DEGREES)
    drivetrain.drive_for(FORWARD, 200, MM)
    drivetrain.set_turn_velocity(20, PERCENT)
    drivetrain.turn(LEFT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if 140 < ai_objects[0].centerX < 180:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)
                while not bumper.pressing():
                    wait(2, MSEC)
                drivetrain.stop()

.centerY #

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

def main():
    # If an object is detected, approach and pick it up
    conveyor_motor.spin_for(FORWARD, 150, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].centerY > 140:
                drivetrain.stop()
                break
            else:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)

.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():
    # Pick up a Block from the top left group
    conveyor_motor.spin_for(FORWARD, 150, DEGREES)
    drivetrain.turn_for(LEFT, 80, DEGREES)
    drivetrain.drive_for(FORWARD, 300, MM)
    drivetrain.set_turn_velocity(20, PERCENT)
    drivetrain.turn(RIGHT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if 100 < ai_objects[0].originX < 140:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)
                while not bumper.pressing():
                    wait(2, MSEC)
                drivetrain.stop()

.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():
    # If an object is detected, approach and pick it up
    conveyor_motor.spin_for(FORWARD, 150, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].originY > 120:
                drivetrain.stop()
                break
            else:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)

.id #

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

AI Classification	id	Signature
BlueBlock	1	`GameElements.BLUE_BLOCK`
RedBlock	2	`GameElements.RED_BLOCK`

def main():
    # Pick up a Red Block from the top left group
    conveyor_motor.spin_for(FORWARD, 150, DEGREES)
    drivetrain.turn_for(LEFT, 80, DEGREES)
    drivetrain.drive_for(FORWARD, 300, MM)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            drivetrain.drive(FORWARD)
            if (ai_objects[0].id) == 2:
                intake_motor.spin(FORWARD)
                while not bumper.pressing():
                    wait(2, MSEC)
                drivetrain.stop()
                break

Sensing #

Optical #

is_near_object #

is_near_object returns a Boolean indicating whether or not the Optical Sensor detects an object close to the sensor.

True – The object is close to the Optical Sensor.
False – The object is not close to the Optical Sensor.

Usage:
optical.is_near_object()

Parameters	Description
	This method has no parameters.

def main():
    # Move the preloaded Block to the top of the Conveyor
    conveyor_motor.spin(FORWARD)
    while not optical.is_near_object():
        wait(2, MSEC)
    conveyor_motor.stop()

color #

color returns the color detected by the Optical Sensor:

Color Returned:
`NONE` – No color detected. `RED` `GREEN` `BLUE` `YELLOW` `ORANGE` `PURPLE` `CYAN`

Color Returned:

NONE – No color detected.
RED
GREEN
BLUE
YELLOW
ORANGE
PURPLE
CYAN

Usage:
optical.color()

Parameters	Description
	This method has no parameters.

def main():
    # Pick up and move a Blue Block to the top of the Conveyor
    conveyor_motor.spin_for(FORWARD, 150, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 360, MM)
    conveyor_motor.spin(FORWARD)
    while not optical.color() == BLUE:
        wait(2, MSEC)
    conveyor_motor.stop()

brightness #

brightness returns the brightness value detected by the Optical Sensor as a percent from 0% to 100%.

Usage:
optical.brightness()

Parameters	Description
	This method has no parameters.

def main():
    # Move the preloaded Block to the top of the Conveyor
    conveyor_motor.spin(FORWARD)
    while not 0 < optical.brightness():
        wait(2, MSEC)
    conveyor_motor.stop()

hue #

hue returns the hue detected by the Optical Sensor.

Hue values range from 0 to 359 degrees, corresponding to positions on the color wheel shown below.

A circular color wheel displaying a full spectrum of hues labeled with degree values around the perimeter, increasing in 30-degree increments from 0° at the top to 360°.

Usage:
optical.hue()

Parameters	Description
	This method has no parameters.

def main():
    # Pick up and move a Blue Block to the top of the Conveyor
    conveyor_motor.spin_for(FORWARD, 150, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 360, MM)
    conveyor_motor.spin(FORWARD)
    while not 220 < optical.hue() < 260:
        wait(2, MSEC)
    conveyor_motor.stop()

object_detected #

object_detected registers a callback function for when the Optical Sensor detects an object.

Usage:
optical.object_detected(callback, arg)

Parameters	Description
`callback`	A function that will be called when an object is detected.
`arg`	Optional. A tuple that is used to pass arguments to the callback function.

def ready_block():
  # Stop the conveyor when Block is at the Sensor
  conveyor_motor.stop()

def main():
  # Move the preloaded Block near the top of the Conveyor
  conveyor_motor.spin(FORWARD)
  optical.object_detected(ready_block)

object_lost #

object_lost registers a callback function for when the Optical Sensor loses a previously detected object.

Usage:
optical.object_lost(callback, arg)

Parameters	Description
`callback`	A function that will be called when a detected object is lost.
`arg`	Optional. A tuple that is used to pass arguments to the callback function.

def ready_block():
  # Stop the conveyor when Block is at the top
  conveyor_motor.stop()

def main():
  # Move the preloaded Block to the top of the Conveyor
  conveyor_motor.spin(FORWARD)
  optical.object_lost(ready_block)

GPS #

All GPS (Game Positioning System™) Sensor examples on this page use the default Playground starting position, C.

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` (Millimeters).

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 150, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive(FORWARD)
    while not gps.x_position(MM) > -795:
        wait(2, MSEC)
    drivetrain.stop()

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` (Millimeters).

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 150, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive(FORWARD)
    while not -450 > gps.y_position(MM):
        wait(2, MSEC)
    drivetrain.stop()

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():
    # Score the preloaded Block into a Center Goal
    drivetrain.set_turn_velocity(30, PERCENT)
    drivetrain.turn(LEFT)
    while not 40 > gps.heading():
        wait(2, MSEC)
    drivetrain.drive_for(FORWARD, 1000, MM)
    drivetrain.turn(RIGHT)
    while not gps.heading() > 310:
        wait(2, MSEC)
    drivetrain.drive_for(REVERSE, 400, MM)
    conveyor_motor.spin(FORWARD)