#include <linux/module.h>
#include <linux/init.h>
#include <linux/serial_core.h>
#include <linux/serial.h>
#include <linux/tty.h>
#include <linux/tty_flip.h>

#define DRIVER_NAME "my_serial_driver"

static struct uart_driver my_uart_driver = {
    .owner = THIS_MODULE,
    .driver_name = DRIVER_NAME,
    .dev_name = "ttyMY",    // 設(shè)備文件名，例如 /dev/ttyMY0
    .major = 0,    // 自動分配主設(shè)備號
    .minor = 0,    // 自動分配從設(shè)備號
    .nr = 1,    // 支持的最大串口數(shù)量
};

// 串口 probe 函數(shù)，用于初始化串口參數(shù)和注冊串口設(shè)備
static int my_serial_probe(struct uart_port *port)
{
    // 設(shè)置串口參數(shù)
    port->ops = &my_uart_driver.ops;
    port->type = PORT_16550A;
    port->iotype = UPIO_MEM;
    port->ioport = 0x3f8;    // 串口的 I/O 端口地址
    port->irq = 4;    // 串口的中斷號
    port->flags = UPF_BOOT_AUTOCONF;

    return uart_add_one_port(&my_uart_driver, port);    // 注冊串口設(shè)備
}

// 串口 remove 函數(shù)，用于注銷串口設(shè)備
static void my_serial_remove(struct uart_port *port)
{
    uart_remove_one_port(&my_uart_driver, port);    // 注銷串口設(shè)備
}

// 串口操作函數(shù)表，這里只需要實現(xiàn) probe 和 remove 函數(shù)
static struct uart_ops my_uart_ops = {
    .tx_empty = NULL,
    .set_mctrl = NULL,
    .get_mctrl = NULL,
    .stop_tx = NULL,
    .start_tx = NULL,
    .send_xchar = NULL,
    .stop_rx = NULL,
    .enable_ms = NULL,
    .break_ctl = NULL,
    .startup = NULL,
    .shutdown = NULL,
    .flush_buffer = NULL,
    .set_termios = NULL,
    .type = NULL,
    .release_port = NULL,
    .request_port = NULL,
    .config_port = NULL,
    .verify_port = NULL,
    .ioctl = NULL,
    .send_xchar_locked = NULL,
};

// 模塊初始化函數(shù)，在這里注冊串口驅(qū)動
static int my_serial_init(void)
{
    int ret = 0;

    // 注冊串口驅(qū)動
    ret = uart_register_driver(&my_uart_driver);
    if (ret) {
        printk(KERN_ERR "Failed to register UART driver\n");
        return ret;
    }

    // 設(shè)置串口操作函數(shù)表中的 probe 和 remove 函數(shù)
    my_uart_ops.probe = my_serial_probe;
    my_uart_ops.remove = my_serial_remove;
    my_uart_driver.ops = my_uart_ops;

    return ret;
}

// 模塊卸載函數(shù)，在這里注銷串口驅(qū)動
static void my_serial_exit(void)
{
    uart_unregister_driver(&my_uart_driver);
}

module_init(my_serial_init);
module_exit(my_serial_exit);

MODULE_LICENSE("GPL");

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <termios.h>

#define DEVICE "/dev/ttyMY0"

