xPL.Arduino, réception des messages

Bonjour, j’ai ouvert un projet sur google code récement : xPL.Arduino. C’est une librairie permettant l’émission et le decodage de message xPL. Je vais vous expliquer rapidement dans cet article comment réceptionner et parser les messages xPL.

[adsGrandRectangleHTexte]

Les sources de la librairie sont accessibles sur google code et la version 0.2 est disponible dans la section download.

Je vais vous détailler les exemples concernant le shield ENC28J60 puisque c’est celui que j’utilise pour le moment et qu’il est légèrement plus compliqué à mettre en oeuvre.

Réception des messages xPL

Je vous rappelle que j’utilise la librairie ethercard pour la gestion du shield ethernet.

La partie déclaration. On définit ici le buffer de réception des trames ethernet (au moins égale à la taille max d’un message xPL) ainsi que les paramètres de la carte réseau. Adresse IP, MAC, Passerelle et l’adresse de broadcast du réseau.
Attention, la librairie ethercard n’émet des packets en broadcast que sur l’adresse 255.255.255.255, n’indiquez donc pas ici l’adresse de broadcast du réseau (192.168.0.255 dans mon cas). Et si vous utilisez xpl-perl, indiquez au xpl-hub d’écouter sur 0.0.0.0 avec –define broadcast=0.0.0.0 sinon vous ne recevrez rien :/

#include <xPL.h>
#include <EtherCard.h>

byte Ethernet::buffer[XPL_MESSAGE_BUFFER_MAX];
xPL xpl;

// Init du serveur HTTP
uint8_t mymac[6] = { 0x54,0x55,0x58,0x10,0x00,0x11 };
uint8_t myip[4] = { 192,168,0,133 };
uint8_t gwip[4] = { 192,168,0,240};

// Ethercard seems to only send broadcast on this addr
// if using xpl-perl, don't forget to add "--define broadcast=0.0.0.0" to the xpl-hub
uint8_t broadcast[4] = { 255,255,255,255};

On définit ensuite deux fonctions. Une qui se chargera de l’émission des messages sur le réseau. Cette fonction est à adapter en fonction du shield ethernet et de la libraire ethernet utilisée.

void SendUdPMessage(char *buffer)
{
    ether.sendUdp (buffer, strlen(buffer), xpl.udp_port, broadcast, xpl.udp_port);
}

La deuxième fonction sera appellée par la librairie xPL à chaque fois qu’elle aura parsé un message xPL avec succès. On y fait ce que l’on veut, c’est ici que l’on va faire réagir l’arduino en fonction du type de message reçu.
Dans l’exemple, on affiche le message dans la console et si le message est explicitement destiné à l’arduino (xpl.TargeIsMe), on vérifie de quel type est ce message. Si son schéma est de type lighting.basic on affiche un message sur la console.

void AfterParseAction(xPL_Message * message)
{
  if (xpl.TargetIsMe(message))
  {
    if (message->IsSchema_P(PSTR("lighting"), PSTR("basic")))
    {
      Serial.println(PSTR("is lighting.basic"));  
    }
  }

  // show message
  Serial.println(message->toString());
}

Vient ensuite le setup. On passe nos deux fonctions à la librairie xPL, puis on définit la source par laquelle l’arduino sera vu sur le réseau xPL, ici : xpl-arduino.test. Il reste ensuite à définir l’interval en minutes entre chaque message heartbeat. Ces messages permettent aux autres applications xPL du réseau de connaitre votre application et de savoir si elle est toujours active.

void setup()
{
  [...]

  xpl.SendExternal = &SendUdPMessage;  // pointer to the send callback
  xpl.AfterParseAction = &AfterParseAction;  // pointer to a post parsing action callback
  xpl.SetSource_P(PSTR("xpl"), PSTR("arduino"), PSTR("test")); // parameters for hearbeat message
}

Le corp du sketch. On commence par xpl.Process(). Cette méthode gère l’émission des messages heartbeat.
On récupère ensuite les packets entrant (ether.packetReceive()) et si c’est un message xPL on le parse avec xpl.ParseInputMessage.
Si vous avez suivis, une fois le parsing terminé, la librairie appelle notre fonction AfterParseAction pour traiter le message.

void loop()
{
   xpl.Process();  // heartbeat management

   word len = ether.packetReceive();
   if( len > 0 )
   {
     // Check if Xpl UDP packet
     if( isXpl( Ethernet::buffer ) )
     {
       char xPLMessageBuff[XPL_MESSAGE_BUFFER_MAX];
       ByteToChar(Ethernet::buffer, xPLMessageBuff, len);

       // parse du message
       xpl.ParseInputMessage(xPLMessageBuff);
     }
   }
}

Et voila, c’est tout pour la réception de messages. Je vous invite à lire l’article suivant sur l’émission de message xPL.