Robotspecifikus Python#

Bevezetés #

A Fling nevű hősbot három motorral és színérzékelővel rendelkezik.

Minden szabványos VEXcode VR módszer elérhető az IQ 21-22 Pitching In 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.

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.

Szín
- color – Visszaadja a színérzékelő által érzékelt színt.
- brightness – Visszaadja az objektumról visszaverődő fény mennyiségét.
- hue – Visszaadja a színérzékelő által érzékelt színárnyalatot.
- is_near_object – Visszaadja, hogy a színérzékelő érzékel-e objektumot a tartományon belül.

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 Fling a szívómotort használja a golyók behúzásához vagy kilökéséhez. A katapult és a katapultkar feszítőmotorjai indítják el a golyókat, a feszítés pedig megváltoztatja a golyók útját.

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

Műveletek #

pörgés #

spin Az 1-es érték örökre előre vagy hátra forgatja a motort. A motor addig forog, amíg egy másik műveletet nem kap, például egy másik irányba forgatja vagy leállítja.

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

motor	Parancs
`intake_motor`	`intake_motor.spin(direction)` — Szívómotor
`catapult_motor`	`catapult_motor.spin(direction)` — Katapultmotor
`catapult_tension_motor`	`catapult_tension_motor.spin(direction)` — Katapult feszítőmotor

Paraméterek	Leírás
`direction`	A motor forgásiránya a kiválasztott motortól függ: `FORWARD` — A szívómotort a szívóirányba forgatja, vagy a kiválasztott katapultmotort előre mozgatja. `REVERSE` — A szívómotort a kiszívásirányba forgatja, vagy a kiválasztott katapultmotort hátrafelé mozgatja.

Paraméterek

Leírás

direction

A motor forgásiránya a kiválasztott motortól függ:

FORWARD — A szívómotort a szívóirányba forgatja, vagy a kiválasztott katapultmotort előre mozgatja.
REVERSE — A szívómotort a kiszívásirányba forgatja, vagy a kiválasztott katapultmotort hátrafelé mozgatja.

def main():
    # Spin the Intake Motor to collect a Ball
    intake_motor.spin(FORWARD)
    wait(1, SECONDS)
    intake_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:
Három elérhető motoros objektum egyike használható ezzel a módszerrel, az alábbiak szerint:

motor	Parancs
`intake_motor`	`intake_motor.spin_for(direction, distance, units, wait=True)` — Szívómotor
`catapult_motor`	`catapult_motor.spin_for(direction, distance, units, wait=True)` — Katapultmotor
`catapult_tension_motor`	`catapult_tension_motor.spin_for(direction, distance, units, wait=True)` — Katapult feszítőmotor

