Robotspecifikus Python

Bevezetés

A Flex nevű hősbot tartalmaz egy karommotort, egy karmotort, egy mesterséges intelligenciával működő látószenzort, egy távolságérzékelőt és egy GPS-érzékelőt.

Minden szabványos VEXcode VR metódus elérhető a V5 26-27 Override Playgroundban.

Az alábbiakban felsoroljuk az összes elérhető robotspecifikus módszert:

Hajtáslánc – Mozgasd és forgatd a robotot.

• Műveletek

  • drive — A robotot előre vagy hátra mozgatja örökké.

  • drive_for — Meghatározott távolságra mozgatja a robotot előre vagy hátra.

  • turn — Örökké balra vagy jobbra forgatja a robotot.

  • turn_for — Meghatározott fokkal balra vagy jobbra forgatja a robotot.

  • turn_to_heading — A robotot egy adott irányba fordítja -359 és 359 fok között.

  • turn_to_rotation — Meghatározott forgásirányba fordítja a robotot.

  • stop — Leállítja a robot mozgását.

• Mutátorok

  • set_heading — A robot aktuális irányát egy új irányra módosítja.

  • set_rotation — A robot aktuális forgását egy új forgásra módosítja.

  • set_timeout — Beállítja, hogy mennyi idő alatt próbálja meg a robot befejezni a mozgást.

  • set_drive_velocity — Megadja a robotnak a haladási sebességét.

  • set_turn_velocity — Megadja a robotnak, hogy milyen gyorsan forduljon.

• Getterek

  • heading — Visszaadja a robot aktuális irányát 0 és 359,99 fok között.

  • rotation — Visszaadja a robot aktuális forgását.

  • is_done — Logikai értékként adja vissza, hogy a robot befejezte-e a mozgást.

  • is_moving — Logikai értékként adja vissza, hogy a robot mozog-e.

  • velocity — Visszaadja a robot sebességét.

Mozgás – Mozgasd és kövesd a robot motorjait.

• Műveletek

  • spin — Előre vagy hátra forgatja a motort örökké.

  • spin_for — Megadott távolságon keresztül megpörgeti a motort.

  • spin_to_position — Egy motort egy adott pozícióba forgat.

  • stop — Leállítja a motor forgását.

• Mutátorok

  • set_position — A motor aktuális pozícióját új értékre módosítja.

  • set_velocity — Megadja a motornak a forgási sebességét.

  • set_timeout — Beállítja, hogy mennyi idő alatt próbálja meg a motor befejezni a mozgást.

• Getterek

  • is_done — Logikai értékként adja vissza, hogy a motor mozgása befejeződött-e.

  • is_spinning — Logikai értékként adja vissza, hogy a motor forog-e.

  • position — Visszaadja a motor aktuális pozícióját.

  • velocity — Visszaadja a motor forgási sebességét.

AI Vision – Rögzítsen és elemezzen tárgyakat az AI látásérzékelővel.

• Getterek

  • take_snapshot – Egy adott aláíráshoz tartozó észlelt objektumok egy tuple-jét adja vissza.

• Ingatlanok

  • .width – A detektált objektum szélessége pixelben.

  • .height – A detektált objektum magassága pixelben.

  • .centerX – Az objektum középpontjának X pozíciója pixelben.

  • .centerY – Az objektum középpontjának Y pozíciója pixelben.

  • .originX – Az objektum bal felső sarkának X pozíciója pixelben.

  • .originY – Az objektum bal felső sarkának Y pozíciója pixelben.

  • .id – Az észlelt objektum osztályozási azonosítója.

Konzol – Kiíratja a konzolra és figyeli az értékeket.

• Nyomtatás

  • brain.screen.print — Szöveget, számokat vagy változóértékeket jelenít meg a konzolon.

  • brain.screen.next_row — A konzol kurzorát a következő sor elejére mozgatja.

  • brain.screen.clear_screen — Törli az összes sort a konzolból.

• Monitor

  • monitor_variable — Egy vagy több előre definiált változót ad hozzá a Monitor laphoz.

  • monitor_sensor — Egy vagy több érzékelőértéket ad hozzá a Monitor fülhöz.

Érzékelés – Használja a robot különféle érzékelőit.

• Távolság

  • found_object – Visszaadja, hogy a távolságérzékelő érzékel-e tárgyat a hatótávolságon belül.

  • object_distance – Visszaadja a távolságérzékelő és a legközelebbi érzékelt tárgy közötti távolságot.

• GPS

  • x_position – Visszaadja a GPS-érzékelő aktuális x koordinátáját a terepen.

  • y_position – Visszaadja a GPS-érzékelő aktuális y koordinátáját a terepen.

  • heading – Visszaadja a robot aktuális haladási irányát a GPS-érzékelő alapján.

Az ezen az oldalon található példák a Játszótér mérkőzés előtti ellenőrzőlistájának C kezdőhelyszínét használják.

