Robotspecifikus Python#

Bevezetés #

A Byte nevű hősbot két motorcsoport-opcióval és egy optikai érzékelővel rendelkezik.

Minden szabványos VEXcode VR metódus elérhető az IQ 23-24 Full Volume 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 motorcsoportjait.

Műveletek
- spin — Egy motoros csoportot előre vagy hátra forgat örökké.
- spin_for — Megadott távolságon keresztül megpörget egy motorcsoportot.
- spin_to_position — Egy motorcsoportot egy adott pozícióba forgat.
- stop — Leállítja a motorcsoport forgását.
Mutátorok
- set_position — A motorcsoport aktuális pozícióját új értékre módosítja.
- set_velocity — Megadja egy motoros csoportnak a forgási sebességét.
- set_timeout — Beállítja, hogy egy motoros csoport mennyi idő alatt próbáljon meg befejezni egy mozgást.
Getterek
- is_done — Logikai értékként adja vissza, hogy a motorcsoport mozgása befejeződött-e.
- is_spinning — Logikai értékként adja vissza, hogy a motorcsoport forog-e.
- position — Visszaadja a motorcsoport aktuális pozícióját.
- velocity — Visszaadja a 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`	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():
    # 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`	Opcionális. Az elforgatás 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():
    # 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 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 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`	Opcionális. Az elforgatás 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():
    # 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`	Opcionális. Az elforgatás 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():
    # 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`	Opcionális. Az irány mértékegysége: `DEGREES` (alapértelmezett).

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`	Opcionális. Az elforgatás mértékegysége: `DEGREES` (alapértelmezett).

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`	Opcionális. A sebesség mértékegysége: `PERCENT` (alapértelmezett).

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`	Opcionális. A sebesség mértékegysége: `PERCENT` (alapértelmezett).

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`	Opcionális. Az irány mértékegysége: `DEGREES` (alapértelmezett).

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`	Opcionális. Az elforgatás mértékegysége: `DEGREES` (alapértelmezett).

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`	Opcionális. A sebesség mértékegysége: `PERCENT` (alapértelmezett).

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 #

A Byte a kar motorcsoportját használja a kar felemeléséhez és leengedéséhez, hogy a blokkok szállíthatók legyenek. A szívómotor-csoport megforgatja az első kerekeket a blokkok összegyűjtéséhez, vagy hátrafelé halad, hogy pontokat szerezzen vagy leejtse azokat.

Minden 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 motorcsoportot bájtonként.

Műveletek #

pörgés #

spin Egy motoros csoportot előre vagy hátra forgat örökre. A motoros csoport addig forog, amíg egy másik műveletet nem kap, például egy másik irányba forog vagy megáll.

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

motor	Parancs
`arm_motor_group`	`arm_motor_group.spin(direction)` — Karmotor csoport
`intake_motor_group`	`intake_motor_group.spin(direction)` — Szívómotor csoport

Paraméterek

Leírás

direction

A motorcsoport forgásiránya:

FORWARD — Emeli a kar motorcsoportot, vagy a szívómotorcsoportot a szívóirányban forgatja.
REVERSE — Leengedi a kar motorcsoportot, vagy a szívómotorcsoportot a kimeneti irányba forgatja.

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)

pörgetés_célra #

spin_for Egy motorcsoportot egy adott távolságra forgat meg. A forgatás a motorcsoport aktuális pozíciójához képest relatív. A projekt megvárja, amíg a motorcsoport befejezi a forgást, mielőtt a következő kódsort futtatná.

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

motor	Parancs
`arm_motor_group`	`arm_motor_group.spin_for(direction, distance, units, wait)` — Kar Motorcsoport
`intake_motor_group`	`intake_motor_group.spin_for(direction, distance, units, wait)` — Szívómotor csoport

Paraméterek	Leírás
`direction`	A motorcsoport forgásiránya: `FORWARD` — Emeli a kar motorcsoportot, vagy a szívómotorcsoportot a szívóirányban forgatja. `REVERSE` — Leengedi a kar motorcsoportot, vagy a szívómotorcsoportot a kimeneti irányba forgatja.
`distance`	A motoros csoport 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 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():
    # Spin the intake motor forward then stop
    intake_motor_group.spin_for(FORWARD, 360, DEGREES)

