Lien du message

Introduction

La classe message_link permet à deux EXP Brains de communiquer en envoyant de courts messages sous forme de chaînes de caractères, accompagnés éventuellement de petites données. Elle est conçue pour la coordination entre robots, notamment pour lancer des routines, partager des résultats de capteurs ou déclencher des comportements sur un autre robot.

Chaque utilisation de send ajoute un message à la file d’attente du cerveau EXP lié, et cette file est lue selon le principe du premier entré, premier sorti (FIFO). Si plusieurs messages sont envoyés avant que l’autre cerveau EXP n’utilise receive, ils seront stockés et renvoyés un par un, dans l’ordre de leur 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 créer 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 message_link , sinon aucun message ne sera envoyé/reçu.

Constructeurs de classes

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

Destructeur de classe

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

virtual ~message_link();

Paramètres

Paramètre	Taper	Description
index	int32_t	Le port intelligent auquel la radio V5 ou le câble intelligent est connecté est écrit sous la forme PORTx, où x est le numéro de port (par exemple, PORT1).
name	char	Nom du lien du message.
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 message_link object is a manager. linkType::worker - The message_link object is a worker.
isWired	bool	Indique si l’objet message_link est câblé. true - L’objet message_link est câblé. false - L’objet message_link est sans fil.

Exemple

Code pour le robot 1

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

Code pour Robot 2

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

Fonctions des membres

La classe message_link comprend les fonctions membres suivantes :

• isLinked — Renvoie si ce cerveau est activement connecté à son cerveau apparié.

• 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 quelconque fonction membre de message_link , une instance message_link doit être créée, comme indiqué ci-dessous :

Code pour le robot 1

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

Code pour Robot 2

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

isLinked

La méthode isLinked renvoie si les EXP Brains d’un MessageLink sont appariés entre eux.

Available Functions

bool isLinked();

Parameters

Cette fonction ne possède aucun paramètre.

Return Values

Cette fonction renvoie une valeur booléenne.

• true – Les deux cerveaux EXP sont appariés et communiquent sur ce lien.

• false – Les deux cerveaux EXP ne sont pas appariés sur ce lien.

Notes

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

Examples

Code pour le robot 1

// Tell the other robot when the screen is being pressed
  // Create the link
  message_link link = message_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");

  // Continuously send if the screen is being pressed
  while (true){
    if (Brain.Screen.pressing()){
      link.send("pressed");
    } else {
      link.send("released");
    }
    wait(0.05, seconds);
  }

Code pour Robot 2

// Display if the other robot's screen is being pressed

  // Create the link
  message_link link = message_link(PORT1, "VEXRoboticsLink123456789", linkType::worker, true);
  
  // Do not run code UNTIL the Brains are linked
  while (!link.isLinked()){
   wait(0.1, seconds);
  }

  // Continuously check if Robot 1 has sent "pressed"
  while (true){
    Brain.Screen.clearScreen();
    Brain.Screen.setCursor(1, 1);
    Brain.Screen.print("Robot 2 - Worker");
    Brain.Screen.newLine();
    char msg[32] = {0};                         // buffer for incoming message
    int32_t n = link.receive(msg, sizeof(msg), 100);  // wait up to 100ms
    if (n > 0 && strcmp(msg, "pressed") == 0) {
      Brain.Screen.newLine();
      Brain.Screen.print("Manager is being pressed!");
    }
    wait(0.05, seconds);
  }

send

Envoie un message via la connexion.

Available Functions

1 — Envoie une chaîne de messages.

int32_t send( 
  const char *message );

2 — Envoie une chaîne de messages avec un double double.

int32_t send( 
  const char *message, 
  double      value );

3 — Envoie une chaîne de messages avec un int32_t et un double.

int32_t send(
  const char *message, 
  int32_t     index, 
  double      value );

Parameters

Paramètre	Taper	Description
message	const char*	Message à envoyer à l’autre EXP Brain lié.
index	int32_t	Un entier à envoyer à l’autre EXP Brain lié.
value	double	Un nombre décimal à envoyer à l’autre EXP Brain lié. Les nombres décimaux sont formatés avec 4 décimales ; si moins de décimales sont fournies, des zéros sont ajoutés à la fin jusqu’à ce que 4 décimales soient affichées.

Return Values

Cette fonction ne renvoie aucune valeur.

Notes

Si seul le message message est envoyé, l’autre EXP Brain lié reçoit exactement ce message.

Si la valeur value (et l’index index s’il est fourni) sont inclus, le cerveau récepteur reçoit un seul message encodé qui combine tous les champs dans cet ordre : .message_index_value

Examples

En utilisant link.send(“string”, 1, 2.55) est reçu comme .string_1_2.5500.

Code pour le robot 1

// Tell the other robot when the screen is being pressed

// Create the link
message_link link = message_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");

// Continuously send if the screen is being pressed
while (true){
  if (Brain.Screen.pressing()){
    link.send("pressed");
  } else {
    link.send("released");
  }
  wait(0.05, seconds);
}

Code pour Robot 2

// Display if the other robot's screen is being pressed

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

// Do not run code UNTIL the Brains are linked
while (!link.isLinked()){
  wait(0.1, seconds);
}
// Continuously check if Robot 1 has sent "pressed"
while (true){
  Brain.Screen.clearScreen();
  Brain.Screen.setCursor(1, 1);
  Brain.Screen.print("Robot 2 - Worker");
  Brain.Screen.newLine();
  char msg[32] = {0};  // buffer for incoming message
  int32_t n = link.receive(msg, sizeof(msg), 100);  // wait up to 100ms
  if (n > 0 && strcmp(msg, "pressed") == 0) {
    Brain.Screen.newLine();
    Brain.Screen.print("Manager is being pressed!");
  }
  wait(0.05, seconds);
}

