Publication LoRaWAN de mesures environnementales avec un module LoRa-E5

void setup() {

  // Démarrage du port série du ST-LINK
  Serial.begin(STLK_BDRATE);

  // Démarrage du port série du module LoRa-E5
  LoRa.begin(LORA_BDRATE);

  Serial.println("Setup completed !");  
}

void loop() {

  // Lecture des commandes en provenance du terminal série Arduino
  // Envoi de ces commandes au module LoRa-E5
  while (Serial.available() > 0) {
    LoRa.write(Serial.read());
  }

  // Lecture des réponses du module LoRa-E5
  // Ecriture de ces réponses sur le terminal série Arduino
  while (LoRa.available() > 0) {
    Serial.write(LoRa.read());
  }
}

//*******************************************************************************************
// Connexion d'un module LoRa-E5 à un réseau LoRaWAN privé sur TTN, préalablement configuré.
// Publication de données de température, humidité et pression sur TTN dans un format
// hexadécimal qui devra ensuite être "décodé" par un parser de payloads sur TagoIO.
// La bibliothèque pour le module LoRa-E5 utilisée est celle de Sylvain Montagny 
// dans sa révision 3.0.0.
// Voir la page README sur https://github.com/SylvainMontagny/LoRaE5, le code exemple 
// utilisé (recopié presque tel quel) est "LoRWAN_Class_A.ino".
//*******************************************************************************************

// Configuration des ports série (celui du ST_Link et celui du module LoRa-E5)
// La biliothèque de Sylvain Montagny suppose  :
// - Que le port série du ST-Link s'appelle "Debug_Serial" et qu'il a une vitesse de 115200 bauds
// - Que le port série du module LoRa-E5 s'appelle "LoRa_Serial" et qu'il a une vitesse de 9600 bauds
// Le fichier "config_board.h" précise les broches utilisées pour le module LoRa-E5.
#include "config_board.h"

// Bibliothèque pour la lecture du capteur BME280, choisie pour ses commandes permettant
// d'utiliser celui-ci en mode basse consommation.
#include <GyverBME280.h>

// Instance du capteur BME280
GyverBME280 bme;

// Variables globales pour les mesures
float temp;  // Température (Celsius)
float pres;  // Pression (hPa)
float humi;  // Humidité relative (%)

// Offset de température du BME280
// (déterminé expérimentalement et différent pour chaque capteur)
#define TEMP_OFFSET (-2.1)

// Bibliothèque basse consommation pour le MCU STM32
#include "STM32LowPower.h"

// Configurations pour la communication LoRaWAN

// Bibliothèque pour l'utilisation du module LoRa-E5 (commandes AT)
#include "lorae5.h"

// Fichier pour renseigner les paramètres de la connexion LoRa
#include "config_application.h" 

// Temps de sommeil du MCU STM32, en millisecondes, entre deux posts (10 minutes)
#define LOW_POWER_DURATION_MS 600000

#define PAYLOAD_SIZE 5 // Nombre d'octets dans les Payloads LoRaWAN
uint8_t payloadUp[PAYLOAD_SIZE]; // Réservation mémoire pour la payload "Uplink"
uint8_t payloadDown[PAYLOAD_SIZE]; // Réservation mémoire pour la payload "Downlink"

uint8_t sizePayloadUp = PAYLOAD_SIZE; // Taille de la payload "Uplink" 
uint8_t sizePayloadDown = PAYLOAD_SIZE; // Taille de la payload "Downlink"

// Instanciation du module LoRa-E5, les paramètres sont dans le fichier config_application.h
LORAE5 lorae5(devEUI, appEUI, appKey, devAddr, nwkSKey, appSKey);

//*******************************************************************************************
// Initialisations
//*******************************************************************************************
void setup() {
  
  // Initialisation des ports série du ST-Link et du module LoRa-E5
  lorae5.setup_hardware(&Debug_Serial, &LoRa_Serial); 

  // Initialisation du BME280, pour utiliser le capteur en mode : "lis et rendors-toi !"
  bme.setMode(FORCED_MODE);
  bme.begin();

  // Configuration du module LoRA-E5
  lorae5.setup_lorawan(REGION, ACTIVATION_MODE, CLASS, SPREADING_FACTOR, ADAPTIVE_DR, CONFIRMED, PORT_UP, SEND_BY_PUSH_BUTTON, FRAME_DELAY);

  // Affichage de la configuration
  lorae5.printInfo();
  
  // Réalisation du join "Over The Air Activation" (OTAA)
  Debug_Serial.println("Procédure de join OTAA en cours ...");
  while (!lorae5.join()) {};
  delay(2000); // Temporisation de deux secondes

  // Configure la LED utilisateur de la carte NUCLEO
  pinMode(LED_BUILTIN, OUTPUT);

  // Active le mode basse consommation du MCU STM32
  LowPower.begin();
}

