Discussion :

[202UH]

Je vais essayer la manipe.

[202UH]

Je n'arrive pas à résoudre le problème de la récupération de la chaine pour la découper et récupérer la partie qui m'interresse. J'ai placé ma trame dans la variable c
int c;
c = inportb(THR_RBR);
à partir de là je bloque. Je ne peut pas utiliser strcpy car je ne peux pas copier du int dans du char. Peut tu m'aider?

[Emmanuel Delahaye]

Je n'arrive pas à résoudre le problème de la récupération de la chaine pour la découper et récupérer la partie qui m'interresse. J'ai placé ma trame dans la variable c
int c;
c = inportb(THR_RBR);
à partir de là je bloque. Je ne peut pas utiliser strcpy car je ne peux pas copier du int dans du char.

Ce que tu as mis dans c, c'est pas une trame, c'est un caractère.

Il faut définir au préalable un tableau de char de taille suffisante pour stocker la trame avec un 0 final et un indice à 0.

A chaque caractère reçu, tu places ce caractère dans le tableau à l'aide de l'indice et tu augmentes l'indice de 1 (si on atteint les limites, c'est qu'il y a un bug : EOL jamais reçu. Purger, c'est à dire remettre i a 0).

Quand tu reçois EOL, tu mets un 0 à la place, tu appelles la fonction de traitement de la chaine et tu remets l'indice à 0.

Fait de ton mieux et ecrit l'algorithme puis le code et poste le tout en cas de problèmes.

[202UH]

Il faut absolument m'aider. Je dois finir ce prog pour cette semaine et on va être vendredi. Si quelqu'un peut me donner la solution, se serai sympa. Il est 22 h est je vais arrêter pour aujourd'hui. Voilà ou j'en suis, alors ne croyer pas que j'attends les réponse toutes finis en me tournant les pouces. Mais je suis réellement bloqué. Merci d'avance...

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
 
#define EOL 10
 
int c;
fin = 0;
 
while (!fin)
{
   if (inportb (LSR) & 0x01) /* LSR.0 : Data Ready */
   {
      clrscr();
      c = inportb (THR_RBR); /* Permet de vider le tampon */
 
      char tableau[41];
 
      while ( (c = getc()) != EFO)
      {
         /* je ne trouve pas la formule pour ecrire ds le tableau */
         c = c++
      }
 
      if ( (c = getc()) == EFO)
 
      /* simulation de la reception  */
//      strcpy (data, "<16>:(PB): 1665 l/h");
 
      /* extraction de la chaine de resultat : */
//      char resultat[6] = "";
//      strncat (resultat, data + 11, 5);
//      printf("%s",resultat);
   }
}

[Emmanuel Delahaye]

Il faut absolument m'aider.

Tu pourrais au moins poster du code complet... ou alors si c'est du pseudo-code, précise le... Ca ne dispense pas des balises code...

Je reprends l'algorithme textuel, et je m'en sers pour écrire le pseudo 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
 
