Python specifický pro roboty#

Zavedení #

Hrdinský robot Dex má dva motory: senzor s umělou inteligencí, optický senzor a senzor GPS (Game Positioning System).

Všechny standardní metody VR kódu VEX jsou k dispozici pro použití na hřišti V5 25-26 Push Back.

Níže je uveden seznam všech dostupných metod specifických pro roboty:

Pohon – Pohyb a otáčení robota.

Akce
- drive — Pohybuje robota vpřed nebo vzad natrvalo.
- drive_for — Pohybuje robotem vpřed nebo vzad o určitou vzdálenost.
- turn — Otočí robota doleva nebo doprava natrvalo.
- turn_for — Otočí robota doleva nebo doprava o určitý počet stupňů.
- turn_to_heading — Otočí robota tak, aby směřoval v určitém směru, od -359 do 359 stupňů.
- turn_to_rotation — Otočí robota do určité rotace.
- stop — Zastaví pohyb robota.
Mutátory
- set_heading — Změní aktuální směr robota na nový směr.
- set_rotation — Změní aktuální rotaci robota na novou rotaci.
- set_timeout — Nastaví, jak dlouho se bude robot snažit dokončit pohyb.
- set_drive_velocity — Říká robotovi, jak rychle má jet.
- set_turn_velocity — Říká robotovi, jak rychle se má otáčet.
Získávači
- heading — Vrátí aktuální směr robota od 0 do 359,99 stupňů.
- rotation — Vrátí aktuální rotaci robota.
- is_done — Vrátí, zda robot dokončil pohyb, jako booleovskou hodnotu.
- is_moving — Vrátí, zda se robot pohybuje, jako booleovskou hodnotu.
- velocity — Vrátí rychlost, s jakou se robot pohybuje.

Pohyb – Pohybujte a sledujte motory robota.

Akce
- spin — Roztočí motor dopředu nebo dozadu navždy.
- spin_for — Roztočí motor o určitou vzdálenost.
- spin_to_position — Roztočí motor do určité polohy.
- stop — Zastaví otáčení motoru.
Mutátory
- set_position — Změní aktuální polohu motoru na novou hodnotu.
- set_velocity — Říká motoru, jak rychle se má otáčet.
- set_timeout — Nastavuje, jak dlouho se bude motor snažit dokončit pohyb.
Získávači
- is_done — Vrátí, zda se motor rozhýbal, jako booleovskou hodnotu.
- is_spinning — Vrátí hodnotu typu Boolean, zda se motor otáčí.
- position — Vrátí aktuální polohu motoru.
- velocity — Vrátí rychlost otáčení motoru.

AI Vision – Zachyťte a analyzujte objekty pomocí senzoru AI Vision.

Získávači
- take_snapshot – Vrátí n-tici detekovaných objektů pro specifický podpis.
Vlastnosti
- width – Šířka detekovaného objektu v pixelech.
- height – Výška detekovaného objektu v pixelech.
- centerX – Pozice středu objektu na ose X v pixelech.
- centerY – Pozice středu objektu na ose Y v pixelech.
- originX – Pozice levého horního rohu objektu na ose X v pixelech.
- originY – Pozice Y levého horního rohu objektu v pixelech.
- id – Klasifikace nebo ID tagu objektu.

Konzola – Výpis do konzole a sledování hodnot.

Vytisknout
- brain.screen.print — Zobrazí text, čísla nebo hodnoty proměnných v konzoli.
- brain.screen.next_row — Přesune kurzor konzole na začátek dalšího řádku.
- brain.screen.clear_screen — Vymaže všechny řádky z konzole.
Monitor
- monitor_variable — Přidá jednu nebo více předdefinovaných proměnných na kartu Monitor.
- monitor_sensor — Přidá jednu nebo více hodnot senzoru na kartu Monitor.

Snímání – Využijte různé senzory robota.

Optický
- is_near_object – Vrací, zda optický senzor detekuje objekt v dosahu.
- color – Vrací barvu detekovanou optickým senzorem.
- brightness – Vrátí množství světla odraženého od objektu.
- hue – Vrací odstín detekovaný optickým senzorem.
- object_detected – Registruje funkci, která má být volána, když optický senzor detekuje objekt.
- object_lost – Registruje funkci, která se má volat, když optický senzor ztratí objekt.
GPS
- x_position – Vrátí aktuální souřadnici x GPS senzoru na poli.
- y_position – Vrátí aktuální souřadnici y GPS senzoru na poli.
- heading – Vrátí směr, kterým se robot aktuálně nachází, na základě údajů GPS senzoru od 0 do 359 stupňů.

Příklady na této stránce používají výchozí počáteční pozici hřiště.

Hnací ústrojí #

Pohon řídí, jak se VR robot řídí a zatáčí. Pohon se může pohybovat vpřed nebo vzad, zatáčet doleva nebo doprava, otáčet se do směru a sledovat svou rotaci.

Akce #

řídit #

drive pohybuje robotem vpřed nebo vzad navždy. Robot se bude pohybovat, dokud mu nebude přidělena jiná akce, například otočení nebo zastavení.

Usage:
drivetrain.drive(direction)

