通用外设接口 - 串口设备和SPI总线设备

字数统计: 2.3k字   |   阅读时长≈ 9分

通用外设接口

rtthread对常用的片内外设做了抽象，为同一类外设提供了通用接口，对于不同的MCU片内外设都可以使用同一套外设接口进行访问。

串口驱动框架

serial.c serial.h

1
2
3
4
5
6
7
8
9
10
11
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;

举例说明下ops里面串口的配置方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
// control方法是可以说是多个方法的集合，它根据 cmd 的不同，可以执行不同的操作：比如：开中断、关中断、配置串口dma、配置dma中断等
// arg 可以传入一些配置参数进来，类似指定是配置dma的tx还是rx这样的
static rt_err_t stm32_control(struct rt_serial_device *serial, int cmd, void *arg)
{
    struct stm32_uart *uart;
#ifdef RT_SERIAL_USING_DMA
    rt_ubase_t ctrl_arg = (rt_ubase_t)arg;
#endif

    RT_ASSERT(serial != RT_NULL);
    uart = rt_container_of(serial, struct stm32_uart, serial);

    switch (cmd)
    {
    /* disable interrupt */
    case RT_DEVICE_CTRL_CLR_INT:
        /* disable rx irq */
        NVIC_DisableIRQ(uart->config->irq_type);
        /* disable interrupt */
        __HAL_UART_DISABLE_IT(&(uart->handle), UART_IT_RXNE);

#ifdef RT_SERIAL_USING_DMA
        /* disable DMA */
        if (ctrl_arg == RT_DEVICE_FLAG_DMA_RX)
        {
            HAL_NVIC_DisableIRQ(uart->config->dma_rx->dma_irq);
            if (HAL_DMA_Abort(&(uart->dma_rx.handle)) != HAL_OK)
            {
                RT_ASSERT(0);
            }

            if (HAL_DMA_DeInit(&(uart->dma_rx.handle)) != HAL_OK)
            {
                RT_ASSERT(0);
            }
        }
        else if(ctrl_arg == RT_DEVICE_FLAG_DMA_TX)
        {
            HAL_NVIC_DisableIRQ(uart->config->dma_tx->dma_irq);
            if (HAL_DMA_DeInit(&(uart->dma_tx.handle)) != HAL_OK)
            {
                RT_ASSERT(0);
            }
        }
#endif
        break;

    /* enable interrupt */
    case RT_DEVICE_CTRL_SET_INT:
        /* enable rx irq */
        HAL_NVIC_SetPriority(uart->config->irq_type, 1, 0);
        HAL_NVIC_EnableIRQ(uart->config->irq_type);
        /* enable interrupt */
        __HAL_UART_ENABLE_IT(&(uart->handle), UART_IT_RXNE);
        break;

#ifdef RT_SERIAL_USING_DMA
    case RT_DEVICE_CTRL_CONFIG:
        stm32_dma_config(serial, ctrl_arg);
        break;
#endif

    case RT_DEVICE_CTRL_CLOSE:
        if (HAL_UART_DeInit(&(uart->handle)) != HAL_OK )
        {
            RT_ASSERT(0)
        }
        break;

    }
    return RT_EOK;
}

串口设备使用步骤：

1.串口设备实例化一个串口驱动设备对象，并通过rt_hw_serial_register()接口注册到设备框架中。

2.串口设备驱动框架通过rt_device_register()接口将设备注册到IO设备管理中。

3.应用程序通过IO设备管理提供的接口访问串口设备硬件。

串口设备时序图：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@startuml
participant 应用程序 order 1
participant IO设备管理器 order 2
participant 串口设备驱动框架 order 3
participant 串口设备驱动 order 4
autonumber "<b>[0]"

