0%

uart测试程序

发表于 2023-11-22 更新于 2024-04-22

UART(RS232) 串口协议

串口应用开发

1. 串口奇偶校验配置

奇校验

1
2
3

newtio.c_cflag |= PARENB;
newtio.c_cflag |= PARODD;
newtio.c_iflag |= (INPCK | ISTRIP);

偶校验

1
2
3

newtio.c_iflag |= (INPCK | ISTRIP);
newtio.c_cflag |= PARENB;
newtio.c_cflag &= ~PARODD;

无校验
1
newtio.c_cflag &= ~PARENB;

2. 设置停止位宽

1位停止位
1
newtio.c_cflag &= ~CSTOPB;
2位停止位
1
newtio.c_cflag |= CSTOPB;

C语言实例

int UART_Open(int fd,char* port)
{
        fd = open(port, O_RDWR|O_NOCTTY|O_NDELAY|O_NONBLOCK);
        if (-1 == fd){
                clog_report((char *)"Can't Open Serial Port");
                cerr_report(Openerr);
                return -1;
        }

        if(fcntl(fd, F_SETFL, 0) < 0){
                clog_report((char *)"fcntl failed!\n");
                cerr_report(Fcntlerr);
                return -1;
        } else {
                //    printf("fcntl=%d\n",fcntl(fd, F_SETFL,0));
        }

        if(0 == isatty(STDIN_FILENO)){
                clog_report((char *)"standard input is not a terminal device\n");
                //cerr_report(Nstdindev);
                //return -1;
        }

        return fd;
}

void UART_Close(int fd)
{
        close(fd);
}

int UART_Set(int fd,int speed,int flow_ctrl,int databits,int stopbits,int parity)
{

        int i;
        int speed_arr[] = { B115200, B38400, B19200, B9600, B4800, B2400, B1200, B300,
                B38400, B19200, B9600, B4800, B2400, B1200, B300
        };
        int name_arr[] = {
                115200, 38400, 19200, 9600, 4800, 2400, 1200, 300, 38400,
                19200, 9600, 4800, 2400, 1200, 300
        };
        struct termios options;
        int arrlen = sizeof(speed_arr) / sizeof(int);

        if(tcgetattr( fd,&options) != 0){
                perror("SetupSerial 1");
                return(-1);
        }

        for(i= 0;i < arrlen;i++) {
                if (speed == name_arr[i]) {
                        cfsetispeed(&options, speed_arr[i]);
                        cfsetospeed(&options, speed_arr[i]);
                }
        }
        options.c_cflag |= CLOCAL;
        options.c_cflag |= CREAD;
        switch(flow_ctrl){
                case 0 :
                        options.c_cflag &= ~CRTSCTS;
                        break;
                case 1 :
                        options.c_cflag |= CRTSCTS;
                        break;
                case 2 :
                        options.c_cflag |= IXON | IXOFF | IXANY;
                        break;
        }
        options.c_cflag &= ~CSIZE;
        switch (databits){
                case 5 :
                        options.c_cflag |= CS5;
                        break;
                case 6    :
                        options.c_cflag |= CS6;
                        break;
                case 7    :
                        options.c_cflag |= CS7;
                        break;
                case 8:
                        options.c_cflag |= CS8;
                        break;
                default:
                        clog_report((char *)"Unsupported data size\n");
                        return (-1);
        }
        switch (parity) {
                case 'n':
                case 'N':
                        options.c_cflag &= ~PARENB;
                        options.c_iflag &= ~INPCK;
                        break;
                case 'o':
                case 'O':
                        options.c_cflag |= (PARODD | PARENB);
                        options.c_iflag |= INPCK;
                        break;
                case 'e':
                case 'E':
                        options.c_cflag |= PARENB;
                        options.c_cflag &= ~PARODD;
                        options.c_iflag |= INPCK;
                        break;
                case 's':
                case 'S':
                        options.c_cflag &= ~PARENB;
                        options.c_cflag &= ~CSTOPB;
                        break;
                default:
                        clog_report((char *)"Unsupported parity");
                        return (-1);
        }
        switch (stopbits){
                case 1:
                        options.c_cflag &= ~CSTOPB;
                        break;
                case 2:
                        options.c_cflag |= CSTOPB;
                        break;
                default:
                        clog_report((char *)"Unsupported stop bits");
                        return (-1);
        }
        options.c_oflag &= ~OPOST;
        options.c_cc[VTIME] = 0;
        options.c_cc[VMIN] = 0;

        tcflush(fd,TCIFLUSH);

        if (tcsetattr(fd,TCSANOW,&options) != 0)
        {
                perror("com set error!/n");
                return -1;
        }
        return 1;
}


