Układ napędowy#

Wstęp #

Robot VEX IQ (2. generacji) wykorzystuje układ napędowy do jazdy i skręcania. Układ napędowy składa się z silników i kół, które współpracują ze sobą, aby poruszać robotem.

Skonfigurowany układ napędowy może korzystać z podłączonego czujnika żyroskopowego, wbudowanego w mózg czujnika bezwładnościowego lub nie korzystać z żadnego czujnika. Gdy czujnik jest używany, układ napędowy wykorzystuje go, aby pomóc robotowi poruszać się i skręcać precyzyjnie. Na początku każdego projektu układ napędowy automatycznie kalibruje czujnik. Podczas kalibracji należy unieruchomić robota na około 2 sekundy, aby mógł on poruszać się i skręcać prawidłowo.

Ta strona używa przykładowej nazwy układu napędowego drivetrain . W razie potrzeby zastąp ją własną, skonfigurowaną nazwą.

Istnieje wiele sposobów kodowania układu napędowego. Poniżej znajduje się lista wszystkich metod kodowania układu napędowego:

Akcje — poruszanie i obracanie robotem.

drive — Przesuwa robota do przodu lub do tyłu w nieskończoność.
drive_for — Przesuwa robota do przodu lub do tyłu na określoną odległość.
turn — Obraca robota w lewo lub prawo na zawsze.
turn_for — Obraca robota w lewo lub prawo o określoną liczbę stopni.
turn_to_heading — Obraca robota w kierunku określonego kierunku od -359 do 359 stopni. Robot obróci się w najkrótszym kierunku, aby osiągnąć docelowy kierunek.
turn_to_rotation — Obraca robota o określoną wartość.
stop — Zatrzymuje ruch robota.
calibrate_drivetrain — Kalibruje czujnik skonfigurowany z układem napędowym.

Mutatory — Dostosuj ustawienia układu napędowego.

set_drive_velocity — Informuje robota, z jaką prędkością ma jechać.
set_turn_velocity — Informuje robota, jak szybko ma skręcić.
set_stopping — Informuje, w jaki sposób robot zatrzyma się: poprzez hamowanie, jazdę bez obciążenia lub przytrzymanie.
set_timeout — Ustawia, ile czasu robot będzie próbował zakończyć ruch.
set_heading — Zmienia aktualny kierunek robota na nowy kierunek.
set_rotation — Zmienia aktualny obrót robota na nowy obrót.
set_turn_threshold — Informuje, jak blisko robot musi się znaleźć pod kątem docelowym, aby zakończyć obrót.
set_turn_constant — Zmienia siłę, z jaką robot koryguje swoje obroty.

Gettery — sprawdź status ruchu.

heading — Zwraca aktualny kierunek robota od 0 do 359 stopni.
rotation — Zwraca aktualny obrót robota.
velocity — Zwraca prędkość, z jaką porusza się robot.
current — Zwraca ilość prądu elektrycznego zużywanego przez układ napędowy.
is_moving — Zwraca wartość logiczną informującą, czy robot się porusza.
is_done — Zwraca wartość logiczną informującą, czy robot zakończył ruch.
is_turning — Zwraca wartość logiczną, czy robot się obraca.
power — Zwraca informację o tym, jak szybko układ napędowy zużywa energię.
torque — Zwraca informację o tym, jaki moment obrotowy wykorzystuje układ napędowy.
efficiency — Zwraca informację o tym, jak efektywnie układ napędowy wykorzystuje moc.
temperature — Zwraca informację o tym, jak ciepły jest układ napędowy.

Konstruktorzy — ręczne tworzenie i konfiguracja układu napędowego.

DriveTrain — Tworzy układ napędowy bez czujnika żyroskopowego lub czujnika bezwładnościowego.
SmartDrive — Tworzy układ napędowy z czujnikiem żyroskopowym lub czujnikiem bezwładnościowym.

Akcje #

drive #