int main()
{
    int fd = 0;
    struct termios tio;
    char buf[256];

    // 打開設(shè)備文件
    fd = open(DEVICE, O_RDWR | O_NOCTTY | O_NDELAY);
    if (fd < 0) {
        perror("open");
        return -1;
    }

    // 設(shè)置串口參數(shù)
    tcgetattr(fd, &tio);
    tio.c_iflag = IGNBRK | IGNPAR;
    tio.c_oflag = 0;
    tio.c_cflag = CS8 | CREAD | CLOCAL;
    tio.c_lflag = 0;
    tio.c_cc[VTIME] = 0;
    tio.c_cc[VMIN] = 1;
cfsetispeed(&tio, B9600);
cfsetospeed(&tio, B9600);
tcsetattr(fd, TCSANOW, &tio);

// 讀取串口數(shù)據(jù)
printf("Reading from serial port...\n");
while (1) {
    int n = read(fd, buf, sizeof(buf));
    if (n > 0) {
        buf[n] = '\0';
        printf("Received: %s", buf);
    }
}

// 關(guān)閉設(shè)備文件
close(fd);

return 0;

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <pthread.h>
//宏定義
#define OK 0
#define ERR (-1)
//靜態(tài)變量
static int fd1;    // 串口設(shè)備文件描述符
static int fd2;
static int send_data;   // 傳輸?shù)臄?shù)據(jù)
// 從串口讀的線程
// 轉(zhuǎn)換波特率
speed_t conver_baudrate(int baudrate)
{
    switch (baudrate) {
        case 9600L:
            return B9600;
        case 19200L:
            return B19200;
        case 38400L:
            return B38400;
        case 115200L:
            return B115200;
        case 1152000L:
            return B1152000;
        default:
            return 1152000L;
    }
}

void set_baud(int fd, int baud)
{
    int ret = ERR;
    struct termios opt;

    tcgetattr(fd, &opt); // tcgetattr用來獲取終端參數(shù)，將從終端獲得的信息fd，保存到opt結(jié)構(gòu)體中
    tcflush(fd, TCIOFLUSH); // 刷清緩沖區(qū)
    cfsetispeed(&opt, baud);
    cfsetospeed(&opt, baud);

    ret = tcsetattr(fd, TCSANOW, &opt); // 設(shè)置終端參數(shù)到opt中，使之立即生效
    if (ret == ERR) {
        perror("tcsetattr fd");
        exit(0);
    }

    tcflush(fd, TCIOFLUSH); // 刷清緩沖區(qū)
}

// 設(shè)置數(shù)據(jù)位
int setup_data_bits(int setup_databits, struct termios *options_databits)
{
        if (options_databits == NULL) {
        perror("setup_data_bits error");
        return ERR;
    }

    switch (setup_databits) {
        case 5L:
            options_databits->c_cflag |= CS5;
            break;
        case 6L:
            options_databits->c_cflag |= CS6;
            break;
        case 7L:
            options_databits->c_cflag |= CS7;
            break;
        case 8L:
            options_databits->c_cflag |= CS8;
            break;
        default:
            return ERR;
    }
    return OK;
}

// 設(shè)置校驗位
int set_params_parity(int setup_parity, struct termios *options_parity)
{
    switch (setup_parity) {
        case 'n':
        case 'N':                               // 無奇偶校驗位
            options_parity->c_cflag &= ~PARENB; // Clear parity enable/
            options_parity->c_iflag &= ~INPCK;  // disable input parity checking/
            break;

        case 'o':
        case 'O':                                         // 設(shè)置為奇校驗
            options_parity->c_cflag |= (PARODD | PARENB); // odd parity checking
            options_parity->c_iflag |= INPCK;             // enable parity checking
            break;

        case 'e':
        case 'E':                               // 設(shè)置為偶校驗
            options_parity->c_cflag |= PARENB;  // Enable parity /
            options_parity->c_cflag &= ~PARODD; // even parity/
            options_parity->c_iflag |= INPCK;   // enable parity checking /
            break;

        case 'M':
        case 'm': // 標記奇偶校驗
            options_parity->c_cflag |= PARENB | CMSPAR | PARODD;
            options_parity->c_iflag |= INPCK; // enable parity checking /
            break;

        case 'S':
        case 's': // 設(shè)置為空格
            options_parity->c_cflag |= PARENB | CMSPAR;
            options_parity->c_cflag &= ~PARODD;
            options_parity->c_iflag |= INPCK; // enable parity checking /
            break;

        default:
            return ERR;
    }
    return OK;
}

// 設(shè)置校驗位
int set_params(int fd, int databits, int stopbits, int parity)
{
    struct termios options;
    int ret = ERR;

    if (tcgetattr(fd, &options) != 0) {
        perror("tcgetattr fail\n");
        return ERR;
    }

    options.c_iflag = 0;
    options.c_oflag = 0;

    // setup data bits
    options.c_cflag &= ~CSIZE;
    ret = setup_data_bits(databits, &options);
    if (ret == ERR) {
        return ERR;
    }

    // parity
    ret = set_params_parity(parity, &options);
    if (ret == ERR) {
        return ERR;
    }

    // stop bits/
    switch (stopbits) {
        case 1:
            options.c_cflag &= ~CSTOPB;
            break;
        case 2L:
            options.c_cflag |= CSTOPB;
            break;
        default:
            return ERR;
    }

    // 請求發(fā)送和清除發(fā)送
    options.c_cflag &= ~CRTSCTS;
    options.c_lflag = 0;
    options.c_cc[VTIME] = 10L;
    options.c_cc[VMIN] = 1;

    tcflush(fd, TCIFLUSH);
    if (tcsetattr(fd, TCSANOW, &options) != 0) {
        return ERR;
    }

    return OK;
}

// 設(shè)置波特率
int uart_init(int fd, int uartBaud)
{
    set_baud(fd, conver_baudrate(uartBaud));
    // uart param /
    if (set_params(fd, 8L, 1, 'n')) {
        perror("set uart parameters fail\n");
        return ERR;
    }
    return OK;
}

int data_proce(recv){
    if(recv=="hello_world"){
        send_data=1;
        return 1;
    }
    else{
        send_data =0;
        return 0;
    }
}

void *_serial_output_task(void){
    pthread_detach(pthread_self());
    int ret;
    ret=write(fd2,(unsigned char *) send_data,1);
    if(ret>0)
        printf("send success");
    else {
        printf("send error");
    }
    usleep(10000);
}
void *_serial_input_task(void)
{
    int i = 0;
    int ret = ERR;    // 函數(shù)返回值
    int buf = 0;    // 用于保存讀取到的字節(jié)
    int recv[FRAME_LEN] = {0};   // 用于保存接收到的數(shù)據(jù)

    while (1) {
        // 讀取一幀數(shù)據(jù)
        for (i = 0; i < FRAME_LEN; i++) {
            ret = read(fd1, &buf, 1);    // 讀取一個字節(jié)
            if (ret == ERR) {
                perror("read error\n");
                exit(0);
            }
            recv[i] = buf;    // 保存讀取到的字節(jié)
        }
        // 處理接收到的數(shù)據(jù)
        ret = data_proce(recv);
        if (ret == ERR) {
            perror("data process error\n");
            exit(0);
        }
    }
}

int main(int argc, char **argv)
{
    char *uart_dev ="ttyUSB1";   // 串口設(shè)備文件路徑
    char *uart_dev_t = "ttyUSB2";   // 串口設(shè)備文件路徑
    int ret1 = ERR;    // 函數(shù)返回值

    // 打開串口設(shè)備文件
    fd1 = open(uart_dev, O_RDWR);
    fd2= open(uart_dev_t,O_RDWR);
    if (fd2== ERR) {
        perror("open file fail\n");
        return ERR;
    }
    if (fd1 == ERR) {
        perror("open file fail\n");
        return ERR;
    }
    // 初始化串口
    ret1 = uart_init(fd1, 9600L);
    ret2 = uart_init(fd2,9600L);
    if (ret1 == ERR) {
        perror("uart init error\n");
        return ERR;
    }
    if (ret2 == ERR) {
        perror("uart_t init error\n");
        return ERR;
    }

    // 創(chuàng)建線程，一直執(zhí)行讀串口的操作
    pthread_t pid_t;
    pthread_create(&pid_t, NULL, (void *)_serial_input_task, 0);
    pthread_create(&pid_t, NULL, (void *)_serial_output_task, 0);
    while (1) {
        sleep(10L);   // 主線程等待
    }
    close(fd1);   // 關(guān)閉串口設(shè)備文件

    return 0;
}