Hajtáslánc

A hajtáslánc vezérli a VR Robot vezetését és fordulását. A hajtáslánc előre vagy hátra mozoghat, balra vagy jobbra fordulhat, irányt vehet, és nyomon követheti a forgását.

Műveletek

hajtás

drive A robotot a végtelenségig előre vagy hátra mozgatja. A robot addig fog mozogni, amíg egy másik műveletet nem kap, például fordulást vagy megállást.

Usage:
drivetrain.drive(direction)

Paraméterek	Leírás
direction	A robot mozgásiránya: FORWARD vagy REVERSE.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive(FORWARD)
    wait(0.5, SECONDS)
    drivetrain.stop()
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

drive_for

drive_for paraméterrel a robot előre vagy hátra mozgatható egy adott távolságra. A projekt megvárja, amíg a robot befejezi a mozgást, mielőtt a következő kódsort futtatná.

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

Paraméterek	Leírás
direction	A robot mozgásiránya: FORWARD vagy REVERSE.
distance	A robot által megtett távolság. Ez lehet integer vagy decimális (float).
units	Opcionális. A távolság mértékegysége: INCHES (alapértelmezett) vagy MM (milliméter).
wait	Opcionális. wait=True (alapértelmezett) esetén a projekt megvárja, amíg a robot befejezi a mozgást, mielőtt a következő kódsor lefutna. wait=False esetén a következő kódsor azonnal lefut.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

fordulat

turn : A robotot balra vagy jobbra forgatja örökre. A robot addig fog forogni, amíg egy másik műveletet nem kap, például vezetést vagy megállást.

Usage:
drivetrain.turn(direction)

Paraméterek	Leírás
direction	A robot fordulási iránya: LEFT vagy RIGHT.

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn(LEFT)
    wait(0.78, SECONDS)
    drivetrain.stop()
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

fordulj_hoz

turn_for paraméterrel a robot balra vagy jobbra forgatható egy megadott fokkal. A forgatás a robot aktuális pozíciójához viszonyított. A projekt megvárja, amíg a robot befejezi a fordulást, mielőtt a következő kódsort futtatná.

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

Paraméterek	Leírás
direction	A robot fordulási iránya: LEFT vagy RIGHT.
angle	A robot fordulatainak száma fokokban. Ez lehet integer vagy decimális (float).
units	Opcionális. A szög mértékegysége: DEGREES (alapértelmezett).
wait	Opcionális. wait=True (alapértelmezett) esetén a projekt megvárja, amíg a robot befejezi a forgást, mielőtt a következő kódsor lefutna. wait=False esetén a következő kódsor azonnal lefut.

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

fordulj_felé

A haladási irány az az irány, amerre a robot néz, fokban mérve. turn_to_heading A „turn_to_heading” (fordulás) beállításnál az 1-es érték a robotot egy adott, -359 és 359 fok közötti irányba fordítja. A robot a legrövidebb irányba fordul, hogy elérje a célirányt.

A kezdő irány 0 fok.

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

