Lien série

Introduction

La classe serial_link permet l’envoi d’un flux d’octets bruts entre robots. Elle est conçue pour la communication entre robots, où l’émetteur et le récepteur comprennent tous deux le contenu du flux de données.

Chaque utilisation de send ajoute des données à la file d’attente du V5 Brain lié, et cette file d’attente est lue selon le principe du premier entré, premier sorti (FIFO). Si plusieurs messages sont envoyés avant que l’autre V5 Brain n’utilise la fonction receive, ils seront stockés et renvoyés un par un, dans l’ordre d’envoi. Étant donné que les messages peuvent être mis en file d’attente, l’envoi répété du même statut à chaque boucle peut engendrer un engorgement ; pour une logique critique en termes de temps, n’envoyez des messages que lorsque les valeurs changent.

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

Constructeurs de classes

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

Destructeur de classe

Détruit l’objet serial_link et libère les ressources associées.

~serial_link();

Paramètres

Paramètre	Taper	Description
index	int32_t	Le port intelligent auquel le lien de message est connecté, écrit sous la forme PORTx, où x est le numéro de port (par exemple, PORT1).
name	const char*	Le nom de ce lien. Il est recommandé que cette chaîne de caractères unique soit suffisamment longue pour que, hachée par Vexos, elle génère un identifiant unique. Un nom de lien générique comme « vexlink » est à proscrire, car il pourrait être utilisé par une autre équipe.
type	linkType	The type of link, either linkType::manager or linkType::worker. This information is used to correctly configure the radio and also determines available bandwidth for transmission and reception. A manager robot has double the available bandwidth (1040 bytes/second) to send information to the worker robot (520 bytes/second). linkType::manager — The serial_link object is a manager linkType::worker — The serial_link object is a worker
isWired	bool	Indique si l’objet serial_link est câblé (par défaut : false) : false  — L’objet serial_link est câblé true  — L’objet serial_link est sans fil

Notes

• VEXlink prend en charge la communication sans fil et filaire, les connexions filaires recommandant un câble intelligent modifié pour éviter les problèmes d’acheminement de l’alimentation.

• Pour la communication sans fil, chaque robot a besoin d’une radio robot V5 connectée à un port intelligent.

• La radio VEXlink peut être utilisée en parallèle avec la radio VEXnet d’un contrôleur V5, qui doit être connectée au port intelligent portant le numéro le plus élevé afin d’éviter les conflits.

• Pour créer un VEXlink, les deux cerveaux V5 doivent être connectés à une radio de robot V5.

Exemple

Code pour le robot 1

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

Code pour Robot 2

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

Fonctions des membres

La classe serial_link comprend les fonctions membres suivantes :

• isLinked — Vérifie si les cerveaux V5 sont appariés et communiquent sur ce lien.

• send — Envoie un message 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.

Avant d’appeler une serial_link , serial_link doit être créée, comme indiqué ci-dessous :

Code pour le robot 1

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

Code pour Robot 2

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

isLinked

Indique si les modules V5 Brains connectés en série sont appariés.

Available Functions

bool isLinked();

Parameters

Cette fonction ne possède aucun paramètre.

Return Values

Renvoie une valeur booléenne indiquant si les cerveaux V5 sont liés :

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

Notes

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

Examples

Code pour le robot 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 pour Robot 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

Envoie un message au cerveau associé.

Available Functions

1 — Envoie un message à l’aide d’un tampon d’octets.

int32_t send( 
  uint8_t *buffer, 
  int32_t  length );

2 — Envoie un message à l’aide d’une mémoire tampon de caractères.

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

Parameters

Paramètre	Taper	Description
buffer	uint8_t* or const char*	Le tampon à envoyer à l’autre cerveau V5 lié.
length	int32_t	La longueur du tampon à envoyer.

Return Values

Renvoie un int32_t int32_t représentant le nombre d’octets envoyés.

Examples

Code pour le robot 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 pour Robot 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

Attend et renvoie le prochain message entrant.

Available Functions

1 — Reçoit un message dans une mémoire tampon de caractères avec délai d’attente optionnel.

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

Parameters

Paramètre	Taper	Description
buffer	char*	Le tampon destiné à stocker le message reçu.
length	int32_t	La longueur du tampon.
timeoutMs	int32_t	Combien de temps en millisecondes receive attendra un nouveau message uniquement si la file d’attente est vide (par défaut 500 ms).

Return Values

Renvoie un entier int32_t représentant le nombre d’octets reçus.

Notes

• receive renvoie le prochain message mis en file d’attente de l’autre cerveau V5 lié.

• Les messages sont lus dans l’ordre FIFO (les plus anciens non lus en premier).

• Si la file d’attente est vide lorsque receive est appelé, il attend jusqu’à timeoutMs spécifié pour un nouveau message.

• Si aucun message n’arrive dans cette fenêtre, receive renvoie 0, et tout message envoyé ultérieurement reste dans la file d’attente pour être lu la prochaine fois receive est utilisé.

Examples

Code pour le robot 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 pour Robot 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

Enregistre une fonction qui sera appelée chaque fois que le V5 Brain recevra des données.

Available Functions

1 — Enregistre une fonction de rappel pour chaque tampon d’octets reçu.

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

Parameters

Paramètre	Taper	Description
callback	void (*)(uint8_t *, int32_t)	Une fonction préalablement définie qui s’exécute lorsque le V5 Brain reçoit des données.

Return Values

Cette fonction ne renvoie aucune valeur.

Notes

• received fonction de rappel est appelée avec deux arguments : un tampon d’octets et le nombre d’octets reçus.

• Les données reçues peuvent ne pas être terminées par un caractère nul. Si la fonction de rappel traite les données comme une chaîne de caractères, copiez les octets reçus dans un tableau de caractères et ajoutez un caractère nul de fin.

Callback Signature

callback(buffer, length)

Argument	Description
buffer	Un pointeur vers la mémoire tampon d’octets reçue.
length	Le nombre d’octets reçus.

Examples

Code pour le robot 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 pour Robot 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);
  }
}