SeriëleLink#

Invoering #

SerialLink maakt communicatie tussen twee V5 Brains mogelijk door middel van het verzenden en ontvangen van onbewerkte seriële data via VEX Link. In plaats van gelabelde berichten verzendt SerialLink een buffer (een tekenreeks of een bytearray). Dit maakt het nuttig voor geavanceerde robot-naar-robotcommunicatie, zoals het streamen van sensorgegevens, het verzenden van aangepaste pakketformaten of het bouwen van een eigen protocol bovenop bytes.

Elke keer dat send wordt gebruikt, worden gegevens toegevoegd aan de ontvangstbuffer van de gekoppelde V5 Brain. De gegevens worden gelezen in de volgorde waarin ze binnenkomen (first-in, first-out). Als er meerdere buffers worden verzonden voordat de andere V5 Brain receive gebruikt, blijven ze in de wachtrij staan en worden ze één voor één teruggestuurd in de volgorde waarin ze zijn verzonden. Omdat gegevens in de wachtrij kunnen blijven staan, kan het herhaaldelijk verzenden van grote buffers in elke lus een opstopping veroorzaken; voor tijdskritieke verbindingen, verzend alleen wat nodig is.

Belangrijk: Beide robots moeten tegelijkertijd projecten uitvoeren die gebruikmaken SerialLink , anders worden er geen gegevens verzonden/ontvangen.

Op deze pagina wordt link als voorbeeld gebruikt voor de naam SerialLink Vervang dit door uw eigen geconfigureerde naam indien nodig.

Hieronder vindt u een lijst met beschikbare methoden:

is_linked – Geeft aan of dit brein actief verbonden is met het bijbehorende brein.
send – Verstuurt een kort bericht (met optionele int/float-gegevens) naar de gekoppelde Brain.
receive – Wacht op het volgende binnenkomende bericht en retourneert dit.
received – Registreert een functie die wordt aangeroepen wanneer een nieuw bericht wordt ontvangen.

Een link maken #

Maak op beide V5 Brains een SerialLink aan om een communicatiekanaal tussen hen tot stand te brengen – draadloos met V5 Robot Radios of via een bekabelde Smart Cable – zodat de robots onbewerkte seriële data naar elkaar kunnen verzenden.

SerialLink(smartport, name, linktype, wired)

Parameter	Beschrijving
`smartport`	De Smart Port die voor deze verbinding wordt gebruikt: de poort waarop de V5 Robot Radio is aangesloten (draadloos) of waarop de Smart Cable is aangesloten (bedraad). Dit wordt weergegeven als `Ports.PORTx` , waarbij x het poortnummer is.
`name`	De unieke naam die aan deze link moet worden gegeven, als tekenreeks. Opmerking: Deze naam moet lang genoeg zijn om een unieke ID te creëren, zodat deze niet per ongeluk overeenkomt met de link van een ander team.
`linktype`	De rol die dit brein zal vervullen voor dit linkpaar. Elk paar moet één manager en één werker bevatten: `VexlinkType.MANAGER` – Gebruik voor de robot die meer of grotere berichten verzendt. Managers hebben een hogere uitgaande bandbreedte (~1040 bytes/sec). `VexlinkType.WORKER` – Gebruik voor de robot die minder of kleinere berichten verzendt. Werkers hebben een lagere uitgaande bandbreedte (~520 bytes/sec).
`wired`	Optioneel. Of deze verbinding bedraad of draadloos is: `True` – De V5 Brains zijn verbonden via een Smart Cable. `False` (standaard) – De V5 Brains maken draadloos verbinding met behulp van V5 RObot Radios.

Code voor Robot 1

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

Code voor Robot 2

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

Beschikbare methoden #

Zodra uw SerialLink is ingesteld en de Brains zijn gekoppeld, kunt u de onderstaande methoden gebruiken om onbewerkte seriële data te verzenden, te ontvangen en erop te reageren.

is_linked #

is_linked methode retourneert of de V5 Brains op een SerialLink met elkaar gekoppeld zijn.

True – De twee V5-hersenen zijn gekoppeld en communiceren via deze verbinding.
False – De twee V5-hersenen zijn niet gekoppeld op deze link.

Let op: Het is goede gewoonte om altijd te controleren of de V5 Brains aan het begin van een project zijn gekoppeld voordat u verdere code uitvoert.

Usage:
link.is_linked()

Parameters	Beschrijving
	Deze methode heeft geen parameters.

Code voor 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 voor 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 verzendt onbewerkte seriële bytes naar de andere gekoppelde V5 Brain.

Bij het lezen van die gegevens met receive, zal receive pas terugkeren nadat het het aantal bytes heeft verzameld dat is gespecificeerd door de parameter length Daarom, als uw code altijd receive aanroept met een vaste length, moet u ervoor zorgen dat elk bericht dat met send wordt verzonden precies dat aantal bytes bevat (vaak door opvulling), zodat de ontvanger niet blokkeert in afwachting van extra bytes.

Als je niet afhankelijk wilt zijn van een exact aantal bytes, gebruik dan received; hiermee kun je alle beschikbare bytes verwerken zonder een specifieke lengte te vereisen.

Usage:
send(buffer)

Parameters	Beschrijving
`buffer`	De gegevens die naar de andere gekoppelde V5 Brain moeten worden verzonden. Dit kan een tekenreeks van `string` of een array van `bytearray`.

Code voor 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 voor 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 seriële data van de andere gekoppelde V5 Brain in FIFO-volgorde (oudste ongelezen data eerst).

Omdat receive wacht op een exact aantal bytes, vereist het verzenden van berichten met een vaste lengte vaak opvulling (padding) bij gebruik van send , zodat elk bericht de verwachte grootte bereikt. Als de afzender minder dan length bytes verzendt, blijft receive wachten op de resterende bytes en retourneert niets.

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)

Parameters	Beschrijving
`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`	Optioneel. Hoe lang in milliseconden `receive` een nieuw bericht, maar alleen als de wachtrij leeg is. Standaard is 300000 (300 seconden).

Code voor 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 voor 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 registreert een functie die moet worden aangeroepen wanneer de V5 Brain seriële data ontvangt.

Usage:
link.received(callback)

Parameters	Beschrijving
`callback`	Een eerder gedefinieerde functie die wordt uitgevoerd wanneer de V5 Brain seriële data ontvangt.

Er zijn received callback wordt aangeroepen met twee argumenten:

Callback-signatuur:
callback(buffer, length)

Argument	Beschrijving
`buffer`	Een bytearray `bytearray` met de ontvangen seriële data. De bytearray kan groter zijn dan het ontvangen bericht.
`length`	The number of valid bytes received in `buffer` for this callback. Use `buffer[:length]` to access the received data.

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

SeriëleLink#

Invoering#

Een link maken#

Beschikbare methoden#

is_linked#

send#

receive#

received#

Invoering #

Een link maken #

Beschikbare methoden #

is_linked #

send #

receive #

received #