Robotspecifik Python#

Introduktion #

Hero Bot, Swish, har ett motoralternativ, ett motorgruppalternativ och en optisk sensor.

Alla standardmetoder för VEXcode VR är tillgängliga för användning i IQ 24-25 Rapid Relay 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 så att den är vänd 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 - Rör dig och spåra robotens motor och motorgrupp.

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

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.

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`	Avståndsenheten: `INCHES` eller `MM` (millimeter).
`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():
    # 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 som roboten roterar. Detta kan vara ett heltal `integer` eller ett decimaltal (`float`).
`units`	Rotationsenheten: `DEGREES`.
`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 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`	Rotationsenheten: `DEGREES`.
`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`	Rotationsenheten: `DEGREES`.
`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`	Kursenheten: `DEGREES`.

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`	Rotationsenheten: `DEGREES`.

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`	Hastighetsenheten: `PERCENT`.

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`	Hastighetsenheten: `PERCENT`.

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`	Kursenheten: `DEGREES`.

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`	Rotationsenheten: `DEGREES`.

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`	Hastighetsenheten: `PERCENT`.

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 #

Swish använder insugningsmotorn för att samla bollar och flytta dem till katapulten. Katapultmotorgruppen sänks ner och släpper katapultarmen för att avfyra bollar.

Varje motor och motorgrupp har sitt eget riktningsbeteende. Riktningsbeskrivningarna förklarar hur varje riktning rör sig i den motorn eller motorgruppen på Swish.

Åtgärder #

snurra #

spin roterar en motor eller motorgrupp framåt eller bakåt för alltid. Motorn eller motorgruppen 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 motor- eller motorgruppobjekt kan användas med den här metoden, enligt nedan:

motor	Kommando
`intake_motor`	`intake_motor.spin(direction)` — Insugningsmotor
`catapult_group`	`catapult_group.spin(direction)` — Katapultgrupp

Parametrar

Beskrivning

direction

Den riktning som motorn eller motorgruppen roterar:

FORWARD — Snurrar insugningsmotorn i insugningsriktningen eller sänker katapultgruppen.
REVERSE — Snurrar insugningsmotorn i utsugningsriktningen eller släpper katapultgruppen.

def main():
    # Spin the Intake Motor to bring a Ball onto the Catapult
    intake_motor.spin(FORWARD)
    wait(2, SECONDS)
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

spin_for #

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

Användning:
Ett av två tillgängliga motor- eller motorgruppobjekt kan användas med den här metoden, enligt nedan:

motor	Kommando
`intake_motor`	`intake_motor.spin_for(direction, distance, units, wait=True)` — Insugningsmotor
`catapult_group`	`catapult_group.spin_for(direction, distance, units, wait=True)` — Katapultgrupp

Parametrar	Beskrivning
`direction`	Den riktning som motorn eller motorgruppen roterar: `FORWARD` — Snurrar insugningsmotorn i insugningsriktningen eller sänker katapultgruppen. `REVERSE` — Snurrar insugningsmotorn i utsugningsriktningen eller släpper katapultgruppen.
`distance`	Avståndet som motorn eller motorgruppen roterar. `DEGREES` använder 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 eller motorgruppen har snurrat klart innan nästa kodrad körs. `wait=False` — Gör att nästa kodrad körs direkt.

def main():
    # Release the preloaded Ball
    catapult_group.spin_for(REVERSE, 5, DEGREES)
    # Lower the Catapult to prepare to load another Ball
    catapult_group.spin_for(FORWARD, 1350, DEGREES)

# VR threads — Do not delete
vr_thread(main)

snurra_till_position #

spin_to_position snurrar en motor eller motorgrupp till en specifik position.

En motors eller motorgrupps 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 sätts motorns eller motorgruppens position till 0 grader. Motorns eller motorgruppens position kan också ställas in med metoden set_position.

Positionsvärdena är absoluta. Det betyder att rotationens riktning beror på motorns eller motorgruppens aktuella position.

Om motorn eller motorgruppen till exempel börjar 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 motor- eller motorgruppobjekt kan användas med den här metoden, enligt nedan:

motor	Kommando
`intake_motor`	`intake_motor.spin_to_position(angle, units, wait=True)` — Insugningsmotor
`catapult_group`	`catapult_group.spin_to_position(angle, units, wait=True)` — Katapultgrupp

Parametrar	Beskrivning
`angle`	Positionsvärdet som motorn eller motorgruppen 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 eller motorgruppen 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 eller motorgruppen 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 eller motorgruppen har snurrat klart innan nästa kodrad körs.
wait=False — Gör att nästa kodrad körs direkt.

def main():
    # Release the preloaded Ball
    catapult_group.spin_to_position(-90, DEGREES)
    # Lower the Catapult to prepare to load another Ball
    catapult_group.spin_to_position(1260, DEGREES)

