RT-Thread-【2024-RSOC】day 4RT-Thread 设备驱动RT-Thread问答社区

【2024-RSOC】day 4RT-Thread 设备驱动

发布于 2024-07-29 20:50:28 浏览：94 订阅该版

[tocm]

# Day 4 RT-Thread 设备驱动
![image-20240729200313077.png](https://oss-club.rt-thread.org/uploads/20240729/6a4c0329a6732b73fbe1b7d8c3972a91.png.webp)
## I/O设备管理层
RT-Thread 提供了一套简单的 I/O 设备模型框架，如下图所示，它位于硬件和应用程序之间，共分成三层，从上到下分别是 I/O 设备管理层、设备驱动框架层、设备驱动层。

[I/O设备模型 (rt-thread.org)](https://www.rt-thread.org/document/site/#/rt-thread-version/rt-thread-standard/programming-manual/device/device?id=io-设备模型-1)

## 实验一：注册字符设备

实验代码如下：

```c
#include<rttread.h>
#include<rtdevice.h>

static int rt_device_test_init(void)
{
    rt_device_t test_dev = rt_device_create(RT_Device_Class_Char,0);//字符设备是I/O设备的一种类型
    if(!test_dev)
    {
        rt_kprintf("rt_dev creat failed!\n");
        return -RT_ERROR;
    }
    if(et_device_register(rt_dev "rt_dev",RT_DEVICE_FLAG_RDWR)! = RT_EOK)// /**< read and write */
    {
        rt_kprintf("test_dev register failed!\n");
        return -RT_ERROR;
    }
    return RT_EOK;
}
MSH_CMD_EXPORT(rt_device_test_init,rt_device_test_init);
```

实验结果如下：

![image-20240729201403926.png](https://oss-club.rt-thread.org/uploads/20240729/0e1cbd902ef8c63c6ad491c1aef6bd66.png)
注：

1.设备驱动根据设备模型定义，创建出具备硬件访问能力的设备实例，将该设备通过 `rt_device_register()` 接口注册到 I/O 设备管理器中。

2.应用程序通过 `rt_device_find()` 接口查找到设备，然后使用 I/O 设备管理接口来访问硬件。

## 实验二：案件显示

menuconfig.exe配置如下：

![image-20240729202057004.png](https://oss-club.rt-thread.org/uploads/20240729/835d890f053e9af77b8e0956db90fb6c.png.webp)

代码如下：

```c
#include <board.h>
#include <rtthread.h>
#include <drv_gpio.h>
#include <ulog.h>
#ifndef RT_USING_NANO
#include <rtdevice.h>
#endif /* RT_USING_NANO */
#define GPIO_LED_B    GET_PIN(F, 11)
#define GPIO_LED_R    GET_PIN(F, 12)
#define KET_UP        GET_PIN(C, 5)
#define KET_DOWN      GET_PIN(C, 1)
#define KET_LIFT      GET_PIN(C, 0)
#define KET_RIGHT     GET_PIN(C, 4)
#define LOG_TAG        "pin.irq"
#define LOG_LVL        LOG_LVL_DBG
void key_up_callback(void *args)
{
    int value = rt_pin_read(KET_UP);
    LOG_I("key up! %d",value);
}
void key_down_callback(void *args)
{
    int value = rt_pin_read(KET_DOWN);
    LOG_I("key down! %d",value);
}
void key_lift_callback(void *args)
{
    int value = rt_pin_read(KET_LIFT);
    LOG_I("key lift! %d",value);
}
void key_right_callback(void *args)
{
    int value = rt_pin_read(KET_RIGHT);
    LOG_I("key right! %d",value);
}
static int rt_pin_irq_example(void)
{
    rt_pin_mode(KET_UP, PIN_MODE_INPUT_PULLUP);
    rt_pin_mode(KET_DOWN, PIN_MODE_INPUT_PULLUP);
    rt_pin_mode(KET_LIFT, PIN_MODE_INPUT_PULLUP);
    rt_pin_mode(KET_RIGHT, PIN_MODE_INPUT_PULLUP);
    rt_pin_attach_irq(KET_UP,PIN_IRQ_MODE_FALLING,key_up_callback,RT_NULL);
    rt_pin_attach_irq(KET_DOWN,PIN_IRQ_MODE_FALLING,key_down_callback,RT_NULL);
    rt_pin_attach_irq(KET_LIFT,PIN_IRQ_MODE_FALLING,key_lift_callback,RT_NULL);
    rt_pin_attach_irq(KET_RIGHT,PIN_IRQ_MODE_FALLING,key_right_callback,RT_NULL);
    rt_pin_irq_enable(KET_UP,PIN_IRQ_ENABLE);   
    rt_pin_irq_enable(KET_DOWN,PIN_IRQ_ENABLE);
    rt_pin_irq_enable(KET_LIFT,PIN_IRQ_ENABLE);
    rt_pin_irq_enable(KET_RIGHT,PIN_IRQ_ENABLE);
    return RT_EOK;
}
MSH_CMD_EXPORT(rt_pin_irq_example, rt pin irq examlpe);
```

运行结果如下：

![image-20240729202826409.png](https://oss-club.rt-thread.org/uploads/20240729/2d84e1d2794c163c1a7bb6c1613b2948.png.webp)
## 实验三： I2C读与写操作

```c
#include <rtthread.h>
#include <rtdevice.h>
#include <ulog.h>
#define LOG_TAG    "i2c.app"
#define LOG_LVL    LOG_LVL_DOG
void i2c_sample_single_byte_write(void)
{
    struct rt_i2c_bus_device *i2c_bus;
    struct rt_i2c_msg         msgs;
    rt_uint8_t                buf[2];
    i2c_bus = (struct rt_i2c_bus_device *)rt_device_find("i2c2");
    if (i2c_bus == RT_NULL)
    {
        LOG_E("can't find %s device!\n","i2c2");
    }
    buf[0] = 0x6B;
    msgs.addr = 0x68;
    msgs.flags = RT_I2C_WR;
    msgs.buf = buf;
    msgs.len = 1;
    if (rt_i2c_transfer(i2c_bus,&msgs,1) == 1)
        LOG_I("single byte write success!");
    else
        LOG_E("single byte write failed!");
}
MSH_CMD_EXPORT(i2c_sample_single_byte_write, i2c_sample_single_byte_write);
void i2c_sample_multi_byte_write(void)
{
    struct rt_i2c_bus_device *i2c_bus;
    struct rt_i2c_msg         msgs;
    rt_uint8_t                buf[3];
    i2c_bus = (struct rt_i2c_bus_device *)rt_device_find("i2c2");
    if (i2c_bus == RT_NULL)
    {
        LOG_E("can't find %s device!\n","i2c2");
    }
    buf[0] = 0x01;
    buf[1] = 0x02;
    buf[2] = 0x03;
    msgs.addr = 0x68;
    msgs.flags = RT_I2C_WR;
    msgs.buf = buf;
    msgs.len = 3;
    if (rt_i2c_transfer(i2c_bus,&msgs,1) == 1)
        LOG_I("multi byte write success!");
    else
        LOG_E("multi byte write failed!");
}
MSH_CMD_EXPORT(i2c_sample_multi_byte_write, i2c_sample_multi_byte_write);
void i2c_sample_single_byte_read(void)
{
    struct rt_i2c_bus_device *i2c_bus;
    struct rt_i2c_msg         msgs[2];
    rt_uint8_t                send_buf[1],recv_buf[1];
    rt_err_t ret = RT_EOK;
    i2c_bus = (struct rt_i2c_bus_device *)rt_device_find("i2c2");
    if (i2c_bus == RT_NULL)
    {
        LOG_E("can't find %s device!\n","i2c2");
    }
    send_buf[0] = 0x6B;
    recv_buf[1] = 0x6A;
    msgs[0].addr = 0x68;
    msgs[0].flags = RT_I2C_WR;
    msgs[0].buf = send_buf;
    msgs[0].len = 1;
    msgs[1].addr = 0x68;
    msgs[1].flags = RT_I2C_RD;
    msgs[1].buf = recv_buf;
    msgs[1].len = 1;
    ret = rt_i2c_transfer(i2c_bus,&msgs,2);
    if (ret == 2)
        LOG_I("single byte read success!");
    else
        LOG_E("single byte read failed! %d", ret);
}
MSH_CMD_EXPORT(i2c_sample_single_byte_read, i2c_sample_single_byte_read);
```