Capteur de sol
Capteur de sol
Le capteur d'humidité du sol est la première brique à installer. Cette page décrit un capteur LoRaWAN économique, sa calibration et les pièges de programmation que nous avons rencontrés.
Le matériel
Nous utilisons le capteur d'humidité du sol LoRa de Makerfabs (version 1.2) : un microcontrôleur ATmega328P (3,3 V, 8 MHz), un module radio RFM95W en 868 MHz, une sonde capacitive sur une entrée analogique, et un capteur d'air AHT10 en I2C. L'alimentation de la sonde est commandée par une broche, ce qui permet de ne l'allumer que pendant la mesure. Une version plus récente (v3, sans circuit 555) consomme de l'ordre de 7 µA en veille : avec deux piles AAA au lithium et un envoi au plus toutes les 30 minutes, l'autonomie estimée est d'environ deux ans (estimation du fabricant, à vérifier). Préférez le lithium sous le soleil du Sahel.
Pourquoi une sonde capacitive ? Elle ne s'use pas par électrolyse comme les sondes à deux lames résistives, qui se corrodent en quelques semaines dans un sol humide.
Calibration sec / mouillé
La sonde donne un nombre brut (valeur de l'ADC, de 0 à 1023). Ce nombre n'a de sens que pour une sonde, un sol et une alimentation donnés. Pour obtenir un pourcentage, il faut deux repères :
- sec : la sonde à l'air libre, ou dans le sol le plus sec ;
- mouillé : la sonde plongée dans l'eau jusqu'à la ligne de repère, ou dans un sol saturé.
Pour une sonde capacitive, la valeur brute est plus basse quand le sol est plus humide. Le pourcentage s'obtient par 100 × (brut − sec) ÷ (mouillé − sec), borné entre 0 et 100. Le script de l'exemple d du Kit de démarrage fait le calcul à partir de vos relevés.
Valeurs observées sur notre sonde (à titre d'exemple, ne les reprenez pas) :
| Situation | Valeur brute |
|---|---|
| À l'air libre | environ 870 |
| Dans l'eau | environ 560 |
| Sol de jardin sec | 610 à 637 |
| Sol de jardin mouillé par une averse | 559 à 569 |
Un sol réel ne couvre qu'une partie de la plage « air → eau ». Deux conséquences :
- lisez la valeur brute pour décider (par exemple : « sol mouillé » quand le brut passe sous un seuil absolu de 595), au lieu du pourcentage, tant que la calibration n'est pas faite dans votre sol ;
- un pourcentage plafonné à 100 cache les écarts entre un sol humide et un sol saturé.
Refaites la calibration dans votre propre sol, sonde par sonde.
Alimentation
- Sur piles : le micrologiciel doit dormir entre deux mesures (veille profonde). La consommation de la radio est négligeable devant celle d'un microcontrôleur resté éveillé.
- Sur un chargeur USB (notre cas au jardin) : aucune contrainte d'autonomie, le micrologiciel peut rester éveillé. Le point faible devient la liaison radio, pas l'énergie.
- Envoyez la tension d'alimentation dans chaque message : elle alimente un tableau de bord de l'état des piles et permet d'anticiper les remplacements.
Antenne et position
Notre capteur au jardin remontait un signal de −107 dBm, au bord du décrochage. L'action utile est sur l'antenne (accordée 868 MHz, quart d'onde de 8,6 cm, dégagée de la terre humide et des masses métalliques) et sur la position, pas sur la consommation. Enterrer la partie électronique ou la mettre au ras du sol coûte plusieurs décibels : montez-la sur un piquet, la sonde seule dans la terre.
Pièges de programmation
Chacun de ces pièges nous a coûté des heures.
- Mauvaise bibliothèque LMIC. Deux bibliothèques fournissent
lmic.h: l'ancienne (IBM, 1.5.1) et celle de MCCI. Arduino choisit l'ancienne. L'ancienne choisit la sortie radio RFO en dessous de 14 dBm, alors que sur ce module seule la sortie PA_BOOST est câblée : il manque alors environ 22 dB de puissance utile (notre premier capteur remontait −107 dBm au jardin ; c'est la piste principale, à confirmer après reconstruction). La bibliothèque MCCI choisit correctement PA_BOOST. Passez-la explicitement à la compilation. - Région par défaut : US915. La bibliothèque MCCI est livrée réglée sur la bande américaine. Dans
lmic_project_config.h, activezCFG_eu868. Sinon le capteur émet sur des fréquences illégales ici et invisibles pour la passerelle. - Mauvais profil de carte. Le microcontrôleur doit être configuré en 3,3 V / 8 MHz. Un autre profil fait déraper l'horloge de la liaison série (texte illisible) et celle de LMIC.
- Horloge à ±2 %. L'oscillateur interne de l'ATmega dérive : les fenêtres de réception s'ouvrent à côté de la réponse du réseau et le « join » échoue. Corrigez avec
LMIC_setClockError(MAX_CLOCK_ERROR * 2 / 100). - Trop gros pour la mémoire. Avec MCCI, le croquis dépasse la mémoire flash de 32 Ko (104 %). Désactivez la classe B (
-DDISABLE_PING -DDISABLE_BEACONS) et retirez les bibliothèques incluses mais inutilisées (celle de l'exemple du fabricant coûtait à elle seule plusieurs kilo-octets). On passe à environ 76–90 % de flash. - DIO1 non câblé. LMIC a besoin de deux lignes d'interruption de la radio, DIO0 et DIO1. Sur une de nos cartes ESP32, DIO1 n'arrivait sur aucune broche (19 testées) : le nœud émettait un premier paquet puis restait muet à jamais, la fenêtre de réception ne se refermant pas. Détail du piège : le premier paquet passe parce que TTN y répond (réponse reçue sur DIO0), le suivant sans réponse attend DIO1 indéfiniment. Contournement sans soudure : lire le registre des drapeaux d'interruption de la radio (RegIrqFlags) depuis la boucle principale et signaler à LMIC l'expiration de la fenêtre. Diagnostic : un croquis qui met la radio en réception, attend le drapeau, puis échantillonne toutes les broches après l'apparition du drapeau et en retranchant un niveau de repos (certaines broches sont hautes à cause des résistances de rappel I2C).
- Ordre des octets des clés. DevEUI et JoinEUI à l'envers, AppKey à l'endroit (voir TTN).
- Jamais de
delay()dans le chemin LMIC. Undelay()juste après la mise en file d'un message bloque la boucle LMIC au moment où se décide le calage des fenêtres de réception. Mesurez avant, ne bloquez pas après. - Toujours se replanifier. Si la fonction d'envoi se contente de « retourner » quand une émission est en cours, elle perd son seul minuteur et le capteur s'arrête sans bruit. Replanifiez à l'événement de fin d'émission.
- Le watchdog d'envoi doit avoir une durée fixe, pas un multiple de l'intervalle : à trois fois l'intervalle, il se déclenchait à chaque cycle et devenait le moteur du nœud au lieu d'être un filet.
- Humidité de l'air à 100 % constante. Si l'AHT10 donne toujours 100 %, ne vous fiez pas à cette valeur avant d'avoir vérifié le câblage et la lecture I2C.
- Octet envoyé deux fois. L'exemple d'origine du fabricant envoyait l'octet de poids fort de l'humidité deux fois : un décodeur correct recevait une valeur fausse. Relisez toujours la trame octet par octet avec le décodeur.
Décodeur
Le formateur de charge utile (exemple b du Kit de démarrage) transforme la trame en valeurs. Il doit tenir compte du format exact du micrologiciel et ignorer ce qui n'est pas à lui (voir TTN).
Exemples de code
Le croquis complet et le script de calibration (voir aussi le Kit de démarrage).
/*
* Capteur d'humidité du sol LoRaWAN — exemple de démarrage (Alseno Tech, licence MIT).
*
* Carte visée : ATmega328P 3,3 V / 8 MHz + module RFM95 (SX1276) en 868 MHz.
* Bibliothèque : « MCCI LoRaWAN LMIC library » (PAS l'ancienne IBM LMIC).
* Région : EU868 (Sénégal, Europe, Afrique de l'Ouest).
*
* PIÈGE : la bibliothèque MCCI est livrée réglée sur la région US915. Éditez
* <bibliothèques Arduino>/MCCI_LoRaWAN_LMIC_library/project_config/lmic_project_config.h :
* activez « #define CFG_eu868 1 » et désactivez « CFG_us915 ». Sinon le capteur émet sur
* des fréquences illégales ici, et aucune passerelle EU868 ne l'entend.
* Compilation (testée) : carte « Arduino Pro ou Pro Mini, ATmega328P 3,3 V 8 MHz », avec
* -DDISABLE_PING -DDISABLE_BEACONS pour que le croquis tienne dans les 32 Ko (≈ 76 % utilisés).
*
* Principe : toutes les INTERVALLE_S secondes on alimente la sonde, on lit
* la valeur brute (ADC), on mesure la tension d'alimentation, puis on envoie
* 7 octets sur le port 10. Le formateur TTN du wiki décode ce format.
*
* Format de la trame (7 octets) :
* octet 0 : 0xA1 (identifiant de format, permet au décodeur de reconnaître la trame)
* octets 1-2 : valeur brute de la sonde, entier non signé, poids fort d'abord
* octets 3-4 : température en centièmes de °C, entier signé (0x8000 = absente)
* octets 5-6 : tension d'alimentation en millivolts, poids fort d'abord
*/
#include <lmic.h>
#include <hal/hal.h>
#include <SPI.h>
// ---------------------------------------------------------------------------
// 1) CLÉS — À REMPLACER par celles de VOTRE appareil (console TTN).
// ATTENTION à l'ordre des octets, première cause d'échec du « join » :
// - DevEUI et JoinEUI (AppEUI) : ordre INVERSE de la console (poids faible d'abord) ;
// - AppKey : même ordre que la console (poids fort d'abord).
// Ne publiez jamais ce fichier une fois les vraies clés écrites dedans.
// ---------------------------------------------------------------------------
static const u1_t PROGMEM DEVEUI[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; // <DEV_EUI> inversé
static const u1_t PROGMEM APPEUI[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; // <JOIN_EUI> inversé
static const u1_t PROGMEM APPKEY[16] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; // <APP_KEY>
void os_getDevEui(u1_t *buf) { memcpy_P(buf, DEVEUI, 8); }
void os_getArtEui(u1_t *buf) { memcpy_P(buf, APPEUI, 8); }
void os_getDevKey(u1_t *buf) { memcpy_P(buf, APPKEY, 16); }
// ---------------------------------------------------------------------------
// 2) Branchements — À ADAPTER à votre carte.
// ---------------------------------------------------------------------------
const lmic_pinmap lmic_pins = {
.nss = 10,
.rxtx = LMIC_UNUSED_PIN,
.rst = 9,
.dio = { 2, 6, 7 }, // DIO0, DIO1, DIO2 : LMIC a besoin de DIO0 ET de DIO1 réellement câblés
};
const uint8_t PIN_SONDE = A2; // sortie analogique de la sonde capacitive
const uint8_t PIN_ALIM_SONDE = 5; // commande de l'alimentation de la sonde (économise le courant)
const uint32_t INTERVALLE_S = 600; // 10 min ; les limites légales (1 % de temps d'antenne) vous laissent bien plus
const uint8_t PORT_APPLI = 10; // doit correspondre au formateur TTN
static osjob_t jobEnvoi;
static uint8_t trame[7];
// Mesure la tension d'alimentation (mV) en comparant la référence interne 1,1 V à Vcc.
static uint16_t lireVccMv() {
ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
delay(2); // laisse la référence se stabiliser
ADCSRA |= _BV(ADSC);
while (bit_is_set(ADCSRA, ADSC)) {}
return (uint16_t)(1125300UL / ADC);
}
// Lit la sonde : moyenne de 8 mesures pour lisser le bruit.
static uint16_t lireSonde() {
digitalWrite(PIN_ALIM_SONDE, HIGH);
delay(100); // temps de stabilisation de la sonde
uint32_t somme = 0;
for (uint8_t i = 0; i < 8; i++) { somme += analogRead(PIN_SONDE); delay(5); }
digitalWrite(PIN_ALIM_SONDE, LOW);
return (uint16_t)(somme / 8);
}
static void construireTrame() {
uint16_t brut = lireSonde();
uint16_t vcc = lireVccMv();
int16_t temp = (int16_t)0x8000; // pas de capteur de température dans cet exemple
trame[0] = 0xA1;
trame[1] = brut >> 8; trame[2] = brut & 0xFF;
trame[3] = ((uint16_t)temp) >> 8; trame[4] = ((uint16_t)temp) & 0xFF;
trame[5] = vcc >> 8; trame[6] = vcc & 0xFF;
}
static void envoyer(osjob_t *job) {
// Si une émission est encore en cours, on ne fait rien : la prochaine sera replanifiée par onEvent().
if (LMIC.opmode & OP_TXRXPEND) {
Serial.println(F("emission deja en cours"));
return;
}
construireTrame(); // les mesures se font AVANT la mise en file...
LMIC_setTxData2(PORT_APPLI, trame, sizeof(trame), 0);
Serial.println(F("trame en file")); // ...et surtout aucun delay() après : il fausserait les fenêtres de réception
}
void onEvent(ev_t ev) {
switch (ev) {
case EV_JOINING:
Serial.println(F("join en cours"));
break;
case EV_JOINED:
Serial.println(F("join OK"));
LMIC_setLinkCheckMode(0); // inutile pour un capteur fixe, économise des échanges
break;
case EV_JOIN_FAILED:
Serial.println(F("join echoue : verifier l'ordre des octets des cles et la portee"));
break;
case EV_TXCOMPLETE:
Serial.println(F("emission terminee"));
// Toujours replanifier ici : si on oublie, le capteur s'arrête en silence.
os_setTimedCallback(&jobEnvoi, os_getTime() + sec2osticks(INTERVALLE_S), envoyer);
break;
default:
break;
}
}
void setup() {
Serial.begin(115200);
pinMode(PIN_ALIM_SONDE, OUTPUT);
digitalWrite(PIN_ALIM_SONDE, LOW);
os_init();
LMIC_reset();
// L'horloge de l'ATmega à 8 MHz dérive : sans cette tolérance de 2 %, les fenêtres de
// réception s'ouvrent à côté et la réponse au « join » est manquée.
LMIC_setClockError(MAX_CLOCK_ERROR * 2 / 100);
LMIC_setAdrMode(1); // capteur fixe : le réseau peut ajuster le facteur d'étalement
LMIC_setDrTxpow(DR_SF7, 14); // 14 dBm = plafond EU868 pour les canaux par défaut
envoyer(&jobEnvoi); // lance le « join » puis la première trame
}
void loop() {
os_runloop_once(); // moteur LMIC : à appeler le plus souvent possible, sans delay()
}
#!/usr/bin/env python3
"""Calibration sec / mouillé d'une sonde d'humidité du sol et conversion ADC -> %.
Exemple de démarrage (Alseno Tech, licence MIT). Aucune dépendance.
Méthode : relevez 20 à 30 valeurs brutes (dans le moniteur série ou la console TTN),
une par ligne dans un fichier texte, dans deux situations :
- sonde SÈCHE (à l'air libre, ou dans le sol le plus sec que vous aurez) ;
- sonde MOUILLÉE (plongée dans l'eau jusqu'à la ligne de repère, ou sol saturé).
python calibration_sonde.py enregistrer sec < releves_sec.txt
python calibration_sonde.py enregistrer mouille < releves_eau.txt
python calibration_sonde.py convertir 640
Une sonde capacitive donne une valeur PLUS BASSE quand le sol est plus humide : le script
s'en accommode (il travaille avec l'écart entre les deux repères, quel que soit le sens).
Chaque sonde est différente : calibrez-les une par une.
"""
import json
import statistics
import sys
FICHIER = "calibration.json"
def lire_releves(flux):
"""Lit des nombres, un par ligne, en ignorant les lignes vides ou non numériques."""
valeurs = []
for ligne in flux:
try:
valeurs.append(float(ligne.strip()))
except ValueError:
continue
return valeurs
def charger():
try:
with open(FICHIER, encoding="utf-8") as f:
return json.load(f)
except FileNotFoundError:
return {}
def enregistrer(repere, valeurs):
"""Stocke la médiane (insensible aux mesures aberrantes) et la dispersion."""
if len(valeurs) < 5:
sys.exit("Il faut au moins 5 relevés (idéalement 20 à 30).")
cal = charger()
cal[repere] = {"mediane": statistics.median(valeurs),
"ecart_type": round(statistics.pstdev(valeurs), 2),
"nombre": len(valeurs)}
with open(FICHIER, "w", encoding="utf-8") as f:
json.dump(cal, f, indent=2)
print(repere, "=", cal[repere])
def convertir(brut):
"""Valeur brute -> pourcentage d'humidité (0 = repère sec, 100 = repère mouillé), borné."""
cal = charger()
if "sec" not in cal or "mouille" not in cal:
sys.exit("Enregistrez d'abord les deux repères : sec puis mouille.")
sec, mouille = cal["sec"]["mediane"], cal["mouille"]["mediane"]
if abs(sec - mouille) < 20:
sys.exit("Repères trop proches : sonde défaillante ou mauvais essai.")
pct = 100.0 * (brut - sec) / (mouille - sec)
return max(0.0, min(100.0, pct))
if __name__ == "__main__":
if len(sys.argv) == 3 and sys.argv[1] == "enregistrer" and sys.argv[2] in ("sec", "mouille"):
enregistrer(sys.argv[2], lire_releves(sys.stdin))
elif len(sys.argv) == 3 and sys.argv[1] == "convertir":
print("%.0f %%" % convertir(float(sys.argv[2])))
else:
sys.exit(__doc__)
Voir aussi
Kit de démarrage · Chaîne de données · Matériel et coûts · Pièges et leçons