Hajtáslánc#

Bevezetés #

A hajtáslánc kerekeket és motorokat tartalmaz, amelyek a robot mozgását és fordulását szabályozzák. A hajtásláncok olyan buildekben találhatók meg, mint a Code Base 2.0, a Super Car vagy egy egyedi robot.

A hajtásláncok az agyban található inerciális érzékelőt használják az ütközések észlelésére, és segítik a robot pontos mozgását és fordulását. Minden projekt elején a hajtáslánc automatikusan kalibrálja az inerciális érzékelőt. A kalibrálás során tartsa a robotot mozdulatlanul körülbelül 2 másodpercig, hogy a robot megfelelően mozoghasson és fordulhasson.

A hajtáslánc kódolásának számos módja van. Az alábbiakban felsoroljuk az összes hajtáslánc metódust:

Műveletek — A robot mozgatása és forgatása.

drive — A robotot előre vagy hátra mozgatja örökké.
drive_for — Meghatározott távolságra mozgatja a robotot előre vagy hátra.
drive_until — Előre mozgatja a robotot, amíg a szemérzékelő egy tárgyat nem érzékel, vagy a robot ütközést nem észlel.
turn — Örökké balra vagy jobbra forgatja a robotot.
turn_for — Meghatározott fokkal balra vagy jobbra forgatja a robotot.
turn_to_heading — A robotot egy adott irányba fordítja -359 és 359 fok között. A robot a legrövidebb irányba fordul, hogy elérje a célirányt.
turn_to_rotation — Meghatározott forgásirányba fordítja a robotot.
stop — Leállítja a robot mozgását.

Mutátorok – Hajtáslánc-beállítások módosítása.

set_drive_velocity — Megadja a robotnak a haladási sebességét.
set_turn_velocity — Megadja a robotnak, hogy milyen gyorsan forduljon.
set_stopping — Megadja, hogyan fog a robot leállni: fékezéssel, gurulással vagy tartással.
set_timeout — Beállítja, hogy a robot mennyi ideig próbálja befejezni a mozgást.
set_heading — A robot aktuális irányát egy új irányra módosítja.
set_rotation — A robot aktuális forgását egy új forgásra módosítja.

Getterek – Mozgás állapotának ellenőrzése.

get_heading — Visszaadja a robot aktuális irányát 0 és 359 fok között.
get_rotation — Visszaadja a robot aktuális forgását.
get_velocity — Visszaadja a robot vezetési sebességét százalékban, -100%-tól 100%-ig.
get_yaw — Visszaadja a robot aktuális elfordulását.
get_roll — Visszaadja a robot aktuális dobását.
get_pitch — Visszaadja a robot aktuális dőlésszögét.
get_crashed — Logikai értékként adja vissza, hogy a robot észlelt-e összeomlást.
is_stopped — Logikai értékként adja vissza, hogy a robot befejezte-e a mozgást.

Műveletek #

drive #

drive A robotot a végtelenségig előre vagy hátra mozgatja. A robot addig fog mozogni, amíg egy másik műveletet nem kap, például fordulást vagy megállást.

Usage:
drivetrain.drive(direction)

Paraméterek	Leírás
`direction`	A robot mozgásiránya: `FORWARD` vagy `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 A robotot egy adott távolságra előre vagy hátra mozgatja.

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

Paraméterek	Leírás
`direction`	A robot mozgásiránya: `FORWARD` vagy `REVERSE`.
`distance`	A robot által megtett távolság. Ez lehet egész vagy tizedes tört.
`units`	Opcionális. A távolság mértékegysége: `MM` (milliméter, alapértelmezett) vagy `INCHES`.
`wait`	Opcionális. `wait=True` (alapértelmezett) esetén a projekt megvárja, amíg a robot befejezi a mozgást, mielőtt a következő kódsor lefutna. `wait=False` esetén a következő kódsor azonnal lefut.

# 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 A robot előre mozog, amíg a szemérzékelő egy tárgyat nem érzékel, vagy a robot ütközést nem észlel.

Usage:
drivetrain.drive_until(condition, wait)

Paraméterek	Leírás
`condition`	A robotot leállító feltétel: `OBJECT` vagy `CRASH`.
`wait`	Opcionális. `wait=True` (alapértelmezett) esetén a projekt megvárja, amíg a robot befejezi a mozgást, mielőtt a következő kódsor lefutna. `wait=False` esetén a következő kódsor azonnal lefut.

# 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 : A robotot balra vagy jobbra forgatja örökre. A robot addig fog forogni, amíg egy másik műveletet nem kap, például megállásig hajt.

Usage:
drivetrain.turn(direction)

Paraméterek	Leírás
`direction`	A robot fordulási iránya: `LEFT` vagy `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 A robotot egy adott fokkal balra vagy jobbra forgatja. A forgatás a robot aktuális pozíciójához viszonyítva történik.

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

