RT-Thread串口设备驱动框架

最新推荐文章于 2024-08-16 10:47:26 发布
最新推荐文章于 2024-08-16 10:47:26 发布
阅读量2.2k 收藏 24
点赞数 4
分类专栏： rtthread操作系统 文章标签： 单片机 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a15236617777/article/details/127748742
版权

转自：嵌入式系统学习记录 - 知乎

目录

1. 串口设备控制块

2. 注册串口设备rt_hw_serial_register

3. 串口设备操作方法

3.1 rt_serial_init

3.2 rt_serial_control

3.3 rt_serial_open

3.4 rt_serial_close

3.5 rt_serial_read

3.6 rt_serial_write

串口驱动框架抽象了不同串口设备的共性，实现了IO设备管理层需要的设备操作方法。

1. 串口设备控制块

rtthread通过serial.c和serial.h两个文件进行串口设备的管理。通过serial.h中的结构体rt_serial_device进行串口设备的定义，串口设备继承自设备基类rt_device，rt_device继承自rt_object基类，继承关系如下

  串口设备通过结构体的定义实现了对rt_device设备基类的继承，结构体的私有成员据定了串口设备的相关操作。

/* components/drivers/include/drivers/serial.h */

struct rt_serial_device
{
    struct rt_device          parent;

    const struct rt_uart_ops *ops;
    struct serial_configure   config;

    void *serial_rx;
    void *serial_tx;
};
typedef struct rt_serial_device rt_serial_t;
  • parent：基类设备对象
  • ops：串口设备操作，需要驱动层实现
  • config：串口配置
  • serial_rx：记录接收软件FIFO首地址
  • serial_tx：记录发送软件FIFO首地址

2. 注册串口设备rt_hw_serial_register

设置设备操作方法，将设备注册到IO设备管理框架中

/* components/drivers/serial/serial.c */

/*
 * serial register
 */
rt_err_t rt_hw_serial_register(struct rt_serial_device *serial,
                               const char              *name,
                               rt_uint32_t              flag,
                               void                    *data)
{
    rt_err_t ret;
    struct rt_device *device;
    RT_ASSERT(serial != RT_NULL);

    device = &(serial->parent);

    device->type        = RT_Device_Class_Char;
    device->rx_indicate = RT_NULL;
    device->tx_complete = RT_NULL;

#ifdef RT_USING_DEVICE_OPS
    device->ops         = &serial_ops;
#else
    device->init        = rt_serial_init;
    device->open        = rt_serial_open;
    device->close       = rt_serial_close;
    device->read        = rt_serial_read;
    device->write       = rt_serial_write;
    device->control     = rt_serial_control;
#endif
    device->user_data   = data;

    /* register a character device */
    ret = rt_device_register(device, name, flag);

#if defined(RT_USING_POSIX)
    /* set fops */
    device->fops        = &_serial_fops;
#endif

    return ret;
}

完成的主要工作：

  • 设置设备类型为RT_Device_Class_Char，即字符设备
  • 设置设备操作方法，包括init、open、close、read、write、control
  • 设置用户数据
  • 将设备注册到设备管理框架

3. 串口设备操作方法

3.1 rt_serial_init

IO设备管理层对串口设备调用rt_device_init时，实际调用的就是这个函数

/* components/drivers/serial/serial.c */

/*
 * This function initializes serial device.
 */
static rt_err_t rt_serial_init(struct rt_device *dev)
{
    rt_err_t result = RT_EOK;
    struct rt_serial_device *serial;

    RT_ASSERT(dev != RT_NULL);
    serial = (struct rt_serial_device *)dev;

    /* initialize rx/tx */
    serial->serial_rx = RT_NULL;
    serial->serial_tx = RT_NULL;

    /* apply configuration */
    if (serial->ops->configure)
        result = serial->ops->configure(serial, &serial->config);

    return result;
}

完成的主要工作：

  • 初始化serial_rx和serial_tx为RT_NULL
  • 调用串口设备configure方法，configure方法需要驱动层实现

3.2 rt_serial_control

IO设备管理层对串口设备调用rt_device_control时，实际调用的就是这个函数

/* components/drivers/serial/serial.c */

