Roboterspezifisches Python#

Einführung #

Der Hero Bot Flex umfasst einen Greifermotor, einen Armmotor, einen KI-Vision-Sensor, einen Distanzsensor und einen Game Positioning System (GPS)-Sensor.

Alle Standard-VEXcode-VR-Methoden stehen im V5 26-27 Override 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 – Klassifizierungs-ID des erkannten 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.

Distanz
- found_object – Gibt zurück, ob der Distanzsensor ein Objekt innerhalb der Reichweite erkennt.
- object_distance – Gibt die Distanz zwischen dem Distanzsensor und dem nächstgelegenen erkannten Objekt zurück.
GPS
- x_position – Gibt die aktuelle x-Koordinate des GPS-Sensors auf dem Feld zurück.
- y_position – Gibt die aktuelle y-Koordinate des GPS-Sensors auf dem Feld zurück.
- heading – Gibt die Richtung zurück, in die der Roboter aktuell blickt, basierend auf dem GPS-Sensor.

Die Beispiele auf dieser Seite verwenden Startposition C aus der Checkliste vor dem Spiel des Spielplatzes.

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():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive(FORWARD)
    wait(0.5, SECONDS)
    drivetrain.stop()
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# 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():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# 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():
    # Score a Pin in a Neutral Goal
    drivetrain.turn(LEFT)
    wait(0.78, SECONDS)
    drivetrain.stop()
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# 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. Winkeleinheit: `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():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, 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.

Der Ausgangskurs beträgt 0 Grad.

Usage:
drivetrain.turn_to_heading(heading, units, wait)

