Sous échantillonnage dans une liaison serie

**riadhz** · 05/06/2007, 19h01

Bonjour,
J'ai une liaison série 422 mono directionnelle asynchrone, qui émet les trames avec une fréquence de 50 Hz.
Dans la réception, il faut recevoir les données avec une fréquence de 1Hz. Donc il faut sous échantillonner les trames : Lire un message chaque seconde.
Et pour lire un message du buffer je vais utilisé la fonction suivante:

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
receive(CMessage* i_message)
{
 
    DWORD      dwRes;
    DWORD      dwCommEvent;
    DWORD      dwOvRes;
	BOOL       fWaitingOnStat = FALSE;
	char       chread[2];
 
    DWORD      dwRead   = 0;
    OVERLAPPED osReader = {0};
    LPDWORD    lpErrors = 0;
	int        i        = 0;
	chread[0]           = m_Context->getEventChar();
	chread[1]           = 0;
 
    if (m_WaitOnRead == 0) 
    {                
        /* Lancer une opération d'attente du car spéciale           */
 
        /* 
         * Si le car spéciale n'est pas arrivé, la méthode d'attente à 
         * retournée immédiatement avec une erreur. On traite l'erreur 
         */
        if (!WaitCommEvent(m_PortHandle, 
                           &dwCommEvent, 
                           &m_osStatus)) 
        {
            /* Si l'opération est en cours */
            if (GetLastError() == ERROR_IO_PENDING)
            {
                m_WaitOnRead = 1;
            }
 
            /* Si l'attente retourne un cas d'erreur */
            else
            { 
                return;
            }
        }
 
        /* 
         * le car spéciale est arrivé, la méthode d'attente a retournée
         * immédiatement. On lit les données qui sont dans le buffer de
         * lecture du port.
         */
        else
        {
			i_message->m_data = "";
			i                   = 0;
 
			ReadFile(m_PortHandle,chread,1,&dwRead,&osReader);
			while (chread[0] != m_Context->getEventChar())
			{
				if (chread[0] == 0)
				{
					i_message->m_data.append("-");
					i_message->m_data[i_message->m_data.length() -1] = 0;
				}
				else
				{
					i_message->m_data.append(chread);
				}						
				ReadFile(m_PortHandle,chread,1,&dwRead,&osReader);
				i++;
			}
			i_message->m_data.append( chread);
 
        }
    }
 
	/* Attendre le résultat de l'opération d'attente en cours */
    if (m_WaitOnRead == 1) 
    {
 
        dwRes = WaitForSingleObject(m_osStatus.hEvent,m_Context->getReadTimeOut());
 
        /* traiter le résultat de l'attente */
        switch(dwRes)
        {
 
            /* 
             * Un évennement s'est produit, on test s'il s'agit 
             * d'une erreur ou que le car spéciale est arrivé. 
             */
            case WAIT_OBJECT_0: 
 
                /* Erreur */
                if (!GetOverlappedResult(m_PortHandle,&m_osStatus,&dwOvRes,FALSE))
                {
					m_WaitOnRead = 0;
                    return;
                }
                /* Car spéciale arrivé */
                else
                {
					i_message->m_data = "";
					i                   = 0;
 
					ReadFile(m_PortHandle,chread,1,&dwRead,&osReader);
					while (chread[0] != m_Context->getEventChar())
					{
						if (chread[0] == 0)
						{
							i_message->m_data.append("-");
							i_message->m_data[i_message->m_data.length() -1] = 0;
						}
						else
						{
							i_message->m_data.append(chread);
						}						
						ReadFile(m_PortHandle,chread,1,&dwRead,&osReader);
						i++;
					}
					i_message->m_data.append( chread);
					m_WaitOnRead   = 0;					
                }                
                break;
 
 
            /* Le time out s'est écoulé sans que le car spéciale arrive */
            case WAIT_TIMEOUT:  
 
				CancelIo(m_PortHandle);
				m_WaitOnRead = 0;
 
//				TRACE ("LNK_CLinkRS::Receive - ERROR READING TIMEOUT\n");
                break;
 
            /* traiter les cas restants */
            default:
 
				CancelIo(m_PortHandle);
				m_WaitOnRead = 0;
 
                break;
        }
    }
}

Et pour lire les messages, je vais utilisé un thread.
Ma question est: Est ce qu'il suffit d'appeler la fonction receive chaque seconde pour lire les messages avec une frequence de 1Hz (Donc, il faut que la fonction receive lit le dernier message reçu) ?
Ou il faut lire tous les messages et prendre le 51 ème (puisque l'envoie est à 50Hz) sachant que la liaison est asynchrone? sinon y a t'il une autre solution?

Merci pour vos aides