Hnací ústrojí#

Zavedení #

Robot VEX IQ (2. generace) používá k řízení a otáčení pohon. Pohon se skládá z motorů a kol, které spolupracují na pohybu robota.

Nakonfigurovaný pohon může používat připojený Gyro senzor, vestavěný Inerciální senzor modulu Brain nebo žádný senzor. Pokud je použit senzor, pohon ho využívá k přesnému pohybu a otáčení robota. Na začátku každého projektu pohon automaticky kalibruje senzor. Během kalibrace držte robota přibližně 2 sekundy v klidu, aby se mohl správně pohybovat a otáčet.

Tato stránka používá jako příklad názvu hnacího ústrojí drivetrain V případě potřeby jej nahraďte vlastním nakonfigurovaným názvem.

Existuje mnoho způsobů, jak kódovat hnací ústrojí. Níže je uveden seznam všech metod kódování hnacího ústrojí:

Akce – Pohyb a otáčení robota.

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 do určitého směru od -359 do 359 stupňů. Robot se otočí nejkratším směrem k dosažení cílového směru.
turn_to_rotation — Otočí robota do určité rotace.
stop — Zastaví pohyb robota.
calibrate_drivetrain — Kalibruje senzor nakonfigurovaný s hnacím ústrojím.

Mutátory – Upravte nastavení hnacího ústrojí.

set_drive_velocity — Říká robotovi, jak rychle má jet.
set_turn_velocity — Říká robotovi, jak rychle se má otáčet.
set_stopping — Určuje, jak se robot zastaví: brzděním, setrvačností nebo zastavením.
set_timeout — Nastaví, jak dlouho se bude robot snažit dokončit pohyb.
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_turn_threshold — Určuje, jak blízko se musí robot dostat k cílovému úhlu, než dokončí otočení.
set_turn_constant — Mění, jak silně robot opravuje své zatáčky.

Gettery – Kontrola stavu pohybu.

heading — Vrátí aktuální směr robota od 0 do 359 stupňů.
rotation — Vrátí aktuální rotaci robota.
velocity — Vrátí rychlost, s jakou se robot pohybuje.
current — Vrátí, kolik elektrického proudu spotřebovává hnací ústrojí.
is_moving — Vrací hodnotu typu Boolean, která ukazuje, zda se robot pohybuje.
is_done — Vrátí, zda robot dokončil pohyb, jako booleovskou hodnotu.
is_turning — Vrací hodnotu typu boolean, zda se robot otáčí.
power — Vrátí, jak rychle hnací ústrojí spotřebovává energii.
torque — Vrátí, kolik točivého momentu hnací ústrojí využívá.
efficiency — Vrátí, jak efektivně hnací ústrojí využívá energii.
temperature — Vrátí teplotu hnacího ústrojí.

Konstruktory – Ruční vytvoření a konfigurace hnacího ústrojí.

DriveTrain — Vytvoří hnací ústrojí bez gyroskopického nebo inerciálního senzoru.
SmartDrive — Vytvoří hnací ústrojí s gyroskopickým senzorem nebo inerciálním senzorem.

Akce #

drive #

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, velocity, units)

Parametry	Popis
`direction`	Směr pohybu robota: `FORWARD` nebo `REVERSE`.
`velocity`	Volitelné. Rychlost, s níž se má robot pohybovat, od 0 % do 100 % při použití `PERCENT`, od 0 do 120 ot/min při použití `RPM`nebo od 0 do 720 stupňů za sekundu při použití `VelocityUnits.DPS`. Může to být celé číslo `integer` nebo desetinné číslo (`float`). Pokud není zadána žádná rychlost, robot se pohybuje aktuální rychlostí pohonu.
`units`	Volitelné. Jednotka rychlosti: `PERCENT` (výchozí), `RPM` (otáčky za minutu) nebo `VelocityUnits.DPS` (stupně za sekundu).

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

