lire trame sur port série

**ritchyv** · 02/10/2009, 09h02

Bonjour,

Je viens de connecter un microcontroleur sur le port série de mon PC.
L'envoie de trame du microcontroleur au PC se passe bien.
Les trames débutent par $$ ensuite j'ai mes données qui peuvent etre des entiers 16 bits ou des float.

Le problème est que je n'arrive pas à trouver un exemple de code me permettant via dev-c++ de récupérer mes données.
Je voudrais pouvoir détecter mes symboles $$ puis traiter mes données.

Pouvez vous m'aider ?

Exemple de code trouvé mais pas claire pour moi. Je ne sais pas comment faire apres le "readfile"

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
 
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <conio.h>
#include <time.h>
#include <string.h>
#include <math.h>
 
 
 
/*********************************************/
/* Déclaration des variables pour */
/* Ouverture de la communication USB */
/*********************************************/
DCB m_dcb;
BOOL port_ok;
COMMTIMEOUTS tmout={MAXWORD, 20,1,20}; // Mystère pour moi
 
char c;
 
 
HANDLE com;
 
 
 
int main(void)
{
printf("Lancement programme\n");
com = CreateFile( "com1", GENERIC_READ | GENERIC_WRITE,0,NULL,OPEN_EXISTING, 0,NULL );
if (com==INVALID_HANDLE_VALUE)
printf("ERREUR COM1 inaccessible utiliser com1 en ligne de commande\n");
port_ok = SetupComm(com, 1024, 1024);
port_ok = GetCommState(com, &m_dcb);
m_dcb.BaudRate = 115200;
m_dcb.ByteSize = 8;
m_dcb.Parity = NOPARITY;
m_dcb.StopBits = ONESTOPBIT;
m_dcb.fAbortOnError = FALSE;
m_dcb.fBinary = TRUE ;
m_dcb.fParity = TRUE ;
m_dcb.fNull=TRUE;
port_ok = SetCommState(com, &m_dcb);
SetCommTimeouts (com,&tmout);
 
while(1)
{
ReadFile(com,&c,1,(LPDWORD) &nbr, NULL);
 
?????????????????????????????,
 
 
 
 
 
 
 
/*********************************************/
/* Test l'appui sur une touche clavier */
/* pour arrèt du programme */
/*********************************************/
 
if (kbhit())
{
caractere_recu = getch();
if (caractere_recu=='y')
{
return(0);
}
 
}
 
}
CloseHandle(com);
return(0);
}

Invité(e) · 02/10/2009, 09h43

Bonjour,

Tes trames commencent par $$, mais se finissent-elles d'une façon particulière, ont elles une taille max ?

La première chose à faire est de bien récupérer les trames ; on peut partir sur le schéma suivant :

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
booléen LiaisonValide : vrai
booléen DansTrame : faux
chaine Trame <-- taille suffisante pour contenir une trame complete
char FinTrame
char DebutTrame
 
TANT QUE LiaisonValide 
FAIRE
  LIRE UN CARACTÈRE : c
  SI DansTrame
    SI c = FinTrame
      ANALYSER Trame
    SINON
      AJOUTER c à Trame <-- attention aux débordements
    FIN SI
  SINON
    SI c = DebutTrame
        EFFACER Trame
    FIN SI
  FIN SI
 
FIN TANT QUE

L'analyse de la trame peut se faire avec sscanf bien paramétré, mais pour cela, il faut connaitre le format exact des trames.

**ritchyv** · 02/10/2009, 16h39

salut,

Les trames ne finissent pas avec un symbole spécial et oui je connais la dimension de la trame.

Ma seconde question est:
Comme tu peux le voir dans le code ma trame est stocké dans "buffer".
Dans celui-ci j'ai des données en float et en int16. Comment puis je décomposer ma trame ?

Invité(e) · 02/10/2009, 16h49

Envoyé par ritchyv

Les trames ne finissent pas avec un symbole spécial et oui je connais la dimension de la trame.

Ok dans ce cas, pour extraire une trame, il suffit de compter les caractères reçus après "$$" et de doner la trame à analyser une fois la taille connue atteinte.

Envoyé par ritchyv

Comme tu peux le voir dans le code ma trame est stocké dans "buffer".

?

Envoyé par ritchyv

Dans celui-ci j'ai des données en float et en int16. Comment puis je décomposer ma trame ?

Ça dépend du format de ta trame.
Si ta trame ressemble à :
"$$ A=<<un int16>> B=<<un float>"
on peut l'analyser avec :

Code :

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