Paraméterek	Leírás
heading	A robot iránya, amellyel szembe kell néznie, -359 és 359 fok között.
units	Opcionális. A szög mértékegysége: DEGREES (alapértelmezett).
wait	Opcionális. wait=True (alapértelmezett) esetén a projekt megvárja, amíg a robot befejezi a forgást, mielőtt a következő kódsor lefutna. wait=False esetén a következő kódsor azonnal lefut.

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_to_heading(-110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

fordulat_forgásig

turn_to_rotation A robotot egy adott forgáspontra forgatja.

A forgás a robot fordulatának mértékét mutatja fokban mérve. A projekt elején a forgási érték 0 fokra van állítva. Jobbra forgatás növeli, balra forgatás pedig csökkenti a forgást.

Például, ha a robot 0 fokról indul, és 720 fokos elfordulást végez, akkor kétszer fordul jobbra. Ha ezután 360 fokos elfordulást végez, akkor egyszer fordul balra, mivel a 360 fok kisebb, mint a 720 fok.

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

Paraméterek	Leírás
rotation	A robot elfordulási értéke fokban megadva. Ez lehet integer vagy decimális (float).
units	Opcionális. A szög mértékegysége: DEGREES (alapértelmezett).
wait	Opcionális. wait=True (alapértelmezett) esetén a projekt megvárja, amíg a robot befejezi a forgást, mielőtt a következő kódsor lefutna. wait=False esetén a következő kódsor azonnal lefut.

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_to_rotation(-110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Stop

stop leállítja a robot mozgását.

Usage:
drivetrain.stop()

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn(LEFT)
    wait(0.78, SECONDS)
    drivetrain.stop()
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Mutátorok

set_heading

A haladási irány a robot felé néző irány, fokban mérve. set_heading a robot aktuális haladási irányát egy új haladási értékre módosítja.

Például, ha a robot jobbra fordult, és a haladási irány 0 fokra állítása a jobbra néző pozíciót teszi az új 0 fokossá. Ezután a robot az új irány alapján más pozíciókba fordulhat.

Usage:
drivetrain.set_heading(heading, units)

Paraméterek	Leírás
heading	A robot számára beállítandó irányérték fokban.
units	Opcionális. A szög mértékegysége: DEGREES (alapértelmezett).

def main():
    # Make facing the Neutral Goal the new heading
    drivetrain.set_heading(110, DEGREES)
    drivetrain.turn_to_heading(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

forgatás beállítása

A forgás a robot fordulatát mutatja fokban mérve. set_rotation paraméterrel a robot aktuális forgását egy új értékre módosítja.

Usage:
drivetrain.set_rotation(rotation, units)

Paraméterek	Leírás
rotation	A robothoz beállítandó forgatási érték fokban. Ez lehet integer vagy decimális (float).
units	Opcionális. A szög mértékegysége: DEGREES (alapértelmezett).

def main():
    # Make facing the Neutral Goal the new rotation
    drivetrain.set_rotation(110, DEGREES)
    drivetrain.turn_to_rotation(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

időkorlát beállítása

set_timeout beállítja, hogy a robot hány másodpercig próbáljon meg befejezni egy mozgást. Ha a robot nem tudja befejezni ennyi idő alatt, akkor leállítja a próbálkozást, és a kód következő sorára lép. Ez megakadályozza, hogy a robot elakadjon egy mozgásnál.

Usage:
drivetrain.set_timeout(time, units)

Paraméterek	Leírás
time	Az az időtartam másodpercben, amíg a robot megpróbálhat befejezni egy mozgást. Ez lehet pozitív integer vagy decimális (float).
units	Opcionális. Az időegység: SECONDS (alapértelmezett) vagy MSEC.

def main():
    # Turn to face the Neutral Goal
    drivetrain.set_timeout(0.8, SECONDS)
    drivetrain.turn_for(LEFT, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_drive_velocity

set_drive_velocity megmondja a robotnak, hogy milyen gyorsan haladjon. Magasabb százalékos érték esetén a robot gyorsabban, alacsonyabb százalékos érték esetén pedig lassabban halad.

Minden projekt azzal kezdődik, hogy a robot alapértelmezés szerint 50%-os sebességgel halad.

Megjegyzés: A nagyobb sebesség gyorsabbá teszi a robotot, de kevésbé pontos lehet. Az alacsonyabb sebesség lassabbá teszi a robotot, de pontosabb lehet.

Usage:
drivetrain.set_drive_velocity(velocity, units)

Paraméterek	Leírás
velocity	A hajtandó sebesség 0%-tól 100%-ig. Ez lehet integer vagy decimális (float).
units	Opcionális. A sebesség mértékegysége: PERCENT (alapértelmezett).

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.set_drive_velocity(100, PERCENT)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

fordulási_sebesség_beállítása

set_turn_velocity megmondja a robotnak, hogy milyen gyorsan forduljon. Magasabb százalékos érték esetén a robot gyorsabban, alacsonyabb százalékos érték esetén pedig lassabban fordul.

Minden projekt azzal kezdődik, hogy a robot alapértelmezés szerint 50%-os sebességgel forog.

Megjegyzés: A nagyobb sebesség gyorsabbá teszi a robot fordulását, de kevésbé pontos lehet. Az alacsonyabb sebesség lassabbá teszi a robot fordulását, de pontosabb lehet.

Usage:
drivetrain.set_turn_velocity(velocity, units)

Paraméterek	Leírás
velocity	A fordulatszám 0%-tól 100%-ig. Ez lehet integer vagy decimális (float).
units	Opcionális. A sebesség mértékegysége: PERCENT (alapértelmezett).

def main():
    # Turn to face the Neutral Goal faster
    drivetrain.set_turn_velocity(100, PERCENT)
    drivetrain.turn_for(LEFT, 110, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Getterek

cím

A haladási irány a robot irányát jelöli, fokban mérve. heading a robot aktuális haladási irányát adja vissza 0 és 359,99 fok között.

A robot kezdő iránya 0 fok.

Usage:
drivetrain.heading(units)

Paraméterek	Leírás
units	Opcionális. Az irány mértékegysége: DEGREES (alapértelmezett).

def main():
    # Turn to the Goal, then show heading
    drivetrain.turn_for(LEFT, 110, DEGREES)
    brain.screen.print("Heading: ")
    brain.screen.print(drivetrain.heading(DEGREES))

# VR threads — Do not delete
vr_thread(main)

forgás

A forgás a robot elfordulásának mértékét adja meg fokban mérve. A projekt elején a forgás értéke 0 fok. rotation értéket adja vissza a robot aktuális forgását.

Jobbra fordulás növeli, balra fordulás pedig csökkenti az elfordulást. Például két teljes jobbra fordulás 720 fokos elfordulást eredményez.

Usage:
drivetrain.rotation(units)

Paraméterek	Leírás
units	Opcionális. Az elforgatás mértékegysége: DEGREES (alapértelmezett).

def main():
    # Spin to find a Pin, then show rotation
    drivetrain.turn_for(RIGHT, 450, DEGREES)
    brain.screen.print("Rotation: ")
    brain.screen.print(drivetrain.rotation(DEGREES))

# VR threads — Do not delete
vr_thread(main)

kész

is_done Logikai értékként adja vissza, hogy a robot befejezte-e a mozgást. Ez felhasználható más viselkedések időzítésének szabályozására a robot mozgása alapján.

• True — A robot mozgása befejeződött.

• False — A robot még mindig mozog.

Ez a metódus a következő wait paraméterrel rendelkező Drivetrain metódusokkal működik együtt: drive_for, turn_for, turn_to_heading, és turn_to_rotation.

Usage:
drivetrain.is_done()

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES, wait=False)
    wait(0.5, SECONDS)
    while not drivetrain.is_done():
        wait(5, MSEC)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

mozgásban van

is_moving Logikai értékként adja vissza, hogy a robot mozog-e. Ez felhasználható más viselkedések időzítésének szabályozására a robot mozgása alapján.

• True — A robot mozog.

• False — A robot nem mozog.

Usage:
drivetrain.is_moving()

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

def main():
    # Raise the Arm once stopped near the Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES, wait=False)
    wait (0.5, SEC)
    while drivetrain.is_moving():
        wait(5, MSEC)
    arm_motor.spin_for(FORWARD, 800, DEGREES)

# VR threads — Do not delete
vr_thread(main)

sebesség

velocity Visszaadja a robot haladási sebességét százalékban, -100%-tól 100%-ig.

Usage:
drivetrain.velocity(units)

Paraméterek	Leírás
units	Opcionális. A sebesség mértékegysége: PERCENT (alapértelmezett).

def main():
    # Show speed while driving to the Goal
    drivetrain.drive_for(FORWARD, 150, MM)
    brain.screen.print("Velocity: ")
    brain.screen.print(drivetrain.velocity(PERCENT))

# VR threads — Do not delete
vr_thread(main)

Mozgás

A Flex a karmotort használja a kar felemeléséhez és leengedéséhez, a karommotort pedig a karom nyitásához és zárásához.

Minden motornak megvan a saját irányviselkedése. Az irányleírások elmagyarázzák, hogy az egyes irányok hogyan mozgatják a motort a Flexen.

Műveletek

pörgés

spin A motort két irány egyikében örökké forgatja. A motor addig forog, amíg egy másik műveletet nem kap, például egy másik irányba forgatást vagy leállítást.

Használat:
Két elérhető motoros objektum egyike használható ezzel a módszerrel, az alábbiak szerint:

motor	Parancs
arm_motor	arm_motor.spin(direction) — Karmotor
claw_motor	claw_motor.spin(direction) — Karmos motor

Paraméterek	Leírás
direction	A motor forgásiránya: FORWARD — Felfelé mozgatja a karmotort, vagy bezárja a karommotort. REVERSE — Lefelé mozgatja a karmotort, vagy kinyitja a karommotort.

def main():
    # Raise the Arm before driving toward a Pin
    arm_motor.spin(FORWARD)
    wait(1, SECONDS)
    arm_motor.stop()

# VR threads — Do not delete
vr_thread(main)

pörgetés_célra

spin_for Megadott távolságon keresztül megforgatja a motort. A pörgés a motor aktuális pozíciójához képest értendő. A projekt megvárja, amíg a motor befejezi a forgást, mielőtt a kód következő sora lefutna.

Használat:
Két elérhető motoros objektum egyike használható ezzel a módszerrel, az alábbiak szerint:

motor	Parancs
arm_motor	arm_motor.spin_for(direction, distance, units, wait) — Karmotor
claw_motor	claw_motor.spin_for(direction, distance, units, wait) — Karmos Motor

Paraméterek	Leírás
direction	A motor forgásiránya: FORWARD — Felfelé mozgatja a karmotort, vagy bezárja a karommotort. REVERSE — Lefelé mozgatja a karmotort, vagy kinyitja a karommotort.
distance	A motor forgási távolsága. DEGREES egész számokat használjon. TURNS egész vagy tizedes törteket használhat.
units	Opcionális. A távolság mértékegysége: DEGREES (alapértelmezett) vagy TURNS.
wait	Opcionális. wait=True (alapértelmezett) — A projekt megvárja, amíg a motor forgása befejeződik, mielőtt a következő sor futna. wait=False — Azonnal futtatja a következő kódsort.

def main():
    # Raise the Arm to carry the Pin to the Goal
    arm_motor.spin_for(FORWARD, 800, DEGREES)

# VR threads — Do not delete
vr_thread(main)

pörgetés_pozícióba

spin_to_position Egy motort egy adott pozícióba forgat.

Egy motor helyzete azt jelzi, hogy milyen messzire fordult el, DEGREES vagy TURNSegységben mérve. Egy fordulat 360 foknak felel meg. A projekt elején a Karmotor helyzete 0 fokra van állítva. A Karmos Motor kivétel – 467 foknál indul (teljesen zárt állapotban). A motor helyzete a set_position metódussal is beállítható.

A pozícióértékek abszolútak. Ez azt jelenti, hogy a forgás iránya a motor aktuális pozíciójától függ.

Például, ha a motor 0 foknál indul és 720 fokos pozícióig forog, akkor két fordulatot előre forog. Ha ezután 360 fokos pozícióig forog, akkor egy fordulatot hátra forog, mert a 360 fok kisebb, mint 720.

Használat:
Két elérhető motoros objektum egyike használható ezzel a módszerrel, az alábbiak szerint:

motor	Parancs
arm_motor	arm_motor.spin_to_position(angle, units, wait=True) — Karmotor
claw_motor	claw_motor.spin_to_position(angle, units, wait=True) — Karmos motor

Paraméterek	Leírás
angle	A motor forgási pozíciója. DEGREES egész számokat használjon. TURNS egész vagy tizedes törteket használhat.
units	Opcionális. A pozíció mértékegysége: DEGREES (alapértelmezett) vagy TURNS.
wait	Opcionális. wait=True (alapértelmezett) — A projekt megvárja, amíg a motor forgása befejeződik, mielőtt a következő sor futna. wait=False — Azonnal futtatja a következő kódsort.

def main():
    # Raise the Arm, then release the Pin
    arm_motor.spin_to_position(800, DEGREES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Stop

stop leállítja a motor forgását.

Használat:
Két elérhető motoros objektum egyike használható ezzel a módszerrel, az alábbiak szerint:

motor	Parancs
arm_motor	arm_motor.stop() — Karmotor
claw_motor	claw_motor.stop() — Karmos motor

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

def main():
    # Raise the Arm partway to hold the Pin
    arm_motor.spin(FORWARD)
    wait(1, SECONDS)
    arm_motor.stop()

# VR threads — Do not delete
vr_thread(main)

Mutátorok

beállított_pozíció

Egy motor pozíciója azt mutatja meg, hogy milyen messzire fordult meg, DEGREES vagy TURNSegységben mérve. Egy fordulat 360 foknak felel meg. set_position parancs a motor aktuális pozícióját egy új értékre módosítja.

Például, ha egy motor 180 fokra forgott, a pozíció 0 fokra állítása visszaállítja ezt a pozíciót 180-ról 0 fokra. Ezután a motor az új érték alapján foroghat a pozíciókba.

Használat:
Két elérhető motoros objektum egyike használható ezzel a módszerrel, az alábbiak szerint:

motor	Parancs
arm_motor	arm_motor.set_position(position, units) — Karmotor
claw_motor	claw_motor.set_position(position, units) — Karmos motor

Paraméterek	Leírás
position	A motorhoz beállítandó pozícióérték. DEGREES egész számokat használjon. TURNS egész vagy tizedes törteket használhat.
units	Opcionális. A pozíció mértékegysége: DEGREES (alapértelmezett) vagy TURNS.

def main():
    # Reset encoder, raise Arm, place Pin
    arm_motor.set_position(0, DEGREES)
    arm_motor.spin_to_position(800, DEGREES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_velocity

set_velocity megmondja a motornak, hogy milyen gyorsan forogjon. Magasabb százalékos érték esetén a motor gyorsabban, alacsonyabb százalékos érték esetén pedig lassabban forog.

Minden projekt úgy kezdődik, hogy minden motor alapértelmezés szerint 50%-os sebességgel forog.

Megjegyzés: A nagyobb sebesség gyorsabban forog a motorban, de kevésbé pontos lehet. Az alacsonyabb sebesség lassítja a motor forgását, de pontosabb lehet.

Használat:
Két elérhető motoros objektum egyike használható ezzel a módszerrel, az alábbiak szerint:

motor	Parancs
arm_motor	arm_motor.set_velocity(velocity, units) — Karmotor
claw_motor	claw_motor.set_velocity(velocity, units) — Karmos motor

Paraméterek	Leírás
velocity	A forgási sebesség 0%-tól 100%-ig. Ez lehet integer vagy decimális (float).
units	A sebesség mértékegysége: PERCENT.

def main():
    # Raise the Arm fast to release the Pin
    arm_motor.set_velocity(100, PERCENT)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

időkorlát beállítása

set_timeout beállítja, hogy mennyi idő alatt próbáljon meg egy motor befejezni egy mozgást. Ha a motor nem tud befejezni ennyi idő alatt, akkor leállítja a próbálkozást, és a kód következő sorára ugrik. Ez megakadályozza, hogy a motor elakadjon egy mozgásnál.

Használat:
Két elérhető motoros objektum egyike használható ezzel a módszerrel, az alábbiak szerint:

motor	Parancs
arm_motor	arm_motor.set_timeout(value, units) — Motor élesítés
claw_motor	claw_motor.set_timeout(value, units) — Karmos motor

Paraméterek	Leírás
value	Az az időtartam, ameddig a motor megpróbálhat befejezni egy mozgást. Ez lehet pozitív integer vagy decimális (float).
units	Az időegység: SECONDS vagy MSEC (milliszekundum).

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    arm_motor.set_timeout(1, SECONDS)
    arm_motor.spin_for(FORWARD, 1800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Getterek

kész

is_done logikai értékként adja vissza, hogy a motor mozgása befejeződött-e. Ez felhasználható más viselkedések időzítésének szabályozására a motor mozgása alapján.

• True — A motor mozgása befejeződött.

• False — A motor még mindig mozog.

Ez a metódus a következő wait paraméterrel rendelkező Motion metódusokkal működik együtt: spin_for és spin_to_position.

Használat:
Két elérhető motoros objektum egyike használható ezzel a módszerrel, az alábbiak szerint:

motor	Parancs
arm_motor	arm_motor.is_done() — Karmotor
claw_motor	claw_motor.is_done() — Karmos motor

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

def main():
    # Raise the Arm while driving to the Goal
    arm_motor.spin_to_position(800, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while not arm_motor.is_done():
        drivetrain.drive(FORWARD)
        wait(5, MSEC)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

forog

is_spinning logikai értékként adja vissza, hogy a motor forog-e. Ez felhasználható más viselkedések időzítésének szabályozására a motor mozgása alapján.

• True — A motor forog.

• False — A motor nem forog.

Ez a metódus a következő wait paraméterrel rendelkező Motion metódusokkal működik együtt: spin_for és spin_to_position.

Használat:
Két elérhető motoros objektum egyike használható ezzel a módszerrel, az alábbiak szerint:

motor	Parancs
arm_motor	arm_motor.is_spinning() — Karmotor
claw_motor	claw_motor.is_spinning() — Karmos motor

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

def main():
    # Raise the Arm while driving to the Goal, then release the Pin
    arm_motor.spin_to_position(800, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while arm_motor.is_spinning():
        drivetrain.drive_for(FORWARD, 25, MM)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

pozíció

Egy motor helyzete azt jelzi, hogy milyen messzire fordult meg, DEGREES vagy TURNSegységben mérve. Egy fordulat 360 foknak felel meg. position a motor aktuális helyzetét adja vissza.

Egy projekt kezdetén a karmotor pozíciója 0 fokra van állítva. A karommotor kivétel – 467 foknál indul (teljesen zárva). Ha a motor egy teljes fordulatot előre forog, a pozíció növekszik. Ha a motor az ellenkező irányba forog, a pozíció csökken.

Használat:
Két elérhető motoros objektum egyike használható ezzel a módszerrel, az alábbiak szerint:

motor	Parancs
arm_motor	arm_motor.position(units) — Karmotor
claw_motor	claw_motor.position(units) — Karmos motor

Paraméterek	Leírás
units	A motor pozícióját visszaadó egység: DEGREES vagy TURNS.

def main():
    # Raise the Arm, then release the Pin
    while arm_motor.position(DEGREES) < 800:
        arm_motor.spin(FORWARD)
        wait(2, MSEC)
    arm_motor.stop()
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

sebesség

velocity visszaadja, hogy milyen gyorsan forog a motor.

A pozitív érték azt jelenti, hogy a motor előre forog. A negatív érték azt jelenti, hogy a motor hátra forog.

Használat:
Két elérhető motoros objektum egyike használható ezzel a módszerrel, az alábbiak szerint:

motor	Parancs
arm_motor	arm_motor.velocity(units) — Karmotor
claw_motor	claw_motor.velocity(units) — Karmos motor

Paraméterek	Leírás
units	A visszaadandó sebesség mértékegysége: PERCENT.

def main():
    # Show Arm Motor velocity while raising
    arm_motor.set_velocity(100, PERCENT)
    arm_motor.spin_to_position(800, DEGREES, wait=False)
    wait(0.2, SECONDS)
    brain.screen.print(arm_motor.velocity(PERCENT))

# VR threads — Do not delete
vr_thread(main)

AI látás

Getterek

pillanatkép készítése

take_snapshot Az AI Vision Sensor keretrendszeréből származó adatokat egyetlen aláírásra szűri – egy mentett leírást valamiről, amit az érzékelő felismer, például egy játékelemet a pályán –, és egy tuple-t ad vissza.

A tuple a 0 indexszel kezdődően, szélesség szerint a legnagyobbtól a legkisebbig rendezve tárolja az objektumokat. Minden objektum properties tulajdonsága a hozzá tartozó index segítségével érhető el. Ha nem található egyező objektum, akkor egy üres tuple kerül visszaadásra.

Usage:
ai_vision.take_snapshot(signature)

Paraméterek

Leírás

signature

Úgy szűri az adathalmazt, hogy csak az adott aláírás adatait tartalmazza. Az elérhető aláírások: AiVision.ALL_AIOBJS - Az összes játékelemet észleli. GameElements.RED_BLUE_PIN - RedBluePin játékelemeket észleli. GameElements.BLUE_YELLOW_PIN - BlueYellowPin játékelemeket észleli. GameElements.RED_YELLOW_PIN - RedYellowPin játékelemeket észleli. GameElements.YELLOW_PIN - YellowPin játékelemeket észleli. GameElements.CUP - Cup játékelemeket észleli.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Turn to face the Pin
    drivetrain.set_turn_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].centerX < 140:
                drivetrain.turn(LEFT)
            elif ai_objects[0].centerX > 180:
                drivetrain.turn(RIGHT)
            else:
                drivetrain.stop()
                break

# VR threads — Do not delete
vr_thread(main)

Tulajdonságok

A take_snapshot metódus használata után a tuple-ben tárolt objektumokhoz hét tulajdonság tartozik.

.id kivételével az összes tulajdonságérték a detektált objektum pozícióját és méretét írja le az AI Vision Sensor nézetében take_snapshot használatának pillanatában. Ezeket az értékeket pixelben mérik, az érzékelő 320 x 240 pixeles felbontása alapján.

.szélesség

.width Visszaadja a detektált objektum szélességét pixelben, ami egy 1 és 320 közötti egész szám.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Approach the next Cup and Pin
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].width > 140:
                drivetrain.stop()
                break
            else:
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.magasság

.height A detektált objektum magasságát adja vissza pixelben, ami egy 1 és 240 közötti egész szám.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Approach the next Cup and Pin
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].height > 200:
                drivetrain.stop()
                break
            else:
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.centerX

.centerX Visszaadja a detektált objektum középpontjának x koordinátáját pixelben, ami egy 0 és 320 közötti egész szám.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Turn and approach the next Cup and Pin
    drivetrain.set_turn_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].centerX < 140:
                drivetrain.turn_for(LEFT, 5, DEGREES)
            else: 
                drivetrain.drive_for(FORWARD, 25, INCHES)
                break

# VR threads — Do not delete
vr_thread(main)

.centerY

.centerY Visszaadja a detektált objektum középpontjának y koordinátáját pixelben, ami egy 0 és 240 közötti egész szám.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Approach the next Cup and Pin
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].centerY > 230:
                drivetrain.stop()
                break
            else:
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.originX

.originX visszaadja a detektált objektum határolókeretének bal felső sarkának x koordinátáját pixelben, ami egy 0 és 320 közötti egész szám.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Turn and approach the next Cup and Pin
    drivetrain.set_turn_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].originX < 100:
                drivetrain.turn_for(LEFT, 5, DEGREES)
            else:
                drivetrain.drive_for(FORWARD, 25, INCHES)
                break

# VR threads — Do not delete
vr_thread(main)

.originY

.originY visszaadja a detektált objektum határolókeretének bal felső sarkának y koordinátáját pixelben, ami egy 0 és 240 közötti egész szám.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Approach the next Cup and Pin
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].originY > 140:
                drivetrain.stop()
                break
            else:
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.id

.id Az észlelt AI osztályozás azonosítóját adja vissza egész számként.

AI osztályozás	azonosító	Aláírás
PirosKékTű	0	GameElements.RED_BLUE_PIN
KékSárgaTű	1	GameElements.BLUE_YELLOW_PIN
PirosSárgaTű	2	GameElements.RED_YELLOW_PIN
Sárga tű	3	GameElements.YELLOW_PIN
Csésze	4	GameElements.CUP

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Display the ID of the next closest object
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            brain.screen.print(ai_objects[0].id)
            break

# VR threads — Do not delete
vr_thread(main)

Konzol

A konzol szöveget, számokat és változóértékeket jelenít meg egy projekt futása közben. A konzolmetódusok segítségével a kurzor új sorba helyezhető, a konzol tartalmát törölhetjük, valamint változókat vagy érzékelőértékeket adhatunk hozzá a Monitor laphoz.

Nyomtatás

agy.képernyő.nyomat

brain.screen.print szöveget, számokat vagy változó értékeket jelenít meg a konzolban az aktuális kurzorpozíció alapján.

Használd a brain.screen.next_row függvényt, ha azt szeretnéd, hogy a következő kiíratott érték új sorban kezdődjön.

Usage:
brain.screen.print(value)

Paraméterek	Leírás
value	A konzolon megjelenítendő szöveg, szám vagy változó értéke.

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

# VR threads — Do not delete
vr_thread(main)

agy.képernyő.következő_sor

brain.screen.next_row parancs a kurzort a konzol következő sorának 1. oszlopába helyezi. A következő kiíratott érték ezen a sorban fog megjelenni.

Usage:
brain.screen.next_row()

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

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)

agy.képernyő.tiszta_képernyő

brain.screen.clear_screen parancs törli az összes sort a konzolból, és visszahelyezi a kurzort az 1. sorba.

Usage:
brain.screen.clear_screen()

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

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)

Monitor

monitor_változó

monitor_variable Az 1-es paraméter egy vagy több előre definiált változót ad hozzá a VEXcode Monitor lapjához. Ez lehetővé teszi egy változó értékének változásának figyelését a projekt futása közben.

A változóknak globálisaknak kell lenniük ahhoz, hogy monitor_variable sikeresen monitorozhassa őket. Adja meg az egyes változók nevét karakterláncként.

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

Paraméterek	Leírás
variable	Egy előre definiált globális változó neve, amelyet figyelni kell, karakterláncként megadva. Egynél több változó figyeléséhez vesszővel kell elválasztani az egyes változók nevét.

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

    # Turn in a full circle 3 times
    for loops in range(12):
        drivetrain.turn_for(RIGHT, 90, DEGREES)

# VR threads — Do not delete
vr_thread(main)

monitor_érzékelő

monitor_sensor A VEXcode Monitor füléhez egy vagy több érzékelőértéket ad hozzá. Ez lehetővé teszi az érzékelőértékek változásának figyelését egy projekt futása közben.

Adja meg az egyes érzékelők értékeit karakterláncként.

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

Paraméterek

Leírás

sensor

A figyelendő érzékelőérték karakterláncként megadva. Egynél több érzékelőérték figyeléséhez vesszővel válassza el az egyes érzékelőértékeket. A támogatott érzékelőazonosítók a következők: Brain brain.timer.time Drivetrain drivetrain.is_done drivetrain.is_moving drivetrain.heading drivetrain.rotation drivetrain.velocity Arm Motor arm_motor.is_done arm_motor.is_spinning arm_motor.position arm_motor.velocity Claw Motor claw_motor.is_done claw_motor.is_spinning claw_motor.position claw_motor.velocity Távolságérzékelő distance.is_object_detected distance.object_distance_mm distance.object_distance_inches GPS-érzékelő gps.position_mm gps.position_inches gps.heading MI vizuális érzékelő 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)

