Python specifický pro roboty

Zavedení

Hrdinský robot Flex obsahuje drápový motor, motor paže, senzor vidění s umělou inteligencí, senzor vzdálenosti a senzor GPS (Game Positioning System).

Všechny standardní metody VR kódu VEX jsou k dispozici pro použití v herním prostředí V5 26-27 Override.

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

Pohon – Pohyb a otáčení robota.

• Akce

  • drive — Pohybuje robota vpřed nebo vzad natrvalo.

  • drive_for — Pohybuje robotem vpřed nebo vzad o určitou vzdálenost.

  • turn — Otočí robota doleva nebo doprava natrvalo.

  • turn_for — Otočí robota doleva nebo doprava o určitý počet stupňů.

  • turn_to_heading — Otočí robota tak, aby směřoval v určitém směru, od -359 do 359 stupňů.

  • turn_to_rotation — Otočí robota do určité rotace.

  • stop — Zastaví pohyb robota.

• Mutátory

  • set_heading — Změní aktuální směr robota na nový směr.

  • set_rotation — Změní aktuální rotaci robota na novou rotaci.

  • set_timeout — Nastaví, jak dlouho se bude robot snažit dokončit pohyb.

  • set_drive_velocity — Říká robotovi, jak rychle má jet.

  • set_turn_velocity — Říká robotovi, jak rychle se má otáčet.

• Získávači

  • heading — Vrátí aktuální směr robota od 0 do 359,99 stupňů.

  • rotation — Vrátí aktuální rotaci robota.

  • is_done — Vrátí, zda robot dokončil pohyb, jako booleovskou hodnotu.

  • is_moving — Vrátí, zda se robot pohybuje, jako booleovskou hodnotu.

  • velocity — Vrátí rychlost, s jakou se robot pohybuje.

Pohyb – Pohybujte a sledujte motory robota.

• Akce

  • spin — Roztočí motor dopředu nebo dozadu navždy.

  • spin_for — Roztočí motor o určitou vzdálenost.

  • spin_to_position — Roztočí motor do určité polohy.

  • stop — Zastaví otáčení motoru.

• Mutátory

  • set_position — Změní aktuální polohu motoru na novou hodnotu.

  • set_velocity — Říká motoru, jak rychle se má otáčet.

  • set_timeout — Nastavuje, jak dlouho se bude motor snažit dokončit pohyb.

• Získávači

  • is_done — Vrátí, zda se motor rozhýbal, jako booleovskou hodnotu.

  • is_spinning — Vrátí hodnotu typu Boolean, zda se motor otáčí.

  • position — Vrátí aktuální polohu motoru.

  • velocity — Vrátí rychlost otáčení motoru.

AI Vision – Zachycujte a analyzujte objekty pomocí senzoru AI Vision.

• Získávači

  • take_snapshot – Vrátí n-tici detekovaných objektů pro specifický podpis.

• Vlastnosti

  • .width – Width of the detected object in pixels.

  • .height – Výška detekovaného objektu v pixelech.

  • .centerX – Pozice středu objektu na souřadnici X v pixelech.

  • .centerY – Pozice středu objektu na souřadnici Y v pixelech.

  • .originX – Pozice levého horního rohu objektu na souřadnici X v pixelech.

  • .originY – Pozice Y levého horního rohu objektu v pixelech.

  • .id – Classification ID of the detected object.

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.

• Vzdálenost

  • found_object – Vrací, zda senzor vzdálenosti detekoval objekt v dosahu.

  • object_distance – Vrátí vzdálenost mezi senzorem vzdálenosti a nejbližším detekovaným objektem.

• GPS

  • x_position – Vrátí aktuální souřadnici x GPS senzoru na poli.

  • y_position – Vrátí aktuální souřadnici y GPS senzoru na poli.

  • heading – Vrátí směr, kterým se robot aktuálně pohybuje, na základě GPS senzoru.

Příklady na této stránce používají výchozí pozici C z kontrolního seznamu před zápasem na hřišti.

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():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive(FORWARD)
    wait(0.5, SECONDS)
    drivetrain.stop()
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# 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():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# 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():
    # Score a Pin in a Neutral Goal
    drivetrain.turn(LEFT)
    wait(0.78, SECONDS)
    drivetrain.stop()
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

otočit_pro

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 úhlu: 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():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, 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 je 0 stupňů.

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

