IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Arduino Discussion :

Consommation : comment améliorer l'autonomie ?


Sujet :

Arduino

  1. #1
    Membre actif
    Inscrit en
    Juillet 2004
    Messages
    762
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 762
    Points : 230
    Points
    230
    Par défaut Consommation : comment améliorer l'autonomie ?
    Bonjour à tous

    TTGO ESP32 LoRa

    Je continue ma quête ...
    et constate que mon Emetteur consomme beaucoup de trop ( voir courbe batterie)

    pour mémoire , je réveille l'ESP322 toute les 10 minutes pour la transmission de la valeur de la tension batterie
    néanmoins le pente me parait importante et je n'arrive pas à en comprendre la raison

    Pour une meilleure compréhension je joins le schéma ainsi que le croquis

    Fort de votre expérience de ce produit peut-être auriez-vous quelques conseils qui me permettraient
    d'améliorer l'autonomie de ma batterie ( type : 2400mAh 18650 )

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
     
    /*************************************/
    //    EMETTEUR    
    //
    // SCK     5    // GPIO5  -- SX1278's SCK
    // MISO    19   // GPIO19 -- SX1278's MISO
    // MOSI    27   // GPIO27 -- SX1278's MOSI
    // SS      18   // GPIO18 -- SX1278's CS
    // RST     14   // GPIO14 -- SX1278's RESET
    // DI0     26   // GPIO26 -- SX1278's IRQ(Interrupt Request)
    // BAND    433E6
    //
    // I2C_SDA      4
    // I2C_SCL      15
    // OLED_RST     16
     
    /***************************************
                    carte TTGO LoRa32-OLED V1
     
                       /----------------\
                       |19            18| 
                       |20            17|
                       |21            16|
                       |22            15| 
                       |23            14|
                       |24            13|
                       |25            12|
                       |26            11|
                       |27            10|  GPIO35   vbatPin
      MISO     GPIO19  |28             9|
                       |29             8|
      SS       GPIO18  |30             7|
      SCK      GPIO05  |31             6|  GPIO26   DI0 
      I2C_SCL  GPIO15  |32             5|  GPIO27   MOSI
      volet    GPIO00  |33             4|  GPIO14   RST
      I2C_SDA  GPIO04  |34             3|
      porte    GPIO17  |35             2| 
      OLED_RST GPIO16  |36             1| 
                       -----------------
     
    *************************************/
     
    #include <LoRa.h>
    #include <SPI.h>
    #include <Wire.h>
    //Libraries for OLED Display
    #include "SSD1306.h" 
    #include "boards.h"
    #include <OneButton.h> //  http://www.mathertel.de/Arduino/OneButtonLibrary.aspx
     
     
    SSD1306Wire display(0x3c, I2C_SDA, I2C_SCL);
     
    const byte pinBouton1 = 32;
    const byte pinBouton2 = 33;
    const uint8_t vbatPin = 35;
     
    #define BUTTON_PIN_BITMASK 0x300002000 // PIN13+PIN32+PIN33 in hex
    #define uS_TO_S_FACTOR 1000000 /* Conversion factor for micro seconds to seconds */
    #define TIME_TO_SLEEP 600 /* Time ESP32 will go to sleep (in seconds) */
     
    RTC_DATA_ATTR int bootCount = 0;
     
    OneButton sw1(pinBouton1);
    int value1;
    OneButton sw2(pinBouton2);
    int value2;
     
    // CALLBACKS BOUTON 1
    void sw1Click()       {loraMessage("1");}
    void sw1DoubleClick() {loraMessage("11");}
    void sw1DebutLong()   {loraMessage("1D");}
    void sw1FinLong()     {loraMessage("1F");}
     
    // CALLBACKS BOUTON 2
    void sw2Click()       {loraMessage("2");}
    void sw2DoubleClick() {loraMessage("21");}
    void sw2DebutLong()   {loraMessage("2D");}
    void sw2FinLong()     {loraMessage("2F");}
     
    //**********************************************
    // SETUP
    //**********************************************
    void setup() {
      Serial.begin(115200);
      initBoard();
      display.init();
      display.flipScreenVertically();
      display.setFont(ArialMT_Plain_10);
     
      while (!Serial) yield();
        SPI.begin(RADIO_SCLK_PIN,RADIO_MISO_PIN,MOSI,RADIO_MOSI_PIN );
        LoRa.setPins(RADIO_CS_PIN,RADIO_RST_PIN,RADIO_DIO_PIN);
        Serial.println("LoRa Sender");
      if (!LoRa.begin(LoRa_frequency)) { // LoRa_frequency 
        Serial.println("Starting LoRa failed!");
        while (true) yield();
      }
      Serial.println("init ok");
      display.init();
      display.flipScreenVertically(); 
      display.setFont(ArialMT_Plain_10);
      display.setTextAlignment(TEXT_ALIGN_CENTER);
      display.drawString(64, 22, "Emetteur: OK"); 
      display.display();
      delay(100);
     
      //Increment boot number and print it every reboot
      ++bootCount;
      Serial.println("Boot number: " + String(bootCount));
     
      // BTN1
      sw1.attachClick(sw1Click);
     
      // BTN2
      sw2.attachClick(sw2Click);
     
      //Print the GPIO used to wake up
      print_wakeup_reason();
      print_GPIO_wake_up();  
      esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
      esp_sleep_enable_ext1_wakeup(BUTTON_PIN_BITMASK,ESP_EXT1_WAKEUP_ANY_HIGH);
     
      esp_deep_sleep_start();
     
    }
     
    //**********************************************
    // LOOP
    //**********************************************
    void loop() {
    }
     
    //***********************************************
    void loraMessage(const char * message) {
      LoRa.beginPacket();
      LoRa.println(message);
      LoRa.endPacket();
    }
     
    //************************************************
    void print_GPIO_wake_up(){
      uint64_t GPIO_reason = esp_sleep_get_ext1_wakeup_status();
      Serial.print("GPIO qui a déclenché le réveil : GPIO ");
      Serial.println((log(GPIO_reason))/log(2), 0);
      int val = (int)((log(GPIO_reason))/log(2));
      switch (val)
      {
      case 32: loraMessage("1"); break;
      case 33: loraMessage("2"); break;
      default : Serial.printf("Aucun GPIO n'a déclenché le réveil :"); break;
      }
    }
     
    char string[25];
    void drawFontFaceDemo(float Vbat) {
        // Font Demo1
        // create more fonts at http://oleddisplay.squix.ch/
        display.setTextAlignment(TEXT_ALIGN_LEFT);
        display.setFont(ArialMT_Plain_10);
        display.drawString(0, 0, "Battery");
        display.setFont(ArialMT_Plain_16);
        display.drawString(0, 10, "Monitoring");
        display.setFont(ArialMT_Plain_24);
        itoa(Vbat,string,10);
        sprintf(string,"%7.5f",Vbat);
        display.drawString(0, 26, string);
    }
     
     
    void print_wakeup_reason(){
       esp_sleep_wakeup_cause_t source_reveil;
       source_reveil = esp_sleep_get_wakeup_cause();
       switch(source_reveil){
          case ESP_SLEEP_WAKEUP_TIMER : 
          Serial.println("Réveil causé par un timer");
          //loraMessage("V");
          envoiVbatBrut();
          break;
          default : Serial.printf("Réveil pas causé par le Deep Sleep: %d\n",source_reveil); 
          break;
       }
    }
     
    void envoiVbatBrut() {
      const int tailleMax = 20; // y compris le '\0' de fin
      static char vBatMessage[tailleMax];                                 // doit être assez grand pour contenir le message
      int vBat = analogRead(vbatPin); // tension échantillonnée brute
      Serial.println("Valeur Brute = "); Serial.print(vBat);
      int n = snprintf(vBatMessage, sizeof vBatMessage, "V%d", vBat);     // 'V' suivi de la tension échantillonnée brute
      if ((n > 0) && (n < tailleMax))                                     // si on a pu écrire correctement le message
        loraMessage(vBatMessage);                                         //   alors envoi du message
    }
    Images attachées Images attachées  
    Images attachées Images attachées

  2. #2
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 711
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 711
    Points : 5 390
    Points
    5 390
    Par défaut
    Vous avez un lien sur la modèle exact de TTGO?

    Avez vous mesuré la consommation en activité (émission) et en sommeil ?

    Avez vous autre chose qui est alimenté par la batterie?

  3. #3
    Membre actif
    Inscrit en
    Juillet 2004
    Messages
    762
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 762
    Points : 230
    Points
    230
    Par défaut
    Bonjour Jay M

    Vous avez un lien sur la modèle exact de TTGO?
    c'est celui-ci SX1278 433MhZ
    http://www.lilygo.cn/prod_view.aspx?...FId=t3:50060:3

    Avez vous mesuré la consommation en activité (émission) et en sommeil ?
    Non malheureusement , mesurer l'intensité sur un phénomène aussi court ne serait pas d'une grande fiabilité et je ne saurai comme faire n'ayant pas d'oscillo
    je m'en remets aux caractéristiques techniques
    par contre j'ai trouvé cet article qui m semble intéressant à creuser peut-être
    https://forum.arduino.cc/t/consommat...-lora/621923/4


    Avez vous autre chose qui est alimenté par la batterie?
    Oui comme il est indiqué sur le schéma
    les boutons via des capacités et le pont de mesure de la batterie
    Images attachées Images attachées

  4. #4
    Expert confirmé

    Homme Profil pro
    Directeur de projet
    Inscrit en
    Mai 2013
    Messages
    1 329
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Service public

    Informations forums :
    Inscription : Mai 2013
    Messages : 1 329
    Points : 4 146
    Points
    4 146
    Par défaut
    Bonjour,

    Il est vrai que ce n'est pas facile sans instrument mais cela me rappelle un film où ils expliquaient, dans un bar lieu de philosophie pratique , comment peser la fumée de cigare. Il suffit de peser le cigare avant et après sa consommation. De la même manière, un relevé sans aucune mise en sommeil et un relevé avec donnera une estimation des gains obtenus sur la consommation.

    Par ailleurs, le lien donné montre à juste type qu'il ne faut pas oublier les périphériques embarqués sur la carte qui eux ne bénéficient pas de la mise en veille.

    Salutations
    Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. (Samuel Beckett)

  5. #5
    Membre actif
    Inscrit en
    Juillet 2004
    Messages
    762
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 762
    Points : 230
    Points
    230
    Par défaut
    Bonjour,

    Merci d'avoir répondu
    je vais essayer de mesurer la consommation
    mais je souhaiterai avoir votre avis
    en effet , dans le projet actuel
    L’émetteur :
    - envoie un signal toutes les x minutes (10) pour tester le bon fonctionnement de la liaison
    - envoie une information si une GPIO ( 32 ou 33) est active

    Si je supprime le réveil toutes les x minutes je gagnerai beaucoup en autonomie
    mais je ne testerai plus la liaison
    le compromis serait peut-être de faire travailler le récepteur toutes les x minutes ( ou heures)
    et d'interroger l'émetteur pour valider la liaison
    de cette façon je pourrai mieux moduler la période de test liaison
    mais çà impose de travailler en full-duplex
    comment puis-je faire svp ?

  6. #6
    Expert confirmé

    Homme Profil pro
    Directeur de projet
    Inscrit en
    Mai 2013
    Messages
    1 329
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Service public

    Informations forums :
    Inscription : Mai 2013
    Messages : 1 329
    Points : 4 146
    Points
    4 146
    Par défaut
    Bonjour,

    Si l'émetteur est endormi comment pourra-t-il répondre ? Et si un mécanisme le réveille où est le gain ? La démarche statistique est effectivement une approche mais cela peut prendre beaucoup de temps sans être une garantie. Par exemple entre température élevée et température basse le comportement des batteries varient très sensiblement.

    L'envoi toutes les dix minutes de la tension de la batterie n'est pas nécessaire. Seul une information d'alerte peut être utile. Il me semble qu'utiliser un seuil batterie comme éveilleur serait le plus efficace. La valeur n'a pas besoin d'une grande précision et un simple transistor bipolaire alimenté par un pont pourrait faire le job en utilisant son comportement autour des 0.6 V de la jonction base émetteur. Ce n'est pas très précis mais simple. Bien sûr une solution avec un comparateur et une zener serait plus précise.

    Salutations
    Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. (Samuel Beckett)

  7. #7
    Membre actif
    Inscrit en
    Juillet 2004
    Messages
    762
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 762
    Points : 230
    Points
    230
    Par défaut
    Bonjour,

    l'envoi de la valeur brute de la tension batterie me permet juste de vérifier le bon fonctionnement
    de la liaison, je me suis dit que quitte à envoyer une information autant qu'elle me soit utile
    si j'optais que pour l'envoi d'une information TOR ouverture de volet ou de porte
    il est donc évident que j'économiserai beaucoup d'énergie ( surtout si l'information est au max 1 ou 2 fois/ jour)
    par contre je n'obtiens plus d'info sur la perte de liaison

    le compromis est donc d'allonger le temps, je pensais à 1h
    et c'est que je suis en train de tester

    Salutations

  8. #8
    Membre actif
    Inscrit en
    Juillet 2004
    Messages
    762
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 762
    Points : 230
    Points
    230
    Par défaut
    carte TTGO LoRa32-OLED V1

    j'ai fait l'essai à 3600s mais

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    #define uS_TO_S_FACTOR 1000000 /* Conversion factor for micro seconds to seconds */
    #define TIME_TO_SLEEP 1800 /* Time ESP32 will go to sleep (in seconds) */
    mais le croquis ne fonctionne pas

    Après plusieurs essais , j'ai constaté qu'au delà de 2000s le programme çà ne fonctionne plus
    Est-ce normal ?
    Y aurait-il une autre solution pour atteindre 3600s sans Horloge interne ?

  9. #9
    Expert confirmé

    Homme Profil pro
    Directeur de projet
    Inscrit en
    Mai 2013
    Messages
    1 329
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Service public

    Informations forums :
    Inscription : Mai 2013
    Messages : 1 329
    Points : 4 146
    Points
    4 146
    Par défaut Tant de temps
    Bonjour,

    3600* 106 us nécessite 31.7453 bits. Cela tient dans un uint32_t ou un int32_t mais si c'est ce dernier format qui est utilisé, le nombre sera négatif car supérieur à 231. Cela explique peut être le problème.

    Si c'est cela, 2147 s soit 35 mn 47 sera le maximum possible. A tester.

    Salutations
    Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. (Samuel Beckett)

  10. #10
    Membre actif
    Inscrit en
    Juillet 2004
    Messages
    762
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 762
    Points : 230
    Points
    230
    Par défaut
    merci bien Guesset

    je vais tester çà

    Existe-t-il une autre manière de contourner le problème ?

  11. #11
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 711
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 711
    Points : 5 390
    Points
    5 390
    Par défaut
    sur ESP32 je crois que ces fonctions utilisent des uint64_t

    forcez donc les calculs en unsigned long long

    au lieu d'utiliser des #define pour lesquels vous ne maitrisez pas le type (int par défaut) et déborder lors des opérations, passez sur des constantes typées


    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
    const uint64_t  uS_TO_S_FACTOR = 1000000ull; /* Conversion factor for micro seconds to seconds */
    const uint64_t  TIME_TO_SLEEP = 600ull; /* Time ESP32 will go to sleep (in seconds) */
    comme ça quand vous faites
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
      esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
    la multiplication se fait en uint64_t et vous êtes tranquille

  12. #12
    Membre actif
    Inscrit en
    Juillet 2004
    Messages
    762
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 762
    Points : 230
    Points
    230
    Par défaut
    merci Jay M

    (mille pardons pour la réponse tardive j'étais absent !)

    Je vais donc essayer cela

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
    const uint64_t  uS_TO_S_FACTOR = 1000000ull; /* Conversion factor for micro seconds to seconds */
    const uint64_t  TIME_TO_SLEEP = 3600ull; /* Time ESP32 will go to sleep (in seconds) */
    j'aurai une dernière requête (en espérant ne pas être hors sujet)

    les entrées 32 et 33 sont actionnées durant un délai de 8s env pour éviter de rester bloquer en position "active"
    ce temps de 8s occasionne de nombreuses sollicitations de l'ESP32 et donc de l’énergie
    J'ai constaté qu'avec la bibliothèque <OneButton.h> il existait les termes par ex :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
    void sw1DebutLong()   {loraMessage("1D");}
    void sw1FinLong()     {loraMessage("1F");}
    pourrai-je utiliser ces termes pour couvrir le délai de 8s et n'avoir un déclenchement que sur le 1er front montant et si oui comment faire svp ?

  13. #13
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 711
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 711
    Points : 5 390
    Points
    5 390
    Par défaut
    Je ne comprends ps bien la question….

  14. #14
    Membre actif
    Inscrit en
    Juillet 2004
    Messages
    762
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 762
    Points : 230
    Points
    230
    Par défaut
    Bonsoir Jay M

    Tout d'abord , les modifications que vous avez préconisées fonctionnent
    puisque j'arrive à 3600s sans problème => merci


    En ce qui concerne ma question ...subsidiaire
    j'ai constaté que lorsque j'actionnais les entrées GPIO32 et GPIO33 càd les boutons
    j'avais une information à 1 d'une durée de 8 s env due essentiellement au temps de la décharge capa ( voir schéma joint )
    le ESP32 s'éteint en fin de "setup" puis se réveille puisqu'il constate une interruption sur GPIO32 ou GPIO33 et ainsi de suite durant 8s

    je voulais savoir, s'il était possible avec la librairie <OneButton.h> d'utiliser seulement le 1er front montant
    et ainsi minimiser la consommation d’énergie

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
    void sw1DebutLong()   {loraMessage("1D");}
    void sw1FinLong()     {loraMessage("1F");}
    Images attachées Images attachées

  15. #15
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 711
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 711
    Points : 5 390
    Points
    5 390
    Par défaut
    Pouvez vous poster le code à jour ainsi que le schéma ?
    Il me semble que vous vouliez envoyer un message sur appui et sur relâchement du bouton. Est-ce le cas?

  16. #16
    Membre actif
    Inscrit en
    Juillet 2004
    Messages
    762
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 762
    Points : 230
    Points
    230
    Par défaut
    Bonjour Jay M

    Voici le schéma en pièce jointe
    le but étant d'éviter la prise en compte d'un état actif de plus de plus de 8s ( volet ou porte ouverts en permanence par ex )

    et le code
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
     
    /*************************************
                 EMETTEUR    
    ************************************/
     
     
    /***************************************
                    carte TTGO LoRa32-OLED V1
     
                       /----------------\
                       |19            18| 
                       |20            17|
                       |21            16|
                       |22            15| 
                       |23            14|
                       |24            13|
                       |25            12|
                       |26            11|
                       |27            10|  GPIO35   vbatPin
      MISO     GPIO19  |28             9|  GPIO32   volet
                       |29             8|  GPI033   Porte  
      SS       GPIO18  |30             7|
      SCK      GPIO05  |31             6|  GPIO26   DI0 
      I2C_SCL  GPIO15  |32             5|  GPIO27   MOSI
                       |33             4|  GPIO14   RST
      I2C_SDA  GPIO04  |34             3|
                       |35             2| 
      OLED_RST GPIO16  |36             1| 
                       -----------------
     
    *************************************/
     
    #include <LoRa.h>
    #include <SPI.h>
    #include <Wire.h>
    #include <OneButton.h> //  http://www.mathertel.de/Arduino/OneButtonLibrary.aspx
     
    //Libraries for OLED Display
    #include "SSD1306.h" 
     
    // LoRa definition
    #define SCK     5    // GPIO5  -- SX1278's SCK
    #define MISO    19   // GPIO19 -- SX1278's MISO
    #define MOSI    27   // GPIO27 -- SX1278's MOSI
    #define SS      18   // GPIO18 -- SX1278's CS
    #define RST     14   // GPIO14 -- SX1278's RESET
    #define DI0     26   // GPIO26 -- SX1278's IRQ(Interrupt Request)
    #define BAND    433E6
     
    // OLED definition
    #define I2C_SDA                     4
    #define I2C_SCL                     15
    #define OLED_RST                    16
    SSD1306Wire display(0x3c, I2C_SDA, I2C_SCL);
     
     
    const byte pinBouton1 = 32;
    const byte pinBouton2 = 33;
    const uint8_t vbatPin = 35;
     
    #define BUTTON_PIN_BITMASK 0x300002000 // PIN32+PIN33 in hex
    //#define uS_TO_S_FACTOR 1000000 /* Conversion factor for micro seconds to seconds */
    //#define TIME_TO_SLEEP 1800 /* Time ESP32 will go to sleep (in seconds) */
     
    const uint64_t  uS_TO_S_FACTOR = 1000000ull; /* Conversion factor for micro seconds to seconds */
    const uint64_t  TIME_TO_SLEEP = 3600ull; /* Time ESP32 will go to sleep (in seconds) */
     
     
    RTC_DATA_ATTR int bootCount = 0;
     
    OneButton sw1(pinBouton1);
    int value1;
    OneButton sw2(pinBouton2);
    int value2;
     
    // CALLBACKS BOUTON 1
    void sw1Click()       {loraMessage("1");}
    void sw1DoubleClick() {loraMessage("11");}
    void sw1DebutLong()   {loraMessage("1D");}
    void sw1FinLong()     {loraMessage("1F");}
     
    // CALLBACKS BOUTON 2
    void sw2Click()       {loraMessage("2");}
    void sw2DoubleClick() {loraMessage("21");}
    void sw2DebutLong()   {loraMessage("2D");}
    void sw2FinLong()     {loraMessage("2F");}
     
    //**********************************************
    // SETUP
    //**********************************************
    void setup() {
      Serial.begin(115200);
     
      while (!Serial) yield();
       	SPI.begin(SCK,MISO,MOSI,SS);
        LoRa.setPins(SS,RST,DI0);
        Serial.println("LoRa Sender");
      if (!LoRa.begin(433E6)) { // LoRa_frequency 
        Serial.println("Starting LoRa failed!");
        while (true) yield();
      }
     
      Serial.println("init ok");
      display.init();
      display.flipScreenVertically(); 
      display.setFont(ArialMT_Plain_10);
      display.setTextAlignment(TEXT_ALIGN_CENTER);
      display.drawString(64, 22, "Emetteur: OK"); 
      display.display();
      delay(100);
      display.clear();
      display.display();
     
      //Increment boot number and print it every reboot
      ++bootCount;
      Serial.println("Boot number: " + String(bootCount));
     
      // BTN1
      sw1.attachClick(sw1Click);
     
      // BTN2
      sw2.attachClick(sw2Click);
     
      //Print the GPIO used to wake up
      print_wakeup_reason();
      print_GPIO_wake_up();  
      esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
      esp_sleep_enable_ext1_wakeup(BUTTON_PIN_BITMASK,ESP_EXT1_WAKEUP_ANY_HIGH);
     
      esp_deep_sleep_start();
     
    }
     
    //**********************************************
    // LOOP
    //**********************************************
    void loop() {
    }
     
    //***********************************************
    void loraMessage(const char * message) {
      LoRa.beginPacket();
      LoRa.println(message);
      LoRa.endPacket();
    }
     
    //************************************************
    void print_GPIO_wake_up(){
      uint64_t GPIO_reason = esp_sleep_get_ext1_wakeup_status();
      Serial.print("GPIO qui a déclenché le réveil : GPIO ");
      Serial.println((log(GPIO_reason))/log(2), 0);
      int val = (int)((log(GPIO_reason))/log(2));
      switch (val)
      {
      case 32:
      loraMessage("1");
      break;
      case 33:
      loraMessage("2");
      break;
      default : Serial.printf("Aucun GPIO n'a déclenché le réveil :"); break;
      }
    }
     
    void print_wakeup_reason(){
       esp_sleep_wakeup_cause_t source_reveil;
       source_reveil = esp_sleep_get_wakeup_cause();
       switch(source_reveil){
          case ESP_SLEEP_WAKEUP_TIMER : 
          Serial.println("Réveil par un timer");
          envoiVbatBrut();
          break;
          default : Serial.printf("Réveil pas causé par le Deep Sleep: %d\n",source_reveil); 
          break;
       }
    }
     
    void envoiVbatBrut() {
      const int tailleMax = 20; // y compris le '\0' de fin
      static char vBatMessage[tailleMax];                                 // doit être assez grand pour contenir le message
      int vBat = analogRead(vbatPin); // tension échantillonnée brute
      Serial.print("Valeur Brute = "); Serial.println(vBat);
      int n = snprintf(vBatMessage, sizeof vBatMessage, "V%d", vBat);     // 'V' suivi de la tension échantillonnée brute
      if ((n > 0) && (n < tailleMax))                                     // si on a pu écrire correctement le message
        loraMessage(vBatMessage);                                         //   alors envoi du message
    }

    Edit : je viens de constater que ma consommation est en base de : 11,39 mA ce qui est énorme , due peut-être au pont de mesure (2x 100k) de la tension batterie
    est-ce que je peux augmenter les résistances à 2 x 1Mohm sans affecter la précision de mesure pour diminuer la consommation ?

    Edt2 : j'ai modifié les valeurs de résistances du pont de mesure en les passant à 1MOhm , la consommation reste identique soit 11,39 mA
    par contre , lorsque j'alimente le TTGO directement via USB puis ensuite le débranchement , la consommation tombe à 4,39 mA puis remonte à 11,39 mA si une entrée a été activée (?)
    Images attachées Images attachées

  17. #17
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 711
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 711
    Points : 5 390
    Points
    5 390
    Par défaut
    à quoi sert la capa C3 de 100µF en parallèle sur R8 au niveau du pont ?

    Juste pour vérifier un truc, si vous prenez votre TTGO avec juste la batterie branchée et sans votre pont et que vous essayez de lire ce qu'il se passe sur la pin 35, est-ce que vous voyez un résultat cohérent qui correspondrait au niveau de la batterie ? certaines cartes TTGO ont si je me souviens bien sur la pin 35 un pont diviseur qui est relié à la batterie


    tel que c'est codé les OneButton ne servent à rien, on se rendort avant même qu'ils aient pu servir à quelque chose non ?

    essayez de mesurer le courant consommé avec ce code
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    const uint64_t  uS_TO_S_FACTOR = 1000000ull; /* Conversion factor for micro seconds to seconds */
    const uint64_t  TIME_TO_SLEEP = 10ull; /* Time ESP32 will go to sleep (in seconds) */
    RTC_DATA_ATTR uint32_t bootCount = 0;
     
    void setup() {
      Serial.begin(115200); Serial.println();
      while(!Serial) yield();
      Serial.println("Hello World");
      ++bootCount;
      esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
      Serial.println("Sleeping in 10s"); Serial.flush();
      delay(10000);
      esp_deep_sleep_start();
    }
     
    void loop() {}
    quand il est en sleep et quand il n'est pas en sleep

  18. #18
    Membre actif
    Inscrit en
    Juillet 2004
    Messages
    762
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 762
    Points : 230
    Points
    230
    Par défaut
    à quoi sert la capa C3 de 100µF en parallèle sur R8 au niveau du pont ?
    Elle me semblait importante pour stabiliser la mesure lors des envoies d'informations


    Juste pour vérifier un truc, si vous prenez votre TTGO avec juste la batterie branchée et sans votre pont et que vous essayez de lire ce qu'il se passe sur la pin 35, est-ce que vous voyez un résultat cohérent qui correspondrait au niveau de la batterie ? certaines cartes TTGO ont si je me souviens bien sur la pin 35 un pont diviseur qui est relié à la batterie
    J'ai retrouvé ce que me semble être le schéma ( voir fichier joint ) et il apparait en Pin 35 un pont avec 2 résistances de 100k relié à Vbat ( voir page 4/4 )
    Mais en prenant la valeur d'entrée , je trouve 0,015 v pour une batterie 3,97v ce qui n'est pas très cohérent

    voici le lien où j'ai trouvé le schéma :
    https://github.com/LilyGO/TTGO-LORA32


    Quant aux mesures de tension demandées, je les ferais demain ....

    tel que c'est codé les OneButton ne servent à rien, on se rendort avant même qu'ils aient pu servir à quelque chose non ?
    Non, les boutons fonctionnent, trop même puisque ils génèrent un flot durant 8s , c'est l'objet de ma demande justement
    Images attachées Images attachées

  19. #19
    Rédacteur/Modérateur

    Avatar de Jerome Briot
    Homme Profil pro
    Freelance mécatronique - Conseil, conception et formation
    Inscrit en
    Novembre 2006
    Messages
    20 302
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Freelance mécatronique - Conseil, conception et formation

    Informations forums :
    Inscription : Novembre 2006
    Messages : 20 302
    Points : 53 166
    Points
    53 166
    Par défaut
    Citation Envoyé par cobra38 Voir le message
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
      if (!LoRa.begin(433E6)) { // LoRa_frequency 
        Serial.println("Starting LoRa failed!");
        while (true) yield();
      }
    Ce n'est peut être pas le cas mais si vous êtes en Europe, vous n'utilisez pas la bonne fréquence pour le LoRa.
    Votre module est un module utilisable en Asie uniquement => https://lora.readthedocs.io/en/lates...considerations
    Il vous faut acheter une nouvelle carte réglée à la fréquence 868 MHz.

    Avez vous essayé d'ajouter des résistances de pull-up sur les broches Lora_CS et Lora_RST ?
    L'état des broches de l'ESP32 n'étant pas maintenu (par défaut) en veille profonde, cela peut parfois activer ou mettre constamment certains périphériques en mode reset.
    Si ça fonctionne, il y a des fonctions qui permettent de garder l'état des boches à la mise en veille (gpio_hold_en et gpio_hold_dis)
    Ingénieur indépendant en mécatronique - Conseil, conception et formation
    • Conception mécanique (Autodesk Fusion 360)
    • Impression 3D (Ultimaker)
    • Développement informatique (Python, MATLAB, C)
    • Programmation de microcontrôleur (Microchip PIC, ESP32, Raspberry Pi, Arduino…)

    « J'étais le meilleur ami que le vieux Jim avait au monde. Il fallait choisir. J'ai réfléchi un moment, puis je me suis dit : "Tant pis ! J'irai en enfer" » (Saint Huck)

  20. #20
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 711
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 711
    Points : 5 390
    Points
    5 390
    Par défaut
    Citation Envoyé par cobra38 Voir le message
    Elle me semblait importante pour stabiliser la mesure lors des envoies d'informations
    la tension devrait être relativement stable si vous ne tirez pas trop, mais ça va lisser effectivement

    Citation Envoyé par cobra38 Voir le message
    J'ai retrouvé ce que me semble être le schéma ( voir fichier joint ) et il apparait en Pin 35 un pont avec 2 résistances de 100k relié à Vbat ( voir page 4/4 )
    Mais en prenant la valeur d'entrée , je trouve 0,015 v pour une batterie 3,97v ce qui n'est pas très cohérent
    essayez avec la formule
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    float vBat = analogRead(35) / 4095.0 * 2.0 * 3.3 * 1.1;

    Citation Envoyé par cobra38 Voir le message
    Non, les boutons fonctionnent, trop même puisque ils génèrent un flot durant 8s , c'est l'objet de ma demande justement
    Le code tel qu'il est se réveille tous les ∆t par l'appel à esp_sleep_enable_timer_wakeup() et quand l'ESP voit un HIGH sur n'importe quelle pins des boutons de BUTTON_PIN_BITMASK. Le code exécute le setup() qui configure LoRa, affiche des choses sur le port série, configure les callbacks pour les boutons et appelle vos fonctions print_wakeup_reason() et print_GPIO_wake_up() puis votre arduino se rendort.

    la bibliothèque OneButton n'utilise que du polling (interrogation quand on demande). ici vous ne faites jamais
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    sw1.tick();
    sw2.tick();
    donc la bibliothèque n'est jamais appelée et les callbacks sw1Click ou sw2Click ne sont jamais utilisés. Ce n'est pas la bibliothèque qui maintient votre ESP allumé

    il se peut que cela vienne de
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
      esp_sleep_enable_ext1_wakeup(BUTTON_PIN_BITMASK,ESP_EXT1_WAKEUP_ANY_HIGH);
    comme le dit Jerome Briot il faut explorer le maintient des broches de l'ESP32 en veille pour que le pullup interne soit conservé. Sinon on peut aussi mettre un pullup externe sur les boutons. cf https://docs.espressif.com/projects/...leep-stub.html

Discussions similaires

  1. Comment améliorer la rotation à 45° d'une image dans un PictureBox
    Par ProgElecT dans le forum VB 6 et antérieur
    Réponses: 6
    Dernier message: 22/07/2006, 01h05
  2. Comment amèliorer ma demande d'emploi ?
    Par unix27 dans le forum Emploi
    Réponses: 19
    Dernier message: 29/03/2006, 13h55
  3. [Sécurité] Comment amélioré mon code ?
    Par Nadd dans le forum Langage
    Réponses: 14
    Dernier message: 03/03/2006, 20h13

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo