Screen#

Introduction #

The Screen methods control how the VEX AIM Coding Robot shows text, numbers, and graphics on its screen, and how it responds to screen presses.

Below is a list of all methods:

Touch – Detect and respond to screen presses.

pressing – Returns whether the screen is currently being pressed.
x_position – Returns the x-coordinate of the last screen press.
y_position – Returns the y-coordinate of the last screen press.

Cursor Print – Display text using a row/column system.

print – Prints text, numbers, or variable values at the current cursor position.
set_cursor – Moves the cursor to a specific row and column.
next_row – Moves the cursor to column 1 of the next row.
clear_row – Clears a row of text.
get_row – Returns the current cursor row.
get_column – Returns the current cursor column.

XY Print – Display text at a specific screen coordinate.

print_at – Prints text, numbers, or variable values at a specific x and y coordinate.
set_origin – Sets the origin used for coordinate-based printing and drawing.

Mutators – Clear the screen or update visual settings.

clear_screen – Clears the screen of all drawings and text.
set_font – Sets the font for printed text.
set_pen_width – Sets the thickness of drawn lines and shape outlines.
set_pen_color – Sets the color of text, pixels, lines, and shape outlines.
set_fill_color – Sets the fill color for drawn shapes and printed text backgrounds.

Draw – Add graphics and images to the screen.

draw_pixel – Draws a pixel at a specific x and y position.
draw_line – Draws a line between two points.
draw_rectangle – Draws a rectangle.
draw_circle – Draws a circle.
show_file – Displays an uploaded image.
set_clip_region – Restricts where drawings and text can appear.

Callbacks – Run functions when the screen is pressed or released.

pressed – Registers a function to call when the screen is pressed.
released – Registers a function to call when the screen is released.

Touch #

pressing #

pressing returns a Boolean indicating whether the robot’s screen is currently being pressed.

True – The screen is being pressed.
False – The screen is not being pressed.

Usage:
robot.screen.pressing()

Parameters	Description
	This method has no parameters.

# Turn LEDs white only while the screen is pressed.
while True:
    if robot.screen.pressing():
        robot.led.on(ALL_LEDS, WHITE)
    else:
        robot.led.off(ALL_LEDS)

    wait(50, MSEC)

# Display different messages after the screen is pressed
while not robot.screen.pressing():
    wait(5, MSEC)
robot.screen.print("First message!")
robot.screen.next_row()
# Lift finger to press the screen again
while robot.screen.pressing():
    wait(5, MSEC)
while not robot.screen.pressing():
    wait(5, MSEC)
robot.screen.print("Second message!")
robot.screen.next_row()

x_position #

x_position returns the x-coordinate of the last screen press as an integer from 0 (left) to 240 (right).

Usage:
robot.screen.x_position()

Parameters	Description
	This method has no parameters.

# Display the x-coordinate of where
# the screen is pressed
while True:
    if robot.screen.pressing():
        robot.screen.clear_screen()
        robot.screen.print(robot.screen.x_position())
    wait (50, MSEC)

y_position #

y_position returns the y-coordinate of the last screen press as an integer from 0 (top) to 240 (bottom).

Usage:
robot.screen.y_position()

Parameters	Description
	This method has no parameters.

# Display the y-coordinate of where
# the screen is pressed
while True:
    if robot.screen.pressing():
        robot.screen.clear_screen()
        robot.screen.print(robot.screen.y_position())
    wait (50, MSEC)

Cursor Print #

print #

print prints text, numbers, or variable values on the robot’s screen at the current cursor position and font.

Usage:
robot.screen.print(text)

Parameters	Description
`text`	The text, number, or variable value to display on the screen.

# Display a message at the starting cursor position
robot.screen.print("Hello, Robot!")

A screenshot of the robot's screen, with "Hello, Robot!" printed in white across the top.

set_cursor moves the text cursor to a specific row and column on the robot’s screen. The next print call will start printing at that location. The number of rows and columns that fit depends on the selected font. With the default monospaced medium font, the screen can clearly display up to 8 rows and 13 columns. Text placed beyond this range may be cut off or harder to read.

