Układ napędowy#

Wstęp #

Układ napędowy obejmuje koła i silniki, które sterują jazdą i skręcaniem robota. Układy napędowe można znaleźć w takich zestawach jak Code Base 2.0, Super Car czy w niestandardowych robotach.

Układy napędowe wykorzystują Czujnik bezwładności w mózgu do wykrywania kolizji i wspomagania precyzyjnego poruszania się i skręcania robota. Na początku każdego projektu układ napędowy automatycznie kalibruje czujnik bezwładności. Podczas kalibracji należy unieruchomić robota na około 2 sekundy, aby mógł on poruszać się i skręcać prawidłowo.

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ść.
drive_until — Przesuwa robota do przodu, aż czujnik oka wykryje obiekt lub robot wykryje zderzenie.
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.

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, jak długo 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.

Gettery — sprawdź status ruchu.

get_heading — Zwraca aktualny kierunek robota od 0 do 359 stopni.
get_rotation — Zwraca aktualny obrót robota.
get_velocity — Zwraca szybkość, z jaką porusza się robot, w procentach od -100% do 100%.
get_yaw — Zwraca aktualne odchylenie robota.
get_roll — Zwraca aktualny rzut robota.
get_pitch — Zwraca aktualny ton głosu robota.
get_crashed — Zwraca wartość logiczną, czy robot wykrył awarię.
is_stopped — Zwraca wartość logiczną, czy robot zakończył ruch.

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)

Parametry	Opis
`direction`	Kierunek, w którym porusza się robot: `FORWARD` lub `REVERSE`.

# Build Used: Code Base 2.0
def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# Start threads — Do not delete
start_thread(main)

drive_for #

drive_for przesuwa robota do przodu lub do tyłu na określoną odległość.

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

Parametry	Opis
`direction`	Kierunek, w którym porusza się robot: `FORWARD` lub `REVERSE`.
`distance`	Odległość pokonywana przez robota. Może być liczbą całkowitą lub dziesiętną.
`units`	Opcjonalnie. Jednostka odległości: `MM` (milimetry, domyślnie) lub `INCHES`.
`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.

# Build Used: Code Base 2.0
def main():
    # Drive back and forth
    drivetrain.drive_for(FORWARD, 100, MM)
    drivetrain.drive_for(REVERSE, 4, INCHES)
    

# Start threads — Do not delete
start_thread(main)

drive_until #

drive_until przesuwa robota do przodu, aż czujnik oka wykryje obiekt lub robot wykryje zderzenie.

Usage:
drivetrain.drive_until(condition, wait)

Parametry	Opis
`condition`	Warunek, który zatrzymuje robota: `OBJECT` lub `CRASH`.
`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.

# Build Used: Code Base 2.0
def main():
    # Turn right after a crash
    drivetrain.drive_until(CRASH)
    drivetrain.turn_for(RIGHT, 90)

# Start threads — Do not delete
start_thread(main)

turn #

turn obraca robota w lewo lub w prawo w nieskończoność. Robot będzie się obracał, dopóki nie zostanie mu wydana inna czynność, np. jazda do zatrzymania.

Usage:
drivetrain.turn(direction)

Parametry	Opis
`direction`	Kierunek, w którym obraca się robot: `LEFT` lub `RIGHT`.

# Build Used: Code Base 2.0
def main():
    # Turn right and left, then stop
    drivetrain.turn(RIGHT)
    wait(2, SECONDS)
    drivetrain.turn(LEFT)
    wait(2, SECONDS)
    drivetrain.stop()

# Start threads — Do not delete
start_thread(main)

turn_for #

turn_for obraca robota w lewo lub w prawo o określoną liczbę stopni. Obrót jest względny w stosunku do aktualnej pozycji robota.

Usage:
drivetrain.turn_for(direction, angle, wait)

Parametry	Opis
`direction`	Kierunek, w którym obraca się robot: `LEFT` lub `RIGHT`.
`angle`	Liczba stopni, o jaką obróci się robot. Może to być liczba całkowita lub dziesiętna.
`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.

# Build Used: Code Base 2.0
def main():
    # Turn right then left
    drivetrain.turn_for(RIGHT, 90)
    drivetrain.turn_for(LEFT, 90)

# Start threads — Do not delete
start_thread(main)

turn_to_heading #

Kurs to kierunek, w którym zwrócony jest mózg robota, 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 kurs wynosi 0 stopni.

Kod VEX GO Base 2.0 pokazujący kierunki kursu: 0 stopni do przodu, 90 stopni w prawo, 180 stopni do tyłu i 270 stopni w lewo.

Usage:
drivetrain.turn_to_heading(angle, wait)

Parametry	Opis
`angle`	Kierunek, w którym robot powinien być zwrócony, wyrażony liczbą całkowitą z zakresu od -359 do 359 stopni.
`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.

# Build Used: Code Base 2.0
def main():
    # Turn to face the cardinal directions
    drivetrain.turn_to_heading(90)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(180)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(270)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(0)

# Start threads — Do not delete
start_thread(main)

turn_to_rotation #

turn_to_rotation obraca robota o określoną wartość.

