Hajtáslánc#

Bevezetés#

A drivetrain osztály szabályozza, hogyan halad és fordul egy robot. A hajtáslánc motorokból és kerekekből áll, amelyek együttesen mozgatják a robotot.

Egy drivetrain nem használ inerciális érzékelőt vagy giroszkópot az irány- vagy forgásalapú fordulókhoz. Előre vagy hátra tud haladni, valamint balra vagy jobbra fordulni, de nem tud egy adott irányba vagy forgásirányba fordulni. Irány- és forgásalapú fordulókhoz a smartdrive osztályt kell használni.

Származtatott osztályok#

A drivetrain osztály alaposztályként szolgál a következő származtatott osztályokhoz:

smartdrive - Ez az osztály inerciális érzékelő vagy giroszkóp támogatást ad hozzá az irány- és forgásalapú fordulók engedélyezéséhez.

Osztálykonstruktorok#

1 - Létrehoz egy hajtásláncot a meglévő motor_group objektumok felhasználásával a bal (&l) és jobb (&r) oldalakhoz.
drivetrain(
    motor_group      &l,
    motor_group      &r,
    double           wheelTravel = 320,
    double           trackWidth = 320,
    double           wheelBase = 130,
    distanceUnits    unit = mm,
    double           externalGearRatio = 1.0 );

2 - Létrehoz egy hajtásláncot a meglévő motor objektumok felhasználásával a bal (&l) és jobb (&r) oldalakhoz.
drivetrain(
    motor            &l,
    motor            &r,
    double           wheelTravel = 320,
    double           trackWidth = 320,
    double           wheelBase = 130,
    distanceUnits    unit = mm,
    double           externalGearRatio = 1.0 );

Osztálydestruktor#

Megsemmisíti a drivetrain objektumot és felszabadítja a hozzá tartozó erőforrásokat.

virtual ~drivetrain();

Paraméterek#

Paraméter	Típus	Leírás
`&l` / `&r`	`motor_group` / `motor`	A bal és jobb oldali motorok vagy motorcsoportok. Mindkét paraméternek azonos típust kell használnia: vagy két `motor_group` objektum, vagy két `motor` objektum.
`wheelTravel`	`double`	A hajtáslánc kerekeinek kerülete. Az alapértelmezett érték `320`.
`trackWidth`	`double`	A bal és jobb kerék közötti távolság. Az alapértelmezett érték `320`.
`wheelBase`	`double`	Az első és hátsó kerekek közötti távolság. Az alapértelmezett érték `130`.
`unit`	`distanceUnits`	A `wheelTravel`, `trackWidth`és `wheelBase`mértékegysége: `mm` (milliméter, alapértelmezett) vagy `inches`.
`externalGearRatio`	`double`	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. Az alapértelmezett érték `1.0`.

Példa#

// Create the left and right motor objects
motor leftMotor = motor(PORT1, false);
motor rightMotor = motor(PORT9, true);

// Create the drivetrain object
drivetrain myDrivetrain = drivetrain(
    leftMotor,  // left motor object
    rightMotor, // right motor object
    259.34,     // wheelTravel
    320,        // trackWidth
    40,         // wheelBase
    mm,         // unit
    1.0 );      // externalGearRatio

Tagfüggvények#

A hajtáslánc kódolásának számos módja van. Az alábbiakban felsoroljuk az összes drivetrain tagfüggvényt:

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

drive - A robotot előre vagy hátra mozgatja örökké.
driveFor - Megadott távolságra előre vagy hátra mozgatja a robotot.
turn - Örökké balra vagy jobbra forgatja a robotot.
turnFor - Meghatározott fokkal balra vagy jobbra forgatja a robotot.
stop - Leállítja a robot mozgását.

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

setDriveVelocity - Megadja a robotnak, hogy milyen gyorsan haladjon.
setTurnVelocity - Megadja a robotnak, hogy milyen gyorsan forduljon.
setStopping - Megadja, hogyan fog a robot leállni: fékezéssel, gurulással vagy tartással.
setTimeout - Beállítja, hogy a robot hány másodpercig próbálja meg befejezni a mozgást.

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

isDone - Logikai értékként adja vissza, hogy a robot befejezte-e a mozgást.
isMoving - Logikai értékként adja vissza, hogy a robot mozog-e.
velocity – Visszaadja a robot sebességét.
current – Visszaadja, hogy mennyi elektromos áramot használ a hajtáslánc.
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 mennyire hatékonyan használja fel az energiát.
temperature – Visszaadja a hajtáslánc melegedését.
voltage – Visszaadja a hajtásláncnak szolgáltatott elektromos feszültséget.

