Makefile文件内容

    1. SOURCE = $(wildcard *.c)
    2. TARGETS = $(patsubst %.c, %, $(SOURCE))
    4. CC = arm-linux-gcc
    5. PREFIX=/usr/lib/alsa-lib
    6. #CFLAGS = -Wall
    9. all:$(TARGETS)
    11. $(TARGETS):%:%.c
    12.         $(CC) $<  -o $@ 
    16. .PHONY:clean all
    17. clean:
    18.         -rm -rf $(TARGETS)

    源文件uart_test.c

    1. #include<stdio.h>
    2. #include<stdlib.h>
    3. #include<fcntl.h>
    4. #include<unistd.h>
    5. #include<assert.h>
    6. #include<termios.h>
    7. #include<string.h>
    8. #include<sys/time.h>
    9. #include<sys/types.h>
    10. #include<errno.h>
    12. static int ret;
    13. static int fd;
    15. /*
    16.  * 安全读写函数
    17.  */
    19. ssize_t safe_write(int fd, const void *vptr, size_t n)
    20. {
    21.     size_t  nleft;
    22.     ssize_t nwritten;
    23.     const char *ptr;
    25.     ptr = vptr;
    26.     nleft = n;
    28.         printf("%s, %d\n", ptr, nleft);
    29.     while(nleft > 0)
    30.     {
    31.     if((nwritten = write(fd, ptr, nleft)) <= 0)
    32.         {
    33.             if(nwritten < 0&&errno == EINTR)
    34.                 nwritten = 0;
    35.             else
    36.                 return -1;
    37.         }
    38.         nleft -= nwritten;
    39.         ptr   += nwritten;
    40.     }
    41.     return(n);
    42. }
    44. ssize_t safe_read(int fd,void *vptr,size_t n)
    45. {
    46.     size_t nleft;
    47.     ssize_t nread;
    48.     char *ptr;
    49.     ptr=vptr;
    50.     nleft=n;
    52.     while(nleft > 0)
    53.     {
    54.         if((nread = read(fd,ptr,nleft)) < 0)
    55.         {
    56.             if(errno == EINTR)//被信号中断
    57.                 nread = 0;
    58.             else
    59.                 return -1;
    60.         }
    61.         else
    62.         if(nread == 0)
    63.             break;
    64.         printf("%s", ptr);
    65.         fflush(stdout);
    66.         nleft -= nread;
    67.         ptr += nread;        
    68.     }
    69.     return (n-nleft);
    70. }
    72. int uart_open(int fd,const char *pathname)
    73. {
    74.     assert(pathname);
    76.     /*打开串口*/
    77.     fd = open(pathname,O_RDWR|O_NOCTTY);
    78.     if(fd == -1)
    79.     {
    80.         perror("Open UART failed!");
    81.         return -1;
    82.     }
    84.     /*清除串口非阻塞标志*/
    85.    /* if(fcntl(fd,F_SETFL,0) < 0)
    86.     {
    87.         fprintf(stderr,"fcntl failed!\n");
    88.         return -1;
    89.     }*/
    91.     return fd;
    92. }
    94. int uart_set(int fd,int baude,int c_flow,int bits,char parity,int stop)
    95. {
    96.     struct termios options;
    98.     /*获取终端属性*/
    99.     if(tcgetattr(fd,&options) < 0)
    100.     {
    101.         perror("tcgetattr error");
    102.         return -1;
    103.     }
    106.     /*设置输入输出波特率，两者保持一致*/
    107.     switch(baude)
    108.     {
    109.         case 4800:
    110.             cfsetispeed(&options,B4800);
    111.             cfsetospeed(&options,B4800);
    112.             break;
    113.         case 9600:
    114.             cfsetispeed(&options,B9600);
    115.             cfsetospeed(&options,B9600);
    116.             break;
    117.         case 19200:
    118.             cfsetispeed(&options,B19200);
    119.             cfsetospeed(&options,B19200);
    120.             break;
    121.         case 38400:
    122.             cfsetispeed(&options,B38400);
    123.             cfsetospeed(&options,B38400);
    124.             break;
    125.         case 115200:
    126.                 cfsetispeed(&options,B115200);
    127.                 cfsetospeed(&options,B115200);
    128.                 break;
    129.         default:
    130.             fprintf(stderr,"Unkown baude!\n");
    131.             return -1;
    132.     }
    134.     /*设置控制模式*/
    135.     options.c_cflag |= CLOCAL;//保证程序不占用串口
    136.     options.c_cflag |= CREAD;//保证程序可以从串口中读取数据,表启用字符接收器，目的是能够从串口中读取输入的数据
    138.     /*设置数据流控制*/
    139.     switch(c_flow)
    140.     {
    141.         case 0://不进行流控制
    142.             options.c_cflag &= ~CRTSCTS;
    143.             break;
    144.         case 1://进行硬件流控制
    145.             options.c_cflag |= CRTSCTS;
    146.             break;
    147.         case 2://进行软件流控制
    148.             options.c_cflag |= IXON|IXOFF|IXANY;
    149.             break;
    150.         default:
    151.             fprintf(stderr,"Unkown c_flow!\n");
    152.             return -1;
    153.     }
    155.     /*设置数据位*/
    156.     switch(bits)
    157.     {
    158.         case 5:
    159.             options.c_cflag &= ~CSIZE;//屏蔽其它标志位
    160.             options.c_cflag |= CS5;
    161.             break;
    162.         case 6:
    163.             options.c_cflag &= ~CSIZE;//屏蔽其它标志位
    164.             options.c_cflag |= CS6;
    165.             break;
    166.         case 7:
    167.             options.c_cflag &= ~CSIZE;//屏蔽其它标志位
    168.             options.c_cflag |= CS7;
    169.             break;
    170.         case 8:
    171.             options.c_cflag &= ~CSIZE;//屏蔽其它标志位
    172.             options.c_cflag |= CS8;
    173.             break;
    174.         default:
    175.             fprintf(stderr,"Unkown bits!\n");
    176.             return -1;
    177.     }
    179.     /*设置校验位*/
    180.     switch(parity)
    181.     {
    182.         /*无奇偶校验位*/
    183.         case 'n':
    184.         case 'N':
    185.             options.c_cflag &= ~PARENB;//PARENB：产生奇偶位，执行奇偶校验
    186.             printf("N\n");
    187.             break;
    188.         /*设为空格,即停止位为2位*/
    189.         case 's':
    190.         case 'S':
    191.             options.c_cflag &= ~PARENB;//PARENB：产生奇偶位，执行奇偶校验
    192.             options.c_cflag &= ~CSTOPB;//CSTOPB：使用两位停止位
    193.             break;
    194.         /*设置奇校验*/
    195.         case 'o':
    196.         case 'O':
    197.             options.c_cflag |= PARENB;//PARENB：产生奇偶位，执行奇偶校验
    198.             options.c_cflag |= PARODD;//PARODD：若设置则为奇校验,否则为偶校验
    199.             options.c_cflag |= INPCK;//INPCK：使奇偶校验起作用
    200.             options.c_cflag |= ISTRIP;//ISTRIP：若设置则有效输入数字被剥离7个字节，否则保留全部8位
    201.             break;
    202.         /*设置偶校验*/
    203.         case 'e':
    204.         case 'E':
    205.             options.c_cflag |= PARENB;//PARENB：产生奇偶位，执行奇偶校验
    206.             options.c_cflag &= ~PARODD;//PARODD：若设置则为奇校验,否则为偶校验
    207.             options.c_cflag |= INPCK;//INPCK：使奇偶校验起作用
    208.             options.c_cflag |= ISTRIP;//ISTRIP：若设置则有效输入数字被剥离7个字节，否则保留全部8位
    209.             break;
    210.         default:
    211.             fprintf(stderr,"Unkown parity!\n");
    212.             return -1;
    213.     }
    215.     /*设置停止位*/
    216.     switch(stop)
    217.     {
    218.         case 1:
    219.             options.c_cflag &= ~CSTOPB;//CSTOPB：使用一位停止位
    220.             break;
    221.         case 2:
    222.             options.c_cflag |= CSTOPB;//CSTOPB：使用两位停止位
    223.             break;
    224.         default:
    225.             fprintf(stderr,"Unkown stop!\n");
    226.             return -1;
    227.     }
    229.     /*设置输出模式为原始输出*/
    230.     options.c_oflag &= ~(OPOST| ONLCR | OLCUC | OCRNL | ONOCR | ONLRET | OFILL);//OPOST：若设置则按定义的输出处理，否则所有c_oflag失效
    232.     /*设置本地模式为原始模式*/
    233.     options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
    234.     /*
    235.      *ICANON：允许规范模式进行输入处理
    236.      *ECHO：允许输入字符的本地回显
    237.      *ECHOE：在接收EPASE时执行Backspace,Space,Backspace组合
    238.      *ISIG：允许信号
    239.      */
    241.     /*设置等待时间和最小接受字符*/
    242.     options.c_cc[VTIME] = 0;//可以在select中设置
    243.     options.c_cc[VMIN] = 1;//最少读取一个字符
    245.     /*如果发生数据溢出，只接受数据，但是不进行读操作*/
    246.     tcflush(fd,TCIFLUSH);
    248.     /*激活配置*/
    249.     if(tcsetattr(fd,TCSANOW,&options) < 0)
    250.     {
    251.         perror("tcsetattr failed");
    252.         return -1;
    253.     }
    255.     return 0;
    256. }
    258. int uart_read(int fd,char *r_buf,size_t len)
    259. {
    260.     ssize_t cnt = 0;
    261.     fd_set rfds;
    262.     struct timeval time;
    264.     /*将文件描述符加入读描述符集合*/
    265.     FD_ZERO(&rfds);
    266.     FD_SET(fd,&rfds);
    268.     /*设置超时为15s*/
    269.     time.tv_sec = 15;
    270.     time.tv_usec = 0;
    272.     /*实现串口的多路I/O*/
    273.     ret = select(fd+1,&rfds,NULL,NULL,&time);
    274.     switch(ret)
    275.     {
    276.         case -1:
    277.             fprintf(stderr,"select error!\n");
    278.             return -1;
    279.         case 0:
    280.             fprintf(stderr,"time out!\n");
    281.             return -1;
    282.         default:
    283.             cnt = safe_read(fd,r_buf,len);
    284.             printf(" in uart_read");
    285.             if(cnt == -1)
    286.             {
    287.                 fprintf(stderr,"read error!\n");
    288.                 return -1;
    289.             }
    290.             return cnt;
    291.     }
    292. }
    294. int uart_write(int fd,const char *w_buf,size_t len)
    295. {
    296.     ssize_t cnt = 0;
    298.     cnt = safe_write(fd,w_buf,len);
    299.     if(cnt == -1)
    300.     {
    301.         fprintf(stderr,"write error!\n");
    302.         return -1;
    303.     }
    305.     return cnt;
    306. }
    308. int uart_close(int fd)
    309. {
    310.     assert(fd);
    311.     close(fd);
    313.     /*可以在这里做些清理工作*/
    315.     return 0;
    316. }
    318. int main(int argc, char *argv[])
    319. {
    320.     const char *w_buf = "hello";
    321.     size_t w_len = strlen(w_buf);
    323.     const char *tty = NULL;
    324.     int baude;
    325.     int c_flow;
    326.     int bits;
    327.     char parity;
    328.     int stop;
    330.     char r_buf[1024];
    331.     bzero(r_buf,1024);
    333.         tty = argv[1];  
    334.         printf("%s\n", tty);  
    335.     fd = uart_open(fd, tty);/*串口号/dev/ttySn,USB口号/dev/ttyUSBn*/
    336.     if(fd == -1)
    337.     {
    338.         fprintf(stderr,"uart_open error\n");
    339.         exit(EXIT_FAILURE);
    340.     }
    341.     printf("open OK\n");
    343.     if( argc < 2)
    344.     {
    345.         printf("format uart_test /dev/ttySx baude stop data_bits parity config_stream\n");
    346.         printf("such as:./uart_test /dev/ttySx 115200 1 8 N 0\n");
    347.         exit(EXIT_FAILURE);
    348.     }
    350.         baude  = atoi(argv[2]);            
    351.         stop   = atoi(argv[3]);            
    352.         bits   = atoi(argv[4]);        
    353.         parity = *argv[5];
    354.         c_flow = atoi(argv[6]);
    356.         printf("%s\n", tty);
    357.         printf("%d, %d, %d, %c, %d\n", baude, stop, bits, parity, c_flow);
    359.     if(uart_set(fd,baude,c_flow,bits,parity,stop) == -1)
    360.     {
    361.         fprintf(stderr,"uart set failed!\n");
    362.         exit(EXIT_FAILURE);
    363.     }
    364.     printf("uart_set OK\n");
    365.     ret = uart_write(fd,w_buf,w_len);
    366.     if(ret == -1)
    367.     {
    368.         fprintf(stderr,"uart write failed!\n");
    369.         exit(EXIT_FAILURE);
    370.     }
    371.     printf("uart_write OK\n");
    372.     while(1)
    373.     {
    374.         ret = uart_read(fd,r_buf,1024);
    375.         printf("loop");
    376.         if(ret == -1)
    377.         {
    378.             fprintf(stderr,"uart read failed!\n");
    379.             exit(EXIT_FAILURE);
    380.         }
    381.         printf("loop");
    382.     }
    384.     ret = uart_close(fd);
    385.     if(ret == -1)
    386.     {
    387.         fprintf(stderr,"uart_close error\n");
    388.         exit(EXIT_FAILURE);
    389.     }
    391.     exit(EXIT_SUCCESS);
    392. }