Üzenetlink#

Bevezetés #

A message_link osztály lehetővé teszi két V5 Brain közötti kommunikációt rövid, opcionálisan kis adatmennyiségekkel rendelkező üzenetek küldésével. Robotok közötti koordinációra tervezték – például rutinok indítására, érzékelőeredmények megosztására vagy viselkedések kiváltására egy másik roboton.

A send minden egyes használata egy üzenetet ad a csatolt V5 Brain sorához, és a sor FIFO (first-in, first-out) elv alapján kerül olvasásra. Ha több üzenet is elküldésre kerül, mielőtt a másik V5 Brain a receive metódust használja, akkor azok egyenként, a küldés sorrendjében kerülnek tárolásra és visszaküldésre. Mivel az üzenetek sorba állíthatók, az állapot ismételt elküldése minden ciklusban várakozást okozhat; időkritikus logika esetén csak akkor küldjön üzenetet, ha az értékek megváltoznak.

Fontos: Mindkét robotnak egyszerre kell olyan projekteket futtatnia, amelyek message_link et használnak, különben nem lesznek üzenetek küldve/fogadva.

Osztálykonstruktorok #

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

Osztálydestruktor #

Megsemmisíti a message_link objektumot és felszabadítja a hozzá tartozó erőforrásokat.

virtual ~message_link();

Paraméterek #

Paraméter	Típus	Leírás
`index`	`int32_t`	Az a Smart Port, amelyhez a V5 rádió vagy a Smart Cable csatlakozik, `PORTx`formátumban írva, ahol `x` a port száma (például `PORT1`).
`name`	`char`	Az üzenethivatkozás neve.
`type`	`linkType`	A kapcsolat típusa, vagy `linkType::manager` , vagy `linkType::worker`Ez az információ a rádió megfelelő konfigurálására szolgál, valamint meghatározza az átvitelhez és vételhez rendelkezésre álló sávszélességet. Egy menedzser robot kétszer akkora sávszélességgel rendelkezik (1040 bájt/másodperc), hogy információt küldjön a munkás robotnak (520 bájt/másodperc). `linkType::manager` - A message_link objektum egy menedzser. `linkType::worker` - A message_link objektum egy munkás.
`isWired`	`bool`	Hogy a message_link objektum vezetékes-e. `true` - A message_link objektum vezetékes. `false` - A message_link objektum vezeték nélküli.

Példa #

1. robot kódja

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

Robot 2 kódja

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

Tagfüggvények #

A message_link osztály a következő tagfüggvényeket tartalmazza:

isLinked — Visszaadja, hogy ez az Agy aktívan csatlakozik-e a párosított Agyhoz.
send — Üzenetet küld a párosított Agynak.
receive — Várakozás a következő bejövő üzenetre, majd visszaküldi azt.
received — Regisztrál egy függvényt, amely minden új üzenet érkezésekor meghívódik.

Bármely message_link tagfüggvény meghívása előtt létre kell hozni egy message_link példányt, az alábbiak szerint:

1. robot kódja

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

Robot 2 kódja

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

isLinked #

isLinked metódus visszaadja, hogy a MessageLinken lévő V5 Brain-ek párosítva vannak-e egymással.

Available Functions

bool isLinked();

Parameters

Ennek a függvénynek nincsenek paraméterei.

Return Values

Ez a függvény egy logikai értéket ad vissza.

true – A két V5 agy párosítva van és ezen a kapcsolaton keresztül kommunikál.
false – A két V5 Brain nincs párosítva ezen a linken.

Notes

Jó gyakorlat, ha a projekt elején mindig ellenőrizzük, hogy a V5 Brain-ek össze vannak-e kapcsolva, mielőtt bármilyen további kódot futtatnánk.

Examples

1. robot kódja

// 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);
  }

Robot 2 kódja

// 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 #

Üzenetet küld a linkkapcsolaton keresztül.

Available Functions

1 — Üzenetet küld.
int32_t send( 
  const char *message );
2 — Egy double es karakterláncot küld.
int32_t send( 
  const char *message, 
  double      value );
3 — Egy üzenetet küld, amelyben egy int32_t és egy double található.
int32_t send(
  const char *message, 
  int32_t     index, 
  double      value );

Parameters

Paraméter	Típus	Leírás
`message`	`const char*`	Az üzenet, amelyet a másik összekapcsolt V5 agynak kell küldeni.
`index`	`int32_t`	Egy egész szám, amelyet el kell küldeni a másik összekapcsolt V5 Brainnek.
`value`	`double`	Egy dupla szám, amit a másik összekapcsolt V5 Brain-nek kell elküldeni. A dupla számok 4 tizedesjegyre vannak formázva; ha kevesebb tizedesjegy van megadva, akkor a záró nullák addig kerülnek hozzáadásra, amíg 4 nem jelenik meg.

