Roboterspezifisches Python#

Einführung #

Der Hero Bot, Axel, verfügt über zwei Motoroptionen, einen KI-Vision-Sensor, einen optischen Sensor, einen Rotationssensor und einen Game Positioning System (GPS)-Sensor.

Alle Standard-VEXcode-VR-Methoden stehen im V5 24-25 High Stakes 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 Motoren des Roboters bewegen und verfolgen.

Aktionen
- spin — Lässt einen Motor unendlich lange vorwärts oder rückwärts laufen.
- spin_for — Lässt einen Motor eine bestimmte Strecke drehen.
- spin_to_position — Dreht einen Motor in eine bestimmte Position.
- stop — Stoppt den Motor.
Mutatoren
- set_position — Ändert die aktuelle Position des Motors auf einen neuen Wert.
- set_velocity — Gibt dem Motor die Drehzahl vor.
- set_timeout — Legt fest, wie lange ein Motor versucht, eine Bewegung abzuschließen.
Getter
- is_done — Gibt als booleschen Wert zurück, ob der Motor seine Bewegung beendet hat.
- is_spinning — Gibt als booleschen Wert zurück, ob sich der Motor dreht.
- position — Gibt die aktuelle Position des Motors zurück.
- velocity — Gibt die Drehzahl des Motors zurück.

KI-Vision – Objekte mithilfe des KI-Vision-Sensors erfassen und analysieren.

Getter
- take_snapshot – Gibt ein Tupel erkannter Objekte für eine bestimmte Signatur zurück.
Eigenschaften
- width – Breite des erkannten Objekts in Pixeln.
- height – Höhe des erkannten Objekts in Pixeln.
- centerX – X-Position des Objektmittelpunkts in Pixeln.
- centerY – Y-Position des Objektmittelpunkts in Pixeln.
- originX – X-Position der oberen linken Ecke des Objekts in Pixeln.
- originY – Y-Position der oberen linken Ecke des Objekts in Pixeln.
- id – Klassifizierung oder Tag-ID des Objekts.

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.
Drehung
- set_position – Setzt die aktuelle Position des Rotationssensors auf einen bestimmten Wert.
- angle – Gibt den aktuellen Winkel des Sensors zwischen 0 und 359,99 Grad zurück.
- position – Gibt die gesamte Rotationsposition in Grad oder Umdrehungen zurück.
GPS
- x_position – Gibt die aktuelle x-Koordinate eines GPS-Sensors auf dem Feld zurück.
- y_position – Gibt die aktuelle y-Koordinate eines GPS-Sensors auf dem Feld zurück.
- heading – Gibt die Richtung zurück, in die der Roboter aktuell zeigt, basierend auf den Messwerten des GPS-Sensors von 0 bis 359 Grad.

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 Drehung 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 Bewegung 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`	The velocity to drive with from 0% to 100%. This can be an `integer` or decimal (`float`).
`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 #

Axel nutzt den Armmotor, um den Arm anzuheben und abzusenken, damit die Ringe in der Nähe von Pfählen positioniert werden können. Der Schiebermotor bewegt den Schieber am Arm entlang nach unten, um die Ringe vom Arm auf einen Pfahl zu drücken.

Jeder Motor hat sein eigenes Richtungsverhalten. Die Richtungsbeschreibungen erklären, wie sich der jeweilige Motor auf der Achse in die entsprechende Richtung bewegt.

Aktionen #

drehen #

spin lässt ihn endlos vorwärts oder rückwärts laufen. Der Motor dreht sich so lange, bis er eine andere Aktion erhält, z. B. die Drehrichtung ändert oder anhält.

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

Motor	Befehl
`arm_motor`	`arm_motor.spin(direction)` — Armmotor
`pusher_motor`	`pusher_motor.spin(direction)` — Schubmotor

Parameter

Beschreibung

direction

Die Drehrichtung des Motors:

FORWARD — Dreht den Arm nach oben oder bewegt den Schieber am Arm nach unten.
REVERSE — Dreht den Arm nach unten oder bewegt den Schieber am Arm nach oben.

def main():
    # Lift the Arm up before moving
    arm_motor.spin(FORWARD)
    wait(1, SECONDS)
    arm_motor.stop()

# VR threads — Do not delete
vr_thread(main)

spin_for #

