##// 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 clsed.
jeandet -
r38:9392f8876142 alexis
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,364 +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 153 }
153 154 }
154 155 return firstitem;
155 156 }
156 157
157 158 void rs232deleteportlist(rs232portslist_t* list)
158 159 {
159 160 if(list!=NULL)
160 161 {
161 162 if(list->next != NULL)
162 163 rs232deleteportlist(list->next);
163 164 free(list);
164 165 }
165 166 }
166 167
167 168
168 169 int rs232setup(rs232port_t fd, int ChSize, int BaudeRate, rs232parity Parity, rs232stop NbStop)
169 170 {
170 171 if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
171 172 {
172 173 return (rs232port_t)badPortValue;
173 174 }
174 175 else
175 176 {
176 177 DCB dcbSerialParams = {0};
177 178 dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
178 179 GetCommState((HANDLE)fd, &dcbSerialParams);
179 180 dcbSerialParams.BaudRate=rs232cfspeed(BaudeRate);
180 181 dcbSerialParams.ByteSize=ChSize;
181 182 dcbSerialParams.StopBits=privatedecodestop(NbStop);
182 183 dcbSerialParams.Parity=privatedecodeparity(Parity);
183 184 SetCommState((HANDLE)fd, &dcbSerialParams);
184 185 COMMTIMEOUTS timeouts={0};
185 186 timeouts.ReadIntervalTimeout=100;
186 187 timeouts.ReadTotalTimeoutConstant=100;
187 188 timeouts.ReadTotalTimeoutMultiplier=1;
188 189 timeouts.WriteTotalTimeoutConstant=100;
189 190 timeouts.WriteTotalTimeoutMultiplier=10;
190 191 SetCommTimeouts((HANDLE)fd, &timeouts);
191 192 return rs232noerr;
192 193 }
193 194 }
194 195
195 196 int rs232setbaudrate(rs232port_t fd, int baudrate)
196 197 {
197 198 if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
198 199 {
199 200 return (rs232port_t)badPortValue;
200 201 }
201 202 else
202 203 {
203 204 DCB dcbSerialParams = {0};
204 205 dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
205 206 GetCommState((HANDLE)fd, &dcbSerialParams);
206 207 dcbSerialParams.BaudRate=rs232cfspeed(baudrate);
207 208 SetCommState((HANDLE)fd, &dcbSerialParams);
208 209 return rs232noerr;
209 210 }
210 211 }
211 212
212 213 int rs232setparity(rs232port_t fd, rs232parity Parity)
213 214 {
214 215 if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
215 216 {
216 217 return (rs232port_t)badPortValue;
217 218 }
218 219 else
219 220 {
220 221 DCB dcbSerialParams = {0};
221 222 dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
222 223 GetCommState((HANDLE)fd, &dcbSerialParams);
223 224 dcbSerialParams.Parity = privatedecodeparity(Parity);
224 225 SetCommState((HANDLE)fd, &dcbSerialParams);
225 226 return rs232noerr;
226 227 }
227 228 }
228 229
229 230 int rs232setnbstop(rs232port_t fd, rs232stop NbStop)
230 231 {
231 232 if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
232 233 {
233 234 return (rs232port_t)badPortValue;
234 235 }
235 236 else
236 237 {
237 238 DCB dcbSerialParams = {0};
238 239 dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
239 240 GetCommState((HANDLE)fd, &dcbSerialParams);
240 241 dcbSerialParams.StopBits = privatedecodestop(NbStop);
241 242 SetCommState((HANDLE)fd, &dcbSerialParams);
242 243 return rs232noerr;
243 244 }
244 245 }
245 246
246 247
247 248 int rs232setcsize(rs232port_t fd, int ChSize)
248 249 {
249 250 if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
250 251 {
251 252 return (rs232port_t)badPortValue;
252 253 }
253 254 else
254 255 {
255 256 DCB dcbSerialParams = {0};
256 257 dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
257 258 GetCommState((HANDLE)fd, &dcbSerialParams);
258 259 dcbSerialParams.ByteSize = ChSize;
259 260 SetCommState((HANDLE)fd, &dcbSerialParams);
260 261 return rs232noerr;
261 262 }
262 263 }
263 264
264 265
265 266
266 267
267 268
268 269
269 270 int rs232write(rs232port_t fd,char *psWrite, int WriteBufferSize)
270 271 {
271 272
272 273 if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
273 274 {
274 275 return (rs232port_t)badPortValue;
275 276 }
276 277 else
277 278 {
278 279 DWORD dwBytesWriten = 0;
279 280 WriteFile((HANDLE)fd, psWrite, WriteBufferSize, &dwBytesWriten, NULL);
280 281 return dwBytesWriten;
281 282 }
282 283 }
283 284
284 285
285 286 int rs232read(rs232port_t fd,char *psRead, int ReadBufferSize)
286 287 {
287 288
288 289 if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
289 290 {
290 291 return (rs232port_t)badPortValue;
291 292 }
292 293 else
293 294 {
294 295 DWORD dwBytesRead = 0;
295 296 ReadFile((HANDLE)fd, psRead, ReadBufferSize, &dwBytesRead, NULL);
296 297 return dwBytesRead;
297 298 }
298 299
299 300 }
300 301
301 302
302 303 int rs232saferead(rs232port_t fd,char* data,int count )
303 304 {
304 305 int read=0;
305 306 int i=0;
306 307 for(i=0;i<100;i++)
307 308 {
308 309 read = rs232read(fd,data,count);
309 310 count -=read;
310 311 data+=read;
311 312 if(count==0)
312 313 return rs232noerr;
313 314 }
314 315 return -1;
315 316 }
316 317
317 318
318 319
319 320 int rs232safewrite(rs232port_t fd,char* data,int count)
320 321 {
321 322 int written=0;
322 323 int i=0;
323 324 for(i=0;i<1000;i++)
324 325 {
325 326 written = rs232write(fd,data+written,count);
326 327 count-=written;
327 328 data+=written;
328 329 if(count==0)
329 330 return rs232noerr;
330 331 }
331 332 return -1;
332 333 }
333 334
334 335
335 336 int rs232setRTS(rs232port_t fd)
336 337 {
337 338 if(EscapeCommFunction((HANDLE)fd, CLRRTS))
338 339 return rs232noerr;
339 340 return -1;
340 341 }
341 342
342 343 int rs232clearRTS(rs232port_t fd)
343 344 {
344 345 if(EscapeCommFunction((HANDLE)fd, SETRTS))
345 346 return rs232noerr;
346 347 return -1;
347 348 }
348 349
349 350 int rs232setDTR(rs232port_t fd)
350 351 {
351 352 if(EscapeCommFunction((HANDLE)fd, CLRDTR))
352 353 return rs232noerr;
353 354 return -1;
354 355 }
355 356
356 357
357 358 int rs232clearDTR(rs232port_t fd)
358 359 {
359 360 if(EscapeCommFunction((HANDLE)fd, SETDTR))
360 361 return rs232noerr;
361 362 return -1;
362 363 }
363 364
364 365 #endif //#ifdef HAVE_WINDOWS_H
General Comments 0
You need to be logged in to leave comments. Login now