BEGIN
 ; Il faut définir au préalable un tableau de char de taille suffisante pour 
 ; stocker la trame avec un 0 final
 trame : ARRAY 0..40 OF character
 
 ; et un indice à 0.
 indice := 0
 
 ; A chaque caractère reçu, 
 LOOP
  c = reception_caractere();
 
  ; Quand tu reçois EOL, 
  IF c = EOL
 
   ; tu mets un 0 à la place, 
   trame[indice] := 0
 
   ; tu appelles la fonction de traitement de la chaine 
   traitement (trame)
 
   ; et tu remets l'indice à 0.
   indice := 0
 
  ELSE
 
   ; tu places ce caractère dans le tableau à l'aide de 
   ; l'indice 
   trame[indice] := c
 
   ; et tu augmentes l'indice de 1 
   indice := indice + 1
 
   ; (si on atteint les limites, 
   IF indice > 40
 
    ; c'est qu'il y a un bug : EOL jamais reçu. 
    ; Purger, c'est à dire remettre i a 0).
    indice := 0
 
   ENDIF
 
  ENDIF
 
 END LOOP
END

Il a fallut légèrement modifier l'ordre de l'algorithme textuel pour arriver à construire un algorithme formel cohérent.

Voilà. Le travail de reflexion (conception) est terminé. Reste plus que le codage...

[202UH]

Je vais faire de mon mieux et essayer de trouver les bon codes. Merci...

[202UH]

Voilà le codage que j'ai fais. Il y a encore un problème. Pourrais-tu m'indiquer ce que je dois corriger?

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
 
/***********************/
/* Boucle de r‚ception */
/***********************/
 
#define ELO 10
fin = 0;
char trame_lue[41];
int c;
int i = 0;
 
if (inportb (LSR) & 0x01) c = inportb (THR_RBR);
 
if (c == ELO)
{
   trame_lue[41] = 0;
   char resultat[6] = "";
   strncat (resultat, trame_lue + 11, 5);
   printf("%s", resultat);
   i = 0;
}
else
{
   trame_lue[i] = c;
   i = i+1;
}
 
if (i > 41) i = 0;

[202UH]

J'ai modifier mon source en rajoutant une boucle while comme ci-dessous. Mais rien ne s'affiche à l'écran. J'ai repris le (!fin) que tu avais mis dans tes premier code. Est ce que fin signifie fin de la chaine de caractères? Faut-il le remplacer par (!EOL)?

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
 
/***********************/
/* Boucle de r‚ception */
/***********************/
 
#define ELO 10
fin = 0;
char trame_lue[41];
int c;
int i = 0;
 
while (!fin)
{
   if (inportb (LSR) & 0x01) c = inportb (THR_RBR);
}
 
if (c == ELO)
{
   trame_lue[41] = 0;
   char resultat[6] = "";
   strncat (resultat, trame_lue + 11, 5);
   printf("%s", resultat);
   i = 0;
}
else
{
   trame_lue[i] = c;
   i = i+1;
}
 
if (i > 41) i = 0;

[Emmanuel Delahaye]

Voilà le codage que j'ai fais. Il y a encore un problème. Pourrais-tu m'indiquer ce que je dois corriger?

/***********************/

comme indiqué dans les règles du forum. C'est fatiguant de répéter toujours les même choses...

/* Boucle de r‚ception */
/***********************/

#define ELO 10
fin = 0;
char trame_lue[41];
int c;
int i = 0;

Elle est où la boucle ? L'initialisation de l'index doit être fait en dehors da la boucle, comme indiqué dans l'algorithme.

if (inportb (LSR) & 0x01) c = inportb (THR_RBR);


if (c == ELO)
{
trame_lue[41] = 0;
char resultat[6] = "";
strncat (resultat, trame_lue + 11, 5);
printf("%s", resultat);
i = 0;
}

else
{
trame_lue[i] = c;
i = i+1;
}

if (i > 41) i = 0;

Ceci doit être dans le else. Pourquoi tu ne suis pas l'algorithme ? Sauf erreur de ma part, l'étude est terminé. Il n'y a plus qu'à coder l'algorithme fidèlement. et à le tester. Si tu codes autre chose, on est dans l'inconnu et on ne peut rien vérifier.

}

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
 
#include <string.h>
#include <stdio.h>
 
/* a completer, je n'ai pas de <dos.h> */
#define ELO 10
 
int main (void)
{
/* BEGIN                             */
 
/*  trame : ARRAY 0..40 OF character */
   char trame_lue[41];
 
/*  indice := 0                      */
   int i = 0;
 
/*  LOOP                             */
   for (;;)
   {
      int c;
/*   c = reception_caractere()      */
      while ((inportb (LSR) & 0x01) == 0)
      {
      }
      c = inportb (THR_RBR);
 
/*   IF c = EOL                      */
      if (c == ELO)
      {
/*    trame[indice] := 0             */
         trame_lue[i] = 0;
/*    traitement (trame)             */
         {
            char resultat[6] = "";
            strncat (resultat, trame_lue + 11, 5);
            printf ("%s", resultat);
         }
         i = 0;
/*    indice := 0                    */
/*   ELSE                            */
      }
      else
      {
/*    trame[indice] := c             */
         trame_lue[i] = c;
/*    indice := indice + 1           */
         i = i + 1;
/*    IF indice > 40                 */
         if (i > 41)
         {
/*     indice := 0                   */
            i = 0;
/*    ENDIF                          */
         }
/*   ENDIF                           */
      }
/*  END LOOP                         */
   }
/* END                               */
   return 0;
}

