Lecture du COM2 au fil de l'eau

**202UH** · 28/11/2006, 12h01

Je ne comprends pas. La version precédente sans les routines fonctionne. Dans la dernière version, j'ai juste mis l'écriture dans le fichier dans la routine ecriture_fichier(void) et le fichier data.txt correspond. En mode pas à pas, je rentre bien dans la routine ecriture_fichier, je fais le fopen, puis le fprintf, puis le close et je sort dans la boucle. Mais quand je vais voir le contenu du fichier data.txt, les anciennes va leurs sont là. Resultat de trois mesures :
1548, 1875, 1622
contenu du fichier data.txt :
154818751622
Je ne vois pas le problème?

**Emmanuel Delahaye** · 28/11/2006, 12h19

Envoyé par 202UH

Je ne comprends pas. La version precédente sans les routines fonctionne. Dans la dernière version, j'ai juste mis l'écriture dans le fichier dans la routine ecriture_fichier(void) et le fichier data.txt correspond. En mode pas à pas, je rentre bien dans la routine ecriture_fichier, je fais le fopen, puis le fprintf, puis le close et je sort dans la boucle. Mais quand je vais voir le contenu du fichier data.txt, les anciennes va leurs sont là. Resultat de trois mesures :
1548, 1875, 1622
contenu du fichier data.txt :
154818751622
Je ne vois pas le problème?

Je n'ai pas de problèmes avec ce code (ignore ce qui concerne CODEBLOCKS)

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
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
 
#ifdef CODEBLOCKS
#include <windows.h>
#include <conio2.h>
#include <ctype.h>
#include "ed/inc/fifo.h"
#undef EOL
 
#define BASE 0x2F8
 
static unsigned char uart[8];
static sFIFO *fifo_rx;
static sFIFO *fifo_lsr;
 
static void sim_init (void)
{
   ASSERT (FIFO_mode () == FIFO_MODE_DYN);
 
   fifo_rx = FIFO_init (32);
   fifo_lsr = FIFO_init (32);
 
   ASSERT (fifo_rx != NULL);
   ASSERT (fifo_lsr != NULL);
}
 
static void sim_end (void)
{
   FIFO_end (fifo_rx);
   FIFO_end (fifo_lsr);
}
 
static void sim_puts (char const *s)
{
   char const *p = s;
   ASSERT (fifo_rx != NULL);
   ASSERT (fifo_lsr != NULL);
 
   while (*p != 0)
   {
      FIFO_put (fifo_rx, *p);
      FIFO_put (fifo_lsr, 0x01);
      p++;
   }
}
 
static void outportb (int port, int data)
{
   printf ("[%04X]<-%02X\n", (unsigned) (port), (unsigned) (data));
   uart[(port) - BASE] = data;
}
 
static int inportb (int port)
{
   int data;
 
   switch (port - BASE)
   {
   case 0:                     /* RX */
      if (!FIFO_empty (fifo_rx))
      {
         data = FIFO_get (fifo_rx);
      }
      else
      {
         data = 0;
      }
      break;
   case 5:                     /* LSR */
      if (!FIFO_empty (fifo_lsr))
      {
         data = FIFO_get (fifo_lsr);
      }
      else
      {
         data = 0;
      }
      break;
   default:
      data = uart[(port) - BASE];
   }
 
   printf ("[%04X]==%02X", (unsigned) (port), (unsigned) data);
 
   if (isprint (data))
   {
      printf (" '%c'", data);
   }
   printf ("\n");
   return data;
}
#endif
 
/* ========================================================================= */
#include <stdio.h>
#include <string.h>
char trame_lue[41];
char resultat[6] = "";
char erreur[5] = "0000";
 
/*****************************************************************/
/* Init port s‚rie : 8 bits donn‚es, 1 bit stop, parit‚ aucune,  */
/* 9600 bauds et positionnement de DLAB pour faire la s‚lection  */
/* de la vitesse de transmission                                 */
/*****************************************************************/
 
void init_com2 (void)
{
     /****************************/
   /* Registres UART port COM2 */
     /****************************/
 
#define ESC     0x1b
#define THR_RBR 0x2F8
#define IER     0x2F9
#define IIR     0x2FA
#define LCR     0x2FB
#define MCR     0x2FC
#define LSR     0x2FD
#define MSR     0x2FE
 
     /**********************/
   /* Bites de registres */
     /**********************/
 
#define DLAB	    0x80
#define RAZ_DLAB    (~DLAB)
 
     /****************************/
   /* ParamŠtres de la liaison */
     /****************************/
 
#define DONNE_8     0x03
#define STOP_1      0x00
#define NONE        0x00
#define BAUDS_9600    12
 
   unsigned init_liaison;
 
   outportb (IER, 0x01);
   init_liaison = DONNE_8 | STOP_1 | NONE | DLAB;
   outportb (LCR, init_liaison);
 
     /******************************************/
   /* Configuration de la vitesse 9600 bauds */
   /* et RAZ bit 7 du LCR                    */
     /******************************************/
 
   outportb (THR_RBR, BAUDS_9600);
   init_liaison &= RAZ_DLAB;
 
     /********************************************/
   /* Envoie a nouveau la configuration au LCR */
   /* avec le bit 7 (DLAB) a 0                 */
     /********************************************/
 
   outportb (LCR, init_liaison);
}
 
