Python specifický pro roboty#

Zavedení #

Hrdinský robot Swish obsahuje jednu variantu motoru, jednu variantu skupiny motorů a optický senzor.

Všechny standardní metody VR kódu VEX jsou k dispozici pro použití na hřišti IQ 24-25 Rapid Relay.

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 — Vrací hodnotu typu Boolean, která ukazuje, zda se robot pohybuje.
- velocity — Vrátí rychlost, s jakou se robot pohybuje.

Pohyb – Pohybujte a sledujte motor a skupinu motorů robota.

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

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 – Vrátí 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.

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`	Jednotka vzdálenosti: `INCHES` 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`	Jednotka rotace: `DEGREES`.
`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`	Jednotka rotace: `DEGREES`.
`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`	Jednotka rotace: `DEGREES`.
`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`	Jednotka záhlaví: `DEGREES`.

def main():
    # Face the new 0 degrees
    drivetrain.set_heading(90, DEGREES)
    drivetrain.turn_to_heading(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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`	Jednotka rotace: `DEGREES`.

def main():
    # Spin counterclockwise two times
    drivetrain.set_rotation(720, DEGREES)
    drivetrain.turn_to_rotation(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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`	Jednotka rychlosti: `PERCENT`.

def main():
    # Drive forward at different velocities
    # Default velocity
    drivetrain.drive_for(FORWARD, 150, MM)
    wait(1, SECONDS)
    # Drive slower
    drivetrain.set_drive_velocity(20, PERCENT)
    drivetrain.drive_for(FORWARD, 150, MM)
    wait(1, SECONDS)
    # Drive faster
    drivetrain.set_drive_velocity(100, PERCENT)
    drivetrain.drive_for(FORWARD, 150, MM)

# VR threads — Do not delete
vr_thread(main)

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`	Jednotka rychlosti: `PERCENT`.

def main():
    # Turn at different velocities
    # Default velocity
    drivetrain.turn_for(RIGHT, 120, DEGREES)
    wait(1, SECONDS)
    # Turn slower
    drivetrain.set_turn_velocity(20, PERCENT)
    drivetrain.turn_for(RIGHT, 120, DEGREES)
    wait(1, SECONDS)
    # Turn faster
    drivetrain.set_turn_velocity(100, PERCENT)
    drivetrain.turn_for(RIGHT, 120, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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`	Jednotka záhlaví: `DEGREES`.

def main():
    # Display the heading after turning
    drivetrain.turn_for(RIGHT, 450, DEGREES)
    brain.screen.print("Heading: ")
    brain.screen.print(drivetrain.heading(DEGREES))

# VR threads — Do not delete
vr_thread(main)

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`	Jednotka rotace: `DEGREES`.

def main():
    # Display the rotation after turning
    drivetrain.turn_for(RIGHT, 450, DEGREES)
    brain.screen.print("Rotation: ")
    brain.screen.print(drivetrain.rotation(DEGREES))

# VR threads — Do not delete
vr_thread(main)

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`	Jednotka rychlosti: `PERCENT`.

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 #

Swish používá sací motor ke sběru koulí a jejich přesunu na katapult. Skupina motorů katapultu se spustí a uvolní rameno katapultu, aby vypustila koule.

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

Akce #

roztočit #

spin roztočí motor nebo skupinu motorů dopředu nebo dozadu navždy. Motor nebo skupina 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 nebo skupiny motorů, jak je znázorněno níže:

motor	Příkaz
`intake_motor`	`intake_motor.spin(direction)` — Sací motor
`catapult_group`	`catapult_group.spin(direction)` — Skupina katapultů

Parametry

Popis

direction

Směr otáčení motoru nebo skupiny motorů:

FORWARD — Otáčí sací motor ve směru sání nebo spouští katapultovací skupinu.
REVERSE — Otáčí sací motor ve směru výfuku nebo uvolňuje katapultovací skupinu.

def main():
    # Spin the Intake Motor to bring a Ball onto the Catapult
    intake_motor.spin(FORWARD)
    wait(2, SECONDS)
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

spin_for #

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

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

motor	Příkaz
`intake_motor`	`intake_motor.spin_for(direction, distance, units, wait=True)` — Sací motor
`catapult_group`	`catapult_group.spin_for(direction, distance, units, wait=True)` — Skupina katapultů

Parametry	Popis
`direction`	Směr otáčení motoru nebo skupiny motorů: `FORWARD` — Otáčí sací motor ve směru sání nebo spouští katapultovací skupinu. `REVERSE` — Otáčí sací motor ve směru výfuku nebo uvolňuje katapultovací skupinu.
`distance`	Vzdálenost, o kterou se motor nebo skupina 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 nebo skupina motorů nedotočí, než se spustí další řádek kódu. `wait=False` — Další řádek kódu se spustí okamžitě.

def main():
    # Release the preloaded Ball
    catapult_group.spin_for(REVERSE, 5, DEGREES)
    # Lower the Catapult to prepare to load another Ball
    catapult_group.spin_for(FORWARD, 1350, DEGREES)

# VR threads — Do not delete
vr_thread(main)

otočení_do_pozice #

spin_to_position otočí motor nebo skupinu motorů do určité polohy.

Poloha motoru nebo skupiny motorů 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 nebo skupiny motorů nastavena na 0 stupňů. Polohu motoru nebo skupiny motorů lze také nastavit metodou set_position.

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

Například pokud se motor nebo skupina motorů spustí na 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 nebo skupiny motorů, jak je znázorněno níže:

motor	Příkaz
`intake_motor`	`intake_motor.spin_to_position(angle, units, wait=True)` — Sací motor
`catapult_group`	`catapult_group.spin_to_position(angle, units, wait=True)` — Skupina katapultů

Parametry	Popis
`angle`	Hodnota polohy, do které se motor nebo skupina 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 nebo skupina 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 nebo skupina 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 nebo skupina motorů nedotočí, než se spustí další řádek kódu.
wait=False — Další řádek kódu se spustí okamžitě.

def main():
    # Release the preloaded Ball
    catapult_group.spin_to_position(-90, DEGREES)
    # Lower the Catapult to prepare to load another Ball
    catapult_group.spin_to_position(1260, DEGREES)

# VR threads — Do not delete
vr_thread(main)

zastavit motor #

stop zastaví otáčení motoru nebo skupiny motorů.

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

motor	Příkaz
`intake_motor`	`intake_motor.stop()` — Sací motor
`catapult_group`	`catapult_group.stop()` — Skupina katapultů

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

def main():
    # Spin the Intake Motor to bring a Ball onto the Catapult
    intake_motor.spin(FORWARD)
    wait(2, SECONDS)
    intake_motor.stop()

# VR threads — Do not delete
vr_thread(main)

Mutátory #

set_position #

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

Například pokud se motor nebo skupina motorů otočily o 180 stupňů, nastavení polohy na 0 stupňů resetuje tuto polohu ze 180 na 0 stupňů. Motor nebo skupina motorů se pak mohou 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 nebo skupiny motorů, jak je znázorněno níže:

motor	Příkaz
`intake_motor`	`intake_motor.set_position(position, units)` — Sací motor
`catapult_group`	`catapult_group.set_position(position, units)` — Skupina katapultů

Parametry	Popis
`position`	Hodnota polohy, která se má nastavit pro motor nebo skupinu 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():
    # Lower the Catapult to prepare to load another Ball
    catapult_group.spin_to_position(1260, DEGREES)
    # Set the new Catapult position to be 0 degrees
    catapult_group.set_position(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_velocity #

set_velocity určuje rychlost otáčení motoru nebo skupiny motorů. Vyšší procento způsobí, že se motor nebo skupina motorů otáčí rychleji, a nižší procento způsobí, že se motor nebo skupina motorů otáčí pomaleji.

Každý projekt začíná s každým motorem nebo skupinou motorů, které se standardně otáčí rychlostí 50 %.

Poznámka: Vyšší rychlost způsobí, že se motor nebo skupina motorů otáčí rychleji, ale může to být méně přesné. Nižší rychlost způsobí, že se motor nebo skupina 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 nebo skupiny motorů, jak je znázorněno níže:

motor	Příkaz
`intake_motor`	`intake_motor.set_velocity(velocity, units)` — Sací motor
`catapult_group`	`catapult_group.set_velocity(velocity, units)` — Skupina katapultů

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

def main():
    # Start spinning the Intake Motor to prepare for picking up a Ball
    intake_motor.set_velocity(100, PERCENT)
    intake_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

set_timeout #

set_timeout nastavuje, jak dlouho se bude motor nebo skupina motorů pokoušet dokončit pohyb. Pokud motor nebo skupina motorů nedokáže v tomto čase dokončit pohyb, přestane se snažit a přesune se na další řádek kódu. Tím se zabrání tomu, aby se motor nebo skupina motorů zasekly na pohybu.

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

motor	Příkaz
`intake_motor`	`intake_motor.set_timeout(value, units)` — Sací motor
`catapult_group`	`catapult_group.set_timeout(value, units)` — Skupina Katapult

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

def main():
    # Limit how long the Catapult waits to reach its target
    catapult_group.set_timeout(2, SECONDS)
    catapult_group.spin_for(FORWARD, 2160, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Gettery #

je_hotovo #

is_done vrací hodnotu, zda je pohyb motoru nebo skupiny motorů dokončen, jako booleovskou hodnotu. Tuto hodnotu lze použít k řízení načasování dalších chování na základě pohybu motoru nebo skupiny motorů.

True — Pohyb motoru nebo skupiny motorů je dokončen.
False — Motor nebo skupina motorů se stále pohybuje.

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 nebo skupiny motorů, jak je znázorněno níže:

motor	Příkaz
`intake_motor`	`intake_motor.is_done()` — Sací motor
`catapult_group`	`catapult_group.is_done()` — Skupina Katapult

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

se točí #

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

True — Motor nebo skupina motorů se otáčí.
False — Motor nebo skupina motorů se neotáčí.

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 nebo skupiny motorů, jak je znázorněno níže:

motor	Příkaz
`intake_motor`	`intake_motor.is_spinning()` — Sací motor
`catapult_group`	`catapult_group.is_spinning()` — Skupina katapultů

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

pozice #

Poloha motoru nebo skupiny motorů 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 nebo skupiny motorů.

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

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

motor	Příkaz
`intake_motor`	`intake_motor.position(units)` — Sací motor
`catapult_group`	`catapult_group.position(units)` — Skupina katapultů

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

def main():
    # Lower the Catapult to prepare to load another Ball
    while not catapult_group.position(DEGREES) == 1260:
        catapult_group.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

rychlost #

velocity vrací rychlost otáčení motoru nebo skupiny motorů.

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

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

motor	Příkaz
`intake_motor`	`intake_motor.velocity(units)` — Sací motor
`catapult_group`	`catapult_group.velocity(units)` — Skupina katapultů

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

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

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

Příkaz brain.screen.print zobrazí text, čísla nebo hodnoty proměnných v konzoli s využitím aktuální pozice kurzoru. Chová se jako příkaz print na stránce API konzole.

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_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` Skupina motorů ramene `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` Sací 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` Skupina motorů sání `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` Motor katapultu `catapult_motor.is_done` `catapult_motor.is_spinning` `catapult_motor.position_degrees` `catapult_motor.position_turns` `catapult_motor.velocity_rpm` `catapult_motor.velocity_percent` Napínací motor katapultu `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` Nárazníky `intake_bumper.pressing` `bumper.pressing` 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` Senzor barev `color.is_near_object` `color.color` `color.brightness` `color.hue`

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_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
Skupina motorů ramene
- 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
Sací 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
Skupina motorů sání
- 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
Motor katapultu
- catapult_motor.is_done
- catapult_motor.is_spinning
- catapult_motor.position_degrees
- catapult_motor.position_turns
- catapult_motor.velocity_rpm
- catapult_motor.velocity_percent
Napínací motor katapultu
- 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
Nárazníky
- intake_bumper.pressing
- bumper.pressing
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
Senzor barev
- 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)

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

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

def main():
    # Launch a loaded Ball once the Intake Optical Sensor detects a Ball
    if intake_optical.is_near_object():
        catapult_group.spin_for(REVERSE, 5, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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

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

def main():
    # Launch a loaded Ball once yellow is detected in the Intake
    if intake_optical.color() == YELLOW:
        catapult_group.spin_for(REVERSE, 5, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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

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

def main():
    # Launch a loaded Ball once the Intake Optical Sensor sees a Ball
    if intake_optical.brightness() > 0:
        catapult_group.spin_for(REVERSE, 5, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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 stupňů nahoře do 360 stupňů.

Usage:
intake_optical.hue()

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

def main():
    # Launch a loaded Ball once the Intake Optical Sensor reports a hue value
    if intake_optical.hue() > 100:
        catapult_group.spin_for(REVERSE, 5, DEGREES)

# VR threads — Do not delete
vr_thread(main)

detekovaný_objekt #

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

Usage:
intake_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 launch_ball():
    catapult_group.spin_for(REVERSE, 5, DEGREES)

def main():
    # Launch the Ball when the Intake Optical Sensor detects an object
    intake_optical.object_detected(launch_ball)

# VR threads — Do not delete
vr_thread(main)

ztracený_objekt #

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

Usage:
intake_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 lower_catapult():
    catapult_group.spin_to_position(1260, DEGREES)

def main():
    # Lower the Catapult when the Intake Optical Sensor no longer detects an object
    intake_optical.object_lost(lower_catapult)

# VR threads — Do not delete
vr_thread(main)