Paraméterek	Leírás
`direction`	A motor forgásiránya a kiválasztott motortól függ: `FORWARD` vagy `REVERSE`.
`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():
    # Collect a Ball with the Intake Motor
    intake_motor.spin_for(FORWARD, 360, 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 pozíciója azt mutatja meg, hogy milyen messzire fordult el, DEGREES vagy TURNSegységben mérve. Egy fordulat 360 foknak felel meg. Egy projekt elején a motor pozíciója 0 fokra van állítva. A motor 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 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:
Három elérhető motoros objektum egyike használható ezzel a módszerrel, az alábbiak szerint:

motor	Parancs
`intake_motor`	`intake_motor.spin_to_position(angle, units, wait=True)` — Szívómotor
`catapult_motor`	`catapult_motor.spin_to_position(angle, units, wait=True)` — Katapultmotor
`catapult_tension_motor`	`catapult_tension_motor.spin_to_position(angle, units, wait=True)` — Katapult feszítő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.

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():
    # Move the Catapult Motor to a launch position
    catapult_motor.spin_to_position(2600, DEGREES)

# VR threads — Do not delete
vr_thread(main)

motor leállítása #

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

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

motor	Parancs
`intake_motor`	`intake_motor.stop()` — Szívómotor
`catapult_motor`	`catapult_motor.stop()` — Katapultmotor
`catapult_tension_motor`	`catapult_tension_motor.stop()` — Katapult feszítőmotor

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

def main():
    # Spin the Intake Motor, then stop it
    intake_motor.spin(FORWARD)
    wait(1, SECONDS)
    intake_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:
Három elérhető motoros objektum egyike használható ezzel a módszerrel, az alábbiak szerint:

motor	Parancs
`intake_motor`	`intake_motor.set_position(position, units)` — Szívómotor
`catapult_motor`	`catapult_motor.set_position(position, units)` — Katapultmotor
`catapult_tension_motor`	`catapult_tension_motor.set_position(position, units)` — Katapult feszítő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():
    # Set the Catapult Motor position, then return it to 0 degrees
    catapult_motor.set_position(2600, DEGREES)
    catapult_motor.spin_to_position(0, 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:
Három elérhető motoros objektum egyike használható ezzel a módszerrel, az alábbiak szerint:

motor	Parancs
`intake_motor`	`intake_motor.set_velocity(velocity, units)` — Szívómotor
`catapult_motor`	`catapult_motor.set_velocity(velocity, units)` — Katapultmotor
`catapult_tension_motor`	`catapult_tension_motor.set_velocity(velocity, units)` — Katapult feszítőmotor

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():
    # Set the Catapult Motor velocity before moving it
    catapult_motor.set_velocity(75, PERCENT)
    catapult_motor.spin_to_position(2600, 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:
Három elérhető motoros objektum egyike használható ezzel a módszerrel, az alábbiak szerint:

motor	Parancs
`intake_motor`	`intake_motor.set_timeout(value, units)` — Szívómotor
`catapult_motor`	`catapult_motor.set_timeout(value, units)` — Katapultmotor
`catapult_tension_motor`	`catapult_tension_motor.set_timeout(value, units)` — Katapult feszítő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():
    # Limit how long the Catapult Motor waits to reach its target
    catapult_motor.set_timeout(2, SECONDS)
    catapult_motor.spin_to_position(5000, 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:
Három elérhető motoros objektum egyike használható ezzel a módszerrel, az alábbiak szerint:

motor	Parancs
`intake_motor`	`intake_motor.is_done()` — Szívómotor
`catapult_motor`	`catapult_motor.is_done()` — Katapultmotor
`catapult_tension_motor`	`catapult_tension_motor.is_done()` — Katapult feszítőmotor

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

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:
Három elérhető motoros objektum egyike használható ezzel a módszerrel, az alábbiak szerint:

motor	Parancs
`intake_motor`	`intake_motor.is_spinning()` — Szívómotor
`catapult_motor`	`catapult_motor.is_spinning()` — Katapultmotor
`catapult_tension_motor`	`catapult_tension_motor.is_spinning()` — Katapult feszítőmotor

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

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 elején a motor pozíciója 0 fokra van állítva. Ha a motor egy teljes fordulatot előre forog, a pozíció 360 fok vagy 1 fordulat lesz. Ha a motor az ellenkező irányba forog, a pozíció negatív lesz.

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

motor	Parancs
`intake_motor`	`intake_motor.position(units)` — Szívómotor
`catapult_motor`	`catapult_motor.position(units)` — Katapultmotor
`catapult_tension_motor`	`catapult_tension_motor.position(units)` — Katapult feszítőmotor

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

def main():
    # Print the current Catapult Motor position
    brain.screen.print(catapult_motor.position(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:
Három elérhető motoros objektum egyike használható ezzel a módszerrel, az alábbiak szerint:

motor	Parancs
`intake_motor`	`intake_motor.velocity(units)` — Szívómotor
`catapult_motor`	`catapult_motor.velocity(units)` — Katapultmotor
`catapult_tension_motor`	`catapult_tension_motor.velocity(units)` — Katapult feszítőmotor

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

def main():
    # Print the current Intake Motor velocity
    brain.screen.print(intake_motor.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 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 #

Szín #

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: A színé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:
color.color()

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

def main():
    # Print the color detected by the Color Sensor
    brain.screen.print(color.color())

# 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 a színérzékelőre. Az alacsonyabb százalékos érték azt jelenti, hogy kevesebb fény verődik vissza.

Usage:
color.brightness()

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

def main():
    # Print the Color Sensor brightness
    brain.screen.print(color.brightness())

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

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

def main():
    # Print the hue detected by the Color Sensor
    brain.screen.print(color.hue())

# VR threads — Do not delete
vr_thread(main)

tárgy_közelében van #

is_near_object egy logikai értéket ad vissza, amely azt jelzi, hogy a színérzékelő érzékel-e objektumot a tartományon belül.

True – A színérzékelő objektumot érzékel.
False – A színérzékelő nem érzékel tárgyat.

Usage:
color.is_near_object()

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

def main():
    # Print whether the Color Sensor detects an object nearby
    brain.screen.print(color.is_near_object())

# VR threads — Do not delete
vr_thread(main)