Parametry	Popis
heading	Směr, kterým by se měl robot otočit, od -359 do 359 stupňů.
units	Volitelné. Jednotka úhlu: 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():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_to_heading(-110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, 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ňů. Otočení doprava rotaci zvýší a otočení doleva ji sníží.

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

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

Parametry	Popis
rotation	Hodnota rotace ve stupních, na kterou se robot otočí. Může to být integer nebo desetinné číslo (float).
units	Volitelné. Jednotka úhlu: 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():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_to_rotation(-110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, 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():
    # Score a Pin in a Neutral Goal
    drivetrain.turn(LEFT)
    wait(0.78, SECONDS)
    drivetrain.stop()
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# 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, která se má nastavit pro robota.
units	Volitelné. Jednotka úhlu: DEGREES (výchozí).

def main():
    # Make facing the Neutral Goal the new heading
    drivetrain.set_heading(110, 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. set_rotation změní aktuální rotaci robota na novou hodnotu.

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 úhlu: DEGREES (výchozí).

def main():
    # Make facing the Neutral Goal the new rotation
    drivetrain.set_rotation(110, DEGREES)
    drivetrain.turn_to_rotation(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_timeout

set_timeout nastavuje, po kolik sekund se robot pokusí 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(time, units)

Parametry	Popis
time	Počet sekund, po které se robot může pokusit dokončit pohyb. Může to být kladné celé číslo integer nebo desetinné číslo (float).
units	Volitelné. Časová jednotka: SECONDS (výchozí) nebo MSEC.

def main():
    # Turn to face the Neutral Goal
    drivetrain.set_timeout(0.8, SECONDS)
    drivetrain.turn_for(LEFT, 180, DEGREES)

# 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():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.set_drive_velocity(100, PERCENT)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# 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 to face the Neutral Goal faster
    drivetrain.set_turn_velocity(100, PERCENT)
    drivetrain.turn_for(LEFT, 110, 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():
    # Turn to the Goal, then show heading
    drivetrain.turn_for(LEFT, 110, 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():
    # Spin to find a Pin, then show rotation
    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.

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES, wait=False)
    wait(0.5, SECONDS)
    while not drivetrain.is_done():
        wait(5, MSEC)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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.

def main():
    # Raise the Arm once stopped near the Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES, wait=False)
    wait (0.5, SEC)
    while drivetrain.is_moving():
        wait(5, MSEC)
    arm_motor.spin_for(FORWARD, 800, DEGREES)

# VR threads — Do not delete
vr_thread(main)

rychlost

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

Usage:
drivetrain.velocity(units)

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

def main():
    # Show speed while driving to the Goal
    drivetrain.drive_for(FORWARD, 150, MM)
    brain.screen.print("Velocity: ")
    brain.screen.print(drivetrain.velocity(PERCENT))

# VR threads — Do not delete
vr_thread(main)

Pohyb

Flex používá motor ramene ke zvedání a spouštění ramene a motor drápu k otevírání a zavírání drápu.

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

Akce

roztočit

spin roztočí motor v jednom ze dvou směrů 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
arm_motor	arm_motor.spin(direction) — Motor ramene
claw_motor	claw_motor.spin(direction) — Drápový motor

Parametry	Popis
direction	Směr otáčení motoru: FORWARD — Pohybuje motorem ramene nahoru nebo zavírá motor s čelistmi. REVERSE — Pohybuje motorem ramene dolů nebo otevírá motor s čelistmi.

def main():
    # Raise the Arm before driving toward a Pin
    arm_motor.spin(FORWARD)
    wait(1, SECONDS)
    arm_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
arm_motor	arm_motor.spin_for(direction, distance, units, wait) — Motor ramene
claw_motor	claw_motor.spin_for(direction, distance, units, wait) — Drápový motor

Parametry	Popis
direction	Směr otáčení motoru: FORWARD — Pohybuje motorem ramene nahoru nebo zavírá motor s čelistmi. REVERSE — Pohybuje motorem ramene dolů nebo otevírá motor s čelistmi.
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():
    # Raise the Arm to carry the Pin to the Goal
    arm_motor.spin_for(FORWARD, 800, 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 ramene nastavena na 0 stupňů. Výjimkou je motor drápů – začíná na 467 stupních (plně zavřeno). Polohu motoru lze také nastavit pomocí metody 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
arm_motor	arm_motor.spin_to_position(angle, units, wait=True) — Motor ramene
claw_motor	claw_motor.spin_to_position(angle, units, wait=True) — Čelisťový motor

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, then release the Pin
    arm_motor.spin_to_position(800, DEGREES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

zastávka

stop zastaví otáčení motoru.

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

motor	Příkaz
arm_motor	arm_motor.stop() — Motor ramene
claw_motor	claw_motor.stop() — Drápový motor

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

def main():
    # Raise the Arm partway to hold the Pin
    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
arm_motor	arm_motor.set_position(position, units) — Motor ramene
claw_motor	claw_motor.set_position(position, units) — Čelisťový motor

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():
    # Reset encoder, raise Arm, place Pin
    arm_motor.set_position(0, DEGREES)
    arm_motor.spin_to_position(800, DEGREES)
    claw_motor.spin_for(REVERSE, 180, 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
arm_motor	arm_motor.set_velocity(velocity, units) — Motor ramene
claw_motor	claw_motor.set_velocity(velocity, units) — Drápový motor

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():
    # Raise the Arm fast to release the Pin
    arm_motor.set_velocity(100, PERCENT)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    claw_motor.spin_for(REVERSE, 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
arm_motor	arm_motor.set_timeout(value, units) — Motor ramene
claw_motor	claw_motor.set_timeout(value, units) — Drápový motor

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():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    arm_motor.set_timeout(1, SECONDS)
    arm_motor.spin_for(FORWARD, 1800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, 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
arm_motor	arm_motor.is_done() — Motor ramene
claw_motor	claw_motor.is_done() — Drápový motor

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

def main():
    # Raise the Arm while driving to the Goal
    arm_motor.spin_to_position(800, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while not arm_motor.is_done():
        drivetrain.drive(FORWARD)
        wait(5, MSEC)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

se točí

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

• True — Motor se točí.

• False — Motor se netočí.

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

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

motor	Příkaz
arm_motor	arm_motor.is_spinning() — Motor ramene
claw_motor	claw_motor.is_spinning() — Drápový motor

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

def main():
    # Raise the Arm while driving to the Goal, then release the Pin
    arm_motor.spin_to_position(800, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while arm_motor.is_spinning():
        drivetrain.drive_for(FORWARD, 25, MM)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

pozice

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

Na začátku projektu je poloha motoru ramene nastavena na 0 stupňů. Výjimkou je motor s čelistí – ten začíná na 467 stupních (plně zavřeno). Pokud se motor otočí o jednu celou otáčku dopředu, poloha se zvýší. Pokud se motor otáčí opačným směrem, poloha se sníží.

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
arm_motor	arm_motor.position(units) — Motor ramene
claw_motor	claw_motor.position(units) — Čelisťový motor

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

def main():
    # Raise the Arm, then release the Pin
    while arm_motor.position(DEGREES) < 800:
        arm_motor.spin(FORWARD)
        wait(2, MSEC)
    arm_motor.stop()
    claw_motor.spin_for(REVERSE, 180, 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
arm_motor	arm_motor.velocity(units) — Motor ramene
claw_motor	claw_motor.velocity(units) — Drápový motor

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

def main():
    # Show Arm Motor velocity while raising
    arm_motor.set_velocity(100, PERCENT)
    arm_motor.spin_to_position(800, DEGREES, wait=False)
    wait(0.2, SECONDS)
    brain.screen.print(arm_motor.velocity(PERCENT))

# VR threads — Do not delete
vr_thread(main)

Vize umělé inteligence

Gettery

pořídit_snímek

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

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

Usage:
ai_vision.take_snapshot(signature)

Parametry

Popis

signature

Filtruje datovou sadu tak, aby zahrnovala pouze data daného podpisu. Dostupné podpisy jsou: AiVision.ALL_AIOBJS - Detekuje všechny herní prvky. GameElements.RED_BLUE_PIN - Detekuje herní prvky RedBluePin. GameElements.BLUE_YELLOW_PIN - Detekuje herní prvky BlueYellowPin. GameElements.RED_YELLOW_PIN - Detekuje herní prvky RedYellowPin. GameElements.YELLOW_PIN - Detekuje herní prvky YellowPin. GameElements.CUP - Detekuje herní prvky Cup.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Turn to face the Pin
    drivetrain.set_turn_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].centerX < 140:
                drivetrain.turn(LEFT)
            elif ai_objects[0].centerX > 180:
                drivetrain.turn(RIGHT)
            else:
                drivetrain.stop()
                break

# VR threads — Do not delete
vr_thread(main)

Nemovitosti

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

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

.šířka

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

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Approach the next Cup and Pin
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].width > 140:
                drivetrain.stop()
                break
            else:
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.výška

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

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Approach the next Cup and Pin
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].height > 200:
                drivetrain.stop()
                break
            else:
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.centerX

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

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Turn and approach the next Cup and Pin
    drivetrain.set_turn_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].centerX < 140:
                drivetrain.turn_for(LEFT, 5, DEGREES)
            else: 
                drivetrain.drive_for(FORWARD, 25, INCHES)
                break

# VR threads — Do not delete
vr_thread(main)

.centerY

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

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Approach the next Cup and Pin
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].centerY > 230:
                drivetrain.stop()
                break
            else:
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.originX

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

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Turn and approach the next Cup and Pin
    drivetrain.set_turn_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].originX < 100:
                drivetrain.turn_for(LEFT, 5, DEGREES)
            else:
                drivetrain.drive_for(FORWARD, 25, INCHES)
                break

# VR threads — Do not delete
vr_thread(main)

.originY

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

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Approach the next Cup and Pin
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].originY > 140:
                drivetrain.stop()
                break
            else:
                drivetrain.drive(FORWARD)

# VR threads — Do not delete
vr_thread(main)

.id

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

Klasifikace umělé inteligence	identifikační číslo	Podpis
ČervenáModráPin	0	GameElements.RED_BLUE_PIN
ModráŽlutáPin	1	GameElements.BLUE_YELLOW_PIN
ČervenáŽlutáKolík	2	GameElements.RED_YELLOW_PIN
ŽlutýPin	3	GameElements.YELLOW_PIN
Pohár	4	GameElements.CUP

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Display the ID of the next closest object
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            brain.screen.print(ai_objects[0].id)
            break

# VR threads — Do not delete
vr_thread(main)

Utěšit

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

Vytisknout

mozek.sítotisk.

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

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

Usage:
brain.screen.print(value)

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

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

# VR threads — Do not delete
vr_thread(main)

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)

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 number of loops
    global loops
    monitor_variable("loops")

    # Turn in a full circle 3 times
    for loops in range(12):
        drivetrain.turn_for(RIGHT, 90, DEGREES)

# 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 Arm Motor arm_motor.is_done arm_motor.is_spinning arm_motor.position arm_motor.velocity Claw Motor claw_motor.is_done claw_motor.is_spinning claw_motor.position claw_motor.velocity Senzor vzdálenosti distance.is_object_detected distance.object_distance_mm distance.object_distance_inches GPS senzor gps.position_mm gps.position_inches gps.heading Senzor AI Vision ai_vision.object_count ai_vision.height ai_vision.width ai_vision.centerX ai_vision.centerY ai_vision.originX ai_vision.originY ai_vision.id

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

# VR threads — Do not delete
vr_thread(main)

Snímání

Vzdálenost

nalezený_objekt

found_object vrací, zda senzor vzdálenosti aktuálně detekuje objekt do vzdálenosti 2000 mm.

• True — Senzor vzdálenosti detekuje objekt.

• False — Senzor vzdálenosti nedetekuje objekt.

Usage:
distance.found_object()

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

def main():
    # Turn until something is detected, then release the Pin
    drivetrain.turn(RIGHT)
    while True:
        wait(5, MSEC)
        if distance.found_object():
            drivetrain.stop()
            break
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

vzdálenost_objektu

object_distance vrací vzdálenost mezi senzorem vzdálenosti a nejbližším detekovaným objektem.

Usage:
distance.object_distance(units)

Parametry	Popis
units	Jednotka vzdálenosti: MM nebo INCHES.

def main():
    # Drive until 200 mm from the Goal, then release the Pin
    while distance.object_distance(MM) > 200:
        wait(5, MSEC)
        drivetrain.drive(FORWARD)
    drivetrain.stop()
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

GPS

pozice_x

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

Usage:
gps.x_position(units)

Parametry	Popis
jednotky	Jednotka hodnoty odsazení: INCHES nebo MM

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive(FORWARD)
    while not gps.x_position(MM) > -1370:
        wait(2, MSEC)
    drivetrain.stop()
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

poloha_y

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

Usage:
gps.y_position(units)

Parametry	Popis
jednotky	Jednotka hodnoty odsazení: INCHES nebo MM

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive(FORWARD)
    while not gps.y_position(MM) < -450:
        wait(2, MSEC)
    drivetrain.stop()
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

záhlaví

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

Usage:
gps.heading()

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

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    monitor_sensor("gps.heading")
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    # Turn left to face the Neutral Goal
    drivetrain.set_turn_velocity(30, PERCENT)
    drivetrain.turn(LEFT)
    while not gps.heading() < 18:
        wait(2, MSEC)
    drivetrain.stop()


# VR threads — Do not delete
vr_thread(main)