Système qui plante et WDT

Bonjour, c'est la première fois que j'utilise des cartes Arduino et avec je réalise un projet d'envoi de données (température) par onde radio. Mon système est composé d'un récepteur, de 2 émetteurs et d'un relais (pour réduire la distance récepteur-émetteur). Le matériel utilisé est des cartes nano pour les émetteurs et le relais, une carte UNO pour le récepteur. Les modules LoRa pour la communication radio sont des Ra-02. J'utilise un amplificateur sur le récepteur.

L'algo est le suivant :

  1. Le récepteur envoie une demande. (une demande toutes les heures)
  2. Le relais la reçoit et la renvoie.
  3. L'émetteur reçoit la demande et renvoie sa température aux relais.
  4. Le relais renvoie la température au récepteur
  5. Le récepteur affiche la température sous la forme d'un graphique sur un écran OLED

J'ai essayé mon système pendant une après-midi, ca a bien fonctionné jusqu'au moment où le relais plante. J'ai trouvé la fonction WDT qui pourrait résoudre mon problème mais je ne sais pas si je l'utilise correctement.

Dans mon premier programme, j'utilise la fonction millis pour effectuer un reset toutes les 30 minutes, mais je ne sais pas si la fonction millis continue à fonctionner lorsque l'arduino plante (j'imagine que non). Lors de mes essais, j'envoyai des demandes toute les 2 minutes afin d'aller plus vite. Et j'ai remarqué que lorsque le perd la communication avec le relais, il m'arrive de la retrouver après un certain temps (comme si le WDT fonctionnait correctement). Et d'autre fois je vois (sur un écran LCD sur le relais) que le relais reçoit les demandes du récepteur et renvoie les températures mais le récepteur ne reçoit rien.

Dans mon second programme j'utilise une autre méthode avec le WDT, sans utiliser la fonction millis, mais je ne suis pas sûr qu'il soit correct. (J'ai essayé très peu de temps mais, il semble ne pas fonctionne)

1er programme :


#include <Wire.h>  
#include <LoRa.h>
#include <LiquidCrystal_I2C.h>
#include <avr/wdt.h>

LiquidCrystal_I2C lcd(0x27, 20, 4);


unsigned long lcdUpdateInterval = 2000;  // intervalle de 10 secondes pour la mise à jour de l'écran LCD
unsigned long previousLCDUpdate = 0; // variable pour stocker le dernier temps de mise à jour de l'écran LCD




int sv=0;
int rssiValue = 0; 


void setup() {
  Serial.begin(9600);
  lcd.init();
  lcd.backlight();  

  lcd.setCursor(0, 0);
  lcd.print("init en court ...");
  

  
  if (!LoRa.begin(433E6))
  {
    Serial.println("Initialisation LoRa échouée.");
    while (1);
  }

  LoRa.setTxPower(20);

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("init OK");
  delay(1000);
}

void loop() {

unsigned long currentMillis = millis(); 



if (LoRa.parsePacket()) {
 
    String receivedData = LoRa.readString(); 
    


if (receivedData.startsWith ("PE")) {
    Serial.println("Recu :" + receivedData);
    
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Recu : " );
    lcd.print(receivedData);
    delay(1000);
  
   
    LoRa.beginPacket();
    delay(300);
    LoRa.print("R" + receivedData );
    delay(300);
    LoRa.endPacket();
    
    Serial.println("Envoyé : R" + receivedData);

    lcd.clear();
    lcd.setCursor(0, 1);
    lcd.print("Env: R" + receivedData);
    //lcd.print(receivedData);
    delay(300);
   }


}


  // Signe de vie
 if (currentMillis - previousLCDUpdate >= lcdUpdateInterval)
  {
    previousLCDUpdate = currentMillis; 
    
if (sv==1) {
  sv=0;
}
else {sv=1;
} 

  lcd.setCursor(0, 2);
  lcd.print("                   ");
  lcd.print(sv);
  
 }


if (millis() > 1800000) reboot(); 

}


void reboot() {
  wdt_enable(WDTO_15MS); // activer le watchdog
  while (1) {};          // et attendre ...
 }
 

2ème programme :


#include <Wire.h>  
#include <LoRa.h>
#include <LiquidCrystal_I2C.h>
#include <avr/wdt.h>

LiquidCrystal_I2C lcd(0x27, 20, 4);


unsigned long lcdUpdateInterval = 2000;  // intervalle de 10 secondes pour la mise à jour de l'écran LCD
unsigned long previousLCDUpdate = 0; // variable pour stocker le dernier temps de mise à jour de l'écran LCD




int sv=0;
int rssiValue = 0; 



void setup() {
  
  Serial.begin(9600);
  lcd.init();
  lcd.backlight();  

  lcd.setCursor(0, 0);
  lcd.print("init en court ...");
  

  
  if (!LoRa.begin(433E6))
  {
    Serial.println("Initialisation LoRa échouée.");
    while (1);
  }

  LoRa.setTxPower(20);

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("init OK");
  delay(1000);
  
  wdt_enable(WDTO_8S);
 
}

void loop() 
{
wdt_reset();
lcd.clear();
unsigned long currentMillis = millis(); 






  

if (LoRa.parsePacket()) {
 wdt_reset();
    String receivedData = LoRa.readString(); 
    


if (receivedData.startsWith ("PE")) {
    Serial.println("Recu :" + receivedData);
    
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Recu : " );
    lcd.print(receivedData);
    
    delay(1000);
  
   
    LoRa.beginPacket();
    delay(300);
    LoRa.print("R" + receivedData );
    delay(300);
    LoRa.endPacket();
 
    Serial.println("Envoyé : R" + receivedData);

    lcd.clear();
    lcd.setCursor(0, 1);
    lcd.print("Env: R" + receivedData);
    delay(300);
    
   }


}

 
  
//Signe de vie 
  
 if (currentMillis - previousLCDUpdate >= lcdUpdateInterval)
  {
    
    previousLCDUpdate = currentMillis; // sauvegarder le temps actuel
    
if (sv==1) {
  sv=0;
  
}
else {sv=1;
} 

  lcd.setCursor(0, 2);
  lcd.print("                   ");
  lcd.print(sv);
 
 }
 
}

J'aimerais votre avis sur mes programmes et si vous avez des pistes pour résoudre mon problème de communication (relais qui plante).

Merci

ma recommandation serait de ne pas faire de reset du tout et d'essayer de comprendre pourquoi c'est nécessaire

Tu penses que ça viendrais plutôt d'un problème matériel ou plus programmation ? Je peux envoyer mes programmes émetteurs et récepteur si tu souhaites.

J'avoue que je débute pas mal avec l'utilisation d'arduino et pareil pour la communication radio, je ne sais plus sur quoi me pencher pour résoudre mon problème

Je ne sais pas d'où ça vient mais dans l'absolu on évite de rebooter pour le plaisir de planquer un bug sous le tapis :slight_smile:

Les détails du code et des circuits pourraient être utilies, oui.

Schéma de câblage récepteur :

Programme récepteur :

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <LoRa.h> 


#define SCREEN_WIDTH 128 
#define SCREEN_HEIGHT 64 


Adafruit_SSD1306 display2(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
Adafruit_SSD1306 display1(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);


const int buttonPE1 = 7; // BP PE1
const int buttonPE2 = 4; // BP PE2


int tempLabels1[] = {2,4,6,8};
int tempLabels2[] = {2,4,6,8};

int mesures1[72]; // les 32 dernieres mesures
int mesures2[72]; // les 32 dernieres mesures

int compteur1 = 0; // nombre de mesures prises jusqu'à présent
int compteur2 = 0; // nombre de mesures prises jusqu'à présent


unsigned long previousAutoSendPE1 = 0;
unsigned long previousPacketTime1 = 0;
const long autoSendIntervalPE1 = 43000;
const long retryInterval1 = 20000;
bool packetReceived1 = false;


unsigned long previousAutoSendPE2 = 0;
unsigned long previousPacketTime2 = 0;
const long autoSendIntervalPE2 = 107000;
const long retryInterval2 = 20000;
bool packetReceived2 = false;


unsigned long systemStartTime;


float temp_float1;
float temp_float2;


void setup() {
  
  Serial.begin(9600);
  pinMode(buttonPE2, INPUT_PULLUP);
  pinMode(buttonPE1, INPUT_PULLUP);
  
  if (!LoRa.begin(433E6)) {
    Serial.println("Initialisation LoRa échouée.");
    while (1);
  }

  LoRa.setTxPower(20);

 delay (300);
 Affichage ();


}

void loop() {


unsigned long currentMillis = millis();



//Si le LORA recoit un packet
   if (LoRa.parsePacket()) {
    
  
    String receivedData = LoRa.readString();  
    Serial.println("Recu :");  
    Serial.print(receivedData);


//DEBUT GESTION GRAPHIQUE COMBE************************************************** 
   if (receivedData.startsWith("RPE1:")) {
     
    
      tcaselect(0); 

      String temp_extrait2 = receivedData.substring(6,11);
      temp_float2 = temp_extrait2.toFloat();

      packetReceived1 = true;
      previousPacketTime1 = currentMillis;
      
      Serial.println(temp_extrait2);
      Serial.println("Conversion en float " + temp_extrait2);

      display2.fillRect(75, 0, 25, 10, BLACK);
      display2.setTextSize(0);
      display2.setTextColor(WHITE);
      display2.setCursor(75,0);
      display2.println(temp_float2);
      display2.display(); 

      int nouvelleValeur2 = map(temp_float2 * 100, 800, 0, 16, 70);

  if (compteur2 > 71) {
      // l'écran est déjà rempli: on fait glisser le graphique vers la gauche
      for (int i = 0; i < 71; i++) {
      mesures2[i] = mesures2[i + 1];
    }

      mesures2[71] = nouvelleValeur2;
      
      display2.clearDisplay();
  

     //tracé de la courbe
      for (int i = 1; i <= 71; i++) {
      display2.drawLine(5.5+1.75 * (i - 1), mesures2[i - 1], 5.5+1.75 * i, mesures2[i], WHITE);

    }

  
      display2.setTextSize(0);
      display2.setTextColor(WHITE);
      display2.setCursor(32,0);
      display2.println("COMBE:");
      display2.display(); 


      //Réaffichez les graduations le long de l'axe Y
      for (int i = 0; i < 4; i++) {
      int y = map(tempLabels2[i], 8, 0, 16, 70);
      display2.setTextSize(1);
      display2.setTextColor(WHITE);
      display2.setCursor(0, y);
      display2.print(tempLabels2[i]);
      display2.display(); 
    }

      Trait3();
      Trait4();

      display2.setTextSize(0);
      display2.setTextColor(WHITE);
      display2.setCursor(75,0);
      display2.println(temp_float2);
      display2.display(); 



   }


 if ((compteur2 > 0) && (compteur2 <= 71)) {
    // pas assez de mesures pour remplir tout l'écran: on ajoute notre nouvelle valeur
    // au graphique déjà visible à l'écran
    
      mesures2[compteur2] = nouvelleValeur2;

    // on trace une droite reliant la mesure précédente à notre nouvelle mesure
      display2.drawLine(5.5+1.75 * (compteur2 - 1), mesures2[compteur2 - 1],5.5+1.75 * compteur2, mesures2[compteur2], WHITE); 
  

 
      compteur2 = compteur2 + 1;
  }
   else if (compteur2 == 0) {
    // c'est la première mesure: on la met en variable,
    // mais on ne trace rien à l'écran, sauf le quadrillage
        mesures2[0] = nouvelleValeur2;
        compteur2 = compteur2 + 1;


   
  
    }
    
   }


//FIN GESTION GRAPHIQUE COMBE**************************************************  








//DEBUT GESTION GRAPHIQUE GU SUD ************************************************** 
   if (receivedData.startsWith("RPE2:")) {

     
    
    tcaselect(1);
   

     String temp_extrait1 = receivedData.substring(6,11);
     temp_float1 = temp_extrait1.toFloat();

     packetReceived2 = true;
     previousPacketTime2 = currentMillis;
      
     Serial.println(temp_extrait1);
     Serial.println("Conversion en float " + temp_extrait1);
     Serial.println(" ");

     display1.fillRect(75, 0, 25, 10, BLACK);
     display1.setTextSize(0);
     display1.setTextColor(WHITE);
     display1.setCursor(75,0);
     display1.println(temp_float1);
     display1.display(); 





    int nouvelleValeur1 = map(temp_float1 * 100, 800, 0, 16, 70);

  if (compteur1 > 71) {
    // l'écran est déjà rempli: on fait glisser le graphique vers la gauche
     for (int i = 0; i < 71; i++) {
      mesures1[i] = mesures1[i + 1];
   }

    mesures1[71] = nouvelleValeur1;


    
    display1.clearDisplay();
  

//tracé de la courbe
     for (int i = 1; i <= 71; i++) {
      display1.drawLine(5.5+1.75 * (i - 1), mesures1[i - 1], 5.5+1.75 * i, mesures1[i], WHITE);

 }

   
      display1.setTextSize(0);
      display1.setTextColor(WHITE);
      display1.setCursor(32,0);
      display1.println("GU SUD:");
      display1.display(); 


  // Réaffichez les graduations le long de l'axe Y
    for (int i = 0; i < 4; i++) {
      int y = map(tempLabels1[i], 8, 0, 16, 70);
      display1.setTextSize(1);
      display1.setTextColor(WHITE);
      display1.setCursor(0, y);
      display1.print(tempLabels1[i]);
      display1.display(); 
      }

    Trait1();
    Trait2();

    display1.setTextSize(0);
    display1.setTextColor(WHITE);
    display1.setCursor(75,0);
    display1.println(temp_float1);
    display1.display(); 



   }


 if ((compteur1 > 0) && (compteur1 <= 71)) {
    // pas assez de mesures pour remplir tout l'écran: on ajoute notre nouvelle valeur
    // au graphique déjà visible à l'écran
    
    mesures1[compteur1] = nouvelleValeur1;

    // on trace une droite reliant la mesure précédente à notre nouvelle mesure
    display1.drawLine(5.5+1.75 * (compteur1 - 1), mesures1[compteur1 - 1],5.5+1.75 * compteur1, mesures1[compteur1], WHITE);   

 
    compteur1 = compteur1 + 1;
  }
  else if (compteur1 == 0) {
    // c'est la première mesure: on la met en variable,
    // mais on ne trace rien à l'écran, sauf le quadrillage
    mesures1[0] = nouvelleValeur1;
    compteur1 = compteur1 + 1;


   
  
    }
    
   }

//DEBUT GESTION GRAPHIQUE GU SUD ************************************************** 

}






//Envoie de PETOP1 avec le BP en pin 7
 if (digitalRead(buttonPE1) == LOW) { 
      PE1();

  }





//Envoie de PETOP2 avec le BP en pin 7
 if (digitalRead(buttonPE2) == LOW) { 
     PE2();

  }





  // Envoi automatique PE1
if (currentMillis - previousAutoSendPE1 >= autoSendIntervalPE1) {
   
     PE1();
     previousAutoSendPE1 = currentMillis; // Met à jour le dernier temps d'envoi automatique
}

// Relancer la demande PETOP2 si aucun paquet n'est reçu après 20 secondes
  if (!packetReceived1 && (currentMillis - previousPacketTime1 >= retryInterval1)&& (millis() - systemStartTime >= 43000)) {
      PE1();
      previousPacketTime1 = currentMillis;
  }


  
//    Envoi automatique PE2
if (currentMillis - previousAutoSendPE2 >= autoSendIntervalPE2) {
      Serial.println(" ");
      PE2();  
      previousAutoSendPE2 = currentMillis; // Met à jour le dernier temps d'envoi automatique
}


// Relancer la demande PETOP2 si aucun paquet n'est reçu après 20 secondes
  if (!packetReceived2 && (currentMillis - previousPacketTime2 >= retryInterval2)&& (millis() - systemStartTime >= 107000)) {
      PE2();
      previousPacketTime2 = currentMillis;
  }

    LoRa.begin(433E6);
}







void PE1() {

 //delay(200);
  LoRa.beginPacket();
  LoRa.print("PETOP1");
  LoRa.endPacket();
  delay(100);

  Serial.println("PETOP1 envoyé !");

  
 }

void PE2() {

 //delay(200);
  LoRa.beginPacket();
  LoRa.print("PETOP2");
  LoRa.endPacket();
  delay(100); 

  Serial.println("PETOP2 envoyé !");

  
 }



void Trait1 () {

  // Définir les coordonnées de début et de fin du trait
int x1 = 10;
int y1 = 15;
int x2 = 128;
int y2 = 15;

// Dessiner le trait pointillé
for (int i = x1; i <= x2; i += 5) {
    if ((i / 5) % 2 == 0) { // Alterner les segments de ligne pour créer l'effet pointillé
        display1.drawLine(i, y1, min(i + 5, x2), y2, WHITE);
    }
  }
}


void Trait2 () {

  // Définir les coordonnées de début et de fin du trait
int x1 = 10;
int y1 = 58;
int x2 = 128;
int y2 = 58;

// Dessiner le trait pointillé
for (int i = x1; i <= x2; i += 5) {
    if ((i / 5) % 2 == 0) { // Alterner les segments de ligne pour créer l'effet pointillé
        display1.drawLine(i, y1, min(i + 5, x2), y2, WHITE);
    }
  }
}


void Trait3 () {

  // Définir les coordonnées de début et de fin du trait
int x1 = 10;
int y1 = 15;
int x2 = 128;
int y2 = 15;

// Dessiner le trait pointillé
for (int i = x1; i <= x2; i += 5) {
    if ((i / 5) % 2 == 0) { // Alterner les segments de ligne pour créer l'effet pointillé
        display2.drawLine(i, y1, min(i + 5, x2), y2, WHITE);
    }
  }
}


void Trait4 () {

  // Définir les coordonnées de début et de fin du trait
int x1 = 10;
int y1 = 58;
int x2 = 128;
int y2 = 58;

// Dessiner le trait pointillé
for (int i = x1; i <= x2; i += 5) {
    if ((i / 5) % 2 == 0) { // Alterner les segments de ligne pour créer l'effet pointillé
        display2.drawLine(i, y1, min(i + 5, x2), y2, WHITE);
    }
  }
}


//Changement de chanel

void tcaselect(uint8_t i) {
  if (i > 7) return;
  
  Wire.beginTransmission(0x70);
  Wire.write(1 << i);
  Wire.endTransmission();

  Serial.println(i);
  
   
} 

void Affichage () {
  tcaselect(0); 
  display2.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  display2.clearDisplay();

  Trait3();
  Trait4();

  display2.setTextSize(0);
  display2.setTextColor(WHITE);
  display2.setCursor(32,0);
  display2.println("COMBE:");
  display2.display(); 

   // GRADUATION GU SUD
    for (int i = 0; i < 4; i++) {
      int y = map(tempLabels1[i], 8, 0, 16, 70);
      display2.setTextSize(1);
      display2.setTextColor(WHITE);
      display2.setCursor(0, y);
      display2.print(tempLabels1[i]);
      display2.display(); 
      }

  
delay(500);


 
  tcaselect(1); 
  display1.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  display1.clearDisplay();
  
  Trait1();
  Trait2();

  display1.setTextSize(0);
  display1.setTextColor(WHITE);
  display1.setCursor(32,0);
  display1.println("GU SUD:");
  display1.display(); 


  // GRADUATION COMBE
    for (int i = 0; i < 4; i++) {
      int y = map(tempLabels2[i], 8, 0, 16, 70);
      display1.setTextSize(1);
      display1.setTextColor(WHITE);
      display1.setCursor(0, y);
      display1.print(tempLabels2[i]);
      display1.display(); 
      }
  
}

Schéma de câblage émetteurs :

Programme émetteurs : (Seul l'emitterID diffère entre mes programmes émetteurs)

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <LoRa.h>
#include <avr/wdt.h>


#define ONE_WIRE_BUS 15

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
LiquidCrystal_I2C lcd(0x27, 16, 2);

const String emitterID = "PE1:";
byte degreeSymbol[8] = {0b00110, 0b01001, 0b01001, 0b00110, 0b00000, 0b00000, 0b00000, 0b00000};

unsigned long timer;

unsigned long previousMillis = 0; // variable pour stocker le dernier temps d'émission
const long interval = 1800000;      // intervalle de 15 minutes en millisecondes
unsigned long lcdUpdateInterval = 2000;  // intervalle de 10 secondes pour la mise à jour de l'écran LCD
unsigned long previousLCDUpdate = 0; // variable pour stocker le dernier temps de mise à jour de l'écran LCD
int nb=00;
int sv=0;
void setup()
{
  Serial.begin(9600);
  lcd.init();
  lcd.backlight();
  lcd.createChar(0, degreeSymbol);
  sensors.begin();

  if (!LoRa.begin(433E6))
  {
    Serial.println("Initialisation LoRa échouée.");
    lcd.setCursor(0, 0);
    lcd.print("Echec LoRa");
    while (1);
  }
  
  LoRa.setTxPower(20);
  
    lcd.setCursor(0, 0);
    lcd.print("INIT OK");
    delay(500);
    lcd.clear();
 
}

void loop()
{
  unsigned long currentMillis = millis(); // obtenir le temps actuel

    // Vérifier si une demande de température a été reçue
  if (LoRa.parsePacket()){
  String receivedData = LoRa.readString();

  Serial.println("Message recu: " + receivedData);

// Si recoit "PETOP1", envoi de la temperature en reponse
    if (receivedData.equals("RPETOP1")){

      Serial.println("Demande RPETOP1 recu, envoie de la température");
      
      delay(500);
      sensors.requestTemperatures();
      float temp = sensors.getTempCByIndex(0);
      
      // Envoyer la température en réponse à la demande
      nb++;
      LoRa.beginPacket();
      delay(100);
      LoRa.print(emitterID + " ");
      delay(100);
      LoRa.print(temp);
      delay(100);
      LoRa.print(" ");
      delay(100);
      LoRa.print(nb);
      delay(100);
      LoRa.endPacket();
      delay(100);

      
       
Serial.println("temp envoyé");

      LoRa.begin(433E6);
    delay(500);
    }
    
  }

  // Vérifier si 10 secondes se sont écoulées depuis la dernière mise à jour de l'écran LCD
  if (currentMillis - previousLCDUpdate >= lcdUpdateInterval)
  {
    previousLCDUpdate = currentMillis; // sauvegarder le temps actuel
if (sv==1) {
  sv=0;
}
else {
  sv=1;
}

    sensors.requestTemperatures();
    float temp = sensors.getTempCByIndex(0);

    lcd.setCursor(0, 0);
    lcd.print("Emetteur 1");

    lcd.setCursor(0, 1);
    lcd.print("Temp: ");
    lcd.print(temp);
    lcd.write(byte(0));
    lcd.print("C");
    lcd.print("  ");
    lcd.print(sv);
  

//    Serial.println("Écran LCD mis à jour avec la nouvelle température !");
  }

if (millis() > 1800000) reboot(); 
  
}


void reboot() {
  wdt_enable(WDTO_15MS); // activer le watchdog
  while (1) {};          // et attendre ...
 }

Vous avez l'ensemble de mon projet en espérant que cela vous permette de déceler le problème que je rencontre (le programme de mon relais est dans mon premier message)

Merci

Bonjour @davidrogerard

Pour info, peut être sans rapport avec le problème signalé.

Il me semble que les signaux MOSI, NSS, SCK et RST sortant d'une carte UNO R4 Mini ont un niveau haut de 5V, idem pour la cartes Nano Every (les 2 cartes apparaissent dans tes schémas)

Les envoyer directement sur un module RA-02 est risqué pour ce dernier (l'alimenter en 3,3V ne suffit pas)
Son fabricant donne 3,6V comme valeur limite pour les signaux entrants et dégage sa responsabilité au delà (mauvais fonctionnement ou destruction peuvent survenir)

Je n'utilise ce genre de module LORA sur bus SPI (RFM95W, SX127x, RA-0x.....) qu'avec des cartes fonctionnant sous 3,3V (Pro MIni 3V3 8MHZ, ESP32....). SI je devais relier un tel module SPI LoRa à une carte dont les signaux sortants sont à 5V j'insérerai des adaptateurs de niveaux logiques sur les 4 signaux mentionnés pour rester en conformité avec les spécifications des composants et mettre toutes les chances de mon côté
image

+1 sur l'adaptation de tension.


sinon c'est pas un bug mais une Remarque, les délais dans le code ci dessous

sont inutiles il me semble car le packet n'est envoyé que lorsque vous faites LoRa.endPacket();. Entre temps vous ne faites qu'accumuler le payload dans un tampon (255 octets max)

Merci pour vos retours, j'ai réalisé la modification du programme au niveau des délais lors de la transmission LoRa. Quant à ma tension sur mon module RA-02 je vais m'y pencher.

Cependant, je reviens à une question de mon premier poste. La fonction millis continue-t-elle de fonctionner lorsque le système plante. Ce que j'entends par plantage, c'est que le système se bloque, mon signe de vie (alternance entre 0 et 1 affiché sur l'écran lcd) ne bouge plus, et je ne reçois plus aucune transmission.

C'est pour savoir si mon utilisation du WDT est correcte

si l'arduino est vraiment planté, plus rien ne tourne. Le timer qui compte les micro-secondes peut éventuellement continuer à compter mais si le code est planté, votre appele à millis() ne se produira jamais

la question est de savoir ce qui se produit réellement. Il se peut que le code soit bloqué dans une boucle ou attente sans fin quelque part. Dans ce cadre là le watchdog peut réparer la situation en forçant un reboot.

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.