ESP32 et BLE

**cobra38** · 18/05/2024, 20h37

J'ai modifié comme suit :

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
 
RTC_DATA_ATTR uint8_t etat[] = {0,0,0,0,0,0,0,0,0};
....
int buttonX = 20;
  int buttonY = 20;
  for (int i = 0; i < 9; ++i)
  {
    buttons[i].x = buttonX;
    buttons[i].y = buttonY;
    //buttons[i].state = false;
	buttons[i].state = etat[i]; // <=================================
 
 
    // Affichage des boutons
    drawButton(buttonX, buttonY, buttons[i].state);
 
    buttonX += BUTTON_WIDTH + BUTTON_MARGIN;
    if (buttonX + BUTTON_WIDTH > tft.width()) {
      buttonX = 20;
      buttonY += BUTTON_HEIGHT + BUTTON_MARGIN;
    }
  }

puis

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
void loop()
{
  currentTime=millis();
 
	  // Vérifie si l'écran tactile a été touché et imprime les informations X, Y et la pression (Z) sur l'écran TFT et le moniteur série.
	  if (touchscreen.tirqTouched() && touchscreen.touched())
	  {
		previousTime=currentTime;  
		// Get Touchscreen points
		TS_Point p = touchscreen.getPoint();
		// Calibrate Touchscreen points with map function to the correct width and height
		touchX = map(p.x, 200, 3700, 1, SCREEN_WIDTH);
		touchY = map(p.y, 240, 3800, 1, SCREEN_HEIGHT);
		touchZ = p.z;

		//printTouchToSerial(touchX, touchY, touchZ);

		for (int i = 0; i < 9; ++i)
		{
		  if (touchX >= buttons[i].x && touchX <= buttons[i].x + BUTTON_WIDTH &&
			  touchY >= buttons[i].y && touchY <= buttons[i].y + BUTTON_HEIGHT)
		  {
			// Si un bouton est touché, inverse son état et met à jour l'affichage
			buttons[i].state = !buttons[i].state;
			drawButton(buttons[i].x, buttons[i].y, buttons[i].state);
			if (buttons[i].state == 1) {
			  Serial.print("Btn "); Serial.print(i + 1); Serial.println(" enfoncé");
			  snprintf(myData.a, sizeof myData.a, "PC%02d=> ON", i + 1);
			  myData.b =  true;
			  esp_err_t result = esp_now_send(clients[i].adresse, (uint8_t *)&myData, sizeof(myData));
			  if (result == ESP_OK) {
				Serial.print("PC"); Serial.print(i + 1); Serial.println(" Envoyé avec succès");
				etat[i] = 1; <================================================
			  } else {
				Serial.print("Erreur d'envoi des données PC"); Serial.print(i + 1);
			  }
			}

			if (buttons[i].state == 0)
			{
			  Serial.print("Btn "); Serial.print(i + 1); Serial.println(" relaché");
			  snprintf(myData.a, sizeof myData.a, "PC%02d=> OFF", i + 1);
			  myData.b =  false;
			  esp_err_t result = esp_now_send(clients[i].adresse, (uint8_t *)&myData, sizeof(myData));
			  if (result == ESP_OK) {
				Serial.print("PC"); Serial.print(i + 1); Serial.println(" Envoyé avec succès");
				etat[i] = 0;  // <=================================================
			  } else {
				Serial.print("Erreur d'envoi des données PC"); Serial.print(i + 1);
			  }
			}
		  }
		  //break;
		  delay(200);
		}
	  }
	   if((currentTime-previousTime)>10000){  
	   //Go to sleep now
         Serial.println("Je vais m'endormir maintenant");
         delay(1000);
         esp_deep_sleep_start();  
	   }  
}

et çà fonctionne , j'ai bien une mise en mémoire des états de chaque boutons

**Jay M** · 19/05/2024, 18h42

il suffisait sans doute de mettre le tableau de structures en RTC_DATA_ATTR

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
// Structure pour représenter un bouton
struct Button {
  int x, y;
  bool state;
};
 
RTC_DATA_ATTR Button buttons[9]; // 9 boutons

**cobra38** · 19/05/2024, 20h46

ah oui , effectivement je n'y avais pas pensé

la seule contrainte est bien de déclarer la structure avant

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
// Structure pour représenter un bouton *************
struct Button {
  int x, y;
  bool state;
};

puis de faire appel à :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
RTC_DATA_ATTR Button buttons[9]; // 9 boutons

sinon plantage à la compilation

**Jay M** · 20/05/2024, 11h23

oui c'est une règle générale du C++
on ne peut utiliser que quelque chose qui a été déclarée avant sinon le compilateur ne comprend pas ce que l'on veut faire

**cobra38** · 20/05/2024, 15h14

Bonjour Jay M

o

ui c'est une règle générale du C++
on ne peut utiliser que quelque chose qui a été déclarée avant sinon le compilateur ne comprend pas ce que l'on veut faire

Quelque part çà semble logique mais ma question était plutôt orientée sur le fait qu'il s'agit ici d'une structure et non pas d'une variable
que l'on peut dimensionner directement dès l'appel comme par ex :
RTC_DATA_ATTR int bootCount = 0;

par contre mon problème du jour se situe plus sur la consommation de l’émetteur (ma bête noire)
celui-ci consomme env 170mA (!) lorsque l'écran est allumé puis normalement plus rien en mode sommeil (15µA )
comme je n'arrive pas à le mesurer j'ai mis un bargraph du niveau batterie

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
 
