Faites communiquer votre Arduino avec votre appareil Android

Cet article est un article « invité », rédigé par Sébastien (vous pourrez retrouver d’autres de ces réalisations à la fin de l’article).

Bonjour à tous !

Dans ce tutoriel porté sur Android et Arduino, nous allons connecter ces deux mondes géniaux (n’est-ce pas 😀 ?). Nous allons illustrer ce tutoriel par une application concrète ! A la fin, vous aurez une application Android avec deux boutons. Ces deux boutons permettront soit d’allumer une led connecté à l’Arduino, soit de l’éteindre. Pour cela, vous allez avoir besoin du matériel suivant :

  • Un Arduino avec un shield Ethernet (ou wifi) ainsi qu’une led et sa résistance
  • Un appareil sous Android
  • Un ordinateur

L’ordinateur jouera le rôle du serveur : il recevra les messages envoyés par l’application Android et les renverra ensuite à l’Arduino. Sachez qu’il est tout à fait possible d’envoyer des messages de l’Arduino à Android.

Au niveau des compétences requises, des connaissances basiques en programmation Android et en Arduino suffiront !

Si vous voulez voir le résultat que vous obtiendrez à la fin de ce tutoriel, je vous invite à vous rendre à la section « Résultat » où vous trouverez une vidéo !

Le protocole MQTT

Pour faire communiquer l’appareil Android avec l’Arduino, nous allons utiliser un langage commun : le protocole MQTT. L’avantage de ce protocole, c’est qu’il existe une librairie pour Android et une librairie pour Arduino. Ainsi nos deux mondes communiqueront de la même façon !

Le protocole MQTT est un protocole de messagerie de type Publish-Subscribe basé sur le protocole TCP/IP (d’où la nécessité du shield Ethernet). Le protocole se décompose donc en trois grandes parties :

  • Les « publishers » : ils envoient un ou des message(s) sur un ou plusieurs « Topic »
  • Le « broker » MQTT : il fait le lien entre les « publishers » et les « subscribers »
  • Les « subscribers » : ils s’abonnent à un ou plusieurs « Topic ». Lorsque qu’un message est publié sur un topic, tous les subscribers de ce topic reçoivent le message

Le broker MQTT permet de faire le lien entre le publisher (appareil Android) et le subscriber (Arduino). Dans notre exemple il n’y a qu’un seul publisher et qu’un seul subscriber, mais il pourrait y en avoir plus.

Le broker MQTT : le nœud central

Le broker MQTT est le cœur de notre architecture (voir image ci-dessous). Il va permettre de faire communiquer l’appareil Android avec l’Arduino.

Architecture

Architecture

Rassurez-vous, vous n’aurez pas besoin de développer votre propre broker, il en existe déjà. Mais si cela peut satisfaire votre soif de développement, ça fera un bon exercice !

