Routine MKR FOX 1200

vince3011 · June 30, 2023, 3:10am

Bonjour tout le monde,
Je réalise une ruche connectée avec un MKRFOX 1200 et un écran LCD.
Mon programme fonctionne lorsque je suis connecté sur mon PC et envoie les données sur sigfox. Tout vas bien.
Dès que je l'alimente en externe, le programme s’exécute une seule fois.
Je ne comprends pas! Si vous pouvez m'aider SVP

#include <LiquidCrystal_I2C.h>
#include <Wire.h>
#include <SigFox.h>
#include <HX711.h>
#include <ArduinoLowPower.h>
#include <Adafruit_Sensor.h>
#include <DHT.h>
#include "data.h"

LiquidCrystal_I2C lcd(0x27,20,4); // définit le type d'écran lcd 20 x 4

// DHT Capteur Température/Hydrometrie
#define DHTPIN 2
#define DHTTYPE DHT22
//#define DHTTYPE DHT11 Suivant le capteur utilise

DHT dht(DHTPIN, DHTTYPE);

// HX711 Balance
const int DOUT = 3; //#define DOUT 3
const int CLK = 4;  //#define CLK 2
HX711 scale;        //HX711 scale(DOUT, CLK);

// analog button
const int analog_in_pin = 0;
int sensorvalue= 0; //Valeur analogique
int statebutton = 0;

// Déclaration variable
float poids;

// Structure message d'envoie
typedef struct __attribute__ ((packed)) sigfox_message {
int16_t moduleTemperatureSig;
uint16_t poid;
int8_t temp;
uint8_t hum;
} SigfoxMessage;
SigfoxMessage msg;

void setup() {
   //Serial.begin(115200);
   SigFox.begin();
   dht.begin();
   scale.begin(DOUT, CLK);
   pinMode(A0, INPUT);

   //Affichage/accueil LCD
   lcd.init(); // initialisation de l'afficheur
   lcd.backlight();
   lcd.setCursor(0,0);
   lcd.print("**** " RUCHE " ****");
   lcd.setCursor(4,1);
   lcd.print("Le Rucher du");
   lcd.setCursor(5,2);
   lcd.print("Brise Vent");
  lcd.setCursor(0,3);
   lcd.print("By Antoine L.");
   lcd.createChar(0,humidity);          // create a new character
   lcd.createChar(1,temp);              // create a new character
   lcd.createChar(2,degres_celsius);    // create a new character
   lcd.createChar(3,humidity_1);        // create a new character
   lcd.createChar(4,masse);             // create a new character

    version();                          //Call fonction
    connexion();                        //Call fonction
  
  // Enable debug prints and LED indication
  //SigFox.debug();
  //SigFox.end();

  Serial.print("*******************************************");
  Serial.print(                 RUCHE                       );
  Serial.println("*****************************************");
  delay(10);

  long zero_factor = scale.read_average();
  Serial.print("Zero factor: ");
  Serial.println(zero_factor);

  scale.set_scale(CALIBRATION_FACTOR); //Calibration Factor obtained from first sketch
  scale.tare(TARE_OFFSET);
  
  lcd.clear();
  updateMenu();
   delay(1000);

}

void loop() 
{
      read_temperature_module();
      read_temperature_DHT();
      read_weight();
      send_message();
      read_switch();

      if(routine==true)
        {
        action1();
        }
}

/*********************************************
lecture des appareils connectes
*********************************************/
void connexion()
{
  if (!SigFox.begin()) 
  {
    Serial.println("Shield error or not present!");
    return;
  }
          else 
            {
              Serial.println("Shield present!");
            }
  if (scale.is_ready()) 
  {
    long reading = scale.read();
    Serial.print("HX711 reading: ");
    Serial.println(reading);
  } 
        else 
          {
            Serial.println("HX711 not found.");
          }
}

/*********************************************
Récupération des identifiants du module
*********************************************/
void version()                    
{
  String versionSig = SigFox.SigVersion();
  String ID = SigFox.ID();
  String PAC = SigFox.PAC();
  Serial.println("**************** Version ******************");
  Serial.println("ID  = " + ID);
  Serial.println("PAC = " + PAC);
  Serial.println("Version" + versionSig);
  Serial.println("*******************************************");
}

/*********************************************
Lecture de température interne du module arduino MKRFOX
*********************************************/
void read_temperature_module() 
{
  static unsigned long previousMillisread_temperature_module = 0;
  unsigned long currentMillis = millis();

     if(currentMillis - previousMillisread_temperature_module >= BLINK_INTERVAL_1) 
   {
     previousMillisread_temperature_module = currentMillis;
   msg.moduleTemperatureSig = (uint8_t) (SigFox.internalTemperature()); 
   Serial.print("Température module: ");
   Serial.print(msg.moduleTemperatureSig);
   Serial.println("°C");
   }
}