Voilà. Aucun mystère, il suffisait de suivre le pseudo-code à la lettre Si ce code ne fonctionne pas, c'est soit qu'il est mal codé (je ne peux pas le compiler ni le tester) soit que l'algorithme est faux (tout est possible, je n'ai pas de moyens de valider), soit que le port série, la liaison ou le capteur ne fonctionnent pas.

Mais je suis un peu désespéré, car je n'ai pas l'impression que mes conseils servent à quoi que ce soit... et c'est très désagréable d'avoir l'impression de parler dans le vide... Si tu voulais m'extorquer du code, tu as gagné, mais tu n'auras pas appris grand chose tant que ça ne viendra pas de toi...

J'ai dit.

[202UH]

Je fais de mon mieux et j'ai suivit tes derniers conseilles dans le dernier programme. Par contre je pense ne pas t'extorquer les codes comme tu dis. J'ai juste du mal a comprendre le fonctionnement pour enregister ma trame dans un table et récupérer le résultat qui m'interesse et c'est normale car quand on est débutant, on ne peut tout savoir. Si vraiment je voulais t'extorquer les codes, je ne me casserais pas la tête le soir jusqu'a 22 heures. J'attendrai que ça se passe et que quelqu'un finisse par me donner la solution toute finie. Si le dernier codage ne correspond pas à ce que tu m'as indiquer, alors explique mois ou j'ai fais l'erreur!

[Emmanuel Delahaye]

je ne me casserais pas la tête le soir jusqu'a 22 heures.

22h, arf... A minuit j'y étais encore, et depuis 8 heures du matin...

Si le dernier codage ne correspond pas à ce que tu m'as indiquer, alors explique mois ou j'ai fais l'erreur!

Tu n'as tout simplement pas suivi l'algorithme tel que je l'ai écrit.

Si tu ne le comprends pas, pose des questions...

[202UH]

Je vais tout reprendre calmement et on verra. En tous cas, je ne suis pas un profiteur, sache le. Merci et à plus.

[Emmanuel Delahaye]

Je vais tout reprendre calmement et on verra.

A part mettre au point le code que j'ai posté, je ne vois pas trop ce qu'il y a à reprendre. Je croyais que ça devais être fini aujourd'hui ? On m'aurait menti à l'insu de mon plein gré ?

En tous cas, je ne suis pas un profiteur, sache le. Merci et à plus.

Ca ne t'a pas empêché de sortir les violons hier soir... voire de donner des ordres...

Il faut absolument m'aider. Je dois finir ce prog pour cette semaine et on va être vendredi.

[Emmanuel Delahaye]

Je vais tout reprendre calmement et on verra. En tous cas, je ne suis pas un profiteur, sache le. Merci et à plus.

J'ai corrigé le code.

[202UH]

Je n'ai pas sorti de violon et je n'ai pas donné d'ordre, je demande que de l'aide. Enfin, comme tu peux voir, j'ai appliqué à la lettre ton codage et je l'ai placé dans une fenêtre code . La compile ne m'a pas généré d' erreur. Mais lorsque je lance l'exe, il se referme de suite. Comment parer ce problème.

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
 
#include <stdio.h>
#include <conio.h>
#include <STRING.H>
/****************************/
/* 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
 
/****************************/
/* ParamŠtres de la liaison */
/****************************/
 
#define DONNE_8     0x03
#define STOP_1      0x00
#define NONE        0x00
#define DLAB	    0x80
#define RAZ_DLAB    0x7F
#define _9600_BAUDS   12
#define  INTR	    0x23
 
unsigned char init_liaison;
int fin;
 
/************************/
/* Programme principale */
/************************/
 
void main()
  {
    clrscr();
 
/*****************************************************************/
/* 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                                 */
/*****************************************************************/
 
    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,_9600_BAUDS);
    init_liaison &= RAZ_DLAB;
 
/**********************************************************************/
/* Envoie … nouveau la configuration au LCR avec le bit 7 (DLAB) … 0  */
/**********************************************************************/
 
    outportb(LCR,init_liaison);
 
/***********************/
/* Boucle de r‚ception */
/***********************/
 
/* Declaration des variables et de la trame
   mise a 0 de l'indice */
 
    #define EOL 10
    char trame_lue[41];
    int i = 0;
 
