求6410b的rs485的测试应用程序（Linux）

─╄OvЁ等待

1. #include <stdio.h>      /*标准输入输出定义*/
   
2. #include <stdlib.h>
   
3. #include <unistd.h>     /*Unix标准函数定义*/
   
4. #include <sys/types.h>  /**/
   
5. #include <sys/stat.h>   /**/
   
6. #include <fcntl.h>      /*文件控制定义*/
   
7. #include <termios.h>    /*PPSIX终端控制定义*/
   
8. #include <errno.h>      /*错误号定义*/
   
9. #include <getopt.h>
   
10. #include <string.h>
    
11. #include <stdlib.h>
    
12. 
    
13. #define TITLE "485 TEST"
    
14. #define FALSE 1
    
15. #define TRUE 0
    
16. #define RS485_SEND "echo 1 > /sys/class/misc/io_ctl/gpio_state"
    
17. #define RS485_RECEIVE "echo 0 > /sys/class/misc/io_ctl/gpio_state"
    
18. FILE *outfile;
    
19. void print_usage();
    
20. char buf[512] = {0};/* Recvice data buffer */
    
21. char message[104] = {0};
    
22. int  fd = 0;
    
23. static int  hex = 0;
    
24. 
    
25. int speed_arr[] = {
    
26.         B921600, B460800, B230400, B115200, B57600, B38400, B19200,
    
27.         B9600, B4800, B2400, B1200, B300,
    
28. };
    
29. int name_arr[] = {
    
30.         921600, 460800, 230400, 115200, 57600, 38400,  19200,  
    
31.         9600,  4800,  2400,  1200,  300,
    
32. };
    
33. 
    
34. void shownInformation(void)
    
35. {
    
36.         printf("*********************************************\n");
    
37.         printf("\t %s \t\n", TITLE);
    
38.         printf("*********************************************\n\n");
    
39. }
    
40. 
    
41. void set_speed(int fd, int speed)
    
42. {
    
43.         int   i;
    
44.         int   status;
    
45.         struct termios   Opt;
    
46. 
    
47.         tcgetattr(fd, &Opt);
    
48. 
    
49.         cfmakeraw(&Opt);
    
50.         for ( i= 0;  i < sizeof(speed_arr) / sizeof(int);  i++) {
    
51.                 if  (speed == name_arr[i]){
    
52.                         tcflush(fd, TCIOFLUSH);
    
53.                         cfsetispeed(&Opt, speed_arr[i]);
    
54.                         cfsetospeed(&Opt, speed_arr[i]);
    
55.                         status = tcsetattr(fd, TCSANOW, &Opt);
    
56.                         if (status != 0)
    
57.                                 perror("tcsetattr fd1");
    
58.                         return;
    
59.                 }
    
60.                 tcflush(fd,TCIOFLUSH);
    
61.         }
    
62. 
    
63.         if (i == 12){
    
64.                 printf("\tSorry, please set the correct baud rate!\n\n");
    
65.                 print_usage(stderr, 1);
    
66.         }
    
67. }
    
68. /*
    
69.         *@brief   设置串口数据位，停止位和效验位
    
70.         *@param  fd     类型  int  打开的串口文件句柄*
    
71.         *@param  databits 类型  int 数据位   取值 为 7 或者8*
    
72.         *@param  stopbits 类型  int 停止位   取值为 1 或者2*
    
73.         *@param  parity  类型  int  效验类型 取值为N,E,O,,S
    
74. */
    
75. int set_Parity(int fd,int databits,int stopbits,int parity)
    