Paraméterek	Leírás
`direction`	A robot fordulási iránya: `LEFT` vagy `RIGHT`.
`angle`	A robot által elfordult fokok száma. Ez lehet egész vagy tizedes tört.
`wait`	Opcionális. `wait=True` (alapértelmezett) esetén a projekt megvárja, amíg a robot befejezi a forgást, mielőtt a következő kódsor lefutna. `wait=False` esetén a következő kódsor azonnal lefut.

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

A haladási irány az az irány, amerre a robot agya néz, fokban mérve. turn_to_heading : Az 1-es érték a robotot egy adott, -359 és 359 fok közötti irányba fordítja. A robot a legrövidebb irányba fordul, hogy elérje a célirányt.

A kezdő irány 0 fok.

Egy VEX GO Code Base 2.0, amely a következő irányokat mutatja: 0 fok előre, 90 fok jobbra, 180 fok hátra és 270 fok balra.

Usage:
drivetrain.turn_to_heading(angle, wait)

Paraméterek	Leírás
`angle`	A robotnak amerre néznie kell, egész számként, -359 és 359 fok között.
`wait`	Opcionális. `wait=True` (alapértelmezett) esetén a projekt megvárja, amíg a robot befejezi a forgást, mielőtt a következő kódsor lefutna. `wait=False` esetén a következő kódsor azonnal lefut.

# 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 A robotot egy adott forgáspontra forgatja.

A forgatás a robot elfordulásának mértékét adja meg fokban mérve. A projekt elején a forgatás értéke 0 fok. A forgatás a set_rotation használatával is beállítható.

A forgási értékek abszolútak. Ez azt jelenti, hogy a fordulat iránya a robot aktuális forgásától függ. Jobbra forgatás növeli, balra forgatás csökkenti a forgást.

Például, ha a robot 0 fokról indul, és 720 fokos elfordulást érünk el, akkor kétszer fordul jobbra. Ha ezután 360 fokos elfordulást végzünk, akkor egyszer fordul balra, mert a 360 fok kisebb, mint a 720 fok.

Egy VEX GO Code Base 2.0, amely jobbra és balra forgó nyilakat mutat. A balra mutató nyíl „mínuszt”, a jobbra mutató nyíl pedig „pluszt” mutat.

Usage:
drivetrain.turn_to_rotation(angle, wait)

Paraméterek	Leírás
`angle`	A robot elfordulási értéke fokban megadva. Ez egész szám lehet.
`wait`	Opcionális. `wait=True` (alapértelmezett) esetén a projekt megvárja, amíg a robot befejezi a forgást, mielőtt a következő kódsor lefutna. `wait=False` esetén a következő kódsor azonnal lefut.

# 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 leállítja a robot mozgását.

Usage:
drivetrain.stop()

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

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

Mutátorok #

set_drive_velocity #

set_drive_velocity megmondja a robotnak, hogy milyen gyorsan haladjon. Magasabb százalékos érték esetén a robot gyorsabban, alacsonyabb százalékos érték esetén pedig lassabban halad.

Minden projekt azzal kezdődik, hogy a robot alapértelmezés szerint 50%-os sebességgel halad.

Megjegyzés: A nagyobb sebesség gyorsabbá teszi a robotot, de kevésbé pontos lehet. Az alacsonyabb sebesség lassabbá teszi a robotot, de pontosabbá.

Usage:
drivetrain.set_drive_velocity(velocity)

Paraméterek	Leírás
`velocity`	A haladási sebesség 0%-tól 100%-ig.

# 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 megmondja a robotnak, hogy milyen gyorsan forduljon. Magasabb százalékos érték esetén a robot gyorsabban, alacsonyabb százalékos érték esetén pedig lassabban fordul.

Minden projekt azzal kezdődik, hogy a robot alapértelmezés szerint 50%-os sebességgel forog.

Megjegyzés: A nagyobb sebesség gyorsabbá teszi a robot forgását, de kevésbé pontos lehet. Az alacsonyabb sebesség lassabbá teszi a robot forgását, de pontosabbá.

Usage:
drivetrain.set_turn_velocity(velocity)

Paraméterek	Leírás
`velocity`	A fordulási sebesség 0%-tól 100%-ig terjedhet.

# 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 beállítja, hogyan állítsa le a robot a mozgást: fékezéssel, gurulással vagy tartással.

Usage:
drivetrain.set_stopping(brake)

Paraméterek	Leírás
`brake`	Hogyan fog megállni a robot: `BRAKE` — Azonnal megáll. `COAST` — Lassan megáll. `HOLD` — Azonnal megáll és megtartja a kerekek helyzetét.

Paraméterek

Leírás

brake

Hogyan fog megállni a robot:

BRAKE — Azonnal megáll.
COAST — Lassan megáll.
HOLD — Azonnal megáll és megtartja a kerekek helyzetét.

Ha ezt a módszert nem használjuk, a robot megálláskor BRAKE beállítást fogja használni.

