Enlace serial#

Introducción #

SerialLink permite que dos V5 Brains se comuniquen enviando y recibiendo datos seriales sin procesar a través de VEX Link. En lugar de mensajes etiquetados, SerialLink transmite un búfer (una cadena o una matriz de bytes). Esto lo hace útil para la comunicación avanzada entre robots, como la transmisión de datos de sensores, el envío de formatos de paquetes personalizados o la creación de un protocolo propio basado en bytes.

Every usage of send adds data to the linked V5 Brain’s receive buffer. Data is read in the order it arrives (first-in, first-out). If multiple buffers are sent before the other V5 Brain uses receive, they remain queued and are returned one at a time in the order they were sent. Because data can queue, repeatedly sending large buffers every loop may create backlog; for time-critical links, send only what you need.

Important: Both robots must be running projects that use SerialLink at the same time, or no data will be sent/received.

This page uses link as the example SerialLink name. Replace it with your own configured name as needed.

A continuación se muestra una lista de los métodos disponibles:

is_linked – Returns whether this Brain is actively connected to its paired Brain.
send – Sends a short message (with optional int/float data) to the paired Brain.
receive – Waits for and returns the next incoming message.
received – Registers a function to be called whenever a new message is received.

Crear un enlace #

Crea un SerialLink en ambos V5 Brains para establecer un canal de comunicación entre ellos, ya sea de forma inalámbrica con las radios de robot V5 o mediante un cable inteligente, de modo que los robots puedan enviarse datos seriales sin procesar.

SerialLink(smartport, name, linktype, wired)

Parámetro	Descripción
`smartport`	The Smart Port used for this link—the port the V5 Robot Radio is connected to (wireless) or the Smart Cable is plugged into (wired). Written as `Ports.PORTx` where x is the port number.
`name`	El nombre único que se le dará a este enlace como una cadena. Nota: Este nombre debe ser lo suficientemente largo para crear una identificación única para que no coincida accidentalmente con el enlace de otro equipo.
`linktype`	The role this Brain will use for this link pair. Each pair must include one Manager and one Worker: `VexlinkType.MANAGER` – Use for the robot that will send more or larger messages. Managers have higher outbound bandwidth (~1040 bytes/sec). `VexlinkType.WORKER` – Use for the robot that will send fewer or smaller messages. Workers have lower outbound bandwidth (~520 bytes/sec).
`wired`	Optional. Whether this link is wired or wireless: `True` – The V5 Brains are connected via a Smart Cable. `False` (default) – The V5 Brains connect wirelessly using V5 RObot Radios.

Código para el Robot 1

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

Código para el Robot 2

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

Métodos disponibles #

Una vez configurado SerialLink y conectados los módulos Brains, puede utilizar los métodos que se describen a continuación para enviar, recibir y responder a datos seriales sin procesar.

is_linked #

is_linked method returns whether the V5 Brains on a SerialLink are paired with one another.

True – The two V5 Brains are paired and communicating on this link.
False – The two V5 Brains are not paired on this link.

Nota: Es recomendable comprobar siempre que los V5 Brains estén conectados al inicio de un proyecto antes de ejecutar cualquier otro código.

Usage:
link.is_linked()

Parámetros	Descripción
	Este método no tiene parámetros.

Código para el Robot 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")

Código para el Robot 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 transmits raw serial bytes to the other linked V5 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.

If you don’t want to depend on an exact byte count, use received instead; it lets you handle whatever bytes are available without requiring a specific length.

Usage:
send(buffer)

Parámetros	Descripción
`buffer`	The data to send to the other linked V5 Brain. This can be a `string` or a `bytearray`.

Código para el Robot 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")

Código para el Robot 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 returns serial data from the other linked V5 Brain in FIFO order (oldest unread data first).

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)

Parámetros	Descripción
`length`	The number of bytes to receive. `receive` waits until this many bytes have arrived, then returns them as a `bytearray`. If `length` is `0`, `receive` returns `None` immediately. If you request more bytes than the sender transmits, `receive` will keep waiting. If the sender transmits more than this, the returned buffer is limited to `length` bytes.
`timeout`	Optional. How long in milliseconds `receive` will wait for a new message only if the queue is empty. Default is 300000 (300 seconds).

Código para el Robot 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)

Código para el Robot 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 registers a function to be called whenever the V5 Brain receives serial data.

Usage:
link.received(callback)

Parámetros	Descripción
`callback`	Una función definida previamente que se ejecuta cuando el cerebro V5 recibe datos seriales.

received callbacks are called with two arguments:

Callback Signature:
callback(buffer, length)

Argumento	Descripción
`buffer`	A `bytearray` containing the received serial data. The bytearray may be larger than the received message.
`length`	The number of valid bytes received in `buffer` for this callback. Use `buffer[:length]` to access the received data.

Código para el Robot 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")

Código para el Robot 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)

Enlace serial#

Introducción#

Crear un enlace#

Métodos disponibles#

is_linked#

send#

receive#

received#

Introducción #

Crear un enlace #

Métodos disponibles #

is_linked #

send #

receive #

received #