/*********************************************
Lecture du capteur hydrometrie
*********************************************/
void read_temperature_DHT()
{
  static unsigned long previousMillisread_temperature_DHT = 0;
  unsigned long currentMillis = millis();

if(currentMillis - previousMillisread_temperature_DHT >= BLINK_INTERVAL_2) 
   {
     previousMillisread_temperature_DHT = currentMillis;
  msg.temp = dht.readTemperature();        // Lecture de la température, exprimée en degrés Celsius
  msg.hum = dht.readHumidity();           // Lecture du taux d'humidité (en %)

         if (isnan(msg.hum) || isnan(msg.temp)|| msg.hum == 255 || msg.temp == 255) 
            {
             Serial.println("DHT22 not found.");
           }
         else
           {
        
        // Affichage des valeurs
        Serial.print("Humidité = "); Serial.print(msg.hum); Serial.println(" %");
        Serial.print("Température = "); Serial.print(msg.temp); Serial.println(" °C");
        Serial.println();
        }
   }
}

/*********************************************
Lecture du poids
*********************************************/
void read_weight()
{
  static unsigned long previousMillisread_weight = 0;
  unsigned long currentMillis = millis();

if(currentMillis - previousMillisread_weight >= BLINK_INTERVAL_3) 
   {
     previousMillisread_weight = currentMillis;
  poids = scale.get_units(5),1; 
  msg.poid = convertoFloatToInt16(poids, 0, 100);
  //Serial.print(scale.get_units(), 2);
  // Serial.print(" lbs"); //Change this to kg and re-adjust the calibration factor if you follow SI units like a sane person
  Serial.print("Lecture Pesée:"); Serial.print( poids); Serial.print(msg.poid);Serial.println(" Kg"); Serial.println();
  delay (100);
  //Serial.print(" calibration_factor: "); Serial.println(CALIBRATION_FACTOR); Serial.println();

   }
}

/*********************************************
Envoie du message a sigFox
*********************************************/
void send_message()
{
static unsigned long previousMillissend_message = 0;
//static unsigned long previousMillistime_out = 0;
unsigned long currentMillis = millis();
//unsigned long currentMillistime_out = millis();

if(currentMillis - previousMillissend_message >= BLINK_INTERVAL_4) 
   {
     previousMillissend_message = currentMillis;
    SigFox.begin();
    delay(100);

     // Clears all pending interrupts
    SigFox.status();
    delay(1);

    SigFox.beginPacket();
    Serial.println("Message in progress...");
    SigFox.write((uint8_t*)&msg, 12);
  
  int ret = 1;
    Serial.println(ret);
   
   

    if (SigFox.parsePacket()) {
    Serial.println("Response from server:");
    while (SigFox.available()) {
      //Serial.print("0x");
      Serial.println(SigFox.read(), HEX);
      //return SigFox.read();
    }
  } else {
 
    Serial.println("Could not get any response from the server");

  }
  

   }
}

/*********************************************
Lecture des boutons
*********************************************/
void read_switch()
{
  static unsigned long previousMillisread_switch = 0;
  unsigned long currentMillis = millis();

if(currentMillis - previousMillisread_switch >= BLINK_INTERVAL_5) 
   {
     previousMillisread_switch = currentMillis;
     sensorvalue = analogRead(analog_in_pin);
    //Serial.println (sensorvalue);         Valeur serial lecture analogique pour test
        if(sensorvalue >495 && sensorvalue <515)
        {
          statebutton = 1;            //Button ESC  505
        if (statebutton == 1)
          {
          button_esc = true;
          
             if (button_esc == true)
             {
            routine = false;
            button_esc = false;
            menu_items = 1;
            updateMenu();
              
             }
          }
            else 
            {
            button_esc = false; 
            }
          //delay(100);
    }
        if(sensorvalue >295 && sensorvalue <315)
        {
          statebutton = 2;            //Button ENTER 305
        if (statebutton == 2)
          {
          button_enter = true;

            if (button_enter == true)
            {
            executeAction();
            button_enter = false; 
            }
          }
            else 
            {
            button_enter = false; 
            }
    //delay(100);
    }

        if(sensorvalue >245 && sensorvalue <265)
        {
          statebutton = 3;            //Button LEFT 255
          //delay(100);
        }

        if(sensorvalue >370 && sensorvalue <390)
        {
          statebutton = 4;            //Button RIGHT 380
         // delay(100);
        }

        if(sensorvalue >210 && sensorvalue <230)
        {
          statebutton = 5;            //Button DOWN 220
        if (statebutton == 5)
        {
         button_down = true;
  
            if (button_down == true)
            {
              menu_items++;
              updateMenu();
              button_down = false; 
            }
        }
          else 
          {
          button_down = false; 
          }
    delay(100);
    }

        if(sensorvalue >750 && sensorvalue <770)
        {
          statebutton = 6;            //Button UP 760
        if (statebutton == 6)
        {
          button_up = true;
          if (button_up == true)
          {
            menu_items--;
            button_up = false;
            updateMenu();
          }
        }
          else 
          {
          button_up = false; 
          }

      delay(100);
      }
   }
}