# 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 beállítja, hogy a robot mennyi ideig próbáljon meg befejezni egy mozgást. Ha a robot nem tudja befejezni ennyi idő alatt, akkor leállítja a próbálkozást, és a kód következő sorára lép. Ez megakadályozza, hogy a robot elakadjon egy mozgásnál.

Usage:
drivetrain.set_timeout(value, units)

Paraméterek	Leírás
`value`	Az az időtartam, ameddig a robot megpróbálhat befejezni egy mozgást. Ez lehet egész szám vagy tizedes tört.
`units`	Opcionális. Az időegység: `SECONDS` (alapértelmezett) vagy `MSEC` (milliszekundum).

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

A haladási irány az az irány, amerre a robot agya néz, fokban mérve. set_heading a robot aktuális haladási irányát egy új haladási értékre módosítja.

Például, ha a robot jobbra fordult, és a haladási irány 0 fokra állítása a jobbra néző pozíciót teszi az új 0 fokossá. Ezután a robot az új irány alapján más pozíciókba fordulhat.

Usage:
drivetrain.set_heading(value)

Paraméterek	Leírás
`value`	A robot számára beállítandó irányérték fokban. Ez egy 0 és 359 közötti egész szám lehet.

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

A forgás a robot elfordulásának mértékét adja meg fokban mérve. A projekt elején a forgási érték 0 fokra van állítva. set_rotation paraméterrel a robot aktuális forgását egy új értékre módosítja.

Például, ha a robot két teljes fordulatot tett jobbra, akkor a forgási értéke 720 fok lesz. Ha a forgást 0 fokra állítja, akkor a forgás 720-ról 0 fokra áll vissza. Ezután a robot az új érték alapján foroghat.

Usage:
drivetrain.set_rotation(value)

Paraméterek	Leírás
`value`	A robothoz beállítandó forgatási érték fokban. Ez egész szám lehet.

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

Getterek #

get_heading #

A haladási irány az az irány, amerre a robot agya néz, fokban mérve. get_heading függvény visszaadja ezt az irányt 0 és 359 fok között.

A robot kezdő iránya 0 fok.

Egy VEX GO agy, amely a következő irányokat mutatja: 0 fok előre, 90 fok jobbra, 180 fok hátra és 270 fok balra.

Usage:
drivetrain.get_heading()

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

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

A forgás a robot elfordulásának mértékét adja meg fokban mérve. A projekt elején a forgás értéke 0 fok. get_rotation függvény visszaadja a robot aktuális forgását.

Jobbra fordulás növeli, balra fordulás pedig csökkenti az elfordulást. Például két teljes jobbra fordulás 720 fokos elfordulást eredményez.

Egy VEX GO Code Base 2.0, amely jobbra és balra forgó nyilakat mutat. A balra mutató nyíl „mínuszt”, a jobbra mutató nyíl pedig „pluszt” mutat.

Usage:
drivetrain.get_rotation()

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

# 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 Visszaadja a robot vezetési sebességét százalékban, -100%-tól 100%-ig.

A pozitív érték azt jelenti, hogy a robot előre halad. A negatív érték azt jelenti, hogy a robot hátramenetben halad.

Usage:
drivetrain.get_velocity()

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

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

A Yaw (elfordulás azt jelzi, hogy a robot mennyit fordult balra vagy jobbra a kiindulási helyzetétől, fokban mérve. get_yaw függvény értéke a robot aktuális elfordulási szögének értéke.

Jobbra kanyarodva növeli, balra kanyarodva pedig csökkenti az elfordulási értéket.

Usage:
drivetrain.get_yaw()

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

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

A roll (gurulás) a robot balra vagy jobbra dőlését jelzi fokban mérve. A get_roll get_roll paraméterek visszaadják a robot aktuális gurulási értékét.

Ha az Agy előre néz, a balra döntés növeli, a jobbra döntés pedig csökkenti a dobás értékét.

Usage:
drivetrain.get_roll()

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

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

A dőlésszög (pitch) a robot előre vagy hátra dőlését jelzi fokban mérve. A get_pitch visszaadja a robot aktuális dőlésszögét.

Ha az agy előre néz, az előrebillenés növeli, a hátrabillenés pedig csökkenti a hangmagasság értékét.

Usage:
drivetrain.get_pitch()

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

# 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 Logikai értékként adja vissza, hogy a robot észlelt-e összeomlást.

True — Összeomlást észleltek.
False — Nem észlelhető összeomlás.

Usage:
drivetrain.get_crashed()

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

# 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 Logikai értékként adja vissza, hogy a robot befejezte-e a mozgást. Ez felhasználható más viselkedések időzítésének szabályozására a robot mozgása alapján.

True — A robot mozgása befejeződött.
False — A robot még mindig mozog.

Ez a metódus a következő wait paraméterrel rendelkező hajtáslánc-metódusokkal működik együtt: drive_for, drive_until, turn_for, turn_to_heading, és turn_to_rotation.

Usage:
drivetrain.is_stopped()

Paraméterek	Leírás
	Ennek a metódusnak nincsenek paraméterei.

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