1
2
3
4
5
6
7
8
int A;
float B;
char *trame; /* <-- trame récupéré par liaison série */
if(sscanf(trame, "$$ A=%d B=%f", &A, &B) == 2) {
    printf("lecture de la trame réussie\n");
} else {
    printf("probleme : la trame semble mal formatée\n");
}

**ritchyv** · 02/10/2009, 17h14

Envoyé par mabu

Ok dans ce cas, pour extraire une trame, il suffit de compter les caractères reçus après "$$" et de doner la trame à analyser une fois la taille connue atteinte.

?

Ça dépend du format de ta trame.
Si ta trame ressemble à :
"$$ A=<<un int16>> B=<<un float>"
on peut l'analyser avec :

Code :

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

1
2
3
4
5
6
7
8
int A;
float B;
char *trame; /* <-- trame récupéré par liaison série */
if(sscanf(trame, "$$ A=%d B=%f", &A, &B) == 2) {
    printf("lecture de la trame réussie\n");
} else {
    printf("probleme : la trame semble mal formatée\n");
}

d'après mon code est ce que ta variable "trame" est la même que ma variable "buffer" ? car j'ai fais le test avec ton code de détection mais il me dit "probleme : la trame semble mal formatée"

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
 
 
 
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
 
/*=============================================================================
  Définition de constantes
=============================================================================*/
#define RX_SIZE         4096    /* taille tampon d'entrée  */
#define TX_SIZE         4096    /* taille tampon de sortie */
#define MAX_WAIT_READ   5000    /* temps max d'attente pour lecture (en ms) */
 
 
/*=============================================================================
  Variables globales.
=============================================================================*/
 
/* Handle du port COM ouvert */
HANDLE g_hCOM = NULL;
 
/* Délais d'attente sur le port COM */
COMMTIMEOUTS g_cto =
{
    MAX_WAIT_READ,  /* ReadIntervalTimeOut          */
    0,              /* ReadTotalTimeOutMultiplier   */
    MAX_WAIT_READ,  /* ReadTotalTimeOutConstant     */
    0,              /* WriteTotalTimeOutMultiplier  */
    0               /* WriteTotalTimeOutConstant    */
};
 
/* Configuration du port COM */
DCB g_dcb =
{
    sizeof(DCB),        /* DCBlength            */
    115200,               /* BaudRate             */
    TRUE,               /* fBinary              */
    FALSE,              /* fParity              */
    FALSE,              /* fOutxCtsFlow         */
    FALSE,              /* fOutxDsrFlow         */
    DTR_CONTROL_ENABLE, /* fDtrControl          */
    FALSE,              /* fDsrSensitivity      */
    FALSE,              /* fTXContinueOnXoff    */
    FALSE,              /* fOutX                */
    FALSE,              /* fInX                 */
    FALSE,              /* fErrorChar           */
    FALSE,              /* fNull                */
    RTS_CONTROL_ENABLE, /* fRtsControl          */
    FALSE,              /* fAbortOnError        */
    0,                  /* fDummy2              */
    0,                  /* wReserved            */
    0x100,              /* XonLim               */
    0x100,              /* XoffLim              */
    8,                  /* ByteSize             */
    NOPARITY,           /* Parity               */
    ONESTOPBIT,         /* StopBits             */
    0x11,               /* XonChar              */
    0x13,               /* XoffChar             */
    '?',                /* ErrorChar            */
    0x1A,               /* EofChar              */
    0x10                /* EvtChar              */
};
 
/*=============================================================================
  Fonctions du module.
=============================================================================*/
BOOL OpenCOM    (int nId);
BOOL CloseCOM   ();
BOOL ReadCOM    (void* buffer, int nBytesToRead, int* pBytesRead);
BOOL WriteCOM   (void* buffer, int nBytesToWrite, int* pBytesWritten);
 
