##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » lppserial
RSS

Clone from http://pc-instru.lpp.polytechnique.fr:5000/lppserial

Win32 read timeout between bytes set to a more realistic value
jeandet -
r43:a38235df29ea alexis
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,386 +1,386
1 1 #include "rs232config.h"
2 2 #include <stdio.h>
3 3 #include <unistd.h>
4 4 #include <fcntl.h>
5 5 #include <string.h>
6 6 #include <errno.h>
7 7 #include <malloc.h>
8 8
9 9 #ifdef HAVE_WINDOWS_H
10 10 #include <windows.h>
11 11 #endif
12 12 #include "RS232.h"
13 13
14 14 #ifdef HAVE_WINDOWS_H
15 15
16 16
17 17 int privatedecodeparity(rs232parity Parity )
18 18 {
19 19 switch(Parity)
20 20 {
21 21 case rs232parityNo:
22 22 return NOPARITY;
23 23 break;
24 24 case rs232parityOdd:
25 25 return ODDPARITY;
26 26 break;
27 27 case rs232parityEven:
28 28 return EVENPARITY;
29 29 break;
30 30 default:
31 31 return NOPARITY;
32 32 break;
33 33 }
34 34 }
35 35
36 36 int privatedecodestop(rs232stop NbStop)
37 37 {
38 38 switch(NbStop)
39 39 {
40 40 case rs232OneStop:
41 41 return ONESTOPBIT;
42 42 break;
43 43 case rs232One5Stop:
44 44 return ONE5STOPBITS;
45 45 break;
46 46 case rs232TwoStop:
47 47 return TWOSTOPBITS;
48 48 break;
49 49 default:
50 50 return ONESTOPBIT;
51 51 break;
52 52 }
53 53 }
54 54
55 55
56 56
57 57 rs232speed_t rs232cfspeed(unsigned int BaudeRate)
58 58 {
59 59
60 60 if(BaudeRate<123)
61 61 return (rs232speed_t)CBR_110;
62 62
63 63 if(BaudeRate<450)
64 64 return (rs232speed_t)CBR_300;
65 65
66 66 if(BaudeRate<900)
67 67 return (rs232speed_t)CBR_600;
68 68
69 69 if(BaudeRate<1500)
70 70 return (rs232speed_t)CBR_1200;
71 71
72 72 if(BaudeRate<3600)
73 73 return (rs232speed_t)CBR_2400;
74 74
75 75 if(BaudeRate<7200)
76 76 return (rs232speed_t)CBR_4800;
77 77
78 78 if(BaudeRate<14000)
79 79 return (rs232speed_t)CBR_9600;
80 80
81 81 if(BaudeRate<16800)
82 82 return (rs232speed_t)CBR_14400;
83 83
84 84 if(BaudeRate<28800)
85 85 return (rs232speed_t)CBR_19200;
86 86
87 87 if(BaudeRate<48000)
88 88 return (rs232speed_t)CBR_38400;
89 89
90 90 if(BaudeRate<86400)
91 91 return (rs232speed_t)CBR_57600;
92 92
93 93 if(BaudeRate<172800)
94 94 return (rs232speed_t)CBR_115200;
95 95
96 96 if(BaudeRate<345600)
97 97 return (rs232speed_t)230400;
98 98
99 99 if(BaudeRate<345600)
100 100 return (rs232speed_t)460800;
101 101
102 102 if(BaudeRate<748800)
103 103 return (rs232speed_t)576000;
104 104
105 105 if(BaudeRate<1210800)
106 106 return (rs232speed_t)921600;
107 107
108 108 if(BaudeRate<1750000)
109 109 return (rs232speed_t)1500000;
110 110
111 111 if(BaudeRate<2250000)
112 112 return (rs232speed_t)2000000;
113 113
114 114 if(BaudeRate<2750000)
115 115 return (rs232speed_t)2500000;
116 116 else
117 117 return (rs232speed_t)3000000;
118 118 }
119 119
120 120
121 121 rs232port_t rs232open(char* psPortName)
122 122 {
123 123 rs232port_t fd;
124 124 fd = (rs232port_t)CreateFile(psPortName,GENERIC_READ | GENERIC_WRITE,0,0,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
125 125 #ifdef RS232_debug
126 126 if(fd==(rs232port_t)INVALID_HANDLE_VALUE)
127 127 {
128 128 printf("can't open Port\n");
129 129 return (rs232port_t)badPortValue;
130 130 }
131 131 #endif
132 132 return fd;
133 133 }
134 134
135 135 int rs232close(rs232port_t fd)
136 136 {
137 137 if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
138 138 {
139 139 return (rs232port_t)badPortValue;
140 140 }
141 141 else
142 142 {
143 143 CloseHandle((HANDLE)fd);
144 144 return rs232noerr;
145 145 }
146 146 }
147 147
148 148 rs232portslist_t* rs232getportlist() //here is the very dirty way!
149 149 {
150 150 int i=0;
151 151 char devName[]="COM111";
152 152 rs232port_t testport;
153 153 rs232portslist_t* firstitem=NULL;
154 154 rs232portslist_t* previtem=NULL;
155 155 for(i=0;i<256;i++)
156 156 {
157 157 devName[3] = '\0';
158 158 devName[4] = '\0';
159 159 devName[5] = '\0';
160 160 devName[6] = '\0';
161 161 sprintf(devName+3,"%d",i);
162 162 testport= rs232open(devName);
163 163 if(testport != (rs232port_t)badPortValue)
164 164 {
165 165 rs232portslist_t* item = (rs232portslist_t*)malloc(sizeof(rs232portslist_t));
166 166 char* name = (char*)malloc(7);
167 167 strcpy(name,devName);
168 168 item->name = name;
169 169 item->next = NULL;
170 170 if(NULL!=previtem)previtem->next = item;
171 171 previtem = item;
172 172 if(NULL==firstitem)firstitem = item;
173 173 rs232close(testport);
174 174 }
175 175 }
176 176 return firstitem;
177 177 }
178 178
179 179 void rs232deleteportlist(rs232portslist_t* list)
180 180 {
181 181 if(list!=NULL)
182 182 {
183 183 if(list->next != NULL)
184 184 rs232deleteportlist(list->next);
185 185 free(list);
186 186 }
187 187 }
188 188
189 189
190 190 int rs232setup(rs232port_t fd, int ChSize, int BaudeRate, rs232parity Parity, rs232stop NbStop)
191 191 {
192 192 if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
193 193 {
194 194 return (rs232port_t)badPortValue;
195 195 }
196 196 else
197 197 {
198 198 DCB dcbSerialParams = {0};
199 199 dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
200 200 GetCommState((HANDLE)fd, &dcbSerialParams);
201 201 dcbSerialParams.BaudRate=rs232cfspeed(BaudeRate);
202 202 dcbSerialParams.ByteSize=ChSize;
203 203 dcbSerialParams.StopBits=privatedecodestop(NbStop);
204 204 dcbSerialParams.Parity=privatedecodeparity(Parity);
205 205 SetCommState((HANDLE)fd, &dcbSerialParams);
206 206 COMMTIMEOUTS timeouts={0};
207 timeouts.ReadIntervalTimeout=100;
207 timeouts.ReadIntervalTimeout=5;
208 208 timeouts.ReadTotalTimeoutConstant=100;
209 209 timeouts.ReadTotalTimeoutMultiplier=1;
210 210 timeouts.WriteTotalTimeoutConstant=100;
211 211 timeouts.WriteTotalTimeoutMultiplier=10;
212 212 SetCommTimeouts((HANDLE)fd, &timeouts);
213 213 return rs232noerr;
214 214 }
215 215 }
216 216
217 217 int rs232setbaudrate(rs232port_t fd, int baudrate)
218 218 {
219 219 if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
220 220 {
221 221 return (rs232port_t)badPortValue;
222 222 }
223 223 else
224 224 {
225 225 DCB dcbSerialParams = {0};
226 226 dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
227 227 GetCommState((HANDLE)fd, &dcbSerialParams);
228 228 dcbSerialParams.BaudRate=rs232cfspeed(baudrate);
229 229 SetCommState((HANDLE)fd, &dcbSerialParams);
230 230 return rs232noerr;
231 231 }
232 232 }
233 233
234 234 int rs232setparity(rs232port_t fd, rs232parity Parity)
235 235 {
236 236 if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
237 237 {
238 238 return (rs232port_t)badPortValue;
239 239 }
240 240 else
241 241 {
242 242 DCB dcbSerialParams = {0};
243 243 dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
244 244 GetCommState((HANDLE)fd, &dcbSerialParams);
245 245 dcbSerialParams.Parity = privatedecodeparity(Parity);
246 246 SetCommState((HANDLE)fd, &dcbSerialParams);
247 247 return rs232noerr;
248 248 }
249 249 }
250 250
251 251 int rs232setnbstop(rs232port_t fd, rs232stop NbStop)
252 252 {
253 253 if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
254 254 {
255 255 return (rs232port_t)badPortValue;
256 256 }
257 257 else
258 258 {
259 259 DCB dcbSerialParams = {0};
260 260 dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
261 261 GetCommState((HANDLE)fd, &dcbSerialParams);
262 262 dcbSerialParams.StopBits = privatedecodestop(NbStop);
263 263 SetCommState((HANDLE)fd, &dcbSerialParams);
264 264 return rs232noerr;
265 265 }
266 266 }
267 267
268 268
269 269 int rs232setcsize(rs232port_t fd, int ChSize)
270 270 {
271 271 if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
272 272 {
273 273 return (rs232port_t)badPortValue;
274 274 }
275 275 else
276 276 {
277 277 DCB dcbSerialParams = {0};
278 278 dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
279 279 GetCommState((HANDLE)fd, &dcbSerialParams);
280 280 dcbSerialParams.ByteSize = ChSize;
281 281 SetCommState((HANDLE)fd, &dcbSerialParams);
282 282 return rs232noerr;
283 283 }
284 284 }
285 285
286 286
287 287
288 288
289 289
290 290
291 291 int rs232write(rs232port_t fd,char *psWrite, int WriteBufferSize)
292 292 {
293 293
294 294 if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
295 295 {
296 296 return (rs232port_t)badPortValue;
297 297 }
298 298 else
299 299 {
300 300 DWORD dwBytesWriten = 0;
301 301 WriteFile((HANDLE)fd, psWrite, WriteBufferSize, &dwBytesWriten, NULL);
302 302 return dwBytesWriten;
303 303 }
304 304 }
305 305
306 306
307 307 int rs232read(rs232port_t fd,char *psRead, int ReadBufferSize)
308 308 {
309 309
310 310 if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
311 311 {
312 312 return (rs232port_t)badPortValue;
313 313 }
314 314 else
315 315 {
316 316 DWORD dwBytesRead = 0;
317 317 ReadFile((HANDLE)fd, psRead, ReadBufferSize, &dwBytesRead, NULL);
318 318 return dwBytesRead;
319 319 }
320 320
321 321 }
322 322
323 323
324 324 int rs232saferead(rs232port_t fd,char* data,int count )
325 325 {
326 326 int read=0;
327 327 int i=0;
328 328 for(i=0;i<100;i++)
329 329 {
330 330 read = rs232read(fd,data,count);
331 331 count -=read;
332 332 data+=read;
333 333 if(count==0)
334 334 return rs232noerr;
335 335 }
336 336 return -1;
337 337 }
338 338
339 339
340 340
341 341 int rs232safewrite(rs232port_t fd,char* data,int count)
342 342 {
343 343 int written=0;
344 344 int i=0;
345 345 for(i=0;i<1000;i++)
346 346 {
347 347 written = rs232write(fd,data+written,count);
348 348 count-=written;
349 349 data+=written;
350 350 if(count==0)
351 351 return rs232noerr;
352 352 }
353 353 return -1;
354 354 }
355 355
356 356
357 357 int rs232setRTS(rs232port_t fd)
358 358 {
359 359 if(EscapeCommFunction((HANDLE)fd, CLRRTS))
360 360 return rs232noerr;
361 361 return -1;
362 362 }
363 363
364 364 int rs232clearRTS(rs232port_t fd)
365 365 {
366 366 if(EscapeCommFunction((HANDLE)fd, SETRTS))
367 367 return rs232noerr;
368 368 return -1;
369 369 }
370 370
371 371 int rs232setDTR(rs232port_t fd)
372 372 {
373 373 if(EscapeCommFunction((HANDLE)fd, CLRDTR))
374 374 return rs232noerr;
375 375 return -1;
376 376 }
377 377
378 378
379 379 int rs232clearDTR(rs232port_t fd)
380 380 {
381 381 if(EscapeCommFunction((HANDLE)fd, SETDTR))
382 382 return rs232noerr;
383 383 return -1;
384 384 }
385 385
386 386 #endif //#ifdef HAVE_WINDOWS_H
General Comments 0
You need to be logged in to leave comments. Login now