76. {
    
77.         struct termios options;
    
78. 
    
79.         if  ( tcgetattr( fd,&options)  !=  0) {
    
80.                 perror("SetupSerial 1");
    
81.                 return(FALSE);
    
82.         }
    
83.        
    
84.         options.c_cflag &= ~CSIZE ;
    
85.         options.c_oflag = 0;
    
86.         switch (databits) /*设置数据位数*/ {
    
87.         case 7:
    
88.                 options.c_cflag |= CS7;
    
89.                 break;
    
90.         case 8:
    
91.                 options.c_cflag |= CS8;
    
92.                 break;
    
93.         default:
    
94.                 fprintf(stderr,"Unsupported data size\n");
    
95.                 return (FALSE);
    
96.         }
    
97.        
    
98.         switch (parity) {
    
99.         case 'n':
    
100.         case 'N':
     
101.                 options.c_cflag &= ~PARENB;   /* Clear parity enable */
     
102.                 options.c_iflag &= ~INPCK;     /* Enable parity checking */
     
103.                 break;
     
104.         case 'o':
     
105.         case 'O':
     
106.                 options.c_cflag |= (PARODD | PARENB);  /* 设置为奇效验*/
     
107.                 options.c_iflag |= INPCK;             /* Disnable parity checking */
     
108.                 break;
     
109.         case 'e':
     
110.         case 'E':
     
111.                 options.c_cflag |= PARENB;     /* Enable parity */
     
112.                 options.c_cflag &= ~PARODD;   /* 转换为偶效验*/
     
113.                 options.c_iflag |= INPCK;       /* Disnable parity checking */
     
114.                 break;
     
115.         case 'S':       
     
116.         case 's':  /*as no parity*/
     
117.                 options.c_cflag &= ~PARENB;
     
118.                 options.c_cflag &= ~CSTOPB;
     
119.                 break;
     
120.         default:
     
121.                 fprintf(stderr,"Unsupported parity\n");
     
122.                 return (FALSE);
     
123.         }
     
124.         /* 设置停止位*/  
     
125.         switch (stopbits) {
     
126.         case 1:
     
127.                 options.c_cflag &= ~CSTOPB;
     
128.                 break;
     
129.         case 2:
     
130.                 options.c_cflag |= CSTOPB;
     
131.                 break;
     
132.         default:
     
133.                 fprintf(stderr,"Unsupported stop bits\n");
     
134.                 return (FALSE);
     
135.         }
     
136.         /* Set input parity option */
     
137.         if (parity != 'n')
     
138.                 options.c_iflag |= INPCK;
     
139. 
     
140.         options.c_cc[VTIME] = 150; // 15 seconds
     
141.         options.c_cc[VMIN] = 0;
     
142. 
     
143.         options.c_lflag &= ~(ECHO | ICANON);
     
144. 
     
145.         tcflush(fd,TCIFLUSH); /* Update the options and do it NOW */
     
146.         if (tcsetattr(fd,TCSANOW,&options) != 0) {
     
147.                 perror("SetupSerial 3");
     
148.                 return (FALSE);
     
149.         }
     
150.         return (TRUE);
     
151. }
     
152. 
     
153. /**
     
154. *@breif 打开串口
     
155. */
     
156. int OpenDev(char *Dev)
     
157. {
     
158.         int fd = open( Dev, O_RDWR );         //| O_NOCTTY | O_NDELAY
     
159.         if (-1 == fd) { /*设置数据位数*/
     
160.                 perror("Can't Open Serial Port");
     
161.                 return -1;
     
162.         } else{
     
163.                 return fd;
     
164.         }
     
165. }
     
166. 
     
167. 
     
168. /* The name of this program */
     
169. const char * program_name;
     
170. 
     
171. /* Prints usage information for this program to STREAM (typically
     
172. * stdout or stderr), and exit the program with EXIT_CODE. Does not
     
173. * return.
     
174. */
     
175. 
     
176. void print_usage (FILE *stream, int exit_code)
     
177. {
     
178.         fprintf(stream, "Usage: %s option [ dev... ] \n", program_name);
     
179.         fprintf(stream,
     
180.                         "\t-h  --help     Display this usage information.\n"
     
181.                         "\t-d i --device   The device ttyS[0-3] or ttyO[0-5]\n"
     
182.                             "\t-b  --baudrate Set the baud rate you can select\n"
     
183.                             "\t               [230400, 115200, 57600, 38400, 19200, 9600, 4800, 2400, 1200, 300]\n"
     
184.                         "\t-s  --string   Write the device data\n"
     
185.                         "\t-l  --hexadecimal  recv in hexadecimal");
     
186.         exit(exit_code);
     
187. }
     
188. 
     
189. void *thread_receive_function(void *arg)
     
