Publié par

Il y a 7 mois -

Temps de lecture 6 minutes

Internet des Objets : Quels protocoles applicatifs utiliser ? (2/2)

Nous avons vu dans le premier article un ensemble de protocoles applicatifs répartis en quatre familles, nous en avons décrit le fonctionnement et les caractéristiques. Dans ce second article, nous nous attarderons sur la mise en pratique d’applications de certains des protocoles étudiés. En effet, nous allons nous intéresser plus en détail à l’utilisation des protocoles MQTT et CoAP, les plus adaptés aux objets connectés contraints (limités en ressources d’énergie et de calcul). Pour la suite, nous avons fait le choix de présenter les parties de code en Java car il s’agit du langage principalement utilisé dans les phases d’industrialisation. De plus, nous n’évoquerons que les solutions open source.

MQTT

On trouve sur Internet de nombreux frameworks open source implémentant le protocole MQTT, dont Mosquitto qui est très cité car simple à utiliser. Cependant, le déploiement en cluster n’est pas garanti, c’est pourquoi il est à écarter si vous souhaitez créer un cluster MQTT. En revanche, il est envisageable d’utiliser le framework Emqtt qui présente les meilleurs caractéristiques.

Toutefois, le framework Mosquitto est intéressant à utiliser comme publisher et subscriber comme le montrent les deux commandes ci-dessous :

mosquitto_pub -h <mqtt-broker-ip> -t <topic-name> -m "Hello Iot World"
mosquitto_sub -h <mqtt-broker-ip> -t <topic-name>

MQTT est aussi accessible via des requêtes HTTP. La commande curl suivante s’exécute sur un cluster Emqtt :

curl -v --basic -u admin:public \
	 -H "Content-Type: application/json" \
	 -d '{"topic": "test_http_request","payload": "Hello Iot World","qos": 1, \
		"retain": false,"client_id": "C_1492145414740"}' \
	 -k http://mqtt-broker-ip:8080/api/v2/mqtt/publish

Dans le cas où vous souhaitez créer vous-mêmes une application, le framework Eclipse Paho est le plus répandu en Java (vous trouverez dans ma page Github un exemple). Il suffit d’ajouter la dépendance Maven suivante pour l’inclure dans votre projet :

<dependency>
	<groupId>org.eclipse.paho</groupId>
	<artifactId>org.eclipse.paho.client.mqttv3</artifactId>
	<version>1.2.0</version>
</dependency>

Le code ci-dessous permet de créer simplement un publisher en spécifiant l’URL du broker, le nom du topic et le message à publier :

MqttClient client = new MqttClient("tcp://mqtt-broker-ip:1883", MqttClient.generateClientId());
client.connect();
MqttMessage message = new MqttMessage();
message.setPayload("My message".getBytes());
client.publish("topic_name", message);   
client.disconnect();

Afin de créer un subscriber, il faut développer une classe callback implémentant la classe org.eclipse.paho.client.mqttv3.MqttCallback. Cette classe est en charge de recevoir les messages depuis un topic MQTT :

public class MyMqttCallBack implements MqttCallback {     

	public void connectionLost(Throwable throwable) {     
		System.out.println("Connection to MQTT broker lost!");    
 	}     

	public void messageArrived(String s, MqttMessage mqttMessage) throws Exception {
		System.out.println("Here is the message received : " 
										+ new String(mqttMessage.getPayload()));
     	//TODO: implement an action     
	}     

	public void deliveryComplete(IMqttDeliveryToken iMqttDeliveryToken) {}    
}


Ainsi, la classe MyMqttCallBack est utilisée dans le code ci-dessous permettant de créer un subscriber :

MqttClient client = new MqttClient("tcp://mqtt-broker-ip:1883", MqttClient.generateClientId());
client.connect();
client.subscribe("topic_name");
client.setCallback( new MyMqttCallBack() ); 

CoAP