# VR threads — Do not delete
vr_thread(main)

stoppa motorn #

stop stoppar en motor eller motorgrupp från att rotera.

Användning:
Ett av två tillgängliga motor- eller motorgruppobjekt kan användas med den här metoden, enligt nedan:

motor	Kommando
`intake_motor`	`intake_motor.stop()` — Insugningsmotor
`catapult_group`	`catapult_group.stop()` — Katapultgrupp

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

def main():
    # Spin the Intake Motor to bring a Ball onto the Catapult
    intake_motor.spin(FORWARD)
    wait(2, SECONDS)
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

Mutatorer #

set_position #

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

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

Användning:
Ett av två tillgängliga motor- eller motorgruppobjekt kan användas med den här metoden, enligt nedan:

motor	Kommando
`intake_motor`	`intake_motor.set_position(position, units)` — Insugningsmotor
`catapult_group`	`catapult_group.set_position(position, units)` — Katapultgrupp

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

def main():
    # Lower the Catapult to prepare to load another Ball
    catapult_group.spin_to_position(1260, DEGREES)
    # Set the new Catapult position to be 0 degrees
    catapult_group.set_position(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_velocity #

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

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

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

Användning:
Ett av två tillgängliga motor- eller motorgruppobjekt kan användas med den här metoden, enligt nedan:

motor	Kommando
`intake_motor`	`intake_motor.set_velocity(velocity, units)` — Insugningsmotor
`catapult_group`	`catapult_group.set_velocity(velocity, units)` — Katapultgrupp

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

def main():
    # Start spinning the Intake Motor to prepare for picking up a Ball
    intake_motor.set_velocity(100, PERCENT)
    intake_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

set_timeout #

set_timeout anger hur lång tid en motor eller motorgrupp ska försöka slutföra en rörelse. Om motorn eller motorgruppen 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 eller motorgruppen fastnar i en rörelse.

Användning:
Ett av två tillgängliga motor- eller motorgruppobjekt kan användas med den här metoden, enligt nedan:

motor	Kommando
`intake_motor`	`intake_motor.set_timeout(value, units)` — Insugningsmotor
`catapult_group`	`catapult_group.set_timeout(value, units)` — Katapultgrupp

Parametrar	Beskrivning
`value`	Den tid som motorn eller motorgruppen 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():
    # Limit how long the Catapult waits to reach its target
    catapult_group.set_timeout(2, SECONDS)
    catapult_group.spin_for(FORWARD, 2160, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Getters #

är_klar #

is_done returnerar huruvida motorn eller motorgruppen ä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 eller motorgruppens rörelse.

True — Motorn eller motorgruppen är klar med sin rörelse.
False — Motorn eller motorgruppen 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 motor- eller motorgruppobjekt kan användas med den här metoden, enligt nedan:

motor	Kommando
`intake_motor`	`intake_motor.is_done()` — Insugningsmotor
`catapult_group`	`catapult_group.is_done()` — Katapultgruppen

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

snurrar #

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

True — Motorn eller motorgruppen snurrar.
False — Motorn eller motorgruppen 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 motor- eller motorgruppobjekt kan användas med den här metoden, enligt nedan:

motor	Kommando
`intake_motor`	`intake_motor.is_spinning()` — Insugningsmotor
`catapult_group`	`catapult_group.is_spinning()` — Katapultgruppen

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

placera #

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

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

Användning:
Ett av två tillgängliga motor- eller motorgruppobjekt kan användas med den här metoden, enligt nedan:

motor	Kommando
`intake_motor`	`intake_motor.position(units)` — Insugningsmotor
`catapult_group`	`catapult_group.position(units)` — Katapultgrupp

Parametrar	Beskrivning
`units`	Enheten för att returnera motorns eller motorgruppens position i: `DEGREES` eller `TURNS`.

def main():
    # Lower the Catapult to prepare to load another Ball
    while not catapult_group.position(DEGREES) == 1260:
        catapult_group.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

hastighet #

velocity returnerar hur snabbt motorn eller motorgruppen roterar.

Ett positivt värde innebär att motorn eller motorgruppen roterar framåt. Ett negativt värde innebär att motorn eller motorgruppen roterar bakåt.

Användning:
Ett av två tillgängliga motor- eller motorgruppobjekt kan användas med den här metoden, enligt nedan:

motor	Kommando
`intake_motor`	`intake_motor.velocity(units)` — Insugningsmotor
`catapult_group`	`catapult_group.velocity(units)` — Katapultgrupp

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

def main():
    # Print the current Catapult velocity
    brain.screen.print(catapult_group.velocity(PERCENT))

# 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. Den beter sig som print på konsolens API-sida.

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 kommer att 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_rpm` `drivetrain.velocity_percent` Arm Motor `arm_motor.is_done` `arm_motor.is_spinning` `arm_motor.position_degrees` `arm_motor.position_turns` `arm_motor.velocity_rpm` `arm_motor.velocity_percent` Arm Motor Group `arm_motor_group.is_done` `arm_motor_group.is_spinning` `arm_motor_group.position_degrees` `arm_motor_group.position_turns` `arm_motor_group.velocity_rpm` `arm_motor_group.velocity_percent` Intake Motor `intake_motor.is_done` `intake_motor.is_spinning` `intake_motor.position_degrees` `intake_motor.position_turns` `intake_motor.velocity_rpm` `intake_motor.velocity_percent` Intake Motor Group `intake_motor_group.is_done` `intake_motor_group.is_spinning` `intake_motor_group.position_degrees` `intake_motor_group.position_turns` `intake_motor_group.velocity_rpm` `intake_motor_group.velocity_percent` Catapult Motor `catapult_motor.is_done` `catapult_motor.is_spinning` `catapult_motor.position_degrees` `catapult_motor.position_turns` `catapult_motor.velocity_rpm` `catapult_motor.velocity_percent` Catapult Tension Motor `catapult_tension_motor.is_done` `catapult_tension_motor.is_spinning` `catapult_tension_motor.position_degrees` `catapult_tension_motor.position_turns` `catapult_tension_motor.velocity_rpm` `catapult_tension_motor.velocity_percent` Bumpers `intake_bumper.pressing` `bumper.pressing` 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` Color Sensor `color.is_near_object` `color.color` `color.brightness` `color.hue`

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_rpm
- drivetrain.velocity_percent
Arm Motor
- arm_motor.is_done
- arm_motor.is_spinning
- arm_motor.position_degrees
- arm_motor.position_turns
- arm_motor.velocity_rpm
- arm_motor.velocity_percent
Arm Motor Group
- arm_motor_group.is_done
- arm_motor_group.is_spinning
- arm_motor_group.position_degrees
- arm_motor_group.position_turns
- arm_motor_group.velocity_rpm
- arm_motor_group.velocity_percent
Intake Motor
- intake_motor.is_done
- intake_motor.is_spinning
- intake_motor.position_degrees
- intake_motor.position_turns
- intake_motor.velocity_rpm
- intake_motor.velocity_percent
Intake Motor Group
- intake_motor_group.is_done
- intake_motor_group.is_spinning
- intake_motor_group.position_degrees
- intake_motor_group.position_turns
- intake_motor_group.velocity_rpm
- intake_motor_group.velocity_percent
Catapult Motor
- catapult_motor.is_done
- catapult_motor.is_spinning
- catapult_motor.position_degrees
- catapult_motor.position_turns
- catapult_motor.velocity_rpm
- catapult_motor.velocity_percent
Catapult Tension Motor
- catapult_tension_motor.is_done
- catapult_tension_motor.is_spinning
- catapult_tension_motor.position_degrees
- catapult_tension_motor.position_turns
- catapult_tension_motor.velocity_rpm
- catapult_tension_motor.velocity_percent
Bumpers
- intake_bumper.pressing
- bumper.pressing
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
Color Sensor
- color.is_near_object
- color.color
- color.brightness
- color.hue

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:
intake_optical.is_near_object()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

def main():
    # Launch a loaded Ball once the Intake Optical Sensor detects a Ball
    if intake_optical.is_near_object():
        catapult_group.spin_for(REVERSE, 5, DEGREES)

# 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:
intake_optical.color()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

def main():
    # Launch a loaded Ball once yellow is detected in the Intake
    if intake_optical.color() == YELLOW:
        catapult_group.spin_for(REVERSE, 5, DEGREES)

# 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:
intake_optical.brightness()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

def main():
    # Launch a loaded Ball once the Intake Optical Sensor sees a Ball
    if intake_optical.brightness() > 0:
        catapult_group.spin_for(REVERSE, 5, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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 grader högst upp till 360 grader.

Usage:
intake_optical.hue()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

def main():
    # Launch a loaded Ball once the Intake Optical Sensor reports a hue value
    if intake_optical.hue() > 100:
        catapult_group.spin_for(REVERSE, 5, DEGREES)

# 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:
intake_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.

def launch_ball():
    catapult_group.spin_for(REVERSE, 5, DEGREES)

def main():
    # Launch the Ball when the Intake Optical Sensor detects an object
    intake_optical.object_detected(launch_ball)

# VR threads — Do not delete
vr_thread(main)

objekt_förlorat #

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

Usage:
intake_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.

def lower_catapult():
    catapult_group.spin_to_position(1260, DEGREES)

def main():
    # Lower the Catapult when the Intake Optical Sensor no longer detects an object
    intake_optical.object_lost(lower_catapult)

# VR threads — Do not delete
vr_thread(main)