static rt_err_t rt_serial_control(struct rt_device *dev,
                                  int              cmd,
                                  void             *args)
{
    rt_err_t ret = RT_EOK;
    struct rt_serial_device *serial;

    RT_ASSERT(dev != RT_NULL);
    serial = (struct rt_serial_device *)dev;

    switch (cmd)
    {
        case RT_DEVICE_CTRL_SUSPEND:
            /* suspend device */
            dev->flag |= RT_DEVICE_FLAG_SUSPENDED;
            break;

        case RT_DEVICE_CTRL_RESUME:
            /* resume device */
            dev->flag &= ~RT_DEVICE_FLAG_SUSPENDED;
            break;

        case RT_DEVICE_CTRL_CONFIG:
            if (args)
            {
                struct serial_configure *pconfig = (struct serial_configure *) args;
                if (pconfig->bufsz != serial->config.bufsz && serial->parent.ref_count)
                {
                    /*can not change buffer size*/
                    return RT_EBUSY;
                }
                /* set serial configure */
                serial->config = *pconfig;
                if (serial->parent.ref_count)
                {
                    /* serial device has been opened, to configure it */
                    serial->ops->configure(serial, (struct serial_configure *) args);
                }
            }

            break;

#ifdef RT_USING_POSIX_TERMIOS
        case TCGETA:
            {
                struct termios *tio = (struct termios*)args;
                if (tio == RT_NULL) return -RT_EINVAL;

                tio->c_iflag = 0;
                tio->c_oflag = 0;
                tio->c_lflag = 0;

                /* update oflag for console device */
                if (rt_console_get_device() == dev)
                    tio->c_oflag = OPOST | ONLCR;

                /* set cflag */
                tio->c_cflag = 0;
                if (serial->config.data_bits == DATA_BITS_5)
                    tio->c_cflag = CS5;
                else if (serial->config.data_bits == DATA_BITS_6)
                    tio->c_cflag = CS6;
                else if (serial->config.data_bits == DATA_BITS_7)
                    tio->c_cflag = CS7;
                else if (serial->config.data_bits == DATA_BITS_8)
                    tio->c_cflag = CS8;

                if (serial->config.stop_bits == STOP_BITS_2)
                    tio->c_cflag |= CSTOPB;

                if (serial->config.parity == PARITY_EVEN)
                    tio->c_cflag |= PARENB;
                else if (serial->config.parity == PARITY_ODD)
                    tio->c_cflag |= (PARODD | PARENB);

                cfsetospeed(tio, _get_speed(serial->config.baud_rate));
            }
            break;

        case TCSETAW:
        case TCSETAF:
        case TCSETA:
            {
                int baudrate;
                struct serial_configure config;

                struct termios *tio = (struct termios*)args;
                if (tio == RT_NULL) return -RT_EINVAL;

                config = serial->config;

                baudrate = _get_baudrate(cfgetospeed(tio));
                config.baud_rate = baudrate;

                switch (tio->c_cflag & CSIZE)
                {
                case CS5:
                    config.data_bits = DATA_BITS_5;
                    break;
                case CS6:
                    config.data_bits = DATA_BITS_6;
                    break;
                case CS7:
                    config.data_bits = DATA_BITS_7;
                    break;
                default:
                    config.data_bits = DATA_BITS_8;
                    break;
                }

                if (tio->c_cflag & CSTOPB) config.stop_bits = STOP_BITS_2;
                else config.stop_bits = STOP_BITS_1;

                if (tio->c_cflag & PARENB)
                {
                    if (tio->c_cflag & PARODD) config.parity = PARITY_ODD;
                    else config.parity = PARITY_EVEN;
                }
                else config.parity = PARITY_NONE;

                serial->ops->configure(serial, &config);
            }
            break;
        case TCFLSH:
            {
                int queue = (int)args;

                _tc_flush(serial, queue);
            }

            break;
        case TCXONC:
            break;
#endif
#ifdef RT_USING_POSIX
        case FIONREAD:
            {
                rt_size_t recved = 0;
                rt_base_t level;

                level = rt_hw_interrupt_disable();
                recved = _serial_fifo_calc_recved_len(serial);
                rt_hw_interrupt_enable(level);

                *(rt_size_t *)args = recved;
            }
            break;
#endif
        default :
            /* control device */
            ret = serial->ops->control(serial, cmd, args);
            break;
    }

    return ret;
}

完成的主要工作：

  • 根据不同的命令执行不同的处理，如果不是预定义的命令，则调用串口设备control方法，control需要驱动层实现

3.3 rt_serial_open