Érzékelés

Távolság

talált_tárgy

found_object visszaadja, hogy a távolságérzékelő jelenleg érzékel-e tárgyat 2000 mm-en belül.

• True — A távolságérzékelő tárgyat érzékel.

• False — A távolságérzékelő nem érzékel tárgyat.

Usage:
distance.found_object()

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

def main():
    # Turn until something is detected, then release the Pin
    drivetrain.turn(RIGHT)
    while True:
        wait(5, MSEC)
        if distance.found_object():
            drivetrain.stop()
            break
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

objektumtávolság

object_distance Visszaadja a távolságérzékelő és a legközelebbi érzékelt tárgy közötti távolságot.

Usage:
distance.object_distance(units)

Paraméterek	Leírás
units	A távolság mértékegysége: MM vagy INCHES.

def main():
    # Drive until 200 mm from the Goal, then release the Pin
    while distance.object_distance(MM) > 200:
        wait(5, MSEC)
        drivetrain.drive(FORWARD)
    drivetrain.stop()
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

GPS

x_pozíció

x_position visszaadja a pályán lévő GPS (Game Positioning System™) érzékelő aktuális x koordinátáját.

Usage:
gps.x_position(units)

Paraméterek	Leírás
egységek	Az eltolás értékének mértékegysége: INCHES vagy MM

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive(FORWARD)
    while not gps.x_position(MM) > -1370:
        wait(2, MSEC)
    drivetrain.stop()
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

y_pozíció

y_position visszaadja a GPS (Game Positioning System™) érzékelő aktuális y koordinátáját a pályán.

Usage:
gps.y_position(units)

Paraméterek	Leírás
egységek	Az eltolás értékének mértékegysége: INCHES vagy MM

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive(FORWARD)
    while not gps.y_position(MM) < -450:
        wait(2, MSEC)
    drivetrain.stop()
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

cím

heading Az 1 paraméter a robot aktuális haladási irányát adja vissza a GPS (Game Positioning System™) érzékelő 0 és 359 fok közötti értékeinek alapján.

Usage:
gps.heading()

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    monitor_sensor("gps.heading")
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    # Turn left to face the Neutral Goal
    drivetrain.set_turn_velocity(30, PERCENT)
    drivetrain.turn(LEFT)
    while not gps.heading() < 18:
        wait(2, MSEC)
    drivetrain.stop()


# VR threads — Do not delete
vr_thread(main)