Robotspecifikus Python#

Bevezetés #

A Swish nevű hősbot egy motoros opcióval, egy motorcsoportos opcióval és optikai érzékelővel rendelkezik.

Minden szabványos VEXcode VR metódus elérhető az IQ 24-25 Rapid Relay 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 motorját és motorcsoportját.

Műveletek
- spin — Egy motort vagy motorcsoportot előre vagy hátra forgat örökké.
- spin_for — Megadott távolságra megpörget egy motort vagy motorcsoportot.
- spin_to_position — Egy motort vagy motorcsoportot egy adott pozícióba forgat.
- stop — Leállítja a motor vagy motorcsoport forgását.
Mutátorok
- set_position — A motor vagy motorcsoport aktuális pozícióját új értékre módosítja.
- set_velocity — Megadja egy motornak vagy motorcsoportnak a forgási sebességét.
- set_timeout — Beállítja, hogy egy motor vagy motorcsoport mennyi idő alatt próbálja meg befejezni a mozgást.
Getterek
- is_done — Logikai értékként adja vissza, hogy a motor vagy motorcsoport mozgása befejeződött-e.
- is_spinning — Logikai értékként adja vissza, hogy a motor vagy a motorcsoport forog-e.
- position — Visszaadja a motor vagy motorcsoport aktuális pozícióját.
- velocity — Visszaadja a motor vagy motorcsoport forgási sebességét.

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.

Optikai
- is_near_object – Visszaadja, hogy az optikai érzékelő érzékel-e objektumot a hatótávolságon belül.
- color – Visszaadja az optikai érzékelő által érzékelt színt.
- brightness – Visszaadja az objektumról visszaverődő fény mennyiségét.
- hue – Visszaadja az optikai érzékelő által érzékelt színárnyalatot.
- object_detected – Regisztrál egy függvényt, amely akkor hívódik meg, amikor az optikai érzékelő objektumot érzékel.
- object_lost – Regisztrál egy függvényt, amely akkor hívódik meg, amikor az optikai érzékelő elveszít egy objektumot.

Az ezen az oldalon található példák az alapértelmezett Játszótér kezdőpozíciójá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():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# 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`	A távolság mértékegysége: `INCHES` 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():
    # Drive forward and backward
    drivetrain.drive_for(FORWARD, 200, MM)
    drivetrain.drive_for(REVERSE, 200, MM)

# 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():
    # 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 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`	A forgási egység: `DEGREES`.
`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():
    # 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)

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 egy adott, -359 és 359 fok közötti irányba fordítja a robotot. A robot a legrövidebb irányba fordul, hogy elérje a célirányt.

A robot kezdő iránya 0 fok.

A projekt megvárja, amíg a robot befejezi a forgást, mielőtt a következő kódsort futtatná.

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

Paraméterek	Leírás
`angle`	Az irány, amerre a robotnak néznie kell, fokban. Ez lehet egy `integer` vagy decimális szám (`float`) -359 és 359 között.
`units`	A forgási egység: `DEGREES`.
`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():
    # 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)

fordulat_forgásig #

turn_to_rotation A robotot egy adott forgáspontra forgatja.

A forgatás a robot elfordulásának mértékét adja meg fokban mérve. A projekt elején a forgatás értéke 0 fok. A forgatás a set_rotation metódussal is beállítható.

A forgási értékek abszolútak. Ez azt jelenti, hogy a fordulat iránya a robot aktuális forgásától függ. Jobbra forgatás növeli, balra forgatás csökkenti a forgást.

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

A projekt megvárja, amíg a robot befejezi a forgást, mielőtt a következő kódsort futtatná.

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

Paraméterek	Leírás
`angle`	A robot elfordulási értéke fokban megadva. Ez lehet `integer` vagy decimális (`float`).
`units`	A forgási egység: `DEGREES`.
`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():
    # 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)

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():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# 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 robothoz beállítandó irányérték fokban. Ez lehet `integer` vagy decimális (`float`).
`units`	Az irány mértékegysége: `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)

forgatás beállítása #

A forgás a robot elfordulásának mértékét adja meg fokban mérve. A projekt elején a forgási érték 0 fokra van állítva. set_rotation paraméterrel a robot aktuális forgását egy új értékre módosítja.

Például, ha a robot két teljes fordulatot tett jobbra, akkor a forgási értéke 720 fok lesz. Ha a forgást 0 fokra állítja, akkor a forgás 720-ról 0 fokra áll vissza. Ezután a robot az új érték alapján foroghat.

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`	A forgási egység: `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)

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