int UART_Init(int fd, int speed,int flow_ctrlint ,int databits,int stopbits,char parity)
{
        if (-1 == UART_Set(fd,speed,flow_ctrlint,databits,stopbits,parity)) {
                cerr_report(Initerr);
                return -1;
        } else {
                return 1;
        }
}

int UART_Recv(int fd, char *rcv_buf,int data_len)
{
        int len = 0;
        fd_set fs_read;

        struct timeval time;

        FD_ZERO(&fs_read);
        FD_SET(fd,&fs_read);

        time.tv_sec = 0;
        time.tv_usec = 300000;

        select(fd+1,&fs_read,NULL,NULL,&time);

        if(FD_ISSET(fd, &fs_read)){
                len = read(fd,rcv_buf,data_len);
                return len;
        } else {
                cerr_report(Recverr);
                return -1;
        }
}

int UART_Send(int fd, char *send_buf,int data_len)
{
        int ret;

        ret = write(fd,send_buf,data_len);
        if (data_len == ret ){
                return ret;
        } else {
                tcflush(fd,TCOFLUSH);
                cerr_report(Senderr);
                return -1;
        }
}

int uart3_loopback(void* arg, int *failcnt)
{
        int fd_tx = -1;
        int ret, i;
        char snd_buf[512] = {0};
        char rcv_buf[512] = {0};
        char cmd[1024] = {0};
        int data_len = 0;
        struct uart_data data = *(struct uart_data *)arg;

        for(i=0; i<99; i++)
        {
                switch(i%2) {
                        case 0:
                                snd_buf[i] = 'c';
                                break;
                        case 1:
                                snd_buf[i] = '5';
                                break;
                }
        }
        snd_buf[i] = '\n';

        fd_tx = UART_Open(fd_tx, data.uart_tx);
        if(-1 == fd_tx){
                sprintf(cmd, "open %s error", data.uart_tx);
                clog_report(cmd);
                (*failcnt)++;
                return -1;
        }

        ret = UART_Init(fd_tx,data.baudrate,1,8,1,'N');
        if (-1 == fd_tx){
                sprintf(cmd, "Set %s Port Error",  data.uart_tx);
                clog_report(cmd);
                (*failcnt)++;
                return -1;
        }
        data_len = strlen(snd_buf);

        memset(rcv_buf,0,sizeof(rcv_buf));
        tcflush(fd_tx,TCIOFLUSH);

        ret = UART_Send(fd_tx,snd_buf, data_len);
        if(-1 == ret){
                sprintf(cmd, "%s(rs422) send failed!", data.uart_tx);
                clog_report(cmd);
                (*failcnt)++;
                return -1;
        } else {
                sprintf(cmd, "port:%s(rs422)[@%ld] send data: %s", data.uart_tx, data.baudrate, snd_buf);
                clog_report(cmd);
        }

        usleep(600000);

        ret = UART_Recv(fd_tx, rcv_buf, data_len);
        if( ret > 0){
                sprintf(cmd, "port:%s(rs422)[@%ld] receive data: %s", data.uart_tx, data.baudrate, rcv_buf);
                clog_report(cmd);
        }
        tcflush(fd_tx,TCIOFLUSH);

        ret = strncmp(snd_buf, rcv_buf, data_len);
        if (ret == 0) {
                sprintf(cmd, "Test[@%ld] %s(rs422) ok ...", data.baudrate, data.uart_tx);
                clog_report(cmd);
        } else {
                sprintf(cmd, "Test[@%ld] %s(rs422) failed ...", data.baudrate, data.uart_tx);
                clog_report(cmd);
                (*failcnt)++;
        }

        UART_Close(fd_tx);

        return 0;
}

