Discussion :

[Aliveli]

Bonsoir,

Je reposte ce topic ( deja sur le topic conception)pour être dans le topic qui convient le mieux à ce problème pensant qu'il s'agissait de probleme de conception.

Il s'agit de la programmation d'un système à microcontrolleur.
Mon probleme est que la condition : if(SQUELCH==0x00) detectée dans la boucle principale ne se detecte pas si elle est utilisé dans des boucles imbriquées.

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
 
 
 
/*variables globales*/
...
 
#define SQV PINF.0; 
 
...
 
unsigned char SQUELCH; 
 
...
 
main()
{
 
....
 
while(1)
{
..
 
if(test==0x01)
{
 SQUELCH=SQV;
 PORTG=PORTG & 0b11110111;
...
}
 
 
if(SQUELCH==0x00)   //ICI condition se detecte bien 
{
 PORTG=PORTG & 0b11110111;
 lcd_gotoxy(17,0);lcd_putsf("  S");
...
}
 
 
...
 
if(condition1)
 
{ 
   ..
 
   if(condition2) 
 
    {
      switch(KEY)
          { 
            case 1:
 
            case 5:
 
            case 3:
 
                      ....
                      while(1)
                      {
                       .....
                              switch(KEY)
                             { 
                              case 4:  //button up
 
                              case 8:  //button down
 
                              case 12:  //button validation for outgoing 
                              }
 
                              if(SQUELCH==0x00)  //ICI pas detecté alors que signal 
                                                         // existant 
                              {
                               PORTG=PORTG & 0b11110111;
                               lcd_gotoxy(17,0);lcd_putsf("  S");
                               }
 
                               if(KEY==12) break; 
 
                       } KEY=0;
 
             case 7:
 
          } KEY=0;
 
      } //condtion2
 
} //condtion1
 
 
} //while(1)
 
} //main

Est ce normal? Pourtant il s'agit de variables globales

J'ai essayé les conditions suivantes if(SQUELCH==0x00)
if(SQV==0x00)
if(PINF.0==0x00)

Mais toujours rien de detecté ? comment je peux verifier cette condtin dans les boucles imbriquées, n'importe où dans le programme ?

Merci

[ram-0000]

Une petite piste qui est peut être une fausse piste.

Est ce que ta variable SQUELCH est positionnée/modifiée extérieurement (par le hardware ou par une interruption par exemple).

J'ai eu ce problème il y a longtemps et c'est l'optimiseur C qui me jouait des tours, comme il voyait que la variable n'était pas modifiée par le programme, il prenait certaines libertés en supprimant certains tests car il pensait qu'ils ne seraient jamais vérifiés.

J'ai réglé ce problème en rajoutant le mot clé 'volatile' devant ma variable pour forcer le compilateur à ne faire aucune supposition sur la valeur de la variable.

[coyotte507]

A l'endroit où ton test n'est pas détecté, tu peux faire un printf pour afficher la valeur de SQUELCH. De plus, si tu vois que la valeur est différente, alors tu peux rajouter d'autres affichages de la valeur de SQUELCH en amont, jusqu'à trouver où elle a été changée.

[ram-0000]

A l'endroit où ton test n'est pas détecté, tu peux faire un printf pour afficher la valeur de SQUELCH. De plus, si tu vois que la valeur est différente, alors tu peux rajouter d'autres affichages de la valeur de SQUELCH en amont, jusqu'à trouver où elle a été changée.

Cette méthode ne sert à rien si c'est un effet de bord de l'optimiseur sur une variable non modifiée par le programme (cf ma réponse précédente).

Comme il sait que la variable vaut 0 (par exemple) et qu'elle n'est pas modifiée, il peut aussi optimiser l'appel à printf en passant 0 comme paramètre et non le contenu de la variable

[Aliveli]

Merci de votre réponses,

Tout d'abord est-il preferable que je rende volatil quelle variable: SQV ou bien directement la variable testée SQUELCH ?

Deplus comme on le voit dans ce bout de code :

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
 
 
#define SQV PINF.0; 
 
...
 
unsigned char SQUELCH; 
 
...
 
 
if(test==0x01)
{
SQUELCH=SQV;
PORTG=PORTG & 0b11110111;
...
}
 
...

SQUELCH prend la valeur de SQV qui lui prend l'etat du Port F0

J'ai fait un premier test en declarant SQUELCH comme volatile comme ceci: (volatile unsigned char SQUELCH) mais ça n'a toujours pas réussi dois-je faire cela avec le define de SQV et comment?