Bármely drivetrain tagfüggvény meghívása előtt létre kell hozni egy drivetrain objektumot, az alábbiak szerint:

/* This constructor is required when using VS Code.
Drivetrain configuration is generated automatically
in VEXcode using the Device Menu. Replace the values
as needed. */

// Create the left and right motor objects
motor leftMotor = motor(PORT1, false);
motor rightMotor = motor(PORT9, true);

// Create the drivetrain object
drivetrain myDrivetrain = drivetrain(
    leftMotor,  // left motor object
    rightMotor, // right motor object
    259.34,     // wheelTravel
    320,        // trackWidth
    40,         // wheelBase
    mm,         // unit
    1.0 );      // externalGearRatio

Műveletek#

hajtás#

drive örökre előre vagy hátra mozgatja a robotot. A robot addig mozog, amíg egy másik műveletet nem kap, például fordulást vagy megállást. RPM vagy DPS esetén a határértéket a hajtáslánc áttétele változtatja.

Available Functions

1 - A meghajtók a jelenleg konfigurált meghajtósebesség értékkel működnek.
void drive(
    directionType dir );

2 - A megadott sebességgel halad.

void drive(
    directionType dir,
    double        velocity,
    velocityUnits units );

Parameters

Paraméter	Típus	Leírás
`dir`	`directionType`	A robot mozgásiránya: `forward` vagy `reverse`.
`velocity`	`double`	A haladási sebesség 0%-tól 100%-ig `velocityUnits::pct`használata esetén, 0-tól 600 rpm-ig `rpm`használata esetén, vagy 0-tól 3600 fok/másodpercig `dps`használata esetén. Ha nincs megadva sebesség, a robot az aktuális haladási sebességgel halad.
`units`	`velocityUnits`	A sebesség mértékegysége: `velocityUnits::pct` (százalék), `rpm` (fordulat/perc) vagy `dps` (fok/másodperc).

Return Values

Ez a függvény nem ad vissza értéket.

Notes

drive meghajtó nem várakozó állapotban van; a projekt a hívás után azonnal folytatja a következő kódsor végrehajtását.
A hajtáslánc addig mozog, amíg a stop függvényt meg nem hívják, vagy egy másik hajtáslánc-mozgási függvényt (például a driveFor vagy a turn) végre nem hajtanak.
Az olyan függvények, mint a isDone és a isMoving nem alkalmazhatók driveesetében, mivel az nem használ cél alapú mozgást (nincs distance paramétere).

Examples

// Drive forward and back
myDrivetrain.drive(forward);
wait(2, seconds);
myDrivetrain.drive(reverse, 25, rpm);
wait(2, seconds);
myDrivetrain.stop();

driveFor#

driveFor A driveFor 1 paraméterrel a robot előre vagy hátra mozgatható egy adott távolságra. A projekt alapértelmezés szerint megvárja, amíg a robot befejezi a mozgást, mielőtt a következő kódsor lefutna. RPM vagy DPS esetén a határértéket a hajtáslánc áttétele változtatja.

Available Functions

1 - A megadott irányban egy adott távolságon keresztül halad a jelenleg beállított meneti sebességgel.
bool driveFor(
    directionType dir,
    double        distance,
    distanceUnits units,
    bool          waitForCompletion = true );

2 - A távolságtól függő irányban halad a jelenleg konfigurált haladási sebesség értékkel.
bool driveFor(
    double        distance,
    distanceUnits units,
    bool          waitForCompletion = true );

3 - A megadott sebességgel a távolságtól függő irányban halad.

bool driveFor(
    double        distance,
    distanceUnits units,
    double        velocity,
    velocityUnits units_v,
    bool          waitForCompletion = true );

4 - A megadott irányban, a megadott sebességgel, egy adott távolságon keresztül halad.
bool driveFor(
    directionType dir,
    double        distance,
    distanceUnits units,
    double        velocity,
    velocityUnits units_v,
    bool          waitForCompletion = true );

Parameters