int uart1_uart2_txrx(void* arg, int *failcnt)
{
                int fd_tx = -1;
                int fd_rx = -1;
                int ret;
                char snd_buf[512] = {0};
                char rcv_buf[512] = {0};
                char cmd[1024] = {0};
                int data_len = 0;
                unsigned long i;
                struct uart_data data = *(struct uart_data *)arg;

                for(i=0; i<99; i++)
                {
                        switch(i%2) {
                                case 0:
                                        snd_buf[i] = 'c';
                                        break;
                                case 1:
                                        snd_buf[i] = '5';
                                        break;
                        }
                }
                snd_buf[i] = '\n';

                fd_tx = UART_Open(fd_tx, data.uart_tx);
                if(-1 == fd_tx){
                        sprintf(cmd, "open %s error", data.uart_tx);
                        clog_report(cmd);
                        (*failcnt)++;
                        return -1;
                }
                ret = UART_Init(fd_tx,data.baudrate,1,8,1,'N');
                if (-1 == fd_tx){
                        sprintf(cmd, "Set %s Port Error",  data.uart_tx);
                        clog_report(cmd);
                        (*failcnt)++;
                        return -1;
                }

                fd_rx = UART_Open(fd_rx,data.uart_rx);
                if(-1 == fd_rx){
                        sprintf(cmd, "open %s error", data.uart_rx);
                        clog_report(cmd);
                        (*failcnt)++;
                        return -1;
                }
                ret = UART_Init(fd_rx,data.baudrate,1,8,1,'N');
                if (-1 == fd_rx){
                        sprintf(cmd, "Set %s Port Error",  data.uart_rx);
                        clog_report(cmd);
                        (*failcnt)++;
                        return -1;
                }
                data_len = strlen(snd_buf);

                memset(rcv_buf,0,sizeof(rcv_buf));
                tcflush(fd_tx,TCIOFLUSH);

                ret = UART_Send(fd_tx, snd_buf, data_len);
                if(-1 == ret){
                        sprintf(cmd, "%s write error!", data.uart_tx);
                        clog_report(cmd);
                        (*failcnt)++;
                        return -1;
                } else {
                        sprintf(cmd, "port:%s(rs232a)[@%ld] send data: %s", data.uart_tx, data.baudrate, snd_buf);
                        clog_report(cmd);
                }
                usleep(600000);

                ret = UART_Recv(fd_rx, rcv_buf,data_len);
                if( ret > 0){
                        sprintf(cmd, "port:%s(rs232b)[@%ld] receive data: %s", data.uart_rx, data.baudrate, rcv_buf);
                        clog_report(cmd);
                }
                tcflush(fd_rx,TCIOFLUSH);

                ret = strncmp(snd_buf, rcv_buf, data_len);
                if (ret == 0) {
                        sprintf(cmd, "Test(@%ld) %s(rs232a) ==> %s(rs232b) ok ...", data.baudrate, data.uart_tx, data.uart_rx);
                        clog_report(cmd);
                } else {
                        sprintf(cmd, "Test(@%ld) %s(rs232a) ==> %s(rs232b) failed ...", data.baudrate, data.uart_tx, data.uart_rx);
                        clog_report(cmd);
                        (*failcnt)++;
                        return -1;
                }

                //loopback
                memset(rcv_buf,0,sizeof(rcv_buf));
                tcflush(fd_rx,TCIOFLUSH);

                ret = UART_Send(fd_rx, snd_buf, data_len);
                if(-1 == ret){
                        sprintf(cmd, "write back to [%s] error!\n", data.uart_rx);
                        clog_report(cmd);
                        (*failcnt)++;
                        return -1;
                } else {
                        sprintf(cmd, "port:%s(rs232b)[@%ld] send data: %s\n", data.uart_rx, data.baudrate, snd_buf);
                        clog_report(cmd);
                }

                usleep(600000);

                ret = UART_Recv(fd_tx, rcv_buf, data_len);
                if(ret > 0){
                        sprintf(cmd, "port:%s(rs232a)[@%ld] receive data: %s\n", data.uart_tx, data.baudrate, rcv_buf);
                        clog_report(cmd);
                }
                tcflush(fd_tx,TCIOFLUSH);

                ret = strncmp(snd_buf, rcv_buf, data_len);
                if (ret == 0) {
                        sprintf(cmd, "Test(@%ld) %s(rs232b) ==> %s(rs232a) ok ...", data.baudrate, data.uart_rx, data.uart_tx);
                        clog_report(cmd);
                } else {
                        sprintf(cmd, "Test(@%ld) %s(rs232b) ==> %s(rs232a) failed ...", data.baudrate, data.uart_rx, data.uart_tx);
                        clog_report(cmd);
                        (*failcnt)++;
                        return -1;
                }

                UART_Close(fd_tx);
                UART_Close(fd_rx);

                return 0;
}