Napęd drive porusza robota do przodu lub do tyłu w nieskończoność. Robot będzie się poruszał, dopóki nie otrzyma innej akcji, takiej jak obrót lub zatrzymanie.

Usage:
drivetrain.drive(direction, velocity, units)

Parametry	Opis
`direction`	Kierunek, w którym porusza się robot: `FORWARD` lub `REVERSE`.
`velocity`	Opcjonalnie. Prędkość jazdy od 0% do 100% przy użyciu opcji `PERCENT`, od 0 do 120 obr./min przy użyciu opcji `RPM`lub od 0 do 720 stopni na sekundę przy użyciu opcji `VelocityUnits.DPS`Może to być liczba całkowita `integer` lub dziesiętna (`float`). Jeśli prędkość nie zostanie podana, robot będzie jechał z bieżącą prędkością jazdy.
`units`	Opcjonalnie. Jednostka prędkości: `PERCENT` (domyślnie), `RPM` (obroty na minutę) lub `VelocityUnits.DPS` (stopnie na sekundę).

# 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 przesuwa robota do przodu lub do tyłu o określoną odległość. Projekt będzie czekał, aż robot zakończy ruch, zanim uruchomi się kolejny wiersz kodu.

Usage:
drivetrain.drive_for(direction, distance, units, velocity, units_v, wait)

Parametry	Opis
`direction`	Kierunek, w którym porusza się robot: `FORWARD` lub `REVERSE`.
`distance`	Odległość pokonywana przez robota. Może to być liczba całkowita `integer` lub liczba dziesiętna (`float`).
`units`	Opcjonalnie. Jednostka odległości: `INCHES` (domyślna), `MM` (milimetry) lub `DistanceUnits.CM` (centymetry).
`velocity`	Opcjonalnie. Prędkość jazdy od 0% do 100% przy użyciu opcji `PERCENT`, od 0 do 120 obr./min przy użyciu opcji `RPM`lub od 0 do 720 stopni na sekundę przy użyciu opcji `VelocityUnits.DPS`Może to być liczba całkowita `integer` lub dziesiętna (`float`). Jeśli prędkość nie zostanie podana, robot będzie jechał z bieżącą prędkością jazdy.
`units_v`	Opcjonalnie. Jednostka prędkości: `RPM` (obroty na minutę, domyślnie), `PERCENT`lub `VelocityUnits.DPS` (stopnie na sekundę).
`wait`	Opcjonalnie. `wait=True` (domyślnie) powoduje, że projekt czeka, aż robot zakończy ruch, zanim zostanie wykonany kolejny wiersz kodu. `wait=False` powoduje, że następny wiersz kodu zostanie wykonany natychmiast.

# 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 obraca robota w lewo lub w prawo w nieskończoność. Robot będzie się obracał, dopóki nie zostanie mu przydzielona inna czynność, taka jak jazda lub zatrzymanie.

Usage:
drivetrain.turn(direction, velocity, units)

Parametry	Opis
`direction`	Kierunek, w którym obraca się robot: `LEFT` lub `RIGHT`.
`velocity`	Opcjonalnie. Prędkość obrotu od 0% do 100% przy użyciu opcji `PERCENT`, od 0 do 120 obr./min przy użyciu opcji `RPM`lub od 0 do 720 stopni na sekundę przy użyciu opcji `VelocityUnits.DPS`Może to być liczba całkowita `integer` lub dziesiętna (`float`). Jeśli prędkość nie zostanie podana, robot obraca się z bieżącą prędkością obrotu.
`units`	Opcjonalnie. Jednostka prędkości: `RPM` (obroty na minutę, domyślnie), `PERCENT`lub `VelocityUnits.DPS` (stopnie na sekundę).

# 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 obraca robota w lewo lub w prawo o określoną liczbę stopni lub obrotów. Obrót jest względny do bieżącej pozycji robota. Projekt będzie czekał, aż robot zakończy obrót, zanim uruchomi się kolejny wiersz kodu.

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

