Roboterspezifisches Python#

Einführung #

Der Hero Bot Byte umfasst zwei Motorgruppenoptionen und einen optischen Sensor.

Alle Standard-VEXcode-VR-Methoden stehen im IQ 23-24 Full Volume Playground zur Verfügung.

Nachfolgend finden Sie eine Liste aller verfügbaren roboterspezifischen Methoden:

Antriebsstrang – Den Roboter bewegen und drehen.

Aktionen
- 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.
- turn_to_rotation — Dreht den Roboter in eine bestimmte Rotation.
- stop — Stoppt die Bewegung des Roboters.
Mutatoren
- 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_timeout — Legt fest, wie lange der Roboter versucht, eine Bewegung abzuschließen.
- set_drive_velocity — Sagt dem Roboter, wie schnell er fahren soll.
- set_turn_velocity — Sagt dem Roboter, wie schnell er sich drehen soll.
Getter
- heading — Gibt die aktuelle Richtung des Roboters von 0 bis 359,99 Grad zurück.
- rotation — Gibt die aktuelle Rotation des Roboters zurück.
- is_done — Gibt als booleschen Wert zurück, ob der Roboter seine Bewegung beendet hat.
- is_moving — Gibt als booleschen Wert zurück, ob sich der Roboter bewegt.
- velocity — Gibt die Geschwindigkeit des Roboters zurück.

Bewegung – Die Motorgruppen des Roboters bewegen und verfolgen.

Aktionen
- spin — Dreht eine Motorgruppe unendlich lange vorwärts oder rückwärts.
- spin_for — Dreht eine Motorgruppe über eine bestimmte Distanz.
- spin_to_position — Dreht eine Motorgruppe in eine bestimmte Position.
- stop — Stoppt die Drehung einer Motorgruppe.
Mutatoren
- set_position — Ändert die aktuelle Position der Motorgruppe auf einen neuen Wert.
- set_velocity — Gibt einer Motorgruppe die gewünschte Drehgeschwindigkeit vor.
- set_timeout — Legt fest, wie lange eine Motorgruppe versucht, eine Bewegung abzuschließen.
Getter
- is_done — Gibt als booleschen Wert zurück, ob die Motorgruppe mit der Bewegung fertig ist.
- is_spinning — Gibt als booleschen Wert zurück, ob sich die Motorgruppe dreht.
- position — Gibt die aktuelle Position der Motorgruppe zurück.
- velocity — Gibt zurück, wie schnell sich die Motorgruppe dreht.

Konsole – Werte auf der Konsole ausgeben und überwachen.

Drucken
- brain.screen.print — Zeigt Text, Zahlen oder Variablenwerte in der Konsole an.
- brain.screen.next_row — Verschiebt den Konsolencursor an den Anfang der nächsten Zeile.
- brain.screen.clear_screen — Löscht alle Zeilen aus der Konsole.
Monitor
- monitor_variable — Fügt der Registerkarte „Monitor“ eine oder mehrere vordefinierte Variablen hinzu.
- monitor_sensor — Fügt dem Monitor-Tab einen oder mehrere Sensorwerte hinzu.

Sensorik – Nutzen Sie die verschiedenen Sensoren des Roboters.

Optisch
- is_near_object – Gibt zurück, ob der optische Sensor ein Objekt in Reichweite erkennt.
- color – Gibt die vom optischen Sensor erkannte Farbe zurück.
- brightness – Gibt die Menge des vom Objekt reflektierten Lichts zurück.
- hue – Gibt den vom optischen Sensor erfassten Farbton zurück.
- object_detected – Registriert eine Funktion, die aufgerufen werden soll, wenn der optische Sensor ein Objekt erkennt.
- object_lost – Registriert eine Funktion, die aufgerufen werden soll, wenn der optische Sensor ein Objekt verliert.

Die Beispiele auf dieser Seite verwenden die standardmäßige Startposition des Playgrounds.

Der Antriebsstrang steuert die Fahr- und Drehbewegungen des VR-Roboters. Er ermöglicht Vorwärts- und Rückwärtsfahrten, Links- und Rechtskurven, Drehungen in verschiedene Richtungen und die Nachführung der Rotation.

Aktionen #

fahren #

drive endlos. Der Roboter bewegt sich so lange, bis ihm eine andere Aktion zugewiesen wird, z. B. Drehen oder Anhalten.

Usage:
drivetrain.drive(direction)

Parameter	Beschreibung
`direction`	Die Bewegungsrichtung des Roboters: `FORWARD` oder `REVERSE`.

def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

fahren_für #

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, wait)