set_timeout beállítja, hogy mennyi idő alatt próbáljon meg a robot befejezni egy mozgást. Ha a robot nem tudja befejezni a megadott időn belül, akkor leállítja a próbálkozást, és továbblép a kód következő sorára. Ez megakadályozza, hogy a robot elakadjon egy mozgásnál.

Usage:
drivetrain.set_timeout(value, units)

Paraméterek	Leírás
`value`	Az az időtartam, ameddig a robot 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():
    # 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 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`	A sebesség mértékegysége: `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)

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`	A sebesség mértékegysége: `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)

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`	Az irány mértékegysége: `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)

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`	A forgási egység: `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)

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.

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.

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`	A sebesség mértékegysége: `PERCENT`.

Példa

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

Mozgás #

Swish a szívómotorral gyűjti össze a labdákat, és a katapultra mozgatja azokat. A katapult motorcsoportja leengedi és elengedi a katapult kart, hogy kilője a labdákat.

Minden motornak és motorcsoportnak megvan a saját irányviselkedése. Az irányleírások elmagyarázzák, hogy az egyes irányok hogyan mozgatják az adott motort vagy motorcsoportot a Swish-en.

Műveletek #

pörgés #

spin Egy motort vagy motorcsoportot előre vagy hátra forgat örökre. A motor vagy motorcsoport 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ő motor vagy motorcsoport objektum egyike használható ezzel a metódussal, az alábbiak szerint:

motor	Parancs
`intake_motor`	`intake_motor.spin(direction)` — Szívómotor
`catapult_group`	`catapult_group.spin(direction)` — Katapultcsoport

Paraméterek

Leírás

direction

A motor vagy motorcsoport forgásiránya:

FORWARD — A szívómotort a szívóirányba forgatja, vagy leengedi a katapultcsoportot.
REVERSE — A szívómotort a kiszívóirányba forgatja, vagy kiengedi a katapultcsoportot.

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)

pörgetés_célra #

spin_for Egy motort vagy motorcsoportot egy adott távolságra megpörget. A pörgés a motor vagy motorcsoport aktuális pozíciójához képest értendő. A projekt megvárja, amíg a motor vagy motorcsoport befejezi a pörgést, mielőtt a következő kódsort futtatná.

Használat:
Két elérhető motor vagy motorcsoport objektum egyike használható ezzel a metódussal, az alábbiak szerint:

motor	Parancs
`intake_motor`	`intake_motor.spin_for(direction, distance, units, wait=True)` — Szívómotor
`catapult_group`	`catapult_group.spin_for(direction, distance, units, wait=True)` — Katapult csoport

Paraméterek	Leírás
`direction`	A motor vagy motorcsoport forgásiránya: `FORWARD` — A szívómotort a szívóirányba forgatja, vagy leengedi a katapultcsoportot. `REVERSE` — A szívómotort a kiszívóirányba forgatja, vagy kiengedi a katapultcsoportot.
`distance`	A motor vagy motorcsoport által megpörgetett távolság. `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 vagy motorcsoport befejezi a forgást, mielőtt a kód következő sora futna. `wait=False` — Azonnal futtatja a kód következő sorát.

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)

pörgetés_pozícióba #

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

Egy motor vagy motorcsoport pozíciója azt jelzi, hogy milyen messzire fordult el, DEGREES vagy TURNSegységben mérve. Egy fordulat 360 foknak felel meg. Egy projekt elején a motor vagy motorcsoport pozíciója 0 fokra van állítva. A motor vagy motorcsoport pozíciója 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 vagy motorcsoport aktuális pozíciójától függ.

Például, ha a motor vagy motorcsoport 0 fokról indul, és 720 fokos pozícióba forog, akkor két fordulatot előre fog forogni. Ha ezután 360 fokos pozícióba forog, akkor egy fordulatot vissza fog forogni, mivel a 360 fok kisebb, mint 720.

Használat:
Két elérhető motor vagy motorcsoport objektum egyike használható ezzel a metódussal, az alábbiak szerint:

motor	Parancs
`intake_motor`	`intake_motor.spin_to_position(angle, units, wait=True)` — Szívómotor
`catapult_group`	`catapult_group.spin_to_position(angle, units, wait=True)` — Katapultcsoport

