Discussion :

[Lucalo33]

Bonjour,

J'ai un soucis avec mes conditions if/else dans ma carte arduino (est-ce le bon forum ?)

Le but de mon programme est de détecter la variations de résistance d'un jauge de contrainte et à l'aide d'un pont de Wheatstone et d'amplis OP on est censé récupérer une tension de 0 a 3.5V dans la carte Arduino. On défini des limites et on allume une led verte,jaune ou rouge en fonction de cette tension.
Mon problème est que pour une tension devant allumer la led verte c'est la led orange qui s'allume (oui j'ai vérifié les pins et les branchements...)

Si quelqu'un peut m'aider se serait avec plaisir.

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
 
// ON DEFINI LES PIN :
 
int Tension = A5;
int green = 2;
int orange = 4;
int red = 7;
 
//#define Tension A5
//#define green 2
//#define orange 4
//#define red 7
 
// VALEUR SORTIE DU CAN EN BITS :
int valeur;
 
// VALEUR CALCULEE EN VOLT A L'ENTREE DU CAN :
float volt;
 
// VALEURS LIMITES /
const int rpe = 0.615;
const int re = 1.235;
 
// ATTENTE :
const int wait = 500;
 
 
void setup() {
 
//INITIALISATION DES PIN :
Serial.begin(9600);
pinMode (Tension, INPUT);
 
pinMode (green, OUTPUT);
pinMode (red, OUTPUT);
pinMode (orange, OUTPUT);
}
 
 
void loop() {
            // on convertit en nombre binaire la tension lue
      valeur = analogRead(Tension);
 
            // on traduit la valeur brute en tension (produit en croix)
      volt = valeur * 5.0 / 1023;
 
//Si volt plus grand que voulu, on allume une LED :
 
        //    LED VERTE :
 if(volt <= rpe){
  digitalWrite(green,HIGH);
}
 else {
  digitalWrite(green,LOW);
}
 
  //    LED JAUNE :
 if(volt >= rpe and volt <= re){
  digitalWrite(orange,HIGH);
}
 else {
  digitalWrite(orange,LOW);
}
 
  //    LED ROUGE :
 if(volt >= re){
   digitalWrite(red,HIGH);
}
 else {
   digitalWrite(red,LOW);
}
 
 
            // on affiche la tension calculée
      Serial.print("volt= ");
      Serial.print(volt,2);
      Serial.println(" V");
 
           // on saute une ligne entre deux affichages
      Serial.println();
      delay(wait);
 
            // on affiche la valeur lue sur la liaison série
 
      Serial.print("valeur en bits= ");
      Serial.print(valeur);
      Serial.println(" /1023");
 
  //          // on saute une ligne entre deux affichages
  //    Serial.println( );
  //    delay(wait);
}

[Sve@r]

Bonjour

Mon problème est que pour une tension devant allumer la led verte c'est la led orange qui s'allume (oui j'ai vérifié les pins et les branchements...)

Déjà le mot clef "and" n'existe pas en C. La syntaxe c'est if (volt >= rpe && volt <= re).

Sinon t'as un test if (volt <= rpe) allumer vert puis un test if (volt >= rpe) allumer orange. Donc le cas volt == rpe valide les deux tests ce qui allume alors le vert puis l'orange (ça aurait été bien que tu nous donne la valeur de "volt"...)

[sambia39]

Bonjour,
(1) La définition des PIN est mal faites, il n'existe pas de sortie analogique A5 ayant pour valeurs A5 ou du moins pas de valeur A5 désignant l’entrée analogique 5.
(2) Analogique 5 (A5) n'est pas non plus destinée a être utiliser plus bas pour la définition des PIN numériques pinMode (Tension, INPUT); normalement à ce stade le compilateur devrait déjà crier.

(3) La formule de mesure du voltage est également fausse et je ne vois nulle part l'application du pont de Wheatstone sans compté l'absence des valeurs de vos résistances et de la formule. En revanche le code de la mesure du voltage, ressemble plus à un diviseur de tension (qui d'ailleurs, est utilisé pour mesurer le voltage en entrée de la broche analogique 5) sous cette forme.

Code C :

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

1
2
3
4
 
const float RESISTANCE_1 = 2000; //(R1)
const float RESITSNACE_2 = 2000; //(R2)
const float ret_volt = ( analogRead(5) / (1023.0 * (RESISTANCE_2/(RESISTANCE_1 + RESISTANCE_2))) );

Bref, Je vous conseil de revoir l'implémentation du pont de Wheatstone.

À bientôt,

[Lucalo33]

La définition des PIN est mal faites, il n'existe pas de sortie analogique A5 ayant pour valeurs A5 ou du moins pas de valeur A5 désignant l’entrée analogique 5.

=> Pour les pin analogiques j'ai essayé avec "#define" puis avec "int" et le résultat est le même dans le moniteur du logiciel arduino (il m'affiche volt=0.06 V).
Je comprend pas trop le problème que vous m'annoncez..

(2) Analogique 5 (A5) n'est pas non plus destinée a être utiliser plus bas pour la définition des PIN numériquenormalement à ce stade le compilateur devrait déjà crier.

=> Le compilateur ne me dit rien et c'est d'après mes collègue la seule facon d'obtenir une valeur de tension (excepté les pins A0 A1 A2 A3 et A4)

La formule de mesure du voltage est également fausse et je ne vois nulle part l'application du pont de Wheatstone sans compté l'absence des valeurs de vos résistances et de la formule. En revanche le code de la mesure du voltage, ressemble plus à un diviseur de tension (qui d'ailleurs, est utilisé pour mesurer le voltage en entrée de la broche analogique 5) sous cette forme

=> Pour le pont de wheatstone je récupère la tension en sortie d'AOP et le calcul est déja fait sur excel, je ne rentre que mes valeurs limites.
En gros pour simplifier le problème ma tension est censé varier de 0 à 3.5 et je veux une led allumée par intervale.

[Lucalo33]

Pour exclure plusieurs causes je rentre ma valeur à la main :
Je met volt=0.06, ça devrait allumer la led verte mais c'est la jaune qui s'allume...

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
 
      // ON DEFINI LES PIN :
 
//int Tension = A5;
int green = 2;
int orange = 4;
int red = 7;
 
//#define Tension A5
//#define green 2
//#define orange 4
//#define red 7
 
// VALEUR SORTIE DU CAN EN BITS :
//int valeur;
 
// VALEUR CALCULEE EN VOLT A L'ENTREE DU CAN :
float volt=0.06;
 
// VALEURS LIMITES /
const int rpe = 0.615;
const int re = 1.235;
 
// ATTENTE :
const int wait = 500;
 
 
void setup() {
 
//INITIALISATION DES PIN :
Serial.begin(9600);
//pinMode (Tension, INPUT);
 
pinMode (green, OUTPUT);
pinMode (red, OUTPUT);
pinMode (orange, OUTPUT);
}
 
 
void loop() {
            // on convertit en nombre binaire la tension lue
 //     valeur = analogRead(A5);
 
            // on traduit la valeur brute en tension (produit en croix)
 //     volt = valeur * 5.0 / 1023;
 
//Si volt plus grand que voulu, on allume une LED :
 
        //    LED VERTE :
 if(volt <= rpe){
  digitalWrite(green,HIGH);
}
 else {
  digitalWrite(green,LOW);
}
 
  //    LED JAUNE :
 if(volt > rpe && volt <= re){
  digitalWrite(orange,HIGH);
}
 else {
  digitalWrite(orange,LOW);
}
 
  //    LED ROUGE :
 if(volt > re){
   digitalWrite(red,HIGH);
}
 else {
   digitalWrite(red,LOW);
}
 
 
            // on affiche la tension calculée
      Serial.print("volt= ");
      Serial.print(volt);
      Serial.println(" V");
 
           // on saute une ligne entre deux affichages
      Serial.println();
      delay(wait);
 
            // on affiche la valeur lue sur la liaison série
 
 //     Serial.print("valeur en bits= ");
//      Serial.print(valeur);
 //     Serial.println(" /1023");
 
  //          // on saute une ligne entre deux affichages
  //    Serial.println( );
  //    delay(wait);
}

[sambia39]

Pour exclure plusieurs causes je rentre ma valeur à la main :
Je met volt=0.06, ça devrait allumer la led verte mais c'est la jaune qui s'allume...

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
 
      // ON DEFINI LES PIN :
 
//int Tension = A5;
int green = 2;
int orange = 4;
int red = 7;
 
//#define Tension A5
//#define green 2
//#define orange 4
//#define red 7
 
// VALEUR SORTIE DU CAN EN BITS :
//int valeur;
 
// VALEUR CALCULEE EN VOLT A L'ENTREE DU CAN :
float volt=0.06;
 
// VALEURS LIMITES /
const int rpe = 0.615;
const int re = 1.235;
 
// ATTENTE :
const int wait = 500;
 
 
void setup() {
 
//INITIALISATION DES PIN :
Serial.begin(9600);
//pinMode (Tension, INPUT);
 
pinMode (green, OUTPUT);
pinMode (red, OUTPUT);
pinMode (orange, OUTPUT);
}
 
 
void loop() {
            // on convertit en nombre binaire la tension lue
 //     valeur = analogRead(A5);
 
            // on traduit la valeur brute en tension (produit en croix)
 //     volt = valeur * 5.0 / 1023;
 
//Si volt plus grand que voulu, on allume une LED :
 
        //    LED VERTE :
 if(volt <= rpe){
  digitalWrite(green,HIGH);
}
 else {
  digitalWrite(green,LOW);
}
 
  //    LED JAUNE :
 if(volt > rpe && volt <= re){
  digitalWrite(orange,HIGH);
}
 else {
  digitalWrite(orange,LOW);
}
 
  //    LED ROUGE :
 if(volt > re){
   digitalWrite(red,HIGH);
}
 else {
   digitalWrite(red,LOW);
}
 
 
            // on affiche la tension calculée
      Serial.print("volt= ");
      Serial.print(volt);
      Serial.println(" V");
 
           // on saute une ligne entre deux affichages
      Serial.println();
      delay(wait);
 
            // on affiche la valeur lue sur la liaison série
 
 //     Serial.print("valeur en bits= ");
//      Serial.print(valeur);
 //     Serial.println(" /1023");
 
  //          // on saute une ligne entre deux affichages
  //    Serial.println( );
  //    delay(wait);
}

Il faut comprendre qu’un programme fait exactement ce qui est écrit et non ce que vous pensez qu’il doit faire et c’est tout à fait normal que la LED jaune s’allume. Car il y a une différence entre un type entier int rpe = 0.615;et un type float float volt=0.06;
Le type entier comprend 0 et non 0.615 et donc bien normale que 0.06 > 0.
volt > rpe && volt <= re sachant que c'est "vraie" que 0.06 > 0 et 0.6 < 1 alors la led jaune s'allume.
à bientôt

[Lucalo33]

Le type entier comprend 0 et non 0.615 et donc bien normale que 0.06[COLOR=#3E3E3E] > 0.

Oui je viens de voir ça et j'allais vous prévenir de cette erreur de débutant (un peu débile...)
C'est bon j'ai plus de pb de plusieurs led en même temps...
Je dois encore avoir un souci avec ma lecture analogique car la valeur de 0.06V est bien trop stable dans le temps (même quand je touche ma jauge de contrainte), c'est étonnant (surtout avec un coef d'amplification de 500 et des fils à l'air...)
Vous sauriez pourquoi si c'est un problème de pin ou software ? C'est peut être ma jauge qui est morte aussi je m'en vais vérifier tout ça...

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
 
      // ON DEFINI LES PIN :
 
//int Tension = A5;
int green = 2;
int orange = 4;
int red = 7;
 
#define Tension A5
//#define green 2
//#define orange 4
//#define red 7
 
// VALEUR SORTIE DU CAN EN BITS :
int valeur;
 
// VALEUR CALCULEE EN VOLT A L'ENTREE DU CAN :
float volt;
 
// VALEURS LIMITES /
const float rpe = 0.615;
const float re = 1.235;
 
// ATTENTE :
const int wait = 500;
 
 
void setup() {
 
//INITIALISATION DES PIN :
Serial.begin(9600);
pinMode (Tension, INPUT);
 
pinMode (green, OUTPUT);
pinMode (red, OUTPUT);
pinMode (orange, OUTPUT);
}
 
 
void loop() {
            // on convertit en nombre binaire la tension lue
      valeur = analogRead(A5);
 
            // on traduit la valeur brute en tension (produit en croix)
      volt = valeur * 5.0 / 1023;
 
//Si volt plus grand que voulu, on allume une LED :
 
        //    LED VERTE :
 if(volt <= rpe){
  digitalWrite(green,HIGH);
}
 else {
  digitalWrite(green,LOW);
}
 
  //    LED JAUNE :
 if(volt > rpe && volt <= re){
  digitalWrite(orange,HIGH);
}
 else {
  digitalWrite(orange,LOW);
}
 
  //    LED ROUGE :
 if(volt > re){
   digitalWrite(red,HIGH);
}
 else {
   digitalWrite(red,LOW);
}
 
 
            // on affiche la tension calculée
      Serial.print("volt= ");
      Serial.print(volt);
      Serial.println(" V");
 
           // on saute une ligne entre deux affichages
      Serial.println();
      delay(wait);
 
            // on affiche la valeur lue sur la liaison série
 
      Serial.print("valeur en bits= ");
      Serial.print(valeur);
      Serial.println(" /1023");
 
            // on saute une ligne entre deux affichages
      Serial.println( );
      delay(wait);
}

[Kannagi]

Je rajouterai que ce n'est pas du C aussi
Sur arduino c'est du C++ par exemple :

Code :

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

1
2
3
4
5
6
 
 
// on affiche la tension calculée
      Serial.print("volt= ");
      Serial.print(volt);
      Serial.println(" V");

[Bktero]

Déjà le mot clef "and" n'existe pas en C. La syntaxe c'est if (volt >= rpe && volt <= re).

Mais il existe en C++ et comme Arduino utilise un hybride (comme le signale Kannagi), ce code est valable sur Arduino

[Sve@r]

Argh cte mauvaise foi d'arracheur de dent
On est sur un fofo C. Si je vois un topic qui montre une erreur de syntaxe C je suis obligé de le dire. C'est mon honneur de Cman qui est en jeu
Trop facile de venir poster un code C++ sur un fofo C et dire ensuite "oui mais en C++ ça marche et justement j'étais en C++"

Remarque je pensais quand-même à un truc de ce genre. Je sais que son code ne peut pas compiler mais il l'avait posté avec tellement de naturel, et sans se plaindre de quoi que ce soit question syntaxe, que je me suis dit en postant ma remarque "je suis sûr que chez-lui ça compile" mais sans trop savoir pourquoi (je m'imaginais un truc un peu "spécial arduino" et j'ai pas pensé au C++).

[ternel]

D'après ma référence préférée (cppreference), and, or et d'autres sont des "alternative operators", définis dans <iso646.h>
alternative operators

[sambia39]

Je dois encore avoir un souci avec ma lecture analogique car la valeur de 0.06V est bien trop stable dans le temps (même quand je touche ma jauge de contrainte), c'est étonnant (surtout avec un coef d'amplification de 500 et des fils à l'air...)
Vous sauriez pourquoi si c'est un problème de pin ou software ? C'est peut être ma jauge qui est morte aussi je m'en vais vérifier tout ça...

C’est tout à fait normal que vous captiez la BBC . Le fil que vous laissez "en l'air" agit comme une antenne parce qu'il y a une différence de potentiel. Vérifiez donc votre montage pour voir si votre Arduino a la même référence de potentiel (la masse) que votre OP.

=> Pour les pin analogiques j'ai essayé avec "#define" puis avec "int" et le résultat est le même dans le moniteur du logiciel arduino (il m'affiche volt=0.06 V).
Je comprend pas trop le problème que vous m'annoncez..

Pour les PIN analogiques, le plus simple est d'utiliser directement la fonction analogRead(..) avec la référence en question sous cette forme analogRead(A5) ou const uint8_t analog_3 = 3; analogRead(analog_3). Et si j'ai parlé du mauvais emploi des broches analogiques, c'est parce qu'A5 (static const uint8_t A5 = 19;) est utilisé comme une référence qui représente la broche Analogique 5. Je reconnais que je me suis un peu emballé en avançant que le compilateur allait signaler une erreur ; ce n'est pas le cas. Cependant, en faisant pinMode (Tension, INPUT);, la broche analogique A5 sera utilisée, comme si c'était une broche numérique; de toute façon, les broches analogiques sont en réalité des broches numériques. C’est en utilisant la fonction analogRead(A5) qu’elles deviennent analogiques grâce au CNA qu'embarque la carte. Faire pinMode(A2,OUTPUT) est valide, car A0 à A5 sont des broches numériques qui peuvent traiter de l’analogique "uniquement en entrée" si l’on utilise la fonction analogRead(..). Or, ce n'est pas ce que vous souhaitez faire. Ce genre d'approche (pinMode (Tension, INPUT);) peut être justifié parce que vous ne disposez plus de broches numériques de libre (par exemple). Mais attention tout de même, si vous utilisez A5 comme sortie et que plus bas dans votre code vous utilisez analogRead(A5) alors la fonction analogRead(..) ne pourra pas fonctionner correctement, il faut alors la redéfinir en entrée pour que cela re-fonctionne de manière correcte.

=> Le compilateur ne me dit rien et c'est d'après mes collègue la seule facon d'obtenir une valeur de tension (excepté les pins A0 A1 A2 A3 et A4)

A5 n'est pas la seule possibilité que vous devez utiliser pour mesurer le voltage. A0 à A4 vous donnent également les mêmes possibilités.

=> Pour le pont de wheatstone je récupère la tension en sortie d'AOP et le calcul est déja fait sur excel, je ne rentre que mes valeurs limites. En gros pour simplifier le problème ma tension est censé varier de 0 à 3.5 et je veux une led allumée par intervale.

Désolé, je n’avais pas compris ça comme ça au départ. Hypothétiquement, je ne peux que deviner qu'à l'entrée de l'OP, il y a un pont de Wheatstone et en sortie de votre OP il y a la carte Arduino qui mesure la tension et qui allume les LED en fonction du voltage qui oscille et effectivement, comme vous oscillez entre 0-3.5 normalement, il ne devrait pas y avoir de soucis sauf s'il y a des fil en l'air/ non connecté.

À bientôt.