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 d'une sonde de pH et d'une sonde de température, et de l'envoi des données en LoRaWAN.
A DeltaLab, un projet d'Aquaponie est en projet, et ce capteur sera évidemment utilisé dès le début.

Introduction

Ce projet a pour but de présenter l'utilisation d'une sonde de pH couplée à une sonde de température, dans le but de les intégrer à un système plus grand.
Le projet se décompose en 2 parties distinctes : le capteur 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

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 :

  • 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.

  • OneWire : pour la sonde de température

    • dans Arduino : Outils > gérer les bibliothèques
      entrez onewire et installez la librairie OneWire by Paul Stoffregen

  • DallasTemperature: pour la sonde de température

    • dans Arduino : Outils > gérer les bibliothèques
      entrez dallas et installez la librairie DallasTemperature by Miles Burton

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 DS18B20 (vous pouvez en acheter ici)

• Sonde pH (vous pouvez en acheter ici)

Montage

Sonde pH

2 solutions

La sonde pH devra être calibrée, pour cela nous vous proposons 2 solutions :

• Une calibration sur plusieurs jours avec une température constante. Ce qui fait que le calcul de pH ne prend en compte qu'une seule donnée de pH.

• Une calibration prenant en compte la température avec la sonde DS18B20 mais qui pour l'instant ne remonte pas la bonne donnée de pH. Cette solution mérite d'être approfondie.

Solution n°1

Si seulement on pouvait juste laisser la sonde dans le liquide et ne rien faire… Préparez-vous.

Pour commencer, vous devrez trouver un moyen d'avoir une solution à pH 7 et d'être dans un environnement entre 20 et 25 °C. Nous avons besoin d'une température constante car le pH varie en fonction de la température.

Je rappelle pour ce début de calibration, il vous faut :

• une solution à pH 7 entre 20 et 25 °C

• de l'eau distillée ( l'eau déminéralisée fait l'affaire )

• du papier absorbant

• la sonde

• votre PC et Arduino

Ici l'eau distillée sert à nettoyer la sonde après chaque mesure. Trempez-la dans de l'eau distillée juste avant de faire vos mesures de pH. Laissez tremper au moins 2 min.

Une fois votre sonde nettoyée, séchez-la avec du papier absorbant, et plongez-la dans la solution à pH 7.Faites en sorte que la sonde soit suffisamment immergée pour que toutes les électrodes de la sonde soit en contact avec la solution.

Il me semble que votre TTGO est branchée à votre PC. Donc maintenant nous allons faire notre première mesure pH. Dans un fichier arduino, copiez-collez ce code ci-dessous:

#include <Arduino.h>
const int adcPin = 13; //pin pour récupérer la donnée

// Initialisation du programme
void setup() {
Serial.begin(115200); //démarrage du moniteur série
}

//Boucle automatique
void loop() {
float value = analogRead(adcPin); //récupère la valeur analogique
float voltage = value * 5.0 / 1024; //calcul de la valeur de voltage
// affichage de la donnée
Serial.println(value);
Serial.print("Voltage = "); Serial.println(voltage, 3);
delay(1000);
}

Allumez le moniteur série en cliquant sur la loupe en haut à droite. Réglez le baud du moniteur; en bas à droite, à gauche de Effacer la sortie; à 115200.Téléversez votre code en cliquant sur la flèche en haut à gauche de Arduino.

Des valeurs s'affichent sur le moniteur série ? Ce n'est pas fini, regardez la valeur de voltage. Cette dernière va nous permettre de calculer le pH. Votre solution est à pH 7, et le voltage correspondant doit être à 2,5 V.
Si cette valeur n'est pas celle qui est affichée, sur la carte entre le Wemos et la sonde se trouve une mollette que vous pouvez tourner avec un tournevis plat. Faites la tourner dans un sens ou dans l'autre de manière à faire varier la tension de sortie.(vous entendrez un "tic" quand vous atteindrez la limite).

Laissez la sonde stabilisée. Et si vous n'avez toujours pas une valeur de 2,5 V... Préparez-vous.

Vous allez avoir besoin d'autres solutions à pH différents de 7 comme 4 et 9. Revenez quand vous aurez ces trois solutions.

Pour cette prochaine étape, vous allez avoir besoin de:

• vos trois solutions à pH 4, 7 et 9

• de l'eau distillée ( l'eau déminéralisée fait l'affaire )

• du papier absorbant

• la sonde

• votre PC et Arduino

• un logiciel de création de graphique (Excel, Google Sheets, MATLAB, etc.)