Parametry	Popis
`direction`	Směr pohybu robota: `FORWARD` nebo `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 pohybuje robotem vpřed nebo vzad o určitou vzdálenost. Projekt počká, dokud se robot nedokončí s pohybem, než se spustí další řádek kódu.

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

Parametry	Popis
`direction`	Směr pohybu robota: `FORWARD` nebo `REVERSE`.
`distance`	Vzdálenost, kterou robot urazí. Může to být `integer` nebo desetinné číslo (`float`).
`units`	Volitelné. Jednotka vzdálenosti: `INCHES` (výchozí) nebo `MM` (milimetry).
`wait`	Volitelné. `wait=True` (výchozí) způsobí, že projekt počká, dokud se robot nedokončí s pohybem, než se spustí další řádek kódu. `wait=False` způsobí, že se další řádek kódu spustí okamžitě.

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)

otočit #

turn otáčí robota doleva nebo doprava navždy. Robot se bude otáčet, dokud nedostane další akci, například jízdu nebo zastavení.

Usage:
drivetrain.turn(direction)

Parametry	Popis
`direction`	Směr otáčení robota: `LEFT` nebo `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 otočí robota doleva nebo doprava o určitý počet stupňů. Otočení je relativní vzhledem k aktuální poloze robota. Projekt počká, dokud se robot nedokončí s otáčením, než se spustí další řádek kódu.

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

Parametry	Popis
`direction`	Směr otáčení robota: `LEFT` nebo `RIGHT`.
`angle`	Počet stupňů, o které se robot otočí. Může to být `integer` nebo desetinné číslo (`float`).
`units`	Volitelné. Jednotka rotace: `DEGREES` (výchozí).
`wait`	Volitelné. `wait=True` (výchozí) způsobí, že projekt počká, dokud robot nedokončí otáčení, než se spustí další řádek kódu. `wait=False` způsobí, že se další řádek kódu spustí okamžitě.

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)

odbočka_k_směru #

Směr je směr, kterým je robot otočen, měřený ve stupních. turn_to_heading otočí robota do určitého směru od -359 do 359 stupňů. Robot se otočí nejkratším směrem, aby dosáhl cílového směru.

Výchozí směr robota je 0 stupňů.

Projekt počká, dokud se robot nedotočí, než se spustí další řádek kódu.

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

Parametry	Popis
`angle`	Směr, kterým by se měl robot otočit, ve stupních. Může to být `integer` nebo desetinné číslo (`float`) od -359 do 359.
`units`	Volitelné. Jednotka rotace: `DEGREES` (výchozí).
`wait`	Volitelné. `wait=True` (výchozí) způsobí, že projekt počká, dokud robot nedokončí otáčení, než se spustí další řádek kódu. `wait=False` způsobí, že se další řádek kódu spustí okamžitě.

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)

otočení_k_rotaci #

turn_to_rotation otočí robota do určité rotace.

Rotace udává, o kolik se robot otočil, měřeno ve stupních. Na začátku projektu je hodnota rotace nastavena na 0 stupňů. Rotaci lze také nastavit pomocí metody set_rotation.

Hodnoty rotace jsou absolutní. To znamená, že směr otáčení závisí na aktuální rotaci robota. Otočení doprava rotaci zvyšuje a otáčení doleva snižuje.

Například pokud robot začne na 0 stupních a otočíte se o 720 stupňů, otočí se dvakrát doprava. Pokud se poté otočíte o 360 stupňů, otočí se jednou doleva, protože 360 je menší než 720.

Projekt počká, dokud se robot nedotočí, než se spustí další řádek kódu.

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

Parametry	Popis
`angle`	Hodnota rotace ve stupních, na kterou se robot otočí. Může to být `integer` nebo desetinné číslo (`float`).
`units`	Volitelné. Jednotka rotace: `DEGREES` (výchozí).
`wait`	Volitelné. `wait=True` (výchozí) způsobí, že projekt počká, dokud robot nedokončí otáčení, než se spustí další řádek kódu. `wait=False` způsobí, že se další řádek kódu spustí okamžitě.

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)

zastávka #

stop zastaví pohyb robota.

Usage:
drivetrain.stop()

Parametry	Popis
	Tato metoda nemá žádné parametry.

def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

Mutátory #

nastavit_nadpis #

Směr je směr, kterým je robot otočen, měřený ve stupních. set_heading změní aktuální směr robota na novou hodnotu směru.

Například pokud se robot otočil čelem doprava, nastavením směru na 0 stupňů se tato poloha směřující doprava stane novými 0 stupni. Robot se pak může na základě tohoto nového směru otáčet do jiných pozic.

Usage:
drivetrain.set_heading(heading, units)

Parametry	Popis
`heading`	Hodnota směru ve stupních, kterou chcete nastavit pro robota. Může to být `integer` nebo desetinné číslo (`float`).
`units`	Volitelné. Jednotka záhlaví: `DEGREES` (výchozí).

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)

set_rotation #

Rotace udává, o kolik se robot otočil, měřeno ve stupních. Na začátku projektu je hodnota rotace nastavena na 0 stupňů. set_rotation změní aktuální rotaci robota na novou hodnotu.

Například pokud robot provedl dvě plné otáčky doprava, jeho hodnota rotace bude 720 stupňů. Nastavením rotace na 0 stupňů se tato hodnota resetuje ze 720 na 0 stupňů. Robot se pak může otáčet na základě této nové hodnoty.

Usage:
drivetrain.set_rotation(rotation, units)

Parametry	Popis
`rotation`	Hodnota rotace ve stupních, kterou chcete nastavit pro robota. Může to být `integer` nebo desetinné číslo (`float`).
`units`	Volitelné. Jednotka rotace: `DEGREES` (výchozí).

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)