IO设备管理层对串口设备调用rt_device_open时，实际调用的就是这个函数。主要完成对serial_rx和serial_tx的初始化。

/* components/drivers/serial/serial.c */

static rt_err_t rt_serial_open(struct rt_device *dev, rt_uint16_t oflag)
{
    rt_uint16_t stream_flag = 0;
    struct rt_serial_device *serial;

    RT_ASSERT(dev != RT_NULL);
    serial = (struct rt_serial_device *)dev;

    LOG_D("open serial device: 0x%08x with open flag: 0x%04x",
        dev, oflag);
    /* check device flag with the open flag */
    if ((oflag & RT_DEVICE_FLAG_DMA_RX) && !(dev->flag & RT_DEVICE_FLAG_DMA_RX))
        return -RT_EIO;
    if ((oflag & RT_DEVICE_FLAG_DMA_TX) && !(dev->flag & RT_DEVICE_FLAG_DMA_TX))
        return -RT_EIO;
    if ((oflag & RT_DEVICE_FLAG_INT_RX) && !(dev->flag & RT_DEVICE_FLAG_INT_RX))
        return -RT_EIO;
    if ((oflag & RT_DEVICE_FLAG_INT_TX) && !(dev->flag & RT_DEVICE_FLAG_INT_TX))
        return -RT_EIO;

    /* keep steam flag */
    if ((oflag & RT_DEVICE_FLAG_STREAM) || (dev->open_flag & RT_DEVICE_FLAG_STREAM))
        stream_flag = RT_DEVICE_FLAG_STREAM;

    /* get open flags */
    dev->open_flag = oflag & 0xff;

    /* initialize the Rx/Tx structure according to open flag */
    if (serial->serial_rx == RT_NULL)
    { 
        if (oflag & RT_DEVICE_FLAG_INT_RX)
        {
            struct rt_serial_rx_fifo* rx_fifo;

            rx_fifo = (struct rt_serial_rx_fifo*) rt_malloc (sizeof(struct rt_serial_rx_fifo) +
                serial->config.bufsz);
            RT_ASSERT(rx_fifo != RT_NULL);
            rx_fifo->buffer = (rt_uint8_t*) (rx_fifo + 1);
            rt_memset(rx_fifo->buffer, 0, serial->config.bufsz);
            rx_fifo->put_index = 0;
            rx_fifo->get_index = 0;
            rx_fifo->is_full = RT_FALSE;

            serial->serial_rx = rx_fifo;
            dev->open_flag |= RT_DEVICE_FLAG_INT_RX;
            /* configure low level device */
            serial->ops->control(serial, RT_DEVICE_CTRL_SET_INT, (void *)RT_DEVICE_FLAG_INT_RX);
        }
#ifdef RT_SERIAL_USING_DMA        
        else if (oflag & RT_DEVICE_FLAG_DMA_RX)
        {
            if (serial->config.bufsz == 0) {
                struct rt_serial_rx_dma* rx_dma;

                rx_dma = (struct rt_serial_rx_dma*) rt_malloc (sizeof(struct rt_serial_rx_dma));
                RT_ASSERT(rx_dma != RT_NULL);
                rx_dma->activated = RT_FALSE;

                serial->serial_rx = rx_dma;
            } else {
                struct rt_serial_rx_fifo* rx_fifo;

                rx_fifo = (struct rt_serial_rx_fifo*) rt_malloc (sizeof(struct rt_serial_rx_fifo) +
                    serial->config.bufsz);
                RT_ASSERT(rx_fifo != RT_NULL);
                rx_fifo->buffer = (rt_uint8_t*) (rx_fifo + 1);
                rt_memset(rx_fifo->buffer, 0, serial->config.bufsz);
                rx_fifo->put_index = 0;
                rx_fifo->get_index = 0;
                rx_fifo->is_full = RT_FALSE;
                serial->serial_rx = rx_fifo;
                /* configure fifo address and length to low level device */
                serial->ops->control(serial, RT_DEVICE_CTRL_CONFIG, (void *) RT_DEVICE_FLAG_DMA_RX);
            }
            dev->open_flag |= RT_DEVICE_FLAG_DMA_RX;
        }
#endif /* RT_SERIAL_USING_DMA */
        else
        {
            serial->serial_rx = RT_NULL;
        }
    }
    else
    {
        if (oflag & RT_DEVICE_FLAG_INT_RX)
            dev->open_flag |= RT_DEVICE_FLAG_INT_RX;
#ifdef RT_SERIAL_USING_DMA
        else if (oflag & RT_DEVICE_FLAG_DMA_RX)
            dev->open_flag |= RT_DEVICE_FLAG_DMA_RX;
#endif /* RT_SERIAL_USING_DMA */  
    }

    if (serial->serial_tx == RT_NULL)
    {
        if (oflag & RT_DEVICE_FLAG_INT_TX)
        {
            struct rt_serial_tx_fifo *tx_fifo;

            tx_fifo = (struct rt_serial_tx_fifo*) rt_malloc(sizeof(struct rt_serial_tx_fifo));
            RT_ASSERT(tx_fifo != RT_NULL);

            rt_completion_init(&(tx_fifo->completion));
            serial->serial_tx = tx_fifo;

            dev->open_flag |= RT_DEVICE_FLAG_INT_TX;
            /* configure low level device */
            serial->ops->control(serial, RT_DEVICE_CTRL_SET_INT, (void *)RT_DEVICE_FLAG_INT_TX);
        }
#ifdef RT_SERIAL_USING_DMA
        else if (oflag & RT_DEVICE_FLAG_DMA_TX)
        {
            struct rt_serial_tx_dma* tx_dma;

            tx_dma = (struct rt_serial_tx_dma*) rt_malloc (sizeof(struct rt_serial_tx_dma));
            RT_ASSERT(tx_dma != RT_NULL);
            tx_dma->activated = RT_FALSE;

            rt_data_queue_init(&(tx_dma->data_queue), 8, 4, RT_NULL);
            serial->serial_tx = tx_dma;

            dev->open_flag |= RT_DEVICE_FLAG_DMA_TX;
            /* configure low level device */
            serial->ops->control(serial, RT_DEVICE_CTRL_CONFIG, (void *)RT_DEVICE_FLAG_DMA_TX);
        }
#endif /* RT_SERIAL_USING_DMA */
        else
        {
            serial->serial_tx = RT_NULL;
        }
    }
    else
    {
        if (oflag & RT_DEVICE_FLAG_INT_TX)
            dev->open_flag |= RT_DEVICE_FLAG_INT_TX;
#ifdef RT_SERIAL_USING_DMA
        else if (oflag & RT_DEVICE_FLAG_DMA_TX)
            dev->open_flag |= RT_DEVICE_FLAG_DMA_TX;
#endif /* RT_SERIAL_USING_DMA */    
    }

    /* set stream flag */
    dev->open_flag |= stream_flag;

    return RT_EOK;
}

