Python specifický pro roboty#

Zavedení #

Hrdinský robot Snapshot má dva motory a optický senzor.

Všechny standardní metody VR kódu VEX jsou k dispozici pro použití na hřišti IQ 22-23 Slapshot.

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

Události – Spustí kód, když se stav senzoru změní.

Nárazník
- pressed - Zaregistruje funkci zpětného volání pro případ stisknutí nárazníku sání.
- released - Zaregistruje funkci zpětného volání pro případ uvolnění nárazníku sání.
Optický
- 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.

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.

Nárazník
- pressing - Vrátí, zda je aktuálně stisknutý nárazník sání.
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.

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

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

Snapshot využívá sací motor k sběru disků nebo k jejich otáčení za účelem jejich nařezání nebo shození. Motor ramene zvedá a spouští rameno pro uvolnění disků z dávkovačů a dosažení prvků pole.

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

Akce #

roztočit #

spin roztočí motor dopředu nebo dozadu navždy. Motor se bude otáčet, dokud nedostane další 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
`arm_motor`	`arm_motor.spin(direction)` — Motor ramene

Parametry

Popis

direction

Směr otáčení motoru:

FORWARD — Otáčí sací motor ve směru sání nebo zvedá motor ramene.
REVERSE — Otáčí sací motor ve směru výfuku nebo spouští motor ramene.

def main():
    # Spin the Intake Motor to collect a Disc
    intake_motor.spin(FORWARD)
    wait(1, SECONDS)
    intake_motor.stop()

# 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=True)` — Sací motor
`arm_motor`	`arm_motor.spin_for(direction, distance, units, wait=True)` — Motor ramene

Parametry	Popis
`direction`	Směr otáčení motoru: `FORWARD` — Otáčí sací motor ve směru sání nebo zvedá motor ramene. `REVERSE` — Otáčí sací motor ve směru výfuku nebo spouští motor ramene.
`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():
    # Collect the preloaded Disc
    intake_motor.spin_for(FORWARD, 180, DEGREES)

# 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
`arm_motor`	`arm_motor.spin_to_position(angle, units, wait=True)` — Motor ramene

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():
    # Raise the Arm to reach over the barrier
    arm_motor.spin_to_position(600, DEGREES)

# VR threads — Do not delete
vr_thread(main)

zastavit motor #

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
`arm_motor`	`arm_motor.stop()` — Motor ramene

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

def main():
    # Raise the Arm briefly, then stop it
    arm_motor.spin(FORWARD)
    wait(1, SECONDS)
    arm_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
`arm_motor`	`arm_motor.set_position(position, units)` — Motor ramene

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():
    # Set the Intake Motor position, then return to 0 degrees
    intake_motor.set_position(180, DEGREES)
    intake_motor.spin_to_position(0, DEGREES)

# 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
`arm_motor`	`arm_motor.set_velocity(velocity, units)` — Motor ramene

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():
    # Set the Intake Motor speed before collecting a Disc
    intake_motor.set_velocity(75, PERCENT)
    intake_motor.spin_for(FORWARD, 180, DEGREES)

# 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
`arm_motor`	`arm_motor.set_timeout(value, units)` — Motor ramene

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():
    # Limit how long the Arm Motor waits to reach its target
    arm_motor.set_timeout(2, SECONDS)
    arm_motor.spin_for(FORWARD, 1080, DEGREES)

# 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
`arm_motor`	`arm_motor.is_done()` — Motor ramene

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

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
`arm_motor`	`arm_motor.is_spinning()` — Motor ramene

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

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
`arm_motor`	`arm_motor.position(units)` — Motor ramene

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

def main():
    # Print the current Arm Motor position
    brain.screen.print(arm_motor.position(DEGREES))

# 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
`arm_motor`	`arm_motor.velocity(units)` — Motor ramene

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

def main():
    # Print the current Intake Motor velocity
    brain.screen.print(intake_motor.velocity(PERCENT))

# VR threads — Do not delete
vr_thread(main)

Události #

Nárazník #

lisované #

pressed zaregistruje funkci zpětného volání pro případ stisknutí nárazníku sání.

Usage:
intake_bumper.pressed(callback)

Parametry	Popis
`callback`	Funkce, která bude volána při stisknutí tlačítka Intake Bumper.

def stop_intake():
    intake_motor.stop()

def main():
    # Stop the Intake Motor when a Disc reaches the Intake Bumper
    intake_bumper.pressed(stop_intake)
    intake_motor.spin(FORWARD)

# VR threads — Do not delete
vr_thread(main)

propuštěn #

released registruje funkci zpětného volání pro případ uvolnění nárazníku sání.

Usage:
intake_bumper.released(callback)

Parametry	Popis
`callback`	Funkce, která bude volána při uvolnění nárazníku sání.

def lower_arm():
    arm_motor.spin_to_position(0, DEGREES)

def main():
    # Lower the Arm when the Intake Bumper is released
    intake_bumper.released(lower_arm)

# VR threads — Do not delete
vr_thread(main)

Optický #

detekovaný_objekt #

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

Usage:
front_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 stop_intake():
    intake_motor.stop()

def main():
    # Stop the Intake Motor when the Optical Sensor detects a Disc
    front_optical.object_detected(stop_intake)
    intake_motor.spin(FORWARD)

# 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:
front_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 resume_intake():
    intake_motor.spin(FORWARD)

def main():
    # Restart the Intake Motor when the Optical Sensor no longer detects a Disc
    front_optical.object_lost(resume_intake)

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

Nárazník #

lisování #

pressing vrátí booleovskou hodnotu označující, zda je aktuálně stisknutý nárazník sání.

True - Je stisknutý nárazník sání.
False - Nárazník sání není stlačený.

Usage:
intake_bumper.pressing()

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

def main():
    # Print whether the Intake Bumper is pressed
    brain.screen.print(intake_bumper.pressing())

# VR threads — Do not delete
vr_thread(main)

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

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

def main():
    # Print whether the Front Optical Sensor detects a nearby Disc
    brain.screen.print(front_optical.is_near_object())

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

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

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

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

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

def main():
    # Print the Front Optical Sensor brightness
    brain.screen.print(front_optical.brightness())

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

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

def main():
    # Print the hue detected by the Front Optical Sensor
    brain.screen.print(front_optical.hue())

# VR threads — Do not delete
vr_thread(main)