Hajtáslánc#

Bevezetés #

A VEX IQ (2. generációs) robot hajtásláncot használ a vezetéshez és a forduláshoz. A hajtáslánc motorokból és kerekekből áll, amelyek együttesen mozgatják a robotot.

Egy konfigurált hajtáslánc használhat csatlakoztatott Gyro Sensor, az agy beépített Inertial Sensor érzékelőjét, vagy egyáltalán nem használhat érzékelőt. Amikor érzékelőt használ, a hajtáslánc azt használja a robot pontos mozgásának és fordulásának elősegítésére. Minden projekt elején a hajtáslánc automatikusan kalibrálja az é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.

Ez az oldal drivetrain értéket használja példaként a hajtáslánc nevére. Szükség szerint cserélje le a saját konfigurált névre.

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.
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.
calibrate_drivetrain — Kalibrálja a hajtáslánccal konfigurált érzékelő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 mennyi idő alatt próbálja meg a robot 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.
set_turn_threshold — Megadja, hogy a robotnak milyen közel kell kerülnie a célszöghöz, mielőtt a fordulás befejeződne.
set_turn_constant — Megváltoztatja, hogy a robot milyen erősen korrigálja a fordulatait.

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

heading — Visszaadja a robot aktuális irányát 0 és 359 fok között.
rotation — Visszaadja a robot aktuális forgását.
velocity — Visszaadja a robot sebességét.
current — Visszaadja, hogy mennyi elektromos áramot használ a hajtáslánc.
is_moving — Logikai értékként adja vissza, hogy a robot mozog-e.
is_done — Logikai értékként adja vissza, hogy a robot befejezte-e a mozgást.
is_turning — Logikai értékként adja vissza, hogy a robot forog-e.
power — Visszaadja, hogy a hajtáslánc milyen gyorsan használja fel az energiát.
torque — Visszaadja, hogy mennyi nyomatékot használ a hajtáslánc.
efficiency — Visszaadja, hogy a hajtáslánc milyen hatékonyan használja fel az energiát.
temperature — Visszaadja a hajtáslánc melegedését.

Konstruktorok – A hajtáslánc manuális létrehozása és konfigurálása.

DriveTrain — Giroszkóp vagy inerciális érzékelő nélküli hajtásláncot hoz létre.
SmartDrive — Giroszkóppal vagy inerciális érzékelővel rendelkező hajtásláncot hoz létre.

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

Paraméterek	Leírás
`direction`	A robot mozgásiránya: `FORWARD` vagy `REVERSE`.
`velocity`	Opcionális. A robot által vezérelt sebesség 0%-tól 100%-ig `PERCENT`használata esetén, 0-tól 120 rpm-ig `RPM`használata esetén, vagy 0-tól 720 fok/másodpercig `VelocityUnits.DPS`használata esetén. Ez lehet egy `integer` vagy decimális szám (`float`). Ha nincs megadva sebesség, a robot az aktuális sebességgel halad.
`units`	Opcionális. A sebesség mértékegysége: `PERCENT` (alapértelmezett), `RPM` (fordulat/perc) vagy `VelocityUnits.DPS` (fok/másodperc).

# 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 paraméterrel a robot előre vagy hátra mozgatható egy adott távolságra. A projekt megvárja, amíg a robot befejezi a mozgást, mielőtt a következő kódsort futtatná.