Parameter	Beschreibung
`direction`	Die Bewegungsrichtung des Roboters: `FORWARD` oder `REVERSE`.
`distance`	Die vom Roboter zurückgelegte Strecke. Dies kann eine ganze Zahl `integer` ) oder eine Dezimalzahl (`float` ) sein.
`units`	Optional. Die Entfernungseinheit: `INCHES` (Standard) oder `MM`.
`wait`	Optional. `wait=True` (Standard) Das Projekt wartet, bis der Roboter seine Bewegung abgeschlossen hat, bevor die nächste Codezeile ausgeführt wird. `wait=False` Die nächste Codezeile wird sofort ausgeführt.

def main():
    # Drive forward and backward
    drivetrain.drive_for(FORWARD, 200, MM)
    drivetrain.drive_for(REVERSE, 200, MM)

# VR threads — Do not delete
vr_thread(main)

drehen #

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)

Parameter	Beschreibung
`direction`	Die Richtung, in die sich der Roboter dreht: `LEFT` oder `RIGHT`.

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

# VR threads — Do not delete
vr_thread(main)

turn_for #

Der Befehl turn_for dreht den Roboter um eine bestimmte Gradzahl 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, wait)

Parameter	Beschreibung
`direction`	Die Richtung, in die sich der Roboter dreht: `LEFT` oder `RIGHT`.
`angle`	Die Anzahl der Grad, um die sich der Roboter dreht. Dies kann eine ganze Zahl `integer` ) oder eine Dezimalzahl (`float` ) sein.
`units`	Optional. Die Rotationseinheit: `DEGREES` (Standard).
`wait`	Optional. `wait=True` (Standard) Das Projekt wartet, bis der Roboter seine Drehung abgeschlossen hat, bevor die nächste Codezeile ausgeführt wird. `wait=False` Die nächste Codezeile wird sofort ausgeführt.

def main():
    # Turn the robot right and left
    drivetrain.turn_for(RIGHT, 90, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_for(LEFT, 90, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Richtung ändern #

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, wait)

Parameter	Beschreibung
`angle`	Die Richtung, in die der Roboter zeigen soll, in Grad. Dies kann eine ganze Zahl `integer` ) oder eine Dezimalzahl (`float`) zwischen -359 und 359 sein.
`units`	Optional. Die Rotationseinheit: `DEGREES` (Standard).
`wait`	Optional. `wait=True` (Standard) Das Projekt wartet, bis der Roboter seine Drehung abgeschlossen hat, bevor die nächste Codezeile ausgeführt wird. `wait=False` Die nächste Codezeile wird sofort ausgeführt.

def main():
    # 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)

# VR threads — Do not delete
vr_thread(main)

Drehung #

turn_to_rotation dreht den Roboter in eine bestimmte Rotation.

Die Rotation gibt an, um welchen Winkel sich der Roboter gedreht hat, gemessen in Grad. Zu Beginn eines Projekts ist der Rotationswert auf 0 Grad eingestellt. Die Rotation kann auch mit der Methode set_rotation festgelegt 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, wait)

Parameter	Beschreibung
`angle`	Der Rotationswert in Grad, um den sich der Roboter drehen wird. Dies kann eine ganze Zahl `integer` ) oder eine Dezimalzahl (`float` ) sein.
`units`	Optional. Die Rotationseinheit: `DEGREES` (Standard).
`wait`	Optional. `wait=True` (Standard) Das Projekt wartet, bis der Roboter seine Drehung abgeschlossen hat, bevor die nächste Codezeile ausgeführt wird. `wait=False` Die nächste Codezeile wird sofort ausgeführt.

def main():
    # 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)

# VR threads — Do not delete
vr_thread(main)

stoppen #

stop stoppt die Bewegung des Roboters.

Usage:
drivetrain.stop()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

Mutatoren #

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
`heading`	Der für den Roboter einzustellende Kurswert in Grad. Dies kann eine ganze Zahl `integer` ) oder eine Dezimalzahl (`float` ) sein.
`units`	Optional. Die Überschrifteneinheit: `DEGREES` (Standard).

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

# VR threads — Do not delete
vr_thread(main)

set_rotation #

Die Rotation gibt an, um welchen Winkel sich der Roboter gedreht hat, gemessen in Grad. 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
`rotation`	Der für den Roboter einzustellende Rotationswert in Grad. Dies kann eine ganze Zahl `integer` ) oder eine Dezimalzahl (`float` ) sein.
`units`	Optional. Die Rotationseinheit: `DEGREES` (Standard).

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

# VR threads — Do not delete
vr_thread(main)

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
`value`	Die Zeitspanne, in der der Roboter versuchen kann, eine Bewegung abzuschließen. Dies kann eine positive ganze Zahl `integer` ) oder eine Dezimalzahl (`float` ) sein.
`units`	Die Zeiteinheit: `SECONDS` oder `MSEC` (Millisekunden).

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

