Introduction

Soyez sûr de comprendre la section sur comment écrire un sketch avant de poursuivre. Le code ci-dessous fait référence à des parties bien spécifiques, détaillées et expliquées dans la section suscitée. De plus, il est impératif d'avoir configuré la puce comme client WiFi !

Dans cet exemple, nous allons créer un serveur UDP qui va écouter les messages en unicast et multicast

Connexion au réseau

Commençons par nous connecter à un réseau en utilisant le DHCP :

#include <ESP8266WiFi.h>

const char ssid[] = "e900";
const char password[] = "********";

void setup() {
	// on démarre le port série
	Serial.begin(115200);
	// On attend "un peu" que le buffer soit prêt
	delay(10);
	// On efface la configuration précédente
	WiFi.disconnect(true);
	// Initialisation de la connection
	WiFi.begin(ssid, password);
	// Test pour déterminer quand la connection est prete
	while (WiFi.status() != WL_CONNECTED) {
		delay(500);
	}
	// Affichage des informations
	Serial.print("\nConnecte a ");
	Serial.print(ssid);
	Serial.print(" avec l'ip ");
	Serial.println(WiFi.localIP());
}
void loop() {
}

Le code précédent vous donne le résultat suivant sur le port série :

Connecte a e900 avec l'ip 192.168.1.188

Serveur UDP unicast

Création du serveur

Nous allons maintenant ajouter la partie écoute en UDP.

Dans la partie des imports ajoutez la ligne suivante :

#include <WiFiUDP.h>

Dans la partie des variables statiques ajoutez les lignes suivantes :

// Port d'écoute UDP
const uint16_t PORT = 4321;
// Taille du tampon de réception
const uint16_t BUFFER_SIZE = 512;
// Tampon de réception
char buffer[BUFFER_SIZE];
// Taille du paquet reçu;
uint16_t len = 0;
// L'instance du serveur UDP
WiFiUDP udp;

A la fin de la fonction setup() nous allons ajouter les lignes suivantes :

// Démarrage de l'écoute
udp.begin(PORT);
Serial.print("Démarrage de l'ecoute sur le port ");
Serial.println(PORT);

Récupération et affichage des paquets

Pour récupérer et afficher le contenu du paquet, nous allons créer une fonction :

void readPacket() {
	len = udp.available();
	Serial.print("Paquet de ");
	Serial.print(len);
	Serial.print(" octets recu de ");
	Serial.print(udp.remoteIP());
	Serial.print(":");
	Serial.print(udp.remotePort());
	Serial.print(" contenant '");
	// Mise en tampon du paquet
	udp.read(buffer, len);
	// Affichage du contenu du paquet
	for (int i = 1; i <= len; i++) {
		Serial.print(buffer[i - 1]);
	}
	Serial.println("'");
}

Que nous allons appeler dans la fonction loop():

void loop() {
	if (udp.parsePacket() > 0) {
		readPacket();
	}
}

Il est désormais possible, en utilisant un logiciel comme Packet Sender d'envoyer un paquet à notre ESP:

Lorsque vous appuyez sur send, vous devriez voir le message suivant s'afficher dans la console :

Paquet de 11 octets recu de 192.168.1.1:62971 contenant 'Hello World'

Envoie d'un paquet UDP

Maintenant que nous recevons les paquets, il faudrait que nous puissions répondre ! Pour cela nous allons créer la fonction suivante :

void sendPacket(const char content[], IPAddress ip, uint16_t port) {
	udp.beginPacket(ip, port);
	udp.write(content);
	udp.endPacket();
}

Pour créer un serveur echo, après la ligne:

readPacket();

Il nous suffit d'ajouter:

sendPacket(buffer, udp.remoteIP(), udp.remotePort());

On a maintenant une réponse de l'ESP:

Serveur UDP multicast

Le multicast permet de créer des groupes de diffusions, très pratiques pour parler à plusieurs équipements en ayant à envoyer qu'un seul paquet.

Pour commencer, nous allons ajouter dans la partie des variables statiques les lignes suivantes :

// Adresse IP multicast
const IPAddress IP_MCAST(239, 0, 0, 50);

Ensuite, dans la fonction setup(), nous allons remplacer les lignes suivantes :

// Démarrage de l'écoute
udp.begin(PORT);
Serial.print("Démarrage de l'ecoute sur le port ");
Serial.println(PORT);

par les lignes :

// Démarrage de l'écoute en multicast
udp.beginMulticast(WiFi.localIP(), IP_MCAST, PORT);
Serial.print("Demarrage de l'ecoute sur les adresses ");
Serial.print(WiFi.localIP());
Serial.print(" et ");
Serial.print(IP_MCAST);
Serial.print(" sur le port ");
Serial.println(PORT);

On peut maintenant envoyer un message sur n'importe laquelle des deux adresses:

Pour aller plus loin

La souscription à un groupe multicast devient nécessaire lorsque certains appareils parlent le même langage (protocole) car cela leurs permet de se reconnaître entre eux en échangeant des messages respectant un certain format. On peut prendre comme exemple les protocoles CDP ou OSPF. C'est une alternative plus intéressante que le broadcast car cela permet de cibler uniquement les équipements parlant le même langage et donc intéressés par le message.

