Voici quelques suggestions de code source additionnelles que Seb (MrSebkilou sur Youtube) m'a gentiment fournies.



Les exemples fournis ne montrent pas les choix de paramètres de communication. Ci-dessous quelques exemples (partiels) de mon code :

void InitLoRa() //initialisation LoRa (SPI, PINS, configuration de la communication)
{
   SPI.begin(SCK,MISO,MOSI,SS);
   LoRa.setPins(SS,RST,DI0);
   LoRa.begin(BAND); //868000000
   LoRa.setSpreadingFactor(9); //entre 7 et 12 (7 plus rapide, mais distance plus courte)
   LoRa.setCodingRate4(8); //entre 5 et 8 (8 plus lent mais plus de sécurité)
   LoRa.enableCrc(); //activer le contrôle CRC pour une communication garantie sans erreur
   LoRa.onReceive(&cbk); //la réception se fera sur la routine void cbk(int packetSize)
   LoRa.receive(); //lance l'écoute
}

Routine de réception (simplifiée, mais dans ma routine originale, je vérifie que le packetsize correspond bien à la taille désirée, et contenant un nombre magique pour savoir si c’est bien une communication venant de mon émetteur) :

void cbk(int packetSize) //Réception LoRa instauré par LoRa.onReceive(cbk) //met trame dans structure tlkkup et vérifie si trame valide (magic, CRC)
{
//gérer que packetsize est bien la taille désirée
 LoRa.readBytes((uint8_t *)&lorac,packetSize);
//vérifier si nombre magique dans ma structure lorac correspond bien avant de valider la réception
}

Routine de réception originale:

void cbk(int packetSize) //Réception LoRa //initialisé par LoRa.onReceive(cbk) //met trame dans structure tlkkup (structure personnelle) et imprime
{
   int i;
   char *byte;
   TrameValide=false;
   if((packetSize==sizeof(tlkkup)) //si le nombre d’octets reçus par le contrôleur LoRa correspond à la taille de ma structure
   {
      LoRa.readBytes((uint8_t *)&tlkkup,packetSize); //lire les données LoRa dans structure
     //vérifier que le code magic et le crc est exact (chez moi, c’est en fait un checksum, plus simple et rapide)
      if((tlkkup.crc!=CRCSum((uint8_t *)&tlkkup,(sizeof(tlkkup))-2))) || tlkkup.Magic[0] !=0xXX  || tlkkup.Magic[1] !=0xYY || tlkkup.Magic[2] !=0xZZ || tlkkup.Magic[3] !=0xWW)
      {
         Serial.println("Cette trame LoRa ne m’est soit pas destinée car pas le bon code magique, ou rencontre une erreur crc");
      }
      else
      {
         TrameValide=true; //pour signaler plus loin dans le code que la trame est valide et peut être traitée
         Serial.print("LoRa: ");
         byte=(char *)&tlkkup;
         for(i=0;i<packetSize;i++) Serial.printf("%0.2x ",*byte++);
         Serial.println();
         Serial.flush(); //vider tampon uart
      }
   }
else //la taille du paquet de données LoRa ne correpond pas à la taille de ma structure
{
   for(i=0;i<packetSize;i++) LoRa.read(); //vider le buffer LoRa sans mémoriser les valeurs
   Serial.println("Mauvaise taille de trame LoRa");
}
lu=true;
}


Pour procéder à un envoi de données :
LoRa.beginPacket();
LoRa.write((uint8_t*)&chaine,sizeof(chaine));
LoRa.endPacket();


La structure ressemble à ceci :

typedef struct trame_LoRa_WKEUP //définition structure de message à recevoir
{
   char Magic[4]; //4 octets qui seront initialisés à une valeur magique : lors de la réception, si le nombre magique est différent, la trame reçue ne sera pas traitée car venant d’un autre émetteur
  //etc, données
   uint16_t crc; //je rajoute un contrôle supplémentaire des données (checksum)
} __attribute__ ((packed)) trame_LoRa_WKEUP; //__attribute__ ((packed)) : pour que la structure ne force pas les variables sur des adresses doubles ou quadruples
trame_LoRa_WKEUP tlkkup;


//routine vérification (ou création) checksum
uint16_t CRCSum(uint8_t *buffer,short len) //Calcul du checksum
{
   short i;
   uint16_t sum=0;
   for(i=0;i<len;i++) sum+=(uint16_t)buffer[i];
   sum+=38; //juste pour qu’un petit malin ne casse pas mon code… (en fait c’est un autre code chez moi, un peu plus complexe)  
   return(sum);
}

 
Quelques lignes de code qui permettent de rentrer en mode light-sleep, et de sortir du mode veille quand une réception LoRa est en cours : 

void loop()
{
    Serial.println("loop");
    Serial.flush();
    if(lu) //lu est mis à true dans le setup, ou en fin de routine de réception
    {
     esp_sleep_enable_ext0_wakeup(GPIO_NUM_26,1);
     esp_light_sleep_start();
     lu=false; //pour ne pas rentrer en mode light-sleep tant que les données LoRa n’ont pas été lues
    }
    delay(1000);
}
 