/*********************************************
MaJ Menu
*********************************************/
void updateMenu() 
{
  switch (menu_items) {
    case 0:
      menu_items = 1;
      break;
    case 1:
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("***** MENU *****");
      lcd.setCursor(17, 0);
      lcd.print("1/4");
      lcd.setCursor(0, 1);
      lcd.print(">" ITEM1);
      lcd.setCursor(0, 2);
      lcd.print(" "ITEM2);
      lcd.setCursor(0, 3);
      lcd.print(" "ITEM3);
      break;
    case 2:
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("***** MENU *****");
      lcd.setCursor(17, 0);
      lcd.print("2/4");
      lcd.setCursor(0, 1);
      lcd.print(" "ITEM1);
      lcd.setCursor(0, 2);
      lcd.print(">"ITEM2);
      lcd.setCursor(0, 3);
      lcd.print(" "ITEM3);
      break;
    case 3:
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("***** MENU *****");
      lcd.setCursor(17, 0);
      lcd.print("3/4");
      lcd.setCursor(0, 1);
      lcd.print(" "ITEM1);
      lcd.setCursor(0, 2);
      lcd.print(" "ITEM2);
      lcd.setCursor(0, 3);
      lcd.print(">" ITEM3);
      break;
    case 4:
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("***** MENU *****");
      lcd.setCursor(17, 0);
      lcd.print("4/4");
      lcd.setCursor(0, 1);
      lcd.print(" "ITEM2);
      lcd.setCursor(0, 2);
      lcd.print(" "ITEM3);
      lcd.setCursor(0, 3);
      lcd.print(">" ITEM4);
      break;
    case 5:
      menu_items = 4;
      break;
  }
}

/*********************************************
Action menu 
*********************************************/
void executeAction() 
{
  switch (menu_items) 
  {
    case 1: 
      action1();    //Read data
      if (button_enter == true)
            {
      scale.tare(TARE_OFFSET);
            }
      break;
    case 2:
      action2();    //state equipment
      break;
    case 3:
      action3();    // reponse message 
      break;
    case 4:
      action4();    //Identification
      break;
  }
}

void action1()    //Read data
{
  routine=true;
  static unsigned long previousMillisrefresh_read = 0;
  unsigned long currentMillis = millis();
  
if(currentMillis - previousMillisrefresh_read >= BLINK_INTERVAL_6) 
   {
     previousMillisrefresh_read = currentMillis;

      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("***** LECTURE ******");
      lcd.setCursor(0,1);
      lcd.print(char(1)); // affiche le caractère temp
      lcd.setCursor(1,1);
      lcd.print("Int");
      lcd.setCursor(0,2);
      lcd.print(msg.moduleTemperatureSig );
      lcd.print(char(2)); // affiche le caractère °c

      lcd.setCursor(5,1);
      lcd.print(char(1)); // affiche le caractère temp
      lcd.setCursor(6,1);
      lcd.print("Ext");
      
      lcd.setCursor(10,1);
      lcd.print(char(0)); // affiche le caractère humdity
      lcd.print(char(3)); // affiche le caractère humdity

      lcd.setCursor(0,3);
      lcd.print("Enter for tare");
      
       if (isnan(msg.hum) || isnan(msg.temp)|| msg.hum == 255 || msg.temp == 255) 
          {
          lcd.setCursor(6,2);
          lcd.print("?");
          lcd.setCursor(10,2);
          lcd.print("?"); 
          }
         else
           {
           lcd.setCursor(6,2);
           lcd.print(msg.temp); 
           lcd.print(char(2)); // affiche le caractère °c
           lcd.setCursor(10,2);
           lcd.print(msg.hum); 
           lcd.print("%");       
           }
      
      lcd.setCursor(17,1);
      lcd.print(char(4)); // affiche le caractère humdity

      lcd.setCursor(14,2);
      lcd.print((float) poids);
      lcd.print("k");

      if (button_enter == true)
            {
      scale.tare(TARE_OFFSET);
            }
   } 
}

