Comparaison de variables

**cobra38** · 22/08/2024, 23h33

Bonjour à tous

ESP32 + librairie <Preferences.h>

Comment fait-on pour comparer 2 ces variables
Var A = variable réelle mise à jour toutes les 5 mn
Var B = variable qui est mise en mémoire avec putFloat()
puis elle est comparée avec getFloat () et à la VarA

Si VarB < VarA Led Rouge
Si VarB > VarA Led Bleue
Si VarB = VarA Led Verte

Au départ la VarB = 0 , la VarA est > VarB
mais ensuite toutes les 5mn la VarA = VarB suite aux mises à jour , çà ne fonctionne donc pas
existe-t-il un autre moyen svp ?

**Jay M** · 23/08/2024, 11h17

est-ce que varB c'est la valeur précédente de varA ?

un exemple qui compare une valeur générée périodiquement avec la valeur en mémoire et qui met à jour la valeur stockée si elle est différente

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
#include <Preferences.h>
Preferences preferences;
const char* clef = "floatValeur";
const float valeurDefaut = -100.0;            // Valeur par défaut si la clé n'existe pas
 
const unsigned long intervalle = 1000ul;      // toutes les secondes pour la démo. 5 minutes normalement
unsigned long millisPrecedent = -intervalle;  // pour commencer tout de suite à afficher sans attendre
 
void setup() {
  Serial.begin(115200);
  preferences.begin("maNamespace", false);
 
  // Vérifier si la clé existe
  if (preferences.getBytesLength(clef) == 0) {
    Serial.println("La clef n'existe pas. Création avec la valeur par défaut.");
    preferences.putFloat(clef, valeurDefaut);
  }
  float valeurStockee = preferences.getFloat(clef, valeurDefaut); // -100 valeur par défaut
  Serial.print("Valeur stockée: ");
  Serial.println(valeurStockee);
}
 
void loop() {
  unsigned long maintenant = millis();
 
  if (maintenant - millisPrecedent >= intervalle) {
    millisPrecedent = maintenant;
 
    // obtenir un nouveau float (ici aléatoire)
    float nouvelleValeur = random(0, 10000) / 100.0;
    Serial.print("Nouvelle valeur générée: ");
    Serial.println(nouvelleValeur);
 
    // Lire la valeur stockée dans les préférences
    float valeurStockee = preferences.getFloat(clef, valeurDefaut);
 
    Serial.print("Comparaison avec la valeur stockée: ");
    Serial.println(valeurStockee);
 
    if (nouvelleValeur != valeurStockee) {
      preferences.putFloat(clef, nouvelleValeur);       // Mettre à jour la valeur stockée dans les préférences
      Serial.print("Valeur mise à jour: ");
      Serial.println(nouvelleValeur);
      // on peut faire autre chose ici si la valeur a changé 
    }
  }
}

**cobra38** · 23/08/2024, 11h43

Bonjour à tous ,

pour illustrer ma demande , j'ai fait un petit croquis
en exemple

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
 
 
#include <Preferences.h>
 
Preferences prefs;
 
#define CYD_LED_BLUE 17
#define CYD_LED_RED 4
#define CYD_LED_GREEN 16
 
 
 
float VarA = 0;
float VarB = 0;
 
float val=-1; 
byte SerialOK=0;
 
unsigned long previousMillis = 0;
#define INTERVAL 60000 * 1  // 1 min
 
 
//*********************************************
//  SETUP
//*********************************************
void setup() {
 
  Serial.begin(115200);
 
  pinMode(CYD_LED_RED, OUTPUT);
  pinMode(CYD_LED_GREEN, OUTPUT);
  pinMode(CYD_LED_BLUE, OUTPUT);
 
  digitalWrite(CYD_LED_RED, HIGH); 
  digitalWrite(CYD_LED_GREEN, HIGH);
  digitalWrite(CYD_LED_BLUE, HIGH);
 
 
 
}
 
//*********************************************
//  LOOP
//********************************************* 
void loop() {
 
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis > INTERVAL) {
    previousMillis = currentMillis;
    TestMem(); 
  }	
 
}    
 
 
void Leds() {
 
  prefs.begin("Memoire", false);
  VarB = prefs.getFloat ("Memoire", VarA);
  prefs.end(); 
  Serial.print("VarB = ");
  Serial.println(VarB);
 
 
   if (VarB < VarA){
      digitalWrite(CYD_LED_RED, LOW); 
      digitalWrite(CYD_LED_GREEN, HIGH);
      digitalWrite(CYD_LED_BLUE, HIGH);
   } else if (VarB  == VarA) {
      digitalWrite(CYD_LED_RED, HIGH); 
      digitalWrite(CYD_LED_GREEN, LOW);
      digitalWrite(CYD_LED_BLUE, HIGH);
   } else if (VarB  > VarA) {
      digitalWrite(CYD_LED_RED, HIGH); 
      digitalWrite(CYD_LED_GREEN, HIGH);
      digitalWrite(CYD_LED_BLUE, LOW);
   } else {
      digitalWrite(CYD_LED_RED, HIGH); 
      digitalWrite(CYD_LED_GREEN, HIGH);
      digitalWrite(CYD_LED_BLUE, HIGH);
   } 
 
 
 
}
 
 
void TestMem() {
 
Serial.print("Saisir la valeur VarA\n");
val = -1;
while( val<0 || val>100)  { // borne inferieure et supèrieure
  int l=0; // nb de donnée à lire present sur le port serie
  char tampon[10]=""; // mémoire tampon pour la lecture serie            
  Serial.println("Veuillez saisir une valeur entre 0.00 et 100.00:");
  while(!l)  { delay(200); l=Serial.available(); } // attend la saisie d'une donnée   
  for (int i=0; i < l; i++){ tampon[i]=Serial.read(); delay(15); }  // lecture 
  val = atof(tampon); // converti en float    
}
VarA = val;
Serial.print("VarA = ");
Serial.println(VarA);
 
Leds();
 
prefs.begin("Memoire", false);
prefs.putFloat ("Memoire", VarA);
prefs.end();
 
 
}