Usage:
drivetrain.drive_for(direction, distance, units, velocity, units_v, 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 `integer` vagy decimális (`float`).
`units`	Opcionális. A távolság mértékegysége: `INCHES` (alapértelmezett), `MM` (milliméter) vagy `DistanceUnits.CM` (centiméter).
`velocity`	Opcionális. A robot által vezérelt sebesség 0%-tól 100%-ig `PERCENT`használata esetén, 0-tól 120 rpm-ig `RPM`használata esetén, vagy 0-tól 720 fok/másodpercig `VelocityUnits.DPS`használata esetén. Ez lehet egy `integer` vagy decimális szám (`float`). Ha nincs megadva sebesség, a robot az aktuális sebességgel halad.
`units_v`	Opcionális. A sebesség mértékegysége: `RPM` (percenkénti fordulatszám, alapértelmezett), `PERCENT`vagy `VelocityUnits.DPS` (fok másodpercenként).
`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.

# 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 : 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 vezetést vagy megállást.

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

Paraméterek	Leírás
`direction`	A robot fordulási iránya: `LEFT` vagy `RIGHT`.
`velocity`	Opcionális. A fordulási sebesség 0%-tól 100%-ig `PERCENT`használata esetén, 0-tól 120 rpm-ig `RPM`használata esetén, vagy 0-tól 720 fok/másodpercig `VelocityUnits.DPS`használata esetén. Ez lehet egy `integer` vagy decimális szám (`float`). Ha nincs megadva sebesség, a robot az aktuális fordulási sebességgel forog.
`units`	Opcionális. A sebesség mértékegysége: `RPM` (percenkénti fordulatszám, alapértelmezett), `PERCENT`vagy `VelocityUnits.DPS` (fok másodpercenként).

# 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 A „turn_for” paraméterrel a robot balra vagy jobbra forgatható egy megadott számú fokban vagy fordulattal. A fordulat a robot aktuális pozíciójához viszonyítva értendő. A projekt megvárja, amíg a robot befejezi a fordulást, mielőtt a következő kódsort futtatná.

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

Paraméterek	Leírás
`direction`	A robot fordulási iránya: `LEFT` vagy `RIGHT`.
`angle`	A robot fordulatszáma. Ez lehet `integer` vagy decimális (`float`).
`units`	Opcionális. A fordulás mértékegysége: `DEGREES` (alapértelmezett) vagy `TURNS`Egy fordulat 360 foknak felel meg.
`velocity`	Opcionális. A fordulási sebesség 0%-tól 100%-ig `PERCENT`használata esetén, 0-tól 120 rpm-ig `RPM`használata esetén, vagy 0-tól 720 fok/másodpercig `VelocityUnits.DPS`használata esetén. Ez lehet egy `integer` vagy decimális szám (`float`). Ha nincs megadva sebesség, a robot az aktuális fordulási sebességgel forog.
`units_v`	Opcionális. A sebesség mértékegysége: `RPM` (percenkénti fordulatszám, alapértelmezett), `PERCENT`vagy `VelocityUnits.DPS` (fok másodpercenként).
`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.

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

A haladási irány az az irány, amerre a robot néz, fokban mérve. turn_to_heading A „turn_to_heading” (fordulás) beállításnál 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 robot kezdő iránya 0 fok.

A projekt megvárja, amíg a robot befejezi a forgást, mielőtt a következő kódsort futtatná.

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

Paraméterek	Leírás
`angle`	Az irány, amerre a robotnak néznie kell, fokban. Ez lehet egy `integer` vagy decimális szám (`float`) -359 és 359 között.
`units`	Opcionális. Az irány mértékegysége: `DEGREES` (alapértelmezett).
`velocity`	Opcionális. A fordulási sebesség 0%-tól 100%-ig `PERCENT`használata esetén, 0-tól 120 rpm-ig `RPM`használata esetén, vagy 0-tól 720 fok/másodpercig `VelocityUnits.DPS`használata esetén. Ez lehet egy `integer` vagy decimális szám (`float`). Ha nincs megadva sebesség, a robot az aktuális fordulási sebességgel forog.
`units_v`	Opcionális. A sebesség mértékegysége: `PERCENT` (alapértelmezett), `RPM` (fordulat/perc) vagy `VelocityUnits.DPS` (fok/másodperc).
`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.

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

A forgatás a robot elfordulásának mértékét adja meg fokban vagy fordulatokban mérve. A projekt elején a forgatás értéke 0 fok. A forgatás a set_rotation metódussal 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.

A projekt megvárja, amíg a robot befejezi a forgást, mielőtt a következő kódsort futtatná.

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

Paraméterek	Leírás
`angle`	A robot elfordulásának értéke fokban vagy fordulatokban. Ez lehet `integer` vagy decimális (`float`).
`units`	Opcionális. Az elforgatás mértékegysége: `DEGREES` (alapértelmezett) vagy `TURNS`Egy fordulat 360 foknak felel meg.
`velocity`	Opcionális. A fordulási sebesség 0%-tól 100%-ig `PERCENT`használata esetén, 0-tól 120 rpm-ig `RPM`használata esetén, vagy 0-tól 720 fok/másodpercig `VelocityUnits.DPS`használata esetén. Ez lehet egy `integer` vagy decimális szám (`float`). Ha nincs megadva sebesség, a robot az aktuális fordulási sebességgel forog.
`units_v`	Opcionális. A sebesség mértékegysége: `PERCENT` (alapértelmezett), `RPM` (fordulat/perc) vagy `VelocityUnits.DPS` (fok/másodperc).
`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.

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

Usage:
drivetrain.stop(mode)

Paraméterek	Leírás
`mode`	Opcionális. Hogyan álljon meg a robot: `BRAKE` (alapértelmezett), `BRAKE`vagy `COAST` `COAST` — Azonnal leáll. `HOLD` — Lassan megáll. `HOLD` — Azonnal leáll és megtartja a kerekek helyzetét.

Paraméterek

Leírás

mode

Opcionális. Hogyan álljon meg a robot: BRAKE (alapértelmezett), BRAKEvagy COAST

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

# 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 egy beépített függvény, amely kalibrálja a hajtáslánccal konfigurált giroszkópot vagy inerciális érzékelőt.

A kalibrálás segít az érzékelőnek a mozgás helyes mérésében. Tartsa a robotot mozdulatlanul körülbelül 2 másodpercig a kalibrálás során. Ha a robot elmozdul a kalibrálás során, előfordulhat, hogy az érzékelő nem méri megfelelően a mozgást.

A projekt a kalibráció befejezéséig vár, mielőtt a következő kódsort futtatná.

Megjegyzés: Ez a függvény nem használható VS Code-on belül.

Usage:
calibrate_drivetrain()

Paraméterek	Leírás
	Ennek a függvénynek nincsenek paraméterei.

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 lehet.

Usage:
drivetrain.set_drive_velocity(velocity, units)

Paraméterek	Leírás
`velocity`	A hajtandó sebesség 0%-tól 100%-ig `PERCENT`használata esetén, 0-tól 120 rpm-ig `RPM`használata esetén, vagy 0-tól 720 fok/másodpercig `VelocityUnits.DPS`használata esetén. Ez lehet egy `integer` vagy decimális szám (`float`).
`units`	Opcionális. A sebesség mértékegysége: `PERCENT` (alapértelmezett), `RPM` (fordulat/perc) vagy `VelocityUnits.DPS` (fok/másodperc).

# 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 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 fordulását, de kevésbé pontos lehet. Az alacsonyabb sebesség lassabbá teszi a robot fordulását, de pontosabb lehet.

Usage:
drivetrain.set_turn_velocity(velocity, units)

Paraméterek	Leírás
`velocity`	A fordulatszám 0%-tól 100%-ig `PERCENT`használata esetén, 0-tól 120 rpm-ig `RPM`használata esetén, vagy 0-tól 720 fok/másodpercig `VelocityUnits.DPS`használata esetén. Ez lehet egy `integer` vagy decimális szám (`float`).
`units`	Opcionális. A sebesség mértékegysége: `PERCENT` (alapértelmezett), `RPM` (fordulat/perc) vagy `VelocityUnits.DPS` (fok/másodperc).

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

Usage:
drivetrain.set_stopping(mode)

Paraméterek	Leírás
`mode`	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

mode

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.

set_timeout #

set_timeout beállítja, hogy mennyi idő alatt próbáljon meg a robot befejezni egy mozgást. Ha a robot nem tudja befejezni a megadott időn belül, akkor leállítja a próbálkozást, és továbblép a kód következő sorára. 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 pozitív `integer` vagy decimális (`float`).
`units`	Opcionális. Az időegység: `MSEC` (milliszekundum, alapértelmezett) vagy `SECONDS`.

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

set_heading #

A haladási irány a robot iránya, fokban mérve. set_heading a robot aktuális irányát egy új irányé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(heading, units)

Paraméterek	Leírás
`heading`	A robothoz beállítandó irányérték fokban vagy fordulatokban. Ez lehet `integer` vagy decimális (`float`).
`units`	Opcionális. Az irány mértékegysége: `DEGREES` (alapértelmezett) vagy `TURNS`Egy fordulat 360 foknak felel meg.

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

set_rotation #

A forgás a robot fordulatát adja meg fokban vagy fordulatokban 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(rotation, units)

Paraméterek	Leírás
`rotation`	A robothoz beállítandó forgatási érték fokban vagy fordulatokban. Ez lehet `integer` vagy decimális (`float`).
`units`	Opcionális. Az elforgatás mértékegysége: `DEGREES` (alapértelmezett) vagy `TURNS`Egy fordulat 360 foknak felel meg.

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

set_turn_threshold #

set_turn_threshold beállítja, hogy a robotnak milyen közel kell kerülnie a célszöghöz, mielőtt a fordulás befejeződne.

Egy kisebb küszöbérték pontosabbá teheti a fordulókat, de a robotnak tovább tarthat a fordulás befejezése. Egy nagyobb küszöbérték gyorsabbá teheti a fordulókat, de kevésbé pontosak lehetnek.

Usage:
drivetrain.set_turn_threshold(value)

Paraméterek	Leírás
`value`	A fordulási küszöbérték fokban. Ez lehet `integer` vagy decimális (`float`). Az alapértelmezett fordulási küszöbérték 1 fok.

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

set_turn_constant #

set_turn_constant megváltoztatja, hogy a robot milyen erősen korrigálja a fordulatait.

Magasabb érték esetén a robot erősebben korrigálja a fordulókat. Alacsonyabb érték esetén a robot finomabban korrigálja a fordulókat. Az alapértelmezett érték 1,0.

Usage:
drivetrain.set_turn_constant(value)

Paraméterek	Leírás
`value`	A fordulási állandó. Ez egy decimális érték lehet (`float`) 0,1 és 4,0 között. Az alapértelmezett érték 1,0.

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

Getterek #

heading #

A haladási irány a robot irányát jelöli, fokban mérve. heading a robot aktuális haladási irányát adja vissza 0 és 359 fok között.

A robot kezdő iránya 0 fok.

Usage:
drivetrain.heading(units)

Paraméterek	Leírás
`units`	Opcionális. A mértékegység, amelyben vissza kell adni az irányt: `DEGREES` (alapértelmezett) vagy `TURNS`Egy fordulat 360 foknak felel meg.

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

rotation #

A forgás a robot fordulatát adja meg fokban vagy fordulatokban mérve. A projekt elején a forgási érték 0 fokra van állítva. rotation értékkel adja vissza 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.

Usage:
drivetrain.rotation(units)

Paraméterek	Leírás
`units`	Opcionális. A forgatás visszaadásához használt mértékegység: `DEGREES` (alapértelmezett) vagy `TURNS`Egy fordulat 360 foknak felel meg.

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

velocity #

velocity a robot haladási sebességét adja vissza.

A sebességet százalékban, -100%-tól 100%-ig, RPM -ben -127 rpm-től 127 rpm-ig, vagy VelocityUnits.DPS -ban (fok/másodperc) adhatja meg. 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.velocity(units)

Paraméterek	Leírás
`units`	Opcionális. A sebesség visszaadásához használt mértékegység: `PERCENT` (alapértelmezett), `RPM` (fordulat/perc) vagy `VelocityUnits.DPS` (fok/másodperc).

current #

current visszaadja, hogy mennyi elektromos áramot használ a hajtáslánc, amperben mérve. Az áram az a mennyiség, amely átfolyik a hajtásláncon.

A magasabb áramérték azt jelenti, hogy a hajtáslánc több elektromos áramot használ. Ez akkor fordulhat elő, amikor a robot egy tárgynak nyomódik, vagy elakadt állapotban próbál mozogni.

Ez felhasználható annak ellenőrzésére, hogy a hajtáslánc mozgás közben akadozik-e. Ha az áram magas marad, a hajtáslánc felmelegedhet, vagy kevésbé hatékonyan használhatja fel az energiát.

Usage:
drivetrain.current(units)

Paraméterek	Leírás
`units`	Opcionális. Az áramerősség visszaadásához használt mértékegység: `CurrentUnits.AMP` (amper, alapértelmezett).

is_moving #

is_moving Logikai értékként adja vissza, hogy a robot mozog-e. 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 mozog.
False — A robot nem mozog.

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

Usage:
drivetrain.is_moving()

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

is_done #

is_done 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ő Drivetrain metódusokkal működik együtt: drive_for, turn_for, turn_to_heading, és turn_to_rotation.

Usage:
drivetrain.is_done()

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

is_turning #

is_turning logikai értékként adja vissza, hogy a robot forog-e. 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 forog.
False — A robot nem forog.

Ez a metódus a következő wait paraméterrel rendelkező Drivetrain metódusokkal működik együtt: turn_for, turn_to_heading, és turn_to_rotation.

Usage:
drivetrain.is_turning()

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

power #

power Visszaadja, hogy mennyi energiát fogyaszt a hajtáslánc, wattban mérve. A Power megmutatja, hogy milyen gyorsan használja fel a hajtáslánc az energiát.

A magasabb teljesítményérték azt jelenti, hogy a hajtáslánc gyorsabban használja fel az energiát. Ez akkor fordulhat elő, amikor a robot egy tárgynak nyomódik, vagy elakadt állapotban próbál mozogni.

Ez felhasználható a mozgások összehasonlítására, vagy annak ellenőrzésére, hogy a hajtáslánc akadozik-e. Ha a teljesítmény magas marad, a hajtáslánc felmelegedhet, vagy kevésbé hatékonyan használhatja fel az energiát.

Usage:
drivetrain.power()

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

torque #

A nyomaték megmutatja, hogy a hajtáslánc milyen erősen tud nyomni vagy húzni, miközben a kerekek forognak.

torque visszaadja, hogy mennyi nyomatékot használ a hajtáslánc, newtonméterben (Nm) vagy hüvelyk-fontban (InLb) mérve.

A magasabb nyomatékérték azt jelenti, hogy a hajtáslánc erősebben nyom vagy húz. Ez akkor fordulhat elő, amikor a robot egy tárgynak nyomódik, vagy elakadt állapotban próbál mozdulni.

Ez felhasználható annak ellenőrzésére, hogy a hajtáslánc akadozik-e, vagy annak összehasonlítására, hogy mennyi lökést igényelnek a különböző mozgások.

Usage:
drivetrain.torque(units)

Paraméterek	Leírás
`units`	Opcionális. A nyomaték mértékegysége: `TorqueUnits.NM` (newtonméter, alapértelmezett) vagy `TorqueUnits.INLB` (hüvelyk-font).

efficiency #

efficiency Visszaadja, hogy a hajtáslánc mennyire hatékonyan használja fel az energiát, 0% és 100% közötti százalékban.

A hatékonyság megmutatja, hogy a hajtáslánc teljesítményének mekkora részét használja fel a mozgás. A magasabb hatékonysági érték azt jelenti, hogy a hajtáslánc teljesítményének nagyobb részét használja fel a mozgás. Alacsonyabb hatékonysági érték akkor fordulhat elő, ha a hajtáslánc keményen dolgozik, de nem mozog sokat, például amikor a robot elakadt vagy egy tárgynak nyomódik.

Ez felhasználható a mozgások összehasonlítására, vagy annak ellenőrzésére, hogy a hajtáslánc pazarolja-e az energiát a mozgás helyett.

Usage:
drivetrain.efficiency()

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

temperature #

temperature A hajtáslánc átlagos hőmérsékletét adja vissza a kiválasztott hőmérsékleti egységben.

A hőmérséklet megmutatja, mennyire melegek a hajtáslánc motorjai. A magasabb hőmérséklet azt jelenti, hogy a motorok működés közben melegednek. A motoroknak 55°C alatt kell maradniuk ahhoz, hogy teljes teljesítményen működjenek.

Ha a motorok túlmelegszenek, csökkentik a maximális áramerősséget önmaguk védelme érdekében. 70°C-on a motorok leállnak, amíg le nem hűlnek.

Ez felhasználható annak ellenőrzésére, hogy a hajtáslánc túlmelegszik-e ismételt mozgások, hosszú futások vagy tárgynak való nyomás során.

Usage:
drivetrain.temperature(units)

Paraméterek	Leírás
`units`	Opcionális. A hőmérséklet visszaadásához használt mértékegység: `TemperatureUnits.CELSIUS` (alapértelmezett) vagy `TemperatureUnits.FAHRENHEIT`.

Konstruktorok #

A konstruktorok segítségével DriveTrain és SmartDrive objektumokat hozhatunk létre a kódban. Ez akkor hasznos, ha a hajtásláncot az Eszközök ablak használata nélkül konfiguráljuk.

Hajtáslánc létrehozása előtt legalább két Motor vagy MotorGroup objektumot kell létrehozni.

DriveTrain #

DriveTrain egy Gyro Sensor vagy Inertial Sensor nélküli hajtásláncot hoz létre.

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

Paraméter	Leírás
`lm`	A bal oldali motor vagy motorcsoport.
`rm`	A jobb oldali motor vagy motorcsoport.
`wheelTravel`	Opcionális. A hajtáslánc kerekeinek kerülete. Az alapértelmezett érték 300 milliméter.
`trackWidth`	Opcionális. A bal és jobb oldali kerekek közötti távolság. Az alapértelmezett érték 320 milliméter.
`wheelBase`	Opcionális. Az első és hátsó kerekek közötti távolság. Az alapértelmezett érték 320 milliméter.
`units`	Opcionális. A `wheelTravel`, `trackWidth`és `wheelBase`mértékegysége: `MM` (milliméter, alapértelmezett), `INCHES`vagy `DistanceUnits.CM` (centiméter).
`externalGearRatio`	Opcionális. A sebességváltó áttétele, amely a meghajtási távolságok beállításához szolgál, ha sebességfokozatok vannak használatban. Ez lehet `integer` vagy decimális érték (`float`). Az alapértelmezett érték 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 egy giroszkóp vagy inerciális érzékelő segítségével hoz létre egy hajtásláncot.

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

Paraméter	Leírás
`lm`	A bal oldali motor vagy motorcsoport.
`rm`	A jobb oldali motor vagy motorcsoport.
`g`	A hajtáslánc által használt Giroszkóp vagy Inerciális Szenzor.
`wheelTravel`	Opcionális. A hajtáslánc kerekeinek kerülete. Az alapértelmezett érték 300 milliméter.
`trackWidth`	Opcionális. A bal és jobb oldali kerekek közötti távolság. Az alapértelmezett érték 320 milliméter.
`wheelBase`	Opcionális. Az első és hátsó kerekek közötti távolság. Az alapértelmezett érték 320 milliméter.
`units`	Opcionális. A `wheelTravel`, `trackWidth`és `wheelBase`mértékegysége: `MM` (milliméter, alapértelmezett), `INCHES`vagy `DistanceUnits.CM` (centiméter).
`externalGearRatio`	Opcionális. A sebességváltó áttétele, amely a meghajtási távolságok beállításához szolgál, ha sebességfokozatok vannak használatban. Ez lehet `integer` vagy decimális érték (`float`). Az alapértelmezett érték 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)

Ha több motorral rendelkező intelligens hajtásláncot készít, akkor a motorokat külön kell létrehozni, mielőtt egy motorcsoportba rendezné őket.

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