Qu'est-ce que DeltaLab ?

DeltaLab est une association ‘loi 1901’ d’intérêt général, dont l’objectif est la création d’un espace dédié à l’innovation, à la production numérique au prototypage et à l’«expression artistique».

Le principe fondateur de l’association est d’apprendre à faire soi-même, pour passer de l’idée à l’objet.

Deltalab se spécialise en Objets Connectés, et est en train de créer un vaste «écosystème numérique» entre Drôme et Vaucluse, pour répondre à des besoins non couverts, mettre à disposition ressources et équipements pour usage professionnels et instaurer des partenariats avec les autres structures et initiatives numériques existantes.

Deltalab est aussi un FabLab (Fabrication Laboratory / Laboratoire de Fabrication ), un tiers-lieu de type makerspace où se trouve un atelier qui dispose de machines de fabrication comme des Imprimantes 3D ou des découpeuses Laser.

Deltalab se veut ouvert à tous publics : étudiants, professionnels, associations, inventeurs, designers, artistes, etc.

Contexte de cette Documentation

Un des projets à moyen termes de DeltaLab est l’installation d’un réseau LoRaWAN permettant la collecte et le traitement d’un grand nombre de données, et ce sur une grande zone s’étendant sur l’enclave des Papes et la Drôme Provençale.

