@@ -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 |
@@ -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 |
@@ -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