<?xml version="1.0"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="fr">
	<id>https://wiki.alseno.tech/index.php?action=history&amp;feed=atom&amp;title=Kit_de_d%C3%A9marrage</id>
	<title>Kit de démarrage - Historique des versions</title>
	<link rel="self" type="application/atom+xml" href="https://wiki.alseno.tech/index.php?action=history&amp;feed=atom&amp;title=Kit_de_d%C3%A9marrage"/>
	<link rel="alternate" type="text/html" href="https://wiki.alseno.tech/index.php?title=Kit_de_d%C3%A9marrage&amp;action=history"/>
	<updated>2026-11-20T20:11:17Z</updated>
	<subtitle>Historique des versions pour cette page sur le wiki</subtitle>
	<generator>MediaWiki 1.43.11</generator>
	<entry>
		<id>https://wiki.alseno.tech/index.php?title=Kit_de_d%C3%A9marrage&amp;diff=47&amp;oldid=prev</id>
		<title>Robot-agri : Alseno Tech : accueil et portail Agritech</title>
		<link rel="alternate" type="text/html" href="https://wiki.alseno.tech/index.php?title=Kit_de_d%C3%A9marrage&amp;diff=47&amp;oldid=prev"/>
		<updated>2026-11-20T19:42:25Z</updated>

		<summary type="html">&lt;p&gt;Alseno Tech : accueil et portail Agritech&lt;/p&gt;