/* boucle for */
 
    for (i=0;i<41;i++)
      {
/* reception caractere*/
 
       int c;
 
	if (inportb (LSR) & 0x01)
	 {
	   c = inportb (THR_RBR);
	 }
 
/* Si End Of Line atteint */
 
	if (c == EOL)
	 {
 
/* Traitement de la trame */
 
	   trame_lue[i] = 0;
	     {
	      char resultat[6] = "";
	      strncat (resultat, trame_lue + 11, 5);
	      printf ("%s", resultat);
	     }
 
	   i = 0;
	 }
 
	else
	   {
	    trame_lue[i] = c;
	    i++;
	   }
 
	if (i > 40)
	 {
	   i = 0;
	 }
      }
 
    return;
}

[Emmanuel Delahaye]

j'ai appliqué à la lettre ton codage

Code :

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

1
2
3
4
5
 
/* boucle for */
 
    for (i=0;i<41;i++)
      {

Je ne me souviens pas avoir parlé de boucle for dans l'algorithme, mais de boucle tout court, c'est à dire sans condition de sortie, ce que j'ai codé :

Code :

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

1
2
3
4
5
6
7
8
9
 
/*  LOOP                             */
   for (;;)
   {
 
   <...>
 
/*  END LOOP                         */
   }

Je reviens vers 18:00

[202UH]

Ca se trouve un peut plus haut sir la page 4 dans ton code.

/* LOOP */
for (;;)
{

Dois-je réutiliser (!fin)? Que représente se fin. Merci...

[Emmanuel Delahaye]

Ca se trouve un peut plus haut sir la page 4 dans ton code.

Ben oui, je l'ai même cité. Mais je n'ai pas parlé de variable ni d'expression concernant ce for. As-tu compris le rôle de la boucle (LOOP-END-LOOP codée en C for(;;){} ou while(1){}, mais c'est plus long à taper... )

Dois-je réutiliser (!fin)? Que représente se fin.

C'est un autre problème. La boucle inconditionnelle (for(;;){}) ne s'arrête jamais. C'est acceptable pour ton programme, car tu n'as pas précisé comment il s'arrêtait. Mais si tu veux qu'il s'arrête sur appui d'une touche genre ESC ou Alt-F4, il faut le préciser dans la spécification et on ajoutera le bout de code qui va bien...

Pour le moment, tu laisses for(;;).

[202UH]

Si j'ai bien compris ce que j'ai fais, je résumerai ça de cette façon :
Comme ma trame est toujour la même, j'aurrai au maximum 41 cases dans mon tableau (0...40), y compris le end of line. Donc pour ranger mes 41 cases, une incrémentation de 40 sur un indice = 0 me font bien 41 rangements pour mes caractères. Puis je quitte la boucle avec mes 41 traitements de fait.
C'est vrai que actuellement je quitte le programme d'une façon assez sauvage qui ne me plait pas du tout (clic sur la croix de fermeture de la fenêtre, puis clic sur le message "Terminer maintenant"). Pourrais tu m'expliquer comment programmer une sortie du programme par une combinaison que moi je définirai (ex : Ctrl + P + S). Si je peux choisir mes touches à additionner à Ctrl, je serai sur de ne pas perturber le Second programme qui lui à de multiples combinaisons de touches. Le programme que j'essais de mettre au point avec ton aide tournera en fond de tâche. C'est en fait un Thread.
Si tu te rappels le début de cette discution, je te parlais d'un soft de supervision WinCC. J'ai trouvé la solution pour afficher le résultat de ma trame dans une fenêtre I/O de ce soft. Je vais finir le programme par un enregistrement du résultat dans un fichier texte et la fenêtre I/O de WinCC permet la récupération de valeurs écrites dans un fichier txt.
Je vais commencer à étudier l'enregistrement de la valeur dans un fichier txt (fopen,fwrite,fclose... d'après les premiers éléments que j'ai pu trouver).
Si tu peux me tenir au courant pour la fermeture du programme proprement, ce serais sympa. Merci beaucoup.
PS Si je t'ai parlé que le programme devait être fini aujourd'hui, je ne t'ai pas raconté de conneries. C'est un impératif que je me suis imposé car il ne me reste plus que 2 semaines de stage pour rédiger mon rapport. Le 11/12/06 je passe mes exames est je serai interrogé sur mon stage, ce que j'ai fais pendant mon stage et ce que j'ai compris. Tu comprends un peut mieux mon stress.
Le week end je ne peut pas accéder à l'entreprise pour les essais, mais j'aimmerai être Ok pour Lundi matin avec l'enregistrement dans un fichier.

[Emmanuel Delahaye]

Si j'ai bien compris ce que j'ai fais, je résumerai ça de cette façon :
Comme ma trame est toujour la même,

On en sait rien... On sait juste qu'elle ne doit pas faire plus de 41 caractères y compris le EOL.

j'aurrai au maximum 41 cases dans mon tableau (0...40), y compris le end of line.

Non. Y compris le 0 final de fin de trame. Le EOL n'est pas enregistré. Il sert à déclencher 3 opérations :

1. Terminer la chaine reçue par un 0 de façon à ce qu'elle puisse être traitée par des fonctions C standards.
2. Lancer le traitement de la-dite chaine
3. Remettre l'indice à 0. (réinitialiser l'acquisition pour être prêt à la saisie suivante.).