Monospaced fonts have characters that are all the same width, making text placement consistent. In contrast, proportional fonts vary in character width, so some letters take up more space than others. However, regardless of which type is used, set_cursor positions the cursor based on row and column size, not font style. The font size can be adjusted using set_font.

Usage:
robot.screen.set_cursor(row, column)

Parameters	Description
`row`	The row to move the cursor to.
`column`	The column to move the cursor to.

# Display text starting at Row 3 Column 2
robot.screen.set_cursor(3, 2)
robot.screen.print("Row 3, Column 2")

A screenshot of the robot's screen, with "Row 3, Column 2" printed in white just above the center of the screen, beginning at row 3 column 2.

next_row #

next_row moves the cursor to column 1 on the next row on the robot’s screen.

Usage:
robot.screen.next_row()

Parameters	Description
	This method has no parameters.

# Display two lines of text
robot.screen.print("Line 1")
robot.screen.next_row()
robot.screen.print("Line 2")

A screenshot of the robot's screen with white text. The screen reads Line 1 on the top line, left-justified, and Line 2 directly beneath.

clear_row #

clear_row clears a single row of text on the robot’s screen.

Usage:
robot.screen.clear_row(row, color)

Parameter	Description
`row`	Optional. The row to clear as an integer. The default is the current cursor row.
`color`	Optional. The color to apply to the cleared row. Options include: `BLACK` `BLUE` `CYAN` `GREEN` `ORANGE` `PURPLE` `RED` `TRANSPARENT` `WHITE` `YELLOW` You can also specify a custom color.

Parameter

Description

row

Optional. The row to clear as an integer. The default is the current cursor row.

color

Optional. The color to apply to the cleared row. Options include:

BLACK
BLUE
CYAN
GREEN
ORANGE
PURPLE
RED
TRANSPARENT
WHITE
YELLOW

You can also specify a custom color.

# Display text on two rows
robot.screen.print("This text stays")
robot.screen.next_row()
robot.screen.print("This text disappears")

# Wait 3 seconds before clearing only the second row
wait(3, SECONDS)
robot.screen.clear_row()

# Turn the 5th row green
robot.screen.clear_row(5, GREEN)

A screenshot of the robot's screen with a green bar across the center of the screen from left to right.

get_row #

get_row returns the current row where text will be printed as an integer.

Usage:
robot.screen.get_row()

Parameters	Description
	This method has no parameters.

# Set cursor to (3,2) and print row number
robot.screen.set_cursor(3, 2)
robot.screen.print(robot.screen.get_row())

SA screenshot of the robot's screen, with a white 3 printed near the center of the upper left quadrant, at row 3 column 2.

get_column #

get_column returns the current column where text will be printed as an integer.

Usage:
robot.screen.get_column()

Parameters	Description
	This method has no parameters.

# Set cursor to (3,2) and print column number
robot.screen.set_cursor(3, 2)
robot.screen.print(robot.screen.get_column())

A screenshot of the robot's screen, with a white 2 printed near the center of the upper left quadrant, at row 3 column 2.

XY Print #

print_at #

print_at prints text, numbers, or variable values on the robot’s screen at a specific x and y coordinate in pixels, using the currently set font and origin. x sets how far from the left side the text begins, and y sets where the bottom of the letters sit. This method disregards the current cursor position.

A top down view of the top of the VEX AIM Coding Robot showing the bounding box of the screen as a white rectangle. Clockwise, starting in the upper left corner, coordinates (0,0), (240,0), (0,240), and (240,240) show the four corners. A red circle is centered within the square, showing the viewable area, with a white dashed crosshair intersecting at (120, 120) in the center of the screen.

Note: The red circle shows which coordinates will be visible on the AIM robot’s circular screen. Coordinates that fall outside the red circle exist within the 0–240 range but will not appear on the screen.

Usage:
robot.screen.print_at(text, x, y)

Parameter	Description
`text`	The text, number, or variable value to print on the screen.
`x`	The horizontal position of the text, as an integer from 0 to 240 pixels. 0 is left; 240 is right.
`y`	The vertical position of the text, as an integer from 0 to 240 pixels. 0 is the top; 240 is the bottom.