/*****************************************************/
/* Sous programme ecriture de la tame dans 1 fichier */
/*****************************************************/
 
void ecriture_fichier (void)
{
#ifdef CODEBLOCKS
   FILE *fichier = fopen ("C:/dev/forums2/data.txt", "w");
#else
   FILE *fichier = fopen ("C:\\aauser\\data.txt", "w");
#endif
   if (fichier == NULL)
   {
      printf (" impossible d'ecrire\n");
   }
   else
   {
      printf ("'%s'\n", resultat);
      fprintf (fichier, "%s", resultat);
      fclose (fichier);
   }
}
 
/**********************************/
/* Controle des caracteres perdus */
/**********************************/
 
static void controle_caract (void)
{
   char const trame_ref1[] = "<16>:(PB): ";
   char const trame_ref2[] = " l/m";
 
   int compare = strncmp (trame_lue + 0, trame_ref1, sizeof trame_ref1 - 1);
   if (compare == 0)
   {
      compare = strncmp (trame_lue + 15, trame_ref2, sizeof trame_ref2 - 1);
      if (compare != 0)
      {
         strcpy (resultat, erreur);
      }
   }
   else
   {
      strcpy (resultat, erreur);
   }
   ecriture_fichier ();
}
 
 
/************************/
/* Programme principale */
/************************/
int main (void)
{
   init_com2 ();
   clrscr ();
 
    /***********************/
   /* Boucle de reception */
    /***********************/
 
   /* Declaration des variables et de la trame
      mise a 0 de l'indice */
 
#define EOL 10
   int i = 0;
 
 
#ifdef CODEBLOCKS
   sim_init ();
   sim_puts ("<16>:(PB): 1234 l/m\n");
#endif
 
   /* Boucle infinie */
   while (1)
   {
      int c;
 
      /* Reception caractere */
      if (inportb (LSR) & 0x01)
      {
         c = inportb (THR_RBR);
         /* Si EOL atteint */
         if (c == EOL)
         {
            /* Fermeture de la chaine */
            trame_lue[i] = 0;
 
            /* Pres a recevoir une nouvelle trame */
            i = 0;
 
            /* Traitement de la trame */
            strncat (resultat, trame_lue + 11, 4);
            controle_caract ();
         }
 
         else
         {
            trame_lue[i] = c;
            i++;
 
            /* Programmation du garde fou */
            if (i > 41)
            {
               i = 0;
            }
         }
      }
 
/* clavier */
      if (kbhit ())
      {
         int c = getch ();
         if (c == ESC)
         {
            break;
         }
      }
 
/* delay */
#ifdef CODEBLOCKS
      Sleep (1000);
#endif
 
   }
#ifdef CODEBLOCKS
   sim_end ();
#endif
   return 0;
}

**202UH** · 28/11/2006, 13h34

Avant tout, je tiens à m'excuser auprès de toi. Dimanche après midi j'avais remplacé mon vieux Turbo C par le Turbo C++ à cause de l'aide qui est beaucoup mieux faite et qui est en Français. Encore une fois, excuses moi.

J'ai ressorti l'ecriture du fichier data.txt de la routine ecriture_fichier et je l'ai remis dans le programme main(). Maintenant l'ecriture dans le fichier fonctionne à nouveau.

**Emmanuel Delahaye** · 28/11/2006, 13h41

Envoyé par 202UH

Avant tout, je tiens à m'excuser auprès de toi. Dimanche après midi j'avais remplacé mon vieux Turbo C par le Turbo C++ à cause de l'aide qui est beaucoup mieux faite et qui est en Français. Encore une fois, excuses moi.

J'ai ressorti l'ecriture du fichier data.txt de la routine ecriture_fichier et je l'ai remis dans le programme main(). Maintenant l'ecriture dans le fichier fonctionne à nouveau.

Ouf !
Je ne suis pas encore gâteux !

C'est fini alors ?

**202UH** · 28/11/2006, 14h18

(ignore ce qui concerne CODEBLOCKS)

J'ai repris ton dernier programme en ignorant ce qui concerne CODEBLOCKS.
J'ai fais 5 mesures : 1687, 1714, 1693, 2008, 1719.
resultat affiché par printf :

Code :

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

1
2
3
4
5
6
 
'0000'
'17'
''
''
''