Paraméter	Típus	Leírás
`dir`	`directionType`	A robot mozgásiránya: `forward` vagy `reverse`.
`distance`	`double`	A robot által megtett távolság.
`units`	`distanceUnits`	A távolság mértékegysége: `mm` (milliméter), `inches`vagy `cm` (centiméter).
`velocity`	`double`	A haladási sebesség 0%-tól 100%-ig `velocityUnits::pct`használata esetén, 0-tól 600 rpm-ig `rpm`használata esetén, vagy 0-tól 3600 fok/másodpercig `dps`használata esetén. Ha nincs megadva sebesség, a robot az aktuális haladási sebességgel halad.
`units_v`	`velocityUnits`	A sebesség mértékegysége: `velocityUnits::pct` (százalék), `rpm` (fordulat/perc) vagy `dps` (fok/másodperc).
`waitForCompletion`	`bool`	`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. `false` esetén a következő kódsor azonnal lefut.

Return Values

Logikai értékként adja vissza, hogy a robot elérte-e a céltávolságot.

true - A robot elérte a céltávolságot.
false - A robot nem fejezte be a mozgást, vagy a függvény a mozgás befejezése előtt adott vissza értéket, mert waitForCompletion értéke false volt.

Notes

Egy másik hajtáslánc-mozgási függvény végrehajtása (például a drive vagy a turnFor) driveFor folyamatban lévő művelet közben megszakítja az aktuális mozgást.
Mivel driveFor cél alapú ( distance paramétert használ), az olyan függvények, mint a isDone és a isMoving a driveFor paraméterrel működnek.

Examples

// Drive 200 mm, then back 200 mm
myDrivetrain.driveFor(forward, 200, mm);
myDrivetrain.driveFor(reverse, 200, mm);

fordulat#

turn A robotot örökre balra vagy jobbra forgatja. A robot addig forog, amíg egy másik műveletet nem kap, például vezetést vagy megállást. RPM vagy DPS esetén a határértéket a hajtáslánc áttétele változtatja.

Available Functions

1 - A jelenleg konfigurált fordulási sebességgel végzett fordulatok.
void turn(
    turnType dir );

2 - A megadott sebességgel fordul.

void turn(
    turnType     dir,
    double       velocity,
    velocityUnits units );

Parameters

Paraméter	Típus	Leírás
`dir`	`turnType`	A robot fordulási iránya: `left` vagy `right`.
`velocity`	`double`	A fordulási sebesség 0%-tól 100%-ig `velocityUnits::pct`használata esetén, 0-tól 600 rpm-ig `rpm`használata esetén, vagy 0-tól 3600 fok/másodpercig `dps`használata esetén. Ha nincs megadva sebesség, a robot az aktuális fordulási sebességgel forog.
`units`	`velocityUnits`	A sebesség mértékegysége: `velocityUnits::pct` (százalék), `rpm` (fordulat/perc) vagy `dps` (fok/másodperc).

Return Values This function does not return a value. Notes

turn kör nem várakozó; a projekt a hívás után azonnal folytatja a következő kódsor végrehajtását.
A hajtáslánc addig forog, amíg a stop függvényt meg nem hívják, vagy egy másik hajtáslánc-mozgási függvényt (például a turnFor vagy a drive) végre nem hajtanak.
Az olyan függvények, mint a isDone és a isMoving nem alkalmazhatók turnmetódusra, mivel az nem használ célpont-alapú mozgást (nincs angle paramétere).

Examples

// Turn right, then left, then stop
myDrivetrain.turn(right);
wait(2, seconds);
myDrivetrain.turn(left);
wait(2, seconds);
myDrivetrain.stop();

forduljFor#

turnFor A 0 fordulatszám-paraméter a robotot egy adott számú fokkal balra vagy jobbra forgatja. A fordulat a robot aktuális pozíciójához viszonyítva értendő. A projekt alapértelmezés szerint megvárja, amíg a robot befejezi a fordulást, mielőtt a következő kódsor lefutna. RPM vagy DPS esetén a határértéket a hajtáslánc áttétele módosítja.

Available Functions

1 - A megadott szögben fordul a jelenleg konfigurált fordulási sebesség használatával.
bool turnFor(
    double        angle,
    rotationUnits units,
    bool          waitForCompletion = true );

2 - A megadott irányba fordul egy szöggel a jelenleg konfigurált fordulási sebesség használatával.
bool turnFor(
    turnType      dir,
    double        angle,
    rotationUnits units,
    bool          waitForCompletion = true );

3 - A megadott szöggel és a megadott sebességgel fordul.

bool turnFor(
    double        angle,
    rotationUnits units,
    double        velocity,
    velocityUnits units_v,
    bool          waitForCompletion = true );

4 - A megadott irányban, a megadott sebességgel és egy szöggel elfordul.

bool turnFor(
    turnType      dir,
    double        angle,
    rotationUnits units,
    double        velocity,
    velocityUnits units_v,
    bool          waitForCompletion = true );

Parameters

Paraméter	Típus	Leírás
`dir`	`turnType`	A robot fordulási iránya: `left` vagy `right`.
`angle`	`double`	A robot fordulási szöge.
`units`	`rotationUnits`	A fordulat mértékegysége: `deg` (fok), `rev` (fordulat) vagy `raw` (nyers egység). Egy fordulat 360 foknak felel meg.
`velocity`	`double`	A fordulási sebesség 0%-tól 100%-ig `velocityUnits::pct`használata esetén, 0-tól 600 rpm-ig `rpm`használata esetén, vagy 0-tól 3600 fok/másodpercig `dps`használata esetén. Ha nincs megadva sebesség, a robot az aktuális fordulási sebességgel forog.
`units_v`	`velocityUnits`	A sebesség mértékegysége: `velocityUnits::pct` (százalék), `rpm` (fordulat/perc) vagy `dps` (fok/másodperc).
`waitForCompletion`	`bool`	`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. `false` esetén a következő kódsor azonnal lefut.