/******************************************************************************
  main : point d'entrée du programme.
******************************************************************************/
int main()
{
    /* variables locales */
    char buffer[9],caractere_recu;
    int nId, nChoice, nBytesWritten, nBytesRead;
    int i;
    char essai;
 
 
 
 
 
    /* demande du numéro du port COM */
   // printf("Entrez le numero du port COM : ");
//    scanf("%d", &nId);
 
/* demande du numéro du port COM */
       nId=1;       //COM1
    /* tentative d'ouverture */
    printf("Ouverture et configuration du port COM%d...\r\n", nId);
    if(!OpenCOM(nId)) return -1;
    printf("...OK\r\n");
 
    /* boucle tant que l'on ne quitte pas */
    while (1)
 
      {
        /* recevoir des données */
 
            printf("\r\n");
            printf("Reception de donnees...\r\n");
            if(ReadCOM(buffer, sizeof(buffer)-1, &nBytesRead))
            {
                buffer[nBytesRead] = '\0';               
 
 
 
                printf("%d octet(s) recu(s) :\r\n %s\r\n", nBytesRead, buffer);
 
            }
            else
                printf("Erreur lors de la réception.\r\n");
 
 
     /*********************************************/
/*     Test l'appui sur une touche clavier   */
/*      pour arrèt du programme              */
/*********************************************/
 
                if (kbhit()) 
 
        { 
			caractere_recu = getch(); 
			if (caractere_recu=='y')
			{	
                 /* fermeture du port COM et retour */
                CloseCOM();				
            	return(0);
			}	
 
		}
 
 
 
}
 
}
 
/******************************************************************************
  OpenCOM : ouverture et configuration du port COM.
  entrée : nId : Id du port COM à ouvrir.
  retour : vrai si l'opération a réussi, faux sinon.
******************************************************************************/
BOOL OpenCOM(int nId)
{
    /* variables locales */
    char szCOM[16];
 
    /* construction du nom du port, tentative d'ouverture */
    sprintf(szCOM, "COM%d", nId);
    g_hCOM = CreateFile(szCOM, GENERIC_READ|GENERIC_WRITE, 0, NULL,
                        OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM, NULL);
    if(g_hCOM == INVALID_HANDLE_VALUE)
    {
        printf("Erreur lors de l'ouverture du port COM%d", nId);
        return FALSE;
    }
 
    /* affectation taille des tampons d'émission et de réception */
    SetupComm(g_hCOM, RX_SIZE, TX_SIZE);
 
    /* configuration du port COM */
    if(!SetCommTimeouts(g_hCOM, &g_cto) || !SetCommState(g_hCOM, &g_dcb))
    {
        printf("Erreur lors de la configuration du port COM%d", nId);
        CloseHandle(g_hCOM);
        return FALSE;
    }
 
    /* on vide les tampons d'émission et de réception, mise à 1 DTR */
    PurgeComm(g_hCOM, PURGE_TXCLEAR|PURGE_RXCLEAR|PURGE_TXABORT|PURGE_RXABORT);
    EscapeCommFunction(g_hCOM, SETDTR);
    return TRUE;
}
 
/******************************************************************************
  CloseCOM : fermeture du port COM.
  retour : vrai si l'opération a réussi, faux sinon.
******************************************************************************/
BOOL CloseCOM()
{
    /* fermeture du port COM */
    CloseHandle(g_hCOM);
    return TRUE;
}
 
/******************************************************************************
  ReadCOM : lecture de données sur le port COM.
  entrée : buffer       : buffer où mettre les données lues.
           nBytesToRead : nombre max d'octets à lire.
           pBytesRead   : variable qui va recevoir le nombre d'octets lus.
  retour : vrai si l'opération a réussi, faux sinon.
-------------------------------------------------------------------------------
  Remarques : - la constante MAX_WAIT_READ utilisée dans la structure
                COMMTIMEOUTS permet de limiter le temps d'attente si aucun
                caractères n'est présent dans le tampon d'entrée.
              - la fonction peut donc retourner vrai sans avoir lu de données.
******************************************************************************/
BOOL ReadCOM(void* buffer, int nBytesToRead, int* pBytesRead)
{
    return ReadFile(g_hCOM, buffer, nBytesToRead, pBytesRead, NULL);
}
 
/******************************************************************************
  WriteCOM : envoi de données sur le port COM.
  entrée : buffer        : buffer avec les données à envoyer.
           nBytesToWrite : nombre d'octets à envoyer.
           pBytesWritten : variable qui va recevoir le nombre d'octets
                           envoyés.
  retour : vrai si l'opération a réussi, faux sinon.
******************************************************************************/
BOOL WriteCOM(void* buffer, int nBytesToWrite, int* pBytesWritten)
{
    /* écriture sur le port */
    return WriteFile(g_hCOM, buffer, nBytesToWrite, pBytesWritten, NULL);
}

Invité(e) · 02/10/2009, 17h36

Envoyé par ritchyv

d'après mon code est ce que ta variable "trame" est la même que ma variable "buffer" ? car j'ai fais le test avec ton code de détection mais il me dit "probleme : la trame semble mal formatée"

Comment est formatée ta trame ?

Comment écris tu ton appel à sscanf ?

lire trame sur port série

C

Vue hybride

Discussions similaires

Partager

Partager