set_timeout #

set_timeout nastavuje, jak dlouho se robot bude snažit dokončit pohyb. Pokud robot nedokončí pohyb v tomto čase, přestane se snažit a přesune se na další řádek kódu. Tím se zabrání tomu, aby se robot zasekl na pohybu.

Usage:
drivetrain.set_timeout(value, units)

Parametry	Popis
`value`	Doba, po kterou se robot může pokusit dokončit pohyb. Může to být kladné celé číslo `integer` nebo desetinné číslo (`float`).
`units`	Časová jednotka: `SECONDS` nebo `MSEC` (milisekundy).

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 říká robotovi, jak rychle má jet. Vyšší procento způsobí, že robot jede rychleji, a nižší procento způsobí, že robot jede pomaleji.

Každý projekt začíná s robotem, který se standardně pohybuje rychlostí 50 %.

Poznámka: Vyšší rychlost zrychluje pohyb robota, ale může být méně přesný. Nižší rychlost zpomaluje pohyb robota, ale může být přesnější.

Usage:
drivetrain.set_drive_velocity(velocity, units)

Parametry	Popis
`velocity`	Rychlost, s níž se má jet, od 0 % do 100 %. Může to být `integer` nebo desetinné číslo (`float`).
`units`	Volitelné. Jednotka rychlosti: `PERCENT` (výchozí).

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)

set_turn_velocity #

set_turn_velocity říká robotovi, jak rychle se má otáčet. Vyšší procento způsobí, že se robot bude otáčet rychleji, a nižší procento způsobí, že se robot bude otáčet pomaleji.

Každý projekt začíná s robotem, který se standardně otáčí rychlostí 50 %.

Poznámka: Vyšší rychlost způsobí, že se robot otáčí rychleji, ale může být méně přesný. Nižší rychlost způsobí, že se robot otáčí pomaleji, ale může být přesnější.

Usage:
drivetrain.set_turn_velocity(velocity, units)

Parametry	Popis
`velocity`	Rychlost otáčení od 0 % do 100 %. Může to být `integer` nebo desetinné číslo (`float`).
`units`	Volitelné. Jednotka rychlosti: `PERCENT` (výchozí).

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)

Gettery #

záhlaví #

Směr je směr, kterým je robot otočen, měřený ve stupních. heading vrací aktuální směr robota od 0 do 359,99 stupňů.

Výchozí směr robota je 0 stupňů.

Usage:
drivetrain.heading(units)

Parametry	Popis
`units`	Volitelné. Jednotka záhlaví: `DEGREES` (výchozí).

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)

otáčení #

Rotace udává, o kolik se robot otočil, měřeno ve stupních. Na začátku projektu je hodnota rotace nastavena na 0 stupňů. rotation vrací aktuální rotaci robota.

Otočení doprava zvětšuje rotaci a otočení doleva ji snižuje. Například provedení dvou celých otoček doprava vrátí rotaci o 720 stupňů.

Usage:
drivetrain.rotation(units)

Parametry	Popis
`units`	Volitelné. Jednotka rotace: `DEGREES` (výchozí).

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)

je_hotovo #

is_done vrací hodnotu typu Boolean, zda robot dokončil pohyb. Tuto hodnotu lze použít k řízení načasování dalších chování na základě pohybu robota.

True — Robot dokončil pohyb.
False — Robot se stále pohybuje.

Tato metoda spolupracuje s následujícími metodami Drivetrain, které mají parametr wait : drive_for, turn_for, turn_to_heading a turn_to_rotation.

Usage:
drivetrain.is_done()

Parametry	Popis
	Tato metoda nemá žádné parametry.

se_pohybuje #

is_moving vrací booleovskou hodnotu, zda se robot pohybuje. Tuto hodnotu lze použít k řízení načasování dalších chování na základě pohybu robota.

True — Robot se pohybuje.
False — Robot se nepohybuje.

Usage:
drivetrain.is_moving()

Parametry	Popis
	Tato metoda nemá žádné parametry.

rychlost #

velocity vrací rychlost, jak se robot pohybuje, v procentech od -100 % do 100 %.

Usage:
drivetrain.velocity(units)

Parametry	Popis
`units`	Volitelné. Jednotka rychlosti: `PERCENT` (výchozí).

Příklad

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

Pohyb #

Dex používá sací motor k vtahování bloků do robota. Motor dopravníku přesouvá bloky ze sání na horní část robota, aby je bylo možné zatlačit do branky.

Každý motor má své vlastní směrové chování. Popisy směrů vysvětlují, jak každý směr pohybuje daným motorem na Dexu.

Akce #

roztočit #

spin roztočí motor dopředu nebo dozadu navždy. Motor se bude otáčet, dokud nedostane jinou akci, například se roztočí jiným směrem nebo se zastaví.

Použití:
S touto metodou lze použít jeden ze dvou dostupných objektů motoru, jak je znázorněno níže:

motor	Příkaz
`intake_motor`	`intake_motor.spin(direction)` — Sací motor
`conveyor_motor`	`conveyor_motor.spin(direction)` — Motor dopravníku

Parametry

Popis

direction

Směr otáčení motoru:

FORWARD — Roztočí motor dopravníku nahoru nebo roztočí motor sání ve směru sání.
REVERSE — Roztočí motor dopravníku dolů nebo roztočí motor sání ve směru výfuku.

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)

