串口通用操作示例

2030阅读　0评论2017-01-24　frankey2009
分类：嵌入式


点击(此处)折叠或打开

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <stdint.h>
  4. #include <string.h>
  5. #include <unistd.h>
  6. #include <sys/types.h>
  7. #include <sys/stat.h>
  8. #include <fcntl.h>
  9. #include <termios.h>
  10. #include <errno.h>
  11. #include <limits.h>
  12. #include <asm/ioctls.h>
  13. #include <time.h>
  14. #include <pthread.h>
  15. #include <sys/ipc.h>
  16. #include <sys/msg.h>

  18. #include "lib-slip.h"

  20. #include "util-port.h"


  23. #define MSG printf

  25. static int gPortFd;
  26. static int gMsgId;
  27. static int gNumPort;
  28. MutilSlipAttr_t gUartSlip = {0};

  30. UartInfoAttr_t gUartInfo[] = {
  31.     [0] = {
  32.         .mPath = UART1_PATH,
  33.         .mMode = UART_115200_8N1,
  34.     },
  35.     [1] = {
  36.         .mPath = UART2_PATH,
  37.         .mMode = UART_115200_8N1,
  38.     },
  39.     [2] = {
  40.         .mPath = UART3_PATH,
  41.         .mMode = UART_115200_8N1,
  42.     },
  43.     [3] = {
  44.         .mPath = UART4_PATH,
  45.         .mMode = UART_115200_8N1,
  46.     },
  47. };

  49. int open_serial(int port){
  50.     int fd;
  51.     struct termios opt;

  53.     if(!gUartInfo[port].mPath){
  54.         return -1;
  55.     }
  56.     fd = open(gUartInfo[port].mPath, O_RDWR | O_NOCTTY);
  57.     if(fd < 0){
  58.         MSG("open uart fail.\n");
  59.         return -1;
  60.     }

  62.     tcgetattr(fd, &opt);

  64.     switch(gUartInfo[port].mMode){
  65.         case     UART_9600_8N1:{
  66.             cfsetispeed(&opt, B9600);
  67.              cfsetospeed(&opt, B9600);

  69.              opt.c_cflag &= ~PARENB;
  70.             opt.c_cflag &= ~CSTOPB;
  71.             opt.c_cflag &= ~CSIZE;
  72.             opt.c_cflag |= CS8;
  73.             break;
  74.         }
  75.         case     UART_9600_8O1:{
  76.             cfsetispeed(&opt, B9600);
  77.              cfsetospeed(&opt, B9600);

  79.              opt.c_cflag |= PARENB;
  80.             opt.c_cflag |= ~PARODD;
  81.             opt.c_cflag &= ~CSTOPB;
  82.             opt.c_cflag &= ~CSIZE;
  83.             opt.c_cflag |= CS8;
  84.             break;
  85.         }
  86.         case     UART_9600_8E1:{
  87.             cfsetispeed(&opt, B9600);
  88.              cfsetospeed(&opt, B9600);

  90.              opt.c_cflag |= PARENB;
  91.             opt.c_cflag &= ~PARODD;
  92.             opt.c_cflag &= ~CSTOPB;
  93.             opt.c_cflag &= ~CSIZE;
  94.             opt.c_cflag |= CS8;
  95.             break;
  96.         }

  98.         case    UART_115200_8N1:{
  99.             cfsetispeed(&opt, B115200);
  100.              cfsetospeed(&opt, B115200);

  102.              opt.c_cflag &= ~PARENB;
  103.             opt.c_cflag &= ~CSTOPB;
  104.             opt.c_cflag &= ~CSIZE;
  105.             opt.c_cflag |= CS8;

  107.             break;
  108.         }
  109.         case    UART_115200_8O1:{
  110.             cfsetispeed(&opt, B115200);
  111.              cfsetospeed(&opt, B115200);

  113.              opt.c_cflag |= PARENB;
  114.             opt.c_cflag |= ~PARODD;
  115.             opt.c_cflag &= ~CSTOPB;
  116.             opt.c_cflag &= ~CSIZE;
  117.             opt.c_cflag |= CS8;
  118.             break;
  119.         }
  120.         case    UART_115200_8E1:{
  121.             cfsetispeed(&opt, B115200);
  122.              cfsetospeed(&opt, B115200);

  124.              opt.c_cflag |= PARENB;
  125.             opt.c_cflag &= ~PARODD;
  126.             opt.c_cflag &= ~CSTOPB;
  127.             opt.c_cflag &= ~CSIZE;
  128.             opt.c_cflag |= CS8;
  129.             break;
  130.         }

  132.         default:{
  133.             return -1;
  134.             //break;
  135.         }
  136.     }

  138.     opt.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
  139.     opt.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
  140.     opt.c_oflag &= ~(OPOST);

  142.     opt.c_cc[VMIN] = 200;
  143.     opt.c_cc[VTIME] = 1;

  145.     if(tcsetattr(fd, TCSANOW, &opt) < 0){
  146.         printf("set attr error.\n");
  147.         return -1;
  148.     }

  150.     tcflush(fd, TCIOFLUSH);

  152.     return fd;
  153. }

  155. int stream_parse( uint8_t *p, int len ){
  156.     UartMsgInfo_t msg;
  157.     int ret;
  158.     while(len--){
  159.         ret = recv_packet(&gUartSlip, *p++);
  160.         if(ret == 1){
  161.             if(gUartSlip.mBuffIdx){
  162.                 //q
  163.                 msg.mType = PORT_MSG_TYPE_RCV; //must not be zero
  164.                 msg.mPayLoad.mLen = gUartSlip.mBuffIdx;
  165.                 memcpy(msg.mPayLoad.mData, gUartSlip.mBuff, gUartSlip.mBuffIdx);
  166.                 if((msgsnd(gMsgId, (void *)&msg, sizeof(UartMsgPayLoad_t), IPC_NOWAIT)) < 0){
  167.                     printf("port%d rcv msg send error.\n", gNumPort+1);
  168.                 }
  169.                 else{
  170.                     printf("port%d post rcv msg ok.\n", gNumPort+1);
  171.                 }
  172.             }
  173.         }
  174.     }
  175.     return 0;
  176. }

  178. void *port_read_thread(void *arg){
  179.     int len;
  180.     int iRet;
  181.     fd_set readSet;
  182.     uint8_t rcvBuff[UART_EACH_BUFF_RCV_MAX];


  185.     while(1){
  186.         FD_ZERO(&readSet);
  187.         FD_SET (gPortFd, &readSet);
  188.         
  189.         iRet = select(gPortFd + 1, &readSet, NULL, NULL, NULL);
  190.         if(iRet == -1){
  191.             MSG("select error.\n");
  192.             exit(-1);
  193.         }
  194.         else if(iRet == 0){
  195.             MSG("No data, exit.\n");
  196.             break;
  197.         }
  198.         else{
  199.             //
  200.             if(FD_ISSET(gPortFd, &readSet)){
  201.                 MSG("Port %d Rcv Data.\n", gNumPort+1);
  202.                 len = read(gPortFd, rcvBuff, UART_EACH_BUFF_RCV_MAX);
  203.                 #if 0 //test
  204.                 for(j = 0; j < len; j++)
  205.                     MSG(" %02x", rcvBuff[j]);
  206.                 MSG("\n");
  207.                 #endif
  208.                 if(len > 0){
  209.                     stream_parse( rcvBuff, len );
  210.                 }
  211.             }
  212.         }
  213.     }
  214.     pthread_exit(NULL);    
  215. }


  218. void *port_write_thread(void *arg){
  219.     UartMsgInfo_t msg;
  220.     int i;
  221.     int ret;
  222.     while(1){
  223.         if((ret = msgrcv(gMsgId, (void *)&msg, sizeof(UartMsgPayLoad_t), PORT_MSG_TYPE_SND, 0)) == -1){
  224.             printf("port%d get snd msg error.\n", gNumPort+1);
  225.         }
  226.         else{
  227.             printf("sMsg: type = %d, payloadLen = %d.\n", msg.mType, msg.mPayLoad.mLen);
  228.             printf(" data=");
  229.             for(i = 0; i < msg.mPayLoad.mLen; i++)
  230.                 printf(" %02x", msg.mPayLoad.mData[i]);
  231.             printf("\n");

  233.             if((ret = write(gPortFd, msg.mPayLoad.mData, msg.mPayLoad.mLen)) < 0){
  234.                 MSG("port%d send error.\n", gNumPort+1);
  235.             }
  236.             else{
  237.                 MSG("port%d send ok.\n", gNumPort+1);
  238.             }
  239.         }
  240.     }

  242. }


  245. int main(int argc, char const *argv[])
  246. {
  247.     /* code */
  248.     int key;
  249.     int ret;
  250.     pthread_t stid,rtid;


  253.     if(argc != 2){
  254.         MSG("argc error.\n");
  255.         return -1;
  256.     }

  258.     gNumPort = atoi(argv[1]);
  259.     if( (gNumPort > UART_NUM_MAX) || (gNumPort == 0)){
  260.         MSG("serial port not existed.\n");
  261.         return -1;
  262.     }
  263.     gNumPort -= 1;

  265.     if((key = ftok(gUartInfo[gNumPort].mPath, UART_MSG_KEY)) == -1){
  266.         MSG("port%d msg key error.\n", gNumPort+1);
  267.         return -1;
  268.     }

  270.     if((gMsgId = msgget(key, IPC_CREAT|0600)) == -1){
  271.         MSG("prot%d msg error.\n", gNumPort+1);
  272.         return -1;
  273.     }
  274.     printf("port%d msg ok. qid = %d\n", gNumPort+1, gMsgId);



  278.     
  279.     if((gPortFd = open_serial(gNumPort)) <= 0){
  280.         MSG("open serial port%d error.\n", gNumPort+1);
  281.         return -1;
  282.     }
  283.     MSG("open serial %d ok.[fd=%d].\n",gNumPort+1, gPortFd);

  285.     ret = pthread_create(&rtid, NULL, port_read_thread, NULL);
  286.     if(ret != 0){
  287.         MSG("port%d create port_read_thread error.\n", gNumPort+1);
  288.         return -1;
  289.     }

  291.     ret = pthread_create(&stid, NULL, port_write_thread, NULL);
  292.     if(ret != 0){
  293.         MSG("port%d create port_write_thread error.\n", gNumPort+1);
  294.         return -1;
  295.     }


  298.     pthread_join(rtid, NULL);
  299.     pthread_join(stid, NULL);

  301.     if(msgctl(gMsgId, IPC_RMID, NULL) < 0){
  302.         MSG("port%d msg ctl error.\n", gNumPort+1);
  303.     }

  305.     return 0;
  306. }
基于多线程实现串口自由收发
上一篇：FM25L256的驱动测试
下一篇：分享一个好东西，索引指南