串口自发自收测试程序

sp_uart_test.c

#include <stdio.h>      /*标准输入输出定义*/
#include <stdlib.h>     /*标准函数库定义*/
#include <unistd.h>     /*Unix标准函数定义*/
#include <sys/types.h>  /**/
#include <sys/stat.h>   /**/
#include <fcntl.h>      /*文件控制定义*/
#include <termios.h>    /*PPSIX终端控制定义*/
#include <errno.h>      /*错误号定义*/
#include <pthread.h>
#include <signal.h>
#include <sys/ioctl.h>

typedef unsigned char uchar;
typedef unsigned int uint;

uchar LRC_Check(uchar *data, uchar length) 
{ 
    uchar i; uint k; 
    uchar result; 
 
    uchar lrcdata[length]; 
    for(i=1;i<length+1;i++) 
    {   
        if(data[i]>0x40) 
            lrcdata[i-1]=data[i]-0x41+10; 
        else 
            lrcdata[i-1]=data[i]-0x30; 
    } 
 
    k=0; 
    for(i=0;i<length/2;i++) 
    { 
     k+=(lrcdata[2*i]*16+lrcdata[2*i+1]); 
    } 
     
    k=k%256; 
    k=256-k; 
    result=k%256; 
    return result; 
} 

unsigned char LRC(uchar * data, int length)
{
    uchar i;
    uint k;
    uchar result;
    uint iCount = 0;
    uint lrcValue = 0x00;
    
    for(iCount=0;iCount<length;iCount++)
    {
        lrcValue=lrcValue^data[iCount];
        //printf("%02x
",data[iCount]);
    }

    result=lrcValue;
    return(result);
}

#define FALSE 0
#define TRUE 1
int uart_fd;
pthread_t g_tid;


