Robotspecifik Python#

Introduktion #

Hero Bot, Byte, har två motorgruppsalternativ och en optisk sensor.

Alla standardmetoder för VEXcode VR är tillgängliga för användning i IQ 23-24 Full Volume 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 – Rör dig och spåra robotens motorgrupper.

Åtgärder
- spin — Snurrar en motorgrupp framåt eller bakåt i all oändlighet.
- spin_for — Snurrar en motorgrupp ett visst avstånd.
- spin_to_position — Roterar en motorgrupp till en specifik position.
- stop — Stoppar en motorgrupp från att snurra.
Mutatorer
- set_position — Ändrar motorgruppens aktuella position till ett nytt värde.
- set_velocity — Anger för en motorgrupp hur snabbt den ska snurra.
- set_timeout — Anger hur lång tid en motorgrupp ska försöka slutföra en rörelse.
Hämtarna
- is_done — Returnerar om motorgruppen är klar med sin rörelse, som ett booleskt värde.
- is_spinning — Returnerar om motorgruppen snurrar, som ett booleskt värde.
- position — Returnerar motorgruppens aktuella position.
- velocity — Returnerar hur snabbt 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`	Valfritt. Avståndsenheten: `INCHES` (standard) 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 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 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`	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 #

Byte använder armmotorgruppen för att höja och sänka armen så att block kan transporteras. Insugningsmotorgruppen snurrar framhjulen för att samla in block, eller backar för att plocka upp eller släppa dem.

Varje motorgrupp har sitt eget riktningsbeteende. Riktningsbeskrivningarna förklarar hur varje riktning rör motorgruppen på Byte.

Åtgärder #

snurra #

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

motor	Kommando
`arm_motor_group`	`arm_motor_group.spin(direction)` — Armmotorgrupp
`intake_motor_group`	`intake_motor_group.spin(direction)` — Insugningsmotorgrupp

Parametrar

Beskrivning

direction

Motorgruppens rotationsriktning:

FORWARD — Höjer armmotorgruppen eller roterar insugningsmotorgruppen i insugningsriktningen.
REVERSE — Sänker armmotorgruppen eller roterar insugningsmotorgruppen i utsugningsriktningen.

def main():
    # Spin the intake motor forward then stop
    intake_motor_group.spin(FORWARD)
    wait(0.5, SECONDS)
    intake_motor_group.stop()

# VR threads — Do not delete
vr_thread(main)

spin_for #

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

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

motor	Kommando
`arm_motor_group`	`arm_motor_group.spin_for(direction, distance, units, wait)` — Armmotorgrupp
`intake_motor_group`	`intake_motor_group.spin_for(direction, distance, units, wait)` — Insugningsmotorgrupp

Parametrar	Beskrivning
`direction`	Motorgruppens rotationsriktning: `FORWARD` — Höjer armmotorgruppen eller roterar insugningsmotorgruppen i insugningsriktningen. `REVERSE` — Sänker armmotorgruppen eller roterar insugningsmotorgruppen i utsugningsriktningen.
`distance`	Avståndet motorgruppen snurrar. `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 motorgruppen har snurrat klart innan nästa kodrad körs. `wait=False` — Gör att nästa kodrad körs direkt.

def main():
    # Spin the intake motor forward then stop
    intake_motor_group.spin_for(FORWARD, 360, DEGREES)

# VR threads — Do not delete
vr_thread(main)

snurra_till_position #

spin_to_position snurrar en motorgrupp till en specifik position.

En 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 är motorgruppens position inställd på 0 grader. Motorgruppens position kan också ställas in med metoden set_position.

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

Om motorgruppen till exempel börjar vid 0 grader och snurrar till en position på 720 grader, kommer den att snurra framåt två varv. Om den sedan snurrar till en position på 360 grader, kommer den att snurra bakåt ett varv, eftersom 360 är mindre än 720.

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

motor	Kommando
`arm_motor_group`	`arm_motor_group.spin_to_position(angle, units, wait=True)` — Armmotorgrupp
`intake_motor_group`	`intake_motor_group.spin_to_position(angle, units, wait=True)` — Insugningsmotorgrupp

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

def main():
    # Spin the intake motor forward then stop
    intake_motor_group.spin_to_position(55, DEGREES)

# VR threads — Do not delete
vr_thread(main)

stopp #

stop stoppar en motorgrupp från att snurra.

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

motor	Kommando
`arm_motor_group`	`arm_motor_group.stop()` — Armmotorgrupp
`intake_motor_group`	`intake_motor_group.stop()` — Insugningsmotorgrupp

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

def main():
    # Spin the intake motor forward then stop
    intake_motor_group.spin(FORWARD)
    wait(0.5, SECONDS)
    intake_motor_group.stop()

# VR threads — Do not delete
vr_thread(main)

Mutatorer #

set_position #

En 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 motorgruppens nuvarande position till ett nytt värde.

Om till exempel en 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. Sedan kan motorgruppen snurra till positioner baserat på det nya värdet.

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

motor	Kommando
`arm_motor_group`	`arm_motor_group.set_position(position, units)` — Armmotorgrupp
`intake_motor_group`	`intake_motor_group.set_position(position, units)` — Insugningsmotorgrupp

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

def main():
    # Set the current motor position to 90 degrees
    intake_motor_group.set_position(90, DEGREES)
    # Spin the intake motor back to 0 degrees
    intake_motor_group.spin_to_position(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_velocity #

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

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

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

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

motor	Kommando
`arm_motor_group`	`arm_motor_group.set_velocity(velocity, units)` — Armmotorgrupp
`intake_motor_group`	`intake_motor_group.set_velocity(velocity, units)` — Insugningsmotorgrupp

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():
    # Spin the intake motor forward then stop
    intake_motor_group.set_velocity(75, PERCENT)
    intake_motor_group.spin_to_position(180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_timeout #

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

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

motor	Kommando
`arm_motor_group`	`arm_motor_group.set_timeout(value, units)` — Armera motorgrupp
`intake_motor_group`	`intake_motor_group.set_timeout(value, units)` — Insugningsmotorgrupp

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

def main():
    # Spin the intake motor forward then stop
    intake_motor_group.set_timeout(2, SECONDS)
    intake_motor_group.spin_to_position(270, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Getters #

är_klar #

is_done returnerar huruvida 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å motorgruppens rörelse.

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

motor	Kommando
`arm_motor_group`	`arm_motor_group.is_done()` — Armmotorgrupp
`intake_motor_group`	`intake_motor_group.is_done()` — Insugningsmotorgrupp

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

snurrar #

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

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

motor	Kommando
`arm_motor_group`	`arm_motor_group.is_spinning()` — Armmotorgrupp
`intake_motor_group`	`intake_motor_group.is_spinning()` — Insugningsmotorgrupp

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

placera #

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

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

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

motor	Kommando
`arm_motor_group`	`arm_motor_group.position(units)` — Armmotorgrupp
`intake_motor_group`	`intake_motor_group.position(units)` — Insugningsmotorgrupp

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

hastighet #

velocity returnerar hur snabbt motorgruppen roterar.

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

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

motor	Kommando
`arm_motor_group`	`arm_motor_group.velocity(units)` — Armmotorgrupp
`intake_motor_group`	`intake_motor_group.velocity(units)` — Insugningsmotorgrupp

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

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

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

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

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

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:
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:
optical.hue()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

objekt_upptäckt #

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

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