Parametry	Opis
`direction`	Kierunek, w którym obraca się robot: `LEFT` lub `RIGHT`.
`angle`	Wartość, o jaką obraca się robot. Może to być liczba całkowita `integer` lub liczba dziesiętna (`float`).
`units`	Opcjonalnie. Jednostka obrotu: `DEGREES` (domyślnie) lub `TURNS`Jeden obrót to 360 stopni.
`velocity`	Opcjonalnie. Prędkość obrotu od 0% do 100% przy użyciu opcji `PERCENT`, od 0 do 120 obr./min przy użyciu opcji `RPM`lub od 0 do 720 stopni na sekundę przy użyciu opcji `VelocityUnits.DPS`Może to być liczba całkowita `integer` lub dziesiętna (`float`). Jeśli prędkość nie zostanie podana, robot obraca się z bieżącą prędkością obrotu.
`units_v`	Opcjonalnie. Jednostka prędkości: `RPM` (obroty na minutę, domyślnie), `PERCENT`lub `VelocityUnits.DPS` (stopnie na sekundę).
`wait`	Opcjonalnie. `wait=True` (domyślnie) powoduje, że projekt czeka, aż robot skończy się obracać, zanim zostanie wykonany kolejny wiersz kodu. `wait=False` powoduje, że następny wiersz kodu zostanie wykonany natychmiast.

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

Kurs to kierunek, w którym zwrócony jest robot, mierzony w stopniach. turn_to_heading obraca robota w określonym kierunku od -359 do 359 stopni. Robot obróci się w najkrótszym kierunku, aby osiągnąć docelowy kurs.

Początkowy kierunek robota wynosi 0 stopni.

Projekt będzie czekał, aż robot zakończy obracanie się, zanim zostanie uruchomiony kolejny wiersz kodu.

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

Parametry	Opis
`angle`	Kierunek, w którym robot powinien być zwrócony, wyrażony w stopniach. Może to być liczba całkowita `integer` lub liczba dziesiętna (`float`) z zakresu od -359 do 359.
`units`	Opcjonalnie. Jednostka nagłówka: `DEGREES` (domyślna).
`velocity`	Opcjonalnie. Prędkość obrotu od 0% do 100% przy użyciu opcji `PERCENT`, od 0 do 120 obr./min przy użyciu opcji `RPM`lub od 0 do 720 stopni na sekundę przy użyciu opcji `VelocityUnits.DPS`Może to być liczba całkowita `integer` lub dziesiętna (`float`). Jeśli prędkość nie zostanie podana, robot obraca się z bieżącą prędkością obrotu.
`units_v`	Opcjonalnie. Jednostka prędkości: `PERCENT` (domyślnie), `RPM` (obroty na minutę) lub `VelocityUnits.DPS` (stopnie na sekundę).
`wait`	Opcjonalnie. `wait=True` (domyślnie) powoduje, że projekt czeka, aż robot skończy się obracać, zanim zostanie wykonany kolejny wiersz kodu. `wait=False` powoduje, że następny wiersz kodu zostanie wykonany natychmiast.

# 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 obraca robota o określoną wartość.

Obrót to wartość, o jaką robot wykonał obrót, mierzona w stopniach lub obrotach. Na początku projektu wartość obrotu jest ustawiona na 0 stopni. Obrót można również ustawić za pomocą metody set_rotation.

Wartości obrotu są bezwzględne. Oznacza to, że kierunek obrotu zależy od aktualnego obrotu robota. Skręt w prawo zwiększa obrót, a w lewo zmniejsza.

Na przykład, jeśli robot zaczyna od 0 stopni i obrócisz go o 720 stopni, skręci w prawo dwa razy. Jeśli następnie obrócisz go o 360 stopni, skręci raz w lewo, ponieważ 360 stopni to mniej niż 720.

Projekt będzie czekał, aż robot zakończy obracanie się, zanim zostanie uruchomiony kolejny wiersz kodu.

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