完成的主要工作：

  • 如果serial_rx未设置
    • 如果要使用RT_DEVICE_FLAG_INT_RX中断接收，则从内存堆中分配接收软件FIFO，将FIFO首地址赋给serial_rx，设置设备RT_DEVICE_FLAG_INT_RX中断接收标志，调用串口设备control方法来处理RT_DEVICE_CTRL_SET_INT命令
    • 如果要使用RT_DEVICE_FLAG_DMA_RXDMA接收，则从内存堆中分配接收软件FIFO，将FIFO首地址赋给serial_rx，设置设备RT_DEVICE_FLAG_DMA_RXDMA接收标志，调用串口设备control方法来处理RT_DEVICE_CTRL_CONFIG命令
    • 否则serial_rx设为RT_NULL
  • 如果serial_rx已设置，则只设置设备的RT_DEVICE_FLAG_INT_RX中断接收标志或RT_DEVICE_FLAG_DMA_RXDMA接收标志
  • 对serial_tx重复上面类似的操作

3.4 rt_serial_close

完成与rt_serial_open相反的操作，主要是释放软件FIFO空间，清除设备中断收发或者DMA收发标志，将serial_rx和serial_tx置为RT_NULL，调用串口设备control方法

3.5 rt_serial_read

/* components/drivers/serial/serial.c */

static rt_size_t rt_serial_read(struct rt_device *dev,
                                rt_off_t          pos,
                                void             *buffer,
                                rt_size_t         size)
{
    struct rt_serial_device *serial;

    RT_ASSERT(dev != RT_NULL);
    if (size == 0) return 0;

    serial = (struct rt_serial_device *)dev;

    if (dev->open_flag & RT_DEVICE_FLAG_INT_RX)
    {
        return _serial_int_rx(serial, (rt_uint8_t *)buffer, size);
    }
#ifdef RT_SERIAL_USING_DMA
    else if (dev->open_flag & RT_DEVICE_FLAG_DMA_RX)
    {
        return _serial_dma_rx(serial, (rt_uint8_t *)buffer, size);
    }
#endif /* RT_SERIAL_USING_DMA */    

    return _serial_poll_rx(serial, (rt_uint8_t *)buffer, size);
}