串口设备驱动 -[#green]> 串口设备驱动: 创建串口设备
串口设备驱动 -[#blue]> 串口设备驱动框架: 注册串口设备 rt_hw_serial_register()
串口设备驱动框架 -[#blue]> IO设备管理器: 注册I/O设备 rt_device_register()

应用程序 -> IO设备管理器: 查找串口设备 rt_device_find()
应用程序 -> IO设备管理器: 打开串口设备 rt_device_open()
IO设备管理器 -> 串口设备驱动框架: rt_serial_open()
串口设备驱动框架 -> 串口设备驱动: 使能设备 control()
应用程序 -> IO设备管理器: 读串口数据 rt_device_read()
IO设备管理器 -> 串口设备驱动框架: rt_serial_read()
串口设备驱动框架 -> 串口设备驱动: 读取数据 getc()
应用程序 -> IO设备管理器: 关闭串口设备 rt_device_close()
IO设备管理器 -> 串口设备驱动框架: rt_serial_close()
串口设备驱动框架 -> 串口设备驱动: 关闭设备 control()
@enduml

时序图软件：plantuml

1.驱动注册到驱动框架：注册设备的操作方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 驱动注册到驱动框架
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;

    device->ops         = &serial_ops;
    device->user_data   = data;

    /* register a character device */
    ret = rt_device_register(device, name, flag);  // 需要把device设备挂载到内核对象链表，驱动层没有这个权限，所以需要交给IO设备管理层去做

    return ret;
}

2.驱动框架注册到IO设备管理器：驱动框架设备挂载到内核对象链表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 驱动框架设备注册到IO设备管理器
rt_err_t rt_device_register(rt_device_t dev,
                            const char *name,
                            rt_uint16_t flags)
{
    if (dev == RT_NULL)
        return -RT_ERROR;

    if (rt_device_find(name) != RT_NULL)
        return -RT_ERROR;

    rt_object_init(&(dev->parent), RT_Object_Class_Device, name);
    dev->flag = flags;
    dev->ref_count = 0;
    dev->open_flag = 0;

    return RT_EOK;
}

注册设备时的flags参数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define RT_DEVICE_FLAG_RDONLY           0x001           /**< read only */
#define RT_DEVICE_FLAG_WRONLY           0x002           /**< write only */
#define RT_DEVICE_FLAG_RDWR             0x003           /**< read and write */

#define RT_DEVICE_FLAG_REMOVABLE        0x004           /**< removable device */
#define RT_DEVICE_FLAG_STANDALONE       0x008           /**< standalone device */
#define RT_DEVICE_FLAG_ACTIVATED        0x010           /**< device is activated */
#define RT_DEVICE_FLAG_SUSPENDED        0x020           /**< device is suspended */
#define RT_DEVICE_FLAG_STREAM           0x040           /**< stream mode */

#define RT_DEVICE_FLAG_INT_RX           0x100           /**< INT mode on Rx */
#define RT_DEVICE_FLAG_DMA_RX           0x200           /**< DMA mode on Rx */
#define RT_DEVICE_FLAG_INT_TX           0x400           /**< INT mode on Tx */
#define RT_DEVICE_FLAG_DMA_TX           0x800           /**< DMA mode on Tx */

驱动层到io设备管理层对象空间占用是一层一层减小

串口回调：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// 在串口中断中回调
void rt_hw_serial_isr(struct rt_serial_device *serial, int event)
{
    switch (event & 0xff)
    {
        case RT_SERIAL_EVENT_RX_IND:
    .....
            /* invoke callback */
            if (serial->parent.rx_indicate != RT_NULL)
            {
                rt_size_t rx_length;

                /* get rx length */
                level = rt_hw_interrupt_disable();
                rx_length = (rx_fifo->put_index >= rx_fifo->get_index)? (rx_fifo->put_index - rx_fifo->get_index):
                    (serial->config.bufsz - (rx_fifo->get_index - rx_fifo->put_index));
                rt_hw_interrupt_enable(level);

                if (rx_length)
                {
                    serial->parent.rx_indicate(&serial->parent, rx_length); // 串口回调
                }
            }
            break;
        }
            ...
    }

SPI设备管理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// spi总线对象
struct rt_spi_bus
{
    struct rt_device parent;   /* 设备基类 */
    rt_uint8_t mode;
    const struct rt_spi_ops *ops;  /* SPI总线的操作方法 */

    struct rt_mutex lock;          /* 互斥锁，防止总线上的从设备访问冲突 */
    struct rt_spi_device *owner;  /* SPI总线的持有者SPI从设备指针 */
};

// spi从设备对象
struct rt_spi_device
{
    struct rt_device parent;  /* 设备基类 */ 
    struct rt_spi_bus *bus;   /* 指向挂载的SPI总线设备 */

    struct rt_spi_configuration config;  /* SPI从设备传输模式配置结构体 */
    void   *user_data;
};

/**
 * SPI从设备传输模式配置结构体
 */
struct rt_spi_configuration
{
    rt_uint8_t mode;
    rt_uint8_t data_width;
    rt_uint16_t reserved;

    rt_uint32_t max_hz;
};
  • SPI总线创建、SPI从设备挂载到总线时序图

SPI总线是一个虚拟的设备（对应MCU硬件上的SPI控制器），总线可以挂载多个从设备，靠CS引脚来区分，总线现在被哪个从设备占用。 struct rt_spi_bus总线对象里的owner用来记录当前总线被哪个从设备占用。struct rt_spi_device从设备对象里的bus用来记录当前从设备挂载在哪个总线上。

1.SPI总线设备创建，drv_spi.c 驱动层里面实例化一个SPI总线对象。

2.SPI总线设备注册到 SPI设备驱动框架层：spi_core.c、spi_device.c ，通过 rt_spi_bus_register() 接口。

3.SPI设备驱动框架对象注册到IO管理层：rt_device.c ，通过 rt_device_register() 接口。

SPI设备驱动框架层由两个文件组成：spi_core.c、spi_device.c

4.在SPI从机设备驱动创建一个SPI从设备：对应具体的SPI外设芯片，在设备的驱动程序实现：比如 ssd1306.c ，使用 rt_spi_bus_attach_device() 里面会实例化一个spi从设备对象，并把从设备对象挂载到指定的一个总线上。

由于 rt_spi_bus_attach_device() 只是创建了一个从设备对象，并把它挂载到一个总线，但并没有配置该从设备通信时主设备该设置成什么参数配置（每个从设备占用总线通信的时候可能需要的总线配置是不一样的，默认的配置是 0），这里需要接着调用 rt_spi_configure() 接口配置总线以适合该从设备和总线（主设备）通信：数据宽度、时钟速度、模式等配置。配置完这么参数后总线上的主设备从能和这个从设备通信。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int ssd1306_attach_to_spi_bus(void)
{
    struct rt_spi_device *spi1_dev_ssd1306;
    struct rt_spi_configuration cfg;
    
    /* ssd1306 硬件引脚配置 */
    rt_pin_mode(SSD1306_DC_PIN, PIN_MODE_OUTPUT);
    rt_pin_mode(SSD1306_RST_PIN, PIN_MODE_OUTPUT);
    rt_pin_write(SSD1306_DC_PIN, 1);
    rt_pin_write(SSD1306_RST_PIN, 1);
    
    /* 在 spi1 总线上挂载一个设备 */
    rt_hw_spi_device_attach("spi1", OLED_DEV_NAME, GPIOC, GPIO_PIN_1);
    
    /* 配置spi从设备 */
    cfg.data_width = 8;
    cfg.max_hz = 20 * 1000 * 1000;  // 20Mhz
    cfg.mode = RT_SPI_MASTER | RT_SPI_MODE_0 | RT_SPI_MSB;
    spi1_dev_ssd1306 = (struct rt_spi_device *)rt_device_find(OLED_DEV_NAME);
    spi1_dev_ssd1306->config = cfg;  // 由于创建从设备对象的时候并没有配置对象，这里设置好spi从设备通信是主设备的配置，第一次操作从设备的时候会自动调用rt_spi_configure() 配置主设备（总线）
//    rt_spi_configure(spi1_dev_ssd1306, &cfg); // 或者直接调用配置函数配置主设备（总线）
    return 0;
}

总线：主设备+虚拟总线的统称。

5.挂载从设备对象到SPI总线：ssd1306.c 和步骤 4 创建对象时合成在一起了，通过 rt_spi_bus_attach_device() 接口。

6.注册spi从设备对象到IO设备管理层：rt_device.c ，通过 rt_device_register() 接口。

7.通过从设备的设备句柄调用 rt_spi_transfer_message() 就可以对从设备收发数据。

8.spi_drv.c 驱动中在检测到该从机是首次收发数据的时候，会调用congfig() 先配置从机，接着在 通过 xfer() 收发本次的数据。

spi_drv.c 驱动中动过检测发送数据的总线对象里面的 owner 是否是本从设备，是代表总线之前就已经被该设备占用，之前肯定是配置过从设备了，不是就代表之前总线不是被该从设备占用需要配置该从设备。

小结：

1.rtthread中把MUC内部的SPI控制器虚拟成了一个虚拟总线。

2.总线在系统启动是就已经创建并注册到IO设备管理器。

3.当我们在应用程序中需要创建挂载一个从设备的时候，首先创建从设备并挂载到总线，还要设置好该从设备与总线通信时，总线的配置参数。

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

从事嵌入式开发