RT-Thread I2C总线设备学习笔记

前面我们学习了RTT的ADC设备的使用，文章链接：

I2C的基本原理之前在公众号就有相应的文章了，很早之前发的，接下来我们来学习RT-Thread I2C总线设备的使用！这是RTT官方设计的一个软件框架，学习一个新东西，还是一样，我个人主张带着需求去学习，而不是漫无目的的去学，有了需求驱动，并且是一个努力付出就可以拥有的成果，那么这还不容易嘛！

我们接下来将基于小熊派开发平台进行实践。

1、实践需求

1.1 硬件配置

LED、光强模块

1.2 软件需求

设备开机，当在串口终端输入bh1750_cmd on时，光强协议数据开始打印，底板LED灯闪烁，当光强值>100lux时，开启光强模块上的高亮LED灯，反之熄灭。关闭终端输入，开启上位机，能够看到当前实时的光强数据曲线展示。

当在串口终端输入bh1750_cmd off数据关闭打印，协议数据停止打印，底板+光强模块上的高亮LED灯熄灭。

这两个功能之前我们都有在Keil MDK上结合stm32cubeMX实现过

很多东西都已经有了，我们就不重复造相同的轮子了，直接白嫖过来用。本节，我们将会学习到RT-Thread I2C总线设备的基本使用。

接下来，我们将基于RT-Thread Studio来构建。

2、开始实践

上一节我们已经熟悉了怎么创建工程和配置项目了，这节我们直接略过这两步操作，直接看硬件图。

2.1 硬件原理图

参考上面文章给出的文章链接。

2.2 软件功能实现

根据官方给出的文档，这里在IDE上就可以点击打开，非常的方便快捷，另外RT-Thread会有代码实例，帮助我们初学者快速上手！I2C设备驱动使用起来非常简单，就两个接口，分别是:

• rt_device_find
• rt_i2c_transfer

接口1：rt_device_find 查找 I2C 总线设备

rt_device_t rt_device_find(const char* name);

参数	描述
name	I2C 总线设备名称
返回	——
设备句柄	查找到对应设备将返回相应的设备句柄
RT_NULL	没有找到相应的设备对象

这个name我们后面写的是"i2c1"，因为光强传感器在i2c1这个位置。

接口2：rt_i2c_transfer 数据传输

rt_size_t rt_i2c_transfer(struct rt_i2c_bus_device *bus,
                          struct rt_i2c_msg         msgs[],
                          rt_uint32_t               num);

参数	描述
bus	I2C 总线设备句柄
msgs[]	待传输的消息数组指针
num	消息数组的元素个数
返回	——
消息数组的元素个数	成功
错误码	失败

在这里，我们看到有两个结构体形参。

struct rt_i2c_bus_device

/*for i2c bus driver*/
struct rt_i2c_bus_device
{
    struct rt_device parent;                 /*继承了rt_device*/
    const struct rt_i2c_bus_device_ops *ops; /*I2C设备的操作方法*/
    rt_uint16_t  flags;                      /*I2C设备参数*/
    rt_uint16_t  addr;                       /*I2C设备地址*/
    struct rt_mutex lock;                    /*互斥量*/
    rt_uint32_t  timeout;                    /*I2C设备获取等待时间*/
    rt_uint32_t  retries;                    /*I2C设备获取次数*/
    void *priv;                              /*I2C设备的私有数据指针*/
};

struct rt_i2c_msg

struct rt_i2c_msg
{
    rt_uint16_t addr;  /* 从机地址(支持7位或10位) */
    rt_uint16_t flags; /* 读、写标志等 */
    rt_uint16_t len;   /* 读写数据字节数 */
    rt_uint8_t  *buf;  /* 读写数据缓冲区指针　*/
};
其中读、写标志flags取值范围如下：
#define RT_I2C_WR              0x0000        /* 写标志 */
#define RT_I2C_RD              (1u << 0)     /* 读标志 */
#define RT_I2C_ADDR_10BIT      (1u << 2)     /* 10 位地址模式 */
#define RT_I2C_NO_START        (1u << 4)     /* 无开始条件 */
#define RT_I2C_IGNORE_NACK     (1u << 5)     /* 忽视 NACK */
#define RT_I2C_NO_READ_ACK     (1u << 6)     /* 读的时候不发送 ACK */

从前面几篇文章可以知道，光强模块的从机地址是0x23，所以当我们要给光强模块写数据的时候，参数填充后调用rt_i2c_transfer发送

struct rt_i2c_msg msgs;
msgs.addr = 0x23;
msgs.flags = RT_I2C_WR;  //写标志
msgs.len = 1;
msgs.buf = (rt_uint8_t*) &cmd;
if (rt_i2c_transfer(i2c_bus, &msgs, 1) == 1)
    return RT_EOK;
