Comment transférer ma mesure ESP32 Lora ?

Version imprimable

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:

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:

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

il suffit d'écrire une fonction envoiVbat()

Code:

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:

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
}

1 pièce(s) jointe(s)

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:

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à ...

Quand vous faites
Code:

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.

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:

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

ah je ne me souvenais plus du code que j'avais écrit :)

quand vous faites
Code:

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

Code:

switch (buffer[0]) {

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:

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

17/12/2022, 18h24
cobra38
Merci Jay M

J'ai juste du mettre
Code:

1 2 float VBAT = 0;
en lieu et place de
Code:

1 2 int VBAT = 0;
sinon je n'avais pas de mesure
maintenant c'est nickel
18/12/2022, 11h18
Jay M

vous n'avez pas du voir ma petite modification discrète

vous aviez écrit

Code:

VBAT = ( valeurBrute / 4096 ) * 2 * 3.3 * 1.1;

et moi

Code:

VBAT = (valeurBrute / 4096.0 ) * 2.0 * 3.3 * 1.1;

vous voyez la différence? :D

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:

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 ....

18/12/2022, 19h39
Jay M

Citation:

Envoyé par cobra38

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.

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

Citation:

"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...
18/12/2022, 21h13
cobra38

1 pièce(s) jointe(s)

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é

Citation:

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

oui 4095.0 c'est bien

--

la bibliothèque OneButton supporte le pulldown, par exemple sur la pin 2 si vous instanciez avec
Code:

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 );

18/12/2022, 23h11
cobra38

Merci Jay M

Citation:

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

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:

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

Code:

sw3.tick();

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

Code:

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
}

19/12/2022, 12h35
Jay M

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
19/12/2022, 13h56
cobra38

Citation:

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:

OneButton sw3(pinBouton3,?,?);

je n'ai jamais essayé mais avec un ESP32 il y a un pulldown interne donc

Code:

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. 
}

20/12/2022, 10h57
cobra38
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:

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
20/12/2022, 17h24
Jay M

OK je n'avais jamais essayé. c'est bon à savoir