Return Values

Ez a függvény nem ad vissza semmilyen értéket.

Notes

Ha csak message üzenet kerül elküldésre, akkor a másik összekapcsolt V5 agy pontosan ezt az üzenetet kapja meg.

Ha value értéket (és index indexet, ha meg van adva) is belefoglaljuk, a fogadó agy egyetlen kódolt üzenetet kap, amely az összes mezőt ebben a sorrendben egyesíti: .message_index_value

Examples

link.send(“string”, 1, 2.55) .string_1_2.5500 -ként kapjuk meg.

1. robot kódja

// 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);
}

Robot 2 kódja

// 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 #

Üzenetet fogad a linkkapcsolattól.

Available Functions

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

Parameters

Paraméter	Típus	Leírás
`buffer`	`char*`	A fogadott üzenet tárolására szolgáló puffer.
`length`	`int32_t`	A puffer hossza.
`timeoutMs`	`int32_t`	Mennyi ideig vár `receive` ezredmásodpercben az új üzenetre, ha a sor üres. Az alapértelmezett érték 300 000 (300 másodperc).

Return Values

Ez a függvény visszaadja a fogadott bájtok számát.

Notes

receive parancs visszaadja a következő sorban álló üzenetet a másik összekapcsolt V5 Brain-től. Az üzenetek FIFO sorrendben kerülnek olvasásra (a legrégebbi olvasatlan először). Ha a várólista üres receive hívásakor, akkor a megadott timeout vár új üzenetre. Ha ebben az ablakban nem érkezik üzenet, receive parancs 0üzenetet ad vissza, és az azt követően küldött üzenetek a sorban maradnak, hogy receive következő használatakor beolvassák azokat.
Ha a másik összekapcsolt V5 Brain csak egy string, receive pontosan ezt a karakterláncot adja vissza.
Ha a másik összekapcsolt V5 Brain egész és/vagy lebegőpontos számot küldött, akkor receive egyetlen kódolt karakterláncot ad vissza, amely az összes mezőt ebben a sorrendben kombinálja: .string_integer_float
- Például, ha a másik összekapcsolt V5 Brain a link.send(“string”, 1, 2.55)függvényt használja, akkor link.receive() használata egy kódolt karakterláncot ad vissza, például .string_1_2.5500jelzést. Ezt a kódolt karakterláncot feloszthatja (lásd az alábbi példákat) az üzenet nevének, egész számának és lebegőpontos értékeinek kinyeréséhez.
- Ha inkább elkerülnéd a manuális felosztást/elemzést, használd a received függvényt egy adott üzenetnévhez tartozó kezelő regisztrálásához; a kezelő argumentumként fogadja az elküldött értékeket.

Examples

link.send(“string”, 1, 2.55) .string_1_2.5500 -ként kapjuk meg.

1. robot kódja

// 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);
}

Robot 2 kódja

// 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 #

Regisztrál egy függvényt, amely minden alkalommal meghívódik, amikor a V5 Brain elküldött üzenetet kap.

Available Functions

1 Visszahívást regisztrál az összes fogadott üzenetre (üzenet + érték).
void received(
    void (* callback)(const char *, const char *, double)
);
2 Visszahívást regisztrál az összes fogadott üzenethez (üzenet + index + érték).
void received(
    void (* callback)(const char *, const char *, int32_t, double)
);
3 Visszahívást regisztrál egy adott üzenethez (üzenet + érték).
void received(
    const char *message,
    void      (* callback)(const char *, const char *, double)
);
4 Visszahívást regisztrál egy adott üzenethez (üzenet + index + érték).
void received(
    const char *message,
    void      (* callback)(const char *, const char *, int32_t, double)
);

Parameters

Paraméter	Típus	Leírás
`message`	`const char *`	A figyelendő üzenet neve. Ha nincs megadva, a visszahívás az összes fogadott üzenetre lefut.
`callback`	`void ()(const char , const char , double)` or `void (``)(const char , const char , int32_t, double)`	Egy függvény, amely üzenet érkezésekor fut le.

Return Values

Ez a függvény nem ad vissza semmilyen értéket.

Callback Signature

1 Fogadja a küldő nevét, az üzenet nevét és az értéket.
void callback(const char *, const char *, double)
2 Fogadja a küldő nevét, az üzenet nevét, az indexet és az értéket.
void callback(const char *, const char *, int32_t, double)

Típus	Leírás
1st `const char *`	A küldő linkjének neve.
2nd `const char *`	A fogadott üzenet neve.
`int32_t`	Az üzenethez társított index.
`double`	Az üzenethez társított érték.

Examples

1. robot kódja

// Create the link.
message_link link(PORT1, "LeftRightLink", linkType::manager, true);

// 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();
  
  // 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);
  }
}

Robot 2 kódja

// 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);
  }
}