Robotspecifik Python#

Introduktion #

Hjälteboten Axel har två motoralternativ: en AI-visionssensor, en optisk sensor, en rotationssensor och en GPS-sensor (spelpositioneringssystem).

Alla vanliga VEXcode VR-metoder är tillgängliga för användning i V5 24-25 High Stakes Playground.

Nedan följer en lista över alla tillgängliga robotspecifika metoder:

Drivinstruktioner – Flytta och vrida roboten.

Åtgärder
- drive — Rör roboten framåt eller bakåt i all oändlighet.
- drive_for — Rör roboten framåt eller bakåt ett visst avstånd.
- turn — Svänger roboten åt vänster eller höger för alltid.
- turn_for — Svänger roboten åt vänster eller höger ett visst antal grader.
- turn_to_heading — Vrider roboten mot en specifik kurs från -359 till 359 grader.
- turn_to_rotation — Vrider roboten till en specifik rotation.
- stop — Stoppar robotens rörelse.
Mutatorer
- set_heading — Ändrar robotens nuvarande kurs till en ny kurs.
- set_rotation — Ändrar robotens aktuella rotation till en ny rotation.
- set_timeout — Anger hur lång tid roboten ska försöka slutföra en rörelse.
- set_drive_velocity — Anger för roboten hur snabbt den ska köra.
- set_turn_velocity — Anger för roboten hur snabbt den ska svänga.
Hämtarna
- heading — Returnerar robotens aktuella kurs från 0 till 359,99 grader.
- rotation — Returnerar robotens aktuella rotation.
- is_done — Returnerar om roboten är klar med sin rörelse, som ett booleskt värde.
- is_moving — Returnerar om roboten rör sig, som ett booleskt värde.
- velocity — Returnerar hur snabbt roboten kör.

Rörelse – Flytta och spåra robotens motorer.

Åtgärder
- spin — Snurrar en motor framåt eller bakåt i all oändlighet.
- spin_for — Snurrar en motor ett visst avstånd.
- spin_to_position — Roterar en motor till en specifik position.
- stop — Stoppar en motor från att snurra.
Mutatorer
- set_position — Ändrar motorns aktuella position till ett nytt värde.
- set_velocity — Anger hur snabbt motorn ska snurra.
- set_timeout — Anger hur lång tid en motor ska försöka slutföra en rörelse.
Hämtarna
- is_done — Returnerar om motorn är klar med att röra sig, som ett booleskt värde.
- is_spinning — Returnerar om motorn snurrar, som ett booleskt värde.
- position — Returnerar motorns aktuella position.
- velocity — Returnerar hur snabbt motorn snurrar.

AI Vision – Fånga och analysera objekt med hjälp av AI Vision-sensorn.

Hämtarna
- take_snapshot – Returnerar en tupel av detekterade objekt för en specifik signatur.
Fastigheter
- width – Bredden på det detekterade objektet i pixlar.
- height – Höjden på det detekterade objektet i pixlar.
- centerX – X-positionen för objektets centrum i pixlar.
- centerY – Y-positionen för objektets centrum i pixlar.
- originX – X-positionen för objektets övre vänstra hörn i pixlar.
- originY – Y-positionen för objektets övre vänstra hörn i pixlar.
- id – Klassificering eller tagg-ID för objektet.

Konsol – Skriv ut till konsolen och övervaka värden.

Skriva ut
- brain.screen.print — Visar text, siffror eller variabelvärden i konsolen.
- brain.screen.next_row — Flyttar konsolmarkören till början av nästa rad.
- brain.screen.clear_screen — Rensar alla rader från konsolen.
Övervaka
- monitor_variable — Lägger till en eller flera fördefinierade variabler på fliken Monitor.
- monitor_sensor — Lägger till ett eller flera sensorvärden på fliken Monitor.

Avkänning - Använd robotens olika sensorer.

Optisk
- is_near_object – Returnerar om den optiska sensorn detekterar ett objekt inom räckhåll.
- color – Returnerar färgen som detekterats av den optiska sensorn.
- brightness – Returnerar mängden ljus som reflekteras från objektet.
- hue – Returnerar nyansen som detekterats av den optiska sensorn.
- object_detected – Registrerar en funktion som ska anropas när den optiska sensorn detekterar ett objekt.
- object_lost – Registrerar en funktion som ska anropas när den optiska sensorn förlorar ett objekt.
Rotation
- set_position – Ställer in rotationssensorns aktuella position till ett specifikt värde.
- angle – Returnerar sensorns aktuella vinkel mellan 0 och 359,99 grader.
- position – Returnerar den totala rotationspositionen i grader eller varv.
GPS
- x_position – Returnerar den aktuella x-koordinaten för en GPS-sensor på fältet.
- y_position – Returnerar den aktuella y-koordinaten för en GPS-sensor på fältet.
- heading – Returnerar den kurs som roboten för närvarande är riktad mot baserat på GPS-sensorns avläsningar från 0 till 359 grader.

Exemplen på den här sidan använder standardstartpositionen för Playground.

Drivlina #

Drivlinan styr hur VR-roboten kör och svänger. Drivlinan kan röra sig framåt eller bakåt, svänga vänster eller höger, följa kursriktningar och spåra sin rotation.

Åtgärder #

köra #

