Python specifický pro roboty#

Zavedení #

Hrdinský robot Byte obsahuje dvě možnosti motorových skupin a optický senzor.

Všechny standardní metody VR VEXcode jsou k dispozici pro použití na hřišti IQ 23-24 Full Volume.

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 motorické skupiny robota.

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

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 nedostane další akci, 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 #

set_heading #

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, s jakou 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 #

Byte používá motorovou skupinu ramene ke zvedání a spouštění ramene, aby bylo možné přepravovat bloky. Motorová skupina sání otáčí předními koly pro sběr bloků nebo couvá, aby je skórovala nebo shodila.

Každá skupina motorů má své vlastní směrové chování. Popisy směrů vysvětlují, jak každý směr pohybuje danou skupinou motorů v bajtu.

Akce #

roztočit #

spin roztočí skupinu motorů dopředu nebo dozadu navždy. Skupina motorů se bude otáčet, dokud nedostane další akci, například otočení jiným směrem nebo zastavení.

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

motor	Příkaz
`arm_motor_group`	`arm_motor_group.spin(direction)` — Skupina motorů ramene
`intake_motor_group`	`intake_motor_group.spin(direction)` — Skupina motorů sání

Parametry

Popis

direction

Směr otáčení motorové skupiny:

FORWARD — Zvedá motorovou skupinu ramene nebo otáčí motorovou skupinou sání ve směru sání.
REVERSE — Spustí motorovou skupinu ramene nebo otáčí motorovou skupinou sání ve směru výfuku.

def main():
    # Spin the intake motor forward then stop
    intake_motor_group.spin(FORWARD)
    wait(0.5, SECONDS)
    intake_motor_group.stop()

# VR threads — Do not delete
vr_thread(main)

spin_for #

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

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

motor	Příkaz
`arm_motor_group`	`arm_motor_group.spin_for(direction, distance, units, wait)` — Skupina motorů ramene
`intake_motor_group`	`intake_motor_group.spin_for(direction, distance, units, wait)` — Skupina motorů sání

Parametry	Popis
`direction`	Směr otáčení motorové skupiny: `FORWARD` — Zvedá motorovou skupinu ramene nebo otáčí motorovou skupinou sání ve směru sání. `REVERSE` — Spustí motorovou skupinu ramene nebo otáčí motorovou skupinou sání ve směru výfuku.
`distance`	Vzdálenost, o kterou se motorová skupina 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 motorová skupina nedotočí, než se spustí další řádek kódu. `wait=False` — Další řádek kódu se spustí okamžitě.

def main():
    # Spin the intake motor forward then stop
    intake_motor_group.spin_for(FORWARD, 360, DEGREES)

# VR threads — Do not delete
vr_thread(main)

otočení_do_pozice #

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

Poloha skupiny motorů udává, o kolik se otočila, měřeno v DEGREES nebo TURNSJedna otáčka se rovná 360 stupňům. Na začátku projektu je poloha skupiny motorů nastavena na 0 stupňů. Polohu 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 motorové skupiny.

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

motor	Příkaz
`arm_motor_group`	`arm_motor_group.spin_to_position(angle, units, wait=True)` — Skupina motorů ramene
`intake_motor_group`	`intake_motor_group.spin_to_position(angle, units, wait=True)` — Skupina motorů sání

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

def main():
    # Spin the intake motor forward then stop
    intake_motor_group.spin_to_position(55, DEGREES)

# VR threads — Do not delete
vr_thread(main)

zastávka #

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

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

motor	Příkaz
`arm_motor_group`	`arm_motor_group.stop()` — Skupina motorů ramene
`intake_motor_group`	`intake_motor_group.stop()` — Skupina motorů sání

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

def main():
    # Spin the intake motor forward then stop
    intake_motor_group.spin(FORWARD)
    wait(0.5, SECONDS)
    intake_motor_group.stop()

# VR threads — Do not delete
vr_thread(main)

Mutátory #

set_position #

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

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

motor	Příkaz
`arm_motor_group`	`arm_motor_group.set_position(position, units)` — Skupina motorů ramene
`intake_motor_group`	`intake_motor_group.set_position(position, units)` — Skupina motorů sání

Parametry	Popis
`position`	Hodnota polohy, která se má nastavit pro 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():
    # Set the current motor position to 90 degrees
    intake_motor_group.set_position(90, DEGREES)
    # Spin the intake motor back to 0 degrees
    intake_motor_group.spin_to_position(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_velocity #

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

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

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

motor	Příkaz
`arm_motor_group`	`arm_motor_group.set_velocity(velocity, units)` — Skupina motorů ramene
`intake_motor_group`	`intake_motor_group.set_velocity(velocity, units)` — Skupina motorů sání

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():
    # Spin the intake motor forward then stop
    intake_motor_group.set_velocity(75, PERCENT)
    intake_motor_group.spin_to_position(180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_timeout #

set_timeout nastavuje, jak dlouho se bude motorická skupina snažit dokončit pohyb. Pokud motorická skupina 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 motorická skupina zasekla na pohybu.

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

motor	Příkaz
`arm_motor_group`	`arm_motor_group.set_timeout(value, units)` — Skupina motorů ramene
`intake_motor_group`	`intake_motor_group.set_timeout(value, units)` — Skupina motorů sání

Parametry	Popis
`value`	Doba, po kterou se motorická skupina 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():
    # Spin the intake motor forward then stop
    intake_motor_group.set_timeout(2, SECONDS)
    intake_motor_group.spin_to_position(270, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Gettery #

je_hotovo #

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

True — Pohyb motorové skupiny je dokončen.
False — Motorová skupina 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ů skupiny motorů, jak je znázorněno níže:

motor	Příkaz
`arm_motor_group`	`arm_motor_group.is_done()` — Skupina motorů ramene
`intake_motor_group`	`intake_motor_group.is_done()` — Skupina motorů sání

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

se točí #

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

True — Motorová skupina se otáčí.
False — Motorová skupina 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ů skupiny motorů, jak je znázorněno níže:

motor	Příkaz
`arm_motor_group`	`arm_motor_group.is_spinning()` — Skupina motorů ramene
`intake_motor_group`	`intake_motor_group.is_spinning()` — Skupina motorů sání

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

pozice #

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

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

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

motor	Příkaz
`arm_motor_group`	`arm_motor_group.position(units)` — Skupina motorů ramene
`intake_motor_group`	`intake_motor_group.position(units)` — Skupina motorů sání

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

rychlost #

velocity vrací rychlost otáčení motorové skupiny.

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

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

motor	Příkaz
`arm_motor_group`	`arm_motor_group.velocity(units)` — Skupina motorů ramene
`intake_motor_group`	`intake_motor_group.velocity(units)` — Skupina sacích motorů

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

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

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

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.

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.

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.

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.

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.