# VR threads — Do not delete
vr_thread(main)

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
`velocity`	Die Geschwindigkeit, mit der gefahren werden soll, von 0 % bis 100 %. Dies kann eine ganze Zahl `integer` oder eine Dezimalzahl (`float` ) sein.
`units`	Optional. Die Geschwindigkeitseinheit: `PERCENT` (Standard).

def main():
    # 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)

# VR threads — Do not delete
vr_thread(main)

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
`velocity`	The velocity to turn with from 0% to 100%. This can be an `integer` or decimal (`float`).
`units`	Optional. Die Geschwindigkeitseinheit: `PERCENT` (Standard).

def main():
    # Turn at different velocities
    # Default velocity
    drivetrain.turn_for(RIGHT, 120, DEGREES)
    wait(1, SECONDS)
    # Turn slower
    drivetrain.set_turn_velocity(20, PERCENT)
    drivetrain.turn_for(RIGHT, 120, DEGREES)
    wait(1, SECONDS)
    # Turn faster
    drivetrain.set_turn_velocity(100, PERCENT)
    drivetrain.turn_for(RIGHT, 120, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Getter #

Überschrift #

Die Ausrichtung (in Grad) gibt die Blickrichtung des Roboters an. Der Befehl heading liefert die aktuelle Ausrichtung des Roboters zwischen 0 und 359,99 Grad.

Die Ausgangsrichtung des Roboters beträgt 0 Grad.

Usage:
drivetrain.heading(units)

Parameter	Beschreibung
`units`	Optional. Die Überschrifteneinheit: `DEGREES` (Standard).

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

# VR threads — Do not delete
vr_thread(main)

Drehung #

Die Rotation gibt an, um wie viel sich der Roboter gedreht hat, gemessen in Grad. 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
`units`	Optional. Die Rotationseinheit: `DEGREES` (Standard).

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

# VR threads — Do not delete
vr_thread(main)

ist_fertig #

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.

bewegt sich #

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.

Usage:
drivetrain.is_moving()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

Geschwindigkeit #

velocity gibt an, wie schnell der Roboter fährt, als Prozentsatz von -100% bis 100%.

Usage:
drivetrain.velocity(units)

Parameter	Beschreibung
`units`	Optional. Die Geschwindigkeitseinheit: `PERCENT` (Standard).

Beispiel

def main():
    # Display the velocity after driving
    drivetrain.drive_for(FORWARD, 150, MM)
    brain.screen.print("Velocity: ")
    brain.screen.print(drivetrain.velocity(PERCENT))

Bewegung #

Byte nutzt die Armmotorengruppe, um den Arm anzuheben und abzusenken, damit Blöcke transportiert werden können. Die Aufnahmemotorengruppe dreht die Vorderräder, um Blöcke einzusammeln, oder dreht sie rückwärts, um sie zu punkten oder abzulegen.

Jede Motorgruppe hat ihr eigenes Richtungsverhalten. Die Richtungsbeschreibungen erklären, wie sich die jeweilige Motorgruppe auf Byte in jeder Richtung bewegt.

Aktionen #

drehen #

spin zwar endlos. Die Motorgruppe dreht sich so lange, bis ihr eine andere Aktion zugewiesen wird, z. B. eine andere Drehrichtung oder ein Stopp.

Verwendung:
Mit dieser Methode kann eines von zwei verfügbaren Motorgruppenobjekten verwendet werden, wie unten dargestellt:

Motor	Befehl
`arm_motor_group`	`arm_motor_group.spin(direction)` — Armmotorgruppe
`intake_motor_group`	`intake_motor_group.spin(direction)` — Ansaugmotorgruppe

Parameter

Beschreibung

direction

Die Drehrichtung der Motorgruppe:

FORWARD — Hebt die Armmotorgruppe an oder dreht die Ansaugmotorgruppe in Ansaugrichtung.
REVERSE — Senkt die Armmotorgruppe ab oder dreht die Ansaugmotorgruppe in Auslassrichtung.

def main():
    # Spin the intake motor forward then stop
    intake_motor_group.spin(FORWARD)
    wait(0.5, SECONDS)
    intake_motor_group.stop()

# VR threads — Do not delete
vr_thread(main)

spin_for #

Der Befehl spin_for lässt eine Motorgruppe eine bestimmte Strecke drehen. Die Drehung bezieht sich auf die aktuelle Position der Motorgruppe. Das Projekt wartet, bis die Motorgruppe ihre Drehung abgeschlossen hat, bevor die nächste Codezeile ausgeführt wird.

Verwendung:
Mit dieser Methode kann eines von zwei verfügbaren Motorgruppenobjekten verwendet werden, wie unten dargestellt:

Motor	Befehl
`arm_motor_group`	`arm_motor_group.spin_for(direction, distance, units, wait)` — Arm Motor Group
`intake_motor_group`	`intake_motor_group.spin_for(direction, distance, units, wait)` — Ansaugmotorgruppe

Parameter	Beschreibung
`direction`	Die Drehrichtung der Motorgruppe: `FORWARD` — Hebt die Armmotorgruppe an oder dreht die Ansaugmotorgruppe in Ansaugrichtung. `REVERSE` — Senkt die Armmotorgruppe ab oder dreht die Ansaugmotorgruppe in Auslassrichtung.
`distance`	Die Strecke, die die Motorgruppe dreht. `DEGREES` ganze Zahlen verwenden. `TURNS` ganze Zahlen oder Dezimalzahlen verwenden.
`units`	Optional. Die Entfernungseinheit: `DEGREES` (Standard) oder `TURNS`.
`wait`	Optional. `wait=True` (Standard) – Das Projekt wartet, bis die Motorgruppe ihre Drehung beendet hat, bevor die nächste Codezeile ausgeführt wird. `wait=False` – Die nächste Codezeile wird sofort ausgeführt.

def main():
    # Spin the intake motor forward then stop
    intake_motor_group.spin_for(FORWARD, 360, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Drehen in Position #

spin_to_position dreht eine Motorgruppe in eine bestimmte Position.

Die Position einer Motorgruppe gibt an, wie weit sie sich gedreht hat, gemessen in DEGREES oder TURNS. Eine Umdrehung entspricht 360 Grad. Zu Beginn eines Projekts wird die Position der Motorgruppe auf 0 Grad eingestellt. Die Position der Motorgruppe kann auch mit der Methode set_position festgelegt werden.

Die Positionswerte sind absolut. Das bedeutet, dass die Drehrichtung von der aktuellen Position der Motorgruppe abhängt.

Wenn sich die Motorgruppe beispielsweise von 0 Grad auf 720 Grad dreht, dreht sie sich zwei Umdrehungen vorwärts. Dreht sie sich anschließend auf 360 Grad, dreht sie sich eine Umdrehung rückwärts, da 360 kleiner als 720 ist.

Verwendung:
Mit dieser Methode kann eines von zwei verfügbaren Motorgruppenobjekten verwendet werden, wie unten dargestellt:

Motor	Befehl
`arm_motor_group`	`arm_motor_group.spin_to_position(angle, units, wait=True)` — Armmotorgruppe
`intake_motor_group`	`intake_motor_group.spin_to_position(angle, units, wait=True)` — Ansaugmotorgruppe

Parameter	Beschreibung
`angle`	Der Positionswert, bis zu dem sich die Motorgruppe dreht. `DEGREES` ganze Zahl verwenden). `TURNS` ganze Zahlen oder Dezimalzahlen verwenden).
`units`	Optional. Die Positionseinheit: `DEGREES` (Standard) oder `TURNS`.
`wait`	Optional. `wait=True` (Standard) – Das Projekt wartet, bis die Motorgruppe ihre Drehung beendet hat, bevor die nächste Codezeile ausgeführt wird. `wait=False` – Die nächste Codezeile wird sofort ausgeführt.

