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 :

Utilisation de la Librairie OneButton


Sujet :

Arduino

  1. #1
    Membre éprouvé
    Inscrit en
    Juillet 2004
    Messages
    914
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 914
    Par défaut Utilisation de la Librairie OneButton
    Bonjour à Tous

    Je poursuis ma quête du post précédent dans lequel j'ai mon émetteur à 3 boutons
    2 boutons symbolisent les alarmes
    le troisième sert à l’acquittement

    dans le même temps je souhaite mesurer le niveau de la batterie de l’émetteur pour ce faire
    j'ai trouvée sur le net ceci :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
    // mesure tension d'alimentation d'un ESP32
    extern "C" int rom_phy_get_vdd33();
    j'obtiens donc une indication de tension en faisant :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     int voltage = (rom_phy_get_vdd33());
      Serial.println(voltage);
      delay(50);
    mais comment obtenir cette indication seulement lorsqu'on appuie longuement sur sw3 par ex
    tout en sachant que cet appui est déjà détecté par le terme :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    sw3.attachLongPressStart(sw3DebutLong);
      sw3.attachLongPressStop(sw3FinLong);
    j'ai tenté çà mais çà ne tient pas compte de la durée de l'appui longue

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    void loop() {
      sw1.tick();
      sw2.tick();  
      sw3.tick(); 
      if  (bool isPressed = (digitalRead(pinBouton3) == LOW)) {
      int voltage = (rom_phy_get_vdd33());
      Serial.println(voltage);
      delay(50);
      } 
    }

  2. #2
    Responsable Arduino et Systèmes Embarqués


    Avatar de f-leb
    Homme Profil pro
    Enseignant
    Inscrit en
    Janvier 2009
    Messages
    13 120
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 54
    Localisation : France, Sarthe (Pays de la Loire)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : Janvier 2009
    Messages : 13 120
    Billets dans le blog
    47
    Par défaut
    Bonjour,

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    sw3.attachLongPressStart(sw3DebutLong);
    D'après la doc,
    Fires as soon as the button is held down for 1 second.
    donc un événement est déclenché dès que l'appui long (1 seconde) sur sw3 est détecté.
    Il suffit de mettre le code que tu veux exécuter dans la fonction de rappel sw3DebutLong() :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    static void sw3DebutLong() {
       // le code à exécuter sur l'événement 
       // ...
    }
    Attention au delay(), il bloque l'appel au gestionnaire des boutons (fonctions swx.tick()).

  3. #3
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 882
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 882
    Par défaut
    Oui la bibliothèque permet pour un appui long de recevoir un appel de fonction au début de l’appui long, pendant l’appui long et à la fin de l’appui long. Donc ça permet de faire pas mal de choses

  4. #4
    Membre éprouvé
    Inscrit en
    Juillet 2004
    Messages
    914
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 914
    Par défaut
    merci bien f-leb
    Attention au delay(), il bloque l'appel au gestionnaire des boutons (fonctions swx.tick()).
    J'ai fait attention mais il faut aussi stabiliser la mesure mes tentatives de mesure de la valeur moyenne ceux ne sont pas avérés fiables

    d'autre part peux-tu me dire stp si cette méthode de mesure de VBat qui ne comporte aucun pont de résistances externes est bonne
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    // mesure tension d'alimentation d'un ESP32
    extern "C" int rom_phy_get_vdd33();
    car je mesure avec USB branché : env 3.22V mais çà varie bien sûr

  5. #5
    Responsable Arduino et Systèmes Embarqués


    Avatar de f-leb
    Homme Profil pro
    Enseignant
    Inscrit en
    Janvier 2009
    Messages
    13 120
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 54
    Localisation : France, Sarthe (Pays de la Loire)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : Janvier 2009
    Messages : 13 120
    Billets dans le blog
    47
    Par défaut
    Citation Envoyé par cobra38 Voir le message
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    // mesure tension d'alimentation d'un ESP32
    extern "C" int rom_phy_get_vdd33();
    Je ne trouve pas de référence ou de documentation sur cette fonction pour l'ESP32 (sinon une référence un peu ancienne pour l'ESP8266 mais sans documentation sur ce qu'elle renvoie comme valeur).

    Relier la batterie via un pont diviseur à un port analogique classique me semble davantage approprié. Au moins, on maîtrise ce qu'on mesure...

  6. #6
    Membre éprouvé
    Inscrit en
    Juillet 2004
    Messages
    914
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 914
    Par défaut
    Merci f-leb

    le peu de mesures que j'ai pu réaliser
    montre une variation très petite autour de 3.3v
    si on ne fonctionne que sur batterie on note une variation faible de 0.5v max donc non exploitable
    par contre comment mesure-t-on l'état d'une batterie avec un TTGO ESP32
    de la même façon qu'un UNO à savoir :
    pont de mesure sur une entré A0 puis le calcul en interne ou est-ce plus compliqué ?
    ( mais je suis peut-être hors sujet)

  7. #7
    Responsable Arduino et Systèmes Embarqués


    Avatar de f-leb
    Homme Profil pro
    Enseignant
    Inscrit en
    Janvier 2009
    Messages
    13 120
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 54
    Localisation : France, Sarthe (Pays de la Loire)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : Janvier 2009
    Messages : 13 120
    Billets dans le blog
    47
    Par défaut
    Le principe sur Arduino UNO ou ESP32 est le même. Par contre les convertisseurs A/N (ADC) ont des caractéristiques différentes : 0-5V pour Arduino Uno, plage réglable selon l'atténuation pour l'ESP32, 10bits pour la Uno contre 12bits par défaut pour l'ESP32, etc.)
    Pour la programmation, c'est évidemment très similaire si tu passes par l'EDI Arduino pour programmer ta carte ESP32, voir ADC. Il y a plus de paramètres à configurer en général sur l'ESP32.

    Tu devrais ouvrir une nouvelle discussion si tu veux poursuivre sur le sujet, ton problème initial concernait la librairie OneButtton

  8. #8
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 882
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 882
    Par défaut
    certaines TTGO ESP32 ont déjà une pin pour mesurer la tension de la batterie sur la pin 34 ou 35 de mémoire

  9. #9
    Membre éprouvé
    Inscrit en
    Juillet 2004
    Messages
    914
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 914
    Par défaut
    merci pour de précisions
    je vais donc creuser pour savoir comment mesurer le niveau de la batterie
    mais ce n'est pas le sujet principal

    par contre pour rester dans le sujet , j'ai voulu y associer le moyen de réduire justement la consommation du ESP32
    et à ce titre je lui ai rajouté dans le croquis la "mise en sommeil" par :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    esp_sleep_enable_ext0_wakeup(GPIO_NUM_32,0); //1 = High, 0 = Low
     
      esp_sleep_enable_ext0_wakeup(GPIO_NUM_33,0); //1 = High, 0 = Low
     
      esp_sleep_enable_ext0_wakeup(GPIO_NUM_13,0); //1 = High, 0 = Low
    et pour sortir de la mise en sommeil l'action sur les sw1,sw2 et sw3 initialement créés
    comment faire désormais pour enclencher les actions d'envoi à l'aide des commandes
    car çà ne semble pas fonctionner correctement

    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
    #include <LoRa.h>
    #include <SPI.h>
    #include <Wire.h>
     
    //Libraries for OLED Display
    #include "SSD1306.h" 
     
    // Optionally include custom images
    #include "images.h"
    #include "boards.h"
     
    //Librairies Bouton
    #include <OneButton.h> //  http://www.mathertel.de/Arduino/OneButtonLibrary.aspx
     
    /*
    #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
    */
     
     
    SSD1306Wire display(0x3c, I2C_SDA, I2C_SCL);
     
    const byte pinBouton1 = 32;
    #define BUTTON_PIN_BITMASK 0x100000000 // 2^32 in hex
    const byte pinBouton2 = 33;
    //#define BUTTON_PIN_BITMASK 0x200000000 // 2^33 in hex
    const byte pinBouton3 = 13;
    //#define BUTTON_PIN_BITMASK 0x20000 // 2^13 in hex
     
    RTC_DATA_ATTR int bootCount = 0;
     
    OneButton sw1(pinBouton1);
    int value1;
    OneButton sw2(pinBouton2);
    int value2;
    OneButton sw3(pinBouton3);
    int value3;
     
    // mesure tension d'alimentation d'un ESP32
    extern "C" int rom_phy_get_vdd33();
     
    // 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");}
     
    // CALLBACKS BOUTON 3
    void sw3Click()       {loraMessage("3");}
    void sw3DoubleClick() {loraMessage("31");}
    //void sw3DebutLong()   {loraMessage("3D");}
    void sw3FinLong()     {loraMessage("3F");}
     
    //**********************************************
    // 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.drawString(0 , 15 , "Emetteur: OK");
      display.display();
      delay(2000);
     
     
      //Increment boot number and print it every reboot
      ++bootCount;
      Serial.println("Boot number: " + String(bootCount));
      print_wakeup_reason();
     
      // BTN1
      sw1.attachClick(sw1Click);
      sw1.attachDoubleClick(sw1DoubleClick);
      sw1.attachLongPressStart(sw1DebutLong);
      sw1.attachLongPressStop(sw1FinLong);
     
      // BTN2
      sw2.attachClick(sw2Click);
      sw2.attachDoubleClick(sw2DoubleClick);
      sw2.attachLongPressStart(sw2DebutLong);
      sw2.attachLongPressStop(sw2FinLong);
     
      // BTN3
      sw3.attachClick(sw3Click);
      sw3.attachDoubleClick(sw3DoubleClick);
      sw3.attachLongPressStart(sw3DebutLong);
      sw3.attachLongPressStop(sw3FinLong);
     
      esp_sleep_enable_ext0_wakeup(GPIO_NUM_32,0); //1 = High, 0 = Low
      loraMessage("1");
      esp_sleep_enable_ext0_wakeup(GPIO_NUM_33,0); //1 = High, 0 = Low
      loraMessage("2");
      esp_sleep_enable_ext0_wakeup(GPIO_NUM_13,0); //1 = High, 0 = Low
      loraMessage("3");
     
     
      //Go to sleep now
      Serial.println("Going to sleep now");
      delay(1000);
      esp_deep_sleep_start();
      Serial.println("This will never be printed");
    }
     
    //**********************************************
    // LOOP
    //**********************************************
    void loop() {
    }
     
     
    //************************************************
     static void sw3DebutLong(){
     float voltage = (rom_phy_get_vdd33());
     Serial.println(voltage);
     display.clear();
     display.setTextAlignment(TEXT_ALIGN_LEFT);
     display.setFont(ArialMT_Plain_16);
     display.drawString(0 , 15 , String("Vbat: ")+ (voltage/100)+String("V"));
     display.display();
     delay(1000);
     
    }  
     
    //***********************************************
    void loraMessage(const char * message) {
      LoRa.beginPacket();
      LoRa.println(message);
      LoRa.endPacket();
    }
     
    //**********************************************
    void print_wakeup_reason(){
      esp_sleep_wakeup_cause_t wakeup_reason;
      wakeup_reason = esp_sleep_get_wakeup_cause();
      switch(wakeup_reason)
      {
        case ESP_SLEEP_WAKEUP_EXT0 : Serial.println("Wakeup caused by external signal using RTC_IO"); break;
        case ESP_SLEEP_WAKEUP_EXT1 : Serial.println("Wakeup caused by external signal using RTC_CNTL"); break;
        case ESP_SLEEP_WAKEUP_TIMER : Serial.println("Wakeup caused by timer"); break;
        case ESP_SLEEP_WAKEUP_TOUCHPAD : Serial.println("Wakeup caused by touchpad"); break;
        case ESP_SLEEP_WAKEUP_ULP : Serial.println("Wakeup caused by ULP program"); break;
        default : Serial.printf("Wakeup was not caused by deep sleep: %d\n",wakeup_reason); break;
      }
    }

  10. #10
    Responsable Arduino et Systèmes Embarqués


    Avatar de f-leb
    Homme Profil pro
    Enseignant
    Inscrit en
    Janvier 2009
    Messages
    13 120
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 54
    Localisation : France, Sarthe (Pays de la Loire)

    Informations professionnelles :
    Activité : Enseignant

    Informations forums :
    Inscription : Janvier 2009
    Messages : 13 120
    Billets dans le blog
    47
    Par défaut
    Il manque au moins les swx.tick() dans la boucle loop().

  11. #11
    Membre éprouvé
    Inscrit en
    Juillet 2004
    Messages
    914
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 914
    Par défaut
    Bonjour f-leb

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    Il manque au moins les swx.tick() dans la boucle loop().
    logiquement non puisque je passe en sommeil dans le "setup"

    par contre je ne suis pas du tout sûr de la bonne utilisation de :
    #define BUTTON_PIN_BITMASK 0x200000000 // 2^33 in hex

    comment faut-il programmer BUTTON_PIN_BITMASK lorsqu'on utilise plusieurs boutons ?
    1 seule ligne pour 3 boutons ou 1 ligne / bouton ?

  12. #12
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 882
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 882
    Par défaut
    esp_sleep_enable_ext0_wakeup ne prend qu'une seule pin. si vous en voulez plusieurs il faut utiliser esp_sleep_enable_ext1_wakeup. Le bitmask est une agrégation des GPIO sur 64 bits et ce doit être des pins RTC

    cf https://docs.espressif.com/projects/..._wakeup_mode_t

    le #define BUTTON_PIN_BITMASK 0x200000000 // 2^33 in hex correspondait à la pin 33

    pour mettre un bit à 1 à une position donnée on fait par exemple pour la pin 33 1ULL << GPIO_NUM_33. ensuite il vous suffit de faire des OU bitwise (|) entre ces valeurs pour construire le mask. le ULL dit à votre arduino que le 1 doit être sur 64 bits. donc pour la pin 25 et 33 par exemple, le masque serait (1ULL << GPIO_NUM_25) | (1ULL << GPIO_NUM_33)un petit exemple de code pour voir le masque:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    void setup() {
      // put your setup code here, to run once:
      Serial.begin(115200);
      Serial.print("GPIO_NUM_25 vaut "); Serial.print(GPIO_NUM_25);
      Serial.print(" ==> BUTTON_PIN_BITMASK 0x"); Serial.println(1ULL << GPIO_NUM_25, HEX);
     
      Serial.print("GPIO_NUM_33 vaut "); Serial.print(GPIO_NUM_33);
      Serial.print(" ==> BUTTON_PIN_BITMASK 0x"); Serial.println(1ULL << GPIO_NUM_33, HEX);
     
      Serial.print("agrégation des 2 masques"); 
      Serial.print(" ==> BUTTON_PIN_BITMASK 0x"); Serial.println((1ULL << GPIO_NUM_25) | (1ULL << GPIO_NUM_33), HEX);
    }
     
    void loop() {}
    vous devriez avoir
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
     
    GPIO_NUM_25 vaut 25 ==> BUTTON_PIN_BITMASK 0x2000000
    GPIO_NUM_33 vaut 33 ==> BUTTON_PIN_BITMASK 0x200000000
    agrégation des 2 masques ==> BUTTON_PIN_BITMASK 0x202000000

  13. #13
    Membre éprouvé
    Inscrit en
    Juillet 2004
    Messages
    914
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 914
    Par défaut
    Bonjour Jay M

    Le bitmask est une agrégation des GPIO sur 64 bits et ce doit être des pins RTC
    J'utilise les pin 32-33 (alarmes) et 13 (acquit)
    sauf erreur, je réponds donc à la spécification car ceux sont bien des broches RTC

    il faut utiliser esp_sleep_enable_ext1_wakeup.
    Broche 32 => 0x100000000
    Broche 33 => 0x200000000
    Broche 13 => 0x20000

    soit donc =>
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    #define BUTTON_PIN_BITMASK 0x300002000 // 13-32-33 in hex
    toutes mes broches sont avec appel vers 0 or il semble que l'on ait que 2 choix
    soit : ESP_EXT1_WAKEUP_ALL_LOW: wake up when all GPIOs go low => toutes à zero
    soit : ESP_EXT1_WAKEUP_ANY_HIGH: wake up if any of the GPIOs go high. => 1 seule à 1

    et donc pour 1 seule à 0 , comment dois-je faire ?

  14. #14
    Membre éprouvé
    Inscrit en
    Juillet 2004
    Messages
    914
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 914
    Par défaut
    Pour faire suite au message précédent j'ai donc testé
    le croquis suivant

    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
     
    #include <LoRa.h>
    #include <SPI.h>
    #include <Wire.h>
     
    //Libraries for OLED Display
    #include "SSD1306.h" 
     
    // Optionally include custom images
    #include "images.h"
    #include "boards.h"
     
    //Librairies Bouton
    #include <OneButton.h> //  http://www.mathertel.de/Arduino/OneButtonLibrary.aspx
     
    /*
    #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
    */
     
     
    SSD1306Wire display(0x3c, I2C_SDA, I2C_SCL);
     
    const byte pinBouton1 = 32;
    //#define BUTTON1_PIN_BITMASK 0x100000000 // 2^32 in hex
    const byte pinBouton2 = 33;
    //#define BUTTON2_PIN_BITMASK 0x200000000 // 2^33 in hex
    const byte pinBouton3 = 13;
    //#define BUTTON3_PIN_BITMASK 0x20000 // 2^13 in hex
     
     
    #define BUTTON_PIN_BITMASK 0x300002000 // 13-32-33 in hex
     
    RTC_DATA_ATTR int bootCount = 0;
     
    OneButton sw1(pinBouton1);
    int value1;
    OneButton sw2(pinBouton2);
    int value2;
    OneButton sw3(pinBouton3);
    int value3;
     
    // mesure tension d'alimentation d'un ESP32
    extern "C" int rom_phy_get_vdd33();
     
    // 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");}
     
    // CALLBACKS BOUTON 3
    void sw3Click()       {loraMessage("3");}
    void sw3DoubleClick() {loraMessage("31");}
    //void sw3DebutLong()   {loraMessage("3D");}
    void sw3FinLong()     {loraMessage("3F");}
     
    //**********************************************
    // 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.drawString(0 , 15 , "Emetteur: OK");
      display.display();
      delay(2000);
     
     
      //Increment boot number and print it every reboot
      ++bootCount;
      Serial.println("Boot number: " + String(bootCount));
      print_wakeup_reason();
     
      //Print the GPIO used to wake up
      print_GPIO_wake_up(); 
     
      // BTN1
      sw1.attachClick(sw1Click);
      sw1.attachDoubleClick(sw1DoubleClick);
      sw1.attachLongPressStart(sw1DebutLong);
      sw1.attachLongPressStop(sw1FinLong);
     
      // BTN2
      sw2.attachClick(sw2Click);
      sw2.attachDoubleClick(sw2DoubleClick);
      sw2.attachLongPressStart(sw2DebutLong);
      sw2.attachLongPressStop(sw2FinLong);
     
      // BTN3
      sw3.attachClick(sw3Click);
      sw3.attachDoubleClick(sw3DoubleClick);
      sw3.attachLongPressStart(sw3DebutLong);
      sw3.attachLongPressStop(sw3FinLong);
     
      /*
      esp_sleep_enable_ext0_wakeup(GPIO_NUM_32,0); //1 = High, 0 = Low
      esp_sleep_enable_ext0_wakeup(GPIO_NUM_33,0); //1 = High, 0 = Low
      esp_sleep_enable_ext0_wakeup(GPIO_NUM_13,0); //1 = High, 0 = Low
      */
     
      esp_sleep_enable_ext1_wakeup(BUTTON_PIN_BITMASK,ESP_EXT1_WAKEUP_ANY_HIGH);
     
      //Go to sleep now
      Serial.println("Going to sleep now");
      delay(1000);
      esp_deep_sleep_start();
      Serial.println("This will never be printed");
    }
     
    //**********************************************
    // LOOP
    //**********************************************
    void loop() {
     
     
    }
     
     
    //************************************************
     static void sw3DebutLong(){
     float voltage = (rom_phy_get_vdd33());
     Serial.println(voltage);
     display.clear();
     display.setTextAlignment(TEXT_ALIGN_LEFT);
     display.setFont(ArialMT_Plain_16);
     display.drawString(0 , 15 , String("Vbat: ")+ (voltage/100)+String("V"));
     display.display();
     delay(1000);
     
    }  
     
    //***********************************************
    void loraMessage(const char * message) {
      LoRa.beginPacket();
      LoRa.println(message);
      LoRa.endPacket();
    }
     
    //**********************************************
    void print_wakeup_reason(){
      esp_sleep_wakeup_cause_t wakeup_reason;
      wakeup_reason = esp_sleep_get_wakeup_cause();
      switch(wakeup_reason)
      {
        case ESP_SLEEP_WAKEUP_EXT0 : Serial.println("Réveil provoqué par un signal externe utilisant RTC_IO"); break;
        case ESP_SLEEP_WAKEUP_EXT1 : Serial.println("Réveil provoqué par un signal externe utilisant RTC_CNTL"); break;
        case ESP_SLEEP_WAKEUP_TIMER : Serial.println("Réveil provoqué par la minuterie"); break;
        case ESP_SLEEP_WAKEUP_TOUCHPAD : Serial.println("Réveil causé par le pavé tactile"); break;
        case ESP_SLEEP_WAKEUP_ULP : Serial.println("Réveil provoqué par le programme ULP"); break;
        default : Serial.printf("Le réveil n'a pas été causé par le sommeil profond : %d\n",wakeup_reason); break;
      }
    }
    void print_GPIO_wake_up(){
      String str;	
      uint64_t GPIO_reason = esp_sleep_get_ext1_wakeup_status();
      Serial.print("GPIO that triggered the wake up: GPIO ");
      Serial.println((log(GPIO_reason))/log(2), 0);
      str = ToString(((log(GPIO_reason))/log(2), 0)) //<====
      switch str
      case "32": loraMessage("1"); break;
      case "33": loraMessage("2"); break;
      case "13": loraMessage("3"); break;
      default : Serial.printf("Aucun GPIO n'a déclenché le réveil :"); break;
    }
    Les boutons sont désormais reconnus
    mais j'ai un blocage à la compilation sur :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    str = ToString(((log(GPIO_reason))/log(2), 0))
    je ne vois comment extraire la valeur GPIO pour me permettre d'envoyer le message

  15. #15
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 882
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 882
    Par défaut
    un truc comme

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    int pinNb = (int)(log(GPIO_reason)/log(2));
    ça vous donne un nombre. Si vous vous voulez une String vous pouvez faire

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    String str = String(pinNb);
    mais le log est couteux... on peut faire mieux avec une approche purement au niveau des bits par exemple avec bitRead()
    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
     
    void setup() {
      Serial.begin(115200);
     
      uint64_t mask = 1ULL << GPIO_NUM_33;
      Serial.print("GPIO_NUM_33 vaut "); Serial.print(GPIO_NUM_33);
      Serial.print(" ==> BUTTON_PIN_BITMASK 0x"); Serial.println(1ULL << GPIO_NUM_33, HEX);
     
      int pos = 63;
      while (pos >= 0)
        if (bitRead(mask, pos) == 1) break;
        else pos--;
      Serial.print("le premier bit à 1 est en position "); Serial.println(pos); // pos vaut -1 si pas trouvé
    }
     
    void loop() {}

  16. #16
    Membre éprouvé
    Inscrit en
    Juillet 2004
    Messages
    914
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 914
    Par défaut
    merci Jay M

    J'avoue ne pas être très doué en matière de conversion
    mais je n'ai pas de chance

    j'ai tenté çà :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    int val = (int)((log(GPIO_reason))/log(2), 0);
    et il m'a repondu çà :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    value computed is not used [-Werror=unused-value]
    j'ai du mal à comprendre pourquoi ?

  17. #17
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 882
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 882
    Par défaut
    désolé, copier coller malheureux -> le , 0 n'at rien à faire là...

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    int val = (int) (log(GPIO_reason) / log(2));
    je préfère la version avec la boucle while et bitRead...

  18. #18
    Membre éprouvé
    Inscrit en
    Juillet 2004
    Messages
    914
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 914
    Par défaut
    Merci vous sauvez là ...

    je préfère la version avec la boucle while et bitRead...
    pour moi au contraire c'est plus compliqué car je ne comprends pas la raison d'aller compter le nb de bytes
    pour en extraire la PIN

    la solution que vous m'avez donnée fonctionne bien
    voici le croquis corrigé

    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
     
    #include <LoRa.h>
    #include <SPI.h>
    #include <Wire.h>
     
    //Libraries for OLED Display
    #include "SSD1306.h" 
     
    // Optionally include custom images
    #include "images.h"
    #include "boards.h"
     
    //Librairies Bouton
    #include <OneButton.h> //  http://www.mathertel.de/Arduino/OneButtonLibrary.aspx
     
    /*
    #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
    */
     
     
    SSD1306Wire display(0x3c, I2C_SDA, I2C_SCL);
     
    const byte pinBouton1 = 32;
    //#define BUTTON1_PIN_BITMASK 0x100000000 // 2^32 in hex
    const byte pinBouton2 = 33;
    //#define BUTTON2_PIN_BITMASK 0x200000000 // 2^33 in hex
    const byte pinBouton3 = 13;
    //#define BUTTON3_PIN_BITMASK 0x20000 // 2^13 in hex
     
     
    #define BUTTON_PIN_BITMASK 0x300002000 // 13-32-33 in hex
     
    RTC_DATA_ATTR int bootCount = 0;
     
    OneButton sw1(pinBouton1);
    int value1;
    OneButton sw2(pinBouton2);
    int value2;
    OneButton sw3(pinBouton3);
    int value3;
     
    // mesure tension d'alimentation d'un ESP32
    extern "C" int rom_phy_get_vdd33();
     
    // 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");}
     
    // CALLBACKS BOUTON 3
    void sw3Click()       {loraMessage("3");}
    void sw3DoubleClick() {loraMessage("31");}
    //void sw3DebutLong()   {loraMessage("3D");}
    void sw3FinLong()     {loraMessage("3F");}
     
    //**********************************************
    // 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.drawString(0 , 15 , "Emetteur: OK");
      display.display();
      delay(100);
     
     
      //Increment boot number and print it every reboot
      ++bootCount;
      Serial.println("Boot number: " + String(bootCount));
     
      //Print the GPIO used to wake up
      print_GPIO_wake_up(); 
     
      // BTN1
      sw1.attachClick(sw1Click);
      sw1.attachDoubleClick(sw1DoubleClick);
      sw1.attachLongPressStart(sw1DebutLong);
      sw1.attachLongPressStop(sw1FinLong);
     
      // BTN2
      sw2.attachClick(sw2Click);
      sw2.attachDoubleClick(sw2DoubleClick);
      sw2.attachLongPressStart(sw2DebutLong);
      sw2.attachLongPressStop(sw2FinLong);
     
      // BTN3
      sw3.attachClick(sw3Click);
      sw3.attachDoubleClick(sw3DoubleClick);
      sw3.attachLongPressStart(sw3DebutLong);
      sw3.attachLongPressStop(sw3FinLong);
     
     
      esp_sleep_enable_ext1_wakeup(BUTTON_PIN_BITMASK,ESP_EXT1_WAKEUP_ANY_HIGH);
     
      //Go to sleep now
      Serial.println("Going to sleep now");
      delay(500);
      esp_deep_sleep_start();
      Serial.println("This will never be printed");
    }
     
    //**********************************************
    // LOOP
    //**********************************************
    void loop() {
     
     
    }
     
    //************************************************
     static void sw3DebutLong(){
     float voltage = (rom_phy_get_vdd33());
     Serial.println(voltage);
     display.clear();
     display.setTextAlignment(TEXT_ALIGN_LEFT);
     display.setFont(ArialMT_Plain_16);
     display.drawString(0 , 15 , String("Vbat: ")+ (voltage/100)+String("V"));
     display.display();
     delay(2000);
     
    }  
     
    //***********************************************
    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));
      Serial.println(val);
      switch (val)
      {
      case 32: loraMessage("1"); break;
      case 33: loraMessage("2"); break;
      case 13: loraMessage("3"); break;
      default : Serial.printf("Aucun GPIO n'a déclenché le réveil :"); break;
      }
    }

  19. #19
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 882
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 882
    Par défaut
    Citation Envoyé par cobra38 Voir le message
    pour moi au contraire c'est plus compliqué car je ne comprends pas la raison d'aller compter le nb de bytes
    pour en extraire la PIN
    C'est rare que quelqu'un soit à l'aise avec les logarithmes naturels (base 10) et la formule qui permet d'extraire à quelle puissance de 2 correspond un nombre - et la précision du log et des calculs en nombre flottant fait que ça pourrait conduire à un souci en cas d'arrondi sur une plateforme 8 bits par exemple

    pour comprendre ce que je disais, et pour faire simple, prenez un nombre sur un octet, entre 0 et 255 donc. Cet octet a 8 bits, chaque bit correspond à une puissance de 2.
    le bit 0 correspond à 20 = 1
    le bit 1 correspond à 21 = 2
    le bit 2 correspond à 22 = 4
    le bit 3 correspond à 23 = 8
    le bit 4 correspond à 24 = 16
    le bit 5 correspond à 25 = 32
    le bit 6 correspond à 26 = 64
    le bit 7 correspond à 27 = 128

    si vous codez une puissance de 2 dont l'exposant est entre 0 et 7 (soit 1, 2, 4, 8, 16, 32, 64, 128) alors vous n'avez qu'un seul '1' dans la représentation binaire de cette valeur

    par exemple 64 sera en binaire 0100 0000 ou encore 4 sera 0000 0100le masque que vous bâtissez correspond à cela. Si vous voulez un masque sur la pin 0, vous mettez le bit 0 à 1 donc la valeur 20. Si vous voulez un masque sur la pin 3 vous codez 23 dans votre masque

    pour trouver la puissance de 2, il faut donc trouver quel est le bit qui est à 1 par exemple en partant de la gauche (donc du bit en position 7 qui correspond à 27 ) et extraire le bit à cette position. Si c'est un '1' on a trouvé, sinon on continue en essayant en position 6 puis 5 puis 4 etc..

    mon code
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
      int pos = 63;
      while (pos >= 0)
        if (bitRead(mask, pos) == 1) break;
        else pos--;
      Serial.print("le premier bit à 1 est en position "); Serial.println(pos); // pos vaut -1 si pas trouvé
    faisait la même chose, mais comme le masque était sur 64 bits, on commençait en position 63

  20. #20
    Membre éprouvé
    Inscrit en
    Juillet 2004
    Messages
    914
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 914
    Par défaut
    Encore Merci Jay M
    pour cette explication

    voici pour l'émetteur la dernière version qui a l'air de fonctionnée
    j'ai procédé à quelques dernières modifications
    et ajouter comme vous le disiez le niveau batterie en PIN35 ( avec 2 résistances de 100K pour le pont)

    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
    194
     
    /*************************************/
    //    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
     
    /**************************************/
     
    #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 byte pinBouton3 = 13;
    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 60 /* Time ESP32 will go to sleep (in seconds) */
     
    RTC_DATA_ATTR int bootCount = 0;
     
    OneButton sw1(pinBouton1);
    int value1;
    OneButton sw2(pinBouton2);
    int value2;
    OneButton sw3(pinBouton3);
    int value3;
     
    float VBAT;  // battery voltage from ESP32 ADC read
     
    // 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");}
     
    // CALLBACKS BOUTON 3
    void sw3Click()       {loraMessage("3");}
    void sw3DoubleClick() {loraMessage("31");}
    void sw3DebutLong()   {loraMessage("3D");}
    void sw3FinLong()     {loraMessage("3F");}
     
    //**********************************************
    // SETUP
    //**********************************************
    void setup() {
      Serial.begin(115200);
      initBoard();
      pinMode(vbatPin, INPUT);  
      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);
      sw1.attachDoubleClick(sw1DoubleClick);
      sw1.attachLongPressStart(sw1DebutLong);
      sw1.attachLongPressStop(sw1FinLong);
     
      // BTN2
      sw2.attachClick(sw2Click);
      sw2.attachDoubleClick(sw2DoubleClick);
      sw2.attachLongPressStart(sw2DebutLong);
      sw2.attachLongPressStop(sw2FinLong);
     
      // BTN3
      sw3.attachClick(sw3Click);
      sw3.attachDoubleClick(sw3DoubleClick);
      sw3.attachLongPressStart(sw3DebutLong);
      sw3.attachLongPressStop(sw3FinLong);
     
      //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;
      case 13:
      loraMessage("3");
      AffVBAT();
      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 AffVBAT() {
      // Battery Voltage
      VBAT = (float)(analogRead(vbatPin)) / 4095*2*3.3*1.1;
      Serial.println("Vbat = "); Serial.print(VBAT); Serial.println(" Volts");
      display.clear();
      drawFontFaceDemo(VBAT);
      display.display();
      delay(1000);
    }
     
    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("4");
          break;
          default : Serial.printf("Réveil pas causé par le Deep Sleep: %d\n",source_reveil); break;
       }
    }
    je pense que mon problème a donc été résolu à savoir la fonctionnalité de la Librairie OneButton.h
    Je clôture donc le post mais je suis loin d'en avoir fini avec le projet

    Je me répète mais merci encore de votre patience

+ Répondre à la discussion
Cette discussion est résolue.
Page 1 sur 2 12 DernièreDernière

Discussions similaires

  1. Utilisation de la librairie JEDI ...
    Par HaldriX dans le forum Composants VCL
    Réponses: 7
    Dernier message: 04/03/2006, 09h38
  2. Utilisation de la librairie LTI
    Par gids01 dans le forum MFC
    Réponses: 1
    Dernier message: 14/12/2005, 14h34
  3. Réponses: 4
    Dernier message: 13/10/2005, 12h41
  4. [Débutant] utilisation de la librairie windows
    Par tavman dans le forum Windows
    Réponses: 12
    Dernier message: 27/08/2005, 16h21
  5. Utilisation de la librairie ng sous FreeBSD
    Par Mercenary Developer dans le forum Autres éditeurs
    Réponses: 3
    Dernier message: 07/12/2004, 09h39

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