Serielle Verbindung

Einführung

Die Klasse serial_link ermöglicht den Austausch eines Datenstroms von Rohbytes zwischen Robotern. Sie ist für die Roboter-zu-Roboter-Kommunikation konzipiert, bei der sowohl der sendende als auch der empfangende Roboter den Inhalt des Datenstroms verstehen.

Jede Verwendung von send fügt Daten zur Warteschlange des verknüpften V5 Brain hinzu. Die Warteschlange wird nach dem FIFO-Prinzip (First In, First Out) gelesen. Werden mehrere Nachrichten gesendet, bevor das andere V5 Brain die Empfangsfunktion verwendet, werden diese nacheinander in der Reihenfolge ihres Eingangs gespeichert und zurückgesendet. Da Nachrichten in einer Warteschlange landen können, kann das wiederholte Senden desselben Status in jeder Schleife zu einem Rückstau führen. Senden Sie daher für zeitkritische Logik nur dann Nachrichten, wenn sich Werte ändern.

Wichtig: Beide Roboter müssen gleichzeitig Projekte ausführen, die serial_link verwenden, sonst werden keine Daten gesendet/empfangen.

Klassenkonstruktoren

serial_link(
 int32_t index,
 const char *name,
 linkType type,
 bool isWired = false );

Klassendestruktor

Zerstört das Objekt serial_link serial_link 1) und gibt die zugehörigen Ressourcen frei.

~serial_link();

Parameter

Parameter	Typ	Beschreibung
index	int32_t	Der Smart Port, mit dem die Nachrichtenverbindung hergestellt wird, wird als PORTxgeschrieben, wobei x die Portnummer ist (zum Beispiel PORT1).
name	const char*	Der Name dieses Links. Es wird empfohlen, dass diese eindeutige Zeichenkette lang genug ist, damit sie beim Hashing durch Vexos eine eindeutige ID erzeugt. Ein ungeeigneter Linkname wäre beispielsweise „vexlink“, da er möglicherweise bereits von einem anderen Team verwendet wird.
type	linkType	Der Verbindungstyp, entweder linkType::manager oder linkType::workerDiese Information dient der korrekten Konfiguration des Funkmoduls und bestimmt die verfügbare Bandbreite für Senden und Empfangen. Ein Manager-Roboter verfügt über die doppelte Bandbreite (1040 Byte/Sekunde) zum Senden von Informationen an den Worker-Roboter (520 Byte/Sekunde). linkType::manager — Das serial_link-Objekt ist ein Manager linkType::worker — Das serial_link-Objekt ist ein Worker
isWired	bool	Gibt an, ob das serial_link-Objekt kabelgebunden ist (Standardwert: false): = true falsefalse = true, = false, = false,true = false false

Anmerkungen

• VEXlink unterstützt sowohl drahtlose als auch kabelgebundene Kommunikation. Für kabelgebundene Verbindungen wird ein modifiziertes Smart-Kabel empfohlen, um Probleme mit der Stromversorgung zu vermeiden.

• Für die drahtlose Kommunikation benötigt jeder Roboter ein V5-Roboterradio, das mit einem Smart Port verbunden ist.

• Das VEXlink-Funkmodul kann zusammen mit dem VEXnet-Funkmodul eines V5-Controllers verwendet werden. Um Konflikte zu vermeiden, sollte das VEXnet-Funkmodul an den Smart Port mit der höchsten Nummer angeschlossen werden.

• Um eine VEXlink-Verbindung herzustellen, müssen beide V5 Brains mit einem V5 Robot Radio verbunden werden.

Beispiel

Code für Roboter 1

// Create a wireless link in Port 1
serial_link link = serial_link(
  PORT1, // index
  "VEXRoboticsLink123456789", // name
  linkType::manager, // type
  true); // isWired

Code für Roboter 2

// Create a wireless link in Port 1
serial_link link = serial_link(
  PORT1, // index
  "VEXRoboticsLink123456789", // name
  linkType::worker, // type
  true); // isWired

Mitgliedsfunktionen

Die Klasse serial_link enthält die folgenden Memberfunktionen:

• isLinked — Prüft, ob die V5 Brains gepaart sind und über diese Verbindung kommunizieren.