Je suis DESESPERE

**202UH** · 28/11/2006, 14h33

Petite erreur de ma part :

'0000'
'17'
''
''
''

correction :

Code :

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

1
2
3
4
5
6
 
'0000'
'14'
''
''
''

**Emmanuel Delahaye** · 28/11/2006, 14h46

Envoyé par 202UH

J'ai repris ton dernier programme en ignorant ce qui concerne CODEBLOCKS.
J'ai fais 5 mesures : 1687, 1714, 1693, 2008, 1719.
resultat affiché par printf :

Code :

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

1
2
3
4
5
6
 
'0000'
'17'
''
''
''

Je suis DESESPERE :cry:

Oui, il y a un bug qui m'avait echappé, mais que j'ai pu détecter grâce à ma simulation :

sim_puts ("<16>:(PB): 1687 l/m\n");
sim_puts ("<16>:(PB): 1714 l/m\n");
sim_puts ("<16>:(PB): 2008 l/m\n");
sim_puts ("<16>:(PB): 1719 l/m\n");

Code :

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

1
2
3
4
5
6
7
 
'1687'
'16871714'
'168717142008'
'1687171420081719'
 
Press ENTER to continue.

Ce qui est un magnifique comportement indéterminé (débordement de tableau grave !)

Comme je me plais à le rappeler "C is sharp tool !"

strncat() nécessite que la chaine de destination soit initialisée (ici, vide) avant utilisation.

Code :

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

1
2
3
            /* Traitement de la trame */
            *resultat = 0;
            strncat (resultat, trame_lue + 11, 4);

Ca devrait aller !

Code :

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

1
2
3
4
5
6
'1687'
'1714'
'2008'
'1719'
 
Press ENTER to continue.

La simulation, c'est puissant. Je n'ai jamais mis du code sur cible embarquée avant qu'il n'ait été testé durement sur PC en simulation...

P.S. Ce bug expliquait ce problème :

mesures :
1548, 1875, 1622
contenu du fichier data.txt :
154818751622

**202UH** · 28/11/2006, 16h03

j'ai fais un dernier éssai et ça y est, c'est bon. Demain matin, je remplacerai le 'm' pour les éssai par EOL pour faire les ésais sur la machine. Je te tiendrai au courant.
Merci beaucoup...

**202UH** · 29/11/2006, 09h38

J'ai fais plusieurs éssais ce matin.

le résultat est bon. Tout fonctionne, je vais attaquer mon rapport de stage car il ne me reste plus qu'une semaine 1/2.

Si je fini mon rapport plus vite que prévu et s'il me reste du temps libre, j'aimerai faire un teste supplémentaire.
Actuellement, à la fin du teste hélium, l'automate envoie en un signale à la supervision et WinCC va alors lire le fichier texte pour afficher la valeur.

J'aimerai modifier cette lecture pour qu'elle soit indépendante de l'automate. C'est à dire, je vais lancer une action de lecture cyclique du fichier qui s'executera toutes les 200 ms ou plus (à voir).

problème : peut on modifier la routine d'écriture du fichier de la façon suivante?
1. contrôle de la disponobilité du fichier
2. si oui : écriture du fichier
3. si non : - attente de la disponibilité du fichier
- dès que fichier disponible, écriture ddu fichier

En attendant, je tiens à te remercier Emmanuel pour toute l'aide que tu m'as apporté, même si ça n'a pas été facile de travailler avec un débutant de chez débutant.

A plus....

**Emmanuel Delahaye** · 29/11/2006, 10h26

Envoyé par 202UH

J'aimerai modifier cette lecture pour qu'elle soit indépendante de l'automate. C'est à dire, je vais lancer une action de lecture cyclique du fichier qui s'executera toutes les 200 ms ou plus (à voir).

Un polling de 200 ms, pour un évènement mis a jour au plus rapidement toutes les 30 s, c'est pas raisonnable. Je dirais 1 à 10 secondes, ça dépend du temps de réaction exigé.

problème : peut on modifier la routine d'écriture du fichier de la façon suivante?
1. contrôle de la disponobilité du fichier
2. si oui : écriture du fichier
3. si non : - attente de la disponibilité du fichier
- dès que fichier disponible, écriture ddu fichier

Selon le système, oui, il peut y avoir un dispositif de verrouillage (flock()). Ce n'est pas portable.

http://man.developpez.com/man2/flock.2.php

**202UH** · 29/11/2006, 13h47

Ok.

Je vais faire mon rapport de stage et s'il me reste du temps libre avant la fin de la période, je verrai la suite. Je pense que le programme peut être amélioré, mais en attendant, je considère le problème comme résolut. Rien ne m'empèche de réouvrir la discution plus tard.

Encore merci.

Lecture du COM2 au fil de l'eau

C

Discussions similaires

Partager

Partager