else
    return -RT_ERROR;

当我们读取光强数据的时候，参数填充后调用rt_i2c_transfer

struct rt_i2c_msg msgs;
msgs.addr = BH1750_DEVICE_ADDR;
msgs.flags = 0x23;  //读标志
msgs.len = 2;       //光强模块返回的是2个字节的数据
msgs.buf = dat;     //要读的数据
if (rt_i2c_transfer(i2c_bus, &msgs, 2) == 2)
    return RT_EOK;
else
    return -RT_ERROR;

了解了基本使用方法以后，我们接下来就可以用了，直接看程序：

/*
 * Copyright (c) 2006-2019, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2019-09-09     RT-Thread    first version
 */

#include <rtthread.h>
#include <board.h>
#include <rtdevice.h>

#define DBG_TAG "main"
#define DBG_LVL DBG_LOG
#include <rtdbg.h>

typedef struct
{
    rt_uint32_t serial_number;
    rt_uint16_t light_lux_value;
    rt_uint8_t led_flag :1;
    rt_uint8_t plot_flag :1;
    rt_uint8_t cnt;
} Sensor_handlerDef;
Sensor_handlerDef light_sensor;

#define LED0_PIN    GET_PIN(B, 9)
#define LED1_PIN    GET_PIN(C, 13)

#define ONCE_H_MODE         0x20
#define BH1750_DEVICE_ADDR  0x23
#define BH1750_DRI_NAME     "i2c1"
static struct rt_i2c_bus_device *i2c_bus = RT_NULL;

rt_err_t BH1750_WR(rt_uint8_t cmd);
rt_err_t BH1750_RD(rt_uint8_t* dat);
rt_uint16_t BH1750_Dat_To_Lux(rt_uint8_t* dat);

int main(void)
{
    rt_uint8_t dat[2] = { 0 };
    char procol_buf[20] = { 0 };
    static rt_uint8_t status = 0;

    light_sensor.led_flag = 0;
    light_sensor.plot_flag = 0;
    light_sensor.serial_number = 0;
    light_sensor.light_lux_value = 0;

    rt_pin_mode(LED0_PIN, PIN_MODE_OUTPUT);
    rt_pin_mode(LED1_PIN, PIN_MODE_OUTPUT);

    /* 查找I2C总线设备，获取I2C总线设备句柄 */
    i2c_bus = (struct rt_i2c_bus_device*) rt_device_find(BH1750_DRI_NAME);
    if (RT_NULL == i2c_bus)
        return -RT_ERROR;

    while (1)
    {
        switch (status)
        {
        //发送指令给BH1750
        case 0:
            BH1750_WR(ONCE_H_MODE);
            light_sensor.cnt = 0;
            status = 1;
            break;
            //延时150ms
        case 1:
            light_sensor.cnt++;
            if (light_sensor.cnt > 150)
            {
                light_sensor.cnt = 0;
                if (light_sensor.led_flag)
                    rt_pin_write(LED1_PIN, 1);
                status = 2;
            }
            else
            {
                rt_thread_mdelay(1);
            }
            break;
            //开始读取光强
        case 2:
            if (light_sensor.plot_flag)
            {
                if (light_sensor.serial_number > 65535)
                    light_sensor.serial_number = 0;
                BH1750_RD(dat);
                light_sensor.light_lux_value = BH1750_Dat_To_Lux(dat);
                if (light_sensor.light_lux_value > 100)
                    rt_pin_write(LED0_PIN, 0);
                else
                    rt_pin_write(LED0_PIN, 1);
                rt_memset(procol_buf, 0, 20);
                rt_sprintf((char *) procol_buf, "%d%d%d%d%d %d%d%d%d%d", light_sensor.serial_number / 10000,
                        light_sensor.serial_number / 1000 % 100 % 10, light_sensor.serial_number / 100 % 10,
                        light_sensor.serial_number / 10 % 10, light_sensor.serial_number % 10,
                        light_sensor.light_lux_value / 10000, light_sensor.light_lux_value / 1000 % 100 % 10,
                        light_sensor.light_lux_value / 100 % 10, light_sensor.light_lux_value / 10 % 10,
                        light_sensor.light_lux_value % 10);
                rt_kprintf("%s \r\n", procol_buf);
                if (light_sensor.led_flag)
                    rt_pin_write(LED1_PIN, 0);
                light_sensor.serial_number++;
            }
            status = 0;
            break;
        default:
            break;
        }
    }
    return RT_EOK;
}