Parametry	Opis
`angle`	Wartość obrotu, w stopniach lub obrotach, o którą obróci się robot. Może to być `integer` lub liczba dziesiętna (`float`).
`units`	Opcjonalnie. Jednostka obrotu: `DEGREES` (domyślnie) lub `TURNS`Jeden obrót to 360 stopni.
`velocity`	Opcjonalnie. Prędkość obrotu od 0% do 100% przy użyciu opcji `PERCENT`, od 0 do 120 obr./min przy użyciu opcji `RPM`lub od 0 do 720 stopni na sekundę przy użyciu opcji `VelocityUnits.DPS`Może to być liczba całkowita `integer` lub dziesiętna (`float`). Jeśli prędkość nie zostanie podana, robot obraca się z bieżącą prędkością obrotu.
`units_v`	Opcjonalnie. Jednostka prędkości: `PERCENT` (domyślnie), `RPM` (obroty na minutę) lub `VelocityUnits.DPS` (stopnie na sekundę).
`wait`	Opcjonalnie. `wait=True` (domyślnie) powoduje, że projekt czeka, aż robot skończy się obracać, zanim zostanie wykonany kolejny wiersz kodu. `wait=False` powoduje, że następny wiersz kodu zostanie wykonany natychmiast.

# 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 zatrzymuje ruch robota.

Usage:
drivetrain.stop(mode)

Parametry	Opis
`mode`	Opcjonalnie. Jak robot się zatrzyma: `BRAKE` (domyślnie), `BRAKE`lub `COAST` `COAST` — zatrzymuje się natychmiast. `HOLD` — zwalnia do zatrzymania. `HOLD` — zatrzymuje się natychmiast i utrzymuje pozycję kół.

Parametry

Opis

mode

Opcjonalnie. Jak robot się zatrzyma: BRAKE (domyślnie), BRAKElub COAST

COAST — zatrzymuje się natychmiast.
HOLD — zwalnia do zatrzymania.
HOLD — zatrzymuje się natychmiast i utrzymuje pozycję kół.

# 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 to wbudowana funkcja kalibrująca czujnik żyroskopowy lub czujnik bezwładnościowy skonfigurowany z układem napędowym.

Kalibracja pomaga czujnikowi prawidłowo mierzyć ruch. Podczas kalibracji należy utrzymać robota w bezruchu przez około 2 sekundy. Jeśli robot porusza się podczas kalibracji, czujnik może nieprawidłowo mierzyć ruch.

Projekt zaczeka na zakończenie kalibracji przed uruchomieniem kolejnej linii kodu.

Uwaga: Tej funkcji nie można używać w programie VS Code.

Usage:
calibrate_drivetrain()

Parametry	Opis
	Ta funkcja nie ma żadnych parametrów.

Mutatory #

set_drive_velocity #

set_drive_velocity określa prędkość, z jaką robot ma jechać. Wyższy procent sprawia, że robot jedzie szybciej, a niższy – wolniej.

Każdy projekt rozpoczyna się od tego, że robot domyślnie porusza się z prędkością równą 50%.

Uwaga: Większa prędkość sprawia, że robot jedzie szybciej, ale może być mniej precyzyjny. Niższa prędkość sprawia, że robot jedzie wolniej, ale może być bardziej precyzyjny.

Usage:
drivetrain.set_drive_velocity(velocity, units)

Parametry	Opis
`velocity`	Prędkość jazdy od 0% do 100% przy użyciu `PERCENT`, od 0 do 120 obr./min przy użyciu `RPM`lub od 0 do 720 stopni na sekundę przy użyciu `VelocityUnits.DPS`Może to być liczba całkowita `integer` lub liczba dziesiętna (`float`).
`units`	Opcjonalnie. Jednostka prędkości: `PERCENT` (domyślnie), `RPM` (obroty na minutę) lub `VelocityUnits.DPS` (stopnie na sekundę).

# 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 określa, jak szybko robot ma się skręcić. Wyższy procent powoduje, że robot skręca szybciej, a niższy – że skręca wolniej.

