SerialLink#

Einführung #

SerialLink ermöglicht die Kommunikation zwischen zwei EXP Brains durch den Austausch von seriellen Rohdaten über VEX Link. Anstelle von beschrifteten Nachrichten überträgt SerialLink einen Puffer (eine Zeichenkette oder ein Byte-Array). Dies macht es nützlich für die fortgeschrittene Roboter-zu-Roboter-Kommunikation, beispielsweise für das Streaming von Sensordaten, das Senden benutzerdefinierter Paketformate oder die Entwicklung eigener Protokolle auf Byte-Basis.

Jede Verwendung von send fügt Daten zum Empfangspuffer des verbundenen EXP Brain hinzu. Die Daten werden in der Reihenfolge ihres Eintreffens gelesen (FIFO). Werden mehrere Puffer gesendet, bevor das andere EXP Brain receive verwendet, bleiben sie in der Warteschlange und werden nacheinander in Sendereihenfolge zurückgesendet. Da Daten in einer Warteschlange landen können, kann das wiederholte Senden großer Puffer in jeder Schleife zu einem Datenstau führen. Senden Sie daher bei zeitkritischen Verbindungen nur die benötigten Daten.

Wichtig: Auf beiden Robotern müssen gleichzeitig Projekte ausgeführt werden, die SerialLink verwenden, sonst werden keine Daten gesendet/empfangen.

Diese Seite verwendet link als Beispielnamen für „ SerialLink . Ersetzen Sie ihn bei Bedarf durch Ihren eigenen konfigurierten Namen.

Nachfolgend finden Sie eine Liste der verfügbaren Methoden:

is_linked – Gibt zurück, ob dieses Gehirn aktiv mit seinem gepaarten Gehirn verbunden ist.
send – Sendet eine kurze Nachricht (mit optionalen int/float Daten) an das gepaarte Brain.
receive – Wartet auf die nächste eingehende Nachricht und gibt sie zurück.
received – Registriert eine Funktion, die aufgerufen wird, sobald eine neue Nachricht empfangen wird.

Link erstellen #

Erstellen Sie auf beiden EXP Brains einen SerialLink, um einen Kommunikationskanal zwischen ihnen herzustellen – entweder drahtlos mit V5 Robot Radios oder über ein kabelgebundenes Smart Cable –, damit die Roboter sich gegenseitig serielle Rohdaten senden können.

SerialLink(smartport, name, linktype, wired)

Parameter	Beschreibung
`smartport`	Der für diese Verbindung verwendete Smart Port – der Port, an den das V5 Robot Radio (drahtlos) oder das Smart Cable (kabelgebunden) angeschlossen ist. Er wird als `Ports.PORTx` geschrieben, wobei x die Portnummer ist.
`name`	Der eindeutige Name für diesen Link als Zeichenkette. Hinweis: Dieser Name sollte lang genug sein, um eine eindeutige ID zu erzeugen, damit er nicht versehentlich mit dem Link eines anderen Teams übereinstimmt.
`linktype`	Die Rolle, die dieses Brain für dieses Linkpaar verwendet. Jedes Paar muss einen Manager und einen Worker enthalten: `VexlinkType.MANAGER` – Für den Roboter verwenden, der mehr oder größere Nachrichten sendet. Manager haben eine höhere ausgehende Bandbreite (~1040 Byte/Sek.). `VexlinkType.WORKER` – Für den Roboter verwenden, der weniger oder kleinere Nachrichten sendet. Worker haben eine geringere ausgehende Bandbreite (~520 Byte/Sek.).
`wired`	Optional. Ob diese Verbindung kabelgebunden oder drahtlos ist: `True` – Die EXP Brains sind über ein Smart Cable verbunden. `False` (Standard) – Die EXP Brains verbinden sich drahtlos über V5 Robot Radios.

Code für Roboter 1

"""
Create a wireless link in Port 1
name: VEXRoboticsLink123456789
linktype: Manager
"""
link = SerialLink(Ports.PORT1, "VEXRoboticsLink123456789", VexlinkType.MANAGER)

Code für Roboter 2

"""
Create a wireless link in Port 1
name: VEXRoboticsLink123456789
linktype: Worker
"""
link = SerialLink(Ports.PORT1, "VEXRoboticsLink123456789", VexlinkType.WORKER)

Verfügbare Methoden #

Sobald SerialLink eingerichtet und die Brains verbunden sind, können Sie die folgenden Methoden verwenden, um serielle Rohdaten zu senden, zu empfangen und darauf zu antworten.