Deuxiement le fait de rendre une variable volatil cela augmente-t-il conciderablement la durée d'exécution des instructions, du programme?

Merci

[groscask]

Mettre SQV en volatile n'aura pas d'influence : primo, c'est une constante (donc pas modifiable), deuxio, tu l'as mise en #define ;-)

Est-ce que SQUELCH garde sa valeur assez longtemps pour que le résultat soit visible par le programme (et d'une) et par l'oeil humain ? Je me rappelle de programmation de µC que l'on pensait buggé, mais dont le bug était en fait qu'on ne voyait pas le résultat
idem pour la valeur KEY qui détermine la fin de ta boucle imbriquée.

Sinon, tu peux toujours tenter ce que j'ai déjà vu faire (à raison apparemment) : faire la même chose quatre fois d'affilée ! Après tout, c'est capricieux ces petites bêtes...

[Aliveli]

Bonjour,

Merci, voila je déclare donc uniquement la variable SQUELCH ainsi:

volatile unsigned char SQUELCH;

et de façon general j'ai ceci dans mon code :

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
 
 
/*variables globales*/
...
 
#define SQV PINF.0; 
 
...
 
volatile unsigned char SQUELCH; //nouvelle declaration volatile
 
...
 
main()
{
 
....
 
while(1)
{
..
 
if(test==0x01)
{
 SQUELCH=SQV;
 PORTG=PORTG & 0b11110111;
...
}
 
 
if(SQUELCH==0x00)   //ICI condition se detecte bien 
{
 PORTG=PORTG & 0b11110111;
 lcd_gotoxy(17,0);lcd_putsf("  S");
...
}
 
 
...
 
if(condition1)
 
{ 
   ..
 
   if(condition2) 
 
    {
      switch(KEY)
          { 
            case 1:
 
            case 5:
 
            case 3:
 
                      ....
                      while(1)
                      {
                       .....
                              switch(KEY)
                             { 
                              case 4:  //button up
 
                              case 8:  //button down
 
                              case 12:  //button validation for outgoing 
                              }
 
                              if(SQUELCH==0x00)  //ICI pas detecté alors que signal 
                                                         // existant 
                              {
                               PORTG=PORTG & 0b11110111;
                               lcd_gotoxy(17,0);lcd_putsf("  S");
                               }
                              if(SQUELCH==0x00)  //ICI pas detecté alors que signal 
                                                         // existant 
                              {
                               PORTG=PORTG & 0b11110111;
                               lcd_gotoxy(17,0);lcd_putsf("  S");
                               }
                              if(SQUELCH==0x00)  //ICI pas detecté alors que signal 
                                                         // existant 
                              {
                               PORTG=PORTG & 0b11110111;
                               lcd_gotoxy(17,0);lcd_putsf("  S");
                               }
                              if(SQUELCH==0x00)  //ICI pas detecté alors que signal 
                                                         // existant 
                              {
                               PORTG=PORTG & 0b11110111;
                               lcd_gotoxy(17,0);lcd_putsf("  S");
                               }
 
                               if(KEY==12) break; 
 
                       } KEY=0;
 
             case 7:
 
          } KEY=0;
 
      } //condtion2
 
} //condtion1
 
 
} //while(1)
 
} //main

Ainsi je repete 4 x la sequence de test if. Mais malgrès ça rien ne se detecte?

Merci

[coyotte507]

Affiche la valeur de SQUELCH. Comme ça tu sais déjà si c'est l'optimiseur du compilo qui bugge ou si SQUELCH est modifiée.

[coyotte507]

Cette méthode ne sert à rien si c'est un effet de bord de l'optimiseur sur une variable non modifiée par le programme (cf ma réponse précédente).

Comme il sait que la variable vaut 0 (par exemple) et qu'elle n'est pas modifiée, il peut aussi optimiser l'appel à printf en passant 0 comme paramètre et non le contenu de la variable

Si il passe 0 à printf, je ne vois pas pourquoi il n'exécuterait pas le test à l'intérieur du if correctement (if (SQUELCH == 0)).

Si c'est ton bug qui se passe, alors il va afficher la valeur qu'il croit que SQUELCH vaut, on aura une idée du problème.

[bpy1401]

Bonjour Aliveli.

j'aurais déjà une petite remarque à te faire. D'après les bouts de code que tu nous fait voir, ta variable SQUELCH n'est initialisée que si TEST vaut 1. De base, j'initialise toujours ma variable avant de l'utiliser, c'est plus propre.

//ICI pas détecté alors que signal existant : Qu'est veut dire signal existant. signal actif à 0, signal actif à 1 ?

D'après le code, SQUELCH ne peut pas être modifié dans ta deuxième boucle while. Cette variable garde la valeur que tu avais lors du test==0x01 au début du code du premier while. Cela pourrait expliquer pourquoi tu ne détecte rien.

Tu peux retirer le mot clef volatile, il ne te servira à rien ici. la variable SQUELCH est modifiable à un endroit dans le code, donc ton compilo ne peut pas faire d'optimisation sur cette variable. Sur SQV, c'est même pas applicable puisque c'est une macro. Pour ton port (car je suppose que PINF.0 est la pin 0 du port F), je pense que cela est déjà en volatile.

[Aliveli]

Bonjour,

Merci à tous, pour ce qui est de l'affichage je ne peux afficher la valeur de SQUELCH car je ne travaille pas en mode console (debug) mais j'ai uniquement un display LCD 20x3.

En fait le signal détecté il s'agit d'un evenement exterieur qui met le port à 0.
Et au départ la variable SQUELCH est bien initialisée car le test c'est:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 if(test)
    {
 
    	SQUELCH=SQV;
 
    }
    else
    {
 
    	SQUELCH=SQU;
 
    }

Effectivement SQV est une macro

#define SQV PINF.0

J'ai fait if(PINF.0==0) au lieu de if(SQUELCH==0) alors ça detecte bien car c'est volatile mais je dois
pouvoir le faire avec une seule variable tel que SQUELCH et cette variable qui prendra le port en cours et fera le test sur ce port actuel.

je crois que c'est l'optimiseur qui doit pouvoir laisser faire le test du if(SQUELCH==0) dans la boucle imbriquée mais ne l'autorise pas. Peut être qu'il y a une autre algo ou astuce à utiliser?

Merci

[jack69]

J'ai fait if(PINF.0==0) au lieu de if(SQUELCH==0) alors ça detecte bien car c'est volatile mais je dois
pouvoir le faire avec une seule variable tel que SQUELCH et cette variable qui prendra le port en cours et fera le test sur ce port actuel.

La réponse est ici :

D'après le code, SQUELCH ne peut pas être modifié dans ta deuxième boucle while. Cette variable garde la valeur que tu avais lors du test==0x01 au début du code du premier while. Cela pourrait expliquer pourquoi tu ne détecte rien.

Il faut que tu retestes

Code :

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

if ( (SQUELCH=SQV) == 0)

si tu veux actualiser ton test sur la valeur du PORT. Sinon SQUELCH contiendra toujours la valeur prise à "l'init".
Cela n'a rien à voir avec le caractère volatile ou non dans ce cas.

[bpy1401]

je suis complètement d'accord avec jack69.
Tu dois relire l'état de ton port pour savoir si il a changé d'état car SQUELCH n'est qu'une variable comme les autres. Elle n'a aucun lien avec ton port. Pour qu'elle reflète l'état de ton port, tu dois copier la valeur du port dans ta variable.

Bon courage

[Aliveli]

Re,

Oui ce code

Code :

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

1
2
 
if ( (SQUELCH=SQV) == 0)

Pourrait faire l'affaire mais le problème c'est que selon un test precedent je determine quelle valeur affectée à SQUELCH soit SQV soit SQU donc pour mettre le code cidessus je dois d'abord faire un test ici:

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
 
 
eeprom	unsigned	char	Current=0xFF; // Current Radio Selection
 
 if(Current==0x01)
    {
 
    	SQUELCH=SQV;
 
    }
    else
    {
 
    	SQUELCH=SQU;
 
    }

Alors je dois faire un test supplémentaire ça deviendra lourd non?

Merci

[coyotte507]

Sinon tu peux utiliser des pointeurs de fonctions, sans que ce soit lourd.
Par exemple tu fais deux fonctions, l'une qui retourne SQV (sqv()), l'autre SQU (squ()).
Tu utilises un pointeur de fonction, qui peut diriger vers l'une ou l'autre des fonctions, et tu l'utilises comme une variable

Code :

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

1
2
3
4
5
6
7
8
9
10
11
inline unsigned char sqv()
{
    return SQV;
}
 
inline unsigned char squ()
{
    return SQU;
}
 
unsigned char (*squelch)(void);

Alors tu peux enlever ta variable SQUELCH
Et tu remplaces dans ton code:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
SQUELCH = SQV;
-->
squelch = sqv;
 
SQULECH = SQU
--> 
squelch = squ;
 
if (SQUELCH == ...)
-->
if (squelch() == ...)

Normalement le mot-clé inline devrait te garantir des performances comme si tu avais des macros, mais je sais pas s'il est conservé avec les pointeurs de fonction.

[Aliveli]

Bonsoir,

Pour ce qui est de la fonction squelch() vous vouliez dire
les fonction squ() ou sqv() je suppose? Si oui quand savoir laquelle choisir

Code :

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

1
2
3
4
5
6
7
 
 
squelch = sqv;
 
squelch = squ;
 
if (squelch() == ...)

Merci

[groscask]

De mémoire, pointeur sur fonctions et inlining ne font pas bon ménage ;-)