Tout ceci a déjà été expliqué dans l'algorithme textuel, dans le pseudo-code et codé tel quel...

Donc pour ranger mes 41 cases, une incrémentation de 40 sur un indice = 0 me font bien 41 rangements pour mes caractères. Puis je quitte la boucle avec mes 41 traitements de fait.

Rien ne dit que le capteur va envoyer exactement 41 caractères. Il en envoi un certain nombre, peu importe combien et quand c'est EOL, on sait que c'est fin. Mais on a une sécurité. Si au bout du 41ème, on a toujours pas reçu le EOL, les caractères reçus précédemment sont ignorés et on relance l'acquisition de la trame suivante. On a déjà expliqué tout ça...

C'est vrai que actuellement je quitte le programme d'une façon assez sauvage qui ne me plait pas du tout (clic sur la croix de fermeture de la fenêtre, puis clic sur le message "Terminer maintenant"). Pourrais tu m'expliquer comment programmer une sortie du programme par une combinaison que moi je définirai (ex : Ctrl + P + S).

Si tu as <conio.h>, getch(), kbhit(), aucun problème. J'attends ta confirmation.

Si je peux choisir mes touches à additionner à Ctrl, je serai sur de ne pas perturber le Second programme qui lui à de multiples combinaisons de touches.

Aucune importance. Sous Windows, seul le programme qui a le focus est sensible au clavier. (Heureusement, tu vois le cirque ? Je fais ctrl-F4, toutes les applications se ferment. Bravo !)

Le programme que j'essais de mettre au point avec ton aide tournera en fond de tâche.

Tâche de fond...

C'est en fait un Thread.

What ? A ma connaissance, un thread tourne en Win32, pas en Win16. Je te rappelle que le code en question n'est pas du tout compatible Win32. Tu as insisté pour accéder directement à l'UART, mais je t'avais bien prévenu que ça ne fonctionnais que sous DOS (disons en mode réel vrai ou ou réel simulé par la VM 16-bit des anciens Windows avant 98SE).

Si tu te rappels le début de cette discution, je te parlais d'un soft de supervision WinCC. J'ai trouvé la solution pour afficher le résultat de ma trame dans une fenêtre I/O de ce soft.

Et tu l'as essayé ça, avec <dos.h>, inportb() etc ? Ca compile ? Ca fonctionne ?

Je vais finir le programme par un enregistrement du résultat dans un fichier texte et la fenêtre I/O de WinCC permet la récupération de valeurs écrites dans un fichier txt.

C'est pas dur. Pour éviter les bêtises, je suggère une ouverture en mode "a" (text append) avec fopen(), puis un enregistrement (fprintf() et une fermeture immédiate (fclose()), le tout à chaque traitement de la chaine (EOL detected). C'est un peu le B.A. BA du C, que tu n'as pas l'air de conaitre...

Je vais commencer à étudier l'enregistrement de la valeur dans un fichier txt (fopen,fwrite,fclose... d'après les premiers éléments que j'ai pu trouver).

Pas fwrite(). Sans intérêt ici. Tu as fortement interêt à enregistrer en mode texte (genre une valeur par ligne codée en décimal). En fait, c'est ce que t'envoie le capteur. C'est donc même pas la peine de convertir la chaine, tu peux l'enregistrée telle quelle (après extraction).

L'usage des fonctions de gestion des flux est décrit dans ton livre de C et dans les tutoriels sérieux.