Return Values

Logikai értékként adja vissza, hogy a robot elérte-e a célszöget.

true - A robot elérte a célszöget.
false - A robot nem fejezte be a fordulót, vagy a függvény a forduló befejezése előtt adott vissza értéket, mert waitForCompletion értéke false volt.

Notes

Egy másik hajtáslánc-mozgási függvény végrehajtása (például a turn vagy a drive) turnFor folyamatban lévő művelet közben megszakítja az aktuális mozgást.
Mivel turnFor cél alapú ( angle paramétert használ), az olyan függvények, mint a isDone és a isMoving , turnFor paraméterrel működnek.

Examples

// Turn right then left
myDrivetrain.turnFor(right, 90, degrees);
wait(1, seconds);
myDrivetrain.turnFor(left, 90, degrees);

Stop#

stop leállítja a robot mozgását. Ha meg van adva egy leállítási mód, akkor az vezérli, hogyan álljon meg a robot ennél a függvényhívásnál.

Available Functions

1 - Leállítja a hajtásláncot a jelenleg konfigurált leállítási mód használatával.
void stop();

2 - Leállítja a hajtásláncot a megadott fékezési móddal.
void stop(
    brakeType mode );

Parameters

Paraméter	Típus	Leírás
`mode`	`brakeType`	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éter

Típus

Leírás

mode

brakeType

Hogyan fog megállni a robot:

brake - Azonnal megáll.
coast - Lassan megáll.
hold - Azonnal megáll és megtartja a kerekek helyzetét.

Return Values

Ez a függvény nem ad vissza értéket.

Examples

// Drive forward, then coast to a stop
myDrivetrain.setDriveVelocity(100, percent);
myDrivetrain.drive(forward);
wait(2, seconds);
myDrivetrain.stop(coast);

Mutátorok#

setDriveVolicity#

setDriveVelocity megmondja a robotnak, hogy milyen gyorsan haladjon. Magasabb százalékérték esetén a robot gyorsabban, alacsonyabb százalékérték esetén pedig lassabban halad. Az RPM vagy a DPS esetében a határértéket a hajtáslánc áttétele változtatja.

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.

Available Functions

void  setDriveVelocity(
  double velocity,
  velocityUnits units );

Parameters

Paraméter	Típus	Leírás
`velocity`	`double`	A hajtandó sebesség 0%-tól 100%-ig `velocityUnits::pct`használata esetén, 0-tól 600 rpm-ig `rpm`használata esetén, vagy 0-tól 3600 fok/másodpercig `dps` használata esetén.
`units`	`velocityUnits`	A sebesség mértékegysége: `velocityUnits::pct` (százalék), `rpm` (fordulat/perc) vagy `dps` (fok/másodperc).

Return Values

Ez a függvény nem ad vissza értéket.

Notes

A hajtási sebesség az összes további hajtáslánc-mozgási függvényre vonatkozik (például a drive és a driveFor függvényekre), kivéve, ha a függvényhívásban egy adott sebesség van megadva.