# VR threads — Do not delete
vr_thread(main)

spin_for #

spin_for roztočí motor o určitou vzdálenost. Otáčení je relativní vzhledem k aktuální poloze motoru. Projekt počká, dokud se motor nedotočí, než se spustí další řádek kódu.

Použití:
S touto metodou lze použít jeden ze dvou dostupných objektů motoru, jak je znázorněno níže:

motor	Příkaz
`intake_motor`	`intake_motor.spin_for(direction, distance, units, wait)` — Sací motor
`conveyor_motor`	`conveyor_motor.spin_for(direction, distance, units, wait)` — Motor dopravníku

Parametry	Popis
`direction`	Směr otáčení motoru: `FORWARD` — Roztočí motor dopravníku nahoru nebo roztočí motor sání ve směru sání. `REVERSE` — Roztočí motor dopravníku dolů nebo roztočí motor sání ve směru výfuku.
`distance`	Vzdálenost, o kterou se motor otočí. `DEGREES` použijte celá čísla. `TURNS` můžete použít celá čísla nebo desetinná čísla.
`units`	Volitelné. Jednotka vzdálenosti: `DEGREES` (výchozí) nebo `TURNS`.
`wait`	Volitelné. `wait=True` (výchozí) — Projekt počká, dokud se motor nedotočí, než se spustí další řádek kódu. `wait=False` — Další řádek kódu se spustí okamžitě.

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)

# VR threads — Do not delete
vr_thread(main)

otočení_do_pozice #

spin_to_position roztočí motor do určité polohy.

Poloha motoru udává, o kolik se otočil, měřeno v DEGREES nebo TURNSJedna otáčka se rovná 360 stupňům. Na začátku projektu je poloha motoru nastavena na 0 stupňů. Polohu motoru lze také nastavit metodou set_position.

Hodnoty polohy jsou absolutní. To znamená, že směr otáčení závisí na aktuální poloze motoru.

Například pokud se motor spustí při 0 stupních a otočí se do polohy 720 stupňů, otočí se o dvě otáčky dopředu. Pokud se poté otočí do polohy 360 stupňů, otočí se o jednu otáčku dozadu, protože 360 je menší než 720.

Použití:
S touto metodou lze použít jeden ze dvou dostupných objektů motoru, jak je znázorněno níže:

motor	Příkaz
`intake_motor`	`intake_motor.spin_to_position(angle, units, wait=True)` — Sací motor
`conveyor_motor`	`conveyor_motor.spin_to_position(angle, units, wait=True)` — Motor dopravníku

Parametry	Popis
`angle`	Hodnota polohy, do které se motor otočí. `DEGREES` použijte celá čísla. `TURNS` můžete použít celá čísla nebo desetinná čísla.
`units`	Volitelné. Jednotka polohy: `DEGREES` (výchozí) nebo `TURNS`.
`wait`	Volitelné. `wait=True` (výchozí) — Projekt počká, dokud se motor nedotočí, než se spustí další řádek kódu. `wait=False` — Další řádek kódu se spustí okamžitě.

Parametry

Popis

angle

Hodnota polohy, do které se motor otočí. DEGREES použijte celá čísla. TURNS můžete použít celá čísla nebo desetinná čísla.

units

Volitelné. Jednotka polohy: DEGREES (výchozí) nebo TURNS.

wait

Volitelné.

wait=True (výchozí) — Projekt počká, dokud se motor nedotočí, než se spustí další řádek kódu.
wait=False — Další řádek kódu se spustí okamžitě.

def main():
    # Pick up a second Block
    conveyor_motor.spin_to_position(150, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)

# VR threads — Do not delete
vr_thread(main)

zastávka #

stop zastaví otáčení motoru.

Použití:
S touto metodou lze použít jeden ze dvou dostupných objektů motoru, jak je znázorněno níže:

motor	Příkaz
`intake_motor`	`intake_motor.stop()` — Sací motor
`conveyor_motor`	`conveyor_motor.stop()` — Motor dopravníku

Parametry	Popis
	Tato metoda nemá žádné parametry.

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

Mutátory #

set_position #

Poloha motoru udává, o kolik se otočil, měřeno v DEGREES nebo TURNSJedna otáčka se rovná 360 stupňům. set_position změní aktuální polohu motoru na novou hodnotu.

Například pokud se motor otočil o 180 stupňů, nastavení polohy na 0 stupňů resetuje tuto polohu ze 180 na 0 stupňů. Motor se pak může otáčet do pozic na základě této nové hodnoty.

Použití:
S touto metodou lze použít jeden ze dvou dostupných objektů motoru, jak je znázorněno níže:

motor	Příkaz
`intake_motor`	`intake_motor.set_position(position, units)` — Sací motor
`conveyor_motor`	`conveyor_motor.set_position(position, units)` — Motor dopravníku

Parametry	Popis
`position`	Hodnota polohy, která se má nastavit pro motor. `DEGREES` použijte celá čísla. `TURNS` můžete použít celá čísla nebo desetinná čísla.
`units`	Volitelné. Jednotka polohy: `DEGREES` (výchozí) nebo `TURNS`.

def main():
    # Pick up a second Block
    conveyor_motor.set_position(-150, DEGREES)
    conveyor_motor.spin_to_position(0, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 350, MM)