Le principe est simple
VarA et VarB sont des valeurs qui représentent des T°
Le but étant de voir avec les Leds de couleurs si la T° augmente,diminue ou reste égale entre 2 mesures ( delai 1mn )
Je simule VarA ( mesure) et souhaite mettre en mémoire cette valeur dans VarB
Ensuite il suffit de comparer VarA et VarB et affecter la couleur Led ad'hoc
mais çà ne fonctionne pas comme souhaité

**Jay M** · 23/08/2024, 12h18

Voici un code d'exemple sur le simulateur

https://wokwi.com/projects/407003954452884481
j'ai mis un potentiomètre pour faire varier la valeur, c'est plus simple que votre lecture (approximative) du port série.

il faut faire les choses dans l'ordre.

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
 
#include <Preferences.h>
Preferences preferences;
 
const char* clef = "temperaturePrecedente";
const float valeurDefaut = -100.0;            // Valeur par défaut si la clé n'existe pas
 
const byte CYD_LED_BLUE  = 17;
const byte CYD_LED_RED   =  4;
const byte CYD_LED_GREEN = 16;
 
const byte TEMP_POT_PIN  = 14; // pour simuler la température
 
unsigned long previousMillis = 0;
const unsigned long INTERVAL = 3000; // 3s pour le test
 
int temperaturePrecedente = -1000;
 
void eteindre() {
  digitalWrite(CYD_LED_RED, LOW);
  digitalWrite(CYD_LED_GREEN, LOW);
  digitalWrite(CYD_LED_BLUE, LOW);
}
 
void setup() {
 
  pinMode(CYD_LED_RED, OUTPUT);
  pinMode(CYD_LED_GREEN, OUTPUT);
  pinMode(CYD_LED_BLUE, OUTPUT);
 
  Serial.begin(115200);
  preferences.begin("Memoire", false);
 
  // Vérifier si la clé existe
  if (preferences.getBytesLength(clef) == 0) {
    Serial.println("La clef n'existe pas. Création avec la valeur par défaut.");
    preferences.putFloat(clef, valeurDefaut);
  }
  temperaturePrecedente = preferences.getFloat(clef, valeurDefaut); 
  Serial.print("temperature Precedente: ");  Serial.println(temperaturePrecedente);
}
 
 
void loop() {
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis > INTERVAL) {
    previousMillis = currentMillis;
    int temperatureActuelle = analogRead(TEMP_POT_PIN); // entre 0 et 4095 sur ESP32
 
    if (temperatureActuelle > temperaturePrecedente ) {
      // on chauffe
      eteindre();
      digitalWrite(CYD_LED_RED, HIGH);
      Serial.println("PLUS CHAUD");
    } else if (temperatureActuelle == temperaturePrecedente ) {
      // on est stable
      eteindre();
      digitalWrite(CYD_LED_GREEN, HIGH);
      Serial.println("IDENTIQUE");
    } else {
      // on est plus froid
      eteindre();
      digitalWrite(CYD_LED_BLUE, HIGH);
      Serial.println("PLUS FROID");
    }
 
    temperaturePrecedente = temperatureActuelle;
 
    //  stocker temperatureActuelle dans les préférences pour la prochaine fois si reboot
    preferences.putFloat(clef, temperatureActuelle);
 
  }
}

PS/ notez que vous avez le même nom pour l'espace des préférences et la nom de la variable dans cet espace. ça prête à confusion. Et quand vous faites VarB = prefs.getFloat ("Memoire", VarA); vous dites que VarA et la valeur par défaut si la lecture n'est pas possible.

**cobra38** · 23/08/2024, 15h17

Merci Mille fois Jay M

(désolé nos messages se sont croisés
je n'ai pas vu votre précédent message lorsque j'ai fait le mien ?)

çà fonctionne effectivement mieux qu'avec atof() et la console
je n'ai pas pense au simulateur, c'eut été plus pratique ....

une petite question subsidiaire :
nous comparons des variables int() ( ex : temperaturePrecedente )
avec des variables float() (ex : valeurDefaut)
je pensais qu'il fallait comparer les variables de "déclaration identique" comme int() avec int() etc ...

ai-je tout faux ?

**cobra38** · 23/08/2024, 16h08

RE ...

Suite au petit désagrément ( voir image )
J'ai du modifier au final les types des variables :

float temperatureActuelle
et
float temperaturePrecedente

**Jay M** · 23/08/2024, 16h48

Envoyé par cobra38

nous comparons des variables int() ( ex : temperaturePrecedente )
avec des variables float() (ex : valeurDefaut)

Vous avez raison j’aurais du mettre des float partout.

J’étais parti sur des int à cause du potentiomètre et ensuite j’ai fait un copier coller (je tapais sur mon iPad) du post précédent pour ajouter les préférences et je n’ai pas fait attention… désolé

A ce propos d’ailleurs avec un float on ne teste pas l’égalité parfaite, c’est source d’erreur, on teste des intervalles. Par exemple si la température est 0.25° autour de l’ancienne valeur alors on considère que ça n’a pas bougé et on ne sauvegarde que quand ça a bougé

**cobra38** · 23/08/2024, 17h37

Merci Jay M
pour votre aide

Cordialement
pascal

Comparaison de variables

Arduino

Discussions similaires

Partager

Partager