Każdy projekt rozpoczyna się od ustawienia robota tak, aby domyślnie obracał się z prędkością równą 50%.

Uwaga: Większa prędkość sprawia, że robot skręca szybciej, ale może być mniej precyzyjny. Niższa prędkość sprawia, że robot skręca wolniej, ale może być bardziej precyzyjny.

Usage:
drivetrain.set_turn_velocity(velocity, units)

Parametry	Opis
`velocity`	Prędkość obrotu od 0% do 100% przy użyciu opcji `PERCENT`, od 0 do 120 obr./min przy użyciu opcji `RPM`lub od 0 do 720 stopni na sekundę przy użyciu opcji `VelocityUnits.DPS`Może to być liczba całkowita `integer` lub liczba dziesiętna (`float`).
`units`	Opcjonalnie. Jednostka prędkości: `PERCENT` (domyślnie), `RPM` (obroty na minutę) lub `VelocityUnits.DPS` (stopnie na sekundę).

# 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 ustawia sposób zatrzymania robota: poprzez hamowanie, jazdę bez obciążenia lub przytrzymywanie.

Usage:
drivetrain.set_stopping(mode)

Parametry	Opis
`mode`	Jak robot się zatrzyma: `BRAKE` — Zatrzymuje się natychmiast. `COAST` — Zwalnia do zatrzymania. `HOLD` — Zatrzymuje się natychmiast i utrzymuje pozycję kół.

Parametry

Opis

mode

Jak robot się zatrzyma:

BRAKE — Zatrzymuje się natychmiast.
COAST — Zwalnia do zatrzymania.
HOLD — Zatrzymuje się natychmiast i utrzymuje pozycję kół.

Jeśli ta metoda nie zostanie użyta, robot będzie używał hamulca BRAKE podczas zatrzymywania.

set_timeout #

set_timeout ustawia, ile czasu robot będzie próbował ukończyć ruch. Jeśli robot nie zdoła ukończyć ruchu w tym czasie, przerwie próby i przejdzie do następnego wiersza kodu. Zapobiega to zablokowaniu ruchu przez robota.

Usage:
drivetrain.set_timeout(value, units)

Parametry	Opis
`value`	Czas, w którym robot może próbować zakończyć ruch. Może to być dodatnia liczba całkowita `integer` lub liczba dziesiętna (`float`).
`units`	Opcjonalnie. Jednostka czasu: `MSEC` (milisekundy, domyślnie) lub `SECONDS`.

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

set_heading #

Kierunek to kierunek, w którym zwrócony jest robot, mierzony w stopniach. set_heading zmienia bieżący kierunek robota na nową wartość kierunku.

Na przykład, jeśli robot obrócił się w prawo, ustawienie kierunku na 0 stopni spowoduje, że ta pozycja skierowana w prawo stanie się nowym 0 stopniem. Następnie robot może obrócić się w inne pozycje w oparciu o ten nowy kierunek.

Usage:
drivetrain.set_heading(heading, units)

Parametry	Opis
`heading`	Wartość kierunku w stopniach lub obrotach, którą należy ustawić dla robota. Może to być `integer` lub liczba dziesiętna (`float`).
`units`	Opcjonalnie. Jednostka nagłówka: `DEGREES` (domyślnie) lub `TURNS`Jeden obrót to 360 stopni.

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

set_rotation #

Obrót to wartość, o jaką robot wykonał obrót, mierzona w stopniach lub obrotach. Na początku projektu wartość obrotu jest ustawiona na 0 stopni. Parametr set_rotation zmienia bieżący obrót robota na nową wartość.

Na przykład, jeśli robot wykonał dwa pełne obroty w prawo, jego wartość obrotu wyniesie 720 stopni. Ustawienie obrotu na 0 stopni zresetuje ten obrót z 720 do 0 stopni. Następnie robot może wykonać obrót w oparciu o tę nową wartość.

Usage:
drivetrain.set_rotation(rotation, units)