# Drive slowly in reverse then stop
drivetrain.drive(REVERSE, 20, PERCENT)
wait(2, SECONDS)
drivetrain.stop()

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, velocity, units_v, 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í), `MM` (milimetry) nebo `DistanceUnits.CM` (centimetry).
`velocity`	Volitelné. Rychlost, s níž se má robot pohybovat, od 0 % do 100 % při použití `PERCENT`, od 0 do 120 ot/min při použití `RPM`nebo od 0 do 720 stupňů za sekundu při použití `VelocityUnits.DPS`. Může to být celé číslo `integer` nebo desetinné číslo (`float`). Pokud není zadána žádná rychlost, robot se pohybuje aktuální rychlostí pohonu.
`units_v`	Volitelné. Jednotka rychlosti: `RPM` (otáčky za minutu, výchozí), `PERCENT`nebo `VelocityUnits.DPS` (stupně za sekundu).
`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ě.

# Drive forward and backward
drivetrain.drive_for(FORWARD, 10)
drivetrain.drive_for(REVERSE, 10)

# Quickly drive forward and backward
drivetrain.drive_for(FORWARD, 200, MM, 100, PERCENT)
drivetrain.drive_for(REVERSE, 200, MM, 100, PERCENT)

turn #

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, velocity, units)

Parametry	Popis
`direction`	Směr otáčení robota: `LEFT` nebo `RIGHT`.
`velocity`	Volitelné. Rychlost otáčení od 0 % do 100 % při použití `PERCENT`, od 0 do 120 ot/min při použití `RPM`nebo od 0 do 720 stupňů za sekundu při použití `VelocityUnits.DPS`. Může to být celé číslo `integer` nebo desetinné číslo (`float`). Pokud není zadána žádná rychlost, robot se otáčí aktuální rychlostí otáčení.
`units`	Volitelné. Jednotka rychlosti: `RPM` (otáčky za minutu, výchozí), `PERCENT`nebo `VelocityUnits.DPS` (stupně za sekundu).

# Turn right and left, then stop
drivetrain.turn(RIGHT)
wait(2, SECONDS)
drivetrain.turn(LEFT)
wait(2, SECONDS)
drivetrain.stop()

# Quickly turn right and left, then stop
drivetrain.turn(RIGHT, 100, PERCENT)
wait(2, SECONDS)
drivetrain.turn(LEFT, 100, PERCENT)
wait(2, SECONDS)
drivetrain.stop()

turn_for #

turn_for otočí robota doleva nebo doprava o určitý počet stupňů nebo otáček. Otočení je relativní vzhledem k aktuální poloze robota. Projekt počká, dokud robot nedokončí otáčení, než se spustí další řádek kódu.

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

Parametry	Popis
`direction`	Směr otáčení robota: `LEFT` nebo `RIGHT`.
`angle`	Množství, o které se robot otočí. Může to být `integer` nebo desetinné číslo (`float`).
`units`	Volitelné. Jednotka otočení: `DEGREES` (výchozí) nebo `TURNS`Jedno otočení se rovná 360 stupňům.
`velocity`	Volitelné. Rychlost otáčení od 0 % do 100 % při použití `PERCENT`, od 0 do 120 ot/min při použití `RPM`nebo od 0 do 720 stupňů za sekundu při použití `VelocityUnits.DPS`. Může to být celé číslo `integer` nebo desetinné číslo (`float`). Pokud není zadána žádná rychlost, robot se otáčí aktuální rychlostí otáčení.
`units_v`	Volitelné. Jednotka rychlosti: `RPM` (otáčky za minutu, výchozí), `PERCENT`nebo `VelocityUnits.DPS` (stupně za sekundu).
`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ě.

# Turn the robot right and left
drivetrain.turn_for(RIGHT, 90, DEGREES)
wait(1, SECONDS)
drivetrain.turn_for(LEFT, 90, DEGREES)

# Quickly turn the robot right and left
drivetrain.turn_for(RIGHT, 90, DEGREES, 100, PERCENT)
wait(1, SECONDS)
drivetrain.turn_for(LEFT, 90, DEGREES, 100, PERCENT)