Paraméterek	Leírás
`angle`	A motor vagy motorcsoport forgási pozícióértéke. `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 vagy motorcsoport befejezi a forgást, mielőtt a kód következő sora futna. `wait=False` — Azonnal futtatja a kód következő sorát.

Paraméterek

Leírás

angle

A motor vagy motorcsoport forgási pozícióértéke. 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 vagy motorcsoport befejezi a forgást, mielőtt a kód következő sora futna.
wait=False — Azonnal futtatja a kód következő sorát.

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)

motor leállítása #

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

Használat:
Két elérhető motor vagy motorcsoport objektum egyike használható ezzel a metódussal, az alábbiak szerint:

motor	Parancs
`intake_motor`	`intake_motor.stop()` — Szívómotor
`catapult_group`	`catapult_group.stop()` — Katapult csoport

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

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)

Mutátorok #

beállított_pozíció #

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

Például, ha egy motor vagy motorcsoport 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 vagy motorcsoport az új érték alapján foroghat a pozíciókba.

Használat:
Két elérhető motor vagy motorcsoport objektum egyike használható ezzel a metódussal, az alábbiak szerint:

motor	Parancs
`intake_motor`	`intake_motor.set_position(position, units)` — Szívómotor
`catapult_group`	`catapult_group.set_position(position, units)` — Katapult csoport

Paraméterek	Leírás
`position`	A motorhoz vagy motorcsoporthoz beállítandó pozícióérték. `DEGREES` egész számokat használ. `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():
    # 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 megmondja a motornak vagy motorcsoportnak, hogy milyen gyorsan forogjon. Magasabb százalékos érték esetén a motor vagy motorcsoport gyorsabban, alacsonyabb százalékos érték esetén pedig lassabban forog.

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

Megjegyzés: A nagyobb sebesség gyorsabban forogtatja a motort vagy a motorcsoportot, de kevésbé pontos lehet. Az alacsonyabb sebesség lassítja a motort vagy a motorcsoportot, de pontosabb lehet.

Használat:
Két elérhető motor vagy motorcsoport objektum egyike használható ezzel a metódussal, az alábbiak szerint:

motor	Parancs
`intake_motor`	`intake_motor.set_velocity(velocity, units)` — Szívómotor
`catapult_group`	`catapult_group.set_velocity(velocity, units)` — Katapult csoport

Paraméterek	Leírás
`velocity`	A forgási sebesség -100%-tól 100%-ig. Ez lehet `integer` vagy decimális (`float`).
`units`	A sebesség mértékegysége: `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)

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

set_timeout beállítja, hogy mennyi idő alatt próbáljon meg egy motor vagy motorcsoport befejezni egy mozgást. Ha a motor vagy motorcsoport nem tudja befejezni az adott 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 vagy motorcsoport elakadjon egy mozgásnál.

Használat:
Két elérhető motor vagy motorcsoport objektum egyike használható ezzel a metódussal, az alábbiak szerint:

motor	Parancs
`intake_motor`	`intake_motor.set_timeout(value, units)` — Szívómotor
`catapult_group`	`catapult_group.set_timeout(value, units)` — Katapult csoport

Paraméterek	Leírás
`value`	Az az időtartam, ameddig a motor vagy motorcsoport 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():
    # 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)

Getterek #

kész #

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

True — A motor vagy motorcsoport mozgása befejeződött.
False — A motor vagy motorcsoport továbbra is 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ő motor vagy motorcsoport objektum egyike használható ezzel a metódussal, az alábbiak szerint:

motor	Parancs
`intake_motor`	`intake_motor.is_done()` — Szívómotor
`catapult_group`	`catapult_group.is_done()` — Katapult csoport

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

forog #

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

True — A motor vagy motorcsoport forog.
False — A motor vagy motorcsoport 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ő motor vagy motorcsoport objektum egyike használható ezzel a metódussal, az alábbiak szerint:

motor	Parancs
`intake_motor`	`intake_motor.is_spinning()` — Szívómotor
`catapult_group`	`catapult_group.is_spinning()` — Katapult csoport

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

pozíció #

Egy motor vagy motorcsoport pozíciója azt jelzi, hogy milyen messzire fordult el, DEGREES vagy TURNSegységben mérve. Egy fordulat 360 foknak felel meg. position a motor vagy motorcsoport aktuális pozícióját adja vissza.

Egy projekt elején a motor vagy motorcsoport pozíciója 0 fokra van állítva. Ha a motor vagy motorcsoport egy teljes fordulatot előre forog, a pozíció 360 fok vagy 1 fordulat lesz. Ha a motor vagy motorcsoport az ellenkező irányba forog, a pozíció negatív lesz.

Használat:
Két elérhető motor vagy motorcsoport objektum egyike használható ezzel a metódussal, az alábbiak szerint:

motor	Parancs
`intake_motor`	`intake_motor.position(units)` — Szívómotor
`catapult_group`	`catapult_group.position(units)` — Katapultcsoport

Paraméterek	Leírás
`units`	Az egység, amely visszaadja a motor vagy motorcsoport pozícióját: `DEGREES` vagy `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)