# VR threads — Do not delete
vr_thread(main)

set_velocity #

set_velocity určuje, jak rychle se má motor otáčet. Vyšší procento způsobí, že se motor otáčí rychleji, a nižší procento, že se motor otáčí pomaleji.

Každý projekt začíná s tím, že se každý motor standardně otáčí rychlostí 50 %.

Poznámka: Vyšší rychlost způsobí, že se motor otáčí rychleji, ale může to být méně přesné. Nižší rychlost způsobí, že se motor otáčí pomaleji, ale může to být přesnější.

Použití:
S touto metodou lze použít jeden ze dvou dostupných objektů motoru, jak je znázorněno níže:

motor	Příkaz
`intake_motor`	`intake_motor.set_velocity(velocity, units)` — Sací motor
`conveyor_motor`	`conveyor_motor.set_velocity(velocity, units)` — Motor dopravníku

Parametry	Popis
`velocity`	Rychlost otáčení od 0 % do 100 %. Může to být `integer` nebo desetinné číslo (`float`).
`units`	Jednotka rychlosti: `PERCENT`.

def main():
    # Pick up a second Block
    conveyor_motor.set_velocity(90, PERCENT)
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 400, MM)

# VR threads — Do not delete
vr_thread(main)

set_timeout #

set_timeout nastavuje, jak dlouho se bude motor snažit dokončit pohyb. Pokud motor nedokončí pohyb v tomto čase, přestane se snažit a přejde na další řádek kódu. Tím se zabrání tomu, aby se motor zasekl na pohybu.

Použití:
S touto metodou lze použít jeden ze dvou dostupných objektů motoru, jak je znázorněno níže:

motor	Příkaz
`intake_motor`	`intake_motor.set_timeout(value, units)` — Sací motor
`conveyor_motor`	`conveyor_motor.set_timeout(value, units)` — Motor dopravníku

Parametry	Popis
`value`	Doba, po kterou se motor může pokusit dokončit pohyb. Může to být kladné celé číslo `integer` nebo desetinné číslo (`float`).
`units`	Časová jednotka: `SECONDS` nebo `MSEC` (milisekundy).

def main():
    # Pick up a second Block
    conveyor_motor.set_timeout(0.5, SECONDS)
    conveyor_motor.spin_to_position(1000, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 400, MM)

# VR threads — Do not delete
vr_thread(main)

Gettery #

je_hotovo #

is_done vrací hodnotu typu Boolean, zda se motor dokončil v pohybu. Tuto hodnotu lze použít k řízení načasování dalších funkcí na základě pohybu motoru.

True — Motor se roztočil.
False — Motor se stále točí.

Tato metoda spolupracuje s následujícími metodami Motion, které mají parametr wait : spin_for a spin_to_position.

Použití:
S touto metodou lze použít jeden ze dvou dostupných objektů motoru, jak je znázorněno níže:

motor	Příkaz
`intake_motor`	`intake_motor.is_done()` — Sací motor
`conveyor_motor`	`conveyor_motor.is_done()` — Motor dopravníku

Parametry	Popis
	Tato metoda nemá žádné parametry.

def main():
    # Pick up a second Block
    conveyor_motor.spin_to_position(300, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while not conveyor_motor.is_done():
        drivetrain.drive(FORWARD)
        intake_motor.spin(FORWARD)
        wait(5, MSEC)
    drivetrain.stop()
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

se točí #

is_spinning vrací booleovskou hodnotu, zda se motor otáčí. Tuto hodnotu lze použít k řízení načasování dalších chování na základě pohybu motoru.

True — Motor se točí.
False — Motor se netočí.

Tato metoda spolupracuje s následujícími metodami Motion, které mají parametr wait : spin_for a spin_to_position.

Použití:
S touto metodou lze použít jeden ze dvou dostupných objektů motoru, jak je znázorněno níže:

motor	Příkaz
`intake_motor`	`intake_motor.is_spinning()` — Sací motor
`conveyor_motor`	`conveyor_motor.is_spinning()` — Motor dopravníku

Parametry	Popis
	Tato metoda nemá žádné parametry.

def main():
    # Pick up a second Block
    conveyor_motor.spin_to_position(300, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while conveyor_motor.is_spinning():
        drivetrain.drive_for(FORWARD, 200, MM)
        intake_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

pozice #

Poloha motoru udává, o kolik se otočil, měřeno v DEGREES nebo TURNSJedna otáčka se rovná 360 stupňům. position vrací aktuální polohu motoru.

Na začátku projektu je poloha motoru nastavena na 0 stupňů. Pokud se motor otočí o jednu celou otáčku dopředu, poloha bude 360 stupňů neboli 1 otáčka. Pokud se motor otáčí opačným směrem, poloha bude záporná.

Použití:
S touto metodou lze použít jeden ze dvou dostupných objektů motoru, jak je znázorněno níže:

motor	Příkaz
`intake_motor`	`intake_motor.position(units)` — Sací motor
`conveyor_motor`	`conveyor_motor.position(units)` — Motor dopravníku

Parametry	Popis
`units`	Jednotka pro návrat do polohy motoru: `DEGREES` nebo `TURNS`.

def main():
    # Pick up a second Block
    while conveyor_motor.position(DEGREES) < 150:
        conveyor_motor.spin(FORWARD)
        wait(2, MSEC)
    conveyor_motor.stop()
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 400, MM)

# VR threads — Do not delete
vr_thread(main)

rychlost #

velocity vrací, jak rychle se motor otáčí.

Kladná hodnota znamená, že se motor otáčí dopředu. Záporná hodnota znamená, že se motor otáčí dozadu.

Použití:
S touto metodou lze použít jeden ze dvou dostupných objektů motoru, jak je znázorněno níže:

motor	Příkaz
`intake_motor`	`intake_motor.velocity(units)` — Sací motor
`conveyor_motor`	`conveyor_motor.velocity(units)` — Motor dopravníku

Parametry	Popis
`units`	Jednotka rychlosti, která se má vrátit: `PERCENT`.

def main():
    # Pick up a second block
    conveyor_motor.set_velocity(100, PERCENT)
    conveyor_motor.spin_to_position(300, DEGREES, wait=False)
    wait(0.2, SECONDS)
    brain.screen.print(conveyor_motor.velocity(PERCENT))
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 400, MM)

