Débuter avec l’IoT Cloud d’Arduino

Pour commencer, vous allez créer un circuit assez simple comportant une LED câblée à une carte Arduino MKR 1000 (ou MKR WiFi 1010). Comme indiqué sur le schéma, connectez la patte positive de la LED au connecteur Digital Pin 2 de la carte, et la patte négative en série avec une résistance 150 Ω à la masse Ground. Notez bien que l’alimentation amenée sur la plaque d’essai provient du connecteur Vcc, et non du connecteur 5V de la carte MKR 1000. Si malencontreusement vous alimentez au 5V, vous pourriez endommager la carte, plus tard dans le tutoriel, quand vous ajouterez le bouton-poussoir.

Maintenant que la LED est câblée, il faut configurer le dispositif pour l’Internet des Objets (ou IoT pour Internet of Thing). Pour cela, il faut commencer par configurer la carte Arduino afin qu’elle puisse communiquer avec le cloud. Pour ce projet, vous pouvez choisir indifféremment la carte MKR 1000 ou MKR WiFi 1010. Rendez-vous dans l’Arduino IoT Cloud et consultez le guide Getting Started pour vous aider à configurer votre carte, lui donner un nom et récupérer les clés qui permettront de sécuriser votre connexion au cloud en passant par un canal chiffré.

Une fois configurée, vous pourrez créer votre premier objet (thing). Votre carte MKR sera automatiquement sélectionnée pour être associée à votre objet, et tout ce qu’il vous reste à faire est de lui donner un nom. On choisira ici d’appeler notre objet IoTCloud_Tutorial_Thing.

Vous serez alors redirigé vers la page d’édition de votre objet, où vous pourrez créer et ajouter ses propriétés (ou properties, des interfaces vers vos capteurs et actionneurs auxquels vous souhaitez accéder depuis le cloud).

L’objectif est d’allumer ou éteindre une LED depuis le cloud en cliquant sur un widget graphique en forme d’interrupteur dans votre navigateur Internet. Pour cela, vous devez créer une propriété (property) en cliquant sur le bouton [+] comme indiqué sur l’image ci-dessous :

On choisira light comme nom significatif de la propriété (ce nom sera repris comme nom de variable dans le croquis Arduino).

On prendra ON/OFF (Boolean) pour le type de la propriété.

Vous pouvez laisser le champ Permission à Read and Write, de manière à autoriser l’utilisateur à basculer l’interrupteur ON/OFF de la LED depuis le navigateur en cliquant dessus. Vous laisserez également le champ Update à When the value changes, pour répercuter tout changement de valeur de la propriété dans le cloud. Finalement, cliquez sur le bouton [CREATE].

Depuis la vue d’édition des priorités, vous pouvez maintenant cliquer sur [EDIT CODE]. Cela vous redirigera vers l’éditeur de code avec un croquis fonctionnel de votre objet généré automatiquement.

Le croquis porte le même nom que votre objet, suivi de la date de création et éventuellement d’un numéro de version si le nom du croquis existe déjà. En plus du fichier principal main.ino, la copie d’écran ci-dessus montre trois fichiers supplémentaires dans des onglets :

• ReadMe.adoc : un fichier texte contenant des informations à propos du croquis, de l’auteur et du projet lui-même ;

  

• thingProperties.h : le code généré par l’Arduino IoT Cloud quand vous avez ajouté la propriété light. Il n’y a pas besoin de modifier le code, mais il sera intéressant d’y jeter un œil pour voir les variables du fichier principal (.ino) qui seront synchronisées avec le cloud ;

  

• Secret : cet onglet permet de renseigner les valeurs des variables SECRET_SSID et SECRET_PASS, qui sont les identifiant et mot de passe du réseau WiFi auquel votre carte doit se connecter.

Regardons le code plus en détail :

#include <ArduinoIoTCloud.h>
#include <WiFiConnectionManager.h>

char ssid[] = SECRET_SSID;    // Network SSID (name)
char pass[] = SECRET_PASS;    // Network password (use for WPA, or use as key for WEP)

#define THING_ID "22daf5e7-4ed2-4228-adca-14d162c26826"

void onLightChange();

bool light;

void initProperties(){
  ArduinoCloud.setThingId(THING_ID);
  ArduinoCloud.addProperty(light, READWRITE, ON_CHANGE, onLightChange);
}