Parameter	Beschreibung
`heading`	Die Richtung, in die der Roboter zeigen sollte, von -359 bis 359 Grad.
`units`	Optional. Winkeleinheit: `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():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_to_heading(-110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, 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. Eine Drehung nach rechts erhöht die Rotation, eine Drehung nach links verringert sie.

Wenn der Roboter beispielsweise bei 0 Grad startet und sich um 720 Grad dreht, dreht er sich zweimal nach rechts. Dreht er sich anschließend um 360 Grad, dreht er sich einmal nach links, da 360 kleiner als 720 ist.

Usage:
drivetrain.turn_to_rotation(rotation, units, wait)

Parameter	Beschreibung
`rotation`	Der Rotationswert in Grad, um den sich der Roboter drehen wird. Dies kann eine ganze Zahl `integer` ) oder eine Dezimalzahl (`float` ) sein.
`units`	Optional. Winkeleinheit: `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():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_to_rotation(-110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, 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():
    # Score a Pin in a Neutral Goal
    drivetrain.turn(LEFT)
    wait(0.78, SECONDS)
    drivetrain.stop()
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# 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.
`units`	Optional. Winkeleinheit: `DEGREES` ° (Standard).

def main():
    # Make facing the Neutral Goal the new heading
    drivetrain.set_heading(110, 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. Der Befehl set_rotation ändert die aktuelle Rotation des Roboters auf einen neuen Wert.

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. Winkeleinheit: `DEGREES` ° (Standard).

def main():
    # Make facing the Neutral Goal the new rotation
    drivetrain.set_rotation(110, DEGREES)
    drivetrain.turn_to_rotation(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_timeout #

set_timeout wird festgelegt, wie viele Sekunden 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(time, units)

Parameter	Beschreibung
`time`	Die Anzahl der Sekunden, die der Roboter versuchen kann, eine Bewegung abzuschließen. Dies kann eine positive ganze Zahl `integer` ) oder eine Dezimalzahl (`float` ) sein.
`units`	Optional. Die Zeiteinheit: `SECONDS` (Standard) oder `MSEC`.

def main():
    # Turn to face the Neutral Goal
    drivetrain.set_timeout(0.8, SECONDS)
    drivetrain.turn_for(LEFT, 180, DEGREES)

# 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():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.set_drive_velocity(100, PERCENT)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# 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 to face the Neutral Goal faster
    drivetrain.set_turn_velocity(100, PERCENT)
    drivetrain.turn_for(LEFT, 110, 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():
    # Turn to the Goal, then show heading
    drivetrain.turn_for(LEFT, 110, 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():
    # Spin to find a Pin, then show rotation
    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.

def main():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES, wait=False)
    wait(0.5, SECONDS)
    while not drivetrain.is_done():
        wait(5, MSEC)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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.

def main():
    # Raise the Arm once stopped near the Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES, wait=False)
    wait (0.5, SEC)
    while drivetrain.is_moving():
        wait(5, MSEC)
    arm_motor.spin_for(FORWARD, 800, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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

def main():
    # Show speed while driving to the Goal
    drivetrain.drive_for(FORWARD, 150, MM)
    brain.screen.print("Velocity: ")
    brain.screen.print(drivetrain.velocity(PERCENT))

# VR threads — Do not delete
vr_thread(main)

Bewegung #

Flex nutzt den Armmotor zum Heben und Senken des Arms und den Klauenmotor zum Öffnen und Schließen der Klaue.

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

Aktionen #

drehen #

spin und zwar endlos. Der Motor dreht sich so lange, bis er eine andere Aktion ausführt, 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
`claw_motor`	`claw_motor.spin(direction)` — Klauenmotor

Parameter

Beschreibung

direction

Die Drehrichtung des Motors:

FORWARD — Bewegt den Armmotor nach oben oder schließt den Greifermotor.
REVERSE — Bewegt den Armmotor nach unten oder öffnet den Greifermotor.

def main():
    # Raise the Arm before driving toward a Pin
    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
`claw_motor`	`claw_motor.spin_for(direction, distance, units, wait)` — Klauenmotor

Parameter	Beschreibung
`direction`	Die Drehrichtung des Motors: `FORWARD` — Bewegt den Armmotor nach oben oder schließt den Greifermotor. `REVERSE` — Bewegt den Armmotor nach unten oder öffnet den Greifermotor.
`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():
    # Raise the Arm to carry the Pin to the Goal
    arm_motor.spin_for(FORWARD, 800, 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 entspricht seiner Drehung, gemessen in DEGREES oder TURNS. Eine Umdrehung entspricht 360 Grad. Zu Beginn eines Projekts ist die Position des Armmotors auf 0 Grad eingestellt. Der Greifermotor bildet die Ausnahme – er startet bei 467 Grad (vollständig geschlossen). Die Motorposition kann auch mit der Methode set_position eingestellt 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
`claw_motor`	`claw_motor.spin_to_position(angle, units, wait=True)` — Klauenmotor

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():
    # Raise the Arm, then release the Pin
    arm_motor.spin_to_position(800, DEGREES)
    claw_motor.spin_for(REVERSE, 180, 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
`claw_motor`	`claw_motor.stop()` — Greifermotor

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

def main():
    # Raise the Arm partway to hold the Pin
    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
`claw_motor`	`claw_motor.set_position(position, units)` — Klauenmotor

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():
    # Reset encoder, raise Arm, place Pin
    arm_motor.set_position(0, DEGREES)
    arm_motor.spin_to_position(800, DEGREES)
    claw_motor.spin_for(REVERSE, 180, 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
`claw_motor`	`claw_motor.set_velocity(velocity, units)` — Klauenmotor

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():
    # Raise the Arm fast to release the Pin
    arm_motor.set_velocity(100, PERCENT)
    arm_motor.spin_for(FORWARD, 800, DEGREES)
    claw_motor.spin_for(REVERSE, 180, 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
`claw_motor`	`claw_motor.set_timeout(value, units)` — Klauenmotor

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():
    # Score a Pin in a Neutral Goal
    drivetrain.turn_for(LEFT, 110, DEGREES)
    arm_motor.set_timeout(1, SECONDS)
    arm_motor.spin_for(FORWARD, 1800, DEGREES)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    claw_motor.spin_for(REVERSE, 180, 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
`claw_motor`	`claw_motor.is_done()` — Klauenmotor

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

def main():
    # Raise the Arm while driving to the Goal
    arm_motor.spin_to_position(800, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while not arm_motor.is_done():
        drivetrain.drive(FORWARD)
        wait(5, MSEC)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

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
`claw_motor`	`claw_motor.is_spinning()` — Klauenmotor

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

def main():
    # Raise the Arm while driving to the Goal, then release the Pin
    arm_motor.spin_to_position(800, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while arm_motor.is_spinning():
        drivetrain.drive_for(FORWARD, 25, MM)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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 ist die Position des Armmotors auf 0 Grad eingestellt. Der Greifermotor bildet die Ausnahme – er startet bei 467 Grad (vollständig geschlossen). Dreht sich der Motor eine volle Umdrehung vorwärts, erhöht sich die Position. Dreht er sich in die andere Richtung, verringert sie sich.

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
`claw_motor`	`claw_motor.position(units)` — Klauenmotor

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

def main():
    # Raise the Arm, then release the Pin
    while arm_motor.position(DEGREES) < 800:
        arm_motor.spin(FORWARD)
        wait(2, MSEC)
    arm_motor.stop()
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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
`claw_motor`	`claw_motor.velocity(units)` — Klauenmotor

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

def main():
    # Show Arm Motor velocity while raising
    arm_motor.set_velocity(100, PERCENT)
    arm_motor.spin_to_position(800, DEGREES, wait=False)
    wait(0.2, SECONDS)
    brain.screen.print(arm_motor.velocity(PERCENT))

# VR threads — Do not delete
vr_thread(main)

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 alle Spielelemente. `GameElements.RED_BLUE_PIN` – Erkennt die Spielelemente „Rot-Blau-Pin“. `GameElements.BLUE_YELLOW_PIN` – Erkennt die Spielelemente „Blau-Gelb-Pin“. `GameElements.RED_YELLOW_PIN` – Erkennt die Spielelemente „Rot-Gelb-Pin“. `GameElements.YELLOW_PIN` – Erkennt die Spielelemente „Gelb-Pin“. `GameElements.CUP` – Erkennt die Spielelemente „Pokal“.

Parameter

Beschreibung

signature

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

AiVision.ALL_AIOBJS – Erkennt alle Spielelemente.
GameElements.RED_BLUE_PIN – Erkennt die Spielelemente „Rot-Blau-Pin“.
GameElements.BLUE_YELLOW_PIN – Erkennt die Spielelemente „Blau-Gelb-Pin“.
GameElements.RED_YELLOW_PIN – Erkennt die Spielelemente „Rot-Gelb-Pin“.
GameElements.YELLOW_PIN – Erkennt die Spielelemente „Gelb-Pin“.
GameElements.CUP – Erkennt die Spielelemente „Pokal“.

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Turn to face the Pin
    drivetrain.set_turn_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].centerX < 140:
                drivetrain.turn(LEFT)
            elif ai_objects[0].centerX > 180:
                drivetrain.turn(RIGHT)
            else:
                drivetrain.stop()
                break

# 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():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Approach the next Cup and Pin
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].width > 140:
                drivetrain.stop()
                break
            else:
                drivetrain.drive(FORWARD)

# 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():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Approach the next Cup and Pin
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].height > 200:
                drivetrain.stop()
                break
            else:
                drivetrain.drive(FORWARD)

# 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():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Turn and approach the next Cup and Pin
    drivetrain.set_turn_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].centerX < 140:
                drivetrain.turn_for(LEFT, 5, DEGREES)
            else: 
                drivetrain.drive_for(FORWARD, 25, INCHES)
                break

# 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():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Approach the next Cup and Pin
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].centerY > 230:
                drivetrain.stop()
                break
            else:
                drivetrain.drive(FORWARD)

# 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():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Turn and approach the next Cup and Pin
    drivetrain.set_turn_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].originX < 100:
                drivetrain.turn_for(LEFT, 5, DEGREES)
            else:
                drivetrain.drive_for(FORWARD, 25, INCHES)
                break

# 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():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Approach the next Cup and Pin
    drivetrain.set_drive_velocity(30, PERCENT)
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            if ai_objects[0].originY > 140:
                drivetrain.stop()
                break
            else:
                drivetrain.drive(FORWARD)

# 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
RedBluePin	0	`GameElements.RED_BLUE_PIN`
Blaugelbe Pin	1	`GameElements.BLUE_YELLOW_PIN`
Rotgelbe Pin	2	`GameElements.RED_YELLOW_PIN`
Gelbe Nadel	3	`GameElements.YELLOW_PIN`
Tasse	4	`GameElements.CUP`

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    drivetrain.turn_for(LEFT, 70, DEGREES)

    # Display the ID of the next closest object
    while True:
        ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
        if ai_objects:
            brain.screen.print(ai_objects[0].id)
            break

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

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)

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 number of loops
    global loops
    monitor_variable("loops")

    # Turn in a full circle 3 times
    for loops in range(12):
        drivetrain.turn_for(RIGHT, 90, DEGREES)

# 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`	Der zu überwachende Sensorwert wird als Zeichenkette angegeben. Um mehrere Sensorwerte zu überwachen, trennen Sie diese durch Kommas. Unterstützte Sensorkennungen: Gehirn `brain.timer.time` Antriebsstrang `drivetrain.is_done` `drivetrain.is_moving` `drivetrain.heading` `drivetrain.rotation` `drivetrain.velocity` Armmotor `arm_motor.is_done` `arm_motor.is_spinning` `arm_motor.position` `arm_motor.velocity` Klauenmotor `claw_motor.is_done` `claw_motor.is_spinning` `claw_motor.position` `claw_motor.velocity` Abstandssensor `distance.is_object_detected` `distance.object_distance_mm` `distance.object_distance_inches` GPS-Sensor `gps.position_mm` `gps.position_inches` `gps.heading` KI-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

Der zu überwachende Sensorwert wird als Zeichenkette angegeben. Um mehrere Sensorwerte zu überwachen, trennen Sie diese durch Kommas. Unterstützte Sensorkennungen:

Gehirn
- brain.timer.time
Antriebsstrang
- drivetrain.is_done
- drivetrain.is_moving
- drivetrain.heading
- drivetrain.rotation
- drivetrain.velocity
Armmotor
- arm_motor.is_done
- arm_motor.is_spinning
- arm_motor.position
- arm_motor.velocity
Klauenmotor
- claw_motor.is_done
- claw_motor.is_spinning
- claw_motor.position
- claw_motor.velocity
Abstandssensor
- distance.is_object_detected
- distance.object_distance_mm
- distance.object_distance_inches
GPS-Sensor
- gps.position_mm
- gps.position_inches
- gps.heading
KI-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 #

Distanz #

gefundenes Objekt #

found_object gibt zurück, ob der Distanzsensor aktuell ein Objekt innerhalb von 2000 mm erkennt.

True — Der Abstandssensor erkennt ein Objekt.
False — Der Abstandssensor erkennt kein Objekt.

Usage:
distance.found_object()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

def main():
    # Turn until something is detected, then release the Pin
    drivetrain.turn(RIGHT)
    while True:
        wait(5, MSEC)
        if distance.found_object():
            drivetrain.stop()
            break
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Objektdistanz #

object_distance gibt die Distanz zwischen dem Distanzsensor und dem nächstgelegenen erkannten Objekt zurück.

Usage:
distance.object_distance(units)

Parameter	Beschreibung
`units`	Die Entfernungseinheit: `MM` oder `INCHES`.

def main():
    # Drive until 200 mm from the Goal, then release the Pin
    while distance.object_distance(MM) > 200:
        wait(5, MSEC)
        drivetrain.drive(FORWARD)
    drivetrain.stop()
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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`

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive(FORWARD)
    while not gps.x_position(MM) > -1370:
        wait(2, MSEC)
    drivetrain.stop()
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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`

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive(FORWARD)
    while not gps.y_position(MM) < -450:
        wait(2, MSEC)
    drivetrain.stop()
    claw_motor.spin_for(REVERSE, 180, DEGREES)

# VR threads — Do not delete
vr_thread(main)

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

def main():
    # Raise the Arm, drive to the Goal, release the Pin
    monitor_sensor("gps.heading")
    arm_motor.spin_for(FORWARD, 300, DEGREES)
    drivetrain.drive_for(FORWARD, 10, INCHES)
    claw_motor.spin_for(REVERSE, 180, DEGREES)

    # Turn left to face the Neutral Goal
    drivetrain.set_turn_velocity(30, PERCENT)
    drivetrain.turn(LEFT)
    while not gps.heading() < 18:
        wait(2, MSEC)
    drivetrain.stop()


# VR threads — Do not delete
vr_thread(main)