Parameter

Beschreibung

angle

Der Positionswert, bis zu dem sich die Motorgruppe dreht. DEGREES ganze Zahl verwenden). TURNS ganze Zahlen oder Dezimalzahlen verwenden).

units

Optional. Die Positionseinheit: DEGREES (Standard) oder TURNS.

wait

Optional.

wait=True (Standard) – Das Projekt wartet, bis die Motorgruppe ihre Drehung beendet hat, bevor die nächste Codezeile ausgeführt wird.
wait=False – Die nächste Codezeile wird sofort ausgeführt.

def main():
    # Spin the intake motor forward then stop
    intake_motor_group.spin_to_position(55, DEGREES)

# VR threads — Do not delete
vr_thread(main)

stoppen #

stop stoppt die Drehung einer Motorgruppe.

Verwendung:
Mit dieser Methode kann eines von zwei verfügbaren Motorgruppenobjekten verwendet werden, wie unten dargestellt:

Motor	Befehl
`arm_motor_group`	`arm_motor_group.stop()` — Armmotorgruppe
`intake_motor_group`	`intake_motor_group.stop()` — Ansaugmotorgruppe

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

def main():
    # Spin the intake motor forward then stop
    intake_motor_group.spin(FORWARD)
    wait(0.5, SECONDS)
    intake_motor_group.stop()

# VR threads — Do not delete
vr_thread(main)

Mutatoren #

Position festlegen #

Die Position einer Motorgruppe gibt an, wie weit sie sich gedreht hat, gemessen in DEGREES oder TURNS. Eine Umdrehung entspricht 360 Grad. set_position wird die aktuelle Position der Motorgruppe auf einen neuen Wert gesetzt.