# Display a message in the middle of the screen
robot.screen.print_at("Hello, Robot!", x=40, y=120)

A screenshot of the robot's screen reads Hello, Robot! in white centered on the screen.

set_origin #

set_origin sets the origin used for drawing and coordinate-based printing on the robot’s screen. By default, the origin is the top-left corner of the screen.

Usage:
robot.screen.set_origin(x, y)

Parameter	Description
`x`	The new x-coordinate to set as the origin, given as an integer from 0 to 240.
`y`	The new y-coordinate to set as the origin, given as an integer from 0 to 240.

# Set the origin to the center of the screen
robot.screen.set_origin(120, 120)

# Draw a rectangle at the new origin
robot.screen.draw_rectangle(0, 0, 80, 40)

A screenshot of the robot’s screen with a white rectangle drawn in the lower left quadrant. The upper left corner of the rectangle is the center of the screen.

Mutators #

clear_screen #

clear_screen clears all drawings and text from the robot’s screen. By default, it also resets the cursor position to row 1, column 1.

Usage:
robot.screen.clear_screen(color)

Parameter	Description
`color`	Optional. Sets the screen color. Options include: `BLACK` `BLUE` `CYAN` `GREEN` `ORANGE` `PURPLE` `RED` `TRANSPARENT` `WHITE` `YELLOW` You can also specify a custom color.

Parameter

Description

color

Optional. Sets the screen color. Options include:

BLACK
BLUE
CYAN
GREEN
ORANGE
PURPLE
RED
TRANSPARENT
WHITE
YELLOW

You can also specify a custom color.

# Draw a circle, and clear it after 2 seconds
robot.screen.draw_circle(120, 120, 60)
wait(2, SECONDS)
robot.screen.clear_screen()

# Set the background color of the screen to red
robot.screen.clear_screen(RED)

A screenshot of the robot's screen, showing the whole screen in bright red.

set_font #

set_font sets the font used for displaying text on the robot’s screen. This font will apply to all text printed with print or print_at. The default font at the start of a project is MONO24.

Usage:
robot.screen.set_font(fontname)

Parameter	Description
`fontname`	Sets the font to one of the following: `MONO12` `MONO15` `MONO20` `MONO24` `MONO30` `MONO40` `MONO60` `PROP20` `PROP30` `PROP40` `PROP60` These options are shown below.

Parameter

Description

fontname

Sets the font to one of the following:

MONO12
MONO15
MONO20
MONO24
MONO30
MONO40
MONO60
PROP20
PROP30
PROP40
PROP60

These options are shown below.

`MONO12`	`MONO15`	`MONO20`
`MONO24`	`MONO30`	`MONO40`
`MONO60`	`PROP20`	`PROP30`
`PROP40`	`PROP60`

# Display text using a larger font
robot.screen.set_font(MONO40)
robot.screen.print("VEX")

A screenshot of the robot’s screen reads VEX in Mono 40 font in the upper left corner.

set_pen_width #

set_pen_width sets the thickness of drawn lines and shape outlines.

Usage:
robot.screen.set_pen_width(width)

Parameter	Description
`width`	The pen width, in pixels, from 0 to 32.

# Draw a rectangle with a pen width of 10
robot.screen.set_pen_width(10)
robot.screen.draw_rectangle(50, 50, 130, 60)

A screenshot of the robot's screen with a thick white rectangle drawn across the upper half.

set_pen_color #

set_pen_color sets the color of text, pixels, lines, and shape outlines.

Usage:
robot.screen.set_pen_color(color)

Parameter	Description
`color`	Optional. The pen and font color to use. Options include: `BLACK` `BLUE` `CYAN` `GREEN` `ORANGE` `PURPLE` `RED` `TRANSPARENT` `WHITE` `YELLOW` You can also specify a custom color.

Parameter

Description

color

Optional. The pen and font color to use. Options include:

BLACK
BLUE
CYAN
GREEN
ORANGE
PURPLE
RED
TRANSPARENT
WHITE
YELLOW

