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 :

Comment transférer ma mesure ESP32 Lora ?


Sujet :

Arduino

  1. #1
    Membre éprouvé
    Inscrit en
    Juillet 2004
    Messages
    954
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 954
    Par défaut Comment transférer ma mesure ESP32 Lora ?
    Bonjour à tous

    j'aurai besoin de votre éclairage pour transférer désormais ma mesure VBAT
    issue d'un calcul interne à l'ESP32 à savoir :
    Pont de mesure 2x 100kOhms sur PIN35
    cette mesure varie de 3,40v -> 2,9V

    Je transmets déjà actuellement 4 messages différents

    sur interruptions EXT1
    - 1 , 2 pour les alarmes et 3 Btn acquit
    sur Timer 60s
    - 4 pour tester la liaison

    ceux sont là des messages simples que vous m'avez aidés à décrypter en réception
    selon vous comment devrai-je faire pour transmettre cette mesure VBAT calculée à l'aide de :
    car ce n'est pas une mesure analogique d'entrée comme pour l'être un capteur externe par ex

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
     VBAT = (float)(analogRead(vbatPin)) / 4095*2*3.3*1.1;
    je remets le croquis de l’émetteur pour aider à la compréhension


    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
     
    /*************************************/
    //    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> //  <a href="http://www.mathertel.de/Arduino/OneButtonLibrary.aspx" target="_blank">http://www.mathertel.de/Arduino/OneButtonLibrary.aspx</a>
     
    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();
      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 <a href="http://oleddisplay.squix.ch/" target="_blank">http://oleddisplay.squix.ch/</a>
        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(2000);
    }
     
    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;
       }
    }
    pardonnez moi mais je construis mon projet par petit bout à la fois
    merci par avance pour votre compréhension

  2. #2
    Expert confirmé

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

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 899
    Par défaut
    il suffit d'écrire une fonction envoiVbat()
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    void envoiVbat() {
      const int tailleMax = 20; // y compris le '\0' de fin
      static char vBatMessage[tailleMax];                                 // doit être assez grand pour contenir le message
      float vBat = analogRead(vbatPin) / 4095.0 * 2.0 * 3.3 * 1.1;        // Battery Voltage
      int n = snprintf(vBatMessage, sizeof vBatMessage, "V%.2f", vBat);   // 'V' suivi de la tension avec deux chiffres après la virgule
      if ((n > 0) && (n < tailleMax))                                     // si on a pu écrire correctement le message
        loraMessage(vBatMessage);                                         //   alors envoi du message
    }
    et vous l'appelez quand vous avez besoin d'envoyer cette tension.

    côté récepteur, si le premier caractère du message reçu est 'V' alors ce qui suit est un nombre décimal qui représente la tension.

    Notez que pour ne pas perdre de précision vous pourriez aussi décider d'émettre juste la valeur du analogRead(vbatPin) (entre 0 et 4095) et appliquer la formule mathématique de l'autre côté.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    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
      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
    }

  3. #3
    Membre éprouvé
    Inscrit en
    Juillet 2004
    Messages
    954
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 954
    Par défaut
    Merci Jay M

    Je progresse doucement ...
    J'ai donc, comme vous l'avez suggéré, transféré une valeur brute vers le récepteur
    pour permettre la lecture , j'ai mis le code suivant

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
     
    case 'V':
               if (BAL == 0) {
               char buffer[packetSize + 1]; // +1 pour mettre un caractère nul à la fin
    	   size_t position = 0;
    	   while (LoRa.available()) buffer[position++]=(char)LoRa.read();
                  buffer[position]*= '\0';
    	      Serial.print("Valeur Brute: "); Serial.println(buffer);	
               }
    la console me donne çà :

    La lecture me dit : V2419
    soit une valeur brute de 2419 => 2419/4096 * 2 * 3.3 * 1.1 = 4,28V ( Branchement direct USB)

    il me reste donc à extraire (char)LoRa.read(); pour afficher la valeur
    et là ...
    Images attachées Images attachées  

  4. #4
    Expert confirmé

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

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 899
    Par défaut
    Quand vous faites
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
     case 'V':
               if (BAL == 0) {
               char buffer[packetSize + 1]; // +1 pour mettre un caractère nul à la fin
    	   size_t position = 0;
    	   while (LoRa.available()) buffer[position++]=(char)LoRa.read();
                  buffer[position]*= '\0';
    	      Serial.print("Valeur Brute: "); Serial.println(buffer);	
               }
    buffer contient la représentation ASCII de votre valeur non ? le V a déjà été lu si je me souviens bien de l'autre code... (pouvez vous le poster en entier, c'est mieux que des bouts de code)

    dont il suffit de faire int valeurBrute = atoi(buffer); pour avoir la valeur sous format entier. (cf https://cplusplus.com/reference/cstdlib/atoi/)

    Il ne faut pas faire d'autres LoRa.read(); puisqu'on a vidé le buffer de réception lora dans le while du dessus pour construire notre variable tableau de caractères buffer.

  5. #5
    Membre éprouvé
    Inscrit en
    Juillet 2004
    Messages
    954
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 954
    Par défaut
    Merci encore Jay M


    mais désolé je ne pige pas , à partir du vidage buffer j'obtiens bien par ex : V2375
    mais je ne parviens pas à en extraire la partie numérique
    je mets le code complet

    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
    #include <LoRa.h>
    #include <SPI.h>
    
    //Libraries for Wifi
    #include <WiFi.h>
    #include <WiFiClient.h>
    #include <WiFiAP.h>
    #include "secret.h"
    
    
    //Libraries for OLED Display
    #include "SSD1306.h" 
    #include "boards.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
    SSD1306Wire display(0x3c, I2C_SDA, I2C_SCL);
    
    // LED definition
    #define LED1   32  // Volet BAL
    #define LED2   33  // Porte BAL
    #define LED3   13  // Acquitement 
    
    
    char ssid[] = SECRET_SSID;   // your network SSID (name) 
    char pass[] = SECRET_PASS;   // your network password
    int keyIndex = 0;            // your network key Index number (needed only for WEP)
    WiFiClient  client;
    
    unsigned long previousMillis = 0; 
    const long interval = 30000;
    int VBAT = 0; 
    byte BAL = 0;
    
    //*****************************
    // SETUP
    //*****************************
    void setup() {
      Serial.begin(115200);
      initBoard();
      display.flipScreenVertically();
      display.setFont(ArialMT_Plain_10);
      
      while (!Serial) yield();
      SPI.begin(SCK,MISO,MOSI,SS);
      LoRa.setPins(SS,RST,DI0);
      Serial.println("LoRa Receiver");
      if (!LoRa.begin(433E6)) { 
        Serial.println("Starting LoRa failed!");
        while (true) yield();
      }
      
      display.init();
      display.flipScreenVertically();  
      display.setFont(ArialMT_Plain_10);
      display.drawString(0 , 15 , "Recepteur: OK");
      display.display();
      delay(100);
        
      pinMode(LED1, OUTPUT);
      pinMode(LED2, OUTPUT);
      pinMode(LED3, OUTPUT);
      
      
      digitalWrite(LED1, LOW);
      digitalWrite(LED2, LOW);
      digitalWrite(LED3, LOW);
      
      
      WiFi.mode(WIFI_STA);
     
        
    }
    
    
    //******************************
    //  LOOP
    //******************************
    void loop() {
        
        if (WiFi.status() != WL_CONNECTED) {
        Serial.print("Attempting to connect to SSID: ");
        Serial.println(SECRET_SSID);
          while (WiFi.status() != WL_CONNECTED) {
            WiFi.begin(ssid, pass); // Connect to WPA/WPA2 network. Change this line if using open or WEP network
            Serial.print(".");
            delay(5000);
          }
        Serial.println("\nConnected.");
        } 	
    	
      int packetSize = LoRa.parsePacket();
      if (packetSize) 
       {
    		char buffer[packetSize + 1]; // +1 pour mettre un caractère nul à la fin
    		size_t position = 0;
    		// on récupère le message dans le buffer
    		while (LoRa.available()) buffer[position++]=(char)LoRa.read();
    				
    		// on termine le message (on suppose que c'est de l'ASCII)
    		buffer[position]*= '\0';
    		// On imprime le message
    		Serial.print("Reception: "); Serial.println(buffer);
    				
    			switch (buffer[0]) {
    			  case '1': 
    						Serial.println("Ouverture Volet");
    						digitalWrite(LED1,HIGH);
    						delay(500);
    						digitalWrite(LED1,LOW);
    						delay(50);
    						digitalWrite(LED3,HIGH);
    						
    						delay(50);
    						BAL = 1;
    						//IOT_Etat();
    						/**************************************/
    						display.clear();
    						display.setFont(ArialMT_Plain_24);
    						display.setTextAlignment(TEXT_ALIGN_CENTER);
    						display.drawString(64, 22, "COURRIER");
    						display.drawHorizontalLine(0,24,127);
    						display.drawHorizontalLine(0,46,127);
    						display.display();	
    						/*************************************/ 
    						break;
    				case '2':
    						Serial.println("Ouverture Porte");
    						digitalWrite(LED2,HIGH);
    						delay(500);
    						digitalWrite(LED2,LOW);
    						delay(50);
    						digitalWrite(LED3,HIGH);
    						delay(50);
    						BAL = 1;
    						//IOT_Etat();					
    						/**************************************/
    						display.clear();
    						display.setFont(ArialMT_Plain_24);
    						display.setTextAlignment(TEXT_ALIGN_CENTER);
    						display.drawString(64, 22, "COLIS");
    						display.drawHorizontalLine(0,24,127);
    						display.drawHorizontalLine(0,46,127);
    						display.display();	
    						/*************************************/ 
    						break;
    				case '3':
    						Serial.println("Courrier Present");
    						digitalWrite(LED3,LOW);
    						delay(50);
    						display.clear();
    						display.display();
    						BAL = 0;
    						//IOT_Etat();
    						break;
    				/*		
    				case '4':
    				        if (BAL == 0) {
    						Serial.println("Test Liaison");
    						digitalWrite(LED3,HIGH);
    						delay(500);
    						digitalWrite(LED3,LOW);
    						delay(50);
    						}
    						break;	
    				*/		
    				case 'V':
                                                    if (BAL == 0) {
    						int valeurBrute = int(atoi(buffer));
    						VBAT = (valeurBrute / 4096 )*2*3.3*1.1;
    						Serial.println(VBAT);
                                                     } 							
    				default:
    					break;
    				}
    						
       }  
    }
    si par exemple j'ai

    15:09:15.707 -> Réception: V2375
    15:09:15.707 ->
    15:09:15.707 -> 0 <=================

    J'obtiens 0 à cause de la présence du symbole "V" que je n'arrive pas extraire

  6. #6
    Expert confirmé

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

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 899
    Par défaut
    ah je ne me souvenais plus du code que j'avais écrit

    quand vous faites
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    if (packetSize)
      {
        char buffer[packetSize + 1]; // +1 pour mettre un caractère nul à la fin
        size_t position = 0;
        // on récupère le message dans le buffer
        while (LoRa.available()) buffer[position++] = (char)LoRa.read();
    vous avez récupéré dans buffer tout le message, par exemple "V2375"
    le switch que vous faites
    teste le premier caractère et donc on peut dire que si ce premier caractère est 'V' alors on peut décoder la suite qui EST DEJA dans le buffer
    ==> donc
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
           case 'V':
            int valeurBrute = atoi(buffer+1); // +1 pour sauter le 'V' et commencer à analyser à partir du premier chiffre 
            VBAT = (valeurBrute / 4096.0 ) * 2.0 * 3.3 * 1.1;
            Serial.println(VBAT);
            break; // ne pas oublier le break

  7. #7
    Membre éprouvé
    Inscrit en
    Juillet 2004
    Messages
    954
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 954
    Par défaut
    Merci Jay M

    J'ai juste du mettre
    en lieu et place de
    sinon je n'avais pas de mesure
    maintenant c'est nickel

  8. #8
    Expert confirmé

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

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 899
    Par défaut
    vous n'avez pas du voir ma petite modification discrète


    vous aviez écrit
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
     VBAT = ( valeurBrute / 4096 ) * 2 * 3.3 * 1.1;
    et moi
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
     VBAT = (valeurBrute / 4096.0 ) * 2.0 * 3.3 * 1.1;
    vous voyez la différence?

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

    Si, si je l'avais bien vu, noté et appliqué mais non expliqué
    mais çà ne fonctionnait pas pour moi , j'ai donc procédé à la modification précitée
    en plus j'y ai rajouté une liaison Blynk pour la visu de la décharge batterie et les alarmes associées
    et çà a l'air de fonctionner
    le dernier problème n'est pas lié à Arduino mais simplement à l'interface d'entrée à savoir
    "comment générer un 1 sur chaque entrée tout en ne vidant pas la batterie si celui-ci reste coincé ...."

    voici le dernier croquis à ce jour
    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
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
     
    #include <LoRa.h>
    #include <SPI.h>
     
    //Libraries for Wifi
    #include <WiFi.h>
    #include <WiFiClient.h>
    #include <WiFiAP.h>
    #include "secret.h"
    #include <BlynkSimpleEsp32.h>
     
    //Libraries for OLED Display
    #include "SSD1306.h" 
    #include "boards.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
    SSD1306Wire display(0x3c, I2C_SDA, I2C_SCL);
     
    // LED definition
    #define LED1   32  // Volet BAL
    #define LED2   33  // Porte BAL
    #define LED3   13  // Acquitement 
     
     
    char ssid[] = SECRET_SSID;   // your network SSID (name) 
    char pass[] = SECRET_PASS;   // your network password
    int keyIndex = 0;            // your network key Index number (needed only for WEP)
    WiFiClient  client;
     
    char auth[] = BLYNK_AUTH_TOKEN;
    unsigned long previousMillis = 0; 
    const long interval = 30000;
    float VBAT = 0; 
    byte BAL = 0;
     
    //*****************************
    // SETUP
    //*****************************
    void setup() {
      Serial.begin(115200);
      initBoard();
      display.flipScreenVertically();
      display.setFont(ArialMT_Plain_10);
     
      while (!Serial) yield();
      SPI.begin(SCK,MISO,MOSI,SS);
      LoRa.setPins(SS,RST,DI0);
      Serial.println("LoRa Receiver");
      if (!LoRa.begin(433E6)) { 
        Serial.println("Starting LoRa failed!");
        while (true) yield();
      }
     
      display.init();
      display.flipScreenVertically();  
      display.setFont(ArialMT_Plain_10);
      display.drawString(0 , 15 , "Recepteur: OK");
      display.display();
      delay(100);
     
      pinMode(LED1, OUTPUT);
      pinMode(LED2, OUTPUT);
      pinMode(LED3, OUTPUT);
     
     
      digitalWrite(LED1, LOW);
      digitalWrite(LED2, LOW);
      digitalWrite(LED3, LOW);
     
     
      WiFi.mode(WIFI_STA);
      Blynk.begin(auth, ssid, pass, "blynk.cloud", 80);
     
    }
     
     
    //******************************
    //  LOOP
    //******************************
    void loop() {
     
        if (WiFi.status() != WL_CONNECTED) {
        Serial.print("Tentative de connexion WIFI : ");
        Serial.println(SECRET_SSID);
          while (WiFi.status() != WL_CONNECTED) {
            WiFi.begin(ssid, pass); // Connect to WPA/WPA2 network. Change this line if using open or WEP network
            Serial.print(".");
            delay(2000);
          }
        Serial.println("\nConnecté.");
        } 	
    	Blynk.run();
      int packetSize = LoRa.parsePacket();
      if (packetSize) 
       {
    		char buffer[packetSize + 1]; // +1 pour mettre un caractère nul à la fin
    		size_t position = 0;
    		// on récupère le message dans le buffer
    		while (LoRa.available()) buffer[position++]=(char)LoRa.read();
     
    		// on termine le message (on suppose que c'est de l'ASCII)
    		buffer[position]*= '\0';
    		// On imprime le message
    		Serial.print("Reception: "); Serial.println(buffer);
     
    			switch (buffer[0]) {
    			  case '1': 
    						Serial.println("Ouverture Volet");
    						digitalWrite(LED1,HIGH);
    						delay(500);
    						digitalWrite(LED1,LOW);
    						delay(50);
    						digitalWrite(LED3,HIGH);
     
    						delay(50);
    						BAL = 1;
    						IOT_Etat();
    						/**************************************/
    						display.clear();
    						display.setFont(ArialMT_Plain_24);
    						display.setTextAlignment(TEXT_ALIGN_CENTER);
    						display.drawString(64, 22, "COURRIER");
    						display.drawHorizontalLine(0,24,127);
    						display.drawHorizontalLine(0,46,127);
    						display.display();	
    						/*************************************/ 
    						break;
    				case '2':
    						Serial.println("Ouverture Porte");
    						digitalWrite(LED2,HIGH);
    						delay(500);
    						digitalWrite(LED2,LOW);
    						delay(50);
    						digitalWrite(LED3,HIGH);
    						delay(50);
    						BAL = 1;
    						IOT_Etat();					
    						/**************************************/
    						display.clear();
    						display.setFont(ArialMT_Plain_24);
    						display.setTextAlignment(TEXT_ALIGN_CENTER);
    						display.drawString(64, 22, "COLIS");
    						display.drawHorizontalLine(0,24,127);
    						display.drawHorizontalLine(0,46,127);
    						display.display();	
    						/*************************************/ 
    						break;
    				case '3':
    						Serial.println("Courrier Present");
    						digitalWrite(LED3,LOW);
    						delay(50);
    						display.clear();
    						display.display();
    						BAL = 0;
    						IOT_Etat();
    						break;
     
    				case 'V':
    				        if (BAL == 0) {
    							Serial.println("Test Liaison");
    							digitalWrite(LED3,HIGH);
    							delay(500);
    							digitalWrite(LED3,LOW);
    							delay(50);
    						}
    						int valeurBrute = atoi(buffer+1); // +1 pour sauter le 'V' et commencer à analyser à partir du premier chiffre 
    						VBAT = (valeurBrute / 4095.0)*2.0*3.3*1.1;
    						AffVBAT();
                           	break;						
     
    			}
     
       }  
    }
     
    //// Battery Voltage
    void AffVBAT() {
      Serial.println("Vbat = "); Serial.print(VBAT); Serial.println(" Volts");
      IOT_Etat();
      display.clear();
      drawFontFaceDemo(VBAT);
      display.display();
      delay(2000);
    }
     
     
    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, "Batterie");
        display.setFont(ArialMT_Plain_16);
        display.drawString(0, 10, "Monitoring");
        display.setFont(ArialMT_Plain_24);
        itoa(VBAT,string,10);
        sprintf(string,"%7.3f",VBAT);
        display.drawString(0, 26, string);
    }
     
    void IOT_Etat() {
      Serial.println("Envoi ...");
      Blynk.virtualWrite(V0, BAL);
      Blynk.virtualWrite(V1, VBAT);
      delay(1000);
    }
    si vous y voyez des incohérence n’hésitez pas

    merci encore ....

  10. #10
    Expert confirmé

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

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 899
    Par défaut
    Citation Envoyé par cobra38 Voir le message
    Si, si je l'avais bien vu, noté et appliqué mais non expliqué
    pour l'explication quand vous faites VBAT = ( valeurBrute / 4096 ) * 2 * 3.3 * 1.1; avec valeurBrute de type entier, comme 4096 est aussi de type entier, la division s'effectue en nombre entier. Hors valeurBrute est entre 0 et 4095 donc quand on divise par 4096 ça fait forcément 0. ensuite quand on multiplie par 2, ça fait 0 et après on passe en nombre décimal car la multiplication est par 3.3 mais c'est trop tard, le mai est fait.

    avec VBAT = (valeurBrute / 4096.0 ) * 2.0 * 3.3 * 1.1; j'ai passé me 4096 en nombre décimal et donc la division s'effectue en virgule flottante on n'a plus 0 et puisqu'on a un nombre décimal, le reste de la formule s'effectue aussi en nombre décimal. ce n'est qu'une fois le calcul réalisé que le résultat est tronqué car VBAT est un entier.

    -------------------------------------------------------


    "comment générer un 1 sur chaque entrée tout en ne vidant pas la batterie si celui-ci reste coincé ...."
    je ne comprends pas trop ce que vous voulez dire...

  11. #11
    Membre éprouvé
    Inscrit en
    Juillet 2004
    Messages
    954
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 954
    Par défaut
    il avait donc 2 astuces :
    - l'une en divisant par 4096.0 et non pas 4096
    ( par contre celle-là je suis passé au travers je suis resté à 4095 puisque l'échelle était pour moi de 0 à 4095 , je vais donc corriger)
    - l'autre le traitement en valeur décimale

    donc le fait de passer en "float" ne sert donc plus à rien , c'est noté

    je ne comprends pas trop ce que vous voulez dire...
    mon approche est certes bizarre, j'en conviens....
    mes entrées sont faites avec des capteurs magnétiques COM-NO-NC
    mais comme j'essaie d'économiser au maximum l’énergie , il faut que le maintien l'état haut d'une entrée se fasse durant un court instant,
    pour ce faire j'utilise une capacité qui se charge puis lors du basculement maintien mon entrée durant quelques secondes
    Or mes entrées étaient au départ "tirées" vers la masse et avec le pull-up ( le schéma classique)
    avec l'utilisation de la librairie tout est inversé maintenant
    les entrées à 1 sont "tirées" vers VCC et je dois donc revoir le câblage ainsi que et le type du Mosfet ou transistor associé

    voilà pourquoi j'ai fait cette remarque mais qui est un peu hors sujet
    Images attachées Images attachées  

  12. #12
    Expert confirmé

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

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 899
    Par défaut
    oui 4095.0 c'est bien

    --

    la bibliothèque OneButton supporte le pulldown, par exemple sur la pin 2 si vous instanciez avec
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     OneButton monBouton = OneButton(
      2,           // Input pin for the button
      false,       // Button is active high
      false        // Disable internal pull-up resistor
    );

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

    a bibliothèque OneButton supporte le pulldown, par exemple sur la pin 2 si vous instanciez avec
    Je ne connaissais pas le terme "PullDown" décidément ....
    Je vais essayer çà et en plus çà pourrait m'éviter, semble-t-il, de nombreuses résistances externes lors de la réalisation

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

    j'ai fait l'essai sur l'emetteur mon plus gros problème d'entré
    pour mémoire tous les boutons sont "tirés" à GND à l'aide d'une resistance de 10k
    et bien sûr raccodés à VCC

    à l'aide de la librairie OneButton, j'ai compris, peut-être à tort, que je pouvais me passer de la résistance externe

    j'ai donc mis :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    OneButton sw3(pinBouton3,false,false);
    mais visiblement dès que retire la résistance çà ne fonctionne plus
    mais serait-ce le fait que je n'utilise pas

    car il n'y rien dans la partie LOOP()
    voir le croquis

    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
     
    /*************************************/
    //    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,false,false);
    int value3;
     
    // 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 sw3DoubleClick() {loraMessage("3");}
    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.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"); 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
    }

  15. #15
    Expert confirmé

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

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 899
    Par défaut
    non la librairie ne règle pas le problème hardware
    un UNO ou Nano ne sait mettre que des pullup sur les pins en interne, c'est ce qui permet de ne pas avoir à gérer la résistance supplémentaire soi même. Mais si vous voulez fonctionner en mode pulldown alors la résistance externe est obligatoire. Le false/false dit simplement à la bibliothèque OneButton comment la pin est configurée (et si vous mettez true (valeur par défaut si vous ne dites rien) il se charge pour vous d'activer le INPUT_PULLUP)

    sur un ESP les pins sont capables d'être en input pullup ou pulldown donc on pourrait se passer de la résistance externe

  16. #16
    Membre éprouvé
    Inscrit en
    Juillet 2004
    Messages
    954
    Détails du profil
    Informations forums :
    Inscription : Juillet 2004
    Messages : 954
    Par défaut
    sur un ESP les pins sont capables d'être en input pullup ou pulldown donc on pourrait se passer de la résistance externe
    pardonnez-moi ,j'avoue ne pas en comprendre le sens
    si je pars du principe que je ne souhaite pas de résistance externe
    et que je veux un "1" lors de l'appui sur mon bouton
    comment dois-je configurer selon vous
    le terme par ex :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    OneButton sw3(pinBouton3,?,?);

  17. #17
    Expert confirmé

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

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 899
    Par défaut
    je n'ai jamais essayé mais avec un ESP32 il y a un pulldown interne donc


    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
     
    OneButton sw3(pinBouton3,false,false); // false false pour dire pas activeLow et pas de pullup
     
    void setup() {
    ... 
     sw3.attachDoubleClick(sw3DoubleClick);
    ...
      // à la fin du setup
      pinMode(pinBouton3, INPUT_PULLDOWN); // on force la pin en PULLDOWN. 
    }

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

    çà n'a pas l'air très efficace
    j'ai procédé aux modifications dans le croquis du récepteur :
    à savoir :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
     
    const int pinAQT = 35;
    OneButton AQT(pinAQT,false,false);
    int value1;
     
    .../... 
     
    void setup() {
      Serial.begin(115200);
      initBoard();
      pinMode(pinAQT,INPUT_PULLDOWN);
     
    ....
    - supprimer la résistance de 10k reliée à GND

    çà ne fonctionne pas , j'ai du me contraindre à la remettre pour que cela fonctionne
    ce n'est pas grave , ce n'est qu'un problème de PCB

  19. #19
    Expert confirmé

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

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 899
    Par défaut
    OK je n'avais jamais essayé. c'est bon à savoir

Discussions similaires

  1. Réponses: 6
    Dernier message: 23/05/2006, 13h28
  2. Réponses: 5
    Dernier message: 03/05/2006, 11h54
  3. comment transférer les données entre 2 pc?.
    Par unix27 dans le forum Administration
    Réponses: 12
    Dernier message: 10/04/2006, 07h48

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