Parametry	Opis
`rotation`	Wartość obrotu, w stopniach lub obrotach, do ustawienia dla robota. Może to być `integer` lub liczba dziesiętna (`float`).
`units`	Opcjonalnie. Jednostka obrotu: `DEGREES` (domyślnie) lub `TURNS`Jeden obrót to 360 stopni.

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

set_turn_threshold #

set_turn_threshold ustawia, jak blisko robot musi się znaleźć pod kątem docelowym, aby zakończyć obrót.

Niższy próg może zwiększyć precyzję skrętów, ale robot może potrzebować więcej czasu na ich wykonanie. Wyższy próg może przyspieszyć wykonywanie skrętów, ale mogą one być mniej precyzyjne.

Usage:
drivetrain.set_turn_threshold(value)

Parametry	Opis
`value`	Próg obrotu w stopniach. Może to być liczba całkowita `integer` lub liczba dziesiętna (`float`). Domyślny próg obrotu to 1 stopień.

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

set_turn_constant #

set_turn_constant zmienia siłę, z jaką robot koryguje swoje obroty.

Wyższa wartość sprawia, że robot wykonuje skręty z większą siłą. Niższa wartość sprawia, że robot wykonuje skręty z mniejszą siłą. Wartość domyślna to 1,0.

Usage:
drivetrain.set_turn_constant(value)

Parametry	Opis
`value`	Stała obrotu. Może to być liczba dziesiętna (`float`) od 0,1 do 4,0. Wartość domyślna to 1,0.

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

Getters #

heading #

Kurs to kierunek, w którym zwrócony jest robot, mierzony w stopniach. heading zwraca aktualny kurs robota od 0 do 359 stopni.

Początkowy kierunek robota wynosi 0 stopni.

Usage:
drivetrain.heading(units)

Parametry	Opis
`units`	Opcjonalnie. Jednostka, w której ma powrócić, ma kurs: `DEGREES` (domyślnie) lub `TURNS`Jeden obrót to 360 stopni.

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

rotation #

Obrót to wartość, o jaką robot wykonał obrót, mierzona w stopniach lub obrotach. Na początku projektu wartość obrotu jest ustawiona na 0 stopni. rotation zwraca aktualny obrót robota.

Skręt w prawo zwiększa obrót, a skręt w lewo zmniejsza. Na przykład, wykonanie dwóch pełnych obrotów w prawo spowoduje obrót o 720 stopni.

Usage:
drivetrain.rotation(units)

Parametry	Opis
`units`	Opcjonalnie. Jednostka, w której następuje obrót: `DEGREES` (domyślnie) lub `TURNS`Jeden obrót to 360 stopni.

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

velocity #

velocity zwraca informację o tym, jak szybko porusza się robot.

Prędkość może być podana w procentach od -100% do 100%, w RPM od -127 obr./min do 127 obr./min lub w VelocityUnits.DPS (stopniach na sekundę). Wartość dodatnia oznacza, że robot jedzie do przodu. Wartość ujemna oznacza, że robot jedzie do tyłu.

Usage:
drivetrain.velocity(units)

Parametry	Opis
`units`	Opcjonalnie. Jednostka, w której ma być zwrócona prędkość: `PERCENT` (domyślnie), `RPM` (obroty na minutę) lub `VelocityUnits.DPS` (stopnie na sekundę).

current #

current zwraca natężenie prądu elektrycznego pobieranego przez układ napędowy, mierzone w amperach. Natężenie prądu to ilość prądu przepływającego przez układ napędowy.

Wyższa wartość prądu oznacza, że układ napędowy zużywa więcej prądu. Może się to zdarzyć, gdy robot naciska na obiekt lub próbuje się poruszyć, gdy utknie.

Można tego użyć, aby sprawdzić, czy układ napędowy ma problemy podczas ruchu. Jeśli prąd utrzymuje się na wysokim poziomie, układ napędowy może się nagrzewać lub zużywać energię mniej efektywnie.

Usage:
drivetrain.current(units)

