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

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

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