Der Befehl spin_for lässt einen Motor eine bestimmte Strecke drehen. Die Drehung bezieht sich auf die aktuelle Position des Motors. Das Projekt wartet, bis der Motor seine Drehung beendet hat, bevor die nächste Codezeile ausgeführt wird.

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

Motor	Befehl
`arm_motor`	`arm_motor.spin_for(direction, distance, units, wait)` — Armmotor
`pusher_motor`	`pusher_motor.spin_for(direction, distance, units, wait)` — Schiebermotor

Parameter	Beschreibung
`direction`	Die Drehrichtung des Motors: `FORWARD` — Dreht den Arm nach oben oder bewegt den Schieber am Arm nach unten. `REVERSE` — Dreht den Arm nach unten oder bewegt den Schieber am Arm nach oben.
`distance`	Die Strecke, die der Motor zurücklegt. `DEGREES` Ganze Zahlen verwenden. `TURNS` Ganze oder Dezimalzahlen verwenden.
`units`	Optional. Die Entfernungseinheit: `DEGREES` (Standard) oder `TURNS`.
`wait`	Optional. `wait=True` (Standard) – Das Projekt wartet, bis der Motor seine Drehung beendet hat, bevor die nächste Codezeile ausgeführt wird. `wait=False` – Die nächste Codezeile wird sofort ausgeführt.