turn_to_heading #

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, velocity, units_v, 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 záhlaví: `DEGREES` (výchozí).
`velocity`	Volitelné. Rychlost otáčení od 0 % do 100 % při použití `PERCENT`, od 0 do 120 ot/min při použití `RPM`nebo od 0 do 720 stupňů za sekundu při použití `VelocityUnits.DPS`. Může to být celé číslo `integer` nebo desetinné číslo (`float`). Pokud není zadána žádná rychlost, robot se otáčí aktuální rychlostí otáčení.
`units_v`	Volitelné. Jednotka rychlosti: `PERCENT` (výchozí), `RPM` (otáčky za minutu) nebo `VelocityUnits.DPS` (stupně za sekundu).
`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ě.

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

# Turn twice slowly
drivetrain.turn_to_heading(90, DEGREES, 20, PERCENT)
wait(1, SECONDS)
drivetrain.turn_to_heading(180, DEGREES, 20, PERCENT)

turn_to_rotation #

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

Rotace udává, o kolik se robot otočil, měřeno ve stupních nebo otáčká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, velocity, units_v, wait)

Parametry	Popis
`angle`	Hodnota rotace ve stupních nebo otáčkách, na kterou se robot otočí. Může to být `integer` nebo desetinné číslo (`float`).
`units`	Volitelné. Jednotka rotace: `DEGREES` (výchozí) nebo `TURNS`Jedna otáčka se rovná 360 stupňům.
`velocity`	Volitelné. Rychlost otáčení od 0 % do 100 % při použití `PERCENT`, od 0 do 120 ot/min při použití `RPM`nebo od 0 do 720 stupňů za sekundu při použití `VelocityUnits.DPS`. Může to být celé číslo `integer` nebo desetinné číslo (`float`). Pokud není zadána žádná rychlost, robot se otáčí aktuální rychlostí otáčení.
`units_v`	Volitelné. Jednotka rychlosti: `PERCENT` (výchozí), `RPM` (otáčky za minutu) nebo `VelocityUnits.DPS` (stupně za sekundu).
`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ě.

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

# Turn left then slowly spin in a
# circle clockwise
drivetrain.turn_to_rotation(-90, DEGREES)
wait(1, SECONDS)
drivetrain.turn_to_rotation(450, DEGREES, 20, PERCENT)

stop #

stop zastaví pohyb robota.

Usage:
drivetrain.stop(mode)

Parametry	Popis
`mode`	Volitelné. Jak robot zastaví: `BRAKE` (výchozí), `BRAKE`nebo `COAST` `COAST` — Okamžitě zastaví. `HOLD` — Zpomalí až do zastavení. `HOLD` — Okamžitě zastaví a udrží kola v pozici.

Parametry

Popis

mode

Volitelné. Jak robot zastaví: BRAKE (výchozí), BRAKEnebo COAST

COAST — Okamžitě zastaví.
HOLD — Zpomalí až do zastavení.
HOLD — Okamžitě zastaví a udrží kola v pozici.

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

# Drive forward and coast to a stop
drivetrain.set_drive_velocity(100, PERCENT)
drivetrain.drive(FORWARD)
wait(2, SECONDS)
drivetrain.stop(COAST)

calibrate_drivetrain #

calibrate_drivetrain je vestavěná funkce, která kalibruje gyroskopický senzor nebo inerciální senzor nakonfigurovaný s hnacím ústrojím.

Kalibrace pomáhá senzoru správně měřit pohyb. Během kalibrace držte robota v klidu asi 2 sekundy. Pokud se robot během kalibrace pohybuje, senzor nemusí správně měřit pohyb.

Projekt počká na dokončení kalibrace, než se spustí další řádek kódu.

Poznámka: Tuto funkci nelze použít uvnitř VS Code.

Usage:
calibrate_drivetrain()

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

Mutátory #

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á jezdit, od 0 % do 100 % při použití `PERCENT`, od 0 do 120 ot/min při použití `RPM`nebo od 0 do 720 stupňů za sekundu při použití `VelocityUnits.DPS`. Může to být celé číslo `integer` nebo desetinné číslo (`float`).
`units`	Volitelné. Jednotka rychlosti: `PERCENT` (výchozí), `RPM` (otáčky za minutu) nebo `VelocityUnits.DPS` (stupně za sekundu).

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

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 % při použití `PERCENT`, od 0 do 120 ot/min při použití `RPM`nebo od 0 do 720 stupňů za sekundu při použití `VelocityUnits.DPS`. Může to být celé číslo `integer` nebo desetinné číslo (`float`).
`units`	Volitelné. Jednotka rychlosti: `PERCENT` (výchozí), `RPM` (otáčky za minutu) nebo `VelocityUnits.DPS` (stupně za sekundu).

# Turn at different velocities
# Default velocity
drivetrain.turn_for(RIGHT, 360)
wait(1, SECONDS)
# Turn slower
drivetrain.set_turn_velocity(20, PERCENT)
drivetrain.turn_for(RIGHT, 360)
wait(1, SECONDS)
# Turn faster
drivetrain.set_turn_velocity(100, PERCENT)
drivetrain.turn_for(RIGHT, 360)

set_stopping #

set_stopping nastavuje, jak se robot zastaví: brzděním, setrvačností nebo zastavením.

Usage:
drivetrain.set_stopping(mode)