ConnectionManager *ArduinoIoTPreferredConnection = new WiFiConnectionManager(SECRET_SSID, SECRET_PASS);

Ligne 1 : importation de la bibliothèque ArduinoIoTCloud, nécessaire pour synchroniser les variables locales du croquis avec leurs propriétés IoT Cloud.

Ligne 2 : la bibliothèque WiFiConnectionManager s’occupe de la connexion WiFi et de son maintien en continu.

Ligne 4-5 : ces valeurs sont extraites de l’onglet Secret.

Ligne 7 : l’identifiant unique de l’objet (thing).

Ligne 9 : cette ligne déclare une fonction à appeler chaque fois que la valeur de la propriété light est modifiée depuis le tableau de bord. On appelle ce type de fonction : fonction de rappel (ou callback).

Ligne 11 : déclaration de la variable light.

Ligne 13 : cette fonction sera appelée depuis le bloc setup() du fichier principal .ino.

Ligne 14 : indique l’objet auquel il faut se connecter.

Ligne 15 : indique au croquis de traiter la variable light en tant que propriété (property) de l’objet (thing), et d’exécuter la fonction de rappel onLightChange chaque fois que la valeur de la propriété est modifiée depuis l’Arduino IoT Cloud. La permission est définie à READWRITE conformément à celle choisie lors de la création de la propriété.

Ligne 18 : initialise le gestionnaire de connexion avec les identifiant (SECRET_SSID) et mot de passe (SECRET_PASS) du point d’accès WiFi, définis dans l’onglet Secret.

/* 
  Sketch generated by the Arduino IoT Cloud Thing "IoTCloud_Tutorial_Thing"
  https://create.arduino.cc/cloud/things/22daf5e7-4ed2-4228-adca-14d162c26826 

  Arduino IoT Cloud Properties description

  The following variables are automatically generated and updated when changes are made to the Thing properties

  bool light;

  Properties which are marked as READ/WRITE in the Cloud Thing will also have functions
  which are called when their values are changed from the Dashboard.
  These functions are generated with the Thing and added at the end of this sketch.
*/

#include "thingProperties.h"

void setup() {
  /*
     The following function allows you to obtain more information
     related to the state of network and IoT Cloud connection and errors
     the higher number the more granular information you’ll get.
     The default is 0 (only errors).
     Maximum is 3     
 */
  setDebugMessageLevel(2);

  // Initialize serial and wait for port to open:
  Serial.begin(9600);
  // This delay gives the chance to wait for a Serial Monitor without blocking if none is found
  delay(1500); 

  // Defined in thingProperties.h
  initProperties();

  // Connect to Arduino IoT Cloud
  ArduinoCloud.begin(ArduinoIoTPreferredConnection);
}

void loop() {
  ArduinoCloud.update();
  // Your code here 
  
  
}


void onLightChange() {
  // Do something
}

Comme dans tout croquis Arduino, on retrouve les deux fonctions void setup(){...} et void loop() {...}. La fonction setup() est appelée une seule fois à la mise sous tension ou après un reset de la carte. La fonction loop()s’exécute en boucle indéfiniment, tant que la carte est alimentée.

Ligne 16 : importe les fonctions et variables déclarées dans thingProperties.h comme pour toute bibliothèque importée.

Ligne 26 : fixe le niveau de détail des messages du journal de suivi (log) qui seront affichés dans le Moniteur Série (Serial Monitor). Actuellement fixé à 2, on peut le changer avec une valeur comprise entre 0 (qui n’affiche que les messages d’erreur) et 3 (qui affiche TOUT le contenu du journal). Si quelque chose ne fonctionne pas avec la connexion, que ce soit avec le WiFi ou le Cloud, il sera plus simple de trouver la solution si le niveau de détail des messages est élevé. Pour le moment, on peut laisser tel quel.

Ligne 29 : initialise le Moniteur Série, pour affichage ou lecture de données.

Ligne 31 : attendre 1,5 seconde pour donner le temps nécessaire au Moniteur Série de s’initialiser.

Ligne 34 : initialise les propriétés définies dans thingProperties.h.

Ligne 37 : initialise la connexion à l’Arduino IoT Cloud avec le gestionnaire de connexion passé en paramètre.