drive rör roboten framåt eller bakåt för alltid. Roboten fortsätter att röra sig tills den får en annan åtgärd, som att vända eller stanna.

Usage:
drivetrain.drive(direction)

Parametrar	Beskrivning
`direction`	Robotens rörelseriktning: `FORWARD` eller `REVERSE`.

def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

kör_för #

drive_for flyttar roboten framåt eller bakåt ett visst avstånd. Projektet väntar tills roboten är klar innan nästa kodrad körs.

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

Parametrar	Beskrivning
`direction`	Robotens rörelseriktning: `FORWARD` eller `REVERSE`.
`distance`	Sträckan roboten kör. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`).
`units`	Valfritt. Avståndsenheten: `INCHES` (standard) eller `MM` (millimeter).
`wait`	Valfritt. `wait=True` (standard) gör att projektet väntar tills roboten är klar med att vända innan nästa kodrad körs. `wait=False` gör att nästa kodrad körs direkt.

def main():
    # Drive forward and backward
    drivetrain.drive_for(FORWARD, 200, MM)
    drivetrain.drive_for(REVERSE, 200, MM)

# VR threads — Do not delete
vr_thread(main)

sväng #

turn vrider roboten åt vänster eller höger för alltid. Roboten fortsätter att vrida tills den får en annan åtgärd, som att köra eller stanna.

Usage:
drivetrain.turn(direction)

Parametrar	Beskrivning
`direction`	Riktningen roboten svänger: `LEFT` eller `RIGHT`.

def main():
    # Turn right and left, then stop
    drivetrain.turn(RIGHT)
    wait(2, SECONDS)
    drivetrain.turn(LEFT)
    wait(2, SECONDS)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

turn_for vrider roboten åt vänster eller höger ett visst antal grader. Vridningen är relativ till robotens aktuella position. Projektet väntar tills roboten är klar med att vrida sig innan nästa kodrad körs.

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

Parametrar	Beskrivning
`direction`	Riktningen roboten svänger: `LEFT` eller `RIGHT`.
`angle`	Antalet grader roboten roterar. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`).
`units`	Valfritt. Rotationsenheten: `DEGREES` (standard).
`wait`	Valfritt. `wait=True` (standard) gör att projektet väntar tills roboten är klar innan nästa kodrad körs. `wait=False` gör att nästa kodrad körs direkt.

def main():
    # Turn the robot right and left
    drivetrain.turn_for(RIGHT, 90, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_for(LEFT, 90, DEGREES)

# VR threads — Do not delete
vr_thread(main)

sväng_till_rubrik #

En kurs är den riktning roboten är vänd mot, mätt i grader. turn_to_heading vrider roboten så att den är vänd mot en specifik kurs från -359 till 359 grader. Roboten kommer att svänga den kortaste riktningen för att nå målkursen.

Robotens startriktning är 0 grader.

Projektet väntar tills roboten är klar med att snurra innan nästa kodrad körs.

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

Parametrar	Beskrivning
`angle`	Riktningen roboten ska vara vänd mot, i grader. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`) från -359 till 359.
`units`	Valfritt. Rotationsenheten: `DEGREES` (standard).
`wait`	Valfritt. `wait=True` (standard) gör att projektet väntar tills roboten är klar med att vända innan nästa kodrad körs. `wait=False` gör att nästa kodrad körs direkt.

def main():
    # Turn to face the cardinal directions
    drivetrain.turn_to_heading(90, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(180, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(270, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

sväng_till_rotation #

turn_to_rotation vrider roboten till en specifik rotation.

Rotation är hur mycket roboten har roterat, mätt i grader. I början av ett projekt sätts rotationsvärdet till 0 grader. Rotation kan också ställas in med metoden set_rotation.

Rotationsvärdena är absoluta. Det betyder att rotationsriktningen beror på robotens aktuella rotation. Att vrida åt höger ökar rotationen och att vrida åt vänster minskar rotationen.

Om roboten till exempel startar vid 0 grader och du roterar 720 grader, kommer den att svänga höger två gånger. Om du sedan roterar 360 grader, kommer den att svänga vänster en gång, eftersom 360 är mindre än 720.

Projektet väntar tills roboten är klar med att snurra innan nästa kodrad körs.

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

Parametrar	Beskrivning
`angle`	Rotationsvärdet, i grader, som roboten kommer att rotera till. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`).
`units`	Valfritt. Rotationsenheten: `DEGREES` (standard).
`wait`	Valfritt. `wait=True` (standard) gör att projektet väntar tills roboten är klar med att vända innan nästa kodrad körs. `wait=False` gör att nästa kodrad körs direkt.

