Lien série#

Introduction #

SerialLink permet à deux EXP Brains de communiquer en envoyant et recevant des données série brutes via VEX Link. Au lieu de messages étiquetés, SerialLink transmet un tampon (une chaîne de caractères ou un tableau d’octets). Ceci s’avère utile pour les communications avancées entre robots, telles que la diffusion de données de capteurs, l’envoi de formats de paquets personnalisés ou la création de votre propre protocole basé sur les octets.

Chaque utilisation de send ajoute des données au tampon de réception du cerveau EXP lié. Les données sont lues dans l’ordre de leur arrivée (premier entré, premier sorti). Si plusieurs tampons sont envoyés avant que l’autre cerveau EXP n’utilise receive, ils restent en file d’attente et sont renvoyés un par un dans l’ordre de leur envoi. Étant donné que les données peuvent s’accumuler, l’envoi répété de tampons volumineux à chaque boucle peut créer un engorgement ; pour les liaisons critiques en termes de temps, n’envoyez que les données nécessaires.

Important : Les deux robots doivent exécuter simultanément des projets utilisant SerialLink , sinon aucune donnée ne sera envoyée/reçue.

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

Vous trouverez ci-dessous une liste des méthodes disponibles :

is_linked – Renvoie si ce cerveau est activement connecté à son cerveau apparié.
send – Envoie un court message (avec des données int/float optionnelles) au cerveau apparié.
receive – Attend et renvoie le prochain message entrant.
received – Enregistre une fonction à appeler chaque fois qu’un nouveau message est reçu.

Créer un lien #

Créez un SerialLink sur les deux EXP Brains pour établir un canal de communication entre eux, soit sans fil avec des radios robotiques V5, soit via un câble intelligent câblé, afin que les robots puissent s’envoyer des données série brutes.

SerialLink(smartport, name, linktype, wired)

Paramètre	Description
`smartport`	Le port intelligent utilisé pour cette liaison est celui auquel la radio du robot V5 est connectée (sans fil) ou celui auquel le câble intelligent est branché (avec fil). Il est indiqué sous la forme `Ports.PORTx` , où x représente le numéro du port.
`name`	The unique name to give this link as a string. Note: This name should be long enough to create a unique ID so it doesn’t accidentally match another team’s link.
`linktype`	Rôle attribué à cette paire de liens par le Cerveau. Chaque paire doit inclure un Gestionnaire et un Travailleur : `VexlinkType.MANAGER` – À utiliser pour le robot qui enverra des messages plus nombreux ou plus volumineux. Les Gestionnaires disposent d’une bande passante sortante plus élevée (environ 1 040 octets/s). `VexlinkType.WORKER` – À utiliser pour le robot qui enverra des messages moins nombreux ou plus courts. Les Travailleurs disposent d’une bande passante sortante plus faible (environ 520 octets/s).
`wired`	Facultatif. Indiquez si la connexion est filaire ou sans fil : `True` – Les EXP Brains sont connectés via un câble intelligent. `False` (par défaut) – Les EXP Brains se connectent sans fil à l’aide de radios robotiques V5.

Code pour le robot 1

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

Code pour Robot 2

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

Méthodes disponibles #

Une fois votre SerialLink configuré et les modules Brains connectés, vous pouvez utiliser les méthodes ci-dessous pour envoyer, recevoir et répondre à des données série brutes.

is_linked #

La méthode is_linked renvoie si les EXP Brains sur un SerialLink sont appariés entre eux.

True – Les deux cerveaux EXP sont appariés et communiquent via ce lien.
False – Les deux cerveaux EXP ne sont pas appariés sur ce lien.

Remarque : Il est recommandé de toujours vérifier que les EXP Brains sont bien liés au début d’un projet avant d’exécuter tout autre code.

Usage:
link.is_linked()

Paramètres	Description
	Cette méthode ne comporte aucun paramètre.

Code pour le 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")

Code pour 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 transmet des octets série bruts à l’autre EXP Brain lié.

Lors de la lecture de ces données avec receive, receive ne renverra une valeur qu’après avoir collecté le nombre d’octets spécifié par son paramètre length Par conséquent, si votre code appelle toujours receive avec une longueur length, vous devez vous assurer que chaque message envoyé avec send contient exactement ce nombre d’octets (souvent par remplissage) afin que le récepteur ne soit pas bloqué en attente d’octets supplémentaires.

Si vous ne voulez pas dépendre d’un nombre d’octets exact, utilisez plutôt received ; cela vous permet de gérer tous les octets disponibles sans nécessiter une longueur spécifique.

Usage:
send(buffer)

Paramètres	Description
`buffer`	Les données à envoyer à l’autre EXP Brain lié. Cela peut être une chaîne de caractères `string` ou un tableau d’octets ( `bytearray`.

Code pour le 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")

Code pour 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 renvoie des données en série de l’autre EXP Brain lié dans l’ordre FIFO (les données non lues les plus anciennes en premier).

Étant donné que receive attend un nombre précis d’octets, l’envoi de messages de longueur receive afin que chaque message atteigne la taille attendue. Si l’expéditeur transmet moins de send , length continuera d’attendre les octets restants sans rien renvoyer.

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)

Paramètres	Description
`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`	Optionnel. Durée d’attente en millisecondes `receive` : attendre un nouveau message uniquement si la file d’attente est vide). Valeur par défaut : 300 000 (300 secondes).

Code pour le 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)

Code pour 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 enregistre une fonction à appeler chaque fois que le cerveau EXP reçoit des données série.

Usage:
link.received(callback)

Paramètres	Description
`callback`	Une fonction définie précédemment qui s’exécute lorsque le cerveau EXP reçoit des données en série.

received rappel est appelé avec deux arguments :

Signature de rappel :
callback(buffer, length)

Argument	Description
`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.

Code pour le 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")

Code pour 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)

Lien série#

Introduction#

Créer un lien#

Méthodes disponibles#

is_linked#

send#

receive#

received#

Introduction #

Créer un lien #

Méthodes disponibles #

is_linked #

send #

receive #

received #