À l’intérieur de la boucle loop(), on trouve :

Ligne 41 : beaucoup de choses se passent en coulisses derrière cette ligne. Cela inclut la synchronisation des valeurs des propriétés entre le cloud et la carte, la gestion de la connexion au réseau et le Cloud, et d’autres choses encore. Si la valeur d’une propriété change dans le programme, la bibliothèque va automatiquement détecter la modification et la notifier dans le Cloud, puis le résultat sera répercuté dans le tableau de bord. Et inversement, lorsque la valeur d’une propriété est modifiée depuis le tableau de bord, la valeur sera automatiquement répercutée dans le programme de la carte.

Lignes 48-50 : l’implémentation de la fonction de rappel (callback) qui sera sollicitée à chaque fois que la valeur de la propriété light est modifiée. Ici, on doit ajouter le code qui doit être exécuté quand on modifie la propriété depuis le tableau de bord.

Voyons les lignes de code qu’il faut rajouter afin d’allumer ou éteindre une LED lorsqu’on clique sur le bouton ON/OFF depuis le tableau de bord.

Premièrement, on doit définir le connecteur de la carte où est connectée la LED. Ajoutez cette déclaration avant la fonction setup() :

#define LED_PIN 2

Dans la fonction setup(), on doit configurer le connecteur en sortie (OUTPUT) :

pinMode(LED_PIN, OUTPUT);

Finalement, dans la fonction onLightChange(), on affiche l’état de la variable light dans le Moniteur Série et on bascule l’état ON/OFF de la LED. Notez que ce type de fonction de rappel est automatiquement généré lors de la définition d’une propriété avec les permissions Read and Write.

void onLightChange() {
    digitalWrite(LED_PIN, light);
    Serial.print("The light is ");
    if (light) {
        Serial.println("ON");
    } else {
        Serial.println("OFF");
    }
}

Et c’est tout. Il ne reste plus qu’à téléverser le croquis en cliquant sur le bouton Upload.

Vous pouvez vérifier si tout fonctionne en ouvrant le Moniteur Série à gauche.

Avec le niveau de détail fixé à 2 du journal de suivi, le Moniteur Série affiche les informations sur la progression de la connexion au réseau et à l’IoT Cloud.

Après la connexion au WiFi et l’accès sécurisé à la plateforme IoT Cloud, des données commencent à être échangées avec la carte :

[ 144313 ] Connecting to "xxxxxx"
[ 148284 ] Connected to "xxxxxx"
[ 148284 ] Acquiring Time from Network
....
[ 148690 ] Network Time: 1550057496
[ 148910 ] Connecting to Arduino IoT Cloud...
[ 152212 ] Connected to Arduino IoT Cloud

Un message d’erreur sera affiché si une des étapes échoue. Si cela arrive, vous pouvez faire un reset de la carte et recommencer, mais si vous avez bien suivi toutes les étapes, il est peu probable que cela se produise :-)

En cliquant sur le bouton [GO TO IOT CLOUD], vous serez redirigé vers la page de contrôle de votre objet. À partir de là, on clique sur le bouton d’accès au tableau de bord (dashboard) :

Vous devriez apercevoir un widget représentant l’état de la propriété light, et il devrait être initialement à l’état OFF.

Il vous reste à cliquer dessus encore et encore, et constater que la LED s’allume puis s’éteint, et s’allume à nouveau, s’éteint, etc.

Mission accomplie !

Maintenant qu’on a confirmation que tout fonctionne, on peut ajouter de nouvelles propriétés à notre objet. On commencera par lier une nouvelle propriété à un potentiomètre câblé au circuit existant. Le potentiomètre est relié à l’alimentation et à la masse, et son curseur au connecteur Analog Pin A1 de la carte Arduino.

Pour ajouter une nouvelle propriété, il faut procéder comme expliqué plus haut : dans la vue d’édition des propriétés de l’objet, cliquez sur le bouton [+] et donnez le nom angle à la propriété. Sélectionnez le type Int avec des valeurs comprises entre 0 et 270 (champs Min Value et Max Value). La permission sera fixée à Read Only et la propriété sera mise à jour sur changement de la valeur. On devra mettre un Delta strictement supérieur à 0 si l’on veut régler la fréquence des mises à jour. Par exemple, avec un Delta égal à 5, la valeur de la propriété sera mise à jour depuis le cloud seulement si la différence entre la nouvelle et l’ancienne valeur est supérieure à 5, sinon le changement sera ignoré.