int speed_arr[] = {B460800, B115200, B57600, B38400, B19200, B9600, B4800, B2400, B1200, B300};
int name_arr[] =  {460800,  115200,  57600,  38400,  19200,  9600,  4800,  2400,  1200,  300};
void set_speed(int fd, int speed)
{
  int   i;
  int   status;
  struct termios   Opt;
  tcgetattr(fd, &Opt);
  for ( i= 0;  i < sizeof(speed_arr) / sizeof(int);  i++)
   {
       if  (speed == name_arr[i])
       {
           tcflush(fd, TCIOFLUSH);
        cfsetispeed(&Opt, speed_arr[i]);
        cfsetospeed(&Opt, speed_arr[i]);
        status = tcsetattr(fd, TCSANOW, &Opt);
        if  (status != 0)
            perror("tcsetattr fd1");
         return;
         }
   tcflush(fd,TCIOFLUSH);
   }
}
/**
*@brief   设置串口数据位，停止位和效验位
*@param  fd     类型  int  打开的串口文件句柄*
*@param  databits 类型  int 数据位   取值 为 7 或者8*
*@param  stopbits 类型  int 停止位   取值为 1 或者2*
*@param  parity  类型  int  效验类型 取值为N,E,O,,S
*/
int set_Parity(int fd,int databits,int stopbits,int parity)
{
    struct termios options;
 if  ( tcgetattr( fd,&options)  !=  0)
  {
      perror("SetupSerial 1");
      return(FALSE);
  }
  options.c_cflag &= ~CSIZE;
  /**
    如果不是开发终端之类的，只是串口传输数据，而不需要串口来处理，那么使用原始模式(Raw Mode)方式来通讯，设置方式如下
   **/
  options.c_lflag  &= ~(ICANON | ECHO | ECHOE | ISIG);  /*Input*/
  options.c_iflag &= ~(ICRNL | IXON | IXOFF);
  options.c_oflag  &= ~OPOST;   /*Output*/ 
  switch (databits) /*设置数据位数*/
  {
      case 7:
          options.c_cflag |= CS7;
          break;
      case 8:
        options.c_cflag |= CS8;
        break;
    default:
        fprintf(stderr,"Unsupported data size
");
        return (FALSE);
    }
  switch (parity)
      {
      case 'n':
    case 'N':
        options.c_cflag &= ~PARENB;   /* Clear parity enable */
        options.c_iflag &= ~INPCK;     /* Enable parity checking */
        break;
    case 'o':
    case 'O':
        options.c_cflag |= (PARODD | PARENB);  /* 设置为奇效验*/ 
        options.c_iflag |= INPCK;             /* Disnable parity checking */
        break;
    case 'e':
    case 'E':
        options.c_cflag |= PARENB;     /* Enable parity */
        options.c_cflag &= ~PARODD;   /* 转换为偶效验*/  
        options.c_iflag |= INPCK;       /* Disnable parity checking */
        break;
    case 'S':
    case 's':  /*as no parity*/
        options.c_cflag &= ~PARENB;
        options.c_cflag &= ~CSTOPB;
        break;
    default:
        fprintf(stderr,"Unsupported parity
");
        return (FALSE);
        }
  /* 设置停止位*/   
  switch (stopbits)
      {
      case 1:
          options.c_cflag &= ~CSTOPB;
        break;
    case 2:
        options.c_cflag |= CSTOPB;
        break;
    default:
        fprintf(stderr,"Unsupported stop bits
");
        return (FALSE);
    }
  /* Set input parity option */
  if (parity != 'n')
          options.c_iflag |= INPCK;
    options.c_cc[VTIME] = 15; // 15 seconds
    options.c_cc[VMIN] = 0;

  tcflush(fd,TCSANOW); /* Update the options and do it NOW */
  
  if(ioctl(fd, TIOCEXCL, 0) < 0) {
     printf("TIOCEXCL err
");
       }
  
  if (tcsetattr(fd,TCSADRAIN,&options) != 0)
      {
          perror("SetupSerial 3");
        return (FALSE);
    }
  return (TRUE);
 }
/**
*@breif 打开串口
*/
int OpenDev(char *Dev)
{
int    fd = open( Dev, O_RDWR| O_NOCTTY);// | O_NDELAY ); 
    if (-1 == fd)
        { /*设置数据位数*/
            perror("Can't Open Serial Port");
            return -1;
        }
    else
    return fd;

}

void SendCommand(unsigned char *buf, int len)    
{      
    int ret=0;
        int total = len;
     
    do
    {
                ret=write(uart_fd,buf,len);
                if ( ret < 0 )
                  break;
                else
        {
                  buf += ret;
                  len -= ret;
                } 
 
                if ( len > 0 )
                {
          printf("send again, data left:%d
",len);
          usleep(5000);
                }
    } while(len > 0);
     
        printf("  --> send size:%d, ret=%d
", total - len, ret);     
}

//06 02 00 09 01 16 00 00 01 23 45 67 89 03 94

#define TEST_DATA_SIZE 2048
#define BUFFER_SIZE (TEST_DATA_SIZE * 2)
void main(void)
{
    int nread=0,i;
    int counts=0;
        int max_data_size=0;
        int time_last;
        int time_now;
    int np=0;
    char *dev ="/dev/ttyS1";

/*    unsigned char  data1[ ]={
    0x00,0x00,0x01, 0x23 ,0x45 ,0x67 ,0x89 ,0xab ,0xcd ,0xef ,};
*/    

    unsigned char  data1[TEST_DATA_SIZE];

    
    unsigned char tmp[BUFFER_SIZE];
    unsigned char revtmp[BUFFER_SIZE];
    
    struct package{  
        unsigned char start; 
        unsigned short length;
        unsigned short sn;
        unsigned short cmd;
        unsigned char *data;//[1018];
        unsigned char end;  
        unsigned char lrc;  
    };
    
    
    struct package pks;
    
      #define PKS_HEAD_SIZE    5
    
    pks.start=0x02;
    pks.length=sizeof(data1);
    pks.sn=0x01;
    pks.cmd=0x16;    
    pks.data=data1;
    pks.end=0x03;

    tmp[0]=pks.start;
    tmp[1]=pks.length>>8;
    tmp[2]=pks.length;
    tmp[3]=pks.sn;
    tmp[4]=pks.cmd;        
    //memcpy(&tmp[5],data1,sizeof(data1));
    //tmp[3+pks.length]=pks.end;
    //pks.lrc=LRC(&tmp[1],pks.length+3);
    //tmp[4+pks.length]=pks.lrc;
    
    //printf("%02x----l:%d
",pks.lrc,pks.length );
    
    printf("S600 uart bridge!
");

    //system("stty -F /dev/ttyS1 speed 115200 -brkint -icrnl -imaxbel -opost -isig -icanon -echo -echoe");

    /*for(i=0;i<pks.length+5;i++)
    {
        printf("%02x
",tmp[i]);
    }
    */
    
    uart_fd = OpenDev(dev);
    if (uart_fd > 0 )
        set_speed(uart_fd,115200*4);
    else
    {
      printf("Can't Open Serial Port!
");
      exit(0);
    }
    
    if (set_Parity(uart_fd,8,1,'N')== FALSE)
    {
      printf("Set Parity Error
");
      exit(1);
    }

    while(1)
    {
SEND:    
            //usleep(1000*100);
                pks.length =  TEST_DATA_SIZE / 2  + rand() % 256;
                pks.sn = counts & 0xff;;

                tmp[1]=pks.length>>8;
            tmp[2]=pks.length;                
        tmp[3] = pks.sn;  //pkg.sn

              for(i=0;i<sizeof(data1);i++)
            {
           data1[i]= i + tmp[3];
            }

        memcpy(&tmp[PKS_HEAD_SIZE],data1,sizeof(data1));
        tmp[5+pks.length]=pks.end;
        pks.lrc=LRC(&tmp[1],pks.length+3);
        tmp[6+pks.length]=pks.lrc;

        printf("NO:%d
", counts);
        SendCommand(tmp,pks.length+PKS_HEAD_SIZE);
        counts++;
        

               time_last = time(NULL);
               np = 0;
              // printf("  <--");
READ:

        nread = read(uart_fd,&revtmp[np],BUFFER_SIZE - np);
        if(nread>0)
        {
            np=np+nread;
                       // printf(".");
        }
        
                time_now = time(NULL);

        if((np>=pks.length+PKS_HEAD_SIZE) || (time_now - time_last) > 5)
        { 
                if ( np > max_data_size )
                             max_data_size = np;

                printf("  <-- recv max %d, recv %d
",max_data_size,np);
                
                if(memcmp(tmp,&revtmp,pks.length+PKS_HEAD_SIZE))
                {
                                    
                    for(i=0;i<np;i++)
                    {
                        printf("%02x ",revtmp[i]);
                                                if (i % 32 == 31 )
                                                  printf("
");
                    }                    
                    printf("
");
                    printf("****************** check erro!*****************
");
                                        for ( i = 0; i < np; i++ )
                                        {
                                           if ( tmp[i] != revtmp[i] ) {
                                             printf("error data index:%d, send value:0x%x, recv value:0x%x
", i, tmp[i], revtmp[i] );
                                           }
                                            
                                        }
                    printf("
");
                    break;
                }
                np=0;
                                printf("
");
                goto SEND;
        }
        else
        {
            goto READ;
        }
        
    }
    
}

Android.mk

LOCAL_PATH:= $(call my-dir)

include $(CLEAR_VARS)

LOCAL_MODULE:= uart_test

LOCAL_SRC_FILES := 
    sp_uart_test.c

include $(BUILD_EXECUTABLE)