Tronlong串口读写例程注释

最新推荐文章于 2024-12-09 10:25:09 发布

原创最新推荐文章于 2024-12-09 10:25:09 发布 · 346 阅读

1 ·

CC 4.0 BY-SA版权

本文介绍了一个串口读写程序的实现细节，包括参数解析、串口初始化、读写操作及信号处理。通过 getopt 函数解析命令行参数，设置串口属性如波特率、数据位等，并使用 select 函数进行非阻塞读取。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h> //getopt_ 函数头文件
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/select.h>
#include <sys/time.h>
#include <fcntl.h>
#include <termios.h>
#include <string.h>
#include <errno.h>
#include <stdbool.h>
#include <libgen.h>
#include <signal.h>
#include <getopt.h>

#define INADEQUATE_CONDITIONS 3

enum Mode { READ, WRITE };

/* Exit flag */
volatile bool g_quit = false;

/* Short option names */
static const char g_shortopts [] = ":d:s:rwvh"; //冒号影响函数返回值，此处没什么意义

/* Option names */
static const struct option g_longopts [] = {
{ "device", required_argument, NULL, 'd' },
{ "read", no_argument, NULL, 'r' },
{ "write", no_argument, NULL, 'w' },
{ "size", required_argument, NULL, 's' },
{ "version", no_argument, NULL, 'v' },
{ "help", no_argument, NULL, 'h' },
{ 0, 0, 0, 0 }
};

static void usage(FILE *fp, int argc, char **argv) {
fprintf(fp,
"Usage: %s [options]\n\n"
"Options:\n"
" -d | --device Device such as '/dev/ttyS0'\n"
" -r | --read Read\n"
" -w | --write Write\n"
" -s | --size Read size\n"
" -v | --version Display version information\n"
" -h | --help Show help content\n"
" e.g. ./tl-uart-rw -d /dev/ttyS1 -r -s 256\n"
" ./tl-uart-rw -d /dev/ttyS1 -w -s 1024\n\n"
"", basename(argv[0]));
}

//argc数值等于输入参数字符数+1

static void opt_parsing_err_handle(int argc, char **argv, int flag) {
/* Exit if no input parameters are entered */
int state = 0;
if (argc < 2) {
printf("No input parameters are entered, please check the input.\n");
state = -1;
} else {
/* Feedback Error parameter information then exit */

//optind 是全局变量
if (optind < argc || flag) {
printf("Error: Parameter parsing failed\n");
if (flag)
printf("\tunrecognized option '%s'\n", argv[optind-1]); // argv[optind-1]打印参数值

while (optind < argc) {
printf("\tunrecognized option '%s'\n", argv[optind++]);
}

state = -1;
}
}

if (state == -1) {
printf("Tips: '-h' or '--help' to get help\n\n");
exit(2);
}
}

//中断处理函数 ctrl+c

void sig_handle(int arg) {
g_quit = true;
}

int init_serial(int *fd, const char *dev) {
struct termios opt;

/* open serial device */
if ((*fd = open(dev, O_RDWR)) < 0) {
perror("open()");
return -1;
}

/* define termois */
if (tcgetattr(*fd, &opt) < 0) {
perror("tcgetattr()");
return -1;
}

opt.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
opt.c_oflag &= ~OPOST;

/* Character length, make sure to screen out this bit before setting the data bit */
opt.c_cflag &= ~CSIZE;

/* No hardware flow control */
opt.c_cflag &= ~CRTSCTS;

/* 8-bit data length */
opt.c_cflag |= CS8;

/* 1-bit stop bit */
opt.c_cflag &= ~CSTOPB;

/* No parity bit */
opt.c_iflag |= IGNPAR;

/* Output mode */
opt.c_oflag = 0;

/* No active terminal mode */
opt.c_lflag = 0;

/* Input baud rate */
if (cfsetispeed(&opt, B115200) < 0)
return -1;

/* Output baud rate */
if (cfsetospeed(&opt, B115200) < 0)
return -1;

/* Overflow data can be received, but not read */
if (tcflush(*fd, TCIFLUSH) < 0)
return -1;

if (tcsetattr(*fd, TCSANOW, &opt) < 0)
return -1;

return 0;
}

int serial_write(int *fd, const char *data, size_t size) {
int ret = write(*fd, data, size);
if ( ret < 0 ) {
perror("write");
tcflush(*fd, TCOFLUSH);
}

return ret;
}

int serial_read(int *fd, char *data, size_t size) {
size_t read_left = size;
size_t read_size = 0;
char *read_ptr = data;
struct timeval timeout = {5, 0};

memset(data, 0, size);

fd_set rfds;
while (!g_quit) {
FD_ZERO(&rfds);
FD_SET(*fd, &rfds);
timeout.tv_sec = 5;
timeout.tv_usec = 0;

if (read_left == 0)
break;

switch (select(*fd+1, &rfds, NULL, NULL, &timeout)) {
case -1:
perror("select()");
break;
case 0:
perror("timeout and retry");
break;
default:
if (FD_ISSET(*fd,&rfds)) {
read_size = read(*fd, read_ptr, read_left);
if (read_size == 0)
break;

read_ptr += read_size;
read_left -= read_size;
}
}
}

return strlen(data);
}

int main(int argc, char *argv[]) {
int c = 0;
int flag = 0;
int fd = -1;
int mode = -1;
int ret = -1;
size_t size = 0;
char *buf = NULL;
char *dev = NULL;

/* Parsing input parameters */
while ((c = getopt_long(argc, argv, g_shortopts, g_longopts, NULL)) != -1) {
switch (c) {
case 'd':
dev = optarg;// 全局变量，代表输入参数字符串
break;

case 'r':
mode = READ;
break;

case 'w':
mode = WRITE;
break;

case 's':
size = atoi(optarg);
break;

case 'v':
/* Display the version */
printf("version : 1.0\n");
exit(0);

case 'h':
usage(stdout, argc, argv);
exit(0);

default :
flag = 1;
break;
}
}

opt_parsing_err_handle(argc, argv, flag);

/* Ctrl+c handler */
signal(SIGINT, sig_handle);

ret = init_serial(&fd, dev);
if (ret < 0) {
goto release;
}

switch (mode) {
case READ:
printf("Mode : read\n");
if (size <= 0) {
printf ("Error : Incorrect size settings\n");
exit(INADEQUATE_CONDITIONS);
}
buf = (char*)malloc(size);
ret = serial_read(&fd, buf, size);
printf("recv: %s\nsize: %d\n", buf, ret);
free(buf);
break;

case WRITE:
printf("Mode : write\n");
if (size <= 0) {
printf("Error : Incorrect size settings\n");
exit(INADEQUATE_CONDITIONS);
}

int i = 0;
char context;
size_t write_size = 0;
while (!g_quit) {
if (i > 7)
i = 0;
context = (char)('0' + i);

write_size += serial_write(&fd, &context, sizeof(context));
i ++;

if (size == write_size)
break;
}

printf("send size: %d\n", write_size);
break;

default:
break;
}

release:
close(fd);
if(ret < 0)
return INADEQUATE_CONDITIONS;
return 0;
}