Définition des messages

Comme dans l'élaboration de n'importe quel protocole, avant d'aller plus loin, il faut commencer par définir la sémantique des messages:

Les commandes :
- HELO → permet de connaître l'adresse unicast de tous les intervenants;
- SUBSW.X.Y.Z → ordonne à un équipement de souscrire au groupe multicast W.X.Y.Z;
- EXIT → ordonne à un équipement de quitter le groupe multicast auquel il est abonné;
Les acquittements :
- ACK → acquittement généré suite à la réussite d'une commande;
- NACK → acquittement généré suite à l'échec d'une commande;

Définition des adresses

Une fois les messages définis, il reste maintenant à décider d'une adresse multicast ou les équipements vont se retrouver.

D'après l'IANA le groupe multicast à utiliser sur un réseau local doit se trouver dans la plage 239.0.0.0/8, nous pouvons donc conserver l'adresse 239.0.0.50 comme adresse multicast de découverte. Sur cette adresse, seule les paquets HELO sont autorisés et sur les autres adresses, tous les paquets sont autorisés. C'est généralement de la sorte que l'on procède, les messages génériques comme HELO sont acceptés sur toutes les interfaces et les messages plus spécifiques sont reçu en unicast ou sur un groupe multicast restreint.

Implémentation du protocole

La première étape consiste à définir des variables statiques suivantes:

// Commande 'HELO'
const char CMD_HELO[] = "HELO";
// Commande 'subscribe'
const char CMD_SUBS[] = "SUBS";
// Commande 'EXIT'
const char CMD_EXIT[] = "EXIT";
// Contenu ACK
const char CONTENT_ACK[] = "ACK";
// Contenu NACK
const char CONTENT_NACK[] = "NACK";

Nous allons ensuite créer les fonctions suivantes pour :

envoyer un acquittement positif à l’émetteur

void sendBackAck() {
	sendPacket(CONTENT_ACK, udp.remoteIP(), udp.remotePort());
}

envoyer un acquittement négatif à l’émetteur

void sendBackAck() {
	sendPacket(CONTENT_NACK, udp.remoteIP(), udp.remotePort());
}

se désabonner d'un groupe multicast

void unsubscribe() {
	// On arrête toutes les écoutes
	udp.stopAll();
}

s'abonner à un groupe multicast

void subscribe(IPAddress mip) {
	udp.beginMulticast(WiFi.localIP(), mip, PORT);
	Serial.print("Ecoute multicast l'adresses ");
	Serial.print(mip);
	Serial.print(" sur le port ");
	Serial.println(PORT);
}

Il faut maintenant modifier la fonction readPacket() pour interpréter les messages:

void readPacket() {
	// Récupération de la taille du paquet
	len = udp.available();
	// Mise en tampon du paquet
	udp.read(buffer, len);
	// Ajout du terminateur de chaîne
	buffer[len] = '\0';
	if (strcmp(buffer, CMD_HELO) == 0) {
		// Commande 'HELO', réponse en envoyant un ACK
		sendBackAck();
	} else if (udp.destinationIP() != IP_MCAST) {
		// La paquet n'est pas à destination de l'adresse de découverte
		if (strcmp(buffer, CMD_EXIT) == 0) {
			// Commande 'EXIT', désinscription du groupe et ACK
			sendBackAck();
			// On arrête toutes les écoutes
			unsubscribe();
			// On démarre l'écoute sur le groupe de découverte
			subscribe(IP_MCAST);
		} else if (strncmp(buffer, CMD_SUBS, 4) == 0) {
			// Commande 'subscribe'
			IPAddress mip;
			// Test de validité de l'adresse
			if (mip.fromString(buffer + strlen(CMD_SUBS))) {
				sendBackAck();
				// On arrête toutes les écoutes
				unsubscribe();
				// On démarre l'écoute sur le groupe de découverte
				subscribe(IP_MCAST);
				// On démarre l'écoute sur le nouveau groupe
				subscribe(mip);
			} else {
				sendBackNack();
			}
		}
	} else {
		// Commande non reconnue
		sendBackNack();
	}
}

Mise en pratique

Découverte

La premier test est celui du paquet 'HELO' fait sur le réseau multicast de découverte :

On voit que tous les deux équipements présents sur le groupe ont répondu !

Écoute sur un autre groupe

Dans un premier temps, on peut s'assurer du faite que les paquets SUBS ne fonctionne pas sur le réseau de découverte:

On a bien la réponse NACK attendue.

Testons maintenant sur une adresse unicast:

et sur le port série on a :

Ecoute multicast sur l'adresses 239.0.0.50 sur le port 4321
Ecoute multicast sur l'adresses 239.0.0.25 sur le port 4321

Désinscription

La désinscription marche sur le même principe, elle ne fonctionnera qu'en unicast ou sur le groupe multicast restreint 239.0.0.25 :