# VR threads — Do not delete
vr_thread(main)

Vize umělé inteligence #

Gettery #

pořídit_snímek #

Funkce take_snapshot filtruje data z rámce senzoru AI Vision do jediného podpisu – uloženého popisu něčeho, co senzor dokáže rozpoznat, například herního prvku na hřišti – a vrací n-tici.

N-tice ukládá objekty seřazené od největší po nejmenší podle šířky, počínaje indexem 0. K vlastnostem properties každého objektu lze přistupovat pomocí jeho indexu. Pokud nejsou detekovány žádné odpovídající objekty, vrátí se prázdná n-tice.

Usage:
ai_vision.take_snapshot(signature)

Parametry	Popis
`signature`	Filtruje datovou sadu tak, aby zahrnovala pouze data daného podpisu. Dostupné podpisy jsou: `AiVision.ALL_AIOBJS` - Detekuje červené a modré bloky.

Parametry

Popis

signature

Filtruje datovou sadu tak, aby zahrnovala pouze data daného podpisu. Dostupné podpisy jsou:

AiVision.ALL_AIOBJS - Detekuje červené a modré bloky.

def main():
    # If an object is detected, pick it up
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            intake_motor.spin(FORWARD)
            drivetrain.drive(FORWARD)
            while not bumper.pressing():
                wait(2, MSEC)
            drivetrain.stop()
            break

# VR threads — Do not delete
vr_thread(main)

Nemovitosti #

Každý objekt uložený v n-tici po použití take_snapshot obsahuje sedm vlastností.

All property values except .id describe the detected object’s position and size in the AI Vision Sensor’s view at the moment take_snapshot was used. These values are measured in pixels, based on the sensor’s 320 by 240 pixel resolution.

.šířka #

.width vrací šířku detekovaného objektu v pixelech, což je celé číslo mezi 1 a 320.

def main():
    # If an object is detected, approach and pick it up
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].width > 65:
                drivetrain.stop()
                break
            else:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.výška #

.height vrací výšku detekovaného objektu v pixelech, což je celé číslo mezi 1 a 240.

def main():
    # If an object is detected, approach and pick it up
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].height > 55:
                drivetrain.stop()
                break
            else:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.centerX #

.centerX vrací souřadnici x středu detekovaného objektu v pixelech, což je celé číslo mezi 0 a 320.

def main():
    # Pick up a Block from the top left group
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    drivetrain.turn_for(LEFT, 80, DEGREES)
    drivetrain.drive_for(FORWARD, 200, MM)
    drivetrain.set_turn_velocity(20, PERCENT)
    drivetrain.turn(LEFT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if 140 < ai_objects[0].centerX < 180:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)
                while not bumper.pressing():
                    wait(2, MSEC)
                drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

.centerY #

.centerY vrací souřadnici y středu detekovaného objektu v pixelech, což je celé číslo mezi 0 a 240.

def main():
    # If an object is detected, approach and pick it up
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].centerY > 140:
                drivetrain.stop()
                break
            else:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.originX #

.originX vrací souřadnici x levého horního rohu ohraničovacího rámečku detekovaného objektu v pixelech, což je celé číslo mezi 0 a 320.

def main():
    # Pick up a Block from the top left group
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    drivetrain.turn_for(LEFT, 80, DEGREES)
    drivetrain.drive_for(FORWARD, 300, MM)
    drivetrain.set_turn_velocity(20, PERCENT)
    drivetrain.turn(RIGHT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if 100 < ai_objects[0].originX < 140:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)
                while not bumper.pressing():
                    wait(2, MSEC)
                drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

.originY #

.originY vrací souřadnici y levého horního rohu ohraničovacího rámečku detekovaného objektu v pixelech, což je celé číslo mezi 0 a 240.

def main():
    # If an object is detected, approach and pick it up
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].originY > 120:
                drivetrain.stop()
                break
            else:
                intake_motor.spin(FORWARD)
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.id #

.id vrací ID detekované klasifikace AI jako celé číslo.

Klasifikace umělé inteligence	identifikační číslo	Podpis
BlueBlock	1	`GameElements.BLUE_BLOCK`
RedBlock	2	`GameElements.RED_BLOCK`

def main():
    # Pick up a Red Block from the top left group
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    drivetrain.turn_for(LEFT, 80, DEGREES)
    drivetrain.drive_for(FORWARD, 300, MM)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            drivetrain.drive(FORWARD)
            if (ai_objects[0].id) == 2:
                intake_motor.spin(FORWARD)
                while not bumper.pressing():
                    wait(2, MSEC)
                drivetrain.stop()
                break