//*******************************************************************************************
// Boucle du programme principal
//*******************************************************************************************
void loop() {

  Debug_Serial.println("\r\nMesure en cours ...");

  // Allume la LED
  digitalWrite(LED_BUILTIN, HIGH);

  // Mesure de la température, de la pression et de l'humidité
  measure();

  // Construction de la payload LoRaWAN à partir des mesures
  build_LoRaWAN_payload();

  // Emission de la trame LoRaWAN
  // Envoie "sizePayloadUp" octets depuis le tableau "payloadUp"
  lorae5.sendData(payloadUp, sizePayloadUp);

  // Vérifie si un Downlink est planifié sur RX1-RX2 (device de classe A) 
  // Appelle processDownlink() pour traiter les octets reçus le cas échéant.
  if (lorae5.awaitForDownlinkClass_A(payloadDown, &sizePayloadDown) == RET_DOWNLINK){
     processDownlink();
  };

  // Place le module LoRa-E5 en mode "basse consommation" jusqu'à la prochaine mesure
  lorae5.sleep();
  
  Debug_Serial.printf("Mise en veille pour %u secondes\r\n", LOW_POWER_DURATION_MS / 1000);

  // Eteint la LED
  digitalWrite(LED_BUILTIN, LOW);
  
  Debug_Serial.flush();  // Vide le buffer du port série avant la mise en sommeil
  delay(1000); // Temporisation blocante pendant 1 seconde
  
  // Place le MCU STM32 en mode sommeil pendant LOW_POWER_DURATION_MS millisecondes
  LowPower.shutdown(LOW_POWER_DURATION_MS);
}

//*******************************************************************************************
// Mesure de la température, de la pression et de l'humidité
//*******************************************************************************************
void measure(void) {

  // Lance une lecture du capteur, il se remet en veille après
  bme.oneMeasurement();

  // Polling en attendant que la lecture soit terminée
  while (bme.isMeasuring()) {};

  // Réalisation des mesures avec le capteur
  temp = bme.readTemperature() + TEMP_OFFSET;
  pres = bme.readPressure() * 0.01;
  humi = bme.readHumidity();

  // Affichage des mesures
  // Attention, pour que cela fonctionne correctement, activer
  // "Newlib Nano + Float printf" dans le menu "Outils/C Runtime Library".
  Debug_Serial.printf("  - Température : %.1f °C\r\n", temp);
  Debug_Serial.printf("  - Pression : %1.f hPa\r\n", pres);
  Debug_Serial.printf("  - Humidité relative : %.1f %%\r\n", humi);
}

//*******************************************************************************************
// Construction de la payload LoRaWAN
//*******************************************************************************************
void build_LoRaWAN_payload(void) {

  // On convertit les mesures de température, pression et humidité en entiers pour décodage 
  // ultérieur avec TagoIO.
  int16_t temp_ = round(10 * temp);
  int16_t pres_ = round(10 * pres);
  int16_t humi_ = round(2 * humi);

  // Construction de la payload LoRaWAN, on agrège les données au format hexadécimal.
  // Voir ce tutoriel :
  // https://www.carnetdumaker.net/articles/quelques-fonctions-bien-pratiques-du-framework-arduino/
  // pour quelques astuces sur les fonctions lowByte(x) et highByte(x) du framework Arduino qui 
  // permettent de simplifier le code ci-dessous.

  // Température, donnée codée sur 16 bits
  payloadUp[0] = (temp_ >> 8) & 0xFF;  // Extraction de l'octet de poids faible
  payloadUp[1] = temp_ & 0xFF;         // Extraction de l'octet de poids fort

  // Pression, donnée codée sur 16 bits
  payloadUp[2] = (pres_ >> 8) & 0xFF;  // Extraction de l'octet de poids faible
  payloadUp[3] = pres_ & 0xFF;         // Extraction de l'octet de poids fort

  // Humidité, donnée codée sur un seul octet
  payloadUp[4] = humi_;
}

//*******************************************************************************************
// Fonction de traitement d'un éventuel downlink
// Lorsque vous avez reçu "sizePayloadDown" octets dans le tableau "payloadDown" ...
//*******************************************************************************************
void processDownlink() {
  Debug_Serial.println("Données reçues du serveur TTN :" );
  for(uint8_t i = 0; i < sizePayloadDown; i++) {
    Debug_Serial.print(payloadDown[i], HEX);
    Debug_Serial.print("\r\n");
  }
}

/***********************************************************************/
/* Please see README page on https://github.com/SylvainMontagny/LoRaE5 */
/***********************************************************************/

#define REGION EU868
#define ACTIVATION_MODE OTAA
#define CLASS CLASS_A
#define SPREADING_FACTOR 7
#define ADAPTIVE_DR false
#define CONFIRMED false
#define PORT_UP 15

#define SEND_BY_PUSH_BUTTON false
#define FRAME_DELAY 20000

String devEUI = "2C F7 F1 20 44 10 BA 4A";

// Configuration for ABP Activation Mode
String devAddr = "00000000";
String nwkSKey = "00000000000000000000000000000000";
String appSKey = "00000000000000000000000000000000";

// Configuration for OTAA Activation Mode
String appKey = "55 10 67 98 B2 15 EE 4E D0 33 19 DC 65 27 88 AB"; 
String appEUI = "00 00 00 00 00 00 00 00";

// Alias pour l'UART du ST-Link (UART2)
#define Debug_Serial Serial

// Broches pour l'UART attribué au module LoRa-E5 (UART4)
 #define RX_PIN_LORA PA1  // Broche A1 Arduino, brancher dessus la ligne TX du module LoRA-E5
 #define TX_PIN_LORA PA0  // Broche A0 Arduino, brancher dessus la ligne RX du module LoRA-E5

// Initialisation de l'UART pour le module LoRa-E5
  HardwareSerial LoRa_Serial(RX_PIN_LORA, TX_PIN_LORA);