void action2()                 //State equipment
{                        
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("****** STATE *******");
      if (!SigFox.begin()) 
        {
        lcd.setCursor(0,1);
        lcd.print("Shield error");
        }         
        else 
          {
          lcd.setCursor(0,1);
          lcd.print("Shield present");
          }
      if (isnan(msg.hum) || isnan(msg.temp)|| msg.hum == 255 || msg.temp == 255) 
        {
        lcd.setCursor(0,2);
        lcd.print("DHT22 not found");
        }
         else
           {
           lcd.setCursor(0,2);
           lcd.print("DHT22 connected");
           }
      if (scale.is_ready()) 
        {
        lcd.setCursor(0,3);
        lcd.print("HX711 reading");
        } 
        else 
          {
          lcd.setCursor(0,3);
          lcd.print("HX711 not found");
          }
}

void action3()
{
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("***** MESSAGE ******");

      lcd.setCursor(0,2);
      lcd.print("Resp from server:");
      if (SigFox.parsePacket())
       {
        lcd.print("Ok");
        }
      else
        {
        lcd.print("NOk");
        }
}

void action4(){                         //Modele et version
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("***** VERSION *****");
      lcd.setCursor(0,1);
      lcd.print ("ID=");
      lcd.print (ID_SIG);
      lcd.setCursor(0,2);
      lcd.print ("PAC=");
      lcd.print (PAC_SIG);
      lcd.setCursor(0,3);
      lcd.print (VERSION_SIG);
}

J-M-L · June 30, 2023, 3:14am

Comment ?

vince3011 · June 30, 2023, 3:22am

Bonjour,

Via la prise USB et sur secteur 5V/1A

J-M-L · June 30, 2023, 3:24am

Vous avez essayé avec un code de démo .de base" et ce type d’alimentation ? Juste pour vous assurer que c’est fonctionnel

vince3011 · June 30, 2023, 4:14am

Oui avec le prg "blink" ça fonctionne.

J-M-L · June 30, 2023, 7:38am

Je veux dire un code qui parle au serveur sigfox

vince3011 · June 30, 2023, 12:42pm

J'ai essayé l'exemple sous ce lien https://docs.arduino.cc/tutorials/mkr-fox-1200/sigfox-first-configuration cela à fonctionné dès que je me suis connecté au PC.
En se connectant avec une alim via la mini USB, il n'y a pas d'échange avec le serveur Sigfox.

J-M-L · June 30, 2023, 12:47pm

le code d'exemple fait

  while(!Serial) {};

comme la connexion Série ne peut pas s'établir, le code ne peut pas fonctionner, il est bloqué dans ce while. Si on veut pouvoir fonctionner sans le port série, il faut tester une attente max pour que ce soit connecté

par exemple

  while(!Serial && millis() < 5000) delay(1);

ça donne 5 secondes au boot pour que le port série soit établi

Vous n'avez pas cela dans le code que vous avez posté ni le begin() mais vous avez des

vince3011:

  Serial.print("*******************************************");
  Serial.print(                 RUCHE                       );
  Serial.println("*****************************************");

est-ce le bon code que vous avez partagé ?

vince3011 · June 30, 2023, 5:29pm

Merci!

Je l'ai mis en commentaire/supprimé. De ce fait, je vois l'évolution du programme avec le moniteur de série. C'est pourquoi j'utilise souvent le Serial.print()/println()
J'ai oublié de mettre le Serial.begin(115200);

Oui.

Avec une alimentation externe sur la mini-USB, le void Setup() s'exécute normalement présentant un affichage d'accueil sur le LCD et ensuite un "main menu" s'affiche (void Loop()) Avec le button_down je peux descendre dans le menu et valider le choix (button_enter). Par contre, il est impossible de sortir du choix avec le button_esc pour revenir au menu principal ou de remonter dans le menu avec le button_up.

En se connectant sur le PC, la navigation est complète. Je ne comprends pas cette incohérence?

Il n'y a pas trop d'amélioration en ajoutant ce code dans le void Setup().
Il y a un intérêt de mettre cette boucle dans ce cas?

J-M-L · June 30, 2023, 5:31pm

c'était pour tester l'exemple de la bibliothèque

vince3011 · July 4, 2023, 9:15am

Bonjour,

Mon programme fonctionne.

Merci pour votre aide.

J-M-L · July 4, 2023, 12:06pm

quel était le souci ?

vince3011 · July 5, 2023, 2:28am

Il y avait deux soucis
-Mauvaise régulation de l'alimentation externe pour la valeur analogique des boutons
-J ai utilisé un câble d'alimentation USB/micro-usb sans les transferts de données.

J-M-L · July 5, 2023, 7:49am

OK ! Content pour vous que ce soit résolu

system · January 1, 2024, 7:49am

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

Topic		Replies	Views
mkr 1200 sigfox + programme balance connectées Français	5	1975	May 6, 2021
MKRFOX 1200 Français	1	736	May 6, 2021
Souci Sigfox / MKRFox Français	12	877	September 13, 2022
Téléversement infini Français	13	3013	May 6, 2021
aide programmation arduino Français	45	19018	May 6, 2021

Routine MKR FOX 1200

Related topics