Tout comme pour le protocole MQTT, il y a un grand nombre de frameworks implémentant le protocole CoAP. Le framework Eclipse Californium sort du lot car il est l’un des plus utilisés et des entreprises comme Bosch et Sierra Wireless en sont membres actifs (vous trouverez dans ma page Github un exemple). Il suffit d’ajouter la dépendance Maven suivante pour l’inclure dans votre projet :

<dependency>
	<groupId>org.eclipse.californium</groupId>
	<artifactId>californium-core</artifactId>
	<version>1.0.6</version>
</dependency>

La classe org.eclipse.californium.core.CoapClient permet de créer simplement un client CoAP comme indiqué ci-dessous :

String resource = "/path/to/resource";
CoapClient coapClient = new CoapClient("coap://coap-server-ip:5683/" + resource);

/** GET request **/
CoapResponse coapResponse = coapClient.get();

/** POST request **/
CoapResponse coapResponse = coapClient.post("My message", MediaTypeRegistry.TEXT_PLAIN);

/** Treatment of server response **/
System.out.println("Is response successful ? " + coapResponse.isSuccess());
System.out.println("Code response " + coapResponse.getCode().value);
System.out.println("Text response " + coapResponse.getResponseText());

Pour développer un serveur CoAP, il faut dans un premier temps définir une stratégie pour la gestion des ressources. Pour illustrer cela, nous allons construire la resource « /sub/helloWorld » qui a pour but de retourner un message pour les requêtes GET. La classe org.eclipse.californium.core.CoapResource permet d’implémenter la gestion des requêtes GET, POST, PUT et DELETE. Dans l’exemple suivant, la classe HelloWorldResource gère, pour la ressource « helloWorld« , les requêtes GET en retournant le message « Hello IoT world » :

public class HelloWorldResource extends CoapResource { 
	public HelloWorldResource() { 
		super("helloWorld"); 
		getAttributes().setTitle("helloWorld Resource"); 
	} 
	
	@Override 
	public void handleGET(CoapExchange exchange) {
		exchange.respond(CoAP.ResponseCode.CONTENT, "Hello IoT world"); 
	}
}

L’instanciation de la classe org.eclipse.californium.core.CoapServer permet de démarrer un serveur CoAP en y ajoutant toutes les ressources implémentées au préalable comme ci-dessus.

public static void main(String[] args) throw SocketException {
	CoapServer coapServer = new CoapServer();
	addEndpoints(); // enable server to be accessible through interfaces
	CoapResource coapResource = new CoapResource("sub"); 
	coapResource.add(new HelloWorldResource());
	server.add(coapResource);
	server.start();
}
private void addEndpoints() {
    for (InetAddress addr : EndpointManager.getEndpointManager().getNetworkInterfaces()) {
        if (addr instanceof Inet4Address || addr.isLoopbackAddress()) {
            InetSocketAddress bindToAddress = new InetSocketAddress(addr, COAP_PORT);
            addEndpoint(new CoapEndpoint(bindToAddress));
        }
    }
}

 

Conclusion

Nous arrivons au terme de notre série d’articles sur les protocoles applicatifs dédiés à l’IoT. Comme on a pu le voir, il existe un grand panel de choix et il peut s’avérer difficile de faire le tri. Encore une fois, le but de nos articles n’est pas de privilégier une technologie sur une autre, mais d’identifier le ou les protocoles à choisir en fonction des besoins et du type d’objets utilisés.

MQTT et CoAP sont très en vogue car adaptés à la télémétrie des objets connectés contraints. L’avantage principale de MQTT sur CoAP est d’être capable de distribuer un même message à plusieurs destinataires en une seule connexion.

XMPP et AMQP sont fiables, robustes et conviennent pour des applications de type M2M.

WebSocket et les API REST sont des technologies qui ont fait leur preuve et sont toujours d’actualité pour l’IoT dans le cas d’objets connectés non contraints.

Publié par

Commentaire

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Nous recrutons

Être un Xebian, c'est faire partie d'un groupe de passionnés ; C'est l'opportunité de travailler et de partager avec des pairs parmi les plus talentueux.