Dans ce cas, autant utiliser deux bonnes vieilles macros... Et de toutes manières, vu l'utilité du code ici, je doute fort que cela soit nécessaire :/

que tu aies :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
inline unsigned char sqv() { return SQV; }
 
inline unsigned char squ() { return SQU; }
 
unsigned char (*squelch)(void);
...
squelch = sqv;
/* ou */
squelch = squ;
...
if (squelch() == ...)

ou bien

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
const unsigned char SQV = ...;
const unsigned char SQU = ...;
 
volatile unsigned char SQUELCH = SQV;
...
SQUELCH = SQV;
/* ou */
SQUELCH = SQU;
...
if (SQUELCH == ...)

C'est kif kif bourricot, avec pour ma part une légère préférence pour la deuxième en terme de perf (à vue de nez hein, il est bien évident que la programmation n'est pas une science exacte )

Par contre, un petit truc qui me chiffonne :

Code :

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

1
2
3
4
 
#define SQV PINF.0; 
...
SQUELCH = SQV;

Ce qui va se traduire (après expansion) par :

Code :

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

1
2
 
SQUELCH = PINF.0;;

Déjà, on remarque un ';' inutile (d'où peut-être certaines erreurs ? Enlève le de la ligne #define), et ensuite, il y a ce .0... Le peu de µC qu'il m'est été donné de faire, on écrivait (sur papier) PINF.0, mais en C cela se transformer plus souvent en PINF_0 : sinon, ca risquerait d'être interprété comme un nombre décimal.

Enfin après, ce sont là les mystères de la programmation en µC...

[bpy1401]

En embarqué, il n'est pas recommandé d'utiliser les pointeurs de fonctions en RAM. pour des raisons de robustesse. Si la robustesse ne te concerne pas pour ce projet, alors cela peut être une solution acceptablle

Pour ceux qui ne le savent pas, le C utilisé sur micro contrôleur n'est pas purement ANSI. l'éditeur de compilateur ajoute souvent des mots clef ou des syntaxes spécifique. Le PINF.0 en est une. Si je ne me trompe pas, cela veut dire pin 0 du port F. la définition de ton PINF.0 doit être dans un fichier .h avec ton compilateur

Pour le choix de la solution , tout dépend de tes contrainte. Si tu es trop juste en pile, n'utilise pas d'appel de fonction, mais utilise plutôt la solution suivante que tu avait donné:

Code :

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

1
2
3
4
5
6
7
8
9
 
if(Current==0x01)
{
  SQUELCH=SQV;
}
else
{
  SQUELCH=SQU;
}

tu as 8 lignes de codes, mais l'équivalent en assembleur n'est pas si grand ni si gourmand en temps

Si tu es limite en ROM, utilise alors la méthode des pointeurs de fonction.

Le choix t'appartient.

[jack69]

Question bete mais aujourd'hui dans tes lignes de code je ne vois pas l'intérêt de passer par une variable intermédiaire. Pourquoi ne travailles-tu pas directement sur la broche ?
A la limite définit une fonction squelch ainsi (pas optimiser en terme de temps d'exécution mais est-ce une contrainte ?)

Code :

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

1
2
3
4
5
6
7
8
9
Unsigned char squelch(int conf)
{
    switch (conf)
    {
        case xxx : return SQV ;
        case yyy : return SQU ;
        defaults : return SQV ;
    }
}

utilisée ainsi

Code :

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

if (squelch(current) == 0)

[Aliveli]

Oui, me revoila désolé pour ce retard. Et merci à tous
pour leur infos effectivement comme briand patrick le dit le C en embarqué n'est pas du pur Ansi et le compilateur il est souvent specifique .

Et la proposition de Jack69 est aussi une bonne alternative
sauf que pour que ca marche bien j'ai pour la fonction squelch() utilisée un int au lieu d'un unsigned char comme retour de fonction.

Merci

@+