190. {
     
191.         unsigned int i = 0, j = 1,num_read;
     
192. //        outfile = fopen("./tmp","w+");
     
193.         tcflush(fd, TCIOFLUSH); //清空串口缓冲区数据
     
194.         while(1){
     
195.                 num_read = read(fd, buf, sizeof(buf));
     
196.                 if (num_read > 0){
     
197.                         if(hex == 1)
     
198.                         {
     
199.                                 printf("sum = %4d num = %2d recv = ",j++,num_read);
     
200.                                 for(i = 0;i< num_read;i++)
     
201.                                 {
     
202.                                         printf("%x",buf[i]);
     
203.                                 }
     
204.                                 printf("\n");
     
205.                                 memset(buf,'\0',sizeof(buf));
     
206.                         }
     
207.                         else
     
208.                         {
     
209. //                        fprintf(outfile,"receive num = %d ",i++);
     
210.                                 buf[num_read] = '\n';
     
211. //                        fwrite(buf,num_read,1,outfile);
     
212. //                        fprintf(outfile,"%s","\n");
     
213.                                 printf("sum = %4d num = %2d recv = %s", j++,num_read, buf);
     
214.                                 memset(buf, '\0', sizeof(buf));
     
215.                         }
     
216.                 }
     
217.         }
     
218. }
     
219. 
     
220. void func_receive()
     
221. {
     
222.         int res;
     
223.         int stop;
     
224.         pthread_t a_thread;
     
225.        
     
226.         system(RS485_RECEIVE);
     
227.         usleep(100);
     
228. 
     
229.         res = pthread_create(&a_thread, NULL, thread_receive_function, NULL);
     
230.         if (res != 0){
     
231.                 perror("Thread creation failed");
     
232.                 exit(1);
     
233.         }
     
234.     usleep(100);
     
235.         while (1){
     
236.                 printf("Select 3 : Stop Receive\n");
     
237.                 printf(">\n");
     
238.                 scanf ("%d", &stop);
     
239.                 getchar();
     
240.                 if (stop == 3){
     
241.         /*                fclose(outfile);*/
     
242.                         res = pthread_cancel(a_thread);
     
243. 
     
244.                         if (res != 0){
     
245.                                 perror("Thread cancelation failed");
     
246.                                 exit(1);
     
247.                         }
     
248.                         break;
     
249.                 }else{
     
250.                         printf("Sorry! Please select [3] stop receive\n\n");
     
251.                 }
     
252.         }
     
253. }
     
254. 
     
255. void *thread_send_function(void *arg)
     
256. {
     
257.         unsigned int num_send = 0, j = 0;
     
258.         tcflush(fd, TCIOFLUSH); //清空串口缓冲区数据
     
259.         while (1){
     
260.                   j = write(fd, message, strlen(message));
     
261.                                   num_send++;
     
262.                                   printf("sum = %4d num = %2d send = %s\n",num_send,j,message );
     
263.                   sleep(1);
     
264.         }
     
265. }
     
266. 
     
267. void func_send()
     
268. {
     
269.         unsigned char len;
     
270.         int stop;
     
271.         pthread_t a_thread;
     
272.         int res;
     
273. 
     
274.         printf("\tPlease enter the information to be sent off!\n");
     
275. 
     
276.         system(RS485_SEND);//控制GPIO0_13引脚电平使485允许发送，禁止接收。
     
277.         usleep(100);
     
278. 
     
279.         while (1){
     
280.                 memset (message, '\0', sizeof(message));
     
281.                 scanf("%[^\n]", message);
     
282.                 printf("message = %s\n", message);
     
283.                 len = strlen(message);
     
284.                 printf("len = %d\n", len);
     
285. 
     
286.                 if (len > 0){
     
287.                         res = pthread_create(&a_thread, NULL, thread_send_function, (void *)message);
     
288.                         if (res != 0){
     
289.                                 perror("Thread creation failed");
     
290.                                 exit(1);
     
291.                         }
     
292. 
     
293.                         while (1){
     
294.                                 printf("Information is sent......\n");
     
295.                                 printf("Select 3 : Stop Send\n");
     
296.                                 printf(">");
     
297.                                 scanf ("%d", &stop);
     
298.                                 getchar();
     
299.                                 if (stop == 3){
     
300.                                         res = pthread_cancel(a_thread);
     
301. 
     
302.                                         if (res != 0){
     
303.                                                 perror("Thread cancelation failed");
     
304.                                                 exit(1);
     
305.                                         }               
     
306. 
     
307.                                         break;
     
308.                                 }else{
     
309.                                         printf("Sorry! Please select [3] stop send\n\n");
     
310.                                 }
     
311.                         }
     
312.                         break;
     
313.                 }else{
     
314.                         printf("Sorry you can not enter an empty message!\n\n");
     
315.                 }
     
316.         }
     
317. }
     