You can also specify a custom color.

# Draw a rectangle with a red pen
robot.screen.set_pen_color(RED)
robot.screen.draw_rectangle(50, 50, 130, 60)

A screenshot of the robot’s screen with a red rectangle with a thin border drawn across the upper half.

set_fill_color #

set_fill_color sets the fill color used when shapes are drawn and when printed text uses a background.

Usage:
robot.screen.set_fill_color(color)

Parameter	Description
`color`	Optional. The fill color to use. Options include: `BLACK` `BLUE` `CYAN` `GREEN` `ORANGE` `PURPLE` `RED` `TRANSPARENT` `WHITE` `YELLOW` You can also specify a custom color.

Parameter

Description

color

Optional. The fill color to use. Options include:

BLACK
BLUE
CYAN
GREEN
ORANGE
PURPLE
RED
TRANSPARENT
WHITE
YELLOW

You can also specify a custom color.

# Draw two orange rectangles
robot.screen.set_fill_color(ORANGE)
robot.screen.draw_rectangle(50, 50, 100, 60)
robot.screen.draw_rectangle(50, 130, 100, 60)

A screenshot of the robot’s screen with two parallel orange rectangles with thin, white outlines positioned to the left center of the screen.

# Display text with a purple background
robot.screen.set_fill_color(PURPLE)
robot.screen.print("Highlight")

A screenshot of the robot’s screen reads Highlight in white text with a purple highlight around it, beginning in the upper left corner.

Draw #

draw_pixel #

draw_pixel draws one pixel at the selected x and y coordinate using the current pen color.

Usage:
robot.screen.draw_pixel(x, y)

Parameter	Description
`x`	The x-coordinate where the pixel will be drawn, given as an integer from 0 to 240.
`y`	The y-coordinate where the pixel will be drawn, given as an integer from 0 to 240.

# Draw a pixel at the center of the screen
robot.screen.draw_pixel(120, 120)

draw_line #

draw_line draws a line from the first screen coordinate (x1, y1) to the second screen coordinate (x2, y2) using the current pen width and pen color.

The x and y-coordinates use the default origin of (0, 0) unless a different origin has been set using set_origin.

Usage:
robot.screen.draw_line(x1, y1, x2, y2)

Parameter	Description
`x1`	The starting x-coordinate of the line, given as an integer from 0 to 240.
`y1`	The starting y-coordinate of the line, given as an integer from 0 to 240.
`x2`	The ending x-coordinate of the line, given as an integer from 0 to 240.
`y2`	The ending y-coordinate of the line, given as an integer from 0 to 240.

# Draw a line from the top left to bottom right of the screen
robot.screen.draw_line(0, 0, 240, 240)

A screenshot of the robot’s screen with a thin white diagonal line drawn from the upper left corner to the lower right corner.

draw_rectangle #

draw_rectangle draws a rectangle with its top-left corner at the selected (x, y) coordinate and a size determined by the given width and height, all measured in pixels. The rectangle’s outline is drawn using the current pen width and pen color. The interior is filled with the current fill color, unless the optional color parameter is used.

The x and y-coordinates use the default origin of (0, 0) unless a different origin has been set using set_origin.

Usage:
robot.screen.draw_rectangle(x, y, width, height, color)

Parameter	Description
`x`	The x-coordinate of the top-left corner of the rectangle, given as an integer from 0 to 240.
`y`	The y-coordinate of the top-left corner of the rectangle, given as an integer from 0 to 240.
`width`	The width of the rectangle, given as an integer from 0 to 240.
`height`	The height of the rectangle, given as an integer from 0 to 240.
`color`	Optional. The fill color of the rectangle. Options include: `BLACK` `BLUE` `CYAN` `GREEN` `ORANGE` `PURPLE` `RED` `TRANSPARENT` `WHITE` `YELLOW` You can also specify a custom color.

# Draw a red rectangle on the screen
robot.screen.draw_rectangle(50, 50, 130, 60, RED)

A screenshot of the robot's screen with a bright red rectangle with a thin white border centered across the upper half of the screen.

draw_circle #