• send — Sendet eine Nachricht an das gepaarte Gehirn.

• receive — Wartet auf die nächste eingehende Nachricht und gibt sie zurück.

• received — Registriert eine Funktion, die aufgerufen wird, sobald eine neue Nachricht empfangen wird.

Bevor Sie eine der Memberfunktionen von serial_link aufrufen, muss eine serial_link Instanz erstellt werden, wie unten gezeigt:

Code für Roboter 1

// Create a wireless link in Port 1
serial_link link = serial_link(
  PORT1, // index
  "VEXRoboticsLink123456789", // name
  linkType::manager, // type
  true); // isWired

Code für Roboter 2

// Create a wireless link in Port 1
serial_link link = serial_link(
  PORT1, // index
  "VEXRoboticsLink123456789", // name
  linkType::worker, // type
  true); // isWired

isLinked

Gibt zurück, ob die V5 Brains über eine serielle Verbindung miteinander gekoppelt sind.

Available Functions

bool isLinked();

Parameters

Diese Funktion hat keine Parameter.

Return Values

Gibt einen booleschen Wert zurück, der angibt, ob die V5-Gehirne miteinander verbunden sind:

• true — The two V5 Brains are paired and communicating on this link.
• false — The two V5 Brains are not paired on this link.

Notes

• Es empfiehlt sich, zu Beginn eines Projekts immer zu überprüfen, ob die V5 Brains verknüpft sind, bevor weiterer Code ausgeführt wird.

Examples

Code für Roboter 1

// Create the link
  serial_link link(PORT1, "VEXRoboticsLink123456789", linkType::manager, true);

  // Do not run code UNTIL the Brains are linked
  while (!link.isLinked()) {
    wait(0.1, seconds);
  }

  Brain.Screen.print("Robot 1 - Manager");
  Brain.Screen.newLine();
  Brain.Screen.print("Sending message...");

  // Message to send
  const char* message = "Hello Robot 2";

  // Send the message
  link.send((uint8_t*)message, strlen(message));

Code für Roboter 2

// Create the link
  serial_link link(PORT1, "VEXRoboticsLink123456789", linkType::worker, true);

  // Do not run code UNTIL the Brains are linked
  while (!link.isLinked()) {
    wait(0.1, seconds);
  }
  
  Brain.Screen.print("Robot 2 - Worker");
  Brain.Screen.newLine();
  Brain.Screen.print("Waiting...");

  // Buffer to store incoming bytes
  uint8_t buffer[32] = {0};

  int32_t n = link.receive(buffer, sizeof(buffer) - 1);

  // Null-terminate
  if (n > 0) {
    buffer[n] = 0;

    // Display the message that was sent
    Brain.Screen.clearScreen();
    Brain.Screen.setCursor(1, 1);
    Brain.Screen.print("Robot 2 - Worker");
    Brain.Screen.newLine();
    Brain.Screen.print((char*)buffer);
  }
  else {
    Brain.Screen.newLine();
    Brain.Screen.print("No message received");
  }

send

Sendet eine Nachricht an das zugehörige Gehirn.

Available Functions

1 — Sendet eine Nachricht mithilfe eines Byte-Puffers.

int32_t send( 
  uint8_t *buffer, 
  int32_t  length );

2 — Sendet eine Nachricht mithilfe eines Zeichenpuffers.

int32_t send( 
  const char *buffer, 
  int32_t     length );

Parameters

Parameter	Typ	Beschreibung
buffer	uint8_t* or const char*	Der Puffer, der an das andere verbundene V5-Gehirn gesendet werden soll.
length	int32_t	Die Länge des zu sendenden Puffers.

Return Values

Gibt einen int32_t zurück, der die Anzahl der gesendeten Bytes darstellt.

Examples

Code für Roboter 1