int main(int argc, const char *argv[])
{
        int ret;
        struct uart_data *uart_data_test = NULL;
        int baudrate[3] = {460800, 115200, 9600};
        char result[20] = {0};
        int i, failcnt = 0;
        int cnt = atoi(argv[1]);
        int times = 1;
        char msg[100] = {0};
        struct timeval start, end;
        double maxtime=0,mintime=1000000,tms=0,full_time=0;

        ret = clog_init((char *)"UART_001", 2);
        if (ret != 0)
        {
                printf("test_uart log_init failed\n");
                return 0;
        }

        uart_data_test = (struct uart_data *)malloc(sizeof(struct uart_data));
        while(cnt) {
                clog_report((char *)"-------------------------------------------------------------------");
                sprintf(msg, "重复测试总轮数: %d 当前轮数: %d", atoi(argv[1]), times++);
                clog_report(msg);
                cnt--;

                gettimeofday(&start, NULL);
                for (i=0; i < 3; i++) {
                        //memset(uart_data_test->uart_tx, 0, 64);
                        //memset(uart_data_test->uart_rx, 0, 64);
                        //strcpy(uart_data_test->uart_tx, "/dev/ttyTHS0");
                        //strcpy(uart_data_test->uart_rx, "/dev/ttyTHS1");
                        //uart_data_test->baudrate = baudrate[i];

                        //ret = uart1_uart2_txrx((void*)uart_data_test, &failcnt);
                        //if (ret)
                        //      goto finish;

                        memset(uart_data_test->uart_tx, 0, 64);
                        strcpy(uart_data_test->uart_tx, "/dev/ttyTHS4");
                        uart_data_test->baudrate = baudrate[i];

                        ret = uart3_loopback((void *)uart_data_test, &failcnt);
                        if (ret)
                                goto finish;
                }
                gettimeofday(&end, NULL);
                tms = ((end.tv_sec - start.tv_sec) * 1000000 + (end.tv_usec - start.tv_usec)) / 1000;

                sprintf(msg, "测试耗时: %lf ms", tms);
                clog_report(msg);
                maxtime=std::max(maxtime,tms);
                mintime=std::min(mintime,tms);
                full_time+=tms;
        };

finish:
        sprintf(msg, "最长测试用时: %lf 最短测试用时: %lf 总测试用时: %lf", maxtime, mintime, full_time);
        clog_report(msg);
        sprintf(msg, "重复测试总轮数: %d 成功轮数: %d 失败轮数: %d", atoi(argv[1]), atoi(argv[1]) - cnt - failcnt, failcnt);
        clog_report(msg);
        clog_report((char *)"-------------------------------------------------------------------");
        free(uart_data_test);

        if(failcnt)
                sprintf(result, "failure");
        else
                sprintf(result, "pass");

        clog_done(result);

        return Success;
}

python实例

import subprocess
import os
import serial  
import time  
  

#打开串口  
ser1 = serial.Serial('/dev/ttyS1', 9600, timeout=1)  
ser2 = serial.Serial('/dev/ttyS2', 9600, timeout=1)  
  
#发送数据  
def send_data(ser, data):  
    ser.write(data.encode())  
  
#接收数据  
def receive_data(ser):  
    while True:  
        data = ser.readline().decode().strip()  
        if data:  
            return data  
  
#统计中断数 
#ttys1Result1 = subprocess.check_output("cat /proc/interrupts | grep ttyS1 | awk '{print $2}'", shell=True)
#ttys2Result1 = subprocess.check_output("cat /proc/interrupts | grep ttyS2 | awk '{print $2}'", shell=True)
#print(ttys1Result1.decode())
#print(ttys2Result1.decode())

#发送开始时间
start_time = time.time()
#9600
send_data(ser1, 'c5c5'*240)  
rcvData = receive_data(ser2)  
if rcvData == 'c5c5'*240:
    print("测试通过")
else:
    print("测试失败")

#发送结束时间
end_time = time.time()

#统计结束后的中断数
#ttys1Result2 = subprocess.check_output("cat /proc/interrupts | grep ttyS1 | awk '{print $2}'", shell=True)
#ttys2Result2 = subprocess.check_output("cat /proc/interrupts | grep ttyS2 | awk '{print $2}'", shell=True)
#print(ttys1Result2.decode())
#print(ttys2Result2.decode())
#result1=int(ttys1Result2) - int(ttys1Result1)
#print(result1)
#result2=int(ttys2Result2) - int(ttys2Result1)
#print(result2)
#print(f"发送数据到的时间: {end_time - start_time}秒")
  
#关闭串口  
ser1.close()  
ser2.close()