Antriebsstrang#
Einführung#
Der VEX IQ (2. Generation) Roboter nutzt einen Antriebsstrang zum Fahren und Drehen. Ein Antriebsstrang besteht aus Motoren und Rädern, die zusammenarbeiten, um den Roboter zu bewegen.
A configured drivetrain can use a connected Gyro Sensor, the Brain’s built-in Inertial Sensor, or no sensor. When a sensor is used, the drivetrain uses it to help the robot move and turn precisely. At the start of each project, the drivetrain calibrates the sensor automatically. Keep the robot still for about 2 seconds during calibration, so the robot can move and turn correctly.
Diese Seite verwendet drivetrain als Beispielnamen für den Antriebsstrang. Ersetzen Sie diesen bei Bedarf durch Ihren eigenen, konfigurierten Namen.
Es gibt viele Möglichkeiten, den Antriebsstrang zu codieren. Nachfolgend finden Sie eine Liste aller Antriebsstrangmethoden:
Aktionen – Den Roboter bewegen und drehen.
drive— Bewegt den Roboter unendlich vorwärts oder rückwärts.drive_for— Bewegt den Roboter vorwärts oder rückwärts über eine bestimmte Distanz.turn— Dreht den Roboter endlos nach links oder rechts.turn_for— Dreht den Roboter um eine bestimmte Anzahl von Grad nach links oder rechts.turn_to_heading— Dreht den Roboter in eine bestimmte Richtung zwischen -359 und 359 Grad. Der Roboter wählt dabei den kürzesten Weg, um die Zielrichtung zu erreichen.turn_to_rotation— Dreht den Roboter in eine bestimmte Rotation.stop— Stoppt die Bewegung des Roboters.calibrate_drivetrain— Kalibriert den mit dem Antriebsstrang konfigurierten Sensor.
Mutatoren – Einstellungen des Antriebsstrangs anpassen.
set_drive_velocity— Sagt dem Roboter, wie schnell er fahren soll.set_turn_velocity— Sagt dem Roboter, wie schnell er sich drehen soll.set_stopping— Gibt an, wie der Roboter seine Bewegung beendet: durch Bremsen, Ausrollen oder Anhalten.set_timeout— Legt fest, wie lange der Roboter versucht, eine Bewegung abzuschließen.set_heading— Ändert die aktuelle Fahrtrichtung des Roboters in eine neue Fahrtrichtung.set_rotation— Ändert die aktuelle Rotation des Roboters in eine neue Rotation.set_turn_threshold— Gibt an, wie nahe der Roboter einem Zielwinkel kommen muss, bevor eine Drehung abgeschlossen ist.set_turn_constant— Ändert, wie stark der Roboter seine Drehungen korrigiert.
Getters – Bewegungsstatus prüfen.
heading— Gibt die aktuelle Richtung des Roboters von 0 bis 359 Grad zurück.rotation— Gibt die aktuelle Rotation des Roboters zurück.velocity— Gibt die Geschwindigkeit des Roboters zurück.current— Gibt zurück, wie viel elektrischer Strom der Antriebsstrang verbraucht.is_moving— Gibt als booleschen Wert zurück, ob sich der Roboter bewegt.is_done— Gibt als booleschen Wert zurück, ob der Roboter seine Bewegung beendet hat.is_turning— Gibt als booleschen Wert zurück, ob sich der Roboter dreht.power— Gibt zurück, wie schnell der Antriebsstrang Energie verbraucht.torque— Gibt zurück, wie viel Drehmoment der Antriebsstrang verwendet.efficiency— Gibt an, wie effizient der Antriebsstrang die Leistung nutzt.temperature— Gibt zurück, wie warm der Antriebsstrang ist.
Konstrukteure – Antriebsstrang manuell erstellen und konfigurieren.
DriveTrain— Erzeugt einen Antriebsstrang ohne Gyrosensor oder Inertialsensor.SmartDrive— Erzeugt einen Antriebsstrang mit einem Gyrosensor oder Inertialsensor.
Aktionen#
drive#
drive endlos. Der Roboter bewegt sich so lange, bis ihm eine andere Aktion zugewiesen wird, z. B. Drehen oder Anhalten.
Usage:
drivetrain.drive(direction, velocity, units)
Parameter |
Beschreibung |
|---|---|
|
Die Bewegungsrichtung des Roboters: |
|
Optional. Die Fahrgeschwindigkeit kann zwischen 0 % und 100 % (bei Verwendung von |
|
Optional. Die Geschwindigkeitseinheit: |
# 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 bewegt den Roboter eine bestimmte Strecke vorwärts oder rückwärts. Das Projekt wartet, bis der Roboter die Bewegung abgeschlossen hat, bevor die nächste Codezeile ausgeführt wird.
Usage:
drivetrain.drive_for(direction, distance, units, velocity, units_v, wait)
Parameter |
Beschreibung |
|---|---|
|
Die Bewegungsrichtung des Roboters: |
|
Die vom Roboter zurückgelegte Strecke. Dies kann eine ganze Zahl |
|
Optional. Die Entfernungseinheit: |
|
Optional. Die Fahrgeschwindigkeit kann zwischen 0 % und 100 % (bei Verwendung von |
|
Optional. Die Geschwindigkeitseinheit: |
|
Optional. |
# 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 links oder rechts, und zwar endlos. Der Roboter dreht sich so lange, bis er eine andere Aktion erhält, z. B. Fahren oder Anhalten.
Usage:
drivetrain.turn(direction, velocity, units)
Parameter |
Beschreibung |
|---|---|
|
Die Richtung, in die sich der Roboter dreht: |
|
Optional. Die Drehgeschwindigkeit kann zwischen 0 % und 100 % (bei Verwendung von |
|
Optional. Die Geschwindigkeitseinheit: |
# 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#
Der Befehl turn_for dreht den Roboter um eine bestimmte Anzahl von Grad oder Umdrehungen nach links oder rechts. Die Drehung erfolgt relativ zur aktuellen Position des Roboters. Das Projekt wartet, bis der Roboter die Drehung abgeschlossen hat, bevor die nächste Codezeile ausgeführt wird.
Usage:
drivetrain.turn_for(direction, angle, units, velocity, units_v, wait)
Parameter |
Beschreibung |
|---|---|
|
Die Richtung, in die sich der Roboter dreht: |
|
Der Drehwinkel des Roboters. Dies kann eine ganze Zahl |
|
Optional. Die Dreheinheit: |
|
Optional. Die Drehgeschwindigkeit kann zwischen 0 % und 100 % (bei Verwendung von |
|
Optional. Die Geschwindigkeitseinheit: |
|
Optional. |
# 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#
Die Ausrichtung des Roboters wird in Grad gemessen. Der Wert turn_to_heading bewirkt, dass der Roboter in eine bestimmte Richtung zwischen -359 und 359 Grad ausgerichtet wird. Dabei wählt er den kürzesten Weg, um die Zielausrichtung zu erreichen.
Die Ausgangsrichtung des Roboters beträgt 0 Grad.
Das Projekt wartet, bis der Roboter seine Drehung abgeschlossen hat, bevor die nächste Codezeile ausgeführt wird.
Usage:
drivetrain.turn_to_heading(angle, units, velocity, units_v, wait)
Parameter |
Beschreibung |
|---|---|
|
Die Richtung, in die der Roboter zeigen soll, in Grad. Dies kann eine ganze Zahl |
|
Optional. Die Überschrifteneinheit: |
|
Optional. Die Drehgeschwindigkeit kann zwischen 0 % und 100 % (bei Verwendung von |
|
Optional. Die Geschwindigkeitseinheit: |
|
Optional. |
# 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 dreht den Roboter in eine bestimmte Rotation.
Die Rotation gibt an, wie weit sich der Roboter gedreht hat, gemessen in Grad oder Umdrehungen. Zu Beginn eines Projekts ist der Rotationswert auf 0 Grad gesetzt. Die Rotation kann auch mit der Methode set_rotation eingestellt werden.
Die Rotationswerte sind absolut. Das bedeutet, die Drehrichtung hängt von der aktuellen Rotation des Roboters ab. Eine Rechtsdrehung erhöht die Rotation, eine Linksdrehung verringert sie.
Wenn der Roboter beispielsweise bei 0 Grad startet und Sie ihn um 720 Grad drehen, dreht er sich zweimal nach rechts. Drehen Sie ihn anschließend um 360 Grad, dreht er sich einmal nach links, da 360 kleiner als 720 ist.
Das Projekt wartet, bis der Roboter seine Drehung abgeschlossen hat, bevor die nächste Codezeile ausgeführt wird.
Usage:
drivetrain.turn_to_rotation(angle, units, velocity, units_v, wait)
Parameter |
Beschreibung |
|---|---|
|
Der Rotationswert in Grad oder Umdrehungen, um den sich der Roboter drehen wird. Dies kann eine ganze Zahl |
|
Optional. Die Rotationseinheit: |
|
Optional. Die Drehgeschwindigkeit kann zwischen 0 % und 100 % (bei Verwendung von |
|
Optional. Die Geschwindigkeitseinheit: |
|
Optional. |
# 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 stoppt die Bewegung des Roboters.
Usage:
drivetrain.stop(mode)
Parameter |
Beschreibung |
|---|---|
|
Optional. So stoppt der Roboter:
|
# 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 ist eine integrierte Funktion, die den mit dem Antriebsstrang konfigurierten Gyrosensor oder Inertialsensor kalibriert.
Die Kalibrierung hilft dem Sensor, Bewegungen korrekt zu messen. Halten Sie den Roboter während der Kalibrierung etwa 2 Sekunden lang ruhig. Bewegt sich der Roboter während der Kalibrierung, misst der Sensor die Bewegung möglicherweise nicht korrekt.
Das Projekt wartet, bis die Kalibrierung abgeschlossen ist, bevor die nächste Codezeile ausgeführt wird.
Hinweis: Diese Funktion kann nicht innerhalb von VS Code verwendet werden.
Usage:
calibrate_drivetrain()
Parameter |
Beschreibung |
|---|---|
Diese Funktion hat keine Parameter. |
Mutatoren#
set_drive_velocity#
Der Wert set_drive_velocity gibt dem Roboter die Fahrgeschwindigkeit vor. Ein höherer Prozentwert beschleunigt den Roboter, ein niedrigerer Prozentwert verlangsamt ihn.
Jedes Projekt beginnt standardmäßig damit, dass der Roboter mit 50 % Geschwindigkeit fährt.
Hinweis: Eine höhere Geschwindigkeit lässt den Roboter schneller fahren, kann aber die Präzision verringern. Eine niedrigere Geschwindigkeit lässt den Roboter langsamer fahren, kann aber die Präzision erhöhen.
Usage:
drivetrain.set_drive_velocity(velocity, units)
Parameter |
Beschreibung |
|---|---|
|
Die Geschwindigkeit, mit der gefahren werden soll, von 0 % bis 100 % bei Verwendung von |
|
Optional. Die Geschwindigkeitseinheit: |
# 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#
Der Wert set_turn_velocity gibt dem Roboter die Drehgeschwindigkeit vor. Ein höherer Prozentwert beschleunigt die Drehung, ein niedrigerer Prozentwert verlangsamt sie.
Jedes Projekt beginnt standardmäßig damit, dass sich der Roboter mit 50 % Geschwindigkeit dreht.
Hinweis: Eine höhere Geschwindigkeit führt zu schnelleren Drehungen des Roboters, kann aber die Präzision verringern. Eine niedrigere Geschwindigkeit verlangsamt die Drehung, kann aber die Präzision erhöhen.
Usage:
drivetrain.set_turn_velocity(velocity, units)
Parameter |
Beschreibung |
|---|---|
|
Die Drehzahl, mit der von 0 % bis 100 % bei Verwendung |
|
Optional. Die Geschwindigkeitseinheit: |
# 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 legt fest, wie der Roboter seine Bewegung stoppt: durch Bremsen, Ausrollen oder Anhalten.
Usage:
drivetrain.set_stopping(mode)
Parameter |
Beschreibung |
|---|---|
|
So stoppt der Roboter:
|
Wird diese Methode nicht verwendet, nutzt der Roboter beim Anhalten die Tasten BRAKE.
set_timeout#
set_timeout wird festgelegt, wie lange der Roboter versucht, eine Bewegung abzuschließen. Gelingt ihm dies nicht, bricht er den Versuch ab und fährt mit der nächsten Codezeile fort. Dadurch wird verhindert, dass der Roboter bei einer Bewegung hängen bleibt.
Usage:
drivetrain.set_timeout(value, units)
Parameter |
Beschreibung |
|---|---|
|
Die Zeitspanne, in der der Roboter versuchen kann, eine Bewegung abzuschließen. Dies kann eine positive ganze Zahl |
|
Optional. Die Zeiteinheit: |
# Turn right after driving forward
drivetrain.set_timeout(1, SECONDS)
drivetrain.drive_for(FORWARD, 25, INCHES)
drivetrain.turn_for(RIGHT, 90)
set_heading#
Die Ausrichtung des Roboters wird in Grad gemessen. Der Befehl set_heading ändert die aktuelle Ausrichtung des Roboters auf einen neuen Wert.
Wenn sich der Roboter beispielsweise nach rechts gedreht hat, wird durch Einstellen der Ausrichtung auf 0 Grad diese Position nach rechts zum neuen 0-Grad-Wert. Anschließend kann der Roboter basierend auf dieser neuen Ausrichtung andere Positionen anfahren.
Usage:
drivetrain.set_heading(heading, units)
Parameter |
Beschreibung |
|---|---|
|
Der für den Roboter einzustellende Kurswert in Grad oder Umdrehungen. Dies kann eine ganze Zahl |
|
Optional. Die Kurseinheit: |
# Face the new 0 degrees
drivetrain.set_heading(90, DEGREES)
drivetrain.turn_to_heading(0, DEGREES)
set_rotation#
Die Rotation gibt an, um wie viel sich der Roboter gedreht hat, gemessen in Grad oder Umdrehungen. Zu Beginn eines Projekts ist der Rotationswert auf 0 Grad eingestellt. Der Befehl set_rotation ändert die aktuelle Rotation des Roboters auf einen neuen Wert.
Hat der Roboter beispielsweise zwei volle Drehungen nach rechts ausgeführt, beträgt sein Rotationswert 720 Grad. Durch Setzen der Rotation auf 0 Grad wird dieser Wert von 720 auf 0 Grad zurückgesetzt. Anschließend kann der Roboter Drehungen basierend auf diesem neuen Wert ausführen.
Usage:
drivetrain.set_rotation(rotation, units)
Parameter |
Beschreibung |
|---|---|
|
Der für den Roboter einzustellende Rotationswert in Grad oder Umdrehungen. Dies kann eine ganze Zahl |
|
Optional. Die Rotationseinheit: |
# Spin counterclockwise two times
drivetrain.set_rotation(720, DEGREES)
drivetrain.turn_to_rotation(0, DEGREES)
set_turn_threshold#
set_turn_threshold legt fest, wie nahe der Roboter einem Zielwinkel kommen muss, bevor eine Drehung abgeschlossen ist.
Ein niedrigerer Schwellenwert ermöglicht präzisere Drehungen, allerdings kann der Roboter für die Drehung länger benötigen. Ein höherer Schwellenwert beschleunigt die Drehungen, die Präzision kann jedoch geringer sein.
Usage:
drivetrain.set_turn_threshold(value)
Parameter |
Beschreibung |
|---|---|
|
Der Drehwinkelschwellenwert in Grad. Dies kann eine ganze Zahl |
# Set the turn threshold to 5 degrees
drivetrain.set_turn_threshold(5)
set_turn_constant#
set_turn_constant ändert, wie stark der Roboter seine Drehungen korrigiert.
Ein höherer Wert bewirkt eine stärkere Korrektur der Kurven durch den Roboter. Ein niedrigerer Wert bewirkt eine sanftere Korrektur. Der Standardwert ist 1,0.
Usage:
drivetrain.set_turn_constant(value)
Parameter |
Beschreibung |
|---|---|
|
Die Umdrehungskonstante. Dies kann eine Dezimalzahl ( |
# Increase the turn constant to 2.0
drivetrain.set_turn_constant(2.0)
Getter#
heading#
Die Ausrichtung (in Grad) gibt die Blickrichtung des Roboters an. Der Befehl heading liefert die aktuelle Ausrichtung des Roboters zwischen 0 und 359 Grad.
Die Ausgangsrichtung des Roboters beträgt 0 Grad.
Usage:
drivetrain.heading(units)
Parameter |
Beschreibung |
|---|---|
|
Optional. Die Einheit für die Rückkehrrichtung: |
# Display the heading after turning
drivetrain.turn_for(RIGHT, 450, DEGREES)
brain.screen.print("Heading: ")
brain.screen.print(drivetrain.heading())
rotation#
Die Rotation gibt an, wie weit sich der Roboter gedreht hat, gemessen in Grad oder Umdrehungen. Zu Beginn eines Projekts ist der Rotationswert auf 0 Grad gesetzt. Die Eingabe rotation gibt die aktuelle Rotation des Roboters zurück.
Eine Rechtsdrehung erhöht die Rotation, eine Linksdrehung verringert sie. Beispielsweise ergibt eine zweifache Rechtsdrehung eine Rotation von 720 Grad.
Usage:
drivetrain.rotation(units)
Parameter |
Beschreibung |
|---|---|
|
Optional. Die Einheit für die Rückdrehung: |
# Display the rotation after turning
drivetrain.turn_for(RIGHT, 450, DEGREES)
brain.screen.print("Rotation: ")
brain.screen.print(drivetrain.rotation())
velocity#
velocity gibt an, wie schnell der Roboter fährt.
It can return velocity as a percentage from -100% to 100%, in RPM from -127 rpm to 127 rpm, or in VelocityUnits.DPS (degrees per second). A positive value means the robot is driving forward. A negative value means the robot is driving in reverse.
Usage:
drivetrain.velocity(units)
Parameter |
Beschreibung |
|---|---|
|
Optional. Die Einheit, in der die Geschwindigkeit ausgegeben werden soll: |
current#
Der Wert current gibt an, wie viel Strom der Antriebsstrang verbraucht, gemessen in Ampere. Stromstärke ist die Menge an Elektrizität, die durch den Antriebsstrang fließt.
Ein höherer Stromwert bedeutet, dass der Antriebsstrang mehr Strom verbraucht. Dies kann vorkommen, wenn der Roboter gegen ein Hindernis drückt oder versucht, sich aus einer festgefahrenen Situation zu befreien.
Dies kann genutzt werden, um zu überprüfen, ob der Antriebsstrang während einer Bewegung überlastet ist. Bleibt der Stromfluss hoch, kann der Antriebsstrang sich erwärmen oder die Energie weniger effizient nutzen.
Usage:
drivetrain.current(units)
Parameter |
Beschreibung |
|---|---|
|
Optional. Die Einheit, in der der Strom zurückgegeben werden soll: |
is_moving#
Die Funktion is_moving gibt als booleschen Wert zurück, ob sich der Roboter bewegt is_moving . Dieser Wert kann verwendet werden, um den Zeitpunkt anderer Verhaltensweisen basierend auf der Bewegung des Roboters zu steuern.
True— Der Roboter bewegt sich.False— Der Roboter bewegt sich nicht.
Diese Methode funktioniert zusammen mit den folgenden Drivetrain-Methoden, die den Parameter wait haben: drive_for, turn_for, turn_to_heading und turn_to_rotation.
Usage:
drivetrain.is_moving()
Parameter |
Beschreibung |
|---|---|
Diese Methode hat keine Parameter. |
is_done#
Die Funktion is_done gibt als booleschen Wert zurück, ob der Roboter seine Bewegung beendet hat is_done . Dieser Wert kann verwendet werden, um den Zeitpunkt anderer Verhaltensweisen basierend auf der Bewegung des Roboters zu steuern.
True— Der Roboter hat seine Bewegung beendet.False— Der Roboter bewegt sich noch.
Diese Methode funktioniert zusammen mit den folgenden Drivetrain-Methoden, die den Parameter wait haben: drive_for, turn_for, turn_to_heading und turn_to_rotation.
Usage:
drivetrain.is_done()
Parameter |
Beschreibung |
|---|---|
Diese Methode hat keine Parameter. |
is_turning#
Die Funktion is_turning gibt als booleschen Wert zurück, ob sich der Roboter dreht is_turning . Dieser Wert kann verwendet werden, um den Zeitpunkt anderer Verhaltensweisen basierend auf der Bewegung des Roboters zu steuern.
True— Der Roboter dreht sich.False— Der Roboter dreht sich nicht.
Diese Methode funktioniert zusammen mit den folgenden Antriebsmethoden, die den Parameter wait haben: turn_for, turn_to_heading und turn_to_rotation.
Usage:
drivetrain.is_turning()
Parameter |
Beschreibung |
|---|---|
Diese Methode hat keine Parameter. |
power#
Die Leistungsangabe power gibt an, wie viel Leistung der Antriebsstrang in Watt verbraucht. Die Leistungsangabe zeigt, wie schnell der Antriebsstrang Energie verbraucht.
Ein höherer Leistungswert bedeutet, dass der Antriebsstrang schneller Energie verbraucht. Dies kann vorkommen, wenn der Roboter gegen ein Hindernis drückt oder versucht, sich aus einer festgefahrenen Situation zu befreien.
Dies kann genutzt werden, um Bewegungen zu vergleichen oder zu überprüfen, ob der Antriebsstrang überlastet ist. Bei anhaltend hoher Leistung kann der Antriebsstrang wärmer werden oder die Energie weniger effizient nutzen.
Usage:
drivetrain.power()
Parameter |
Beschreibung |
|---|---|
Diese Methode hat keine Parameter. |
torque#
Das Drehmoment gibt an, wie stark der Antriebsstrang drücken oder ziehen kann, während sich die Räder drehen.
torque gibt an, wie viel Drehmoment der Antriebsstrang verwendet, gemessen in Newtonmeter (Nm) oder Inch-Pfund (InLb).
Ein höherer Drehmomentwert bedeutet, dass der Antriebsstrang stärker drückt oder zieht. Dies kann vorkommen, wenn der Roboter gegen ein Hindernis drückt oder versucht, sich aus einer festgefahrenen Situation zu befreien.
Dies kann genutzt werden, um zu überprüfen, ob der Antriebsstrang überlastet ist oder um zu vergleichen, wie viel Schubkraft für verschiedene Bewegungen benötigt wird.
Usage:
drivetrain.torque(units)
Parameter |
Beschreibung |
|---|---|
|
Optional. Die Einheit, in der das Drehmoment zurückgegeben werden soll: |
efficiency#
efficiency gibt an, wie effizient der Antriebsstrang die Leistung nutzt, als Prozentsatz von 0% bis 100%.
Der Wirkungsgrad gibt an, wie viel der Antriebsleistung für die Bewegung genutzt wird. Ein höherer Wirkungsgrad bedeutet, dass mehr Antriebsleistung für die Bewegung verwendet wird. Ein niedriger Wirkungsgrad kann auftreten, wenn der Antriebsstrang stark beansprucht wird, sich aber kaum bewegt, beispielsweise wenn der Roboter feststeckt oder gegen ein Hindernis stößt.
Dies kann genutzt werden, um Bewegungen zu vergleichen oder zu überprüfen, ob der Antriebsstrang Energie verschwendet, anstatt sie für die Bewegung zu nutzen.
Usage:
drivetrain.efficiency()
Parameter |
Beschreibung |
|---|---|
Diese Methode hat keine Parameter. |
temperature#
temperature gibt die Durchschnittstemperatur des Antriebsstrangs in der ausgewählten Temperatureinheit zurück.
Die Temperaturanzeige gibt an, wie warm die Antriebsmotoren sind. Eine höhere Temperatur bedeutet, dass die Motoren während des Betriebs wärmer werden. Um ihre volle Leistung zu erbringen, sollten die Motoren unter 55 °C bleiben.
Wenn die Motoren zu heiß werden, reduzieren sie zum Selbstschutz ihren maximalen Strom. Bei 70 °C schalten sich die Motoren ab, bis sie abgekühlt sind.
Dies kann verwendet werden, um zu überprüfen, ob der Antriebsstrang bei wiederholten Bewegungen, langen Fahrten oder beim Drücken gegen ein Objekt zu heiß wird.
Usage:
drivetrain.temperature(units)
Parameter |
Beschreibung |
|---|---|
|
Optional. Die Einheit, in der die Temperatur zurückgegeben werden soll: |
Konstruktoren#
Konstruktoren dienen dazu, im Code DriveTrain und SmartDrive Objekte zu erstellen. Dies ist hilfreich, wenn ein Antriebsstrang konfiguriert werden soll, ohne das Gerätefenster zu verwenden.
Vor dem Erstellen eines Antriebsstrangs müssen mindestens zwei Motor- oder MotorGroup-Objekte erstellt werden.
DriveTrain#
DriveTrain erzeugt einen Antriebsstrang ohne Gyro Sensor oder Inertial Sensor.
Usage:
DriveTrain(lm, rm, wheelTravel, trackWidth, wheelBase, units, externalGearRatio)
Parameter |
Beschreibung |
|---|---|
|
Der linke Motor oder Motorgruppe. |
|
Der rechte Motor oder Motorgruppe. |
|
Optional. Der Umfang der Antriebsräder. Standardwert: 300 Millimeter. |
|
Optional. Der Abstand zwischen dem linken und rechten Rad. Standardmäßig beträgt er 320 Millimeter. |
|
Optional. Der Abstand zwischen Vorder- und Hinterrad. Standardmäßig beträgt er 320 Millimeter. |
|
Optional. Die Einheit für |
|
Optional. Das Übersetzungsverhältnis zur Anpassung der Antriebsdistanzen, falls Zahnräder verwendet werden. Mögliche Werte: |
# 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 erstellt einen Antriebsstrang mit einem Gyrosensor oder Inertialsensor.
Usage:
SmartDrive(lm, rm, g, wheelTravel, trackWidth, wheelBase, units, externalGearRatio)
Parameter |
Beschreibung |
|---|---|
|
Der linke Motor oder Motorgruppe. |
|
Der rechte Motor oder Motorgruppe. |
|
Der vom Antriebsstrang verwendete Gyrosensor oder Inertialsensor. |
|
Optional. Der Umfang der Antriebsräder. Standardwert: 300 Millimeter. |
|
Optional. Der Abstand zwischen dem linken und rechten Rad. Standardmäßig beträgt er 320 Millimeter. |
|
Optional. Der Abstand zwischen Vorder- und Hinterrad. Standardmäßig beträgt er 320 Millimeter. |
|
Optional. Die Einheit für |
|
Optional. Das Übersetzungsverhältnis zur Anpassung der Antriebsdistanzen, falls Zahnräder verwendet werden. Mögliche Werte: |
# 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)
Wenn Sie einen intelligenten Antriebsstrang mit mehreren Motoren erstellen, müssen Sie die Motoren separat erstellen, bevor Sie sie zu einer Motorgruppe zusammenfassen.
# 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)