Parametry	Opis
`units`	Opcjonalnie. Jednostka, w której ma być zwrócony prąd: `CurrentUnits.AMP` (ampery, wartość domyślna).

is_moving #

is_moving zwraca wartość logiczną, czy robot się porusza. Można jej użyć do kontrolowania czasu innych zachowań na podstawie ruchu robota.

True — Robot się porusza.
False — Robot się nie porusza.

Ta metoda działa razem z następującymi metodami Drivetrain, które mają parametr wait wait : drive_for, turn_for, turn_to_heading i turn_to_rotation.

Usage:
drivetrain.is_moving()

Parametry	Opis
	Ta metoda nie ma żadnych parametrów.

is_done #

is_done zwraca wartość logiczną, czy robot zakończył ruch. Można jej użyć do kontrolowania czasu innych zachowań na podstawie ruchu robota.

True — Robot zakończył ruch.
False — Robot nadal się porusza.

Ta metoda działa razem z następującymi metodami Drivetrain, które mają parametr wait wait : drive_for, turn_for, turn_to_heading i turn_to_rotation.

Usage:
drivetrain.is_done()

Parametry	Opis
	Ta metoda nie ma żadnych parametrów.

is_turning #

is_turning zwraca wartość logiczną, czy robot się obraca. Można jej użyć do sterowania czasem innych zachowań na podstawie ruchu robota.

True — Robot się obraca.
False — Robot się nie obraca.

Ta metoda działa razem z następującymi metodami Drivetrain, które mają parametr wait wait : turn_for, turn_to_heading i turn_to_rotation.

Usage:
drivetrain.is_turning()

Parametry	Opis
	Ta metoda nie ma żadnych parametrów.

power #

power zwraca ilość energii zużywanej przez układ napędowy, mierzoną w watach. Power pokazuje, jak szybko układ napędowy zużywa energię.

Wyższa wartość mocy oznacza, że układ napędowy zużywa energię szybciej. Może się to zdarzyć, gdy robot naciska na obiekt lub próbuje się poruszyć, gdy utknie.

Można tego użyć do porównania ruchów lub sprawdzenia, czy układ napędowy ma problemy. Jeśli moc utrzymuje się na wysokim poziomie, układ napędowy może się nagrzewać lub zużywać energię mniej efektywnie.

Usage:
drivetrain.power()

Parametry	Opis
	Ta metoda nie ma żadnych parametrów.

torque #

Moment obrotowy pokazuje, jak mocno układ napędowy może pchać lub ciągnąć, gdy koła się kręcą.

torque zwraca wartość momentu obrotowego wykorzystywanego przez układ napędowy, mierzoną w niutonometrach (Nm) lub funtach na cal (InLb).

Wyższy moment obrotowy oznacza, że układ napędowy pcha lub ciągnie mocniej. Może się tak zdarzyć, gdy robot pcha obiekt lub próbuje się poruszyć, gdy utknie.

Można tego użyć, aby sprawdzić, czy układ napędowy ma problemy lub porównać, ile siły nacisku potrzeba przy różnych ruchach.

Usage:
drivetrain.torque(units)

Parametry	Opis
`units`	Opcjonalnie. Jednostka momentu obrotowego: `TorqueUnits.NM` (niutonometry, domyślnie) lub `TorqueUnits.INLB` (cale-funty).

efficiency #

efficiency zwraca informację o tym, jak efektywnie układ napędowy wykorzystuje moc, w procentach od 0% do 100%.

Sprawność pokazuje, jaka część mocy układu napędowego jest wykorzystywana do poruszania się. Wyższa wartość sprawności oznacza, że większa część mocy układu napędowego jest wykorzystywana do poruszania się. Niższa wartość sprawności może wystąpić, gdy układ napędowy intensywnie pracuje, ale porusza się nieznacznie, na przykład gdy robot utknął lub popycha obiekt.

Można tego użyć do porównania ruchów lub sprawdzenia, czy układ napędowy marnuje moc zamiast wykorzystać ją do ruchu.