Obrót to wartość obrotu robota, mierzona w stopniach. Na początku projektu wartość obrotu jest ustawiona na 0 stopni. Obrót można również ustawić za pomocą 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.

Kod VEX GO Base 2.0 ze strzałkami obracającymi się w prawo i w lewo. Lewa strzałka pokazuje „minus”, a prawa „plus”.

Usage:
drivetrain.turn_to_rotation(angle, wait)

Parametry	Opis
`angle`	Wartość obrotu, w stopniach, o jaką obróci się robot. Może to być liczba całkowita.
`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.

# Build Used: Code Base 2.0
def main():
    # Make one full turn to the right
    drivetrain.turn_to_rotation(360)
    # Make another full turn to the right
    drivetrain.turn_to_rotation(720)
    # Make one full turn to the left, returning to 360 degrees
    drivetrain.turn_to_rotation(360)
# Start threads — Do not delete
start_thread(main)

stop #

stop zatrzymuje ruch robota.

Usage:
drivetrain.stop()

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

# Build Used: Code Base 2.0
def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# Start threads — Do not delete
start_thread(main)

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 jest bardziej precyzyjny.

Usage:
drivetrain.set_drive_velocity(velocity)

Parametry	Opis
`velocity`	Prędkość jazdy od 0% do 100%.

# Build Used: Code Base 2.0
def main():
    # Drive at different velocities
    drivetrain.drive_for(FORWARD, 100, MM)
    wait(1, SECONDS)
    # Drive slow
    drivetrain.set_drive_velocity(20)
    drivetrain.drive_for(FORWARD, 100, MM)
    wait(1, SECONDS)
    # Drive fast
    drivetrain.set_drive_velocity(100)
    drivetrain.drive_for(FORWARD, 100, MM)

# Start threads — Do not delete
start_thread(main)

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 jest bardziej precyzyjny.

Usage:
drivetrain.set_turn_velocity(velocity)

Parametry	Opis
`velocity`	Prędkość skrętu od 0% do 100%.

# Build Used: Code Base 2.0
def main():
    # Turn at different velocities
    drivetrain.turn_for(RIGHT, 180)
    wait(1, SECONDS)
    # Turn fast
    drivetrain.set_turn_velocity(100)
    drivetrain.turn_for(RIGHT, 180)

# Start threads — Do not delete
start_thread(main)

set_stopping #

set_stopping ustawia sposób zatrzymania robota: poprzez hamowanie, jazdę bez obciążenia lub przytrzymywanie.

Usage:
drivetrain.set_stopping(brake)

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

Parametry

Opis

brake

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.

# Build Used: Code Base 2.0
def main():
    # Drive, then coast to a stop
    drivetrain.set_drive_velocity(100)
    drivetrain.set_stopping(COAST)
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# Start threads — Do not delete
start_thread(main)

set_timeout #

set_timeout ustawia, jak długo robot będzie próbował zakończyć ruch. Jeśli robot nie zdoła tego zrobić w tym czasie, przerwie próbę i przejdzie do następnej linijki 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ć wykonać ruch. Może to być liczba całkowita lub dziesiętna.
`units`	Opcjonalnie. Jednostka czasu: `SECONDS` (domyślnie) lub `MSEC` (milisekundy).

# Build Used: Code Base 2.0
def main():
    # Drive as far as possible for 1 second before turning right
    drivetrain.set_timeout(1, SECONDS)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    drivetrain.turn_for(RIGHT, 90)

# Start threads — Do not delete
start_thread(main)

set_heading #

Kierunek to kierunek, w którym zwrócony jest mózg robota, 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(value)

Parametry	Opis
`value`	Wartość kierunku (w stopniach), którą należy ustawić dla robota. Może to być liczba całkowita od 0 do 359.

# Build Used: Code Base 2.0
def main():
    # Face the new 0 degree heading
    drivetrain.set_heading(90)
    drivetrain.turn_to_heading(0)

# Start threads — Do not delete
start_thread(main)

set_rotation #

Obrót to wartość obrotu robota, mierzona w stopniach. Na początku projektu wartość obrotu jest ustawiona na 0 stopni. 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(value)

Parametry	Opis
`value`	Wartość obrotu (w stopniach), którą należy ustawić dla robota. Może to być liczba całkowita.

# Build Used: Code Base 2.0
def main():
    # Spin counterclockwise two times
    drivetrain.set_rotation(720)
    drivetrain.turn_to_rotation(0)

# Start threads — Do not delete
start_thread(main)

Getters #

get_heading #

Kierunek to kierunek, w którym zwrócony jest mózg robota, mierzony w stopniach. get_heading zwraca kierunek z zakresu od 0 do 359 stopni.

Początkowy kierunek robota wynosi 0 stopni.

Mózg VEX GO pokazujący kierunki: 0 stopni do przodu, 90 stopni w prawo, 180 stopni do tyłu i 270 stopni w lewo.

Usage:
drivetrain.get_heading()

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

# Build Used: Code Base 2.0
def main():
    # Display the heading while turning
    monitor_sensor("drivetrain.get_heading")
    drivetrain.turn_for(RIGHT, 450)


# Start threads — Do not delete
start_thread(main)

get_rotation #

Obrót to wartość obrotu robota, mierzona w stopniach. Na początku projektu wartość obrotu jest ustawiona na 0 stopni. get_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.

Kod VEX GO Base 2.0 ze strzałkami obracającymi się w prawo i w lewo. Lewa strzałka pokazuje „minus”, a prawa „plus”.

Usage:
drivetrain.get_rotation()

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

# Build Used: Code Base 2.0
def main():
    # Display the rotation while turning
    monitor_sensor("drivetrain.get_rotation")
    drivetrain.turn_for(RIGHT, 450)


# Start threads — Do not delete
start_thread(main)

get_velocity #

get_velocity zwraca szybkość, z jaką porusza się robot, w procentach od -100% do 100%.

Wartość dodatnia oznacza, że robot jedzie do przodu. Wartość ujemna oznacza, że robot jedzie do tyłu.

Usage:
drivetrain.get_velocity()

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

# Build Used: Code Base 2.0
def main():
    # Display the velocity of the robot before and while moving
    console.print("Start: ")
    console.print(drivetrain.get_velocity())
    console.new_line()
    drivetrain.drive(FORWARD)
    wait(0.5, SECONDS)
    console.print("Moving: ")
    console.print(drivetrain.get_velocity())
    drivetrain.stop()


# Start threads — Do not delete
start_thread(main)

get_yaw #

Odchylenie to kąt, o jaki robot obrócił się w lewo lub w prawo od pozycji początkowej, mierzony w stopniach. get_yaw zwraca aktualną wartość odchylenia robota.

Skręt w prawo zwiększa wartość odchylenia, a skręt w lewo zmniejsza wartość odchylenia.

Usage:
drivetrain.get_yaw()

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

# Build Used: Super Code Base 2.0
def main():
    # Change the LED color based on the yaw while
    # moving the robot by hand
    monitor_sensor("drivetrain.get_yaw")
    while True:
        if drivetrain.get_yaw() > 0:
            bumper.set_color(GREEN)
        elif drivetrain.get_yaw() < 0:
            bumper.set_color(RED)
        else:
            bumper.set_color(NONE)

# Start threads — Do not delete
start_thread(main)

get_roll #

Przechylenie robota w lewo lub w prawo, mierzone w stopniach. get_roll zwraca aktualną wartość przechyłu robota.

Gdy mózg jest skierowany do przodu, pochylenie w lewo zwiększa wartość przechyłu, a pochylenie w prawo zmniejsza wartość przechyłu.

Usage:
drivetrain.get_roll()

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

# Build Used: Super Code Base 2.0
def main():
    # Change the LED color based on the roll while
    # moving the robot by hand
    monitor_sensor("drivetrain.get_roll")
    while True:
        if drivetrain.get_roll() > 0:
            bumper.set_color(GREEN)
        elif drivetrain.get_roll() < 0:
            bumper.set_color(RED)
        else:
            bumper.set_color(NONE)

# Start threads — Do not delete
start_thread(main)

get_pitch #

Kąt nachylenia to wartość, o jaką robot przechyla się do przodu lub do tyłu, mierzona w stopniach. get_pitch zwraca aktualną wartość kąta nachylenia robota.

Gdy mózg jest skierowany do przodu, pochylenie do przodu zwiększa wartość wysokości dźwięku, a pochylenie do tyłu zmniejsza wartość wysokości dźwięku.

Usage:
drivetrain.get_pitch()

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

# Build Used: Super Code Base 2.0
def main():
    # Change the LED color based on the pitch while
    # moving the robot by hand
    monitor_sensor("drivetrain.get_pitch")
    while True:
        if drivetrain.get_pitch() > 0:
            bumper.set_color(GREEN)
        elif drivetrain.get_pitch() < 0:
            bumper.set_color(RED)
        else:
            bumper.set_color(NONE)

# Start threads — Do not delete
start_thread(main)

get_crashed #

get_crashed zwraca wartość logiczną, czy robot wykrył awarię.

True — Wykryto awarię.
False — Nie wykryto awarii.

Usage:
drivetrain.get_crashed()

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

# Build Used: Super Code Base 2.0
def main():
    # Drive until a crash
    drivetrain.drive(FORWARD)
    while not drivetrain.get_crashed():
        wait(50, MSEC)
    drivetrain.stop()
    drivetrain.turn_for(RIGHT, 90)

# Start threads — Do not delete
start_thread(main)

is_stopped #

is_stopped 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 układu napędowego, które mają parametr wait wait : drive_for, drive_until, turn_for, turn_to_heading i turn_to_rotation.

Usage:
drivetrain.is_stopped()

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

# Build Used: Code Base 2.0
def main():
    # Turn when the drivetrain is done moving forward
    drivetrain.drive_for(FORWARD, 100, MM, wait=False)
    wait(0.25, SECONDS)
    while True:
        if drivetrain.is_stopped():
            drivetrain.turn_for(RIGHT, 180)
            break
        else:
            console.print("Still moving...")
            wait(0.1, SECONDS)
            console.clear()

# Start threads — Do not delete
start_thread(main)