Examples

// Drive forward, then coast to a stop
myDrivetrain.setDriveVelocity(100, percent);
myDrivetrain.drive(forward);
wait(2, seconds);
myDrivetrain.stop(coast);

FordulásiSebesség beállítása#

setTurnVelocity 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. RPM vagy DPS esetén a határértéket a hajtáslánc áttétele változtatja.

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.

Available Functions

void  setTurnVelocity(
  double velocity,
  velocityUnits units );

Parameters

Paraméter	Típus	Leírás
`velocity`	`double`	A fordulatszám 0%-tól 100%-ig `velocityUnits::pct`használata esetén, 0-tól 600 rpm-ig `rpm`használata esetén, vagy 0-tól 3600 fok/másodpercig `dps` használata esetén.
`units`	`velocityUnits`	A sebesség mértékegysége: `percent` vagy `pct` (százalék), `rpm` (fordulat/perc), vagy `dps` (fok/másodperc).

Return Values

Ez a függvény nem ad vissza értéket.

Notes

A fordulási sebesség az összes további hajtáslánc-fordulási függvényre vonatkozik (például a turn és a turnFor függvényekre), kivéve, ha a függvényhívásban megadunk egy adott sebességet.

Examples

// Try default, slow, then fast
myDrivetrain.turnFor(right, 360, degrees);
wait(1, seconds);
myDrivetrain.setTurnVelocity(20, percent);
myDrivetrain.turnFor(right, 360, degrees);
wait(1, seconds);
myDrivetrain.setTurnVelocity(100, percent);
myDrivetrain.turnFor(right, 360, degrees);

setStopping#

setStopping beállítja, hogyan álljon meg a robot: fékezéssel, gurulással vagy tartással.

Available Functions

void setStopping(
  brakeType mode );

Parameters

Paraméter	Típus	Leírás
`mode`	`brakeType`	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éter

Típus

Leírás

mode

brakeType

Hogyan fog megállni a robot:

brake - Azonnal megáll.
coast - Lassan megáll.
hold - Azonnal megáll és megtartja a kerekek helyzetét.

Return Values

Ez a függvény nem ad vissza értéket.

Notes

A leállítási mód az összes további stop hívásra vonatkozik, kivéve, ha a függvényhívásban megadunk egy adott leállítási módot.

időtúllépés beállítása#

setTimeout beállítja, hogy a robot hány másodpercig 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 továbblép a kód következő sorára. Ez megakadályozza, hogy a robot elakadjon egy mozgásnál.

Available Functions

void  setTimeout(
  int32_t time,
  timeUnits units );

Parameters

Paraméter	Típus	Leírás
`time`	`int32_t`	Az az időtartam, ameddig a robot megpróbálhat befejezni egy mozgást. Ennek pozitív egész számnak kell lennie.
`units`	`timeUnits`	Az idő mértékegysége: `sec` (másodperc) vagy `msec` (milliszekundum).

Return Values

Ez a függvény nem ad vissza értéket.

Notes

Az időtúllépés csak a célalapú hajtáslánc-mozgási függvényekre vonatkozik (például a driveFor és a turnFor).

Examples

// Start turning if driving takes too long
myDrivetrain.setTimeout(1, seconds);
myDrivetrain.driveFor(forward, 25, inches);
myDrivetrain.turnFor(right, 90, degrees);

Getterek#

Kész#

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

Available Functions

bool isDone( void );

Parameters

Ez a függvény nem fogad el paramétereket.

Return Values

true - A robot mozgása befejeződött.
false - A robot még mindig mozog.

Notes

isDone kompatibilis a célpont-alapú hajtáslánc-mozgásokkal (olyan függvények, amelyek egy célpont felé mozognak, mint például a driveFor és turnFor).
isDone nem kompatibilis olyan függvényekkel, mint a drive és az turn, mivel ezek nem használnak célpont alapú mozgást.

Mozgásban van#

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

Available Functions

virtual bool isMoving( void );

Parameters

Ez a függvény nem fogad el paramétereket.

Return Values

true - A robot mozog.
false - A robot nem mozog.

Notes

isMoving kompatibilis a célpont-alapú hajtáslánc-mozgásokkal (olyan függvények, amelyek egy célpont felé mozognak, mint például a driveFor és turnFor).
isMoving nem kompatibilis olyan függvényekkel, mint a drive és turn, mivel ezek nem használnak célpont alapú mozgást.