def main():
    # Lift the Arm up before moving
    arm_motor.spin_for(FORWARD, 400, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Drehen in Position #

spin_to_position dreht einen Motor in eine bestimmte Position.

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

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

Wenn der Motor beispielsweise bei 0 Grad startet und sich bis zu einer Position von 720 Grad dreht, dreht er sich zwei Umdrehungen vorwärts. Dreht er sich anschließend bis zu einer Position von 360 Grad, dreht er sich eine Umdrehung rückwärts, da 360 kleiner als 720 ist.

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

Motor	Befehl
`arm_motor`	`arm_motor.spin_to_position(angle, units, wait=True)` — Armmotor
`pusher_motor`	`pusher_motor.spin_to_position(angle, units, wait=True)` — Schubmotor

Parameter	Beschreibung
`angle`	Der Positionswert, bis zu dem sich der Motor 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 der Motor seine 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 der Motor 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 der Motor seine Drehung beendet hat, bevor die nächste Codezeile ausgeführt wird.
wait=False – Die nächste Codezeile wird sofort ausgeführt.

def main():
    # Lift the Arm up before moving
    arm_motor.spin_to_position(400, DEGREES)

# VR threads — Do not delete
vr_thread(main)

stoppen #

stop stoppt den Motor.

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

Motor	Befehl
`arm_motor`	`arm_motor.stop()` — Armmotor
`pusher_motor`	`pusher_motor.stop()` — Schiebermotor

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

def main():
    # Lift the Arm up before moving
    arm_motor.spin(FORWARD)
    wait(1, SECONDS)
    arm_motor.stop()

# VR threads — Do not delete
vr_thread(main)

Mutatoren #

Position festlegen #

Die Position eines Motors entspricht seiner Drehung, gemessen in DEGREES oder TURNS. Eine Umdrehung entspricht 360 Grad. set_position wird die aktuelle Position des Motors auf einen neuen Wert geändert.

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

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

Motor	Befehl
`arm_motor`	`arm_motor.set_position(position, units)` — Armmotor
`pusher_motor`	`pusher_motor.set_position(position, units)` — Schiebermotor

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

def main():
    # Make the raised Arm as the new 0 degrees position
    arm_motor.spin_to_position(400, DEGREES)
    arm_motor.set_position(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_velocity #

Der Wert set_velocity gibt die Drehzahl des Motors an. Ein höherer Prozentwert beschleunigt die Drehung, ein niedrigerer Prozentwert verlangsamt sie.

Jedes Projekt beginnt standardmäßig damit, dass jeder Motor mit 50 % Drehzahl läuft.

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

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

Motor	Befehl
`arm_motor`	`arm_motor.set_velocity(velocity, units)` — Armmotor
`pusher_motor`	`pusher_motor.set_velocity(velocity, units)` — Schubmotor

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():
    # Lift the Arm up before moving
    arm_motor.set_velocity(100, PERCENT)
    arm_motor.spin_to_position(400, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_timeout #

set_timeout wird festgelegt, wie lange ein Motor versucht, eine Bewegung abzuschließen. Schafft er es nicht, die Bewegung innerhalb dieser Zeit zu beenden, bricht er den Versuch ab und fährt mit der nächsten Codezeile fort. Dadurch wird verhindert, dass der Motor bei einer Bewegung hängen bleibt.

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

Motor	Befehl
`arm_motor`	`arm_motor.set_timeout(value, units)` — Armmotor
`pusher_motor`	`pusher_motor.set_timeout(value, units)` — Schubmotor

Parameter	Beschreibung
`value`	Die Zeitspanne, in der der Motor 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():
    # Lift the Arm up before moving
    arm_motor.set_timeout(1, SECONDS)
    arm_motor.spin_for(FORWARD, 1080, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Getter #

ist_fertig #

Die Funktion is_done gibt als booleschen Wert zurück, ob der Motor seine Bewegung beendet hat is_done . Dieser Wert kann verwendet werden, um den Zeitpunkt anderer Aktionen basierend auf der Motorbewegung zu steuern.

True — Der Motor hat seine Bewegung beendet.
False — Der Motor dreht 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 Motorobjekten verwendet werden, wie unten dargestellt:

Motor	Befehl
`arm_motor`	`arm_motor.is_done()` — Armmotor
`pusher_motor`	`pusher_motor.is_done()` — Schubmotor

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

is_spinning #

is_spinning is_spinning gibt als booleschen Wert zurück, ob sich der Motor dreht. Dieser Wert kann verwendet werden, um den Zeitpunkt anderer Aktionen basierend auf der Motorbewegung zu steuern.

True — Der Motor dreht sich.
False — Der Motor 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 Motorobjekten verwendet werden, wie unten dargestellt:

Motor	Befehl
`arm_motor`	`arm_motor.is_spinning()` — Armmotor
`pusher_motor`	`pusher_motor.is_spinning()` — Schubmotor

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

Position #

Die Position eines Motors gibt an, wie weit er sich gedreht hat, gemessen in DEGREES oder TURNS. Eine Umdrehung entspricht 360 Grad. position gibt die aktuelle Position des Motors zurück.

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

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

Motor	Befehl
`arm_motor`	`arm_motor.position(units)` — Armmotor
`pusher_motor`	`pusher_motor.position(units)` — Schubmotor

Parameter	Beschreibung
`units`	Die Einheit, um die Motorposition in folgender Reihenfolge wiederherzustellen: `DEGREES` oder `TURNS`.

Geschwindigkeit #

velocity gibt an, wie schnell sich der Motor dreht.

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

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

Motor	Befehl
`arm_motor`	`arm_motor.velocity(units)` — Armmotor
`pusher_motor`	`pusher_motor.velocity(units)` — Schubmotor

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

KI-Vision #

Getter #

Schnappschuss aufnehmen #

take_snapshot filtert Daten aus dem AI Vision Sensor-Frame zu einer einzelnen Signatur – einer gespeicherten Beschreibung von etwas, das der Sensor erkennen kann, wie zum Beispiel ein Spielelement auf dem Spielfeld – und gibt ein Tupel zurück.

The tuple stores objects ordered from largest to smallest by width, starting at index 0. Each object’s properties can be accessed using its index. An empty tuple is returned if no matching objects are detected.

Usage:
ai_vision.take_snapshot(signature)

Parameter	Beschreibung
`signature`	Filtert den Datensatz, sodass nur Daten der angegebenen Signatur enthalten sind. Verfügbare Signaturen: `AiVision.ALL_AIOBJS` – Erkennt Mobile Goals, Red Rings und Blue Rings.

Parameter

Beschreibung

signature

Filtert den Datensatz, sodass nur Daten der angegebenen Signatur enthalten sind. Verfügbare Signaturen:

AiVision.ALL_AIOBJS – Erkennt Mobile Goals, Red Rings und Blue Rings.

def main():
    # Lift the Arm to not block the AI Vision Sensor's field of view
    arm_motor.spin_for(FORWARD, 350, DEGREES)
    while True:
        brain.screen.clear_screen()

        # Display the data of the largest detected Game Element
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

        if len(ai_objects) is not 0:
            brain.screen.print("Center X: ", ai_objects[0].centerX)
            brain.screen.next_row()

            brain.screen.print("Center Y: ", ai_objects[0].centerY)
            brain.screen.next_row()

        else:
            brain.screen.print("No object detected.")

        wait(0.2, SECONDS)

# VR threads — Do not delete
vr_thread(main)

Eigenschaften #

Es gibt sieben Eigenschaften, die zu jedem Objekt gehören, das nach der Verwendung von take_snapshot in einem Tupel gespeichert wird.

Alle Eigenschaftswerte außer .id beschreiben Position und Größe des erkannten Objekts im Sichtfeld des KI-Vision-Sensors zum Zeitpunkt der Verwendung take_snapshot Diese Werte werden in Pixeln gemessen, basierend auf der Auflösung des Sensors von 320 x 240 Pixeln.

.Breite #

.width gibt die Breite des erkannten Objekts in Pixeln zurück, eine ganze Zahl zwischen 1 und 320.

def main():
    # Lift the Arm to not block the AI Vision Sensor's view
    arm_motor.spin_for(FORWARD, 350, DEGREES)

    # Display the width of the largest Game Element
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

    if len(ai_objects) is not 0:
        brain.screen.print(ai_objects[0].width)

# VR threads — Do not delete
vr_thread(main)

.Höhe #

.height gibt die Höhe des erkannten Objekts in Pixeln zurück, eine ganze Zahl zwischen 1 und 240.

def main():
    # Lift the Arm to not block the AI Vision Sensor's view
    arm_motor.spin_for(FORWARD, 350, DEGREES)

    # Display the height of the largest Game Element
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

    if len(ai_objects) is not 0:
        brain.screen.print(ai_objects[0].height)

# VR threads — Do not delete
vr_thread(main)

.centerX #

.centerX gibt die x-Koordinate des Mittelpunkts des erkannten Objekts in Pixeln zurück, eine ganze Zahl zwischen 0 und 320.

def main():
    # Lift the Arm to not block the AI Vision Sensor's view
    arm_motor.spin_for(FORWARD, 350, DEGREES)

    # Display the centerX of the largest Game Element
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

    if len(ai_objects) is not 0:
        brain.screen.print(ai_objects[0].centerX)

# VR threads — Do not delete
vr_thread(main)

.centerY #

.centerY gibt die y-Koordinate des Mittelpunkts des erkannten Objekts in Pixeln zurück, eine ganze Zahl zwischen 0 und 240.

def main():
    # Lift the Arm to not block the AI Vision Sensor's view
    arm_motor.spin_for(FORWARD, 350, DEGREES)

    # Display the centerY of the largest Game Element
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

    if len(ai_objects) is not 0:
        brain.screen.print(ai_objects[0].centerY)

# VR threads — Do not delete
vr_thread(main)

.originX #

.originX gibt die x-Koordinate der oberen linken Ecke des Begrenzungsrahmens des erkannten Objekts in Pixeln zurück, eine ganze Zahl zwischen 0 und 320.

def main():
    # Lift the Arm to not block the AI Vision Sensor's view
    arm_motor.spin_for(FORWARD, 350, DEGREES)

    # Display the originX of the largest Game Element
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

    if len(ai_objects) is not 0:
        brain.screen.print(ai_objects[0].originX)

# VR threads — Do not delete
vr_thread(main)

.originY #

.originY gibt die y-Koordinate der oberen linken Ecke des Begrenzungsrahmens des erkannten Objekts in Pixeln zurück, eine ganze Zahl zwischen 0 und 240.

def main():
    # Lift the Arm to not block the AI Vision Sensor's view
    arm_motor.spin_for(FORWARD, 350, DEGREES)

    # Display the originY of the largest Game Element
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

    if len(ai_objects) is not 0:
        brain.screen.print(ai_objects[0].originY)

# VR threads — Do not delete
vr_thread(main)

.Ausweis #

.id gibt die ID der erkannten KI-Klassifizierung als ganze Zahl zurück.

KI-Klassifizierung	Ausweis	Unterschrift
MobileGoal	0	`GameElements.MOBILE_GOAL`
RedRing	1	`GameElements.RED_RING`
BlueRing	2	`GameElements.BLUE_RING`

def main():
    # Lift the Arm to not block the AI Vision Sensor's view
    arm_motor.spin_for(FORWARD, 350, DEGREES)

    # Display if a Mobile Goal is detected
    ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)

    if len(ai_objects) is not 0:

        if ai_objects[0].id == GameElements.MOBILE_GOAL:
            brain.screen.print("This is a Mobile Goal.")
        else:
            brain.screen.print("This is not a Mobile Goal.")

# VR threads — Do not delete
vr_thread(main)

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` Pusher Motor `pusher_motor.is_done` `pusher_motor.is_spinning` `pusher_motor.position` `pusher_motor.velocity` Arm Motor `arm_motor.is_done` `arm_motor.is_spinning` `arm_motor.position` `arm_motor.velocity` 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` GPS Sensor `gps.position_mm` `gps.position_inches` `gps.heading` Pusher Rotation Sensor `pusher_rotation.angle` `pusher_rotation.position` AI Vision Sensor `ai_vision.object_count` `ai_vision.height` `ai_vision.width` `ai_vision.centerX` `ai_vision.centerY` `ai_vision.originX` `ai_vision.originY` `ai_vision.id`

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
Pusher Motor
- pusher_motor.is_done
- pusher_motor.is_spinning
- pusher_motor.position
- pusher_motor.velocity
Arm Motor
- arm_motor.is_done
- arm_motor.is_spinning
- arm_motor.position
- arm_motor.velocity
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
GPS Sensor
- gps.position_mm
- gps.position_inches
- gps.heading
Pusher Rotation Sensor
- pusher_rotation.angle
- pusher_rotation.position
AI Vision Sensor
- ai_vision.object_count
- ai_vision.height
- ai_vision.width
- ai_vision.centerX
- ai_vision.centerY
- ai_vision.originX
- ai_vision.originY
- ai_vision.id

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:
front_optical.is_near_object()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

def main():
    # Display if the Optical Sensor is detecting an object
    brain.screen.print(front_optical.is_near_object())

# VR threads — Do not delete
vr_thread(main)

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:
front_optical.color()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

def main():
    # Display the color of the ring on the Arm
    brain.screen.print(front_optical.color())

# VR threads — Do not delete
vr_thread(main)

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:
front_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:
front_optical.hue()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

def main():
    # Display the hue of the ring on the Arm.
    brain.screen.print("Hue: ", optical.hue())

# VR threads — Do not delete
vr_thread(main)

Objekt_erkannt #

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

Usage:
front_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:
front_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.

Drehung #

Position festlegen #

set_position setzt die aktuelle Position des Rotationssensors auf einen Wert in Grad.

Usage:
pusher_rotation.set_position(position, units)

Parameter	Beschreibung
Position	Die Position, auf die der Rotationssensor eingestellt werden soll.
Einheiten	Optional. Positionseinheit:`DEGREES` (Standard) oder `TURNS`

Winkel #

angle gibt den aktuellen Winkel des Sensors als Gleitkommazahl zurück.

Usage:
pusher_rotation.angle(units)

Parameter

Beschreibung

Einheiten

Optional. Winkeleinheit:

DEGREES (Standard) – 0 bis 359,99
TURNS

Position #

position gibt die gesamte Rotationsposition zurück.

Usage:
pusher_rotation.position(units)

Parameter

Beschreibung

Einheiten

Optional. Positionseinheit:

DEGREES (Standard) – 0 bis 359 als Ganzzahl
TURNS – Als Gleitkommazahl

GPS #

x-Position #

x_position gibt die aktuelle x-Koordinate eines GPS-Sensors (Game Positioning System™) auf dem Spielfeld zurück.

Usage:
gps.x_position(units)

Parameter	Beschreibung
Einheiten	Die Einheit des Offset-Wertes: `INCHES` oder `MM`

y-Position #

y_position gibt die aktuelle y-Koordinate eines GPS-Sensors (Game Positioning System™) auf dem Spielfeld zurück.

Usage:
gps.y_position(units)

Parameter	Beschreibung
Einheiten	Die Einheit des Offset-Wertes: `INCHES` oder `MM`

Überschrift #

heading gibt die Richtung zurück, in die der Roboter aktuell zeigt, basierend auf den Messwerten des GPS-Sensors (Game Positioning System™) von 0 bis 359 Grad.

Usage:
gps.heading()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.