Seriell länk

Introduktion

SerialLink låter två V5-hjärnor kommunicera genom att skicka och ta emot rådata i serie via VEX Link. Istället för märkta meddelanden skickar SerialLink en buffert (en sträng eller en bytearray). Detta gör den användbar för avancerad robot-till-robot-kommunikation, såsom strömmande sensordata, sändning av anpassade paketformat eller byggande av ditt eget protokoll ovanpå byte.

Varje användning av send lägger till data i den länkade V5 Brains mottagningsbuffert. Data läses i den ordning de anländer (först in, först ut). Om flera buffertar skickas innan den andra V5 Brain använder receive, förblir de i kö och returneras en i taget i den ordning de skickades. Eftersom data kan köas kan det skapa eftersläpning om man upprepade gånger skickar stora buffertar i varje loop; för tidskritiska länkar, skicka bara det du behöver.

Viktigt: Båda robotarna måste köra projekt som använder SerialLink samtidigt, annars kommer ingen data att skickas/tas emot.

Den här sidan använder link som exempelnamn SerialLink Ersätt det med ditt eget konfigurerade namn efter behov.

Nedan följer en lista över tillgängliga metoder:

• is_linked – Returnerar om denna hjärna är aktivt ansluten till sin parade hjärna.

• send – Skickar ett kort meddelande (med valfri int/float-data) till den parade hjärnan.

• receive – Väntar på och returnerar nästa inkommande meddelande.

• received – Registrerar en funktion som ska anropas när ett nytt meddelande tas emot.

Skapa en länk

Skapa en seriell länk på båda V5-hjärnorna för att upprätta en kommunikationskanal mellan dem – antingen trådlöst med V5-robotradior eller via en trådbunden smartkabel – så att robotarna kan skicka rådata i serie till varandra.

SerialLink(smartport, name, linktype, wired)

Parameter	Beskrivning
smartport	Smart Port som används för denna länk – porten som V5 Robot Radio är ansluten till (trådlös) eller Smart Cable är inkopplad i (kabelansluten). Skrivs som Ports.PORTx där x är portnumret.
name	Det unika namnet som ska anges som en sträng för denna länk. Obs: Detta namn ska vara tillräckligt långt för att skapa ett unikt ID så att det inte av misstag matchar ett annat teams länk.
linktype	Den roll som denna hjärna kommer att använda för detta länkpar. Varje par måste innehålla en chef och en arbetare: VexlinkType.MANAGER – Används för roboten som skickar fler eller större meddelanden. Chefer har högre utgående bandbredd (~1040 byte/sek). VexlinkType.WORKER – Används för roboten som skickar färre eller mindre meddelanden. Arbetare har lägre utgående bandbredd (~520 byte/sek).
wired	Valfritt. Om den här länken är trådbunden eller trådlös: True – V5 Brains är anslutna via en Smart Cable. False (standard) – V5 Brains ansluts trådlöst med V5 RObot Radios.

Kod för robot 1

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

Kod för robot 2

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

Tillgängliga metoder

När din SerialLink är konfigurerad och hjärnorna är länkade kan du använda metoderna nedan för att skicka, ta emot och svara på rådata i serie.

is_linked

is_linked -metoden returnerar om V5-hjärnorna på en SerialLink är parade med varandra.

• True – De två V5-hjärnorna är parade ihop och kommunicerar på den här länken.

• False – De två V5-hjärnorna är inte parade ihop på den här länken.

Obs! Det är god praxis att alltid kontrollera att V5-hjärnorna är länkade i början av ett projekt innan ytterligare kod körs.

Usage:
link.is_linked()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

Kod för 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")

Kod för 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 överför råa seriella byte till den andra länkade V5 Brain.

När man läser data med receive, kommer receive bara att returnera när den har samlat in det antal byte som anges av dess length parameter. På grund av detta, om din kod alltid anropar receive med en fast length, bör du se till att varje meddelande som skickas med send är exakt så många byte (ofta genom utfyllnad) så att mottagaren inte blockerar väntan på ytterligare byte.

Om du inte vill vara beroende av ett exakt antal byte, använd received istället; det låter dig hantera alla tillgängliga byte utan att kräva en specifik längd.

Usage:
send(buffer)

Parametrar	Beskrivning
buffer	Data som ska skickas till den andra länkade V5 Brain. Detta kan vara en string eller en bytearray.

Kod för 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")

Kod för 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 returnerar seriella data från den andra länkade V5 Brain i FIFO-ordning (äldsta olästa data först).

Eftersom receive väntar på ett exakt antal bytes kräver meddelanden med fast längd ofta utfyllnad när send används så att varje meddelande når den förväntade storleken. Om avsändaren skickar färre än length , kommer receive att fortsätta vänta på de återstående bytes och inte returnera något.

Om kön är tom och du anger en timeout timeout, receive väntar upp till det angivna antalet millisekunder på ny data. Om ingenting anländer i det fönstret returneras None. All data som skickas efteråt förblir i kö för att läsas senare.

Usage:
receive(length, timeout)

Parametrar	Beskrivning
length	Antalet byte att ta emot. receive väntar tills detta antal byte har anlänt och returnerar dem sedan som en bytearrayOm length är 0, receive returnerar length omedelbart. Om du begär fler byte än avsändaren sänder, kommer receive att fortsätta vänta. Om avsändaren sänder mer än detta är den returnerade bufferten begränsad till None byte.
timeout	Valfritt. Hur länge i millisekunder receive väntar på ett nytt meddelande endast om kön är tom. Standard är 300000 (300 sekunder).

Kod för 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)

Kod för 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 registrerar en funktion som ska anropas när V5 Brain tar emot seriell data.

Usage:
link.received(callback)

Parametrar	Beskrivning
callback	En tidigare definierad funktion som körs när V5 Brain tar emot seriell data.

received återanrop anropas med två argument:

Återuppringningssignatur:
callback(buffer, length)

Argument	Beskrivning
buffer	En bytearray som innehåller mottagen seriell data. Bytearrayen kan vara större än det mottagna meddelandet.
length	Antalet giltiga byte som mottagits i buffer för detta återanrop. Använd buffer[:length] för att komma åt mottagen data.

Kod för 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")

Kod för 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)