Cliquer sur le bouton [CREATE] ajoutera la nouvelle propriété à l’objet en cours, et permettra de revenir à la fenêtre d’édition.

Entre temps, le croquis a été mis à jour pour refléter les changements. Cliquez sur [EDIT CODE] pour revenir dans l’éditeur de code et regardez dans le code de l’onglet thingProperties.h, vous noterez que deux nouvelles lignes sont apparues.

Déclaration de la variable angle représentant la valeur de la propriété qui vient d’être créée :

int angle;

Connexion de la variable angle à sa propriété correspondante, avec la permission READ (impossibilité de modification depuis le tableau de bord). Avec cette permission READ uniquement, il n’y a pas de fonction de rappel générée, d’où le paramètre NULL. Le dernier argument représente la valeur du paramètre Delta discuté plus haut :

ArduinoCloud.addProperty(angle, READ, ON_CHANGE, NULL, 5.000000);

Pour faire interagir le potentiomètre avec le cloud, il faut définir le connecteur de la carte avec lequel il sera connecté dans le fichier principal .ino :

#define POTENTIOMETER_PIN A1

Ensuite, dans la boucle loop(), on lit la valeur sur l’entrée analogique où est relié le potentiomètre, et on rééchelonne la plage des valeurs entre 0 et 270. Ainsi, en tournant le bouton du potentiomètre, la valeur de la propriété sera modifiée et répercutée dans le tableau de bord.

int angleSensor = analogRead(POTENTIOMETER_PIN);
angle = map(angleSensor, 0, 1023, 0, 270);

Il ne reste plus qu’à téléverser le code (Upload) dans la carte et constater le résultat sur le tableau de bord en tournant le bouton du potentiomètre. La valeur devrait évoluer entre 0 et 270 (mais la plage de valeurs peut dépendre du potentiomètre et de la qualité de sa fabrication).

Pour conclure ce tutoriel, on ajoutera une dernière propriété ! Cette nouvelle propriété sera associée à un bouton-poussoir qui complétera le circuit selon le schéma ci-dessous : une broche du bouton sera reliée au rail d’alimentation (Vcc), l’autre broche sera reliée au connecteur Digital Pin 5 (le fil blanc) et à la masse au travers d’une résistance pull-down 10 kΩ. Cette configuration tire le connecteur au niveau logique bas (LOW) lorsque le bouton est relâché, et au niveau logique haut (HIGH) lorsque le bouton est pressé.

Depuis l’éditeur, cliquez sur [GO TO IOT CLOUD] et créez une nouvelle propriété nommée toggle, de type ON/OFF (Boolean), permission Read Only et Updtate When the value changes.

Une fois de plus, cliquez sur [EDIT CODE] pour revenir à l’éditeur de code. Un coup d’œil rapide dans le code du fichier thingProperties.h fait apparaître une nouvelle variable toggle, associée à sa propriété via ArduinoCloud.assProperty(…).

Dans le fichier principal .ino, on définit un nouveau connecteur et deux variables définissant l’état du bouton (qui seront explicitées plus bas dans ce tutoriel) :

#define BUTTON_PIN 5
int btnState;
int btnPrevState = 0;

La variable btnPrevState (état précédent du bouton) est nécessaire, car on doit mettre à jour la propriété seulement sur changement d’état lorsque l’utilisateur presse le bouton, et non quand il relâche la pression sur celui-ci.

Ensuite, dans la fonction setup() , on configure le connecteur relié au bouton en entrée (INPUT) :

pinMode(BUTTON_PIN, INPUT);

Et finalement, on rajoute ces quelques lignes à la fin de la boucle loop() :

btnState = digitalRead(BUTTON_PIN);
if (btnPrevState == 0 && btnState == 1) {
 toggle = !toggle;
}
btnPrevState = btnState;

De cette façon, le bouton agit comme un interrupteur à bascule et vous verrez l’état de la bascule commuter TRUE/FALSE dans le tableau de bord à chaque pression sur le bouton-poussoir.