// Create the link
  serial_link link(PORT1, "VEXRoboticsLink123456789", linkType::manager, true);

  // Do not run code UNTIL the Brains are linked
  while (!link.isLinked()) {
    wait(0.1, seconds);
  }

  Brain.Screen.clearScreen();
  Brain.Screen.setCursor(1, 1);
  Brain.Screen.print("Robot 1 - Manager");

  // Track last sent state
  uint8_t lastState = 255;  // impossible initial value

 // Tell Robot 2 when the screen is being pressed
  while (true) {
    uint8_t state = Brain.Screen.pressing() ? 1 : 0;

    // Only send if state changed
    if (state != lastState) {
      link.send(&state, 1);
      lastState = state;
    }

    wait(0.02, seconds);
  }

Code für Roboter 2

// Create the link
  serial_link link(PORT1, "VEXRoboticsLink123456789", linkType::worker, true);

  // Do not run code UNTIL the Brains are linked
   while (!link.isLinked()) {
    wait(0.1, seconds);
  }

  Brain.Screen.clearScreen();
  Brain.Screen.setCursor(1, 1);
  Brain.Screen.print("Robot 2 - Worker");
  Brain.Screen.newLine();
  Brain.Screen.print("Waiting...");

  // Track the last state
  uint8_t lastShown = 255;

  while (true) {
    // Variable stores 1 - pressed, 0 - not pressed 
    uint8_t state = 0;
    int32_t n = link.receive(&state, 1, 200);

    // Only update screen if state changes
    if (n == 1 && state != lastShown) {
      Brain.Screen.clearScreen();
      Brain.Screen.setCursor(1, 1);
      Brain.Screen.print("Robot 2 - Worker");
      Brain.Screen.newLine();

      // Display text if Robot 1's screen is being pressed
      if (state == 1) {
        Brain.Screen.print("Manager IS being pressed!");
      } else {
        Brain.Screen.print("Manager is NOT being pressed");
      }

      lastShown = state;
    }
    wait(0.02, seconds);
  }

receive

Wartet auf die nächste eingehende Nachricht und gibt diese zurück.

Available Functions

1 — Empfängt eine Nachricht in einen Zeichenpuffer mit optionalem Timeout.

int32_t receive( 
  char    *buffer, 
  int32_t  length, 
  int32_t  timeoutMs = 500);

Parameters

Parameter	Typ	Beschreibung
buffer	char*	Der Puffer zum Speichern der empfangenen Nachricht.
length	int32_t	Die Länge des Puffers.
timeoutMs	int32_t	Wie lange in Millisekunden receive wartet nur dann auf eine neue Nachricht, wenn die Warteschlange leer ist (Standardwert: 500 ms).

Return Values

Gibt einen int32_t zurück, der die Anzahl der empfangenen Bytes darstellt.

Notes

• receive gibt die nächste in der Warteschlange befindliche Nachricht vom anderen verbundenen V5 Brain zurück.

• Nachrichten werden in der Reihenfolge FIFO gelesen (älteste ungelesene zuerst).

• Wenn die Warteschlange leer ist, wenn receive aufgerufen wird, wartet sie bis zu den angegebenen timeoutMs auf eine neue Nachricht.

• Wenn in diesem Zeitfenster keine Nachricht eintrifft, gibt receive den Wert 0zurück, und jede danach gesendete Nachricht bleibt in der Warteschlange, um beim nächsten Aufruf receive gelesen zu werden.

Examples

Code für Roboter 1

// Create the link
  serial_link link(PORT1, "VEXRoboticsLink123456789", linkType::manager, true);

  // Do not run code UNTIL the Brains are linked
  while (!link.isLinked()) {
    wait(0.1, seconds);
  }

  Brain.Screen.clearScreen();
  Brain.Screen.setCursor(1, 1);
  Brain.Screen.print("Robot 1 - Manager");

  // Track last sent state
  uint8_t lastState = 255;  // impossible initial value

 // Tell Robot 2 when the screen is being pressed
  while (true) {
    uint8_t state = Brain.Screen.pressing() ? 1 : 0;

    // Only send if state changed
    if (state != lastState) {
      link.send(&state, 1);
      lastState = state;
    }

    wait(0.02, seconds);
  }

Code für Roboter 2