sebesség #

velocity visszaadja, hogy milyen gyorsan forog a motor vagy motorcsoport.

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

Használat:
Két elérhető motor vagy motorcsoport objektum egyike használható ezzel a metódussal, az alábbiak szerint:

motor	Parancs
`intake_motor`	`intake_motor.velocity(units)` — Szívómotor
`catapult_group`	`catapult_group.velocity(units)` — Katapultcsoport

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

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

# 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. Úgy viselkedik, mint print a konzol API oldalon.

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)

A VEXcode konzol, amelyen a konzol és a „Hello, robot!” szöveg látható.

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)

A VEXcode konzol, amelyen a konzol és az első sorban az „1. sor”, a második sorban pedig a „2. sor” szöveg látható.

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 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_é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`	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`

Paraméterek

Leírás

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)

Érzékelés #

Optikai #

tárgy_közelében van #

is_near_object egy logikai értéket ad vissza, amely azt jelzi, hogy az optikai érzékelő érzékel-e objektumot a hatótávolságon belül.

True – Az optikai érzékelő objektumot érzékel.
False – Az optikai érzékelő nem érzékel tárgyat.

Usage:
intake_optical.is_near_object()

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

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)

szín #

color egy Color osztály egy példányát adja vissza a detektált színárnyalat-érték alapján. Ezeket összehasonlíthatjuk előre definiált Color objektumokkal feltételes utasítások létrehozásához.

Lehetséges színek a következők:

NONE
RED – 340° és 20° közötti színárnyalatérték
GREEN – 80° és 140° közötti színárnyalatérték
BLUE – 200° és 240° közötti színárnyalatérték
YELLOW – 40° és 60° közötti színárnyalatérték
ORANGE – 20° és 40° közötti színárnyalatérték
PURPLE – 240° és 280° közötti színárnyalatérték
CYAN – 140° és 200° közötti színárnyalat

Megjegyzés: Az optikai érzékelő a megadott színnek megfelelő színárnyalat-tartományokat keresi. Az adott színárnyalat-tartományok észleléséhez lásd: hue.

Usage:
intake_optical.color()

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

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)

fényesség #

brightness értéke a tárgyról visszaverődő fény mennyiségét adja vissza decimális törtként (float), amely százalékot jelent.

A magasabb százalékos érték azt jelenti, hogy több fény verődik vissza az optikai érzékelőre. Az alacsonyabb százalékos érték azt jelenti, hogy kevesebb fény verődik vissza.

Usage:
intake_optical.brightness()

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

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)

színárnyalat #

hue Az 1-es paraméter visszaadja a detektált szín árnyalatértékét decimális alakban (float) 0 és 359 között.

A színárnyalat a színek leírásának egy módja, számok segítségével, egy színkör körül.

Kör alakú színkör, amely a színárnyalatok teljes spektrumát jeleníti meg, a kerület mentén fokszámokkal jelölve, 30 fokos lépésekben növekvő 0 foktól a tetején 360 fokig.

Usage:
intake_optical.hue()

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

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)

objektum_észlelt #

object_detected regisztrál egy függvényt, amely akkor hívódik meg, amikor az optikai érzékelő új objektumot észlel.

Usage:
intake_optical.object_detected(callback, arg)

Paraméterek	Leírás
`callback`	Egy korábban definiált függvény, amely akkor hajtódik végre, amikor az optikai érzékelő új objektumot észlel.
`arg`	Opcionális. Egy tuple, amely argumentumokat tartalmaz a visszahívó függvénynek átadandó. További információkért lásd a Függvények használata paraméterekkel részt.

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)

elveszett_objektum #

object_lost regisztrál egy függvényt, amely akkor hívódik meg, amikor az optikai érzékelő elveszít egy érzékelt objektumot.

Usage:
intake_optical.object_lost(callback, arg)

Paraméterek	Leírás
`callback`	Egy korábban definiált függvény, amely akkor hajtódik végre, amikor az optikai érzékelő elveszít egy érzékelt objektumot.
`arg`	Opcionális. Egy tuple, amely argumentumokat tartalmaz a visszahívó függvénynek átadandó. További információkért lásd a Függvények használata paraméterekkel részt.

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)