Étonnant, n’est-ce pas ? Téléversez le code (Upload) et testez par vous-même en appuyant sur le bouton pour vous en rendre compte.

Du chemin a été parcouru depuis le début de ce tutoriel, et vous avez maintenant les moyens de réaliser de puissantes applications pour vos objets connectés. On vous propose quand même de poursuivre et simplifier la gestion du bouton-poussoir en utilisant une bibliothèque extérieure.

Quand vous utilisez des boutons-poussoirs comme on a vu précédemment, vous pouvez être confronté au fameux problème des « rebonds », un phénomène de transition lors de l’établissement mécanique du contact entre parties métalliques, où le signal va osciller quelques millisecondes entre les deux états logiques haut et bas. Ce phénomène peut mettre en défaut le fonctionnement normal de votre croquis, et sa prise en compte par un système anti-rebond logiciel peut rendre le code peu lisible (variables temporaires pour mémoriser l’état précédent du bouton, temporisations, etc.) Imaginez alors le code si vous aviez plusieurs boutons à gérer de la sorte…

Une solution plus rapide consiste à utiliser une bibliothèque logicielle dédiée à la gestion des boutons, incluant un système anti-rebonds (debouncing library). La bibliothèque FTDebouncer que l’on peut installer par l’intermédiaire du gestionnaire de bibliothèques (library manager) est une de ces solutions.

Il suffit de se rendre dans le menu Libraries dans la barre de menus sur le côté, saisir « FTDebouncer » dans le champ de recherche et d’appuyer sur Entrée : la bibliothèque apparaîtra et vous pourrez alors l’inclure dans votre croquis en pressant le bouton INCLUDE.

Vous verrez alors une ligne supplémentaire dans le code du fichier principal .ino :

#include <FTDebouncer.h>

Avant le setup(), vous remplacerez les définitions de variables relatives à l’état du bouton…

int btnState;
int btnPrevState = 0;

… avec la déclaration d’une instance de la classe FTDebouncer :

FTDebouncer buttons;

Puis vous remplacerez la ligne d’initialisation…

pinMode(BUTTON_PIN, INPUT);

…par les deux lignes suivantes :

buttons.addPin(BUTTON_PIN, LOW);
buttons.init();

Au début de la boucle loop(), vous ajouterez la commande…

buttons.update();

…et vous supprimerez ces lignes relatives à la gestion du bouton :

btnState = digitalRead(BUTTON_PIN);
if (btnPrevState == 0 && btnState == 1) {
    toggle = !toggle;
}
btnPrevState = btnState;

Finalement, à la fin du croquis, vous ajouterez les fonctions suivantes :

void onPinActivated(uint8_t pinNr){
    Serial.println(pinNr);
    toggle = !toggle;
}
void onPinDeactivated(uint8_t pinNr){
    Serial.println(pinNr);
}

Grâce à la bibliothèque FTDebouncer, la fonction onPinActivated() sera appelée quand le bouton est pressé (une seule fois). Quand cela se produit, la propriété toggle change d’état en basculant (bascule à True si False et vice-versa) grâce à l’opérateur ! (opérateur logique NON)

Si on veut exécuter du code en particulier lorsque le bouton est relâché, une fonction onPinDeactivated() est même prévue pour cela.

Ceci termine ce tutoriel détaillé pour débuter avec l’Arduino IoT Cloud.

Si vous avez des retours à faire, vous pouvez vous rendre sur les pages du forum de la communauté Arduino et poser vos questions sur les discussions ouvertes à l’occasion.

Nous travaillons très dur pour créer des outils faciles d’accès pour notre communauté afin qu’elle puisse développer des applications connectées, et de plus en plus de cartes Arduino seront supportées au fur et à mesure des évolutions du projet.

Merci de votre attention, nous veillons toujours à créer davantage de contenus pour une plus grande satisfaction de la communauté.

Bien à vous,

The Arduino Team

• Schéma du circuit

  

• Code complet : Arduino_IoT_Cloud_Example

• FT Debouncer Library sur GitHub

Vous pouvez retrouver la version originale de ce tutoriel rédigé par l’Arduino Team en suivant ce lien : IoT Cloud - Getting Started

Nous remercions les membres de la rédaction pour le travail de traduction et relecture qu’ils ont effectué, en particulier : f-leb et naute.