sebesség#

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

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.

Available Functions

double velocity(
  velocityUnits units );

Parameters

Paraméter	Típus	Leírás
`units`	`velocityUnits`	A sebesség mértékegysége: `percent` vagy `pct` (százalék), `rpm` (fordulat/perc), vagy `dps` (fok/másodperc).

Return Values

A hajtáslánc sebességét adja vissza double formátumban a kiválasztott egységben.

Examples

// Show velocity before and during motion
Brain.Screen.print("Resting: %f", myDrivetrain.velocity(percent));
myDrivetrain.drive(forward, 100, velocityUnits::pct);
wait(1, seconds);
Brain.Screen.newLine();
Brain.Screen.print("Moving: %f", myDrivetrain.velocity(percent));
myDrivetrain.stop();

jelenlegi#

current visszaadja, hogy mennyi elektromos áramot használ a hajtáslánc. Az áram az a villamos energia mennyisége, amely átfolyik a hajtásláncon. Amperben (amper) vagy százalékban adható vissza, a mértékegységtől függően.

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.

Available Functions

1 - Visszaadja a hajtáslánc elektromos áramát amperben.
double current(
    currentUnits units = currentUnits::amp );

2 - Visszaadja a hajtáslánc elektromos áramát a maximum százalékában.
double current(
    percentUnits units );

Parameters

Paraméter	Típus	Leírás
`units`	`currentUnits`	Az áramerősség visszaadásához szükséges mértékegység: `amp` (amper, alapértelmezett).
`units`	`percentUnits`	Az áram visszaadásához szükséges mértékegység: `percent` vagy `pct`.

Return Values

A hajtáslánc áramát double -ként adja vissza a kiválasztott egységben.

hatalom#

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.

Available Functions

double power(
  powerUnits units = powerUnits::watt );

Parameters

Paraméter	Típus	Leírás
`units`	`powerUnits`	A teljesítmény mértékegysége: `watt` (watt, alapértelmezett).

Return Values

A hajtáslánc teljesítményét wattban adja vissza double formátumban.

nyomaték#

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.

Available Functions

double torque(
  torqueUnits units = torqueUnits::nm );

Parameters

Paraméter	Típus	Leírás
`units`	`torqueUnits`	A nyomaték mértékegysége: `Nm` (newtonméter, alapértelmezett) vagy `InLb` (hüvelyk-font).

Return Values

A hajtáslánc nyomatékát double -ként adja vissza a kiválasztott mértékegységben.

hatékonyság#

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.

Available Functions

double efficiency(
  percentUnits units = percentUnits::pct );

Parameters

Paraméter	Típus	Leírás
`units`	`percentUnits`	A hatásfok visszaadásához használt mértékegység: `percent` vagy `pct` (alapértelmezett).

Return Values

A hajtáslánc hatékonyságát double értékként adja vissza a kiválasztott egységben.

hőmérséklet#

temperature A hajtáslánc átlagos hőmérsékletét adja vissza százalékban 0% és 100% között.

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.

Available Functions

double temperature(
  percentUnits units );

Parameters

Paraméter	Típus	Leírás
`units`	`percentUnits`	A visszatérő hőmérséklet mértékegysége: `percent` vagy `pct` százalék.

Return Values

A hajtáslánc átlagos hőmérsékletét adja vissza double formátumban a kiválasztott mértékegységben.

Notes

A 50% visszaadott érték azt jelzi, hogy az átlagos motorhőmérséklet körülbelül 45Â°C (113Â°F).
The typical operating temperature range for the drivetrain is approximately 20Â°C (68Â°F) to 70Â°C (158Â°F).

feszültség#

voltage visszaadja a hajtásláncnak szolgáltatott elektromos feszültséget.

A feszültség a hajtáslánc motorjaihoz juttatott elektromos nyomás. Ez az áram- és teljesítményértékekkel együtt felhasználható annak megértésére, hogyan használja fel a hajtáslánc az elektromos energiát.

Available Functions

double  voltage(
  voltageUnits units = voltageUnits::volt );

Parameters

Paraméter	Típus	Leírás
`units`	`voltageUnits`	A feszültség visszaadásához használt mértékegység: `volt` (volt, alapértelmezett) vagy `voltageUnits::mV` (millivolt).

Return Values

A hajtáslánc feszültségét double -ként adja vissza a kiválasztott mértékegységben.