draw_circle draws a circle with its center at the selected (x, y) coordinate and a size determined by the given radius, all measured in pixels. The circle’s outline is drawn using the current pen width and pen color. The interior is filled with the current fill color, unless the optional color parameter is used.

The x and y-coordinates use the default origin of (0, 0) unless a different origin has been set using set_origin.

Usage:
robot.screen.draw_circle(x, y, radius, color)

Parameter	Description
`x`	The x-coordinate of the center of the circle, given as an integer from 0 to 240.
`y`	The y-coordinate of the center of the circle, given as an integer from 0 to 240.
`radius`	The radius of the circle, given as an integer from 0 to 240 pixels.
`color`	Optional. The fill color of the circle. Options include: `BLACK` `BLUE` `CYAN` `GREEN` `ORANGE` `PURPLE` `RED` `TRANSPARENT` `WHITE` `YELLOW` You can also specify a custom color.

# Draw a green circle on the screen
robot.screen.draw_circle(120, 120, 40, GREEN)

A screenshot of the robot's screen with a bright green circle with a thin white border in the center.

show_file #

show_file displays a custom uploaded image on the robot’s screen, with its position set using the x, y, and center parameters based on the image’s reference point.

Usage:
robot.screen.show_file(file, x, y, center)

Parameter	Description
`file`	The custom image to use, from `IMAGE1` to `IMAGE10`. The image number matches the number shown in the AIM control panel.
`x`	The horizontal offset for the image, given as an integer in pixels. Positive values move it right; negative values move it left.
`y`	The vertical offset for the image, given as an integer in pixels. Positive values move it down; negative values move it up.
`center`	Optional. If `center=True`, the image is placed using its center at coordinate (120, 120). By default (`center=False`), the top-left corner of the image is used and positioned relative to the current origin.

# Display uploaded Image 1 in the top left corner
robot.screen.show_file(IMAGE1, 0, 0)

# Show the same image on both sides of the screen
# Image size is 120 x 120
robot.screen.show_file(IMAGE1, 65, 0, center=True)
robot.screen.show_file(IMAGE1, -65, 0, center=True)

set_clip_region #

set_clip_region defines a rectangular area on the screen where all drawings and text will be confined. Any content outside this region will not be displayed.

Usage:
robot.screen.set_clip_region(x, y, width, height)

Parameter	Description
`x`	The x-coordinate of the top-left corner of the clip region, given as an decimal (`float`) from 0 to 240.
`y`	The y-coordinate of the top-left corner of the clip region, given as an decimal (`float`) from 0 to 240.
`width`	The width of the clip region in pixels, given as an decimal (`float`) from 0 to 240.
`height`	The height of the clip region in pixels, given as an decimal (`float`) from 0 to 240.

# Restrict text and drawings to a specific region
robot.screen.set_clip_region(0, 0, 120, 120)
robot.screen.draw_rectangle(60, 60, 100, 100, RED)
robot.screen.print_at("Cut off!", x=60, y=60)

A screenshot of the robot's screen showing the text and image that fit in the clip region. In the upper left quadrant, white text reads Cut o, with a red square directly beneath.

Callbacks #

pressed #

pressed registers a method to be called when the robot’s screen is pressed.

Usage:
robot.screen.pressed(callback, arg)

Parameters	Description
`callback`	A function that is previously defined to execute when the controller screen is pressed.
`arg`	Optional. A tuple containing arguments to pass to the callback function. See Using Functions with Parameters for more information.

# Set the LEDs to green when the screen is pressed.
def screen_touched():
    robot.led.on(ALL_LEDS, GREEN)

robot.screen.pressed(screen_touched)

released #

released registers a method to be called when the robot’s screen is released.

Usage:
robot.screen.released(callback, arg)

Parameters	Description
`callback`	A function that is previously defined to execute when the controller screen is pressed.
`arg`	Optional. A tuple containing arguments to pass to the callback function. See Using Functions with Parameters for more information.

# Set the LEDs to blue when the screen is released.
def screen_released():
    robot.led.on(ALL_LEDS, BLUE)

robot.screen.released(screen_released)