Wenn sich beispielsweise eine Motorgruppe um 180 Grad gedreht hat, wird durch Einstellen der Position auf 0 Grad diese Position von 180 auf 0 Grad zurückgesetzt. Anschließend kann sich die Motorgruppe basierend auf diesem neuen Wert in verschiedene Positionen drehen.

Verwendung:
Mit dieser Methode kann eines von zwei verfügbaren Motorgruppenobjekten verwendet werden, wie unten dargestellt:

Motor	Befehl
`arm_motor_group`	`arm_motor_group.set_position(position, units)` — Armmotorgruppe
`intake_motor_group`	`intake_motor_group.set_position(position, units)` — Ansaugmotorgruppe

Parameter	Beschreibung
`position`	Der für die Motorgruppe einzustellende Positionswert. `DEGREES` (ganze Zahlen verwenden). `TURNS` (ganze oder Dezimalzahlen verwenden).
`units`	Optional. Die Positionseinheit: `DEGREES` (Standard) oder `TURNS`.

def main():
    # Set the current motor position to 90 degrees
    intake_motor_group.set_position(90, DEGREES)
    # Spin the intake motor back to 0 degrees
    intake_motor_group.spin_to_position(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_velocity #

Der Wert set_velocity gibt einer Motorgruppe die Drehgeschwindigkeit vor. Ein höherer Prozentwert beschleunigt die Drehung, ein niedrigerer Prozentwert verlangsamt sie.

Jedes Projekt beginnt standardmäßig damit, dass sich jede Motorengruppe mit 50 % Drehzahl dreht.

Hinweis: Eine höhere Drehzahl lässt die Motorengruppe schneller rotieren, kann aber die Präzision verringern. Eine niedrigere Drehzahl lässt die Motorengruppe langsamer rotieren, kann aber die Präzision erhöhen.

Verwendung:
Mit dieser Methode kann eines von zwei verfügbaren Motorgruppenobjekten verwendet werden, wie unten dargestellt:

Motor	Befehl
`arm_motor_group`	`arm_motor_group.set_velocity(velocity, units)` — Arm Motor Group
`intake_motor_group`	`intake_motor_group.set_velocity(velocity, units)` — Ansaugmotorgruppe

Parameter	Beschreibung
`velocity`	Die Drehzahl, mit der die Rotation erfolgen soll, von 0 % bis 100 %. Dies kann eine ganze Zahl `integer` oder eine Dezimalzahl (`float` ) sein.
`units`	Die Geschwindigkeitseinheit: `PERCENT`.

def main():
    # Spin the intake motor forward then stop
    intake_motor_group.set_velocity(75, PERCENT)
    intake_motor_group.spin_to_position(180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_timeout #

set_timeout wird festgelegt, wie lange eine Motorgruppe versucht, eine Bewegung abzuschließen. Gelingt dies nicht, bricht die Motorgruppe den Versuch ab und fährt mit der nächsten Codezeile fort. Dadurch wird verhindert, dass die Motorgruppe bei einer Bewegung hängen bleibt.

Verwendung:
Mit dieser Methode kann eines von zwei verfügbaren Motorgruppenobjekten verwendet werden, wie unten dargestellt:

Motor	Befehl
`arm_motor_group`	`arm_motor_group.set_timeout(value, units)` — Armmotorgruppe
`intake_motor_group`	`intake_motor_group.set_timeout(value, units)` — Ansaugmotorgruppe

Parameter	Beschreibung
`value`	Die Zeitspanne, die die Motorgruppe versuchen kann, eine Bewegung abzuschließen. Dies kann eine positive ganze Zahl `integer` ) oder eine Dezimalzahl (`float` ) sein.
`units`	Die Zeiteinheit: `SECONDS` oder `MSEC` (Millisekunden).

def main():
    # Spin the intake motor forward then stop
    intake_motor_group.set_timeout(2, SECONDS)
    intake_motor_group.spin_to_position(270, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Getter #

ist_fertig #

Die Funktion is_done gibt als booleschen Wert zurück, ob die Motorgruppe ihre Bewegung abgeschlossen hat (Wert is_done . Dieser Wert kann verwendet werden, um den Zeitpunkt anderer Verhaltensweisen basierend auf der Bewegung der Motorgruppe zu steuern.

True — Die Motorgruppe hat ihre Bewegung beendet.
False — Die Motorgruppe bewegt sich noch.

Diese Methode funktioniert zusammen mit den folgenden Bewegungsmethoden, die den Parameter wait haben: spin_for und spin_to_position.

Verwendung:
Mit dieser Methode kann eines von zwei verfügbaren Motorgruppenobjekten verwendet werden, wie unten dargestellt:

Motor	Befehl
`arm_motor_group`	`arm_motor_group.is_done()` — Armmotorgruppe
`intake_motor_group`	`intake_motor_group.is_done()` — Ansaugmotorgruppe

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

is_spinning #

is_spinning is_spinning gibt als booleschen Wert zurück, ob sich die Motorgruppe dreht. Dieser Wert kann verwendet werden, um das Timing anderer Verhaltensweisen basierend auf der Bewegung der Motorgruppe zu steuern.

True — Die Motorgruppe dreht sich.
False — Die Motorgruppe dreht sich nicht.

Diese Methode funktioniert zusammen mit den folgenden Bewegungsmethoden, die den Parameter wait haben: spin_for und spin_to_position.

Verwendung:
Mit dieser Methode kann eines von zwei verfügbaren Motorgruppenobjekten verwendet werden, wie unten dargestellt:

Motor	Befehl
`arm_motor_group`	`arm_motor_group.is_spinning()` — Armmotorgruppe
`intake_motor_group`	`intake_motor_group.is_spinning()` — Ansaugmotorgruppe

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

Position #

Die Position einer Motorgruppe gibt an, wie weit sie sich gedreht hat, gemessen in DEGREES oder TURNS. Eine Umdrehung entspricht 360 Grad. position gibt die aktuelle Position der Motorgruppe zurück.

Zu Beginn eines Projekts wird die Position der Motorgruppe auf 0 Grad eingestellt. Dreht sich die Motorgruppe eine volle Umdrehung vorwärts, beträgt die Position 360 Grad bzw. eine Umdrehung. Dreht sich die Motorgruppe in die andere Richtung, ist die Position negativ.

Verwendung:
Mit dieser Methode kann eines von zwei verfügbaren Motorgruppenobjekten verwendet werden, wie unten dargestellt:

Motor	Befehl
`arm_motor_group`	`arm_motor_group.position(units)` — Armmotorgruppe
`intake_motor_group`	`intake_motor_group.position(units)` — Ansaugmotorgruppe

Parameter	Beschreibung
`units`	Die Einheit kehrt in die Position der Motorgruppe zurück in: `DEGREES` oder `TURNS`.

Geschwindigkeit #

velocity gibt an, wie schnell sich die Motorgruppe dreht.

Ein positiver Wert bedeutet, dass sich die Motorgruppe vorwärts dreht. Ein negativer Wert bedeutet, dass sich die Motorgruppe rückwärts dreht.

Verwendung:
Mit dieser Methode kann eines von zwei verfügbaren Motorgruppenobjekten verwendet werden, wie unten dargestellt:

Motor	Befehl
`arm_motor_group`	`arm_motor_group.velocity(units)` — Armmotorgruppe
`intake_motor_group`	`intake_motor_group.velocity(units)` — Ansaugmotorgruppe

Parameter	Beschreibung
`units`	Die zurückzugebende Geschwindigkeitseinheit: `PERCENT`.

Konsole #

Die Konsole zeigt während der Projektausführung Text, Zahlen und Variablenwerte an. Mit den Konsolenmethoden lässt sich außerdem der Cursor in eine neue Zeile bewegen, die Konsole leeren und Variablen oder Sensorwerte zum Monitor-Tab hinzufügen.

Drucken #

Gehirn.Bildschirm.Drucken #

brain.screen.print zeigt Text, Zahlen oder Variablenwerte in der Konsole an der aktuellen Cursorposition an.

Verwenden Sie brain.screen.next_row, wenn der nächste ausgegebene Wert in einer neuen Zeile beginnen soll.

Usage:
brain.screen.print(value)

Parameter	Beschreibung
`value`	Der Text, die Zahl oder der Variablenwert, der in der Konsole angezeigt werden soll.

def main():
    # Display a message in the Console
    brain.screen.print("Hello, robot!")

# VR threads — Do not delete
vr_thread(main)

Die VEXcode-Konsole zeigt die Konsole und den Text "Hallo, Roboter!" an.

brain.screen.next_row #

brain.screen.next_row wird der Cursor in der Konsole in Spalte 1 der nächsten Zeile gesetzt. Der nächste ausgegebene Wert erscheint in dieser Zeile.

Usage:
brain.screen.next_row()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

def main():
    # Print on two rows
    brain.screen.print("Row 1")
    brain.screen.next_row()
    brain.screen.print("Row 2")

# VR threads — Do not delete
vr_thread(main)

Die VEXcode-Konsole zeigt die Konsole und den Text "Zeile 1" in der ersten Zeile und "Zeile 2" in der zweiten Zeile an.

brain.screen.clear_screen #

brain.screen.clear_screen löscht alle Zeilen aus der Konsole und setzt den Cursor zurück auf Zeile 1.

Usage:
brain.screen.clear_screen()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

def main():
    # Display text, then clear it after two seconds
    brain.screen.print("This will disappear...")
    wait(2, SECONDS)
    brain.screen.clear_screen()

# VR threads — Do not delete
vr_thread(main)

Monitor #

Monitorvariable #

monitor_variable werden dem Monitor-Tab in VEXcode eine oder mehrere vordefinierte Variablen hinzugefügt. So können Sie die Wertänderung einer Variablen während der Projektausführung beobachten.

Variablen müssen global sein, damit die Überwachung mit monitor_variable erfolgreich funktioniert. Geben Sie jeden Variablennamen als Zeichenkette an.

Usage:
monitor_variable(“variable”)
monitor_variable(“variable1”, “variable2”)

Parameter	Beschreibung
`variable`	Der Name einer vordefinierten globalen Variable, die überwacht werden soll, wird als Zeichenkette angegeben. Um mehrere Variablen zu überwachen, trennen Sie die Variablennamen durch Kommas.

def main():
    # Monitor the amount of loops
    global loops
    monitor_variable("loops")

    # Drive in a square 3 times
    for loops in range(12):
        drivetrain.turn_for(RIGHT, 90, DEGREES)
        drivetrain.drive_for(FORWARD, 150, MM)

# VR threads — Do not delete
vr_thread(main)

Monitor-Sensor #

Der Befehl monitor_sensor fügt dem Monitor-Tab in VEXcode einen oder mehrere Sensorwerte hinzu. Dadurch können Sie die Änderungen der Sensorwerte während der Projektausführung beobachten.

Geben Sie jeden Sensorwert als Zeichenkette an.

Usage:
monitor_sensor(“sensor”)
monitor_sensor(“sensor1”, “sensor2”)

Parameter	Beschreibung
`sensor`	The sensor value to monitor, given as a string. To monitor more than one sensor value, separate each sensor value with a comma. Supported sensor identifiers include: Brain `brain.timer.time` Drivetrain `drivetrain.is_done` `drivetrain.is_moving` `drivetrain.heading` `drivetrain.rotation` `drivetrain.velocity_rpm` `drivetrain.velocity_percent` Arm Motor `arm_motor.is_done` `arm_motor.is_spinning` `arm_motor.position_degrees` `arm_motor.position_turns` `arm_motor.velocity_rpm` `arm_motor.velocity_percent` Arm Motor Group `arm_motor_group.is_done` `arm_motor_group.is_spinning` `arm_motor_group.position_degrees` `arm_motor_group.position_turns` `arm_motor_group.velocity_rpm` `arm_motor_group.velocity_percent` Intake Motor `intake_motor.is_done` `intake_motor.is_spinning` `intake_motor.position_degrees` `intake_motor.position_turns` `intake_motor.velocity_rpm` `intake_motor.velocity_percent` Intake Motor Group `intake_motor_group.is_done` `intake_motor_group.is_spinning` `intake_motor_group.position_degrees` `intake_motor_group.position_turns` `intake_motor_group.velocity_rpm` `intake_motor_group.velocity_percent` Catapult Motor `catapult_motor.is_done` `catapult_motor.is_spinning` `catapult_motor.position_degrees` `catapult_motor.position_turns` `catapult_motor.velocity_rpm` `catapult_motor.velocity_percent` Catapult Tension Motor `catapult_tension_motor.is_done` `catapult_tension_motor.is_spinning` `catapult_tension_motor.position_degrees` `catapult_tension_motor.position_turns` `catapult_tension_motor.velocity_rpm` `catapult_tension_motor.velocity_percent` Bumpers `intake_bumper.pressing` `bumper.pressing` Front Distance Sensor `front_distance.is_object_detected` `front_distance.object_distance_mm` `front_distance.object_distance_inches` Front Optical Sensor `front_optical.is_near_object` `front_optical.color` `front_optical.brightness` `front_optical.hue` Color Sensor `color.is_near_object` `color.color` `color.brightness` `color.hue`

Parameter

Beschreibung

sensor

The sensor value to monitor, given as a string. To monitor more than one sensor value, separate each sensor value with a comma. Supported sensor identifiers include:

Brain
- brain.timer.time
Drivetrain
- drivetrain.is_done
- drivetrain.is_moving
- drivetrain.heading
- drivetrain.rotation
- drivetrain.velocity_rpm
- drivetrain.velocity_percent
Arm Motor
- arm_motor.is_done
- arm_motor.is_spinning
- arm_motor.position_degrees
- arm_motor.position_turns
- arm_motor.velocity_rpm
- arm_motor.velocity_percent
Arm Motor Group
- arm_motor_group.is_done
- arm_motor_group.is_spinning
- arm_motor_group.position_degrees
- arm_motor_group.position_turns
- arm_motor_group.velocity_rpm
- arm_motor_group.velocity_percent
Intake Motor
- intake_motor.is_done
- intake_motor.is_spinning
- intake_motor.position_degrees
- intake_motor.position_turns
- intake_motor.velocity_rpm
- intake_motor.velocity_percent
Intake Motor Group
- intake_motor_group.is_done
- intake_motor_group.is_spinning
- intake_motor_group.position_degrees
- intake_motor_group.position_turns
- intake_motor_group.velocity_rpm
- intake_motor_group.velocity_percent
Catapult Motor
- catapult_motor.is_done
- catapult_motor.is_spinning
- catapult_motor.position_degrees
- catapult_motor.position_turns
- catapult_motor.velocity_rpm
- catapult_motor.velocity_percent
Catapult Tension Motor
- catapult_tension_motor.is_done
- catapult_tension_motor.is_spinning
- catapult_tension_motor.position_degrees
- catapult_tension_motor.position_turns
- catapult_tension_motor.velocity_rpm
- catapult_tension_motor.velocity_percent
Bumpers
- intake_bumper.pressing
- bumper.pressing
Front Distance Sensor
- front_distance.is_object_detected
- front_distance.object_distance_mm
- front_distance.object_distance_inches
Front Optical Sensor
- front_optical.is_near_object
- front_optical.color
- front_optical.brightness
- front_optical.hue
Color Sensor
- color.is_near_object
- color.color
- color.brightness
- color.hue

def main():
    # Monitor the robot's heading
    monitor_sensor("drivetrain.heading")
    drivetrain.turn_for(RIGHT, 450, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Sensorik #

Optische #

is_near_object #

is_near_object gibt einen booleschen Wert zurück, der angibt, ob der optische Sensor ein Objekt in Reichweite erkennt oder nicht.

True – Der optische Sensor erkennt ein Objekt.
False – Der optische Sensor erkennt kein Objekt.

Usage:
optical.is_near_object()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

Farbe #

Die Methode color gibt eine Instanz der Klasse ` Color basierend auf dem ermittelten Farbtonwert zurück. Diese können mit vordefinierten Objekten der Klasse Color verglichen werden, um bedingte Anweisungen zu erstellen.

Mögliche Farben sind:

NONE
RED - Ein Farbtonwert zwischen 340° und 20°
GREEN - Ein Farbtonwert zwischen 80° und 140°
BLUE - Ein Farbtonwert zwischen 200° und 240°
YELLOW - Ein Farbtonwert zwischen 40° und 60°
ORANGE - Ein Farbtonwert zwischen 20° und 40°
PURPLE - Ein Farbtonwert zwischen 240° und 280°
CYAN - Ein Farbtonwert zwischen 140° und 200°

Hinweis: Der optische Sensor sucht nach Farbtonbereichen, die der angegebenen Farbe entsprechen. Informationen zur Erkennung spezifischer Farbtonbereiche finden Sie unter hue.

Usage:
optical.color()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

Helligkeit #

brightness gibt die Menge des vom Objekt reflektierten Lichts als Dezimalzahl (float) zurück, die einen Prozentwert darstellt.

Ein höherer Prozentsatz bedeutet, dass mehr Licht zum optischen Sensor zurückreflektiert wird. Ein niedrigerer Prozentsatz bedeutet, dass weniger Licht zurückreflektiert wird.

Usage:
optical.brightness()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

Farbton #

hue gibt den Farbtonwert der erkannten Farbe als Dezimalzahl (float) von 0 bis 359 zurück.

Der Farbton ist eine Methode, Farben mithilfe von Zahlen auf einem Farbkreis zu beschreiben.

Ein kreisförmiges Farbrad, das ein vollständiges Farbspektrum anzeigt, wobei die Gradwerte am Rand in 30-Grad-Schritten von 0° oben bis 360° ansteigen.

Usage:
optical.hue()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

Objekt_erkannt #

object_detected registriert eine Funktion, die aufgerufen wird, sobald der optische Sensor ein neues Objekt erkennt.

Usage:
optical.object_detected(callback, arg)

Parameter	Beschreibung
`callback`	Eine zuvor definierte Funktion, die ausgeführt wird, wenn der optische Sensor ein neues Objekt erkennt.
`arg`	Optional. Ein Tupel mit Argumenten, die an die Callback-Funktion übergeben werden sollen. Weitere Informationen finden Sie unter Verwendung von Funktionen mit Parametern.

Objekt verloren #

object_lost registriert eine Funktion, die aufgerufen wird, wenn der optische Sensor ein erkanntes Objekt verliert.

Usage:
optical.object_lost(callback, arg)

Parameter	Beschreibung
`callback`	Eine zuvor definierte Funktion, die ausgeführt wird, wenn der optische Sensor ein erkanntes Objekt verliert.
`arg`	Optional. Ein Tupel mit Argumenten, die an die Callback-Funktion übergeben werden sollen. Weitere Informationen finden Sie unter Verwendung von Funktionen mit Parametern.