def main():
    # Turn left, then spin in a circle
    # clockwise and face right
    drivetrain.turn_to_rotation(-90, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_to_rotation(450, DEGREES)

# VR threads — Do not delete
vr_thread(main)

stopp #

stop stoppar robotens rörelse.

Usage:
drivetrain.stop()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

Mutatorer #

set_header #

En kurs är den riktning roboten är vänd i, mätt i grader. set_heading ändrar robotens nuvarande kurs till ett nytt kursvärde.

Om roboten till exempel har vänt sig åt höger och kursen ställs in på 0 grader, blir den högervända positionen den nya 0 grader. Roboten kan då vända sig till andra positioner baserat på den nya kursen.

Usage:
drivetrain.set_heading(heading, units)

Parametrar	Beskrivning
`heading`	Kursvärdet, i grader, som ska ställas in för roboten. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`).
`units`	Valfritt. Kursenheten: `DEGREES` (standard).

def main():
    # Face the new 0 degrees
    drivetrain.set_heading(90, DEGREES)
    drivetrain.turn_to_heading(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_rotation #

Rotation är hur mycket roboten har roterat, mätt i grader. I början av ett projekt sätts rotationsvärdet till 0 grader. set_rotation ändrar robotens aktuella rotation till ett nytt värde.

Om roboten till exempel har gjort två hela varv åt höger blir dess rotationsvärde 720 grader. Om rotationen ställs in på 0 grader återställs den rotationen från 720 till 0 grader. Sedan kan roboten vända sig till rotationer baserat på det nya värdet.

Usage:
drivetrain.set_rotation(rotation, units)

Parametrar	Beskrivning
`rotation`	Rotationsvärdet, i grader, som ska ställas in för roboten. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`).
`units`	Valfritt. Rotationsenheten: `DEGREES` (standard).

def main():
    # Spin counterclockwise two times
    drivetrain.set_rotation(720, DEGREES)
    drivetrain.turn_to_rotation(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_timeout #

set_timeout anger hur lång tid roboten ska försöka slutföra en rörelse. Om roboten inte kan slutföra inom den tiden kommer den att sluta försöka och gå vidare till nästa kodrad. Detta förhindrar att roboten fastnar i en rörelse.

Usage:
drivetrain.set_timeout(value, units)

Parametrar	Beskrivning
`value`	Den tid roboten kan försöka slutföra en rörelse. Detta kan vara ett positivt `integer` eller ett decimaltal (`float`).
`units`	Tidsenheten: `SECONDS` eller `MSEC` (millisekunder).

def main():
    # Turn right after driving forward
    drivetrain.set_timeout(1, SECONDS)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    drivetrain.turn_for(RIGHT, 90)

# VR threads — Do not delete
vr_thread(main)

set_drive_velocity #

set_drive_velocity anger hur snabbt roboten ska köra. En högre procentandel gör att roboten kör snabbare och en lägre procentandel gör att roboten kör långsammare.

Varje projekt börjar med att roboten kör med 50 % hastighet som standard.

Obs: En högre hastighet gör att roboten kör snabbare, men den kan vara mindre precis. En lägre hastighet gör att roboten kör långsammare, men den kan vara mer precis.

Usage:
drivetrain.set_drive_velocity(velocity, units)

Parametrar	Beskrivning
`velocity`	Hastigheten att köra med från 0 % till 100 %. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`).
`units`	Valfritt. Hastighetsenheten: `PERCENT` (standard).

def main():
    # Drive forward at different velocities
    # Default velocity
    drivetrain.drive_for(FORWARD, 150, MM)
    wait(1, SECONDS)
    # Drive slower
    drivetrain.set_drive_velocity(20, PERCENT)
    drivetrain.drive_for(FORWARD, 150, MM)
    wait(1, SECONDS)
    # Drive faster
    drivetrain.set_drive_velocity(100, PERCENT)
    drivetrain.drive_for(FORWARD, 150, MM)

# VR threads — Do not delete
vr_thread(main)

set_turn_velocity #

set_turn_velocity anger hur snabbt roboten ska snurra. En högre procentandel gör att roboten snurrar snabbare och en lägre procentandel gör att roboten snurrar långsammare.

Varje projekt börjar med att roboten roterar med 50 % hastighet som standard.

Obs: En högre hastighet gör att roboten roterar snabbare, men den kan vara mindre exakt. En lägre hastighet gör att roboten roterar långsammare, men den kan vara mer exakt.

Usage:
drivetrain.set_turn_velocity(velocity, units)

Parametrar	Beskrivning
`velocity`	Hastigheten att rotera med från 0 % till 100 %. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`).
`units`	Valfritt. Hastighetsenheten: `PERCENT` (standard).

