Robotspecifikus Python#

Bevezetés #

A Huey hősbot két motorral rendelkezik: az IQ AI látásérzékelővel, az optikai érzékelővel és az érintő LED-del.

Minden szabványos VEXcode VR módszer elérhető az IQ 25-26 Mix & Match Játszótéren.

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

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

Műveletek
- drive — A robotot előre vagy hátra mozgatja örökké.
- drive_for — Meghatározott távolságra mozgatja a robotot előre vagy hátra.
- turn — Örökké balra vagy jobbra forgatja a robotot.
- turn_for — Meghatározott fokkal balra vagy jobbra forgatja a robotot.
- turn_to_heading — A robotot egy adott irányba fordítja -359 és 359 fok között.
- turn_to_rotation — Meghatározott forgásirányba fordítja a robotot.
- stop — Leállítja a robot mozgását.
Mutátorok
- set_heading — A robot aktuális irányát egy új irányra módosítja.
- set_rotation — A robot aktuális forgását egy új forgásra módosítja.
- set_timeout — Beállítja, hogy mennyi idő alatt próbálja meg a robot befejezni a mozgást.
- set_drive_velocity — Megadja a robotnak a haladási sebességét.
- set_turn_velocity — Megadja a robotnak, hogy milyen gyorsan forduljon.
Getterek
- heading — Visszaadja a robot aktuális irányát 0 és 359,99 fok között.
- rotation — Visszaadja a robot aktuális forgását.
- is_done — Logikai értékként adja vissza, hogy a robot befejezte-e a mozgást.
- is_moving — Logikai értékként adja vissza, hogy a robot mozog-e.
- velocity — Visszaadja a robot sebességét.

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

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

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

Getterek
- take_snapshot - Egy adott aláíráshoz tartozó észlelt objektumok egy tuple-jét adja vissza.
Ingatlanok
- width - A detektált objektum szélessége pixelben.
- height - A detektált objektum magassága pixelben.
- centerX - Az objektum középpontjának X pozíciója pixelben.
- centerY - Az objektum középpontjának Y pozíciója pixelben.
- originX - Az objektum bal felső sarkának X pozíciója pixelben.
- originY - Az objektum bal felső sarkának Y pozíciója pixelben.
- id - Az objektum osztályozása vagy címkeazonosítója.

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

Nyomtatás
- brain.screen.print — Szöveget, számokat vagy változóértékeket jelenít meg a konzolon.
- brain.screen.next_row — A konzol kurzorát a következő sor elejére mozgatja.
- brain.screen.clear_screen — Törli az összes sort a konzolból.
Monitor
- monitor_variable — Egy vagy több előre definiált változót ad hozzá a Monitor laphoz.
- monitor_sensor — Egy vagy több érzékelőértéket ad hozzá a Monitor fülhöz.

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

Érintőképernyős LED
- set_color - Beállítja az érintőképernyős LED színét a kiválasztott színre.
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 #

Huey a karommotort használja a karom nyitásához és zárásához, így a csapokat és gerendákat fel lehet venni vagy le lehet dobni. Az emelőmotor felemeli és leengedi a csapokat vagy gerendákat, hogy azok egymáshoz lehessen rögzíteni.

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 Huey-n.

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

motor	Parancs
`claw_motor`	`claw_motor.spin(direction)` — Karmos motor
`lift_motor`	`lift_motor.spin(direction)` — Emelőmotor

Paraméterek

Leírás

direction

A motor forgásiránya:

FORWARD — Nyitja a karomot vagy leengedi az emelőt.
REVERSE — Zárja a karomot vagy felemeli az emelőt.

def main():
    # Raise the lift, drive forward, then open the claw.
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

pörgetés_célra #

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

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

motor	Parancs
`claw_motor`	`claw_motor.spin_for(direction, distance, units, wait=True)` — Karmos motor
`lift_motor`	`lift_motor.spin_for(direction, distance, units, wait=True)` — Emelőmotor

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

def main():
    # Raise the lift, drive forward, then open the claw.
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

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

