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

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

Replaced debug define by RS232_debug.
Jeandet Alexis -
r40:06a15f9219de alexis
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,52 +1,52
1 1 // SOPSUYSI_RS232.h
2 2 #ifndef RS232_H
3 3 #define RS232_H
4 #define debug
4 #define RS232_debug
5 5
6 6 #define badPortValue -1
7 7 #define rs232noerr 0
8 8 typedef int rs232port_t;
9 9 typedef int rs232speed_t;
10 10 typedef enum {rs232OneStop,rs232One5Stop,rs232TwoStop}rs232stop;
11 11 typedef enum {rs232parityNo,rs232parityOdd,rs232parityEven}rs232parity;
12 12
13 13 #ifdef __cplusplus
14 14 extern "C" {
15 15 #endif
16 16 typedef struct rs232portslist_t
17 17 {
18 18 char* name;
19 19 struct rs232portslist_t* next;
20 20 }rs232portslist_t;
21 21 #ifdef __cplusplus
22 22 }
23 23 #endif
24 24
25 25
26 26 #ifdef __cplusplus
27 27 #define rs232extern extern "C"
28 28 #else
29 29 #define rs232extern extern
30 30 #endif
31 31 rs232extern rs232port_t rs232open(char* psPortName);
32 32 rs232extern rs232portslist_t* rs232getportlist();
33 33 rs232extern void rs232deleteportlist(rs232portslist_t* list);
34 34 rs232extern int rs232close(rs232port_t fd);
35 35 rs232extern int rs232setup(rs232port_t fd, int ChSize, int BaudeRate, rs232parity Parity, rs232stop NbStop);
36 36 rs232extern int rs232write(rs232port_t fd,char *psWrite, int WriteBufferSize);
37 37 rs232extern int rs232read(rs232port_t fd,char *psRead, int ReadBufferSize);
38 38 rs232extern int rs232setparity(rs232port_t fd, rs232parity Parity);
39 39 rs232extern int rs232setnbstop(rs232port_t fd, rs232stop NbStop);
40 40 rs232extern int rs232setcsize(rs232port_t fd, int ChSize);
41 41 rs232extern int rs232setbaudrate(rs232port_t fd, int baudrate);
42 42 rs232extern int rs232setRTS(rs232port_t fd);
43 43 rs232extern int rs232clearRTS(rs232port_t fd);
44 44 rs232extern int rs232setDTR(rs232port_t fd);
45 45 rs232extern int rs232clearDTR(rs232port_t fd);
46 46 rs232extern int rs232saferead(rs232port_t fd,char* data,int count );
47 47 rs232extern int rs232safewrite(rs232port_t fd,char* data,int count);
48 48
49 49 #endif
50 50
51 51
52 52
Show file before | Show file after | Hide comments
@@ -1,536 +1,536
1 1 #include <stdio.h>
2 2 #include <unistd.h>
3 3 #include <fcntl.h>
4 4 #include <string.h>
5 5 #include <errno.h>
6 6 #include <malloc.h>
7 7 #include <dirent.h>
8 8 #include <limits.h>
9 9 #include <stdlib.h>
10 10 #include <sys/stat.h>
11 11 #include "rs232config.h"
12 12
13 13 #ifdef HAVE_TERMIOS_H
14 14 #include <termios.h>
15 15 #endif
16 16 #ifdef HAVE_TERMIO_H
17 17 #include <termio.h>
18 18 #endif
19 19 #include "RS232.h"
20 20
21 21 #ifdef HAVE_WINDOWS_H
22 22 #else
23 23 #ifdef HAVE_TERMIOS_H
24 24 rs232speed_t rs232cfspeed(unsigned int BaudeRate);
25 25
26 26 rs232port_t rs232open(char* psPortName)
27 27 {
28 28 rs232port_t fd;
29 29 int flags;
30 30 fd = (rs232port_t)open(psPortName, O_RDWR | O_NOCTTY );//| O_NDELAY);
31 31 //fcntl((int)fd, F_SETFL, FNDELAY);
32 32 //fd = open(psPortName, O_RDWR | O_NOCTTY);
33 #ifdef debug
33 #ifdef RS232_debug
34 34 if(fd==-1)printf("can't open Port\n");
35 35 #else
36 36 if(fd!=-1)
37 37 {
38 38 //flags = fcntl(fd, F_GETFL);
39 39 //flags |= O_NONBLOCK;
40 40 //flags|=FNDELAY;
41 41 //fcntl(fd, F_SETFL, flags);
42 42 //fcntl((int)fd, F_SETFL, FNDELAY);
43 43 }
44 44
45 45 #endif
46 46 return fd;
47 47 }
48 48
49 49 int rs232close(rs232port_t fd)
50 50 {
51 51 if ((int)fd == -1)
52 52 {
53 53 return -1;
54 54 }
55 55 else
56 56 {
57 57 close(fd);
58 58 return 0;
59 59 }
60 60 }
61 61
62 62 rs232portslist_t* rs232getportlist()
63 63 {
64 64 struct dirent *dp;
65 65 char* path="/dev/serial/by-id";
66 66 DIR *dir = opendir(path);
67 67 rs232portslist_t* firstitem=NULL;
68 68 rs232portslist_t* previtem=NULL;
69 69 char linkname[1024];
70 70 int i=0;
71 71 if(dir!=NULL)
72 72 {
73 73 while ((dp=readdir(dir)) != NULL)
74 74 {
75 75 char* name = (char*)malloc(1024);
76 76 for(i=0;i<1024;i++)
77 77 {
78 78 name[i]='\0';
79 79 linkname[i]='\0';
80 80 }
81 81 struct stat statbuf;
82 82 strcpy(linkname,path);
83 83 strcat(linkname,"/");
84 84 strcat(linkname,dp->d_name);
85 85 lstat(linkname, &statbuf);
86 86 if(S_ISLNK(statbuf.st_mode))
87 87 {
88 88 if(-1!=readlink(linkname,name,1024))
89 89 {
90 90 for(i=0;i<1024;i++)
91 91 {
92 92 linkname[i]='\0';
93 93 }
94 94 strcpy(linkname,path);
95 95 strcat(linkname,"/");
96 96 strcat(linkname,name);
97 97 for(i=0;i<1024;i++)
98 98 {
99 99 name[i]='\0';
100 100 }
101 101 if(NULL!=realpath(linkname, name))
102 102 {
103 103 rs232portslist_t* item = (rs232portslist_t*)malloc(sizeof(rs232portslist_t));
104 104 item->name = name;
105 105 item->next = NULL;
106 106 if(NULL!=previtem)previtem->next = item;
107 107 previtem = item;
108 108 if(NULL==firstitem)firstitem = item;
109 109 }
110 110
111 111 }
112 112 }
113 113
114 114 }
115 115 }
116 116 return firstitem;
117 117 }
118 118
119 119 void rs232deleteportlist(rs232portslist_t* list)
120 120 {
121 121 if(list!=NULL)
122 122 {
123 123 if(list->next != NULL)
124 124 rs232deleteportlist(list->next);
125 125 free(list);
126 126 }
127 127 }
128 128
129 129 int rs232setup(rs232port_t fd, int ChSize, int BaudeRate, rs232parity Parity, rs232stop NbStop)
130 130 {
131 131 if ((int)fd == -1)
132 132 {
133 133 return -1;
134 134 }
135 135 else
136 136 {
137 137 struct termios terminos;
138 138 tcgetattr(fd, &terminos);
139 139 terminos.c_iflag=0;
140 140 terminos.c_oflag=0;
141 141 terminos.c_cflag=0;
142 142 terminos.c_lflag=0;
143 143 cfsetispeed(&terminos, rs232cfspeed(BaudeRate));
144 144 cfsetospeed(&terminos, rs232cfspeed(BaudeRate));
145 145 terminos.c_cflag |= (CLOCAL | CREAD);
146 146 rs232cfparity((int)fd, &terminos, Parity);
147 147 rs232cfnbstop((int)fd, &terminos, NbStop);
148 148 rs232cfcsize((int)fd, &terminos, ChSize);
149 149 terminos.c_cc[VMIN]=0;
150 150 terminos.c_cc[VTIME]=1;
151 151 tcflush(fd, TCIFLUSH);
152 #ifdef debug
152 #ifdef RS232_debug
153 153 if(tcsetattr(fd, TCSANOW, &terminos)!=0)printf("bad setup\n");
154 154 #else
155 155 tcsetattr(fd, TCSANOW, &terminos);
156 156 #endif
157 157 return 0;
158 158 }
159 159 }
160 160
161 161 int rs232setbaudrate(rs232port_t fd, int baudrate)
162 162 {
163 163 if ((int)fd == -1)
164 164 {
165 165 return fd;
166 166 }
167 167 else
168 168 {
169 169 struct termios terminos;
170 170 tcgetattr((int)fd, &terminos);
171 171 cfsetispeed(&terminos, rs232cfspeed(baudrate));
172 172 cfsetospeed(&terminos, rs232cfspeed(baudrate));
173 173 tcsetattr((int)fd, TCSANOW, &terminos);
174 174 return 0;
175 175 }
176 176 }
177 177
178 178 int rs232setparity(rs232port_t fd, rs232parity Parity)
179 179 {
180 180 if ((int)fd == -1)
181 181 {
182 182 return fd;
183 183 }
184 184 else
185 185 {
186 186 struct termios terminos;
187 187 tcgetattr((int)fd, &terminos);
188 188 terminos.c_cflag &= ~PARENB;
189 189 terminos.c_cflag &= ~PARODD;
190 190 switch(Parity)
191 191 {
192 192 case rs232parityNo:
193 193 terminos.c_cflag &= ~PARENB;
194 194 break;
195 195 case rs232parityOdd:
196 196 terminos.c_cflag |= PARENB;
197 197 terminos.c_cflag |= PARODD;
198 198 break;
199 199 case rs232parityEven:
200 200 terminos.c_cflag |= PARENB;
201 201 terminos.c_cflag &= ~PARODD;
202 202 break;
203 203 default:
204 204 terminos.c_cflag &= ~PARENB;
205 205 break;
206 206 }
207 207 tcsetattr((int)fd, TCSANOW, &terminos);
208 208 return 0;
209 209 }
210 210 }
211 211
212 212 int rs232setnbstop(rs232port_t fd, rs232stop NbStop)
213 213 {
214 214 if ((int)fd == -1)
215 215 {
216 216 return fd;
217 217 }
218 218 else
219 219 {
220 220 struct termios terminos;
221 221 tcgetattr((int)fd, &terminos);
222 222 switch(NbStop)
223 223 {
224 224 case rs232OneStop:
225 225 terminos.c_cflag &= ~CSTOPB;
226 226 break;
227 227 case rs232One5Stop:
228 228 terminos.c_cflag |= CSTOPB;
229 229 break;
230 230 case rs232TwoStop:
231 231 terminos.c_cflag |= CSTOPB;
232 232 break;
233 233 default:
234 234 terminos.c_cflag &= ~CSTOPB;
235 235 break;
236 236 }
237 237 tcsetattr((int)fd, TCSANOW, &terminos);
238 238 return 0;
239 239 }
240 240 }
241 241
242 242
243 243 int rs232setcsize(rs232port_t fd, int ChSize)
244 244 {
245 245 if ((int)fd == -1)
246 246 {
247 247 return fd;
248 248 }
249 249 else
250 250 {
251 251 struct termios terminos;
252 252 tcgetattr((int)fd, &terminos);
253 253 terminos.c_cflag &= ~CSIZE;
254 254 switch(ChSize)
255 255 {
256 256 case 5:
257 257 terminos.c_cflag |= CS5;
258 258 break;
259 259 case 6:
260 260 terminos.c_cflag |= CS6;
261 261 break;
262 262 case 7:
263 263 terminos.c_cflag |= CS7;
264 264 break;
265 265 default:
266 266 terminos.c_cflag |= CS8;
267 267 break;
268 268 }
269 269 tcsetattr((int)fd, TCSANOW, &terminos);
270 270 return 0;
271 271 }
272 272 }
273 273
274 274 rs232speed_t rs232cfspeed(unsigned int BaudeRate)
275 275 {
276 276 if(BaudeRate<25)
277 277 return B0;
278 278
279 279 if(BaudeRate<67)
280 280 return B50;
281 281
282 282 if(BaudeRate<93)
283 283 return B75;
284 284
285 285 if(BaudeRate<123)
286 286 return B110;
287 287
288 288 if(BaudeRate<142)
289 289 return B134;
290 290
291 291 if(BaudeRate<175)
292 292 return B150;
293 293
294 294 if(BaudeRate<250)
295 295 return B200;
296 296
297 297 if(BaudeRate<450)
298 298 return B300;
299 299
300 300 if(BaudeRate<900)
301 301 return B600;
302 302
303 303 if(BaudeRate<1500)
304 304 return B1200;
305 305
306 306 if(BaudeRate<2100)
307 307 return B1800;
308 308
309 309 if(BaudeRate<3600)
310 310 return B2400;
311 311
312 312 if(BaudeRate<7200)
313 313 return B4800;
314 314
315 315 if(BaudeRate<1400)
316 316 return B9600;
317 317
318 318 if(BaudeRate<28800)
319 319 return B19200;
320 320
321 321 if(BaudeRate<48000)
322 322 return B38400;
323 323
324 324 if(BaudeRate<86400)
325 325 return B57600;
326 326
327 327 if(BaudeRate<172800)
328 328 return B115200;
329 329 else
330 330 return B230400;
331 331 }
332 332
333 333
334 334 int rs232cfparity(int fd, struct termios *terminos, rs232parity Parity)
335 335 {
336 336 if ((int)fd == -1)
337 337 {
338 338 return fd;
339 339 }
340 340 else
341 341 {
342 342 terminos->c_cflag &= ~PARENB;
343 343 terminos->c_cflag &= ~PARODD;
344 344 switch(Parity)
345 345 {
346 346 case rs232parityNo:
347 347 terminos->c_cflag &= ~PARENB;
348 348 terminos->c_cflag &= ~PARODD;
349 349 break;
350 350 case rs232parityOdd:
351 351 terminos->c_cflag |= PARENB;
352 352 terminos->c_cflag |= PARODD;
353 353 break;
354 354 case rs232parityEven:
355 355 terminos->c_cflag |= PARENB;
356 356 terminos->c_cflag &= ~PARODD;
357 357 break;
358 358 default:
359 359 terminos->c_cflag &= ~PARENB;
360 360 terminos->c_cflag &= ~PARODD;
361 361 break;
362 362 }
363 363 return 0;
364 364 }
365 365 }
366 366
367 367 int rs232cfnbstop(int fd, struct termios *terminos, rs232stop NbStop)
368 368 {
369 369 if ((int)fd == -1)
370 370 {
371 371 return fd;
372 372 }
373 373 else
374 374 {
375 375 switch(NbStop)
376 376 {
377 377 case 2:
378 378 terminos->c_cflag |= CSTOPB;
379 379 break;
380 380 default:
381 381 terminos->c_cflag &= ~CSTOPB;
382 382 break;
383 383 }
384 384 return 0;
385 385 }
386 386 }
387 387
388 388
389 389 int rs232cfcsize(int fd, struct termios *terminos, int ChSize)
390 390 {
391 391 if ((int)fd == -1)
392 392 {
393 393 return fd;
394 394 }
395 395 else
396 396 {
397 397 terminos->c_cflag &= ~CSIZE;
398 398 switch(ChSize)
399 399 {
400 400 case 5:
401 401 terminos->c_cflag |= CS5;
402 402 break;
403 403 case 6:
404 404 terminos->c_cflag |= CS6;
405 405 break;
406 406 case 7:
407 407 terminos->c_cflag |= CS7;
408 408 break;
409 409 default:
410 410 terminos->c_cflag |= CS8;
411 411 break;
412 412 }
413 413 return 0;
414 414 }
415 415 }
416 416
417 417
418 418 int rs232write(rs232port_t fd,char *psWrite, int WriteBufferSize)
419 419 {
420 420 if ((int)fd == -1)
421 421 {
422 422 return -1;
423 423 }
424 424 else
425 425 {
426 426 return write((int)fd, psWrite, WriteBufferSize);
427 427 }
428 428 }
429 429
430 430
431 431 int rs232read(rs232port_t fd,char *psReadHex, int ReadBufferSize)
432 432 {
433 433
434 434 if ((int)fd == -1)
435 435 {
436 436 return -1;
437 437 }
438 438 else
439 439 {
440 440 return read((int)fd, psReadHex, ReadBufferSize);
441 441 }
442 442
443 443 }
444 444
445 445
446 446 int rs232setRTS(rs232port_t fd)
447 447 {
448 448 int status;
449 449 ioctl((int)fd, TIOCMGET, &status);
450 450 status &= ~TIOCM_RTS;
451 451 if (ioctl((int)fd, TIOCMSET, &status))
452 452 {
453 453 return -1;
454 454 }
455 455 return 0;
456 456 }
457 457
458 458 int rs232clearRTS(rs232port_t fd)
459 459 {
460 460 int status;
461 461 ioctl((int)fd, TIOCMGET, &status);
462 462 status |= TIOCM_RTS;
463 463 if (ioctl((int)fd, TIOCMSET, &status))
464 464 {
465 465 return -1;
466 466 }
467 467 return 0;
468 468 }
469 469
470 470 int rs232setDTR(rs232port_t fd)
471 471 {
472 472 int status;
473 473 ioctl((int)fd, TIOCMGET, &status);
474 474 status &= ~TIOCM_DTR;
475 475 if (ioctl((int)fd, TIOCMSET, &status))
476 476 {
477 477 return -1;
478 478 }
479 479 return 0;
480 480 }
481 481
482 482
483 483 int rs232clearDTR(rs232port_t fd)
484 484 {
485 485 int status;
486 486 ioctl((int)fd, TIOCMGET, &status);
487 487 status |= TIOCM_DTR;
488 488 if (ioctl((int)fd, TIOCMSET, &status))
489 489 {
490 490 return -1;
491 491 }
492 492 return 0;
493 493 }
494 494
495 495
496 496
497 497 int rs232saferead(rs232port_t fd,char* data,int count )
498 498 {
499 499 int read=0;
500 500 int i=0;
501 501 for(i=0;i<1000;i++)
502 502 {
503 503 read = rs232read((int)fd,data,count);
504 504 //printf("read %d bytes\n",read);
505 505 if(read==-1)read=0;
506 506 count-=read;
507 507 data+=read;
508 508 if(count==0)
509 509 return 0;
510 510 usleep(10);
511 511 }
512 512 return -1;
513 513 }
514 514
515 515
516 516
517 517 int rs232safewrite(rs232port_t fd,char* data,int count)
518 518 {
519 519 int written=0;
520 520 int i=0;
521 521 for(i=0;i<1000;i++)
522 522 {
523 523 written = rs232write((int)fd,data+written,count);
524 524 //printf("%d bytes written\n",written);
525 525 if(written==-1)written=0;
526 526 count-=written;
527 527 data+=written;
528 528 if(count==0)
529 529 return 0;
530 530 }
531 531 return -1;
532 532 }
533 533
534 534 #endif
535 535 #endif //#ifdef HAVE_TERMIOS_H
536 536
Show file before | Show file after | Hide comments
@@ -1,365 +1,365
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 else
96 96 return (rs232speed_t)CBR_256000;
97 97 }
98 98
99 99
100 100 rs232port_t rs232open(char* psPortName)
101 101 {
102 102 rs232port_t fd;
103 103 fd = (rs232port_t)CreateFile(psPortName,GENERIC_READ | GENERIC_WRITE,0,0,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
104 #ifdef debug
104 #ifdef RS232_debug
105 105 if(fd==(rs232port_t)INVALID_HANDLE_VALUE)
106 106 {
107 107 printf("can't open Port\n");
108 108 return (rs232port_t)badPortValue;
109 109 }
110 110 #endif
111 111 return fd;
112 112 }
113 113
114 114 int rs232close(rs232port_t fd)
115 115 {
116 116 if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
117 117 {
118 118 return (rs232port_t)badPortValue;
119 119 }
120 120 else
121 121 {
122 122 CloseHandle((HANDLE)fd);
123 123 return rs232noerr;
124 124 }
125 125 }
126 126
127 127 rs232portslist_t* rs232getportlist() //here is the very dirty way!
128 128 {
129 129 int i=0;
130 130 char devName[]="COM111";
131 131 rs232port_t testport;
132 132 rs232portslist_t* firstitem=NULL;
133 133 rs232portslist_t* previtem=NULL;
134 134 for(i=0;i<256;i++)
135 135 {
136 136 devName[3] = '\0';
137 137 devName[4] = '\0';
138 138 devName[5] = '\0';
139 139 devName[6] = '\0';
140 140 sprintf(devName+3,"%d",i);
141 141 testport= rs232open(devName);
142 142 if(testport != (rs232port_t)badPortValue)
143 143 {
144 144 rs232portslist_t* item = (rs232portslist_t*)malloc(sizeof(rs232portslist_t));
145 145 char* name = (char*)malloc(7);
146 146 strcpy(name,devName);
147 147 item->name = name;
148 148 item->next = NULL;
149 149 if(NULL!=previtem)previtem->next = item;
150 150 previtem = item;
151 151 if(NULL==firstitem)firstitem = item;
152 152 rs232close(testport);
153 153 }
154 154 }
155 155 return firstitem;
156 156 }
157 157
158 158 void rs232deleteportlist(rs232portslist_t* list)
159 159 {
160 160 if(list!=NULL)
161 161 {
162 162 if(list->next != NULL)
163 163 rs232deleteportlist(list->next);
164 164 free(list);
165 165 }
166 166 }
167 167
168 168
169 169 int rs232setup(rs232port_t fd, int ChSize, int BaudeRate, rs232parity Parity, rs232stop NbStop)
170 170 {
171 171 if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
172 172 {
173 173 return (rs232port_t)badPortValue;
174 174 }
175 175 else
176 176 {
177 177 DCB dcbSerialParams = {0};
178 178 dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
179 179 GetCommState((HANDLE)fd, &dcbSerialParams);
180 180 dcbSerialParams.BaudRate=rs232cfspeed(BaudeRate);
181 181 dcbSerialParams.ByteSize=ChSize;
182 182 dcbSerialParams.StopBits=privatedecodestop(NbStop);
183 183 dcbSerialParams.Parity=privatedecodeparity(Parity);
184 184 SetCommState((HANDLE)fd, &dcbSerialParams);
185 185 COMMTIMEOUTS timeouts={0};
186 186 timeouts.ReadIntervalTimeout=100;
187 187 timeouts.ReadTotalTimeoutConstant=100;
188 188 timeouts.ReadTotalTimeoutMultiplier=1;
189 189 timeouts.WriteTotalTimeoutConstant=100;
190 190 timeouts.WriteTotalTimeoutMultiplier=10;
191 191 SetCommTimeouts((HANDLE)fd, &timeouts);
192 192 return rs232noerr;
193 193 }
194 194 }
195 195
196 196 int rs232setbaudrate(rs232port_t fd, int baudrate)
197 197 {
198 198 if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
199 199 {
200 200 return (rs232port_t)badPortValue;
201 201 }
202 202 else
203 203 {
204 204 DCB dcbSerialParams = {0};
205 205 dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
206 206 GetCommState((HANDLE)fd, &dcbSerialParams);
207 207 dcbSerialParams.BaudRate=rs232cfspeed(baudrate);
208 208 SetCommState((HANDLE)fd, &dcbSerialParams);
209 209 return rs232noerr;
210 210 }
211 211 }
212 212
213 213 int rs232setparity(rs232port_t fd, rs232parity Parity)
214 214 {
215 215 if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
216 216 {
217 217 return (rs232port_t)badPortValue;
218 218 }
219 219 else
220 220 {
221 221 DCB dcbSerialParams = {0};
222 222 dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
223 223 GetCommState((HANDLE)fd, &dcbSerialParams);
224 224 dcbSerialParams.Parity = privatedecodeparity(Parity);
225 225 SetCommState((HANDLE)fd, &dcbSerialParams);
226 226 return rs232noerr;
227 227 }
228 228 }
229 229
230 230 int rs232setnbstop(rs232port_t fd, rs232stop NbStop)
231 231 {
232 232 if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
233 233 {
234 234 return (rs232port_t)badPortValue;
235 235 }
236 236 else
237 237 {
238 238 DCB dcbSerialParams = {0};
239 239 dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
240 240 GetCommState((HANDLE)fd, &dcbSerialParams);
241 241 dcbSerialParams.StopBits = privatedecodestop(NbStop);
242 242 SetCommState((HANDLE)fd, &dcbSerialParams);
243 243 return rs232noerr;
244 244 }
245 245 }
246 246
247 247
248 248 int rs232setcsize(rs232port_t fd, int ChSize)
249 249 {
250 250 if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
251 251 {
252 252 return (rs232port_t)badPortValue;
253 253 }
254 254 else
255 255 {
256 256 DCB dcbSerialParams = {0};
257 257 dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
258 258 GetCommState((HANDLE)fd, &dcbSerialParams);
259 259 dcbSerialParams.ByteSize = ChSize;
260 260 SetCommState((HANDLE)fd, &dcbSerialParams);
261 261 return rs232noerr;
262 262 }
263 263 }
264 264
265 265
266 266
267 267
268 268
269 269
270 270 int rs232write(rs232port_t fd,char *psWrite, int WriteBufferSize)
271 271 {
272 272
273 273 if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
274 274 {
275 275 return (rs232port_t)badPortValue;
276 276 }
277 277 else
278 278 {
279 279 DWORD dwBytesWriten = 0;
280 280 WriteFile((HANDLE)fd, psWrite, WriteBufferSize, &dwBytesWriten, NULL);
281 281 return dwBytesWriten;
282 282 }
283 283 }
284 284
285 285
286 286 int rs232read(rs232port_t fd,char *psRead, int ReadBufferSize)
287 287 {
288 288
289 289 if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
290 290 {
291 291 return (rs232port_t)badPortValue;
292 292 }
293 293 else
294 294 {
295 295 DWORD dwBytesRead = 0;
296 296 ReadFile((HANDLE)fd, psRead, ReadBufferSize, &dwBytesRead, NULL);
297 297 return dwBytesRead;
298 298 }
299 299
300 300 }
301 301
302 302
303 303 int rs232saferead(rs232port_t fd,char* data,int count )
304 304 {
305 305 int read=0;
306 306 int i=0;
307 307 for(i=0;i<100;i++)
308 308 {
309 309 read = rs232read(fd,data,count);
310 310 count -=read;
311 311 data+=read;
312 312 if(count==0)
313 313 return rs232noerr;
314 314 }
315 315 return -1;
316 316 }
317 317
318 318
319 319
320 320 int rs232safewrite(rs232port_t fd,char* data,int count)
321 321 {
322 322 int written=0;
323 323 int i=0;
324 324 for(i=0;i<1000;i++)
325 325 {
326 326 written = rs232write(fd,data+written,count);
327 327 count-=written;
328 328 data+=written;
329 329 if(count==0)
330 330 return rs232noerr;
331 331 }
332 332 return -1;
333 333 }
334 334
335 335
336 336 int rs232setRTS(rs232port_t fd)
337 337 {
338 338 if(EscapeCommFunction((HANDLE)fd, CLRRTS))
339 339 return rs232noerr;
340 340 return -1;
341 341 }
342 342
343 343 int rs232clearRTS(rs232port_t fd)
344 344 {
345 345 if(EscapeCommFunction((HANDLE)fd, SETRTS))
346 346 return rs232noerr;
347 347 return -1;
348 348 }
349 349
350 350 int rs232setDTR(rs232port_t fd)
351 351 {
352 352 if(EscapeCommFunction((HANDLE)fd, CLRDTR))
353 353 return rs232noerr;
354 354 return -1;
355 355 }
356 356
357 357
358 358 int rs232clearDTR(rs232port_t fd)
359 359 {
360 360 if(EscapeCommFunction((HANDLE)fd, SETDTR))
361 361 return rs232noerr;
362 362 return -1;
363 363 }
364 364
365 365 #endif //#ifdef HAVE_WINDOWS_H
General Comments 0
You need to be logged in to leave comments. Login now