Programmation système avec polling et/ou interruption

**Aliveli** · 07/03/2008, 16h27

Bonjour,

Ma question relève de la conception de mon programme qui est basé sur un polling.
Voila j'ai un système embarqué à base de microcontrolleur Atmega128 et j'ai donc une boucle principale while(1) contenant une séquence d'instructions basé sur des tests if et autres.

le synoptique generale ressemble à ceci:

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
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
 
 
//declarations variables & fonctions
 
main()
{
 
//initialisations
 
/*Display message LCD*/
Dspscr();
 
while(1)
{
 
/* Watchdog activation */ 
WDT_raz();
 
    if(Action1)
   {
    //instructions
    }
    else
    {
    //instructions	
    }
 
 
    if(Action2)
   {
    //instructions
    }
    else
    {
    //instructions	
    }
 
//////
//////
 
    if(Action6)
   {
    //instructions
    }
    else
    {
    //instructions	
    }
 
    KEY_TMT++;
    if(Keyboard)
   {
     KEY_TMT=0;
     scan_key();
	if(KEY|=0) //Key pressed
	{
                switch(KEY)
 	   {
	   case  1: //facile	
		{
                             //instructions
                          }
	   case  5://facile	
		{
                             //instructions
                          }
 
////////////////////////////////
	   case  2: // avec boucle infini	
		{
		while(1)
		{
		WDT_raz();
		delay_ms(100);
		KEY=0;
		scan_key();
		 switch(KEY)
		 {
                            case  4	:	// ----- Up
	                {
			if(condition)
			{
			//instructions				
			}
		     break;  
		   }
								               case  8	:	// ----- Down
 
	                {
			if(condition)
			{
			//instructions				
			}
		     break;  
		   }
 
 
		case 12	:	// ----- Enter
									             {
 
		//Validate_changes						DspScr();
		break;
									             }
		case 20	:	// ----- Escape
									             {
										DspScr();
		break;
									             }
                         }
                        }
                     }
//////////////////////////////
	   case  6: // avec boucle infini	
		{
		while(1)
		{
		WDT_raz();
		delay_ms(100);
		KEY=0;
		scan_key();
		 switch(KEY)
		 {
                            case  4	:	// ----- Up
	                {
			if(condition)
			{
			//instructions				
			}
		     break;  
		   }
								               case  8	:	// ----- Down
 
	                {
			if(condition)
			{
			//instructions				
			}
		     break;  
		   }
 
 
		case 12	:	// ----- Enter
									             {
 
		//Validate_changes						DspScr();
		break;
									             }
		case 20	:	// ----- Escape
									             {
										DspScr();
		break;
									             }
                       }
                   }
                }
 
/////////////////////////
	   case  3: // avec boucle infini	
		{
		while(1)
		{
		WDT_raz();
		delay_ms(100);
		KEY=0;
		scan_key();
		 switch(KEY)
		 {
                            case  4	:	// ----- Up
	                {
			if(condition)
			{
			//instructions				
			}
		     break;  
		   }
								               case  8	:	// ----- Down
 
	                {
			if(condition)
			{
			//instructions				
			}
		     break;  
		   }
 
 
		case 12	:	// ----- Enter
									             {
 
		//Validate_changes						DspScr();
		break;
									             }
		case 20	:	// ----- Escape
									             {
										DspScr();
		break;
									             }
                       }
                     }
                   }
 
 
                 }
             }
 
		}
	}

Mais ce système prévoit aussi la saisie sur clavier numérique pour affichage sur display lcd d'un message par example. Dans cette phase de saisie clavier le programme reste dans une petite boucle while(1) ( qui permet d'encoder 5 chiffres sur clavier avec validation avec enter) qui tant qu'on appui pas sur la saisie "Enter", le programme ne sort pas.
Ce qui voudrait dire que la séquence du boucle principale est arrreté tant qu'on aura pas appuyer sur Enter après cette saisie clavier.

Donc mon problème est que si un autre évenement B a lieu (et que cet evenement peut être deceler si l'on se trouvait dans la boucle while(1) principale ) je ne peux le deceler tant que je suis en mode saisie clavier.

J'ai pensé à mettre dans la phase saisie clavier au lieu d'un petite boucle while(1), un test "if(evenementB) break;" pour y sortir rapidement mais dans ce cas de figure je doit pouvoir garder ce qu'il ya dans l'ecran. et les procahines saisies clavier doivent pouvoir influencer sur l'affichage comme si il n'y avait p

Existe-t-il une solution autre que l'interruption pour pouvoir tenir compte de l'
évenement B même si on est en mode saisie clavier?

Merci

**souviron34** · 07/03/2008, 17h37

d'une part ce post devrait etre sur le forum C...

D'autre part oui c'est possible... Cependant cela depend fortement de l'OS.

Parlons de ce que je connais :

sur systeme unixoide, il faut effectivement faire un poll (j'ai un code quelque part qui fait ca).

Moi je l'ai fait avec en parallele un signal provenant d'un socket asynchrone et une saisie clavier...

Je posterais un morceau de code d'ici la fin du we...

**Aliveli** · 09/03/2008, 19h33

Merci,

J'ai envisagé une autre solution qui me semble plus interressante.

Je m'explique au lieu de faire une boucle while avec tempo, j'ajouterrai uniquement un bloc if(evenementB) dans la petite boucle while(1) et si la condtion est vérifiée alors j'execute mes instructions voulu et je fait un break
pour sortir de cette petite boucle while(1).

Mais la condition ne se verifie pas alors que réellement elle se déroule car il s'agit d'injecter un signal sur un port du microcontrolleur.

j'ai comme declaration :

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

Voici je pense que c'est du aux imbriquations multiples ?
Pourtan j'ai changé la condition de test en remplacant :
if(SQUELCH=0x00) par if(SQV=0x00) et par if(PINF.0=0x00)

mais rien a faire la condition ne se verifie toujours pas ?

Povez vous m'aider?

Merci

**apesle** · 11/03/2008, 19h42

Envoyé par souviron34

Cependant cela depend fortement de l'OS.

C'est sur un atmega128, ce qui veut dire, sauf grossiere erreure de ma part, qu'il n'y a pas d'OS, et donc aucune notion de fichiers, thread et parallelisme.

Pour moi il faut que tu passes par les interruptions externe.
Ainsi lors de l'appuis d'une touche de ton clavier, ton microncontroleur ira automatiquement executé le code de l'interruption où tu peux y faire ce que tu veux. (par exemple compter le nombre de touches appuyés, les mémoriser et les afficher lorsque tu a eu le bon nombre de touche enfoncées.)
Lorsque le microC aura fini d'executer le code de l'interruption, il reprendra automatiquement l'execution du code où il l'a laissé.

C'est je pense le seul mécanisme pour faire "plusieurs taches en même temps". façon de parler).

Par contre il te faut connecter ton clavier sur une entrée INTx et configurer le microC comme il faut pour déclancher l'interruption.
exemple : http://wiki.jelectronique.com/winavr...uption_externe

Programmation système avec polling et/ou interruption

C

Vue hybride

Discussions similaires

Partager

Partager