is_linked #

Die Methode is_linked gibt zurück, ob die EXP Brains auf einem SerialLink miteinander gepaart sind.

True – Die beiden EXP Brains sind gepaart und kommunizieren über diese Verbindung.
False – Die beiden EXP Brains sind über diese Verbindung nicht gekoppelt.

Hinweis: Es empfiehlt sich, zu Beginn eines Projekts immer zu überprüfen, ob die EXP Brains verknüpft sind, bevor weiterer Code ausgeführt wird.

Usage:
link.is_linked()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

Code für Roboter 1

# Send a message to the other robot

# Create the link
link = SerialLink(Ports.PORT1, "VEXRoboticsLink123456789", VexlinkType.MANAGER)

# Do not run code UNTIL the Brains are linked
while not link.is_linked():
    wait(0.1, SECONDS)

brain.screen.print("Robot 1 - Manager")

link.send("HELLO")

Code für Roboter 2

# Display the message that Robot 1 sends

# Create the link
link = SerialLink(Ports.PORT1, "VEXRoboticsLink123456789", VexlinkType.WORKER)

# Do not run code UNTIL the Brains are linked
while not link.is_linked():
    wait(0.1, SECONDS)

brain.screen.print("Robot 2 - Worker")
brain.screen.next_row()

def received_message(bytearray, length):
    # Slice the bytearray to the valid data
    data = bytearray[:length]  
    # Decode and strip the message before displaying it
    text = data.decode().strip()
    brain.screen.print("Got: ", text)

# Call received_message whenever a message is received
link.received(received_message)

send #

send überträgt rohe serielle Bytes an das andere verbundene EXP Brain.

When reading that data with receive, receive will only return once it has collected the number of bytes specified by its length parameter. Because of that, if your code always calls receive with a fixed length, you should ensure each message sent with send is exactly that many bytes (often by padding) so the receiver doesn’t block waiting for additional bytes.

Wenn Sie nicht von einer genauen Byteanzahl abhängig sein möchten, verwenden Sie stattdessen received; damit können Sie alle verfügbaren Bytes verarbeiten, ohne eine bestimmte Länge zu benötigen.

Usage:
send(buffer)

Parameter	Beschreibung
`buffer`	Die Daten, die an das andere verbundene EXP Brain gesendet werden sollen. Dies kann eine Zeichenkette `string` oder ein Byte-Array ( `bytearray` sein.

Code für Roboter 1

# Send a message to the other robot

# Create the link
link = SerialLink(Ports.PORT1, "VEXRoboticsLink123456789", VexlinkType.MANAGER)

# Do not run code UNTIL the Brains are linked
while not link.is_linked():
    wait(0.1, SECONDS)

brain.screen.print("Robot 1 - Manager")

link.send("HELLO")

Code für Roboter 2

# Display the message that Robot 1 sends

# Create the link
link = SerialLink(Ports.PORT1, "VEXRoboticsLink123456789", VexlinkType.WORKER)

# Do not run code UNTIL the Brains are linked
while not link.is_linked():
    wait(0.1, SECONDS)

brain.screen.print("Robot 2 - Worker")
brain.screen.next_row()

def received_message(bytearray, length):
    # Slice the bytearray to the valid data
    data = bytearray[:length]  
    # Decode and strip the message before displaying it
    text = data.decode().strip()
    brain.screen.print("Got: ", text)

# Call received_message whenever a message is received
link.received(received_message)

receive #

receive gibt serielle Daten vom anderen verbundenen EXP Brain in FIFO-Reihenfolge zurück (älteste ungelesene Daten zuerst).

Because receive waits for an exact byte count, fixed-length messaging often requires padding when using send so each message reaches the expected size. If the sender transmits fewer than length bytes, receive will continue waiting for the remaining bytes and not return anything.

If the queue is empty and you provide a timeout, receive waits up to that many milliseconds for new data. If nothing arrives in that window, it returns None. Any data sent afterward remains queued to be read later.

Usage:
receive(length, timeout)

Parameter	Beschreibung
`length`	Die Anzahl der zu empfangenden Bytes. `receive` wartet, bis diese Anzahl an Bytes eingetroffen ist, und gibt sie dann als `bytearray`zurück. Wenn `length` gleich `0`ist, `receive` gibt `None` sofort zurück. Wenn Sie mehr Bytes anfordern, als der Sender sendet, `receive` wartet 14 receive 15 weiter. Wenn der Sender mehr als diese Anzahl sendet, ist der zurückgegebene Puffer auf `length` Bytes begrenzt.
`timeout`	Optional. Wartezeit in Millisekunden `receive` Wartezeit auf neue Nachrichten nur bei leerer Warteschlange). Standardwert: 300000 (300 Sekunden).