# VR threads — Do not delete
vr_thread(main)

pörgetés_pozícióba #

spin_to_position Egy motoros csoportot egy adott pozícióba forgat.

Egy 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 motorcsoport pozíciója 0 fokra van állítva. A 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 motorcsoport aktuális pozíciójától függ.

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

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

motor	Parancs
`arm_motor_group`	`arm_motor_group.spin_to_position(angle, units, wait=True)` — Kar Motorcsoport
`intake_motor_group`	`intake_motor_group.spin_to_position(angle, units, wait=True)` — Szívómotor csoport

Paraméterek	Leírás
`angle`	A 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 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 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 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():
    # Spin the intake motor forward then stop
    intake_motor_group.spin_to_position(55, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Stop #

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

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

motor	Parancs
`arm_motor_group`	`arm_motor_group.stop()` — Motorkar csoport
`intake_motor_group`	`intake_motor_group.stop()` — Szívómotor csoport

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

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)

Mutátorok #

beállított_pozíció #

Egy 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 motorcsoport aktuális pozícióját egy új értékre módosítja.

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

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

motor	Parancs
`arm_motor_group`	`arm_motor_group.set_position(position, units)` — Karmotor csoport
`intake_motor_group`	`intake_motor_group.set_position(position, units)` — Szívómotor csoport

Paraméterek	Leírás
`position`	A motorcsoporthoz 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():
    # 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 megmondja a motorcsoportnak, hogy milyen gyorsan forogjon. Magasabb százalékos érték esetén a motorcsoport gyorsabban, alacsonyabb százalékos érték esetén pedig lassabban forog.

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

Megjegyzés: A nagyobb sebesség gyorsabban forogtatja a motorcsoportot, de kevésbé pontos lehet. Az alacsonyabb sebesség lassabban forogtatja a motorcsoportot, de pontosabb lehet.

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

motor	Parancs
`arm_motor_group`	`arm_motor_group.set_velocity(velocity, units)` — Kar Motorcsoport
`intake_motor_group`	`intake_motor_group.set_velocity(velocity, units)` — Szívómotor csoport

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

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

set_timeout beállítja, hogy mennyi idő alatt próbáljon meg egy motoros csoport befejezni egy mozgást. Ha a motoros csoport 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 motoros csoport elakadjon egy mozgásnál.

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

motor	Parancs
`arm_motor_group`	`arm_motor_group.set_timeout(value, units)` — Motorcsoport élesítése
`intake_motor_group`	`intake_motor_group.set_timeout(value, units)` — Szívómotor csoport

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

Getterek #

kész #

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

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

motor	Parancs
`arm_motor_group`	`arm_motor_group.is_done()` — Karmotor csoport
`intake_motor_group`	`intake_motor_group.is_done()` — Szívómotor csoport

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

forog #

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

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

motor	Parancs
`arm_motor_group`	`arm_motor_group.is_spinning()` — Karmotor csoport
`intake_motor_group`	`intake_motor_group.is_spinning()` — Szívómotor csoport

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

pozíció #

Egy 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 motorcsoport aktuális pozícióját adja vissza.

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

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

motor	Parancs
`arm_motor_group`	`arm_motor_group.position(units)` — Karmotor csoport
`intake_motor_group`	`intake_motor_group.position(units)` — Szívómotor csoport

Paraméterek	Leírás
`units`	Az egység, amely visszaadja a motorcsoport pozícióját: `DEGREES` vagy `TURNS`.

sebesség #

velocity visszaadja, hogy milyen gyorsan forog a motorcsoport.

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

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

motor	Parancs
`arm_motor_group`	`arm_motor_group.velocity(units)` — Karmotor csoport
`intake_motor_group`	`intake_motor_group.velocity(units)` — Szívómotor-csoport

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

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 A parancs szöveget, számokat vagy változóértékeket jelenít meg a konzolon 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)

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

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

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

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

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

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

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°-tól 360°-ig.

Usage:
optical.hue()

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

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

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