# VR threads — Do not delete
vr_thread(main)

Utěšit #

Konzole zobrazuje text, čísla a hodnoty proměnných během spuštěného projektu. Metody konzole mohou také přesunout kurzor na nový řádek, vymazat konzoli a přidat proměnné nebo hodnoty senzorů na kartu Monitor.

Vytisknout #

mozek.sítotisk.#

brain.screen.print zobrazí text, čísla nebo hodnoty proměnných v konzoli s využitím aktuální pozice kurzoru.

Použijte brain.screen.next_row, pokud chcete, aby další vytištěná hodnota začínala na novém řádku.

Usage:
brain.screen.print(value)

Parametry	Popis
`value`	Text, číslo nebo hodnota proměnné, která se má zobrazit v konzoli.

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

# VR threads — Do not delete
vr_thread(main)

Konzole VEXcode zobrazující konzoli a text „Ahoj, robote!“

brain.screen.next_row #

brain.screen.next_row přesune kurzor do sloupce 1 na dalším řádku v konzoli. Další vypsaná hodnota se zobrazí na tomto řádku.

Usage:
brain.screen.next_row()

Parametry	Popis
	Tato metoda nemá žádné parametry.

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)

Konzole VEXcode zobrazující konzoli a text „Řádek 1“ zobrazený na prvním řádku a „Řádek 2“ na druhém řádku.

brain.screen.clear_screen #

brain.screen.clear_screen vymaže všechny řádky z konzole a přesune kurzor zpět na řádek 1.

Usage:
brain.screen.clear_screen()

Parametry	Popis
	Tato metoda nemá žádné parametry.

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 #

monitorovací_proměnná #

monitor_variable přidá jednu nebo více předdefinovaných proměnných na kartu Monitor ve VEXcode. To umožňuje sledovat změnu hodnoty proměnné během běhu projektu.

Proměnné musí být globální, aby bylo možné je úspěšně monitorovat pomocí parametru monitor_variable Název každé proměnné zadejte jako řetězec.

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

Parametry	Popis
`variable`	Název předdefinované globální proměnné, která se má sledovat, zadaný jako řetězec. Chcete-li sledovat více než jednu proměnnou, oddělte jednotlivé názvy proměnných čárkou.

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_senzor #

monitor_sensor přidá jednu nebo více hodnot senzorů na kartu Monitor ve VEXcode. To umožňuje sledovat změny hodnot senzorů během běhu projektu.

Každou hodnotu senzoru zadejte jako řetězec.

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