318. 
     
319. /*显示二级菜单*/
     
320. void display_two_menu()
     
321. {
     
322.         int flag_num;
     
323. 
     
324.         while (1){
     
325.                 printf("\nSelect 1 : Send a message\n");
     
326.                 printf("Select 2 : Receive messages\n");
     
327.                 printf(">");
     
328.        
     
329.                 scanf("%d", &flag_num);
     
330.                 getchar();
     
331.                
     
332.                 switch (flag_num){
     
333.                 case 1 :
     
334.                         func_send();
     
335.                         break;
     
336.                 case 2 :
     
337.                         func_receive();
     
338.                         break;
     
339.                 default :
     
340.                         printf("\n\nSorry! Please select the number of 1 to 2...\n");
     
341.                 }
     
342.         }
     
343. }
     
344. 
     
345. void funct_select()
     
346. {       
     
347.         display_two_menu();
     
348. }
     
349. 
     
350. 
     
351. /*
     
352. *@breif  main()
     
353. */
     
354. int main(int argc, char *argv[])
     
355. {
     
356.         int   next_option, havearg = 0;
     
357.         char *device;
     
358.         int i=0,j=0;
     
359.         int nread;                /* Read the counts of data */
     
360.         int speed = 0;
     
361.         char *xmit = "6";         /* Default send data */
     
362. 
     
363.         const char *const short_options = "lhd:s:b:";
     
364. 
     
365.         const struct option long_options[] = {
     
366.                 { "help",   0, NULL, 'h'},
     
367.                 { "device", 1, NULL, 'd'},
     
368.                 { "string", 1, NULL, 's'},
     
369.                 { "baudrate", 1, NULL, 'b'},
     
370.                 {"hexadecimal",0,NULL,'l'},
     
371.                 { NULL,     0, NULL, 0  }
     
372.         };
     
373. 
     
374.         program_name = argv[0];
     
375. 
     
376.         do {
     
377.                 next_option = getopt_long (argc, argv, short_options, long_options, NULL);
     
378.                 switch (next_option) {
     
379.                 case 'h':
     
380.                         print_usage (stdout, 0);
     
381.                 case 'd':
     
382.                         device = optarg;
     
383.                         havearg = 1;
     
384.                         break;
     
385.                 case 'b':
     
386.                         speed = atoi(optarg);
     
387.                         break;
     
388.                 case 's':
     
389.                         xmit = optarg;
     
390.                         havearg = 1;
     
391.                         break;
     
392.                 case 'l':
     
393.                         hex = 1;
     
394.                         havearg = 1;
     
395.                         break;
     
396.                 case -1:
     
397.                         if (havearg)  
     
398.                                 break;
     
399.                 case '?':
     
400.                         print_usage (stderr, 1);
     
401.                         default:
     
402.                         abort ();
     
403.                 }
     
404.         }while(next_option != -1);
     
405. 
     
406.         sleep(1);
     
407.         fd = OpenDev(device);
     
408. 
     
409.         shownInformation();
     
410. 
     
411.         if (fd > 0) {
     
412.                 set_speed(fd, speed);
     
413.         } else {
     
414.                 fprintf(stderr, "Error opening %s: %s\n", device, strerror(errno));
     
415.                 exit(1);
     
416.         }
     
417. 
     
418.         if (set_Parity(fd,8,1,'N')== FALSE) {
     
419.                 fprintf(stderr, "Set Parity Error\n");
     
420.                 close(fd);
     
421.                 exit(1);
     
422.         }
     
423. 
     
424.         funct_select();
     
425. 
     
426.         close(fd);
     
427.         exit(0);
     
428. }
     

复制代码

飞凌-unix

楼主，我们测试rs485是通过串口测试程序测试的，没有单独针对485的测试例程