def main():
    # Turn at different velocities
    # Default velocity
    drivetrain.turn_for(RIGHT, 120, DEGREES)
    wait(1, SECONDS)
    # Turn slower
    drivetrain.set_turn_velocity(20, PERCENT)
    drivetrain.turn_for(RIGHT, 120, DEGREES)
    wait(1, SECONDS)
    # Turn faster
    drivetrain.set_turn_velocity(100, PERCENT)
    drivetrain.turn_for(RIGHT, 120, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Getters #

rubrik #

En kurs är den riktning roboten är vänd i, mätt i grader. heading returnerar robotens aktuella kurs från 0 till 359,99 grader.

Robotens startriktning är 0 grader.

Usage:
drivetrain.heading(units)

Parametrar	Beskrivning
`units`	Valfritt. Kursenheten: `DEGREES` (standard).

def main():
    # Display the heading after turning
    drivetrain.turn_for(RIGHT, 450, DEGREES)
    brain.screen.print("Heading: ")
    brain.screen.print(drivetrain.heading(DEGREES))

# VR threads — Do not delete
vr_thread(main)

rotation #

Rotation är hur mycket roboten har roterat, mätt i grader. I början av ett projekt sätts rotationsvärdet till 0 grader. rotation returnerar robotens aktuella rotation.

Att vrida åt höger ökar rotationen, och att vrida åt vänster minskar rotationen. Om du till exempel gör två hela varv åt höger får du en rotation på 720 grader.

Usage:
drivetrain.rotation(units)

Parametrar	Beskrivning
`units`	Valfritt. Rotationsenheten: `DEGREES` (standard).

def main():
    # Display the rotation after turning
    drivetrain.turn_for(RIGHT, 450, DEGREES)
    brain.screen.print("Rotation: ")
    brain.screen.print(drivetrain.rotation(DEGREES))

# VR threads — Do not delete
vr_thread(main)

är_klar #

is_done returnerar huruvida roboten är klar med att röra sig, som ett booleskt värde. Detta kan användas för att styra tidpunkten för andra beteenden baserat på robotens rörelse.

True — Roboten är klar med sin rörelse.
False — Roboten rör sig fortfarande.

Den här metoden fungerar tillsammans med följande drivlinmetoder som har parametern wait : drive_for, turn_for, turn_to_heading och turn_to_rotation.

Usage:
drivetrain.is_done()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

rör sig #

is_moving returnerar huruvida roboten rör sig, som ett booleskt värde. Detta kan användas för att styra tidpunkten för andra beteenden baserat på robotens rörelse.

True — Roboten rör sig.
False — Roboten rör sig inte.

Usage:
drivetrain.is_moving()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

hastighet #

velocity returnerar hur snabbt roboten kör, som en procentandel från -100 % till 100 %.

Usage:
drivetrain.velocity(units)

Parametrar	Beskrivning
`units`	Valfritt. Hastighetsenheten: `PERCENT` (standard).

Exempel

def main():
    # Display the velocity after driving
    drivetrain.drive_for(FORWARD, 150, MM)
    brain.screen.print("Velocity: ")
    brain.screen.print(drivetrain.velocity(PERCENT))

Rörelse #

Axel använder armmotorn för att lyfta och sänka armen så att ringarna kan placeras nära pålarna. Påskjutarmotorn flyttar påskjutaren ner längs armen för att trycka ringarna från armen och upp på en påle.

Varje motor har sitt eget riktningsbeteende. Riktningsbeskrivningarna förklarar hur varje riktning rör motorn på axeln.

Åtgärder #

snurra #

spin snurrar en motor framåt eller bakåt för alltid. Motorn fortsätter att snurra tills den får en annan åtgärd, som att snurra i en annan riktning eller stanna.

Användning:
Ett av två tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
`arm_motor`	`arm_motor.spin(direction)` — Armmotor
`pusher_motor`	`pusher_motor.spin(direction)` — Tryckmotor

Parametrar

Beskrivning

direction

Motorns rotationsriktning:

FORWARD — Snurrar armen uppåt eller flyttar påtryckaren neråt längs armen.
REVERSE — Snurrar armen nedåt eller flyttar påtryckaren uppåt längs armen.

def main():
    # Lift the Arm up before moving
    arm_motor.spin(FORWARD)
    wait(1, SECONDS)
    arm_motor.stop()

# VR threads — Do not delete
vr_thread(main)

spin_for #

spin_for snurrar en motor ett visst avstånd. Rotationen är relativ till motorns aktuella position. Projektet väntar tills motorn har snurrat klart innan nästa kodrad körs.

Användning:
Ett av två tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
`arm_motor`	`arm_motor.spin_for(direction, distance, units, wait)` — Armmotor
`pusher_motor`	`pusher_motor.spin_for(direction, distance, units, wait)` — Pusher Motor

Parametrar	Beskrivning
`direction`	Motorns rotationsriktning: `FORWARD` — Snurrar armen uppåt eller flyttar påtryckaren neråt längs armen. `REVERSE` — Snurrar armen nedåt eller flyttar påtryckaren uppåt längs armen.
`distance`	Avståndet motorn snurrar. `DEGREES` använd heltal. `TURNS` kan använda heltal eller decimaler.
`units`	Valfritt. Avståndsenheten: `DEGREES` (standard) eller `TURNS`.
`wait`	Valfritt. `wait=True` (standard) — Gör att projektet väntar tills motorn har snurrat klart innan nästa kodrad körs. `wait=False` — Gör att nästa kodrad körs direkt.

def main():
    # Lift the Arm up before moving
    arm_motor.spin_for(FORWARD, 400, DEGREES)

# VR threads — Do not delete
vr_thread(main)

snurra_till_position #

spin_to_position snurrar en motor till en specifik position.

En motors position är hur långt den har snurrat, mätt i DEGREES eller TURNSEtt varv är lika med 360 grader. I början av ett projekt är motorpositionen inställd på 0 grader. Motorpositionen kan också ställas in med metoden set_position.

Positionsvärdena är absoluta. Det betyder att rotationsriktningen beror på motorns aktuella position.

Om motorn till exempel startar vid 0 grader och snurrar till en position på 720 grader, snurrar den framåt två varv. Om den sedan snurrar till en position på 360 grader, snurrar den bakåt ett varv, eftersom 360 är mindre än 720.

Användning:
Ett av två tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
`arm_motor`	`arm_motor.spin_to_position(angle, units, wait=True)` — Armmotor
`pusher_motor`	`pusher_motor.spin_to_position(angle, units, wait=True)` — Tryckmotor

Parametrar	Beskrivning
`angle`	Positionsvärdet som motorn kommer att rotera till. `DEGREES` använd heltal. `TURNS` kan använda heltal eller decimaler.
`units`	Valfritt. Positionsenheten: `DEGREES` (standard) eller `TURNS`.
`wait`	Valfritt. `wait=True` (standard) — Gör att projektet väntar tills motorn har snurrat klart innan nästa kodrad körs. `wait=False` — Gör att nästa kodrad körs direkt.

Parametrar

Beskrivning

angle

Positionsvärdet som motorn kommer att rotera till. DEGREES använd heltal. TURNS kan använda heltal eller decimaler.

units

Valfritt. Positionsenheten: DEGREES (standard) eller TURNS.

wait

Valfritt.

wait=True (standard) — Gör att projektet väntar tills motorn har snurrat klart innan nästa kodrad körs.
wait=False — Gör att nästa kodrad körs direkt.

def main():
    # Lift the Arm up before moving
    arm_motor.spin_to_position(400, DEGREES)

# VR threads — Do not delete
vr_thread(main)

stopp #

stop stoppar en motor från att snurra.

Användning:
Ett av två tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
`arm_motor`	`arm_motor.stop()` — Armmotor
`pusher_motor`	`pusher_motor.stop()` — Tryckmotor

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

def main():
    # Lift the Arm up before moving
    arm_motor.spin(FORWARD)
    wait(1, SECONDS)
    arm_motor.stop()

# VR threads — Do not delete
vr_thread(main)

Mutatorer #

set_position #

En motors position är hur långt den har snurrat, mätt i DEGREES eller TURNSEtt varv är lika med 360 grader. set_position ändrar motorns nuvarande position till ett nytt värde.

Om till exempel en motor har snurrat 180 grader, kommer en position som ställs in på 0 grader att återställas från 180 grader till 0 grader. Motorn kan sedan snurra till positioner baserat på det nya värdet.

Användning:
Ett av två tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
`arm_motor`	`arm_motor.set_position(position, units)` — Armmotor
`pusher_motor`	`pusher_motor.set_position(position, units)` — Pushermotor

Parametrar	Beskrivning
`position`	Positionsvärdet som ska ställas in för motorn. `DEGREES` använd heltal. `TURNS` kan använda heltal eller decimaler.
`units`	Valfritt. Positionsenheten: `DEGREES` (standard) eller `TURNS`.

def main():
    # Make the raised Arm as the new 0 degrees position
    arm_motor.spin_to_position(400, DEGREES)
    arm_motor.set_position(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_velocity #

set_velocity anger hur snabbt en motor ska snurra. En högre procentandel gör att motorn snurrar snabbare och en lägre procentandel gör att motorn snurrar långsammare.

Varje projekt börjar med att varje motor roterar med 50 % hastighet som standard.

Obs! En högre hastighet gör att motorn snurrar snabbare, men den kan vara mindre exakt. En lägre hastighet gör att motorn snurrar långsammare, men den kan vara mer exakt.

Användning:
Ett av två tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
`arm_motor`	`arm_motor.set_velocity(velocity, units)` — Armmotor
`pusher_motor`	`pusher_motor.set_velocity(velocity, units)` — Pushermotor

Parametrar	Beskrivning
`velocity`	Hastigheten att rotera med från 0% till 100%. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`).
`units`	Hastighetsenheten: `PERCENT`.

def main():
    # Lift the Arm up before moving
    arm_motor.set_velocity(100, PERCENT)
    arm_motor.spin_to_position(400, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_timeout #

set_timeout anger hur lång tid en motor ska försöka slutföra en rörelse. Om motorn inte kan slutföra inom den tiden kommer den att sluta försöka och gå vidare till nästa kodrad. Detta förhindrar att motorn fastnar i en rörelse.

Användning:
Ett av två tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
`arm_motor`	`arm_motor.set_timeout(value, units)` — Armera motor
`pusher_motor`	`pusher_motor.set_timeout(value, units)` — Tryckmotor

Parametrar	Beskrivning
`value`	Den tid motorn kan försöka slutföra en rörelse. Detta kan vara ett positivt `integer` eller ett decimaltal (`float`).
`units`	Tidsenheten: `SECONDS` eller `MSEC` (millisekunder).

def main():
    # Lift the Arm up before moving
    arm_motor.set_timeout(1, SECONDS)
    arm_motor.spin_for(FORWARD, 1080, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Getters #

är_klar #

is_done returnerar om motorn är klar med att röra sig, som ett booleskt värde. Detta kan användas för att styra tidpunkten för andra beteenden baserat på motorns rörelse.

True — Motorn är klar med att röra sig.
False — Motorn rör sig fortfarande.

Den här metoden fungerar tillsammans med följande rörelsemetoder som har parametern wait : spin_for och spin_to_position.

Användning:
Ett av två tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
`arm_motor`	`arm_motor.is_done()` — Armmotor
`pusher_motor`	`pusher_motor.is_done()` — Tryckmotor

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

snurrar #

is_spinning returnerar huruvida motorn snurrar, som ett booleskt värde. Detta kan användas för att styra tidpunkten för andra beteenden baserat på motorns rörelse.

True — Motorn snurrar.
False — Motorn snurrar inte.

Den här metoden fungerar tillsammans med följande rörelsemetoder som har parametern wait : spin_for och spin_to_position.

Användning:
Ett av två tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
`arm_motor`	`arm_motor.is_spinning()` — Armmotor
`pusher_motor`	`pusher_motor.is_spinning()` — Tryckmotor

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

placera #

En motors position är hur långt den har snurrat, mätt i DEGREES eller TURNSEtt varv är lika med 360 grader. position returnerar motorns aktuella position.

I början av ett projekt är motorpositionen inställd på 0 grader. Om motorn snurrar ett helt varv framåt blir positionen 360 grader eller 1 varv. Om motorn snurrar åt andra hållet blir positionen negativ.

Användning:
Ett av två tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
`arm_motor`	`arm_motor.position(units)` — Armmotor
`pusher_motor`	`pusher_motor.position(units)` — Pushermotor

Parametrar	Beskrivning
`units`	Enheten för att återställa motorpositionen i: `DEGREES` eller `TURNS`.

hastighet #

velocity returnerar hur snabbt motorn snurrar.

Ett positivt värde betyder att motorn roterar framåt. Ett negativt värde betyder att motorn roterar bakåt.

Användning:
Ett av två tillgängliga motorobjekt kan användas med den här metoden, som visas nedan:

motor	Kommando
`arm_motor`	`arm_motor.velocity(units)` — Armmotor
`pusher_motor`	`pusher_motor.velocity(units)` — Tryckmotor

Parametrar	Beskrivning
`units`	Hastighetsenheten som ska returneras: `PERCENT`.

AI-vision #

Getters #

ta_ögonblicksbild #

take_snapshot filtrerar data från AI Vision Sensor-ramen till en enda signatur – en sparad beskrivning av något som sensorn kan känna igen, till exempel ett spelelement på planen – och returnerar en tupel.

Tupeln lagrar objekt sorterade från störst till minst efter bredd, med början vid index 0. Varje objekts egenskaper kan nås med hjälp av dess index. En tom tupel returneras om inga matchande objekt upptäcks.

Usage:
ai_vision.take_snapshot(signature)

Parametrar	Beskrivning
`signature`	Filtrerar datamängden för att endast inkludera data från den givna signaturen. Tillgängliga signaturer är: `AiVision.ALL_AIOBJS` - Upptäcker mobila mål, röda ringar och blå ringar.

Parametrar

Beskrivning

signature

Filtrerar datamängden för att endast inkludera data från den givna signaturen. Tillgängliga signaturer är:

AiVision.ALL_AIOBJS - Upptäcker mobila mål, röda ringar och blå ringar.

def main():
    # Lift the Arm to not block the AI Vision Sensor's field of view
    arm_motor.spin_for(FORWARD, 350, DEGREES)
    while True:
        brain.screen.clear_screen()

        # Display the data of the largest detected Game Element
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

        if len(ai_objects) is not 0:
            brain.screen.print("Center X: ", ai_objects[0].centerX)
            brain.screen.next_row()

            brain.screen.print("Center Y: ", ai_objects[0].centerY)
            brain.screen.next_row()

        else:
            brain.screen.print("No object detected.")

        wait(0.2, SECONDS)

# VR threads — Do not delete
vr_thread(main)

Fastigheter #

Det finns sju egenskaper som ingår i varje objekt som lagras i en tupel efter att take_snapshot har använts.

Alla egenskapsvärden utom .id beskriver det detekterade objektets position och storlek i AI-visionssensorns vy vid det ögonblick då take_snapshot användes. Dessa värden mäts i pixlar, baserat på sensorns upplösning på 320 x 240 pixlar.

.bredd #

.width returnerar bredden på det detekterade objektet i pixlar, vilket är ett heltal mellan 1 och 320.

def main():
    # Lift the Arm to not block the AI Vision Sensor's view
    arm_motor.spin_for(FORWARD, 350, DEGREES)

    # Display the width of the largest Game Element
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

    if len(ai_objects) is not 0:
        brain.screen.print(ai_objects[0].width)

# VR threads — Do not delete
vr_thread(main)

.höjd #

.height returnerar höjden på det detekterade objektet i pixlar, vilket är ett heltal mellan 1 och 240.

def main():
    # Lift the Arm to not block the AI Vision Sensor's view
    arm_motor.spin_for(FORWARD, 350, DEGREES)

    # Display the height of the largest Game Element
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

    if len(ai_objects) is not 0:
        brain.screen.print(ai_objects[0].height)

# VR threads — Do not delete
vr_thread(main)

.centerX #

.centerX returnerar x-koordinaten för det detekterade objektets centrum i pixlar, vilket är ett heltal mellan 0 och 320.

def main():
    # Lift the Arm to not block the AI Vision Sensor's view
    arm_motor.spin_for(FORWARD, 350, DEGREES)

    # Display the centerX of the largest Game Element
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

    if len(ai_objects) is not 0:
        brain.screen.print(ai_objects[0].centerX)

# VR threads — Do not delete
vr_thread(main)

.centerY #

.centerY returnerar y-koordinaten för det detekterade objektets centrum i pixlar, vilket är ett heltal mellan 0 och 240.

def main():
    # Lift the Arm to not block the AI Vision Sensor's view
    arm_motor.spin_for(FORWARD, 350, DEGREES)

    # Display the centerY of the largest Game Element
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

    if len(ai_objects) is not 0:
        brain.screen.print(ai_objects[0].centerY)

# VR threads — Do not delete
vr_thread(main)

.originX #

.originX returnerar x-koordinaten för det övre vänstra hörnet av det detekterade objektets avgränsningsram i pixlar, vilket är ett heltal mellan 0 och 320.

def main():
    # Lift the Arm to not block the AI Vision Sensor's view
    arm_motor.spin_for(FORWARD, 350, DEGREES)

    # Display the originX of the largest Game Element
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

    if len(ai_objects) is not 0:
        brain.screen.print(ai_objects[0].originX)

# VR threads — Do not delete
vr_thread(main)

.ursprungY #

.originY returnerar y-koordinaten för det övre vänstra hörnet av det detekterade objektets avgränsningsram i pixlar, vilket är ett heltal mellan 0 och 240.

def main():
    # Lift the Arm to not block the AI Vision Sensor's view
    arm_motor.spin_for(FORWARD, 350, DEGREES)

    # Display the originY of the largest Game Element
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

    if len(ai_objects) is not 0:
        brain.screen.print(ai_objects[0].originY)

# VR threads — Do not delete
vr_thread(main)

.id #

.id returnerar ID:t för den detekterade AI-klassificeringen som ett heltal.

AI-klassificering	id	Signatur
Mobilmål	0	`GameElements.MOBILE_GOAL`
RödRing	1	`GameElements.RED_RING`
BlåRing	2	`GameElements.BLUE_RING`

def main():
    # Lift the Arm to not block the AI Vision Sensor's view
    arm_motor.spin_for(FORWARD, 350, DEGREES)

    # Display if a Mobile Goal is detected
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

    if len(ai_objects) is not 0:

        if ai_objects[0].id == GameElements.MOBILE_GOAL:
            brain.screen.print("This is a Mobile Goal.")
        else:
            brain.screen.print("This is not a Mobile Goal.")

# VR threads — Do not delete
vr_thread(main)

Trösta #

Konsolen visar text, siffror och variabelvärden medan ett projekt körs. Konsolmetoder kan också flytta markören till en ny rad, rensa konsolen och lägga till variabler eller sensorvärden på fliken Monitor.

Skriva ut #

hjärnskärmavtryck #

brain.screen.print visar text, siffror eller variabelvärden i konsolen med hjälp av markörens aktuella position.

Använd brain.screen.next_row när du vill att nästa utskrivna värde ska börja på en ny rad.

Usage:
brain.screen.print(value)

Parametrar	Beskrivning
`value`	Texten, talet eller variabelvärdet som ska visas i konsolen.

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

# VR threads — Do not delete
vr_thread(main)

VEXcode-konsolen, som visar konsolen och texten "Hej, robot!" visas.

hjärnskärm.nästa_rad #

brain.screen.next_row flyttar markören till kolumn 1 på nästa rad i konsolen. Nästa värde som skrivs ut visas på den raden.

Usage:
brain.screen.next_row()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

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)

VEXcode-konsolen, som visar konsolen och texten "Rad 1" visas på den första raden och "Rad 2" på den andra raden.

hjärnskärm.klar_skärm #

brain.screen.clear_screen rensar alla rader från konsolen och flyttar markören tillbaka till rad 1.

Usage:
brain.screen.clear_screen()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

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)

Övervaka #

monitor_variabel #

monitor_variable lägger till en eller flera fördefinierade variabler till fliken Monitor i VEXcode. Detta låter dig se en variabels värde ändras medan ett projekt körs.

Variabler måste vara globala för att monitor_variable ska kunna övervakas. Ange varje variabelnamn som en sträng.

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

Parametrar	Beskrivning
`variable`	Namnet på en fördefinierad global variabel som ska övervakas, angivet som en sträng. För att övervaka mer än en variabel, separera varje variabelnamn med ett kommatecken.

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

    # Drive in a square 3 times
    for loops in range(12):
        drivetrain.turn_for(RIGHT, 90, DEGREES)
        drivetrain.drive_for(FORWARD, 150, MM)

# VR threads — Do not delete
vr_thread(main)

monitor_sensor #

monitor_sensor lägger till ett eller flera sensorvärden till fliken Monitor i VEXcode. Detta låter dig se sensorvärden ändras medan ett projekt körs.

Ange varje sensorvärde som en sträng.

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

Parametrar	Beskrivning
`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` Pusher Motor `pusher_motor.is_done` `pusher_motor.is_spinning` `pusher_motor.position` `pusher_motor.velocity` Arm Motor `arm_motor.is_done` `arm_motor.is_spinning` `arm_motor.position` `arm_motor.velocity` Front Distance Sensor `front_distance.is_object_detected` `front_distance.object_distance_mm` `front_distance.object_distance_inches` Front Optical Sensor `front_optical.is_near_object` `front_optical.color` `front_optical.brightness` `front_optical.hue` GPS Sensor `gps.position_mm` `gps.position_inches` `gps.heading` Pusher Rotation Sensor `pusher_rotation.angle` `pusher_rotation.position` 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`

Parametrar

Beskrivning

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
Pusher Motor
- pusher_motor.is_done
- pusher_motor.is_spinning
- pusher_motor.position
- pusher_motor.velocity
Arm Motor
- arm_motor.is_done
- arm_motor.is_spinning
- arm_motor.position
- arm_motor.velocity
Front Distance Sensor
- front_distance.is_object_detected
- front_distance.object_distance_mm
- front_distance.object_distance_inches
Front Optical Sensor
- front_optical.is_near_object
- front_optical.color
- front_optical.brightness
- front_optical.hue
GPS Sensor
- gps.position_mm
- gps.position_inches
- gps.heading
Pusher Rotation Sensor
- pusher_rotation.angle
- pusher_rotation.position
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)

Avkänning #

Optisk #

är_nära_objektet #

is_near_object returnerar ett booleskt värde som anger om den optiska sensorn detekterar ett objekt inom räckhåll.

True – Den optiska sensorn detekterar ett objekt.
False – Den optiska sensorn detekterar inte ett objekt.

Usage:
front_optical.is_near_object()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

def main():
    # Display if the Optical Sensor is detecting an object
    brain.screen.print(front_optical.is_near_object())

# VR threads — Do not delete
vr_thread(main)

färg #

color returnerar en instans av en Color klass, baserat på det detekterade nyansvärdet. Dessa kan jämföras med fördefinierade Color -objekt för att skapa villkorliga satser.

Möjliga färger är:

NONE
RED - Ett nyansvärde mellan 340° - 20°
GREEN - Ett nyansvärde mellan 80° - 140°
BLUE - Ett nyansvärde mellan 200° - 240°
YELLOW - Ett nyansvärde mellan 40° och 60°
ORANGE - Ett nyansvärde mellan 20° - 40°
PURPLE - Ett nyansvärde mellan 240° och 280°
CYAN - Ett nyansvärde mellan 140° och 200°

Obs! Den optiska sensorn letar efter nyansintervall som matchar den angivna färgen. För att upptäcka specifika nyansintervall, se hue.

Usage:
front_optical.color()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

def main():
    # Display the color of the ring on the Arm
    brain.screen.print(front_optical.color())

# VR threads — Do not delete
vr_thread(main)

ljusstyrka #

brightness returnerar mängden ljus som reflekteras från objektet som ett decimaltal (float) som representerar en procentandel.

En högre procentandel innebär att mer ljus reflekteras tillbaka till den optiska sensorn. En lägre procentandel innebär att mindre ljus reflekteras tillbaka.

Usage:
front_optical.brightness()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

nyans #

hue returnerar nyansvärdet för den detekterade färgen som ett decimaltal (float) från 0 till 359.

Nyans är ett sätt att beskriva färg med hjälp av siffror runt en färgcirkel.

En cirkulär färgcirkel som visar ett komplett spektrum av nyanser märkta med gradvärden runt omkretsen, ökande i 30-graders steg från 0° högst upp till 360°.

Usage:
front_optical.hue()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

def main():
    # Display the hue of the ring on the Arm.
    brain.screen.print("Hue: ", optical.hue())

# VR threads — Do not delete
vr_thread(main)

objekt_upptäckt #

object_detected registrerar en funktion som ska anropas när den optiska sensorn detekterar ett nytt objekt.

Usage:
front_optical.object_detected(callback, arg)

Parametrar	Beskrivning
`callback`	En tidigare definierad funktion som körs när den optiska sensorn detekterar ett nytt objekt.
`arg`	Valfritt. En tupel som innehåller argument som ska skickas till callback-funktionen. Se Använda funktioner med parametrar för mer information.

objekt_förlorat #

object_lost registrerar en funktion som ska anropas när den optiska sensorn förlorar ett detekterat objekt.

Usage:
front_optical.object_lost(callback, arg)

Parametrar	Beskrivning
`callback`	En tidigare definierad funktion som körs när den optiska sensorn förlorar ett detekterat objekt.
`arg`	Valfritt. En tupel som innehåller argument som ska skickas till callback-funktionen. Se Använda funktioner med parametrar för mer information.

Rotation #

set_position #

set_position ställer in rotationssensorns aktuella position till ett värde i grader.

Usage:
pusher_rotation.set_position(position, units)

Parametrar	Beskrivning
placera	Positionen att ställa in rotationssensorn på.
enheter	Valfritt. Positionsenheten:`DEGREES` (standard) eller `TURNS`

vinkel #

angle returnerar sensorns aktuella vinkel som ett flyttal.

Usage:
pusher_rotation.angle(units)

Parametrar

Beskrivning

enheter

Valfritt. Vinkelenheten:

DEGREES (standard) – 0 till 359,99
TURNS

placera #

position returnerar den totala rotationspositionen.

Usage:
pusher_rotation.position(units)

Parametrar

Beskrivning

enheter

Valfritt. Positionsenheten:

DEGREES (standard) – 0 till 359 som ett heltal
TURNS – Som ett flyttal

GPS #

x_position #

x_position returnerar den aktuella x-koordinaten för en GPS-sensor (Game Positioning System™) på planen.

Usage:
gps.x_position(units)

Parametrar	Beskrivning
enheter	Enheten för offsetvärdet: `INCHES` eller `MM`

y-position #

y_position returnerar den aktuella y-koordinaten för en GPS-sensor (Game Positioning System™) på planen.

Usage:
gps.y_position(units)

Parametrar	Beskrivning
enheter	Enheten för offsetvärdet: `INCHES` eller `MM`

rubrik #

heading returnerar den kurs som roboten för närvarande är vänd mot baserat på GPS-sensorns (Game Positioning System™) avläsningar från 0 till 359 grader.

Usage:
gps.heading()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.