/*命令控制*/
static int bh1750_cmd(int argc, char *argv[])
{
    char *cmd_str[] = { "bh1750_cmd", "on", "off" };
    if (argc < 2 || argc > 2)
    {
        rt_kprintf("cmd input error!\n");
        return -1;
    }
    if (rt_strcmp(argv[0], cmd_str[0]) == 0)
    {
        if (rt_strcmp(argv[1], cmd_str[1]) == 0)
        {
            rt_kprintf("Open bh1750\n");
            light_sensor.plot_flag = 1;
            light_sensor.led_flag = 1;
            light_sensor.serial_number = 0 ;
        }
        else if (rt_strcmp(argv[1], cmd_str[2]) == 0)
        {
            rt_kprintf("Close bh1750\n");
            light_sensor.cnt = 0;
            light_sensor.led_flag = 0;
            light_sensor.plot_flag = 0;
            light_sensor.serial_number = 0 ;
            rt_pin_write(LED0_PIN, PIN_LOW);
            rt_pin_write(LED1_PIN, PIN_LOW);
        }
        else
        {
            rt_kprintf("cmd para input error!\n");
            return -3;
        }
    }
    else
    {
        rt_kprintf("cmd input error!\n");
        return -2;
    }
    return 0;
}
/* 导出到 msh 命令列表中 */
MSH_CMD_EXPORT(bh1750_cmd, bh1750 open or close);

/*BH1750写数据*/
rt_err_t BH1750_WR(rt_uint8_t cmd)
{
    struct rt_i2c_msg msgs;
    msgs.addr = BH1750_DEVICE_ADDR;
    msgs.flags = RT_I2C_WR;
    msgs.len = 1;
    msgs.buf = (rt_uint8_t*) &cmd;
    if (rt_i2c_transfer(i2c_bus, &msgs, 1) == 1)
        return RT_EOK;
    else
        return -RT_ERROR;
}

/*BH1750读数据*/
rt_err_t BH1750_RD(rt_uint8_t* dat)
{
    struct rt_i2c_msg msgs;
    msgs.addr = BH1750_DEVICE_ADDR;
    msgs.flags = RT_I2C_RD;
    msgs.len = 2;
    msgs.buf = dat;
    if (rt_i2c_transfer(i2c_bus, &msgs, 2) == 2)
        return RT_EOK;
    else
        return -RT_ERROR;
}

/**
 * @brief        将BH1750的两个字节数据转换为光照强度值（0-65535）
 * @param        dat  —— 存储光照强度的地址（两个字节数组）
 * @retval        成功 —— 返回光照强度值
 */
rt_uint16_t BH1750_Dat_To_Lux(rt_uint8_t* dat)
{
    rt_uint16_t lux = 0;
    lux = dat[0];
    lux <<= 8;
    lux += dat[1];
    lux = (int) (lux / 1.2);
    return lux;
}

编写程序完成以后，还没完呢！我们还要做一系列设置，才能把I2C用起来，在board.h中I2C部分，看到这么一段话：

/*-------------------------- I2C CONFIG BEGIN --------------------------*/

/** if you want to use i2c bus(soft simulate) you can use the following instructions.
  *
  * STEP 1, open i2c driver framework(soft simulate) support in the RT-Thread Settings file
  *
  * STEP 2, define macro related to the i2c bus
  *                 such as     #define BSP_USING_I2C1
  *
  * STEP 3, according to the corresponding pin of i2c port, modify the related i2c port and pin information
  *                 such as     #define BSP_I2C1_SCL_PIN    GET_PIN(port, pin)   ->   GET_PIN(C, 11)
  *                             #define BSP_I2C1_SDA_PIN    GET_PIN(port, pin)   ->   GET_PIN(C, 12)
  */

所以我们直接配置我们光强模块能读的管脚

#define BSP_USING_I2C1
#ifdef BSP_USING_I2C1
#define BSP_I2C1_SCL_PIN    GET_PIN(B, 6)
#define BSP_I2C1_SDA_PIN    GET_PIN(B, 7)
#endif

在RT-Thread Settings把软件模拟I2C的选项给勾选上！

下载测试

打开IDE自己内置的串口：

看看支持哪些指令：

可以看到，bh1750_cmd这个命令是我们添加进来的。

当在终端输入bh1750_cmd on时：

关掉自带的串口，打开上位机，可以看到光强的数据以曲线的形式进行显示

(这个小熊派的综合测试上位机最后会开源，尽请期待！)

当在终端输入bh1750_cmd off时：

公众号粉丝福利时刻

这里我给大家申请到了福利，本公众号读者购买小熊派开发板可享受9折优惠，有需要购买小熊派的朋友，淘宝搜索即可，跟客服说你是公众号：嵌入式云IOT技术圈 的粉丝，立享9折优惠！

往期精彩

若觉得本次分享的文章对您有帮助，随手点[在看]并转发分享，也是对我的支持。