void Affich_vBat() 
{
  // Niveau batterie ************************************************
    int valeurBrute = analogRead(vbatPin);
    Serial.print(" Valeur Brute = "); Serial.println(valeurBrute); 
    vBat = 1.37*(valeurBrute/4095.0)*3.3; // modification changement carte uPesy Vbat Brute = 3804 pour 100%
    progress = ((vBat-3.2)*100);
    Serial.print(" Vbat = "); Serial.print(vBat,1);Serial.println(" Volts"); 
    Serial.print(" % = "); Serial.println(progress); 
    if (progress != LastPercent){
      drawBar(progress);     
    }
 
}
 
void drawScale(){  
 
  tft.drawFastVLine(300, 50,100, SCALECOLOR );  // Vertical Scale Line  
  tft.drawFastHLine(297, 50, 8,  SCALECOLOR);   // Major Division
  tft.drawFastHLine(300, 75, 5,  SCALECOLOR);   // Major Division
  tft.drawFastHLine(297, 100, 8,  SCALECOLOR);   // Minor Division
  tft.drawFastHLine(300, 125, 5,  SCALECOLOR);   // Major Division
  tft.drawFastHLine(297, 150, 8,  SCALECOLOR);   // Minor Division
 
}
 
void drawBar (int progress){
 
  if(progress < LastPercent){
    tft.fillRect(305, 50 + (100-LastPercent), 20, LastPercent - progress,  BACKCOLOR);     
  }
  else{
    tft.fillRect(305, 50 + (100-progress), 20, progress - LastPercent,  BARCOLOR);
  }    
  LastPercent = progress;  
  tft.setCursor(300,40);
  tft.setTextFont(1);
  tft.setTextSize(1);
  tft.setTextColor(TFT_WHITE, TFT_BLACK);
  tft.print(progress);tft.println("%");
 
}

mais de mémoire il me semble que l'on peut en mode sommeil inhiber toutes les entrées GPIO non utilisées
mais je me souviens plus de la façon de procéder

**Jay M** · 21/05/2024, 11h54

Envoyé par cobra38

Quelque part çà semble logique mais ma question était plutôt orientée sur le fait qu'il s'agit ici d'une structure et non pas d'une variable
que l'on peut dimensionner directement dès l'appel comme par ex :
RTC_DATA_ATTR int bootCount = 0;

Une variable de type structure est comme les autres... Le compilateur connait le type et donc est capable de définir le nombre d'octets nécessaire pour représenter cette variable.

L'attribut RTC_DATA_ATTR dit simplement au compilateur que l'on veut stocker les octets représentant la variable dans un espace mémoire plutôt qu'un autre (celui qui reste alimenté lors du sommeil profond).

Envoyé par cobra38

de mémoire il me semble que l'on peut en mode sommeil inhiber toutes les entrées GPIO non utilisées
mais je me souviens plus de la façon de procéder

vous pouvez basculer les pins en INPUT avant le deep sleep par exemple. Il faut aussi arrêter le wifi et le bluetooth si utilisés

comment alimentez vous l'écran ? avez vous moyen de "couper le courant" ? (il ne s'agit pas d'arrêter uniquement le rétro-éclairage pour couper toute consommation)

**cobra38** · 21/05/2024, 12h12

Bonjour Jay M

comment alimentez vous l'écran ?

L'ESP32 est alimenté par une batterie LiPo 3.7v d'une capacité d'env 1000mAh
chaque appui sur le TPP223 consomme durant 5s => 170 mA ( Wifi etc )

avez vous moyen de "couper le courant" ? (il ne s'agit pas d'arrêter uniquement le rétro-éclairage pour couper toute consommation)

l'écran est alimenté via GPIO021 de fait lorsque l'ESP32 passe en deep-sleep , l'écran s'éteint normalement mais non je n'ai pas de moyen externe pour couper l'écran
par ailleurs j'ai fait l'expérience hier :
j'ai chargé la batterie à 100% , la tension au voltmètre m'indiquait 4,19V
ce matin elle m'indiquait 4,18v , ce qui tant à prouver que la consommation reste somme toute minime

par contre je n'arrive pas correctement à afficher la mesure vBat , en effet , l'appel sur le bouton entraine un fort pic de courant durant 5s
comme le calcul et l'affichage se font durant le "setup" la valeur indiquée n'est pas celle réelle de la batterie
j'ai donc séparé le calcul et l'affichage mais ce n'est pas vraiment probant
je suis preneur de conseil ...

**Jay M** · 21/05/2024, 15h04

l'écran est alimenté via GPIO021

une pin n'est généralement pas une bonne source de courant ! voulez vous dire que c'est un pin "enable" et qu'il y a un VCC par ailleurs ?

est-ce que votre module dispose bien d'un vbatPin qui fait la mesure ?

**cobra38** · 21/05/2024, 15h16

une pin n'est généralement pas une bonne source de courant ! voulez vous dire que c'est un pin "enable" et qu'il y a un VCC par ailleurs ?

oui pardon , mauvaise formulation , il s'agit bien de GPIO021 où est raccordée la LED mais l'écran lui est alimenté en 3.3v à partir de l'ESP32

est-ce que votre module dispose bien d'un vbatPin qui fait la mesure ?

Oui , une entrée lui est dédiée GPIO35

je calcule vBat de cette façon :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
void Calcul_vBat(){
    int cmpt = 8;
    int vBatOld = 0 ; 
    do {
       cmpt--;
       valeurBrute  = analogRead(vbatPin); // tension échantillonnée brute
       vBatOld = valeurBrute;
    } while((abs(valeurBrute-vBatOld) > DELTA) && (cmpt > 0));
    vBat = 1.40*(valeurBrute/4095.0)*3.3; // modification changement carte uPesy Vbat Brute = 3804 pour 100%
    progress = ((vBat-3.2)*100);
}

ESP32 et BLE

Arduino

Discussions similaires

Partager

Partager