motor	Parancs
`claw_motor`	`claw_motor.spin_to_position(angle, units, wait=True)` — Karmos motor
`lift_motor`	`lift_motor.spin_to_position(angle, units, wait=True)` — Emelő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():
    # Raise the lift to a known position, drive, then open the claw
    lift_motor.spin_to_position(-720, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

motor leállítása #

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

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

motor	Parancs
`claw_motor`	`claw_motor.stop()` — Karmos motor
`lift_motor`	`lift_motor.stop()` — Emelőmotor

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

def main():
    # Raise the lift for 2 seconds, then stop
    lift_motor.spin(REVERSE)
    wait(2, SECONDS)
    lift_motor.stop()
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

Mutátorok #

beállított_pozíció #

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

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

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

motor	Parancs
`claw_motor`	`claw_motor.set_position(position, units)` — Karmos motor
`lift_motor`	`lift_motor.set_position(position, units)` — Emelőmotor

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

def main():
    # Reset the lift position, then move to a new target.
    lift_motor.set_position(100, DEGREES)
    lift_motor.spin_to_position(-500, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

set_velocity #

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

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

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

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

motor	Parancs
`claw_motor`	`claw_motor.set_velocity(velocity, units)` — Karmos motor
`lift_motor`	`lift_motor.set_velocity(velocity, units)` — Emelőmotor

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

def main():
    # Set lift speed, then raise it.
    lift_motor.set_velocity(100, PERCENT)
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_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 befejezni egy mozgást. Ha a motor nem tud befejezni ennyi idő alatt, akkor leállítja a próbálkozást, és a kód következő sorára ugrik. Ez megakadályozza, hogy a motor elakadjon egy mozgásnál.

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

motor	Parancs
`claw_motor`	`claw_motor.set_timeout(value, units)` — Karmos motor
`lift_motor`	`lift_motor.set_timeout(value, units)` — Emelő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 lift waits to reach its target.
    lift_motor.set_timeout(2, SECONDS)
    lift_motor.spin_for(REVERSE, 1800, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

Getterek #

kész #

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

True — A motor mozgása befejeződött.
False — A motor még mindig mozog.

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

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

motor	Parancs
`claw_motor`	`claw_motor.is_done()` — Karmos motor
`lift_motor`	`lift_motor.is_done()` — Emelőmotor

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

def main():
    # Flash the Touch LED while the lift is moving.
    lift_motor.spin_for(REVERSE, 600, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while not lift_motor.is_done():
        touchled.set_color(RED)
        wait(0.5, SECONDS)
        touchled.set_color(NONE)
        wait(0.5, SECONDS)

# VR threads — Do not delete
vr_thread(main)

forog #

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

True — A motor forog.
False — A motor nem forog.

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

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

motor	Parancs
`claw_motor`	`claw_motor.is_spinning()` — Karmos motor
`lift_motor`	`lift_motor.is_spinning()` — Emelőmotor

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

def main():
    # Flash the Touch LED while the lift is spinning.
    lift_motor.spin_for(REVERSE, 600, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while lift_motor.is_spinning():
        touchled.set_color(RED)
        wait(0.5, SECONDS)
        touchled.set_color(NONE)
        wait(0.5, SECONDS)

# VR threads — Do not delete
vr_thread(main)

pozíció #

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

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

motor	Parancs
`claw_motor`	`claw_motor.position(units)` — Karmos motor
`lift_motor`	`lift_motor.position(units)` — Emelőmotor

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

def main():
    # Raise the lift until it reaches roughly 600 degrees.
    lift_motor.spin(REVERSE)
    while not lift_motor.position(DEGREES) <= -600:
        wait(2, MSEC)
    lift_motor.stop()
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

sebesség #

velocity visszaadja, hogy milyen gyorsan forog a motor.

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

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

motor	Parancs
`claw_motor`	`claw_motor.velocity(units)` — Karmos motor
`lift_motor`	`lift_motor.velocity(units)` — Emelőmotor

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

def main():
    # Print the lift velocity while it is moving.
    lift_motor.set_velocity(100, PERCENT)
    lift_motor.spin_for(REVERSE, 600, DEGREES, wait=False)
    wait(0.5, SECONDS)
    brain.screen.print(lift_motor.velocity(PERCENT))

# VR threads — Do not delete
vr_thread(main)

AI látás #

Getterek #

pillanatkép készítése #

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

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

Usage:
ai_vision.take_snapshot(signature)

Paraméterek	Leírás
`signature`	Úgy szűri az adathalmazt, hogy csak az adott szignatúra adatait tartalmazza. Az elérhető szignatúrák: `AiVision.ALL_AIOBJS` - Sugárnyalábokat és kék, piros és narancssárga tűket érzékel.

Paraméterek

Leírás

signature

Úgy szűri az adathalmazt, hogy csak az adott szignatúra adatait tartalmazza. Az elérhető szignatúrák:

AiVision.ALL_AIOBJS - Sugárnyalábokat és kék, piros és narancssárga tűket érzékel.

def main():
    # Place the Red Pin on the top-left Blue Pin.
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.turn_for(LEFT, 38, DEGREES)

    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
    while not ai_objects[0].width > 48:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        drivetrain.drive(FORWARD)

    drivetrain.drive_for(FORWARD, 160, MM)
    claw_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

Tulajdonságok #

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

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

.szélesség #

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

def main():
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
    if len(ai_objects) > 0:
        brain.screen.print(ai_objects[0].width)

# VR threads — Do not delete
vr_thread(main)

.magasság #

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

def main():
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
    if len(ai_objects) > 0:
        brain.screen.print(ai_objects[0].height)

# VR threads — Do not delete
vr_thread(main)

.centerX #

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

def main():
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
    if len(ai_objects) > 0:
        brain.screen.print(ai_objects[0].centerX)

# VR threads — Do not delete
vr_thread(main)

.centerY #

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

def main():
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
    if len(ai_objects) > 0:
        brain.screen.print(ai_objects[0].centerY)

# VR threads — Do not delete
vr_thread(main)

.originX #

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

def main():
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
    if len(ai_objects) > 0:
        brain.screen.print(ai_objects[0].originX)

# VR threads — Do not delete
vr_thread(main)

.originY #

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

def main():
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
    if len(ai_objects) > 0:
        brain.screen.print(ai_objects[0].originY)

# VR threads — Do not delete
vr_thread(main)

.id #

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

AI osztályozás	azonosító	Aláírás
Gerenda	0	`GameElements.BEAM`
Kék tű	1	`GameElements.BLUE_PIN`
Piros tű	2	`GameElements.RED_PIN`
Narancssárga kitűző	3	`GameElements.ORANGE_PIN`

def main():
    # Find the nearest Blue Pin in the current snapshot.
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    object_count = 1
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

    if len(ai_objects) > 0:
        for repeat_count in range(len(ai_objects)):
            if ai_objects[repeat_count].id == GameElements.BLUE_PIN:
                brain.screen.print(str("Closest Blue Pin is ") + str(object_count))
                break
            object_count = object_count + 1

# 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`	A figyelendő érzékelőérték karakterláncként megadva. Egynél több érzékelőérték figyeléséhez vesszővel válassza el az egyes érzékelőértékeket. A támogatott érzékelőazonosítók a következők: Brain `brain.timer.time` Drivetrain `drivetrain.is_done` `drivetrain.is_moving` `drivetrain.heading` `drivetrain.rotation` `drivetrain.velocity` Pusher Motor `pusher_motor.is_done` `pusher_motor.is_spinning` `pusher_motor.position` `pusher_motor.velocity` Kar Motor `arm_motor.is_done` `arm_motor.is_spinning` `arm_motor.position` `arm_motor.velocity` Elülső távolságérzékelő `front_distance.is_object_detected` `front_distance.object_distance_mm` `front_distance.object_distance_inches` Elülső optikai érzékelő `front_optical.is_near_object` `front_optical.color` `front_optical.brightness` `front_optical.hue` GPS-érzékelő `gps.position_mm` `gps.position_inches` `gps.heading` Tolórúd forgásérzékelője `pusher_rotation.angle` `pusher_rotation.position` MI-alapú vizuális érzékelő `ai_vision.object_count` `ai_vision.height` `ai_vision.width` `ai_vision.centerX` `ai_vision.centerY` `ai_vision.originX` `ai_vision.originY` `ai_vision.id`

Paraméterek

Leírás

sensor

A figyelendő érzékelőérték karakterláncként megadva. Egynél több érzékelőérték figyeléséhez vesszővel válassza el az egyes érzékelőértékeket. A támogatott érzékelőazonosítók a következők:

Brain
- brain.timer.time
Drivetrain
- drivetrain.is_done
- drivetrain.is_moving
- drivetrain.heading
- drivetrain.rotation
- drivetrain.velocity
Pusher Motor
- pusher_motor.is_done
- pusher_motor.is_spinning
- pusher_motor.position
- pusher_motor.velocity
Kar Motor
- arm_motor.is_done
- arm_motor.is_spinning
- arm_motor.position
- arm_motor.velocity
Elülső távolságérzékelő
- front_distance.is_object_detected
- front_distance.object_distance_mm
- front_distance.object_distance_inches
Elülső optikai érzékelő
- front_optical.is_near_object
- front_optical.color
- front_optical.brightness
- front_optical.hue
GPS-érzékelő
- gps.position_mm
- gps.position_inches
- gps.heading
Tolórúd forgásérzékelője
- pusher_rotation.angle
- pusher_rotation.position
MI-alapú vizuális érzékelő
- ai_vision.object_count
- ai_vision.height
- ai_vision.width
- ai_vision.centerX
- ai_vision.centerY
- ai_vision.originX
- ai_vision.originY
- ai_vision.id

def main():
    # Monitor the robot's heading
    monitor_sensor("drivetrain.heading")
    drivetrain.turn_for(RIGHT, 450, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Érzékelés #

Érintőképernyős LED #

színbeállítás #

set_color beállítja az érintőképernyős LED színét.

Usage:
touchled.set_color(color)

Paraméterek	Leírás
`color`	Az érintőképernyős LED színének beállítása: `NONE` - Kikapcsolja az érintőképernyős LED-et `RED` `GREEN` `BLUE` `YELLOW` `ORANGE` `PURPLE` `WHITE` `RED_VIOLET` `VIOLET` `BLUE_VIOLET` `BLUE_GREEN` `YELLOW_GREEN` `YELLOW_ORANGE` `RED_ORANGE`

Paraméterek

Leírás

color

Az érintőképernyős LED színének beállítása:

NONE - Kikapcsolja az érintőképernyős LED-et
RED

GREEN

BLUE
YELLOW
ORANGE
PURPLE
WHITE
RED_VIOLET
VIOLET
BLUE_VIOLET
BLUE_GREEN
YELLOW_GREEN
YELLOW_ORANGE
RED_ORANGE

def main():
    # Light the Touch LED while placing a Pin.
    touchled.set_color(RED)
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)
    touchled.set_color(NONE)

# VR threads — Do not delete
vr_thread(main)

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.

def main():
    # Wait until the claw no longer detects an object, then lower the lift.
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)
    while optical.is_near_object():
        wait(2, MSEC)
    lift_motor.spin_to_position(0, 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:
optical.color()

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

def main():
    # Wait until the Optical Sensor detects red, then lower the lift.
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)
    while not optical.color() == RED:
        wait(5, MSEC)
    lift_motor.spin_to_position(0, 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:
optical.brightness()

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

def main():
    # Lower the lift once the claw sees a darker object.
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)
    while not 30 > optical.brightness():
        wait(5, MSEC)
    lift_motor.spin_to_position(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

színárnyalat #

hue Az 1-es paraméter a detektált szín árnyalatértékét adja vissza decimális formában (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:
optical.hue()

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

def main():
    # Lower the lift once the Optical Sensor reports a hue value.
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)
    while not optical.hue() > 0:
        wait(5, MSEC)
    lift_motor.spin_to_position(0, 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:
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 pin_in_claw():
    touchled.set_color(RED)

def main():
    # Change the Touch LED color when the claw detects an object.
    optical.object_detected(pin_in_claw)
    touchled.set_color(GREEN)
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# 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:
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_lift():
    # Lower the lift when the claw no longer holds an object.
    lift_motor.spin_to_position(0, DEGREES)

def main():
    optical.object_lost(lower_lift)
    lift_motor.spin_for(REVERSE, 600, DEGREES)
    drivetrain.drive_for(FORWARD, 140, MM)
    claw_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)