receive

Reçoit un message de la connexion de liaison.

Available Functions

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	Durée d’attente en millisecondes receive pour un nouveau message uniquement si la file d’attente est vide. Valeur par défaut : 300 000 (300 secondes).

Return Values

Cette fonction renvoie le nombre d’octets reçus.

Notes

• receive returns the next queued message from the other linked EXP Brain. Messages are read in FIFO order (oldest unread first). If the queue is empty when receive is called, it waits up to the specified timeout for a new message. If no message arrives in that window, receive returns 0, and any message sent afterward remains in the queue to be read the next time receive is used.

• Si l’autre EXP Brain lié a envoyé uniquement une chaîne string, receive renvoie cette chaîne exacte.

• Si l’autre EXP Brain lié a envoyé un entier et/ou un nombre à virgule flottante, receive renvoie une seule chaîne encodée qui combine tous les champs dans cet ordre : .string_integer_float

  • Par exemple, si l’autre EXP Brain lié utilise link.send(“string”, 1, 2.55), alors link.receive() renvoie une chaîne encodée telle que .string_1_2.5500. Vous pouvez diviser cette chaîne encodée (voir les exemples ci-dessous) pour extraire le nom du message, l’entier et les valeurs flottantes.

  • Si vous préférez éviter le fractionnement/l’analyse manuel, utilisez received pour enregistrer un gestionnaire pour un nom de message spécifique ; le gestionnaire reçoit les valeurs envoyées comme arguments.

Examples

En utilisant link.send(“string”, 1, 2.55) est reçu comme .string_1_2.5500.

Code pour le robot 1

// Tell the other robot when the screen is being pressed

// Create the link
message_link link = message_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");

// Continuously send if the screen is being pressed
while (true){
  if (Brain.Screen.pressing()){
    link.send("pressed");
  } else {
    link.send("released");
  }
  wait(0.05, seconds);
}

Code pour Robot 2

// Display if the other robot's screen is being pressed

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

// Do not run code UNTIL the Brains are linked
while (!link.isLinked()){
  wait(0.1, seconds);
}
// Continuously check if Robot 1 has sent "pressed"
while (true){
  Brain.Screen.clearScreen();
  Brain.Screen.setCursor(1, 1);
  Brain.Screen.print("Robot 2 - Worker");
  Brain.Screen.newLine();
  char msg[32] = {0};   // buffer for incoming message
  int32_t n = link.receive(msg, sizeof(msg), 100);  // wait up to 100ms
  if (n > 0 && strcmp(msg, "pressed") == 0) {
    Brain.Screen.newLine();
    Brain.Screen.print("Manager is being pressed!");
  }
  wait(0.05, seconds);
}

received

Enregistre une fonction qui sera appelée chaque fois que le cerveau EXP recevra un message envoyé.

Available Functions

1 Enregistre une fonction de rappel pour tous les messages reçus (message + valeur).

void received(
    void (* callback)(const char *, const char *, double)
);

2 Enregistre une fonction de rappel pour tous les messages reçus (message + index + valeur).

void received(
    void (* callback)(const char *, const char *, int32_t, double)
);

3 Enregistre un rappel pour un message spécifique (message + valeur).

void received(
    const char *message,
    void      (* callback)(const char *, const char *, double)
);

4 Enregistre un rappel pour un message spécifique (message + index + valeur).

void received(
    const char *message,
    void      (* callback)(const char *, const char *, int32_t, double)
);

Parameters

Paramètre	Taper	Description
message	const char *	Nom du message à surveiller. Si ce nom est omis, la fonction de rappel est exécutée pour tous les messages reçus.
callback	pointeur de fonction	Une fonction qui s’exécute lorsqu’un message est reçu.

Return Values

Cette fonction ne renvoie aucune valeur.

Callback Signature

1 Reçoit le nom de l’expéditeur, le nom du message et la valeur.

void callback(const char *, const char *, double)

2 Reçoit le nom de l’expéditeur, le nom du message, l’index et la valeur.

void callback(const char *, const char *, int32_t, double)

Taper	Description
1st const char *	Nom du lien de l’expéditeur.
2nd const char *	Nom du message reçu.
int32_t	L’index associé au message.
double	La valeur associée au message.

Examples

Code pour le robot 1

// Send whether screen is pressed on left or right
void screen_pressed() {
  if (Brain.Screen.xPosition() < 240) {
    link.send("left");
  } else {
    link.send("right");
  }
}

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();
  
// Create the link
  message_link link(PORT1, "LeftRightLink", 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.pressed(screen_pressed);

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

Code pour Robot 2

// Create variable to track where screen is pressed
int lastPress = 0;

// Update the variable whenever a new message is received
void message_received(const char* message, const char* linkname, double timestamp) {
  if (strcmp(message, "left") == 0)  lastPress = 1;
  if (strcmp(message, "right") == 0) lastPress = 2;
}

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

// Create the link
  message_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(message_received);

  // Display if Robot 1's screen was pressed on the left or right
  while (true) {
    Brain.Screen.clearScreen();
    Brain.Screen.setCursor(1, 1);
    Brain.Screen.print("Robot 2 - Worker");
    Brain.Screen.newLine();

    if (lastPress == 1) {
      Brain.Screen.print("Manager pressed LEFT");
    } else if (lastPress == 2) {
      Brain.Screen.print("Manager pressed RIGHT");
    } else {
      Brain.Screen.print("Waiting...");
    }

    wait(0.1, seconds);
  }
}