Ce projet présente l'utilisation de capteurs de turbidité ( à quel point un liquide est trouble) et de température de liquide. Ces capteurs sont utilisés dans beaucoup de machines (lave-linges , lave-vaisselle,...) et dans de nombreux projets autour de l'Eau (monitoring d'une rivière, d'un château d'eau,...).
A DeltaLab, un projet d'Aquaponie est en cours de réalisation, et ces capteurs seront évidemment utilisés dès le début.

Introduction

Ce projet a pour but de présenter l'utilisation de capteurs de turbidité et de température aquatique, dans le but de les intégrer à un système plus grand.
Le projet se décompose en 2 parties distinctes : les capteurs et la carte TTGO associée, et le serveur Node-RED.

Les fonctionnalités proposées par ce projet sont les suivantes :

• Récupération des données des capteurs

• Affichage dans Node-RED

• Possible stockage dans une BDD

Logiciels

• Arduino IDE : téléchargeable à www.arduino.cc/en/main/software

• Node-RED : on assume que vous en avez un, sinon installez-le avec ceci.

• TTGO : Fichier > Préférences > URL du gestionnaire de cartes. Entrez l’URL
  https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
  Puis, dans Arduino, Outils > Type de Carte > Gestionnaire de cartes, recherchez ESP32 et installez la carte correspondante. Choisissez ensuite TTGO_LoRa_32-OLED comme Type de Carte.

• Librairies :

  • OneWire : pour le capteur

    • dans Arduino : Outils > gérer les bibliothèques
      OneWire by Paul Stroffregen

  • DallasTemperature : pour le capteur

    • dans Arduino : Outils > gérer les bibliothèques
      Dallas Temperature by Miles Burton

  • MCCI_LoRaWAN_LMIC : pour LoRaWAN

    • dans Arduino : Outils > gérer les bibliothèques
      entrez LMIC et installez la librairie MCCI_LoRaWAN_LMIC_Library

    • important : allez dans votre dossier arduino (défaut : Documents\Arduino) et allez dans la configuration de la librairie pour activer la bonne fréquence ( libraries > MCCI_LoRaWAN_LMIC_Library > project_config > lmic_project_config.h ).
      Dans ce fichier, décommentez (enlevez le ' // ') la ligne #define CFG_eu868 1 (fréquence européenne) et commentez (mettez un ' // ') la ligne qui était décommentée (par défaut #define CFG_us915 1, fréquence américaine).
      Si vous avez un problème de définition pour hal_init ajoutez #define hal_init LMICHAL_init dans libraries > MCCI_LoRaWAN_LMIC_Library > project_config > lmic_project_config.h.

Matériels

• TTGO lora32 OLED (vous pouvez l'acheter ici)

• Câble USB-micro USB type B (vous pouvez en acheter ici)

• 6 jumper wires (vous pouvez en acheter ici)

• Sonde de température DS18B20 (vous pouvez en acheter ici)

• une résistance 4,7K Ohm (vous pouvez en acheter ici)

• Capteur de turbidité (vous pouvez en acheter ici)

Présentation du circuit

Circuit

Connexions

Explications

• Le capteur de Température DS18B20 est entièrement Water-Proof. Il en existe de différentes longueurs, les plus longs mesurant plusieurs mètres. La longueur n'est pas problématique pour la qualité des données grâce au support et au protocole utilisé. Il utilise la librairie OneWire, qui permet d'avoir plusieurs capteurs indentiques sur une seule Pin et de pouvoir récupérer leurs données individuellement. Il renvoie une tempéraure en degré celsius et fonctionnne entre -50 et 80°C.

• Le capteur de Turbidité se compose d'un circuit et d'une sonde. Le circuit n'est pas Water-Proof, la partie opaque en haut de la sonde non plus. Seule la partie inférieure translucide de la sonde doit donc être immergée. La sonde est reliée au circuit via 3 cables :

  • rouge : alimentaion positive , pin #1

  • bleu : alimentation négative , pin#2,

  • jaune : données , pin #3

La pin #4 doit être reliée à une pin Ground de votre TTGO. Le capteur peut fonctionner de deux manières différentes :

• Analogique : vous devez brancher un cable sur la pin A. Le capteur renverra alors une valeur entre 0 et 1023, de telle sorte que plus le liquide est trouble, plus la valeur est basse.

• Digital : vous devez brancher un cable sur la pin D. Le capteur renverra 0 (LOW) par défaut et passera à 1 (HIGH) une fois un seuil de turbidité franchi. Ce seuil est réglable grâce à la vis sur la partie bleue du circuit. La tourner dans le sens horaire augmentera ce seuil et inversement.

La TTGO récupère les données et les transmet à Node-RED via LoRaWAN.

Code Arduino

Code

Copiez-collez le code dans un nouveau fichier Arduino

/*Libraries*/
#include <OneWire.h>
#include <DallasTemperature.h>
#include <lmic.h>
#include <hal/hal.h>

/*Constantes*/
#define pin_turbi 12
#define pin_tmp 13

/*Variables*/
double turb;
double tmp;
OneWire Wir(pin_tmp);
DallasTemperature sensor(&Wir);
const unsigned TX_INTERVAL = 20 ;
osjob_t sendjob;

// Données à envoyer
typedef union {
float f[2];
unsigned char bytes[8];
} donnees;
donnees datas;

// Application EUI : en 'lsb' (little endian format)
static const u1_t PROGMEM APPEUI[8]={/*disponible lors de la création de l'objet sur TheThingsNetwork */};
void os_getArtEui (u1_t* buf) { memcpy_P(buf, APPEUI, 8);}

// Device EUI : même chose qu'au dessus
static const u1_t PROGMEM DEVEUI[8]={/*disponible lors de la création de l'objet sur TheThingsNetwork */};
void os_getDevEui (u1_t* buf) { memcpy_P(buf, DEVEUI, 8);}

// Application Key : vous pouvez la copier telle qu'elle depuis TTN
static const u1_t PROGMEM APPKEY[16] = {/*disponible lors de la création de l'objet sur TheThingsNetwork */};
void os_getDevKey (u1_t* buf) { memcpy_P(buf, APPKEY, 16);}

// Pin Mapping
const lmic_pinmap lmic_pins = {
.nss = 18,
.rxtx = LMIC_UNUSED_PIN,
.rst = 14,
.dio = {26, 33, 32},
};

// Gestionnaire des évenements de TTN
void onEvent (ev_t ev) {
switch(ev) {
case EV_JOINING: // recherche d'une antenne LoRaWAN pour se connecter à TTN
Serial.println(F("EV_JOINING - antenne cherchée"));
break;
case EV_JOINED: // connection à TTN établie
Serial.println(F("EV_JOINED - antenne connectée"));
LMIC_setLinkCheckMode(0);
break;
case EV_TXCOMPLETE:
Serial.println(F("EV_TXCOMPLETE - message envoyé"));
// Envoi du message contenant les données
os_setTimedCallback(&sendjob, os_getTime()+sec2osticks(TX_INTERVAL), Send);
break;
default:
Serial.print(F("Unknown event: ")); // Par défaut, il sera affiché un évènement inconnu
break;
}
}

// Récupération des donneés des capteurs
void getData(){
turb = 100.0-(analogRead(pin_turbi)*(100.0/1000.0)); // Récupère la donnée de turbidité
sensor.requestTemperatures(); // Requête à la sonde pour la température
tmp = sensor.getTempCByIndex(0); // Récupère la donnée de température
// Affichage des données
Serial.println(analogRead(pin_turbi));
Serial.println(turb);
Serial.println(sensor.getTempCByIndex(0));
}

// Envoi des données à TTN
void Send(osjob_t* j){
getData();
// Insertion des données dans le tableau de données qui sera envoyé
datas.f[0] = turb; //turbidité
datas.f[1] = tmp ; //température
LMIC_setTxData2(1, datas.bytes, 8, 0);
Serial.println(F("Prêt à l'envoi"));
}

// SetUp : démarrage du capteur, initialisation de LMIC et de la boucle d'envoi
void setup() {
Serial.begin(115200); //Démarrage du moniteur série
Serial.println(F("Starting"));
pinMode(pin_tmp , INPUT_PULLUP);
sensor.begin(); // Activation de la sonde DS18B20
pinMode(pin_turbi , INPUT); // Activation du capteur de turbidité
os_init();
LMIC_reset();
LMIC_setClockError(MAX_CLOCK_ERROR * 1/100);
Send(&sendjob);
}

// Boucle automatique
void loop() {
os_runloop_once();
}

Dans arduino, pour choisir la bonne carte, allez dans Outils > Type de carte. On utilise ici une TTGO_LORA32_OLED_V1. Vérifiez le Port et la vitesse d’écriture (il doit être à 115200).
Pour téléverser le code sur la carte, allez dans croquis > Téléverser, ou cliquez sur la flèche.

The Things Network

Ajout du device

Avant de lancer le programme, il faut créer la réception des données sinon le code tournera en boucle sans rien faire.

Sur The Things Network, il est possible d'enregistrer son objet pour voir le flux de données.

Avant cela, si vous n'avez pas d'antenne LoRaWAN pour recevoir les données allez ici.

Ajout du device

• Sur TTN (www.thethingsnetwork.org/), connectez-vous (ou créez un compte), allez dans la console en cliquant sur votre profil, allez dans Applications et Ajoutez une nouvelle appli. Renseignez un ID, un nom et une description (facultatif).

• Dans cette application, ajoutez un nouveau End Device. Renseignez les informations de votre objet connecté dans la section Manually.

  • LoRaWAN version : MAC V1.0

• Sélectionnez la fréquence dans Frequency plan dont l'endroit correspond à la région où sera placé votre objet. En Europe, on prendra la fréquence Europe 863-870 MHz(SF9 for RX2-recommended).

• L’AppEUI devrait être renseigné par le fabricant ou remplissez avec des zéros.

• Le DevEUI est soit renseigné par le fabricant ou imprimé sur le paquet soit générer par le bouton juste à droite.

• L’Appkey est soit renseigné par le fabricant soit générer par le bouton juste à droite.

• Dans l'overview de votre End Device , vous avez accès aux EUIs et à l’AppKey nécessaires dans le programme. Pour les EUIs, cliquez sur les chevrons à droite de chacun d'eux, ils seront au format msb.
  Et ça tombe bien, sur Arduino les EUIs sont au format msb. Vous pouvez les copiez et les collez dans le code.

Pour l' AppKey, il faudra la rendre visible en cliquant sur l'œil et dans le code remplacez seulement les chiffres après les 0x.

Décodage du payload

On utilise un décodeur sur TTN car les données qui sont créées par les objets sont au format binaire donc illisible pour l’homme.

On utilisera le langage Javascript pour créer notre propre décodeur.

Dans Application > End devices > votre device > Payload Formatters et dans Uplink sélectionnez Javascript dans le menu déroulant. Copiez-collez le code ci-dessous dans la zone 'Formatter parameter'. Et cliquez sur Save changes pour sauvegarder. Et vérifiez l'indentation sinon cela ne fonctionnera pas.

function B2F32(bytes) { // Convertit les données binaires en nombres à virgules
var sign = (bytes & 0x80000000) ? -1 : 1;
var exponent = ((bytes >> 23) & 0xFF) - 127;
var significand = (bytes & ~(-1 << 23));
if (exponent == 128)
return sign * ((significand) ? Number.NaN : Number.POSITIVE_INFINITY);
if (exponent == -127) {
if (significand === 0) return sign * 0.0;
exponent = -126;
significand /= (1 << 22);
} else significand = (significand | (1 << 23)) / (1 << 23);
return sign * significand * Math.pow(2, exponent);
}

function Decoder(bytes, port) { // Envoi du message de donnée au serveur MQTT
var turb = bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0];
var tmp = bytes[7] << 24 | bytes[6] << 16 | bytes[5] << 8 | bytes[4];
return{ turb: B2F32(turb) , tmp: B2F32(tmp) };
}

Serveur MQTT

Pour que l’on puisse récupérer les données avec Node-RED, nous allons créer un serveur MQTT.

Toujours dans TheThingsNetwork dans votre Application, allez dans Integrations > MQTT. Cliquez sur Generate new API key et copiez-la car elle ne sera plus visible si vous quittez la page. L' API key servira de mot de passe.

Ça y est, on peut maintenant traiter les données avec Node-RED.

Serveur Node-RED

Flow

Explications

• • Le capteur envoie ses données et TTN les récupère. Node-RED les lit ensuite grâce à la node mqtt-in.

• • Les données sont ensuite récupérées par les nodes de dashboard qui permettent de les afficher : des jauges pour la turbidité et la température, ainsi qu'un graphe pour l'évolution de ces deux dernières.

• • Chaque fois que vous finissez de configurer un node, cliquez sur Done.

• • ATTENTION : pour enregistrer vos modifications, cliquez sur Deploy.

Interface utilisateur

L'intérêt de tout ceci est pour la visualisation des données. Node-RED permet ceci avec une interface utilisateur.
Pour y accéder, avec le moteur de recherche que vous voulez, tapez l'ip du serveur Node-RED, puis deux points, puis le numéro port puis /ui (XXX.XXX.XXX.XXX:YYYY/ui).

Mise en forme

Pour mettre en forme l'interface utilisateur, retournez dans Node-RED
Cliquez sur les trois barres en haut à droite, allez dans View puis cliquez sur Dashboard.
En mettant le curseur sur le nom du groupe des jauges et du graphe, cliquez sur layout.
Sur la droite réglez la largeur de l'interface sur Width. Ensuite cliquez sur Done, puis sur Deploy et revenez dans le layout pour faire la mise en forme. Essayez d'obtenir le résultat ci-dessous.