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

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

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