// Create the link
  serial_link link(PORT1, "VEXRoboticsLink123456789", linkType::worker, true);

  // Do not run code UNTIL the Brains are linked
   while (!link.isLinked()) {
    wait(0.1, seconds);
  }

  Brain.Screen.clearScreen();
  Brain.Screen.setCursor(1, 1);
  Brain.Screen.print("Robot 2 - Worker");
  Brain.Screen.newLine();
  Brain.Screen.print("Waiting...");

  // Track the last state
  uint8_t lastShown = 255;

  while (true) {
    // Variable stores 1 - pressed, 0 - not pressed 
    uint8_t state = 0;
    int32_t n = link.receive(&state, 1, 200);

    // Only update screen if state changes
    if (n == 1 && state != lastShown) {
      Brain.Screen.clearScreen();
      Brain.Screen.setCursor(1, 1);
      Brain.Screen.print("Robot 2 - Worker");
      Brain.Screen.newLine();

      // Display text if Robot 1's screen is being pressed
      if (state == 1) {
        Brain.Screen.print("Manager IS being pressed!");
      } else {
        Brain.Screen.print("Manager is NOT being pressed");
      }

      lastShown = state;
    }
    wait(0.02, seconds);
  }

received

Registriert eine Funktion, die aufgerufen werden soll, sobald das V5 Brain Daten empfängt.

Available Functions

1 — Registriert eine Callback-Funktion für jeden empfangenen Byte-Puffer.

void received( 
  void (* callback)(uint8_t *, int32_t) );

Parameters

Parameter	Typ	Beschreibung
callback	void (*)(uint8_t *, int32_t)	Eine zuvor definierte Funktion, die ausgeführt wird, wenn das V5-Gehirn Daten empfängt.

Return Values

Diese Funktion gibt keinen Wert zurück.

Notes

• received Rückruffunktionen werden mit zwei Argumenten aufgerufen: einem Byte-Puffer und der Anzahl der empfangenen Bytes.

• Die empfangenen Daten sind möglicherweise nicht nullterminiert. Falls die Callback-Funktion die Daten als Zeichenkette behandelt, kopieren Sie die empfangenen Bytes in ein Zeichenarray und fügen Sie ein Nullbyte hinzu.

Callback Signature

callback(buffer, length)

Argument	Beschreibung
buffer	Ein Zeiger auf den empfangenen Byte-Puffer.
length	Die Anzahl der empfangenen Bytes.

Examples

Code für Roboter 1

// Create the link.
serial_link link(PORT1, "VEXRoboticsLink123456789", linkType::manager, true);

// Send left or right when pressed.
void screen_pressed() {
  if (Brain.Screen.xPosition() < 240) {
    link.send((uint8_t*)"left", 4);
  } else {
    link.send((uint8_t*)"right", 5);
  }
}

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  // Do not run code UNTIL the Brains are linked.
  while (!link.isLinked()) {
    wait(0.1, seconds);
  }

  Brain.Screen.print("Robot 1 - Manager");


  Brain.Screen.pressed(screen_pressed);

  while (true) {
    wait(10, msec);
  }
}

Code für Roboter 2

// Called when message received.
void received_callback(uint8_t *buffer, int32_t length) {
  char msg[32];

  // Copy safely and null terminate.
  int n = (length < 31) ? length : 31;
  memcpy(msg, buffer, n);
  msg[n] = '\0';

  Brain.Screen.clearScreen();
  Brain.Screen.setCursor(1,1);
  Brain.Screen.print("Robot 2 - Worker");
  Brain.Screen.newLine();

  // Display if Robot 1's screen is pressed on left or right
  if (strcmp(msg, "left") == 0) {
    Brain.Screen.print("Manager pressed LEFT");
  }
  else if (strcmp(msg, "right") == 0) {
    Brain.Screen.print("Manager pressed RIGHT");
  }
}

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  // Create the link.
  serial_link link(PORT1, "VEXRoboticsLink123456789", linkType::worker, true);

  // Do not run code UNTIL the Brains are linked.
  while (!link.isLinked()) {
    wait(0.1, seconds);
  }

  link.received(received_callback);

  Brain.Screen.clearScreen();
  Brain.Screen.setCursor(1,1);
  Brain.Screen.print("Robot 2 - Worker");
  Brain.Screen.newLine();
  Brain.Screen.print("Waiting...");

  while (true) {
    wait(10, msec);
  }
}