Parameter

Beschreibung

length

Die Anzahl der zu empfangenden Bytes. receive wartet, bis diese Anzahl an Bytes eingetroffen ist, und gibt sie dann als bytearrayzurück. Wenn length gleich 0ist, receive gibt None sofort zurück. Wenn Sie mehr Bytes anfordern, als der Sender sendet, receive wartet 14 receive 15 weiter. Wenn der Sender mehr als diese Anzahl sendet, ist der zurückgegebene Puffer auf length Bytes begrenzt.

timeout

Optional. Wartezeit in Millisekunden receive Wartezeit auf neue Nachrichten nur bei leerer Warteschlange). Standardwert: 300000 (300 Sekunden).

Code für Roboter 1

# Send a math problem for the other Brain to solve

# Create the link
link = SerialLink(Ports.PORT1, "VEXRoboticsLink123456789", VexlinkType.MANAGER)

# Do not run code UNTIL the Brains are linked
while not link.is_linked():
    wait(0.1, SECONDS)

brain.screen.print("Robot 1 - Manager")

"""
Change whether to "add" or "subtract",
then what numbers to use in the operation.
"""
packet = "add,7,2.5"

# Pad with spaces until it's exactly 16 bytes
while len(packet) < 16:
    packet = packet + " "

link.send(packet)

Code für Roboter 2

# Solve the math problem that the other Brain sends

# Create the link
link = SerialLink(Ports.PORT1, "VEXRoboticsLink123456789", VexlinkType.WORKER)

# Do not run code UNTIL the Brains are linked
while not link.is_linked():
    wait(0.1, SECONDS)

brain.screen.print("Robot 2 - Worker")
brain.screen.next_row()

# Receive exactly 16 bytes
buffer = link.receive(16)

# Remove the added " " padding
text = buffer.decode().strip()

# Separate the operator and numbers
parts = text.split(",")

operator = parts[0]
a = float(parts[1])
b = float(parts[2])

# Use what operator was sent
if operator == "add":
    result = a + b
elif operator == "subtract":
    result = a - b
# If not "add" or "subtract", do nothing
else:
    pass

brain.screen.print("Result = ", result)

received #

received registriert eine Funktion, die aufgerufen werden soll, sobald das EXP Brain serielle Daten empfängt.

Usage:
link.received(callback)

Parameter	Beschreibung
`callback`	Eine zuvor definierte Funktion, die ausgeführt wird, wenn das EXP Brain serielle Daten empfängt.

received Rückruffunktion wird mit zwei Argumenten aufgerufen:

Callback-Signatur:
callback(buffer, length)

Argument	Beschreibung
`buffer`	Ein `bytearray` das die empfangenen seriellen Daten enthält. Das Byte-Array kann größer als die empfangene Nachricht sein.
`length`	Die Anzahl der gültigen Bytes, die in `buffer` für diesen Rückruf empfangen wurden. Verwenden Sie `buffer[:length]` um auf die empfangenen Daten zuzugreifen.

Code für Roboter 1

# Send a message to the other robot

# Create the link
link = SerialLink(Ports.PORT1, "VEXRoboticsLink123456789", VexlinkType.MANAGER)

# Do not run code UNTIL the Brains are linked
while not link.is_linked():
    wait(0.1, SECONDS)

brain.screen.print("Robot 1 - Manager")

link.send("HELLO")

Code für Roboter 2

# Display the message that Robot 1 sends

# Create the link
link = SerialLink(Ports.PORT1, "VEXRoboticsLink123456789", VexlinkType.WORKER)

# Do not run code UNTIL the Brains are linked
while not link.is_linked():
    wait(0.1, SECONDS)

brain.screen.print("Robot 2 - Worker")
brain.screen.next_row()

def received_message(bytearray, length):
    # Slice the bytearray to the valid data
    data = bytearray[:length]  
    # Decode and strip the message before displaying it
    text = data.decode().strip()
    brain.screen.print("Got: ", text)

# Call received_message whenever a message is received
link.received(received_message)

SerialLink#

Einführung#

Link erstellen#

Verfügbare Methoden#

is_linked#

send#

receive#

received#

Einführung #

Link erstellen #

Verfügbare Methoden #

is_linked #

send #

receive #

received #