完成的主要工作：　

  • 根据设备打开标志进行中断接收，或DMA接收，或轮询接收

3.6 rt_serial_write

/* components/drivers/serial/serial.c */

static rt_size_t rt_serial_write(struct rt_device *dev,
                                 rt_off_t          pos,
                                 const void       *buffer,
                                 rt_size_t         size)
{
    struct rt_serial_device *serial;

    RT_ASSERT(dev != RT_NULL);
    if (size == 0) return 0;

    serial = (struct rt_serial_device *)dev;

    if (dev->open_flag & RT_DEVICE_FLAG_INT_TX)
    {
        return _serial_int_tx(serial, (const rt_uint8_t *)buffer, size);
    }
#ifdef RT_SERIAL_USING_DMA    
    else if (dev->open_flag & RT_DEVICE_FLAG_DMA_TX)
    {
        return _serial_dma_tx(serial, (const rt_uint8_t *)buffer, size);
    }
#endif /* RT_SERIAL_USING_DMA */
    else
    {
        return _serial_poll_tx(serial, (const rt_uint8_t *)buffer, size);
    }
}

完成的主要工作：　

  • 根据设备打开标志进行中断发送，或DMA发送，或轮询发送
IOT-Power
关注
专栏目录
基于RT-Thread和GD32F4的串口驱动
03-05
1.符合RT-Thread设备驱动框架 2.使用GD32F470
I/O 设备模型-2
qq_37932504的博客
10-10 1040
旧版本接收缓冲区统一为 RT_SERIAL_RB_BUFSZ ，旧版本没有发送缓冲区的设置。
《RT-Thread设备驱动开发指南》—— 基础篇之UART设备驱动开发
weixin_46158019的博客
06-19 2177
RT-Thread设备驱动开发-第2章 UART设备驱动开发UART介绍UART（Universal Asynchronous Receiver/Transmitter，通用异步收发传输器）也常被称为串口。UART作为异步串口通信协议的一种，工作原理是将传输数据的每个字符一位接一位地传输。UART是在应用程序开发过程中使用频率最高的数据总线。在嵌入式设计中，UART常用于主机与辅助设备通信，如嵌...
【RT-Thread进阶】设备应用层与底层的映射以及串口DMA中断回调原理机制
最新发布
weixin_64284370的博客
08-16 942
剖析RT-Thread中设备应用层与底层的映射关联以及串口DMA中断回调原理机制
RT-Thread系列02——驱动框架及时钟修改
32Haozi
12-06 1751
RT-Thread 驱动框架介绍及时钟修改
由串口驱动分析rt-thread设备驱动框架
victor_zy的博客
12-29 2141
rt-thread中，线程、信号量、互斥锁、设备等等都是“**内核对象**”，`_object_container`是一个数组，包含所有的内核对象信息。 对象信息的定义 ```c struct rt_object_information { enum rt_object_class_type type; /**< object class type */ rt_list_t object_list;
第一章 rt-thread设备驱动模型
weixin_43249970的博客
08-17 2713
rt-thread提供了一套通用的设备驱动框架，是为了应用开发使用统一的接口来操作设备，从而降低应用程序和驱动程序的耦合性。这样的驱动框架带来的好处是，当底层设备驱动更换后，上层应用可以不进行修改。..................
rt-thread开源串口转以太网资料
06-24
1. **串口驱动**：首先，需要熟悉rt-thread的串口驱动框架，包括初始化、发送和接收数据等基本操作。开发者需要确保串口配置正确，能够稳定地收发数据。 2. **网络协议栈**：rt-thread内建了lwIP轻量级IP协议栈，...
NXP i.MX RT1052 RT-Thread实战：新建RT-Thread工程—软件仿真【基于Cortex-M4】
12-01
RT-Thread提供了丰富的设备驱动框架，允许开发者按照标准API编写驱动，便于移植和维护。例如，为NXP i.MX RT1052的串口驱动，需要实现rt_device_init、rt_device_open、rt_device_close等接口，以便RT-Thread能够...
RT-thread+GD32F450+uart+DMA.zip
04-07
在RT-thread中，UART驱动是其设备驱动层的重要组成部分，用于实现MCU与外部设备的串行通信。 对于UART+DMA的组合，其优势在于能够实现数据传输的并行化，减轻CPU负担。在常规的UART通信中，CPU需要不断轮询检查数据...
rt-thread-3.1.2.zip
07-01
3. **组件系统**：RT-Thread拥有丰富的软件组件，如TCP/IP网络栈、文件系统、USB主机/设备驱动、图形用户界面(GUI)、蓝牙等，这些组件可按需选择，增强了系统的功能性和灵活性。 4. **物联网中间件**：为了更好地...
RT-Thread设备驱动框架
sscb0521的博客
02-28 510
I/O设备是input/output设备，串口，定时器，adc,i2c,spi,flash，SD，USB等都是I/O设备。
RT-Thread传感器驱动框架详解（框架介绍+使用方法+源码理解）
weixin_41118203的博客
02-03 5327
RT-Thread传感器驱动框架使用详解1、整体框架2、使用步骤①ENV工具配置②Sensor框架初始化③创建线程3、源码追踪 由于传感器种类众多，RT-Thread官方设计了传感器框架，为上层提供统一的操作接口，提高上层代码的可重用性；简化底层驱动开发的难度，只要实现简单的 ops(operations: 操作命令) 就可以将传感器注册到系统上。 本博客中2、使用步骤处源码均出自RT-Thread官网开源项目：分布式温度监控系统 1、整体框架 Sensor 驱动框架为上层用户提供了标准 devic
RT-Thread设备和驱动总结
qq_41854911的博客
10-04 4277
已剪辑自: https://www.rt-thread.org/document/site/#/rt-thread-version/rt-thread-standard/programming-manual/device/device绝大部分的嵌入式系统都包括一些 I/O（Input/Output，输入 / 输出）设备，例如仪器上的数据显示屏、工业设备上的串口通信、数据采集设备上用于保存数据的 Flash 或 SD 卡，以及网络设备的以太网接口等，都是嵌入式系统中容易找到的 I/O 设备例子。本章主要介绍
RT Thread device组件(一)
denghuajing的博客
03-27 1302
device 组件的运作大致如上图所示。 RTT DEVICE API 1.是用户对设备进行访问的统一接口。 2.设备的访问通过handler索引 3.handler 的来源 是RTT 资源容器(或者称为IO设备管理) 4.所为注册就是向容器内（设备管理器）加入自己的索引。 IO设备管理器是移植RTT 设备层的关键。 以上整个流程IO设备管理层负责接收驱动层的注册，记录其handler。对RTT DEVICE API来说，需要向其提供目标设备的handler索引。 ...
RT-Thread控制台设备初始化
qq_34999565的博客
10-23 671
今天在研究RT-Thread日志模块ulog的时候发现最终log是通过控制台设备输出，控制台设备本质也是一个串口设备，于是就研究了一下串口设备。 我们先来看一下log输出： rt_device_t dev = rt_console_get_device(); rt_uint16_t old_flag = dev->open_flag; dev->open_flag |= RT_DEVICE_FLAG_STREAM; rt_device_write(dev, 0, log, len); dev
RTT串口V1版本的使用分析及问题排查指南（一）
rtthreadiotos的博客
07-20 1261
本文由RT-Thread论坛用户123原创发布：https://club.rt-thread.org/ask/article/2894.html RTT串口V1版本的使用分析及问题排查指南(一) 简述 无论是刚接触 RT-Thread 的新手，还是经验老道的大牛们，他们使用 RT-Thread 的时候，使用最频繁最广泛的外设，想必也非串口设备莫属。 回想大家在移植一个新的BSP或者芯片时，如何验证是否移植成功呢？是的，msh控制台窗口走一波 RTT 的 logo 信息，输出成功了就基本代表移植成功了。如下所
RT-Thread 学习笔记（六）——串口
skawu
11-14 8831
RTThread 串口学习，未完待续！
RT-Thread操作系统的I/O 设备模型框架接口示例与驱动分析
qq_42475039的博客
08-27 778
在RT-Thread实时操作系统环境下使用STM32F1XX的GPIO资源有两种方式——I/O 设备模型框架接口和调用硬件API。本文分别给出这两种方式的示例程序，并分析它们的实现机制、比较了它们的异同之处。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

IOT-Power

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值