Usage:
drivetrain.efficiency()

Parametry	Opis
	Ta metoda nie ma żadnych parametrów.

temperature #

temperature zwraca średnią temperaturę układu napędowego w wybranej jednostce temperatury.

Temperatura wskazuje, jak ciepłe są silniki układu napędowego. Wyższa temperatura oznacza, że silniki nagrzewają się podczas pracy. Aby silniki pracowały z pełną wydajnością, ich temperatura powinna utrzymywać się poniżej 55°C.

Jeśli silniki się przegrzeją, obniżą maksymalny prąd, aby się zabezpieczyć. Przy temperaturze 70°C silniki przestaną pracować do momentu ostygnięcia.

Można tego użyć, aby sprawdzić, czy układ napędowy nie nagrzewa się zbytnio podczas powtarzających się ruchów, długich przejazdów lub gdy naciska na jakiś obiekt.

Usage:
drivetrain.temperature(units)

Parametry	Opis
`units`	Opcjonalnie. Jednostka temperatury, w której ma być zwrócona: `TemperatureUnits.CELSIUS` (domyślnie) lub `TemperatureUnits.FAHRENHEIT`.

Konstruktorzy #

Konstruktory służą do tworzenia w kodzie obiektów DriveTrain i SmartDrive Jest to przydatne podczas konfigurowania układu napędowego bez użycia okna Urządzenia.

Przed utworzeniem układu napędowego należy utworzyć co najmniej dwa obiekty Motor lub MotorGroup.

DriveTrain #

DriveTrain tworzy układ napędowy bez czujnika żyroskopowego lub czujnika bezwładnościowego.

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

Parametr	Opis
`lm`	Lewy silnik lub grupa silników.
`rm`	Prawy silnik lub grupa silników.
`wheelTravel`	Opcjonalnie. Obwód kół napędowych. Domyślnie 300 milimetrów.
`trackWidth`	Opcjonalnie. Szerokość między lewym a prawym kołem. Domyślnie 320 milimetrów.
`wheelBase`	Opcjonalnie. Odległość między przednimi i tylnymi kołami. Domyślnie 320 milimetrów.
`units`	Opcjonalnie. Jednostka dla `wheelTravel`, `trackWidth`i `wheelBase`: `MM` (milimetrów, domyślnie), `INCHES`lub `DistanceUnits.CM` (centymetrów).
`externalGearRatio`	Opcjonalnie. Przełożenie używane do regulacji odległości jazdy, jeśli używane są przekładnie. Może to być `integer` lub liczba dziesiętna (`float`). Wartość domyślna to 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 tworzy układ napędowy z czujnikiem żyroskopowym lub czujnikiem bezwładnościowym.

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

Parametr	Opis
`lm`	Lewy silnik lub grupa silników.
`rm`	Prawy silnik lub grupa silników.
`g`	Czujnik żyroskopowy lub Czujnik bezwładnościowy używany przez układ napędowy.
`wheelTravel`	Opcjonalnie. Obwód kół napędowych. Domyślnie 300 milimetrów.
`trackWidth`	Opcjonalnie. Szerokość między lewym a prawym kołem. Domyślnie 320 milimetrów.
`wheelBase`	Opcjonalnie. Odległość między przednimi i tylnymi kołami. Domyślnie 320 milimetrów.
`units`	Opcjonalnie. Jednostka dla `wheelTravel`, `trackWidth`i `wheelBase`: `MM` (milimetrów, domyślnie), `INCHES`lub `DistanceUnits.CM` (centymetrów).
`externalGearRatio`	Opcjonalnie. Przełożenie używane do regulacji odległości jazdy, jeśli używane są przekładnie. Może to być `integer` lub liczba dziesiętna (`float`). Wartość domyślna to 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)

Jeśli tworzysz inteligentny układ napędowy z wieloma silnikami, musisz utworzyć silniki osobno, zanim połączysz je w grupę silników.

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