Voici la procédure à suivre :

1. Notez la température à laquelle vous allez faire vos mesures.

2. Avec le même code ci-dessus, prenez des mesures de voltage des trois solutions, n'oubliez pas de laisser tremper la sonde avant chaque mesure dans de l'eau distillée et de la sécher avec du papier avant et après.

3. Notez ces mesures de voltage avec leur pH correspondant.

4. Construisez un graphique avec ces mesures. Axe x : voltage, Axe y : pH.

5. Tracez une courbe avec les points et déduisez en l'équation type "ax+b" correspondante.
   a=coefficient directeur
   b=ordonnée à l'origine

6. Nettoyez la sonde à l'eau distillée.

Répétez cela sur plusieurs jours jusqu'à avoir une courbe satisfaisante, c'est-à-dire presque linéaire.

Une fois que vous avez votre courbe, conservez son équation.

Code Arduino

Copiez-collez le code ci-dessous dans un fichier arduino:

//Bibliothèques
#include <SPI.h>
#include <Wire.h>
#include <lmic.h>
#include <hal/hal.h>
#include <OneWire.h>
#include <DallasTemperature.h>

//Constantes pour la prise de données
#define SensorPin 12 //pin de récupération de la donnée
#define Offset 0.00 //compensation avec la déviation
#define ONE_WIRE_BUS 13
#define SCK 5 // GPIO5 -- SX1278's SCK
#define MISO 19 // GPIO19 -- SX1278's MISnO
#define MOSI 27 // GPIO27 -- SX1278's MOSI
#define SS 18 // GPIO18 -- SX1278's CS
#define RST 14 // GPIO14 -- SX1278's RESET
#define DI0 26 // GPIO26 -- SX1278's IRQ(Interrupt Request)

float voltage, phValue, temperature;
int buf[100],temp;
osjob_t sendjob;
const unsigned TX_INTERVAL = 2 ;

// Setup a oneWire instance to communicate with any OneWire devices
// (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);
// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);

// Données à envoyer
typedef union {
float f[3];
unsigned char bytes[12];
} 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: // connexion à 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
Serial.println((unsigned) ev);
break;
}
}

// Envoi des données à TTN
void Send(osjob_t* j){
if (LMIC.opmode & OP_TXRXPEND) {
Serial.println(F("OP_TXRXPEND, not sending"));
} else {
//Insertion des données dans le tableau de données à envoyer
datas.f[0] = voltage; //voltage
datas.f[1] = phValue; //pH
datas.f[2] = temperature; // temperature
LMIC_setTxData2(1, datas.bytes, 12, 0);
Serial.println(F("Packet queued"));
}
}

//Initialisation du programme
void setup(void)
{
Serial.begin(115200); //démarrage du moniteur série
Serial.println(F("Starting"));
Wire1.begin(4, 15);

// Start up the library
sensors.begin(); //Activation de la sonde de température
ph.begin(); //Activation de la sonde de pH
SPI.begin(SCK,MISO,MOSI,SS);
os_init();
LMIC_reset();
LMIC_setClockError(MAX_CLOCK_ERROR * 10/100);
Send(&sendjob);
}

//Boucle automatique
void loop(void)
{
for(int i=0;i<100;i++) //Prends 100 valeurs analogiques pour faire une moyenne
{
buf[i]=analogRead(SensorPin);
//Serial.println(buf[i]);
delay(10);
}

for(int i=0;i<99;i++) //tri des valeurs analogiques
{
for(int j=i+1;j<100;j++)
{
if(buf[i]>buf[j]){
temp=buf[i];
buf[i]=buf[j];
buf[j]=temp;
}
}
}

float avgValue=0.0;
for(int i=2;i<98;i++){ // prends 96 valeurs moyennes
avgValue+= buf[i];
}
avgValue = avgValue / 96.0;
voltage = avgValue * 5.0 / 1024.0;
phValue = votre équation de courbe;
temperature = readTemperature(); //Récupère la donnée de température
// Affichage des données
Serial.print("Voltage:");
Serial.print(voltage,2);
Serial.print(" pH value: ");
Serial.println(phValue,2);
Serial.print("Temperature: ");
Serial.print(temperature, 2);
Serial.println(" °C");
os_runloop_once();
}
// Retourne la donnée de température
float readTemperature()
{
sensors.requestTemperatures(); // Envoi une demande pour avoir la donnée de température
return sensors.getTempCByIndex(0);
}

Solution n°2

