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

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

Removed error on port enumeration on win32, now the ports are correctly closed....
jeandet -
r39:76a16f453f75 alexis
parent child
Show More
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 104 #ifdef 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 rs232close(devName);
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