&lt;p&gt;&lt;b&gt;Nouvelle page&lt;/b&gt;&lt;/p&gt;&lt;div&gt;= Kit de démarrage =&lt;br /&gt;
Cinq exemples de code pour se lancer. Ils sont &amp;#039;&amp;#039;&amp;#039;neufs, courts, génériques et commentés en français&amp;#039;&amp;#039;&amp;#039; : ils s&amp;#039;inspirent de ce qui a marché pour nous (et des pièges évités), mais n&amp;#039;en sont pas des copies. Chaque valeur à remplacer est notée entre chevrons : &amp;lt;code&amp;gt;&amp;lt;DEV_EUI&amp;gt;&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;&amp;lt;APP_KEY&amp;gt;&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;&amp;lt;URL_API&amp;gt;&amp;lt;/code&amp;gt;, &amp;lt;code&amp;gt;&amp;lt;CLE_A_CHOISIR&amp;gt;&amp;lt;/code&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
&amp;#039;&amp;#039;&amp;#039;Licence proposée pour ces exemples : MIT&amp;#039;&amp;#039;&amp;#039; (utilisation, copie et modification libres, sans garantie) — en attente de confirmation par Alseno Tech.&lt;br /&gt;
&lt;br /&gt;
&amp;#039;&amp;#039;&amp;#039;Vérification.&amp;#039;&amp;#039;&amp;#039; Le croquis Arduino a été compilé avec arduino-cli pour une carte ATmega328P 3,3 V / 8 MHz avec la bibliothèque MCCI LMIC 6.1.0 (région EU868) : environ 76 % de flash et 77 % de mémoire vive. Les scripts Python ont été vérifiés par &amp;lt;code&amp;gt;python -m py_compile&amp;lt;/code&amp;gt; puis exécutés sur des données fictives ; le récepteur de webhook a été testé avec un message TTN fictif (authentification, enregistrement, doublon). Le formateur JavaScript a été vérifié par &amp;lt;code&amp;gt;node --check&amp;lt;/code&amp;gt; et exécuté sur des trames fictives. Aucun de ces essais n&amp;#039;a utilisé de vrai appareil : à vous de tester sur le vôtre.&lt;br /&gt;
&lt;br /&gt;
{| class=&amp;quot;wikitable&amp;quot;&lt;br /&gt;
! Exemple !! Rôle !! Langage&lt;br /&gt;
|-&lt;br /&gt;
| [[#a. Capteur de sol LoRaWAN (Arduino)|a]] || le capteur : mesure et envoi OTAA || Arduino (C++)&lt;br /&gt;
|-&lt;br /&gt;
| [[#b. Formateur de charge utile TTN|b]] || décode la trame dans TTN || JavaScript&lt;br /&gt;
|-&lt;br /&gt;
| [[#c. Récepteur de webhook TTN|c]] || reçoit les mesures et les stocke || Python + SQLite&lt;br /&gt;
|-&lt;br /&gt;
| [[#d. Calibration sec / mouillé|d]] || convertit la valeur brute en pourcentage || Python&lt;br /&gt;
|-&lt;br /&gt;
| [[#e. Règle de conseil d&amp;#039;arrosage|e]] || dit s&amp;#039;il faut arroser || Python&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
Les cinq exemples forment une chaîne : (a) émet une trame de 7 octets sur le port 10, (b) la décode dans TTN, (c) la reçoit et la range en base, (d) donne le pourcentage, (e) en tire un conseil. Voir [[Chaîne de données]].&lt;br /&gt;
&lt;br /&gt;
== a. Capteur de sol LoRaWAN (Arduino) ==&lt;br /&gt;
Mesure toutes les 10 minutes, envoie 7 octets. Utilise la bibliothèque « MCCI LoRaWAN LMIC library » (pas l&amp;#039;ancienne). &amp;#039;&amp;#039;À régler avant de compiler : région EU868, clés, broches&amp;#039;&amp;#039; (voir [[Capteur de sol]]).&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;cpp&amp;quot;&amp;gt;&lt;br /&gt;
/*&lt;br /&gt;
 * Capteur d&amp;#039;humidité du sol LoRaWAN — exemple de démarrage (Alseno Tech, licence MIT).&lt;br /&gt;
 *&lt;br /&gt;
 * Carte visée : ATmega328P 3,3 V / 8 MHz + module RFM95 (SX1276) en 868 MHz.&lt;br /&gt;
 * Bibliothèque : « MCCI LoRaWAN LMIC library » (PAS l&amp;#039;ancienne IBM LMIC).&lt;br /&gt;
 * Région       : EU868 (Sénégal, Europe, Afrique de l&amp;#039;Ouest).&lt;br /&gt;
 *&lt;br /&gt;
 * PIÈGE : la bibliothèque MCCI est livrée réglée sur la région US915. Éditez&lt;br /&gt;
 *   &amp;lt;bibliothèques Arduino&amp;gt;/MCCI_LoRaWAN_LMIC_library/project_config/lmic_project_config.h :&lt;br /&gt;
 *   activez « #define CFG_eu868 1 » et désactivez « CFG_us915 ». Sinon le capteur émet sur&lt;br /&gt;
 *   des fréquences illégales ici, et aucune passerelle EU868 ne l&amp;#039;entend.&lt;br /&gt;
 * Compilation (testée) : carte « Arduino Pro ou Pro Mini, ATmega328P 3,3 V 8 MHz », avec&lt;br /&gt;
 *   -DDISABLE_PING -DDISABLE_BEACONS pour que le croquis tienne dans les 32 Ko (≈ 76 % utilisés).&lt;br /&gt;
 *&lt;br /&gt;
 * Principe : toutes les INTERVALLE_S secondes on alimente la sonde, on lit&lt;br /&gt;
 * la valeur brute (ADC), on mesure la tension d&amp;#039;alimentation, puis on envoie&lt;br /&gt;
 * 7 octets sur le port 10. Le formateur TTN du wiki décode ce format.&lt;br /&gt;
 *&lt;br /&gt;
 * Format de la trame (7 octets) :&lt;br /&gt;
 *   octet 0     : 0xA1  (identifiant de format, permet au décodeur de reconnaître la trame)&lt;br /&gt;
 *   octets 1-2  : valeur brute de la sonde, entier non signé, poids fort d&amp;#039;abord&lt;br /&gt;
 *   octets 3-4  : température en centièmes de °C, entier signé (0x8000 = absente)&lt;br /&gt;
 *   octets 5-6  : tension d&amp;#039;alimentation en millivolts, poids fort d&amp;#039;abord&lt;br /&gt;
 */&lt;br /&gt;
#include &amp;lt;lmic.h&amp;gt;&lt;br /&gt;
#include &amp;lt;hal/hal.h&amp;gt;&lt;br /&gt;
#include &amp;lt;SPI.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
// ---------------------------------------------------------------------------&lt;br /&gt;
// 1) CLÉS — À REMPLACER par celles de VOTRE appareil (console TTN).&lt;br /&gt;
//    ATTENTION à l&amp;#039;ordre des octets, première cause d&amp;#039;échec du « join » :&lt;br /&gt;
//      - DevEUI et JoinEUI (AppEUI) : ordre INVERSE de la console (poids faible d&amp;#039;abord) ;&lt;br /&gt;
//      - AppKey                      : même ordre que la console (poids fort d&amp;#039;abord).&lt;br /&gt;
//    Ne publiez jamais ce fichier une fois les vraies clés écrites dedans.&lt;br /&gt;
// ---------------------------------------------------------------------------&lt;br /&gt;
static const u1_t PROGMEM DEVEUI[8]  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };  // &amp;lt;DEV_EUI&amp;gt; inversé&lt;br /&gt;
static const u1_t PROGMEM APPEUI[8]  = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };  // &amp;lt;JOIN_EUI&amp;gt; inversé&lt;br /&gt;
static const u1_t PROGMEM APPKEY[16] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,&lt;br /&gt;
                                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };  // &amp;lt;APP_KEY&amp;gt;&lt;br /&gt;
&lt;br /&gt;
void os_getDevEui(u1_t *buf) { memcpy_P(buf, DEVEUI, 8); }&lt;br /&gt;
void os_getArtEui(u1_t *buf) { memcpy_P(buf, APPEUI, 8); }&lt;br /&gt;
void os_getDevKey(u1_t *buf) { memcpy_P(buf, APPKEY, 16); }&lt;br /&gt;
&lt;br /&gt;
// ---------------------------------------------------------------------------&lt;br /&gt;
// 2) Branchements — À ADAPTER à votre carte.&lt;br /&gt;
// ---------------------------------------------------------------------------&lt;br /&gt;
const lmic_pinmap lmic_pins = {&lt;br /&gt;
  .nss  = 10,&lt;br /&gt;
  .rxtx = LMIC_UNUSED_PIN,&lt;br /&gt;
  .rst  = 9,&lt;br /&gt;
  .dio  = { 2, 6, 7 },        // DIO0, DIO1, DIO2 : LMIC a besoin de DIO0 ET de DIO1 réellement câblés&lt;br /&gt;
};&lt;br /&gt;
&lt;br /&gt;
const uint8_t  PIN_SONDE      = A2;   // sortie analogique de la sonde capacitive&lt;br /&gt;
const uint8_t  PIN_ALIM_SONDE = 5;    // commande de l&amp;#039;alimentation de la sonde (économise le courant)&lt;br /&gt;
const uint32_t INTERVALLE_S   = 600;  // 10 min ; les limites légales (1 % de temps d&amp;#039;antenne) vous laissent bien plus&lt;br /&gt;
const uint8_t  PORT_APPLI     = 10;   // doit correspondre au formateur TTN&lt;br /&gt;
&lt;br /&gt;
static osjob_t jobEnvoi;&lt;br /&gt;
static uint8_t trame[7];&lt;br /&gt;
&lt;br /&gt;
// Mesure la tension d&amp;#039;alimentation (mV) en comparant la référence interne 1,1 V à Vcc.&lt;br /&gt;
static uint16_t lireVccMv() {&lt;br /&gt;
  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);&lt;br /&gt;
  delay(2);                               // laisse la référence se stabiliser&lt;br /&gt;
  ADCSRA |= _BV(ADSC);&lt;br /&gt;
  while (bit_is_set(ADCSRA, ADSC)) {}&lt;br /&gt;
  return (uint16_t)(1125300UL / ADC);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
// Lit la sonde : moyenne de 8 mesures pour lisser le bruit.&lt;br /&gt;
static uint16_t lireSonde() {&lt;br /&gt;
  digitalWrite(PIN_ALIM_SONDE, HIGH);&lt;br /&gt;
  delay(100);                             // temps de stabilisation de la sonde&lt;br /&gt;
  uint32_t somme = 0;&lt;br /&gt;
  for (uint8_t i = 0; i &amp;lt; 8; i++) { somme += analogRead(PIN_SONDE); delay(5); }&lt;br /&gt;
  digitalWrite(PIN_ALIM_SONDE, LOW);&lt;br /&gt;
  return (uint16_t)(somme / 8);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
static void construireTrame() {&lt;br /&gt;
  uint16_t brut = lireSonde();&lt;br /&gt;
  uint16_t vcc  = lireVccMv();&lt;br /&gt;
  int16_t  temp = (int16_t)0x8000;        // pas de capteur de température dans cet exemple&lt;br /&gt;
  trame[0] = 0xA1;&lt;br /&gt;
  trame[1] = brut &amp;gt;&amp;gt; 8;  trame[2] = brut &amp;amp; 0xFF;&lt;br /&gt;
  trame[3] = ((uint16_t)temp) &amp;gt;&amp;gt; 8;  trame[4] = ((uint16_t)temp) &amp;amp; 0xFF;&lt;br /&gt;
  trame[5] = vcc &amp;gt;&amp;gt; 8;   trame[6] = vcc &amp;amp; 0xFF;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
static void envoyer(osjob_t *job) {&lt;br /&gt;
  // Si une émission est encore en cours, on ne fait rien : la prochaine sera replanifiée par onEvent().&lt;br /&gt;
  if (LMIC.opmode &amp;amp; OP_TXRXPEND) {&lt;br /&gt;
    Serial.println(F(&amp;quot;emission deja en cours&amp;quot;));&lt;br /&gt;
    return;&lt;br /&gt;
  }&lt;br /&gt;
  construireTrame();                      // les mesures se font AVANT la mise en file...&lt;br /&gt;
  LMIC_setTxData2(PORT_APPLI, trame, sizeof(trame), 0);&lt;br /&gt;
  Serial.println(F(&amp;quot;trame en file&amp;quot;));     // ...et surtout aucun delay() après : il fausserait les fenêtres de réception&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void onEvent(ev_t ev) {&lt;br /&gt;
  switch (ev) {&lt;br /&gt;
    case EV_JOINING:&lt;br /&gt;
      Serial.println(F(&amp;quot;join en cours&amp;quot;));&lt;br /&gt;
      break;&lt;br /&gt;
    case EV_JOINED:&lt;br /&gt;
      Serial.println(F(&amp;quot;join OK&amp;quot;));&lt;br /&gt;
      LMIC_setLinkCheckMode(0);           // inutile pour un capteur fixe, économise des échanges&lt;br /&gt;
      break;&lt;br /&gt;
    case EV_JOIN_FAILED:&lt;br /&gt;
      Serial.println(F(&amp;quot;join echoue : verifier l&amp;#039;ordre des octets des cles et la portee&amp;quot;));&lt;br /&gt;
      break;&lt;br /&gt;
    case EV_TXCOMPLETE:&lt;br /&gt;
      Serial.println(F(&amp;quot;emission terminee&amp;quot;));&lt;br /&gt;
      // Toujours replanifier ici : si on oublie, le capteur s&amp;#039;arrête en silence.&lt;br /&gt;
      os_setTimedCallback(&amp;amp;jobEnvoi, os_getTime() + sec2osticks(INTERVALLE_S), envoyer);&lt;br /&gt;
      break;&lt;br /&gt;
    default:&lt;br /&gt;
      break;&lt;br /&gt;
  }&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void setup() {&lt;br /&gt;
  Serial.begin(115200);&lt;br /&gt;
  pinMode(PIN_ALIM_SONDE, OUTPUT);&lt;br /&gt;
  digitalWrite(PIN_ALIM_SONDE, LOW);&lt;br /&gt;
&lt;br /&gt;
  os_init();&lt;br /&gt;
  LMIC_reset();&lt;br /&gt;
  // L&amp;#039;horloge de l&amp;#039;ATmega à 8 MHz dérive : sans cette tolérance de 2 %, les fenêtres de&lt;br /&gt;
  // réception s&amp;#039;ouvrent à côté et la réponse au « join » est manquée.&lt;br /&gt;
  LMIC_setClockError(MAX_CLOCK_ERROR * 2 / 100);&lt;br /&gt;
  LMIC_setAdrMode(1);                     // capteur fixe : le réseau peut ajuster le facteur d&amp;#039;étalement&lt;br /&gt;
  LMIC_setDrTxpow(DR_SF7, 14);            // 14 dBm = plafond EU868 pour les canaux par défaut&lt;br /&gt;
&lt;br /&gt;
  envoyer(&amp;amp;jobEnvoi);                     // lance le « join » puis la première trame&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void loop() {&lt;br /&gt;
  os_runloop_once();                      // moteur LMIC : à appeler le plus souvent possible, sans delay()&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== b. Formateur de charge utile TTN ==&lt;br /&gt;
Ne décode que le port et le format du croquis (a) ; renvoie une erreur sinon. À coller dans la console TTN, ou mieux : sur l&amp;#039;appareil seul.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;javascript&amp;quot;&amp;gt;&lt;br /&gt;
// Formateur de charge utile TTN (montante) — exemple de démarrage (Alseno Tech, licence MIT).&lt;br /&gt;
// À coller dans : console TTN &amp;gt; Application &amp;gt; Payload formatters &amp;gt; Uplink &amp;gt; JavaScript.&lt;br /&gt;
//&lt;br /&gt;
// PIÈGE : un formateur défini au niveau de l&amp;#039;APPLICATION s&amp;#039;applique à TOUS les appareils&lt;br /&gt;
// de cette application (capteurs, mouchards de couverture, tests...). Un appareil qui n&amp;#039;a&lt;br /&gt;
// rien à voir recevrait des « mesures » inventées. Deux protections ci-dessous :&lt;br /&gt;
//   1. on ne décode que le port PORT_SOL ;&lt;br /&gt;
//   2. on exige l&amp;#039;octet d&amp;#039;identification 0xA1 et la bonne longueur ; sinon on répond par une erreur,&lt;br /&gt;
//      jamais par des valeurs plausibles.&lt;br /&gt;
// Mieux encore : définissez le formateur sur l&amp;#039;appareil lui-même (onglet Payload formatters&lt;br /&gt;
// de l&amp;#039;appareil), il ne touche alors que celui-là.&lt;br /&gt;
&lt;br /&gt;
var PORT_SOL = 10;&lt;br /&gt;
var ID_FORMAT = 0xA1;&lt;br /&gt;
var LONGUEUR = 7;&lt;br /&gt;
&lt;br /&gt;
// Calibration de VOTRE sonde (voir la page « Capteur de sol ») : valeur brute dans l&amp;#039;air / dans l&amp;#039;eau.&lt;br /&gt;
var BRUT_SEC = 870;      // sonde à l&amp;#039;air libre : 0 %&lt;br /&gt;
var BRUT_HUMIDE = 560;   // sonde dans l&amp;#039;eau : 100 %  (une sonde capacitive donne MOINS quand c&amp;#039;est plus humide)&lt;br /&gt;
&lt;br /&gt;
function decodeUplink(input) {&lt;br /&gt;
  var b = input.bytes;&lt;br /&gt;
&lt;br /&gt;
  if (input.fPort !== PORT_SOL) {&lt;br /&gt;
    return { errors: [&amp;quot;port &amp;quot; + input.fPort + &amp;quot; non géré par ce formateur&amp;quot;] };&lt;br /&gt;
  }&lt;br /&gt;
  if (b.length !== LONGUEUR || b[0] !== ID_FORMAT) {&lt;br /&gt;
    return { errors: [&amp;quot;trame inconnue (longueur &amp;quot; + b.length + &amp;quot;)&amp;quot;] };&lt;br /&gt;
  }&lt;br /&gt;
&lt;br /&gt;
  var brut = (b[1] &amp;lt;&amp;lt; 8) | b[2];&lt;br /&gt;
  var tempBrute = (b[3] &amp;lt;&amp;lt; 8) | b[4];&lt;br /&gt;
  if (tempBrute &amp;amp; 0x8000) tempBrute -= 0x10000;      // entier signé sur 16 bits&lt;br /&gt;
  var vccMv = (b[5] &amp;lt;&amp;lt; 8) | b[6];&lt;br /&gt;
&lt;br /&gt;
  // Conversion brut -&amp;gt; pourcentage, bornée entre 0 et 100.&lt;br /&gt;
  var pct = 100 * (BRUT_SEC - brut) / (BRUT_SEC - BRUT_HUMIDE);&lt;br /&gt;
  pct = Math.max(0, Math.min(100, Math.round(pct)));&lt;br /&gt;
&lt;br /&gt;
  var data = { sol_brut: brut, sol_pct: pct, batterie_mv: vccMv };&lt;br /&gt;
  if (tempBrute !== -32768) data.temperature_c = tempBrute / 100;   // 0x8000 = « pas de mesure »&lt;br /&gt;
  return { data: data };&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== c. Récepteur de webhook TTN ==&lt;br /&gt;
Reçoit les messages de TTN, vérifie la clé, déduplique, range les mesures dans SQLite. Une seule dépendance (Flask).&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;python&amp;quot;&amp;gt;&lt;br /&gt;
#!/usr/bin/env python3&lt;br /&gt;
&amp;quot;&amp;quot;&amp;quot;Récepteur minimal de webhook TTN : stocke les mesures dans SQLite.&lt;br /&gt;
&lt;br /&gt;
Exemple de démarrage (Alseno Tech, licence MIT). Une seule dépendance : Flask.&lt;br /&gt;
&lt;br /&gt;
    pip install flask&lt;br /&gt;
    export CLE_INGESTION=&amp;quot;&amp;lt;CLE_A_CHOISIR&amp;gt;&amp;quot;      # longue chaîne aléatoire, à vous&lt;br /&gt;
    python recepteur_webhook.py&lt;br /&gt;
&lt;br /&gt;
Dans la console TTN : Integrations &amp;gt; Webhooks &amp;gt; Custom webhook&lt;br /&gt;
    URL de base : https://&amp;lt;URL_API&amp;gt;      chemin montant : /ttn&lt;br /&gt;
    En-tête     : X-Ingest-Key = &amp;lt;CLE_A_CHOISIR&amp;gt;&lt;br /&gt;
(Exposez le service derrière HTTPS : proxy inverse, tunnel...)&lt;br /&gt;
&lt;br /&gt;
Choix de conception, tirés de l&amp;#039;expérience :&lt;br /&gt;
  * on répond TOUJOURS 200 aux charges inattendues ou déjà vues : un webhook qui reçoit&lt;br /&gt;
    des erreurs réessaie, puis TTN finit par le désactiver. Seules l&amp;#039;authentification&lt;br /&gt;
    (401) et une vraie panne (500) échouent ;&lt;br /&gt;
  * on garde la charge d&amp;#039;origine (colonne brut) : un décodeur peut être faux, et sans le&lt;br /&gt;
    brut on ne peut rien rejouer ;&lt;br /&gt;
  * un doublon (même appareil, même compteur de trame, même heure) est ignoré proprement.&lt;br /&gt;
&amp;quot;&amp;quot;&amp;quot;&lt;br /&gt;
import hmac&lt;br /&gt;
import json&lt;br /&gt;
import os&lt;br /&gt;
import sqlite3&lt;br /&gt;
&lt;br /&gt;
from flask import Flask, jsonify, request&lt;br /&gt;
&lt;br /&gt;
BASE = os.environ.get(&amp;quot;BASE_SQLITE&amp;quot;, &amp;quot;mesures.db&amp;quot;)&lt;br /&gt;
CLE = os.environ.get(&amp;quot;CLE_INGESTION&amp;quot;, &amp;quot;&amp;quot;)&lt;br /&gt;
&lt;br /&gt;
app = Flask(__name__)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
def ouvrir_base():&lt;br /&gt;
    &amp;quot;&amp;quot;&amp;quot;Ouvre la base et crée les tables au premier appel (mode WAL : lecture pendant l&amp;#039;écriture).&amp;quot;&amp;quot;&amp;quot;&lt;br /&gt;
    cnx = sqlite3.connect(BASE)&lt;br /&gt;
    cnx.execute(&amp;quot;PRAGMA journal_mode=WAL&amp;quot;)&lt;br /&gt;
    cnx.executescript(&amp;quot;&amp;quot;&amp;quot;&lt;br /&gt;
        CREATE TABLE IF NOT EXISTS receptions (&lt;br /&gt;
            id INTEGER PRIMARY KEY,&lt;br /&gt;
            appareil TEXT NOT NULL,&lt;br /&gt;
            recu_le TEXT NOT NULL,&lt;br /&gt;
            compteur INTEGER,&lt;br /&gt;
            rssi REAL, snr REAL,&lt;br /&gt;
            brut TEXT NOT NULL,&lt;br /&gt;
            UNIQUE (appareil, compteur, recu_le)&lt;br /&gt;
        );&lt;br /&gt;
        CREATE TABLE IF NOT EXISTS mesures (&lt;br /&gt;
            reception_id INTEGER NOT NULL REFERENCES receptions(id),&lt;br /&gt;
            grandeur TEXT NOT NULL,&lt;br /&gt;
            valeur REAL NOT NULL&lt;br /&gt;
        );&lt;br /&gt;
        CREATE INDEX IF NOT EXISTS idx_mesures ON mesures (grandeur, reception_id);&lt;br /&gt;
    &amp;quot;&amp;quot;&amp;quot;)&lt;br /&gt;
    return cnx&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
def cle_valide():&lt;br /&gt;
    &amp;quot;&amp;quot;&amp;quot;Compare la clé reçue à la clé attendue, en temps constant.&amp;quot;&amp;quot;&amp;quot;&lt;br /&gt;
    recue = request.headers.get(&amp;quot;X-Ingest-Key&amp;quot;, &amp;quot;&amp;quot;)&lt;br /&gt;
    return bool(CLE) and hmac.compare_digest(recue, CLE)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
@app.post(&amp;quot;/ttn&amp;quot;)&lt;br /&gt;
def recevoir():&lt;br /&gt;
    if not cle_valide():&lt;br /&gt;
        return jsonify(erreur=&amp;quot;non autorise&amp;quot;), 401&lt;br /&gt;
&lt;br /&gt;
    msg = request.get_json(silent=True) or {}&lt;br /&gt;
    montante = msg.get(&amp;quot;uplink_message&amp;quot;)&lt;br /&gt;
    if not montante:                       # événement qui n&amp;#039;est pas une mesure (join, etc.)&lt;br /&gt;
        return jsonify(ok=True, ignore=&amp;quot;pas une mesure&amp;quot;)&lt;br /&gt;
&lt;br /&gt;
    appareil = msg.get(&amp;quot;end_device_ids&amp;quot;, {}).get(&amp;quot;device_id&amp;quot;, &amp;quot;inconnu&amp;quot;)&lt;br /&gt;
    decode = montante.get(&amp;quot;decoded_payload&amp;quot;) or {}&lt;br /&gt;
    # On ne retient que les valeurs numériques : un champ texte inattendu ne casse rien.&lt;br /&gt;
    mesures = {k: float(v) for k, v in decode.items()&lt;br /&gt;
               if isinstance(v, (int, float)) and not isinstance(v, bool)}&lt;br /&gt;
    if not mesures:&lt;br /&gt;
        return jsonify(ok=True, ignore=&amp;quot;rien a stocker&amp;quot;)&lt;br /&gt;
&lt;br /&gt;
    meta = (montante.get(&amp;quot;rx_metadata&amp;quot;) or [{}])[0]   # première passerelle ayant entendu la trame&lt;br /&gt;
    cnx = ouvrir_base()&lt;br /&gt;
    try:&lt;br /&gt;
        with cnx:                          # une transaction : tout ou rien&lt;br /&gt;
            cur = cnx.execute(&lt;br /&gt;
                &amp;quot;INSERT OR IGNORE INTO receptions (appareil, recu_le, compteur, rssi, snr, brut) &amp;quot;&lt;br /&gt;
                &amp;quot;VALUES (?, ?, ?, ?, ?, ?)&amp;quot;,&lt;br /&gt;
                (appareil, msg.get(&amp;quot;received_at&amp;quot;, &amp;quot;&amp;quot;), montante.get(&amp;quot;f_cnt&amp;quot;),&lt;br /&gt;
                 meta.get(&amp;quot;rssi&amp;quot;), meta.get(&amp;quot;snr&amp;quot;), json.dumps(msg)))&lt;br /&gt;
            if cur.rowcount == 0:          # doublon : déjà enregistré&lt;br /&gt;
                return jsonify(ok=True, ignore=&amp;quot;doublon&amp;quot;)&lt;br /&gt;
            cnx.executemany(&lt;br /&gt;
                &amp;quot;INSERT INTO mesures (reception_id, grandeur, valeur) VALUES (?, ?, ?)&amp;quot;,&lt;br /&gt;
                [(cur.lastrowid, g, v) for g, v in mesures.items()])&lt;br /&gt;
    finally:&lt;br /&gt;
        cnx.close()&lt;br /&gt;
    return jsonify(ok=True, stocke=len(mesures))&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
if __name__ == &amp;quot;__main__&amp;quot;:&lt;br /&gt;
    app.run(host=&amp;quot;127.0.0.1&amp;quot;, port=8600)    # derrière un proxy HTTPS, jamais exposé tel quel&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== d. Calibration sec / mouillé ==&lt;br /&gt;
Calcule les deux repères à partir de vos relevés, puis convertit une valeur brute en pourcentage.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;python&amp;quot;&amp;gt;&lt;br /&gt;
#!/usr/bin/env python3&lt;br /&gt;
&amp;quot;&amp;quot;&amp;quot;Calibration sec / mouillé d&amp;#039;une sonde d&amp;#039;humidité du sol et conversion ADC -&amp;gt; %.&lt;br /&gt;
&lt;br /&gt;
Exemple de démarrage (Alseno Tech, licence MIT). Aucune dépendance.&lt;br /&gt;
&lt;br /&gt;
Méthode : relevez 20 à 30 valeurs brutes (dans le moniteur série ou la console TTN),&lt;br /&gt;
une par ligne dans un fichier texte, dans deux situations :&lt;br /&gt;
  - sonde SÈCHE (à l&amp;#039;air libre, ou dans le sol le plus sec que vous aurez) ;&lt;br /&gt;
  - sonde MOUILLÉE (plongée dans l&amp;#039;eau jusqu&amp;#039;à la ligne de repère, ou sol saturé).&lt;br /&gt;
&lt;br /&gt;
    python calibration_sonde.py enregistrer sec     &amp;lt; releves_sec.txt&lt;br /&gt;
    python calibration_sonde.py enregistrer mouille &amp;lt; releves_eau.txt&lt;br /&gt;
    python calibration_sonde.py convertir 640&lt;br /&gt;
&lt;br /&gt;
Une sonde capacitive donne une valeur PLUS BASSE quand le sol est plus humide : le script&lt;br /&gt;
s&amp;#039;en accommode (il travaille avec l&amp;#039;écart entre les deux repères, quel que soit le sens).&lt;br /&gt;
Chaque sonde est différente : calibrez-les une par une.&lt;br /&gt;
&amp;quot;&amp;quot;&amp;quot;&lt;br /&gt;
import json&lt;br /&gt;
import statistics&lt;br /&gt;
import sys&lt;br /&gt;
&lt;br /&gt;
FICHIER = &amp;quot;calibration.json&amp;quot;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
def lire_releves(flux):&lt;br /&gt;
    &amp;quot;&amp;quot;&amp;quot;Lit des nombres, un par ligne, en ignorant les lignes vides ou non numériques.&amp;quot;&amp;quot;&amp;quot;&lt;br /&gt;
    valeurs = []&lt;br /&gt;
    for ligne in flux:&lt;br /&gt;
        try:&lt;br /&gt;
            valeurs.append(float(ligne.strip()))&lt;br /&gt;
        except ValueError:&lt;br /&gt;
            continue&lt;br /&gt;
    return valeurs&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
def charger():&lt;br /&gt;
    try:&lt;br /&gt;
        with open(FICHIER, encoding=&amp;quot;utf-8&amp;quot;) as f:&lt;br /&gt;
            return json.load(f)&lt;br /&gt;
    except FileNotFoundError:&lt;br /&gt;
        return {}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
def enregistrer(repere, valeurs):&lt;br /&gt;
    &amp;quot;&amp;quot;&amp;quot;Stocke la médiane (insensible aux mesures aberrantes) et la dispersion.&amp;quot;&amp;quot;&amp;quot;&lt;br /&gt;
    if len(valeurs) &amp;lt; 5:&lt;br /&gt;
        sys.exit(&amp;quot;Il faut au moins 5 relevés (idéalement 20 à 30).&amp;quot;)&lt;br /&gt;
    cal = charger()&lt;br /&gt;
    cal[repere] = {&amp;quot;mediane&amp;quot;: statistics.median(valeurs),&lt;br /&gt;
                   &amp;quot;ecart_type&amp;quot;: round(statistics.pstdev(valeurs), 2),&lt;br /&gt;
                   &amp;quot;nombre&amp;quot;: len(valeurs)}&lt;br /&gt;
    with open(FICHIER, &amp;quot;w&amp;quot;, encoding=&amp;quot;utf-8&amp;quot;) as f:&lt;br /&gt;
        json.dump(cal, f, indent=2)&lt;br /&gt;
    print(repere, &amp;quot;=&amp;quot;, cal[repere])&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
def convertir(brut):&lt;br /&gt;
    &amp;quot;&amp;quot;&amp;quot;Valeur brute -&amp;gt; pourcentage d&amp;#039;humidité (0 = repère sec, 100 = repère mouillé), borné.&amp;quot;&amp;quot;&amp;quot;&lt;br /&gt;
    cal = charger()&lt;br /&gt;
    if &amp;quot;sec&amp;quot; not in cal or &amp;quot;mouille&amp;quot; not in cal:&lt;br /&gt;
        sys.exit(&amp;quot;Enregistrez d&amp;#039;abord les deux repères : sec puis mouille.&amp;quot;)&lt;br /&gt;
    sec, mouille = cal[&amp;quot;sec&amp;quot;][&amp;quot;mediane&amp;quot;], cal[&amp;quot;mouille&amp;quot;][&amp;quot;mediane&amp;quot;]&lt;br /&gt;
    if abs(sec - mouille) &amp;lt; 20:&lt;br /&gt;
        sys.exit(&amp;quot;Repères trop proches : sonde défaillante ou mauvais essai.&amp;quot;)&lt;br /&gt;
    pct = 100.0 * (brut - sec) / (mouille - sec)&lt;br /&gt;
    return max(0.0, min(100.0, pct))&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
if __name__ == &amp;quot;__main__&amp;quot;:&lt;br /&gt;
    if len(sys.argv) == 3 and sys.argv[1] == &amp;quot;enregistrer&amp;quot; and sys.argv[2] in (&amp;quot;sec&amp;quot;, &amp;quot;mouille&amp;quot;):&lt;br /&gt;
        enregistrer(sys.argv[2], lire_releves(sys.stdin))&lt;br /&gt;
    elif len(sys.argv) == 3 and sys.argv[1] == &amp;quot;convertir&amp;quot;:&lt;br /&gt;
        print(&amp;quot;%.0f %%&amp;quot; % convertir(float(sys.argv[2])))&lt;br /&gt;
    else:&lt;br /&gt;
        sys.exit(__doc__)&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== e. Règle de conseil d&amp;#039;arrosage ==&lt;br /&gt;
Un seuil et une tendance. Point de départ à ajuster par plante et par sol, avant un modèle appris (voir [[Agriculture de précision]]).&lt;br /&gt;
&lt;br /&gt;
&amp;lt;syntaxhighlight lang=&amp;quot;python&amp;quot;&amp;gt;&lt;br /&gt;
#!/usr/bin/env python3&lt;br /&gt;
&amp;quot;&amp;quot;&amp;quot;Conseil d&amp;#039;arrosage v1 : un seuil et une tendance. Point de départ d&amp;#039;un modèle plus fin.&lt;br /&gt;
&lt;br /&gt;
Exemple de démarrage (Alseno Tech, licence MIT). Aucune dépendance.&lt;br /&gt;
&lt;br /&gt;
Idée : on n&amp;#039;arrose pas seulement parce que le sol est sec, on regarde aussi&lt;br /&gt;
  - s&amp;#039;il vient d&amp;#039;être mouillé (pluie, arrosage) : la tendance est à la hausse -&amp;gt; on attend ;&lt;br /&gt;
  - s&amp;#039;il s&amp;#039;assèche vite : on prévient plus tôt.&lt;br /&gt;
Les seuils dépendent de la plante et du sol : ce sont des valeurs de départ à ajuster.&lt;br /&gt;
&amp;quot;&amp;quot;&amp;quot;&lt;br /&gt;
from datetime import datetime, timedelta&lt;br /&gt;
&lt;br /&gt;
SEUIL_ARROSER = 30.0      # % d&amp;#039;humidité en dessous duquel on conseille d&amp;#039;arroser&lt;br /&gt;
SEUIL_ATTENTION = 40.0    # en dessous, on surveille de près&lt;br /&gt;
HAUSSE_PLUIE = 5.0        # hausse (points de %) en 2 h qui signale un arrosage ou une pluie récente&lt;br /&gt;
FENETRE_H = 3             # durée sur laquelle on mesure la tendance&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
def pente_par_heure(releves, maintenant):&lt;br /&gt;
    &amp;quot;&amp;quot;&amp;quot;Pente moyenne (points de % par heure) sur FENETRE_H heures, par régression linéaire simple.&lt;br /&gt;
&lt;br /&gt;
    releves : liste de (datetime, pourcentage). Renvoie None s&amp;#039;il y a trop peu de points.&amp;quot;&amp;quot;&amp;quot;&lt;br /&gt;
    debut = maintenant - timedelta(hours=FENETRE_H)&lt;br /&gt;
    pts = [((t - debut).total_seconds() / 3600.0, v) for t, v in releves if t &amp;gt;= debut]&lt;br /&gt;
    if len(pts) &amp;lt; 4:&lt;br /&gt;
        return None&lt;br /&gt;
    n = len(pts)&lt;br /&gt;
    mx = sum(x for x, _ in pts) / n&lt;br /&gt;
    my = sum(y for _, y in pts) / n&lt;br /&gt;
    var = sum((x - mx) ** 2 for x, _ in pts)&lt;br /&gt;
    if var == 0:&lt;br /&gt;
        return None&lt;br /&gt;
    return sum((x - mx) * (y - my) for x, y in pts) / var&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
def conseil(releves, maintenant=None):&lt;br /&gt;
    &amp;quot;&amp;quot;&amp;quot;Renvoie (action, raison) avec action dans &amp;#039;arroser&amp;#039;, &amp;#039;surveiller&amp;#039;, &amp;#039;attendre&amp;#039;, &amp;#039;donnees_insuffisantes&amp;#039;.&amp;quot;&amp;quot;&amp;quot;&lt;br /&gt;
    maintenant = maintenant or datetime.now()&lt;br /&gt;
    if not releves:&lt;br /&gt;
        return &amp;quot;donnees_insuffisantes&amp;quot;, &amp;quot;aucune mesure&amp;quot;&lt;br /&gt;
    releves = sorted(releves)&lt;br /&gt;
    dernier_t, dernier = releves[-1]&lt;br /&gt;
    if maintenant - dernier_t &amp;gt; timedelta(hours=2):&lt;br /&gt;
        return &amp;quot;donnees_insuffisantes&amp;quot;, &amp;quot;derniere mesure trop ancienne (capteur muet ?)&amp;quot;&lt;br /&gt;
&lt;br /&gt;
    pente = pente_par_heure(releves, maintenant)&lt;br /&gt;
    deux_h = [v for t, v in releves if t &amp;gt;= maintenant - timedelta(hours=2)]&lt;br /&gt;
    if deux_h and dernier - min(deux_h) &amp;gt;= HAUSSE_PLUIE:&lt;br /&gt;
        return &amp;quot;attendre&amp;quot;, &amp;quot;humidite en hausse : pluie ou arrosage recent&amp;quot;&lt;br /&gt;
&lt;br /&gt;
    if dernier &amp;lt; SEUIL_ARROSER:&lt;br /&gt;
        return &amp;quot;arroser&amp;quot;, &amp;quot;sol sec (%.0f %% &amp;lt; %.0f %%)&amp;quot; % (dernier, SEUIL_ARROSER)&lt;br /&gt;
    if dernier &amp;lt; SEUIL_ATTENTION and pente is not None and pente &amp;lt; -1.0:&lt;br /&gt;
        return &amp;quot;arroser&amp;quot;, &amp;quot;sol en train de secher vite (%.1f points/h)&amp;quot; % pente&lt;br /&gt;
    if dernier &amp;lt; SEUIL_ATTENTION:&lt;br /&gt;
        return &amp;quot;surveiller&amp;quot;, &amp;quot;sol assez sec (%.0f %%)&amp;quot; % dernier&lt;br /&gt;
    return &amp;quot;attendre&amp;quot;, &amp;quot;humidite suffisante (%.0f %%)&amp;quot; % dernier&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
if __name__ == &amp;quot;__main__&amp;quot;:&lt;br /&gt;
    # Démonstration avec des mesures fictives : le sol sèche de 45 % à 32 % en 3 heures.&lt;br /&gt;
    maintenant = datetime(2026, 1, 1, 12, 0)&lt;br /&gt;
    exemple = [(maintenant - timedelta(minutes=15 * k), 32 + 13 * (k / 12.0)) for k in range(13)]&lt;br /&gt;
    print(conseil(exemple, maintenant))&lt;br /&gt;
&amp;lt;/syntaxhighlight&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Pour aller plus loin ==&lt;br /&gt;
* Ajouter un capteur de température au croquis et à la trame (le champ existe déjà).&lt;br /&gt;
* Faire dormir le microcontrôleur entre deux mesures si vous êtes sur piles.&lt;br /&gt;
* Brancher le conseil (e) sur les mesures de la base du récepteur (c).&lt;br /&gt;
* Commander une vanne : voir [[Matériel et coûts]].&lt;br /&gt;
&lt;br /&gt;
== Licence ==&lt;br /&gt;
Exemples proposés sous licence MIT, © Alseno Tech (sous réserve de confirmation).&lt;br /&gt;
&lt;br /&gt;
[[Catégorie:Agritech]]&lt;br /&gt;
[[Catégorie:Capteurs]]&lt;br /&gt;
[[Catégorie:LoRaWAN]]&lt;br /&gt;
[[Catégorie:Agriculture de précision]]&lt;/div&gt;</summary>
		<author><name>Robot-agri</name></author>
	</entry>
</feed>