Celui que je vais utiliser tout au long de ce tuto, et que je vous conseille, est le broker « Mosquitto ». C’est un broker open source. Il suffit de télécharger l’exécutable sur le site officiel (https://mosquitto.org/) et de l’installer. Pensez à lire le fichier readme.txt qui se trouve à la racine du dossier d’installation, car il vous précise les dépendances à installer. Il vous faudra notamment installer pthread, openSSL (les liens vous sont fournis dans le readme) ainsi que l’ajout de quelques dll. Pour information, il vous faudra placer les dll dans le dossier de l’installation.

Pour le lancer, une simple ligne de commande suffit. Dans mon cas ça donne (sachant que je suis sous Windows) :

Il suffit donc de lancer l’exécutable qui a été installé, avec les options :

  • -v : mode verbose
  • -p 1883 : on va utiliser le port de l’ordinateur 1883

Vous voilà avec un broker qui tourne et qui est prêt à recevoir et envoyer des messages !

Connectez votre appareil Android au broker MQTT

On va à présent créer notre application Android ! Elle sera composée de deux boutons : un pour allumer la LED connectée à notre Arduino, et l’autre pour l’éteindre.

Initialisez votre projet Android

On va dans un premier temps initialiser notre projet pour qu’il puisse communiquer avec le protocole MQTT. Pour cela, il faut :

– Ajouter les dépendances dans le fichier gradle:

– Au tout début de votre fichier gradle :

– Dans la partie dependencies de votre fichier gradle:

– Ajouter le service dans le Manifest entre les balises (si vous l’oubliez, vous n’aurez aucune erreur mais il vous sera impossible de vous connecter au broker et d’envoyer/recevoir des messages. Si je vous dis ça c’est que j’ai passé quelques heures à débogger mon application pour ce simple oublie) :

Ajouter les permissions dans le Manifest (en dessous de la balise fermante : ) :

Connectez vous au broker MQTT

Votre projet est enfin prêt ! Nous allons maintenant créer la méthode qui va nous permettre de nous connecter au broker. Voici son prototype :

  • Le premier argument address, correspond à l’adresse IP où se situe le broker. Pour connaitre l’adresse IP de votre ordinateur (sous windows), ouvrez une console et tapez la commande ipconfig et cherchez la ligne Adresse IPv4. L’adresse est de la forme : 192.168.1.xxx
  • Le second argument port correspond au port utilisé par votre broker MQTT.

Dans la partie précédente, nous avons lancé notre broker MQTT sur le port 1883.

Le corps de la méthode est assez simple. Je vous laisse le découvrir par vous même. Si la connexion est réussi, la méthode onSuccess est appelée, sinon la méthode onFailure sera appelée. Attention ! Vous aurez une erreur sur la dernière ligne, quand on appelle la méthode setCallback, ainsi que sur la ligne subscribe(topic);. Commentez les, nous y reviendrons plus tard.

Il ne vous reste plus qu’à appeler cette méthode dans la méthode onResume et vous serez connecté à votre broker ! Pensez à mettre votre propre adresse IP et à avoir le broker qui tourne sur votre ordinateur pour que la connexion puisse se faire.

Bien sûr, si vous vous connectez au broker dans la méthode onResume, il faut penser à vous déconnecter dans la méthode onPause. Je ne détaille pas le code mais je vous le donne (il est assez simple) :

Envoyez un message sur un topic

Pour envoyer un message, nous aurons besoin de deux choses : le topic sur lequel envoyer le message et le message lui-même. Pour ce faire, nous allons utiliser la méthode publish de notre client (de classe MqttAndroidClient). Cette méthode prend en paramètre un topic et un message, ça tombe bien ! Pour notre exemple, nous allons publier un message sur le topic LEDArduino. Ainsi, tous les subscribers abonnés à ce topic receveront le message. Voici le code :

Recevoir un message

Pour notre exemple, notre application Android n’aura pas besoin de recevoir de message. Vous pouvez passer cette partie si vous le souhaitez. Sachez que c’est dans cette partie que nous allons pouvoir décommenter le code précédemment commenté dans notre méthode connect.

Nous allons avoir besoin de deux choses pour recevoir des messages : souscrire à des topics et avoir un callback qui sera appelé automatiquement quand un message aura été reçu par l’application.

Pour souscrire à un topic, nous allons faire appel à la méthode subscribe de notre client. Cette méthode prend deux arguments :

– topic : le topic sur lequel on veut s’abonner
– QOS (quality of service) : peut prendre trois valeurs :
– 0 : Le message sera délivré qu’une seule fois, sans confirmation
– 1 : Le message sera délivré au moins une fois, avec confirmation
– 2 : Le message sera délivré exactement une fois, avec vérification en quatre étapes

Voici ce que donne notre méthode subscribe. Une fois inséré dans votre code, vous pouvez décommenter le code qui l’appele dans la méthode connect.

Passons maintenant à la classe qui va permettre d’avoir nos callback ! Elle doit implémenter l’interface MqttCallback. Une fois cette classe implémenter, vous allez pouvoir décommenter la méthode setCallback de la méthode connect. Dans notre exemple, la classe qui implémente cette interface se nomme MqttCallbackHandler. Je vous donne le code basique de la classe. Encore une fois, il est facile à comprendre :

Créez votre application

Nous avons maintenant toutes les bases qu’il nous faut pour créer notre application qui va communiquer avec notre Arduino. Il ne nous reste plus qu’à créer deux boutons : un bouton qui va permettre d’allumer la LED et un bouton pour l’éteindre. Si on clique sur le bouton qui doit allumer la LED, on va envoyer le message « ON » en appelant simplement la méthode sendMsg précédemment écrite. Si on clique sur le bouton pour éteindre la LED, on va envoyer le message « OFF ». Simple non ? Je vous laisse le faire, et si besoin je vous donne mon code Java et XML :

Une fois votre application terminée, elle devrait pouvoir se connecter au broker MQTT (pensez à lancer le broker sur votre ordinateur et à avoir votre appareil Android en réseau local avec votre ordinateur, par exemple en étant sur le même réseau wifi, et envoyer des messages. Lorsque vous cliquez sur un bouton sur Android, vous devriez voir dans la console que le broker MQTT a reçu un message (voir image ci-dessous).

Console Mosquitto

Console Mosquitto

Le message reçu par le broker qui fait 2 bytes est le message « ON » et le message reçu qui fait 3 bytes est le message « OFF ».

Connectez votre Arduino au broker MQTT

Initialiser votre projet Arduino

Comme pour Android, il vous faut d’abord télécharger la librairie qui va vous permettre de communiquer avec le protocole MQTT. Rendez-vous à l’adresse suivante : https://eclipse.org/paho/clients/c/embedded/ et descendez jusqu’à la section Arduino. Vous allez avoir un lien pour télécharger la librairie. Pour rappel, pour ajouter la librairie dans Arduino (téléchargée au format ZIP), il vous faut cliquer (dans l’IDE d’Arduino) sur « Croquis->Inclure une bibliothèque->Ajouter la bibliothèque .ZIP ».

Une fois la librairie ajoutée, vous pouvez utiliser le protocole MQTT ! Sachez qu’un exemple très complet vous est fourni avec la librairie. Vous le trouverez dans votre dossier Arduino->libraries->MQTTClient->example. Vous ne devriez pas avoir de mal à le lire car il reprends ce que nous avons vu avec Android (connect, subscribe, …), mais façon Arduino. Sachez d’ailleurs que je me suis grandement inspiré de cet exemple pour écrire le code que nous allons voir ensemble.

Le câblage

Pour pouvoir utiliser le protocole MQTT sur votre Arduino, il vous faut un shield ethernet (ou wifi). En effet, le protocole MQTT étant basé sur le protocole TCP/IP, le shield ethernet (ou wifi) est requis. Il vous faudra également relier votre Arduino à votre réseau local en connectant le shield à votre box via un câble ethernet (ou via wifi). Une fois ceci fait, nous allons pouvoir brancher notre LED.

Concernant la LED, je l’ai connecté au PIN 2 de l’Arduino, en série avec sa résistance (ça serait bête de la griller !). J’ai connecté l’anode sur le pin 5V de l’Arduino et la cathode sur le PIN 2. Ainsi, quand le PIN 2 sera à 0V, la LED s’allumera, et quand le PIN sera à 5V, la LED s’éteindra.

Communiquez avec le protocole MQTT

Nous allons à présent passer au code pour connecter l’Arduino au broker MQTT et pour recevoir les messages. Je ne vous montrerai pas comment envoyer un message. Vous trouverez, si besoin, les quelques lignes qui le permettent dans la fonction loop() de l’exemple fourni avec la librairie.

Les includes nécessaires sont les suivants

Les variables nécessaires

Dont le pin de la LED et le topic auquel on veut souscrire (qui sera le même que celui sur lequel on envoie les messages côté Android) :

Les fonctions connect et messageArrived

Nous allons créer la fonction qui sera appelée quand un message sera reçu. On indiquera plus tard au client MQTT que c’est cette fonction qu’il faudra qu’il appelle quand on recevra un message appartenant au topic LEDArduino. C’est dans cette fonction que nous gérons l’allumage et l’extinction de la LED en fonction du message reçu.

Maintenant il va falloir nous connecter au broker MQTT et souscrire au topic qui nous intéresse. Pour cela, nous allons créer la méthode connect, exactement de la même façon que nous avons fait pour Android. Pensez à remplacer la variable hostname par votre propre adresse IP (comme nous avons fait pour l’application Android).

Finalisation du programme

Voilà ! Toutes nos fonctions sont prêtes, il ne nous reste plus qu’à implémenter les fonctions setup() et loop() ! Pensez à appeler client.yield(1000) dans la fonction loop() sinon votre Arduino ne recevra aucun message !

Le résultat !

Nous allons à présent voir le résultat tant attendu après un travail acharné entre le monde d’Android, d’Arduino et sans oublier le protocole MQTT géré par le broker qui tourne sur votre ordinateur.

  • Lancez le broker sur votre ordinateur
  • Lancez l’application Android (soyez sûr que vous ayez toujours la bonne adresse IP pour le broker MQTT et que vous soyez connecté en réseau local avec le broker)
  • Démarrez votre Arduino connecté à votre réseau local

Amusez-vous à cliquer sur les boutons qui permettent d’allumer et d’éteindre la LED de votre Arduino !

Nous avons vu dans ce tutoriel comment faire communiquer un appareil Android avec un Arduino.

Nous nous sommes contenté, pour illustrer ce tuto, d’envoyer un message à l’Arduino pour qu’il allume ou éteigne une LED. Mais les possibilités sont infinies ! Vous pouvez envoyer des messages d’un Arduino à un appareil Android. Vous pouvez aussi faire communiquer autant d’Arduino et d’appareil d’Android que vous le voulez simultanément !

J’espère que ce tutoriel vous a plu ! Je vous laisse libre imagination pour intégrer la communication Android/Arduino dans vos futurs projets !

Si vous êtes intéressé par le développement Android, vous pouvez me retrouver :

A bientôt !

Sébastien

2 commentaires

  1. Bonjour et merci pour le partage de ce magnifique travail, ne possédant pas de PC j’ai vu des utilisateurs codé ou compilé des sketchs avec tablette et arduinodroid, mais je n’ai jamais réussi car « Error de compilation » apparemment il me faut le pack driver, où trouvé ? Comme mon uno est un funduino le clone du clone l’İDE Arduinodriod ne compile pas, alors j’ai acheté le module convertisseur ftdi voir si une petite lumière d’espoir s’allume, J’ai téléchargé votre livre unique qui, vaut de l’Or pour les novices et pro, Grand merci et Grand respect à vous ☆ ESKIMON ☆

Laisser un commentaire