Seriell länk#

Introduktion #

SerialLink låter två EXP Brains 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å bytes.

Varje användning av send lägger till data till den länkade EXP Brain:s mottagningsbuffert. Data läses i den ordning de anländer (först in, först ut). Om flera buffertar skickas innan den andra EXP 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 EXP-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` – EXP-hjärnorna är anslutna via en Smart Cable. `False` (standard) – EXP-hjärnorna ansluts trådlöst med V5-robotradior.

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 EXP-hjärnorna på en SerialLink är parade med varandra.

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

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

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 sänder råa seriella byte till den andra länkade EXP 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 EXP 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 seriell data från den andra länkade EXP 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 `bytearray`Om `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 EXP Brain tar emot seriell data.

Usage:
link.received(callback)

Parametrar	Beskrivning
`callback`	En tidigare definierad funktion som körs när EXP 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)

Seriell länk#

Introduktion#

Skapa en länk#

Tillgängliga metoder#

is_linked#

send#

receive#

received#

Introduktion #

Skapa en länk #

Tillgängliga metoder #

is_linked #

send #

receive #

received #