Parametry	Popis
`sensor`	Hodnota senzoru, která se má sledovat, zadaná jako řetězec. Chcete-li sledovat více hodnot senzoru, oddělte je čárkou. Podporované identifikátory senzorů zahrnují: 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` Arm Motor `arm_motor.is_done` `arm_motor.is_spinning` `arm_motor.position` `arm_motor.velocity` Přední senzor vzdálenosti `front_distance.is_object_detected` `front_distance.object_distance_mm` `front_distance.object_distance_inches` Přední optický senzor `front_optical.is_near_object` `front_optical.color` `front_optical.brightness` `front_optical.hue` GPS senzor `gps.position_mm` `gps.position_inches` `gps.heading` Senzor otáčení tlačného zařízení `pusher_rotation.angle` `pusher_rotation.position` Senzor AI Vision `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`

Parametry

Popis

sensor

Hodnota senzoru, která se má sledovat, zadaná jako řetězec. Chcete-li sledovat více hodnot senzoru, oddělte je čárkou. Podporované identifikátory senzorů zahrnují:

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
Arm Motor
- arm_motor.is_done
- arm_motor.is_spinning
- arm_motor.position
- arm_motor.velocity
Přední senzor vzdálenosti
- front_distance.is_object_detected
- front_distance.object_distance_mm
- front_distance.object_distance_inches
Přední optický senzor
- front_optical.is_near_object
- front_optical.color
- front_optical.brightness
- front_optical.hue
GPS senzor
- gps.position_mm
- gps.position_inches
- gps.heading
Senzor otáčení tlačného zařízení
- pusher_rotation.angle
- pusher_rotation.position
Senzor AI Vision
- 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)

Snímání #

Optický #

je_blízko_objektu #

is_near_object vrací booleovskou hodnotu, která indikuje, zda optický senzor detekuje objekt v dosahu.

True – Optický senzor detekuje objekt.
False – Optický senzor nedetekuje objekt.

Usage:
optical.is_near_object()

Parametry	Popis
	Tato metoda nemá žádné parametry.

def main():
    # Move the preloaded Block to the top of the Conveyor
    conveyor_motor.spin(FORWARD)
    while not optical.is_near_object():
        wait(2, MSEC)
    conveyor_motor.stop()

# VR threads — Do not delete
vr_thread(main)

barva #

color vrací instanci třídy Color na základě detekované hodnoty odstínu. Tyto objekty lze porovnat s předdefinovanými objekty Color a vytvořit tak podmíněné příkazy.

Možné barvy jsou:

NONE
RED - Hodnota odstínu mezi 340° a 20°
GREEN - Hodnota odstínu mezi 80° a 140°
BLUE - Hodnota odstínu mezi 200° a 240°
YELLOW - Hodnota odstínu mezi 40° a 60°
ORANGE - Hodnota odstínu mezi 20° a 40°
PURPLE - Hodnota odstínu mezi 240° a 280°
CYAN - Hodnota odstínu mezi 140° a 200°

Poznámka: Optický senzor hledá rozsahy odstínů, které odpovídají zadané barvě. Informace o detekci konkrétních rozsahů odstínů naleznete v části hue.

Usage:
optical.color()

Parametry	Popis
	Tato metoda nemá žádné parametry.

def main():
    # Pick up and move a Blue Block to the top of the Conveyor
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 360, MM)
    conveyor_motor.spin(FORWARD)
    while not optical.color() == BLUE:
        wait(2, MSEC)
    conveyor_motor.stop()

# VR threads — Do not delete
vr_thread(main)

jas #

brightness vrací množství světla odraženého od objektu jako desetinné číslo (float) představující procenta.

Vyšší procento znamená, že se zpět k optickému senzoru odráží více světla. Nižší procento znamená, že se zpět odráží méně světla.

Usage:
optical.brightness()

Parametry	Popis
	Tato metoda nemá žádné parametry.

def main():
    # Move the preloaded Block to the top of the Conveyor
    conveyor_motor.spin(FORWARD)
    while not 0 < optical.brightness():
        wait(2, MSEC)
    conveyor_motor.stop()

# VR threads — Do not delete
vr_thread(main)

odstín #

hue vrací hodnotu odstínu detekované barvy jako desetinné číslo (float) od 0 do 359.

Odstín je způsob, jak popsat barvu pomocí čísel v barevném kruhu.

Kruhové barevné kolo zobrazující celé spektrum odstínů označených stupni po obvodu, které se zvyšují v krocích po 30 stupních od 0° nahoře do 360°.

Usage:
optical.hue()

Parametry	Popis
	Tato metoda nemá žádné parametry.

def main():
    # Pick up and move a Blue Block to the top of the Conveyor
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive_for(FORWARD, 360, MM)
    conveyor_motor.spin(FORWARD)
    while not 220 < optical.hue() < 260:
        wait(2, MSEC)
    conveyor_motor.stop()

# VR threads — Do not delete
vr_thread(main)

detekovaný_objekt #

object_detected registruje funkci, která má být volána vždy, když optický senzor detekuje nový objekt.

Usage:
optical.object_detected(callback, arg)

Parametry	Popis
`callback`	Dříve definovaná funkce, která se provede, když optický senzor detekuje nový objekt.
`arg`	Volitelné. N-tice tuple obsahující argumenty, které se mají předat zpětné funkci. Další informace naleznete v části Použití funkcí s parametry.

def ready_block():
  # Stop the conveyor when Block is at the Sensor
  conveyor_motor.stop()

def main():
  # Move the preloaded Block near the top of the Conveyor
  conveyor_motor.spin(FORWARD)
  optical.object_detected(ready_block)

# VR threads — Do not delete
vr_thread(main)

ztracený_objekt #

object_lost registruje funkci, která má být volána vždy, když optický senzor ztratí detekovaný objekt.

Usage:
optical.object_lost(callback, arg)

Parametry	Popis
`callback`	Dříve definovaná funkce, která se provede, když optický senzor ztratí detekovaný objekt.
`arg`	Volitelné. N-tice tuple obsahující argumenty, které se mají předat zpětné funkci. Další informace naleznete v části Použití funkcí s parametry.

def ready_block():
  # Stop the conveyor when Block is at the top
  conveyor_motor.stop()

def main():
  # Move the preloaded Block to the top of the Conveyor
  conveyor_motor.spin(FORWARD)
  optical.object_lost(ready_block)

# VR threads — Do not delete
vr_thread(main)

GPS #

pozice_x #

x_position vrací aktuální souřadnici x senzoru GPS (Game Positioning System™) na hřišti.

Usage:
gps.x_position(units)

Parametry	Popis
jednotky	Jednotka hodnoty odsazení: `INCHES` nebo `MM`

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive(FORWARD)
    while not gps.x_position(MM) > -795:
        wait(2, MSEC)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

poloha_y #

y_position vrací aktuální souřadnici y senzoru GPS (Game Positioning System™) na hřišti.

Usage:
gps.y_position(units)

Parametry	Popis
jednotky	Jednotka hodnoty odsazení: `INCHES` nebo `MM`

def main():
    # Pick up a second Block
    conveyor_motor.spin_for(FORWARD, 200, DEGREES)
    intake_motor.spin(FORWARD)
    drivetrain.drive(FORWARD)
    while not -450 > gps.y_position(MM):
        wait(2, MSEC)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

záhlaví #

heading vrací směr, kterým se robot aktuálně nachází, na základě údajů ze senzoru GPS (Game Positioning System™) v rozmezí od 0 do 359 stupňů.

Usage:
gps.heading()

Parametry	Popis
	Tato metoda nemá žádné parametry.

def main():
    # Score the preloaded Block into a Center Goal
    drivetrain.set_turn_velocity(30, PERCENT)
    drivetrain.turn(LEFT)
    while not 40 > gps.heading():
        wait(2, MSEC)
    drivetrain.drive_for(FORWARD, 1000, MM)
    drivetrain.turn(RIGHT)
    while not gps.heading() > 310:
        wait(2, MSEC)
    drivetrain.drive_for(REVERSE, 400, MM)
    conveyor_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)