Cette seconde solution est une reprise d'une calibration qui existe déjà sur ce site,
En allant sur le site vous tomberez sur un projet de code dont vous allez avoir besoin. Sur cette page cliquez sur l'encadré Code en vert, puis cliquez sur Download Zip. Un dossier compressé ZIP va être téléchargé.
Maintenant allons sur Arduino pour intégrer cette librairie, allez dans Croquis > Inclure une bibliothèque > Ajouter la bibliothèque .ZIP. Une interface apparaît pour cherchez le dossier zip dans vos fichiers, vous trouverez le ZIP dans vos Téléchargements.

Code Arduino

Copiez-collez le code ci-dessous dans un fichier arduino:

// Libraries
#include <lmic.h>
#include <hal/hal.h>
#include <Wire.h>
#include <SPI.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include "DFRobot_ESP_PH.h"
#include "EEPROM.h"

// Constantes
#define SCK 5 // GPIO5 -- SX1278's SCK
#define MISO 19 // GPIO19 -- SX1278's MISnO
#define MOSI 27 // GPIO27 -- SX1278's MOSI
#define SS 18 // GPIO18 -- SX1278's CS
#define RST 14 // GPIO14 -- SX1278's RESET
#define DI0 26 // GPIO26 -- SX1278's IRQ(Interrupt Request)
#define ESPADC 4096.0 //the esp Analog Digital Convertion value
#define ESPVOLTAGE 3300 //the esp voltage supply value
#define PH_PIN 12 //the esp gpio data pin number
#define ONE_WIRE_BUS 13

//Variables
DFRobot_ESP_PH ph;
double voltage, phValue, temperature;
osjob_t sendjob;
const unsigned TX_INTERVAL = 2 ;
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

// Données à envoyer
typedef union {
float f[3];
unsigned char bytes[12];
} 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 évènements 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:// connexion à 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
Serial.println((unsigned) ev);
break;
}
}

// Envoi des données à TTN
void Send(osjob_t* j){
if (LMIC.opmode & OP_TXRXPEND) {
Serial.println(F("OP_TXRXPEND, not sending"));
} else {
// Insertion des données dans le tableau de données qui sera envoyé
datas.f[0] = voltage; //voltage
datas.f[1] = phValue; //pH
datas.f[2] = temperature; //température

LMIC_setTxData2(1, datas.bytes, 12, 0);
Serial.println(F("Packet queued"));
}
}

// 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"));
Wire1.begin(4, 15);
sensors.begin(); //Activation de la sonde de température
EEPROM.begin(32);//needed to permit storage of calibration value in eeprom
ph.begin(); //Activation de la sonde de pH
SPI.begin(SCK,MISO,MOSI,SS);
os_init();
LMIC_reset();
LMIC_setClockError(MAX_CLOCK_ERROR * 10/100);
Send(&sendjob);
}

// Boucle automatique
void loop() {
static unsigned long timepoint = millis();
if (millis() - timepoint > 1000U) //intervalle de temps: 1s
{
timepoint = millis();
//voltage = rawPinValue / esp32ADC * esp32Vin
voltage = analogRead(PH_PIN) / ESPADC * ESPVOLTAGE; // Récupère la donnée de voltage de la sonde pH
temperature = readTemperature(); // Récupère la donnée de température
phValue = ph.readPH(voltage, temperature); // calcul du pH avec compensation de la température
}
ph.calibration(voltage, temperature); // processus de calibration avec le moniteur série
os_runloop_once();
}

// Retourne la donnée de température
float readTemperature()
{
sensors.requestTemperatures(); // Envoi d'une demande pour avoir la donnée de température
return sensors.getTempCByIndex(0);
}

The Things Network

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 ou générer par le bouton juste à droite.

• L’Appkey est soit renseigné par le fabricant ou 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 voltage = bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0];
var ph = bytes[7] << 24 | bytes[6] << 16 | bytes[5] << 8 | bytes[4];
var temp = bytes[11] << 24 | bytes[10] << 16 | bytes[9] << 8 | bytes[8];
return{
voltage: B2F32(voltage) , ph: B2F32(ph), temp: B2F32(temp)
}; }

Maintenant vous pouvez upload votre programme, si vous voulez suivre ce que le programme fait allez dans Outils et cliquez sur Moniteur série.

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.

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 le pH et le voltage de la sonde ainsi qu'une jauge de niveau pour la température.

• • 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.

Pour modifier la taille des composants, cliquez sur le cadenas en haut à droite du composant et une double flèche apparait en bas à droite de ce dernier. Maintenez le clique dessus pour modifier la taille.