Parametry	Popis
`mode`	Jak robot zastaví: `BRAKE` — Okamžitě zastaví. `COAST` — Zpomalí až do úplného zastavení. `HOLD` — Okamžitě zastaví a udrží kola v požadované poloze.

Parametry

Popis

mode

Jak robot zastaví:

BRAKE — Okamžitě zastaví.
COAST — Zpomalí až do úplného zastavení.
HOLD — Okamžitě zastaví a udrží kola v požadované poloze.

Pokud se tato metoda nepoužije, robot při zastavení použije BRAKE.

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`	Volitelné. Jednotka času: `MSEC` (milisekundy, výchozí nastavení) nebo `SECONDS`.

# Turn right after driving forward
drivetrain.set_timeout(1, SECONDS)
drivetrain.drive_for(FORWARD, 25, INCHES)
drivetrain.turn_for(RIGHT, 90)

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 nebo otáčkách, která se má nastavit pro robota. Může to být `integer` nebo desetinné číslo (`float`).
`units`	Volitelné. Jednotka směru: `DEGREES` (výchozí) nebo `TURNS`Jedno otočení se rovná 360 stupňům.

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

set_rotation #

Rotace udává, o kolik se robot otočil, měřeno ve stupních nebo otáčká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 nebo otáčkách, která se má nastavit pro robota. Může to být `integer` nebo desetinné číslo (`float`).
`units`	Volitelné. Jednotka rotace: `DEGREES` (výchozí) nebo `TURNS`Jedna otáčka se rovná 360 stupňům.

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

set_turn_threshold #

set_turn_threshold nastavuje, jak blízko se musí robot dostat k cílovému úhlu, než dokončí otočení.

Menší prahová hodnota může zpřesnit zatáčení, ale robotovi může trvat déle, než otočení dokončí. Vyšší prahová hodnota může zrychlit zatáčení, ale může být méně přesné.

Usage:
drivetrain.set_turn_threshold(value)

Parametry	Popis
`value`	Práh otáčení ve stupních. Může to být `integer` nebo desetinné číslo (`float`). Výchozí prahová hodnota otáčení je 1 stupeň.

# Set the turn threshold to 5 degrees
drivetrain.set_turn_threshold(5)

set_turn_constant #

set_turn_constant mění, jak silně robot opravuje své zatáčky.

Vyšší hodnota způsobí, že robot bude opravovat zatáčky silněji. Nižší hodnota způsobí, že robot bude opravovat zatáčky jemněji. Výchozí hodnota je 1,0.

Usage:
drivetrain.set_turn_constant(value)

Parametry	Popis
`value`	Konstanta otáčení. Může to být desetinné číslo (`float`) od 0,1 do 4,0. Výchozí hodnota je 1,0.

# Increase the turn constant to 2.0
drivetrain.set_turn_constant(2.0)

Gettery #

heading #

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 stupňů.

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

Usage:
drivetrain.heading(units)

Parametry	Popis
`units`	Volitelné. Jednotka pro návratový kurz: `DEGREES` (výchozí) nebo `TURNS`Jedna otáčka se rovná 360 stupňům.

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

rotation #

Rotace udává, o kolik se robot otočil, měřeno ve stupních nebo otáčká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 pro vrácení rotace: `DEGREES` (výchozí) nebo `TURNS`Jedna otáčka se rovná 360 stupňům.

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

velocity #

velocity vrací, jak rychle se robot pohybuje.

Může vracet rychlost v procentech od -100 % do 100 %, v RPM od -127 ot./min do 127 ot./min nebo ve VelocityUnits.DPS (stupně za sekundu). Kladná hodnota znamená, že robot jede vpřed. Záporná hodnota znamená, že robot jede vzad.

Usage:
drivetrain.velocity(units)

Parametry	Popis
`units`	Volitelné. Jednotka, ve které se má vrátit rychlost: `PERCENT` (výchozí), `RPM` (otáčky za minutu) nebo `VelocityUnits.DPS` (stupně za sekundu).

current #

current vrací množství elektrického proudu spotřebovaného hnacím ústrojím, měřené v ampérech. Proud je množství elektřiny protékající hnacím ústrojím.

Vyšší hodnota proudu znamená, že pohon spotřebovává více elektrického proudu. K tomu může dojít, když robot tlačí na nějaký předmět nebo se snaží pohnout, když je zaseknutý.

Toto lze použít ke kontrole, zda se během pohybu nevyskytují problémy s pohonem. Pokud proud zůstává vysoký, hnací ústrojí se může zahřívat nebo méně efektivně využívat energii.

Usage:
drivetrain.current(units)

Parametry	Popis
`units`	Volitelné. Jednotka, ve které se má vrátit proud: `CurrentUnits.AMP` (výchozí hodnota jsou ampéry).

is_moving #

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.

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_moving()

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

is_done #

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.

is_turning #

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

True — Robot se otáčí.
False — Robot se neotáčí.

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

Usage:
drivetrain.is_turning()

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

power #

power vrací množství energie spotřebované hnacím ústrojím, měřené ve wattech. Výkon ukazuje, jak rychle hnací ústrojí energii spotřebovává.

Vyšší hodnota výkonu znamená, že hnací ústrojí spotřebovává energii rychleji. K tomu může dojít, když robot tlačí na nějaký předmět nebo se snaží pohnout, když je zaseknutý.

Toto lze použít k porovnání pohybů nebo ke kontrole, zda hnací ústrojí nemá problémy. Pokud výkon zůstává vysoký, hnací ústrojí se může zahřívat nebo méně efektivně využívat energii.

Usage:
drivetrain.power()

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

torque #

Točivý moment ukazuje, jak silně může hnací ústrojí tlačit nebo táhnout, zatímco se kola protáčejí.

torque vrací hodnotu momentu, který hnací ústrojí využívá, měřenou v newtonmetrech (Nm) nebo palcích v librách (InLb).

Vyšší hodnota točivého momentu znamená, že hnací ústrojí tlačí nebo táhne silněji. K tomu může dojít, když robot tlačí na nějaký předmět nebo se snaží pohnout, když je zaseknutý.

To lze použít ke kontrole, zda má hnací ústrojí problémy, nebo k porovnání, kolik tlaku potřebují různé pohyby.

Usage:
drivetrain.torque(units)

Parametry	Popis
`units`	Volitelné. Jednotka pro udávání točivého momentu: `TorqueUnits.NM` (newtonmetry, výchozí) nebo `TorqueUnits.INLB` (palce-libry).

efficiency #

efficiency vrací, jak efektivně hnací ústrojí využívá výkon, v procentech od 0 % do 100 %.

Účinnost ukazuje, kolik výkonu hnacího ústrojí se využívá k pohybu. Vyšší hodnota účinnosti znamená, že se k pohybu využívá více výkonu hnacího ústrojí. Nižší hodnota účinnosti může nastat, když hnací ústrojí pracuje intenzivně, ale moc se nepohybuje, například když je robot zaseknutý nebo tlačí na nějaký předmět.

To lze použít k porovnání pohybů nebo ke kontrole, zda hnací ústrojí plýtvá výkonem, místo aby jej využívalo k pohybu.

Usage:
drivetrain.efficiency()

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

temperature #

temperature vrací průměrnou teplotu hnacího ústrojí ve vybrané teplotní jednotce.

Teplota ukazuje, jak jsou motory hnacího ústrojí zahřáté. Vyšší teplota znamená, že se motory během provozu zahřívají. Aby motory fungovaly na plný výkon, měly by se teplota motorů udržovat pod 55 °C.

Pokud se motory příliš zahřejí, sníží svůj maximální proud, aby se chránily. Při 70 °C se motory zastaví, dokud nevychladnou.

Toto lze použít ke kontrole, zda se hnací ústrojí příliš nezahřívá během opakovaných pohybů, dlouhých běhů nebo když tlačí na nějaký předmět.

Usage:
drivetrain.temperature(units)

Parametry	Popis
`units`	Volitelné. Jednotka pro vrácení teploty: `TemperatureUnits.CELSIUS` (výchozí) nebo `TemperatureUnits.FAHRENHEIT`.

Konstruktéři #

Konstruktory se používají k vytvoření DriveTrain a SmartDrive v kódu. To je užitečné při konfiguraci hnacího ústrojí bez použití okna Zařízení.

Před vytvořením hnacího ústrojí musí být vytvořeny alespoň dva objekty Motor nebo MotorGroup.

DriveTrain #

DriveTrain vytváří pohon bez Gyro senzoru nebo Inerciálního senzoru.

Usage:
DriveTrain(lm, rm, wheelTravel, trackWidth, wheelBase, units, externalGearRatio)

Parametr	Popis
`lm`	Levý motor nebo skupina motorů.
`rm`	Pravý motor nebo skupina motorů.
`wheelTravel`	Volitelné. Obvod kol hnacího ústrojí. Výchozí hodnota je 300 milimetrů.
`trackWidth`	Volitelné. Šířka mezi levým a pravým kolem. Výchozí hodnota je 320 milimetrů.
`wheelBase`	Volitelné. Vzdálenost mezi předními a zadními koly. Výchozí hodnota je 320 milimetrů.
`units`	Volitelné. Jednotka pro `wheelTravel`, `trackWidth`a `wheelBase`: `MM` (milimetry, výchozí), `INCHES`nebo `DistanceUnits.CM` (centimetry).
`externalGearRatio`	Volitelné. Převodový poměr použitý k úpravě vzdáleností pohonu, pokud jsou použita převodová kola. Může to být `integer` nebo desetinné číslo (`float`). Výchozí hodnota je 1,0.

# Create left and right drive motor objects
left_drive_smart = Motor(Ports.PORT1, 1.0, False)
right_drive_smart = Motor(Ports.PORT2, 1.0, True)

'''
Create a Drivetrain with the following values:
wheelTravel: 200
trackWidth: 173
wheelBase: 76
units: MM
externalGearRatio: 1
'''
drivetrain = DriveTrain(left_drive_smart, right_drive_smart, 200, 173, 76, MM, 1)

# Create two motor group objects for left and right motors
left_motor_a = Motor(Ports.PORT1, 1.0, False)
left_motor_b = Motor(Ports.PORT2, 1.0, False)
left_drive_smart = MotorGroup(left_motor_a, left_motor_b)

right_motor_a = Motor(Ports.PORT3, 1.0, True)
right_motor_b = Motor(Ports.PORT4, 1.0, True)
right_drive_smart = MotorGroup(right_motor_a, right_motor_b)

'''
Create a Drivetrain with the following values:
wheelTravel: 200
trackWidth: 173
wheelBase: 76
units: MM
externalGearRatio: 1
'''
drivetrain = DriveTrain(left_drive_smart, right_drive_smart, 200, 173, 76, MM, 1)

SmartDrive #

SmartDrive vytváří hnací ústrojí s Gyro senzorem nebo Inerciálním senzorem.

Usage:
SmartDrive(lm, rm, g, wheelTravel, trackWidth, wheelBase, units, externalGearRatio)

Parametr	Popis
`lm`	Levý motor nebo skupina motorů.
`rm`	Pravý motor nebo skupina motorů.
`g`	Gyroskopický senzor nebo inerciální senzor používaný hnacím ústrojím.
`wheelTravel`	Volitelné. Obvod kol hnacího ústrojí. Výchozí hodnota je 300 milimetrů.
`trackWidth`	Volitelné. Šířka mezi levým a pravým kolem. Výchozí hodnota je 320 milimetrů.
`wheelBase`	Volitelné. Vzdálenost mezi předními a zadními koly. Výchozí hodnota je 320 milimetrů.
`units`	Volitelné. Jednotka pro `wheelTravel`, `trackWidth`a `wheelBase`: `MM` (milimetry, výchozí), `INCHES`nebo `DistanceUnits.CM` (centimetry).
`externalGearRatio`	Volitelné. Převodový poměr použitý k úpravě vzdáleností pohonu, pokud jsou použita převodová kola. Může to být `integer` nebo desetinné číslo (`float`). Výchozí hodnota je 1,0.

# Create the Inertial Sensor
brain_inertial = Inertial()

# Make left and right drive motors
left_drive_smart = Motor(Ports.PORT1, 1.0, False)
right_drive_smart = Motor(Ports.PORT6, 1.0, True)

# Create a SmartDrive object with wheelTravel 200
drivetrain = SmartDrive(left_drive_smart, right_drive_smart, brain_inertial, 200)

Pokud vytváříte inteligentní hnací ústrojí s více motory, je třeba je před seskupením do skupiny motorů vytvořit samostatně.

# Create the Inertial Sensor
brain_inertial = Inertial()

# Create two motor groups for left and right motors
left_motor_a = Motor(Ports.PORT1, 1.0, False)
left_motor_b = Motor(Ports.PORT2, 1.0, False)
left_drive_smart = MotorGroup(left_motor_a, left_motor_b)

right_motor_a = Motor(Ports.PORT5, 1.0, True)
right_motor_b = Motor(Ports.PORT6, 1.0, True)
right_drive_smart = MotorGroup(right_motor_a, right_motor_b)

# Create a SmartDrive object with wheelTravel 200 mm
drivetrain = SmartDrive(left_drive_smart, right_drive_smart, brain_inertial, 200)