STM32应用开发——BH1750光照传感器详解_stm32驱动bh1750

STM32应用开发——BH1750光照传感器详解

前言

几年前我发布了一篇关于STM32+BH1750光照传感器的博客，因为大学时期经验欠缺，无论是代码还是博客，都有很多不足之处，也收到了非常多同学的反馈。于是我重新整理了代码和文章，这是一个全新版本。

1 硬件介绍

1.1 BH1750简介

BH1750FVI 是一种用于两线式串行总线接口的数字型光强度传感器集成电路。这种集成电路可以根据收集的光线强度数据来调整液晶或者键盘背景灯的亮度。利用它的高分辨率可以探测较大范围的光强度变化。

注：这个模块只适用于室内环境或者学习使用，户外场景下会超量程。

BH1750的引脚如下：

注：上述引脚指的是芯片的引脚，如果用的是某宝买的那种传感器模式，引出来的排针引脚排列是不同的。

参考外围电路如下：

1.2 硬件接线

本文使用STM32F103作为主控MCU，STM32和BH1750的引脚连接如下表：

注：BH1750用的是模块，模块上已经有接上拉电阻了，因此STM32这边就不需要再接了。另外，ADDR引脚默认有一个下拉电阻，因此不接地其实也是没关系的。

BH1750模块的电路图如下：

2 软件编程

2.1 软件原理

BH1750是一个IIC设备，通讯协议遵循标准IIC协议。只需要着重关注设备地址，发送命令，读取寄存器即可。

2.1.1 IIC设备地址

所有IIC设备都有一个专属的设备地址，BH1750也不例外，BH1750一共有2个设备地址，可以通过芯片的ADDR引脚切换。
数据手册原文如下：

翻译过来的话，设备地址的配置如下：

注：这里解释一下7bit地址和8bit地址。
IIC设备的地址一般来说都只有7位，也就是7bit地址，BH1750数据手册上面写的也是7bit地址。
但是设备地址并不是单独使用的，在地址后面需要补1个读写位（不懂的先看下IIC通信协议），也就相当于把7bit的地址左移了1位，那么得到的值就是8bit地址。
所以，在IIC进行读写的时候，要用7bit地址还是8bit地址取决于你这个读写函数里面有没有对这个地址进行移位操作。

2.1.2 IIC读写

1、IIC写入流程。

时序解释：先发送设备地址+读写位，再发送指令数据。

题外话：
大多数IIC设备，在发送的这串数据中，往往会把第1个字节的数据作为1个寄存器地址（有些也叫偏移），随后才是真正的数据。这样一来，就可以通过1个字节或多个字节的寄存器地址，来实现数据和命令的扩展。
不过BH1750可能是因为功能比较简单，它没有采用这种方式，读写似乎都在同一个寄存器里面操作。

2、IIC读取流程。

时序解释：先发送设备地址+读写位，随后读取两个数据（其中高位数据在前，低位数据在后）。

题外话：
这个读取的流程跟绝大多数IIC设备的读取流程是一样的。

2.1.3 BH1750指令集

在初始化BH1750时，通过发送1个字节的指令即可配置BH1750的模式。

详细指令集如下表：

2.1.4 BH1750工作流程

根据数据手册的描述，配置流程如下图：

总结一下这个流程：
第1步：给BH1750供电。
第2步：BH1750上电后默认为断电模式（此断电模式不是说芯片没有电，而是芯片没有进入工作模式）。
第3步：通过发送指令，把BH1750配置为通电模式（此时芯片进入工作模式）。
第4步：发送测量指令（测量方式有多种，详细信息看上面2.1.3的指令集）。
第5步：读取测量结果并转换成光照值。

按照上面这个流程走，就可以使BH1750正常工作。

2.1.5 BH1750测量模式

BH1750有6种测量模式，每种模式有各自的特点，详见下表：

总结：
L分辨率模式采集时间短，但精度差，适用于采集光照变化大且变化非常快的场景。
H分辨率模式采集时间长，但精度高，适用于光照变化速度不快的场景。
一次采集模式适用于采集间隔时间长或者需要省电的场景。
连续采集模式适用于对设备节能没有要求的大多数场景。

2.2 测试代码

根据上述原理，编写测试代码，主要的代码清单如下：

注：
1、除了串口的代码，其他代码全部都在下面贴出来了。串口的教程很多，这里就不细说了。
2、我这里采用软件IIC和硬件IIC两种方式测试，但实际上两种方式只能同时使用其中一种。
3、本文主要介绍如何驱动BH1750，尝试了几种测量模式，结果都由串口打印出来，不需要使用串口的话注释掉即可，如果需要现在在LCD屏或者OLED屏，请自行增加这部分的代码。

测试示例代码如下：

iic_software.h :
注：打开宏USE_SOFTWARE_IIC，表示使用软件IIC。此时要注释掉iic_hardware.h的宏USE_HARDWARE_IIC。

#ifndef __IIC_SOFTWARE_H__
#define __IIC_SOFTWARE_H__

#define USE_SOFTWARE_IIC   // 使用软件IIC（注：软件IIC和硬件IIC只能同时使用一种）

#ifdef USE_SOFTWARE_IIC
#include "stm32f10x.h"
#include "stm32f10x_gpio.h"

// IIC SCL引脚配置
#define IIC_SCL_CLOCK   RCC_APB2Periph_GPIOB     // 时钟
#define IIC_SCL_PORT    GPIOB                    // 端口
#define IIC_SCL_PIN     GPIO_Pin_6               // 引脚号
// IIC SCL电平设置
#define SET_IIC_SCL(s)  s > 0 ? GPIO_SetBits(IIC_SCL_PORT, IIC_SCL_PIN) : GPIO_ResetBits(IIC_SCL_PORT, IIC_SCL_PIN)

// IIC SDA引脚配置
#define IIC_SDA_CLOCK   RCC_APB2Periph_GPIOB     // 时钟
#define IIC_SDA_PORT    GPIOB                    // 端口
#define IIC_SDA_PIN     GPIO_Pin_7               // 引脚号
// IIC SDA电平设置
#define SET_IIC_SDA(s)  s > 0 ? GPIO_SetBits(IIC_SDA_PORT, IIC_SDA_PIN) : GPIO_ResetBits(IIC_SDA_PORT, IIC_SDA_PIN)  
#define READ_IIC_SDA    GPIO_ReadInputDataBit(IIC_SDA_PORT, IIC_SDA_PIN)

void iic_init(void);
uint8_t iic_write_bytes(uint8_t addr, uint8_t *buf, uint8_t buf_size);
uint8_t iic_receive_bytes(uint8_t addr, uint8_t *buf, uint8_t buf_size);
#endif
#endif
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

iic_software.c :

/**************************************************************************
 * 文件名  ：iic_software.c
 * 描述    ：软件模拟IIC程序  
****************************************************************************/
#include "iic_software.h"
#include "delay.h"
#include "stdio.h"

#ifdef USE_SOFTWARE_IIC  // 使用软件IIC（注：软件IIC和硬件IIC只能同时使用一种）
/* IIC软件模拟时序延时函数 */
void iic_delay(uint16_t us)
{
    delay_us(us);
}

/* IIC起始信号 */
void set_iic_sda_mode(uint8_t mode)
{
    GPIO_InitTypeDef GPIO_InitStruct;
    if(mode > 0)
    {// 设置为输出模式
        GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_OD; // 开漏或推挽，外部需要接上拉电阻
    }
    else
    {// 设置为输入模式
        GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IPU; // 浮空或上拉，外部需要接上拉电阻
    }
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStruct.GPIO_Pin = IIC_SDA_PIN;
    GPIO_Init(IIC_SDA_PORT, &GPIO_InitStruct);
}

/* IIC起始信号 */
void iic_start(void)
{
    SET_IIC_SDA(1);
    SET_IIC_SCL(1);
    iic_delay(5);
    SET_IIC_SDA(0);     
    SET_IIC_SCL(0);          
    iic_delay(5);  
}

/* IIC停止信号 */
void iic_stop(void)
{
    SET_IIC_SCL(0);
    SET_IIC_SDA(0);                
    iic_delay(5);                    
    SET_IIC_SCL(1);           
    SET_IIC_SDA(1);                  
    iic_delay(5);
}

/* IIC发送应答信号 */
uint8_t iic_send_ack(int ack)
{
    set_iic_sda_mode(1);
    if(ack == 1)
    {// 发送NACK
        SET_IIC_SDA(1); 
    }
    else if(ack == 0)
    {// 发送ACK
        SET_IIC_SDA(0); 
    }
    else
    {
        return 0;  // 入参有误，发送失败
    }         
    SET_IIC_SCL(1);     
    iic_delay(5);     
    SET_IIC_SCL(0);     
    iic_delay(5);    

    return 1;  // 发送成功
}

/* IIC接收应答信号 */
uint8_t iic_wait_ack(void)
{
    uint8_t ack = 0;
    uint8_t timeout = 5;

    SET_IIC_SDA(1); 
    set_iic_sda_mode(0);  // SDA输入模式
    SET_IIC_SCL(1);           
    iic_delay(5);  
    while(timeout--)       
    {// 等待从设备发送ACK
        if(READ_IIC_SDA == 0)
        {// 读到应答信号
            ack = 1;  
        }
        else
        {// 没有读到应答信号，继续等待
            iic_delay(1);
            if(timeout == 0)
            {// 等待超时
                ack = 0; 
            }
        }
    }           
    SET_IIC_SCL(0);             
    iic_delay(5);        
    set_iic_sda_mode(1); // SDA输出模式
    
    return ack;
}

/* IIC总线发送1个字节数据 */
uint8_t iic_send_byte(uint8_t dat)
{
    uint8_t i;
    for (i = 0; i < 8; i++)
    {
        if(0x80 & dat)
        {
            SET_IIC_SDA(1); 
        }
        else
        {
            SET_IIC_SDA(0); 
        }
        dat <<= 1;
        SET_IIC_SCL(1);          
        iic_delay(5);             
        SET_IIC_SCL(0); 
        iic_delay(5);
    }

    return iic_wait_ack();  // 返回从设备应答信号
}

/* IIC总线接收1个字节数据 */
uint8_t iic_receive_byte(void)
{
    uint8_t i;
    uint8_t dat = 0;
    uint8_t bit;

    set_iic_sda_mode(0);  // SDA输入模式
    for (i = 0; i < 8; i++)
    {
        dat <<= 1;
        SET_IIC_SCL(1);
        iic_delay(5);
        if(READ_IIC_SDA == 1)
        {
            bit = 0X01;
        }
        else
        {
            bit = 0x00;  
        }
        dat |= bit;        //读数据    
        SET_IIC_SCL(0);
        iic_delay(5);
    }        
    set_iic_sda_mode(1); // SDA输出模式

    return dat;
}

/* IIC发送多个数据 */
uint8_t iic_write_bytes(uint8_t addr, uint8_t *buf, uint8_t buf_size)
{
    uint8_t i;
    uint8_t result = 0;

    iic_start();                   // 起始信号
    if(iic_send_byte(addr << 1))   // 发送设备地址(7bit地址)
    {// 收到应答，发送成功
        for (i = 0; i < buf_size; i++)  // 发送数据
        {
            if(iic_send_byte(buf[i]))
            {// 收到应答，发送成功
                result = 1;
            }
            else
            {// 没有收到应答，发送失败
                result = 0; 
            }
        }
    }
    iic_stop();                   // 发送停止信号

    return result;
}

/* IIC接收多个数据 */
uint8_t iic_receive_bytes(uint8_t addr, uint8_t *buf, uint8_t buf_size)
{
    uint8_t i;    
    uint8_t result = 0;

    iic_start();                        // 起始信号
    if(iic_send_byte((addr << 1) | 1))  // 发送设备地址(7bit地址)
    {
        for (i = 0; i < buf_size; i++)    // 连续读取数据
        {
            *buf++ = iic_receive_byte(); 
            if (i == buf_size - 1)
            {
                iic_send_ack(1);   // 最后一个数据需要回NACK
            }
            else
            {        
                iic_send_ack(0);   // 发送ACK
            }
        }
        result = 1;
    }
    iic_stop();                // 停止信号

	return result;
}

/* IIC初始化 */
void iic_init(void)
{
    GPIO_InitTypeDef GPIO_InitStruct;

    RCC_APB2PeriphClockCmd(IIC_SCL_CLOCK, ENABLE); 
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;  
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStruct.GPIO_Pin = IIC_SCL_PIN;
    GPIO_Init(IIC_SCL_PORT, &GPIO_InitStruct); 

    RCC_APB2PeriphClockCmd(IIC_SDA_CLOCK, ENABLE); 
    GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;  
    GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStruct.GPIO_Pin = IIC_SDA_PIN;
    GPIO_Init(IIC_SDA_PORT, &GPIO_InitStruct); 
}
#endif
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236

iic_hardware.h :
注：打开宏USE_HARDWARE_IIC，表示使用硬件IIC。此时要注释掉iic_software.h的宏USE_SOFTWARE_IIC。

#ifndef __IIC_HARDWARE_H__
#define __IIC_HARDWARE_H__

// #define USE_HARDWARE_IIC   // 使用硬件IIC（注：软件IIC和硬件IIC只能同时使用一种）

#ifdef USE_HARDWARE_IIC
#include "stm32f10x.h"
#include "stm32f10x_gpio.h"
#include "stm32f10x_i2c.h"
#include "stm32f10x_dma.h"
#include "misc.h"

// IIC 端口配置
#define IIC_PORT              I2C1
#define IIC_PORT_CLOCK        RCC_APB1Periph_I2C1
#define I2C_SPEED             400000             // IIC速率
#define I2C_SLAVE_ADDRESS7    0xA0               // IIC本机地址（无用）
#define IIC_LONG_TIMEOUT      10 * 0x1000        // IIC通讯超时时间

// IIC SCL引脚配置
#define IIC_SCL_CLOCK    RCC_APB2Periph_GPIOB     // 时钟
#define IIC_SCL_PORT     GPIOB                    // 端口
#define IIC_SCL_PIN      GPIO_Pin_6               // 引脚号

// IIC SDA引脚配置
#define IIC_SDA_CLOCK    RCC_APB2Periph_GPIOB     // 时钟
#define IIC_SDA_PORT     GPIOB                    // 端口
#define IIC_SDA_PIN      GPIO_Pin_7               // 引脚号

// IIC DMA设置
#define I2C_DMA                      DMA1   
// #define I2C_DMA_FLAG_TX_TC           DMA1_IT_TC6   
// #define I2C_DMA_FLAG_TX_GL           DMA1_IT_GL6 
// #define I2C_DMA_CHANNEL_TX           DMA1_Channel6
// #define I2C_DMA_TX_IRQn              DMA1_Channel6_IRQn
#define I2C_DMA_FLAG_RX_TC           DMA1_IT_TC7 
#define I2C_DMA_FLAG_RX_GL           DMA1_IT_GL7    
#define I2C_DMA_CHANNEL_RX           DMA1_Channel7 
#define I2C_DMA_RX_IRQn              DMA1_Channel7_IRQn 
#define I2C_DMA_CLK                  RCC_AHBPeriph_DMA1
#define I2C_DR_Address               ((uint32_t)0x40005410)
#define I2C_DMA_PREPRIO              0     // DMA中断优先级
#define I2C_DMA_SUBPRIO              0   

void iic_init(void);
uint8_t iic_write_bytes(uint8_t addr, uint8_t *buf, uint8_t buf_size);
uint8_t iic_receive_bytes(uint8_t addr, uint8_t *buf, uint8_t buf_size);
#endif
#endif
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

iic_hardware.c :

/**************************************************************************
 * 文件名  ：iic_hardware.c
 * 描述    ：硬件IIC程序  
****************************************************************************/
#include "iic_hardware.h"
#include "delay.h"
#include "stdio.h"
#include "string.h"

#ifdef USE_HARDWARE_IIC  // 使用软件IIC（注：软件IIC和硬件IIC只能同时使用一种）

uint8_t dma_rx_buffer[2];
uint8_t dma_receive_flag = 0;

/* IIC发送多个数据 */
uint8_t iic_write_bytes(uint8_t addr, uint8_t *buf, uint8_t buf_size)
{ 
    uint32_t timeout;

    /*!< While the bus is busy */
    timeout = IIC_LONG_TIMEOUT;
    while(I2C_GetFlagStatus(IIC_PORT, I2C_FLAG_BUSY))
    {
        if((timeout--) == 0) 
            return 0;
    }
    
    /*!< Send START condition */
    I2C_GenerateSTART(IIC_PORT, ENABLE);
    /*!< Check EV5 and clear it */
    timeout = IIC_LONG_TIMEOUT;
    while(!I2C_CheckEvent(IIC_PORT, I2C_EVENT_MASTER_MODE_SELECT))
    {
        if((timeout--) == 0) 
            return 0;
    }
    
    /*!< Send address for write */
    I2C_Send7bitAddress(IIC_PORT, (addr<<1), I2C_Direction_Transmitter);
    /*!< Check EV6 and clear it */
    timeout = IIC_LONG_TIMEOUT;
    while(!I2C_CheckEvent(IIC_PORT, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
    {
        if((timeout--) == 0) 
            return 0;
    }
    
    /*!< Send N byte data */
    while(buf_size--)
    {
        I2C_SendData(IIC_PORT, *buf);

        /*!< Check EV8 and clear it */
        timeout = IIC_LONG_TIMEOUT; 
        while(!I2C_CheckEvent(IIC_PORT, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
        {
            if((timeout--) == 0) 
                return 0;
        } 
    }

    /*!< Send STOP condition */
    I2C_GenerateSTOP(I2C1, ENABLE);

    /* If all operations OK, return 1 */
    return 1;
}

/**
  * @brief  This function handles DMA1 Channel 7 interrupt request.
  * @param  None
  * @retval None
  */
void DMA1_Channel7_IRQHandler(void)
{
    if(DMA_GetITStatus(DMA1_IT_TC7))
    {
        DMA_ClearITPendingBit(DMA1_IT_GL7);
        I2C_AcknowledgeConfig(IIC_PORT, DISABLE);
        I2C_GenerateSTOP(IIC_PORT, ENABLE);
        dma_receive_flag = 1;  // 已收到数据
    }
}

/* IIC接收多个数据 */
uint8_t iic_receive_bytes(uint8_t addr, uint8_t *buf, uint8_t buf_size)
{
    uint32_t timeout;

    /*!< While the bus is busy */
    timeout = IIC_LONG_TIMEOUT;
    while(I2C_GetFlagStatus(IIC_PORT, I2C_FLAG_BUSY))
    {
        if((timeout--) == 0) 
            return 0;
    }

    /*!< Send START condition */
    I2C_GenerateSTART(IIC_PORT, ENABLE);
    /*!< Check EV5 and clear it */
    timeout = IIC_LONG_TIMEOUT;
    while(!I2C_CheckEvent(IIC_PORT, I2C_EVENT_MASTER_MODE_SELECT))
    {
        if((timeout--) == 0) 
            return 0;
    }
    
    /*!< Send address for read */
    I2C_Send7bitAddress(IIC_PORT, (addr<<1), I2C_Direction_Receiver);
    /*!< Test on EV6 and clear it */
    timeout = IIC_LONG_TIMEOUT;
    while(!I2C_CheckEvent(IIC_PORT, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
    {
        if((timeout--) == 0) 
            return 0;
    }  
    
    I2C_AcknowledgeConfig(IIC_PORT, ENABLE);
    
    /* Inform the DMA that the next End Of Transfer Signal will be the last one */
    I2C_DMALastTransferCmd(IIC_PORT, ENABLE); 

    /* Configure the DMA Rx Channel with the buffer address and the buffer size */
    DMA_Cmd(I2C_DMA_CHANNEL_RX, DISABLE); 
    DMA_SetCurrDataCounter(DMA1_Channel7, buf_size);
    DMA_Cmd(I2C_DMA_CHANNEL_RX, ENABLE); 

    /* 接收数据 */
    timeout = IIC_LONG_TIMEOUT;
    while(!dma_receive_flag)
    {// 等待数据接收完成
        if((timeout--) == 0) 
        {
            dma_receive_flag = 0;
            return 0;
        }
    }
    memcpy(buf, dma_rx_buffer, buf_size);

    /* If all operations OK, return 1 */
    return 1;
}

/* IIC初始化 */
void iic_init(void)
{
    GPIO_InitTypeDef  GPIO_InitStructure;
    NVIC_InitTypeDef NVIC_InitStructure;  
    DMA_InitTypeDef   DMA_InitStructure;   
    I2C_InitTypeDef  I2C_InitStructure; 

    /*!< I2C_SCL_GPIO_CLK and I2C_SDA_GPIO_CLK Periph clock enable */
    RCC_APB2PeriphClockCmd(IIC_SCL_CLOCK | IIC_SDA_CLOCK, ENABLE);

    /*!< I2C Periph clock enable */
    RCC_APB1PeriphClockCmd(IIC_PORT_CLOCK, ENABLE);
        
    /*!< GPIO configuration */  
    /*!< Configure I2C pins: SCL */
    GPIO_InitStructure.GPIO_Pin = IIC_SCL_PIN;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;
    GPIO_Init(IIC_SCL_PORT, &GPIO_InitStructure);

    /*!< Configure I2C pins: SDA */
    GPIO_InitStructure.GPIO_Pin = IIC_SDA_PIN;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;
    GPIO_Init(IIC_SDA_PORT, &GPIO_InitStructure); 

    /* Configure and enable I2C DMA RX Channel interrupt */
    NVIC_InitStructure.NVIC_IRQChannel = I2C_DMA_RX_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = I2C_DMA_PREPRIO;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = I2C_DMA_SUBPRIO;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);  
    
    /*!< I2C DMA RX channels configuration */
    /* Enable the DMA clock */
    RCC_AHBPeriphClockCmd(I2C_DMA_CLK, ENABLE);

    /* I2C RX DMA Channel configuration */
    DMA_DeInit(I2C_DMA_CHANNEL_RX);
    DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)I2C_DR_Address;
    DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)&dma_rx_buffer;
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC; 
    DMA_InitStructure.DMA_BufferSize = 2;         
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_MemoryDataSize_Byte;
    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
    DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
    DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
    DMA_Init(I2C_DMA_CHANNEL_RX, &DMA_InitStructure);  
    
    /* Enable the DMA Channels Interrupts */
    DMA_ITConfig(I2C_DMA_CHANNEL_RX, DMA_IT_TC, ENABLE);  

    /*!< I2C configuration */
    /* I2C configuration */
    I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
    I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
    I2C_InitStructure.I2C_OwnAddress1 = I2C_SLAVE_ADDRESS7;
    I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
    I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
    I2C_InitStructure.I2C_ClockSpeed = I2C_SPEED;
    
    /* Apply I2C configuration after enabling it */
    I2C_Init(IIC_PORT, &I2C_InitStructure);

    /* I2C Peripheral Enable */
    I2C_Cmd(IIC_PORT, ENABLE);

    /* Enable the I2C peripheral DMA requests */
    I2C_DMACmd(IIC_PORT, ENABLE);
}
#endif
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218

bh1750.h :

#ifndef __BH1750_H__
#define __BH1750_H__

#include "stm32f10x.h"

#define BH1750_ADDRESS_LOW      0x23    // addr low  7bit:0x23 8bit:0x46
#define BH1750_ADDRESS_HIGH     0x5C    // addr high 7bit:0x5C 8bit:0xB8

#define BH1750_ADDRESS          BH1750_ADDRESS_LOW  

/*bh1750 registers define */
#define BH1750_POWER_ON			0x01	// power on
#define BH1750_POWER_DOWN   	0x00	// power down
#define BH1750_RESET			0x07	// reset	
#define BH1750_CON_H_RES_MODE	0x10	// Continuously H-Resolution Mode
#define BH1750_CON_H_RES_MODE2	0x11	// Continuously H-Resolution Mode2 
#define BH1750_CON_L_RES_MODE	0x13	// Continuously L-Resolution Mode
#define BH1750_ONE_H_RES_MODE	0x20	// One Time H-Resolution Mode
#define BH1750_ONE_H_RES_MODE2	0x21	// One Time H-Resolution Mode2
#define BH1750_ONE_L_RES_MODE	0x23	// One Time L-Resolution Mode

uint8_t bh1750_init(void);
void bh1750_read_example(void);

#endif
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

bh1750.c :

/**************************************************************************
 * 文件名  ：bh1750.c
 * 描述    ：光强传感模块     
****************************************************************************/
#include "bh1750.h"
#include "delay.h"
#include "iic_hardware.h"
#include "iic_software.h"

#define LOG_ENABLE

#ifdef LOG_ENABLE
    #include "stdio.h"
    #define LOG   printf
#else
    #define LOG(format, ...)    
#endif

uint8_t current_mode;    // BH1750的测量模式
float current_light;     // BH1750的测量光照值

// BH1750延时函数
void bh1750_delay(uint16_t ms)
{// ms级延时，BH1750每次测量都需要时间，该函数用于等待测量结果
    delay_ms(ms);
}

// 写命令
uint8_t bh1750_write_cmd(uint8_t cmd)
{
    return iic_write_bytes(BH1750_ADDRESS, &cmd, 1);
}

// 写寄存器
uint8_t bh1750_read_regs(uint8_t *buf, uint8_t buf_size)
{
    return iic_receive_bytes(BH1750_ADDRESS, buf, buf_size);
}

// 复位
uint8_t bh1750_reset(void)
{
    return bh1750_write_cmd(BH1750_RESET);
}
// 打开电源
uint8_t bh1750_power_on(void)
{
    return bh1750_write_cmd(BH1750_POWER_ON);
}

// 关闭电源
uint8_t bh1750_power_down(void)
{
    return bh1750_write_cmd(BH1750_POWER_DOWN);
}

// 设置测量模式
uint8_t bh1750_set_measure_mode(uint8_t mode)
{
    uint8_t result = 0;

    if(bh1750_write_cmd(mode))
    {
        result =  1;
    }
    return result;
}

// 单次读取光照值
uint8_t bh1750_single_read_light(uint8_t mode, float *light)
{// 单次测量模式在测量后会自动设置为断电模式   
    uint8_t temp[2];
    uint8_t result = 0;
    
    if(mode != BH1750_ONE_H_RES_MODE && mode != BH1750_ONE_H_RES_MODE2 && mode != BH1750_ONE_L_RES_MODE)
    {
        LOG("bh1750 single read measure mode error! mode:0x%02x\n", mode);
        return result;
    }
    if(bh1750_set_measure_mode(mode)) // 每次采集前先设置模式
    {
        LOG("bh1750 set measure mode success! mode:0x%02x\n", mode);
        current_mode = mode;
        switch (mode)
        {
        case BH1750_ONE_H_RES_MODE:  // 单次H分辨率模式（精度1lx，测量时间120ms）
            bh1750_delay(120);  // 等待采集完成
            break;
        case BH1750_ONE_H_RES_MODE2: // 单次H分辨率模式（精度0.5lx，测量时间120ms）
            bh1750_delay(120);  // 等待采集完成
            break;
        case BH1750_ONE_L_RES_MODE:  // 单次L分辨率模式（精度4lx，测量时间16ms）
            bh1750_delay(16);  // 等待采集完成
            break;
        default:
            break;
        }
        if(bh1750_read_regs(temp, 2))  // 读取测量结果
        {
            *light = ((float)((temp[0] << 8) + temp[1]) / 1.2); // 换算成光照值
            result = 1;
        }
        else
        {
            LOG("bh1750 read light failed!");
        }
    }
    else
    {
        LOG("bh1750 set measure mode failed! mode:0x%02x\n", mode);
        return result;
    }
    
    return result;
}

// 连续读取光照值
uint8_t bh1750_continuous_read_light(uint8_t mode, float *light)
{   
    uint8_t temp[2];
    uint8_t result = 0;
    
    if(mode != BH1750_CON_H_RES_MODE && mode != BH1750_CON_H_RES_MODE2 && mode != BH1750_CON_L_RES_MODE)
    {
        LOG("bh1750 continuous read measure mode error! mode:0x%02x\n", mode);
        return result;
    }

    if(mode != current_mode)
    {// 要使用的测量模式和BH1750当前的模式不同，则配置成相同模式
        if(bh1750_set_measure_mode(mode))
        {
            LOG("bh1750 set measure mode success! mode:0x%02x\n", mode);
            current_mode = mode;
        }
        else
        {// 模式设置失败
            LOG("bh1750 set measure mode failed! mode:0x%02x\n", mode);
            return result;
        }
        switch (mode)
        {
        case BH1750_CON_H_RES_MODE:  // 连续H分辨率模式（精度1lx，测量时间120ms）
            bh1750_delay(120);  // 等待采集完成
            break;
        case BH1750_CON_H_RES_MODE2: // 连续H分辨率模式（精度0.5lx，测量时间120ms）
            bh1750_delay(120);  // 等待采集完成
            break;
        case BH1750_CON_L_RES_MODE:  // 连续L分辨率模式（精度4lx，测量时间16ms）
            bh1750_delay(16);  // 等待采集完成
            break;
        default:
            break;
        }
    }
    if(bh1750_read_regs(temp, 2))  // 读取测量结果
    {
        *light = ((float)((temp[0] << 8) + temp[1]) / 1.2); // 换算成光照值
        result = 1;
    }
    else
    {
        LOG("bh1750 read light failed!");
    }
    
    return result;
}

// BH1750初始化
uint8_t bh1750_init(void)
{
    uint8_t result = 0;
    iic_init();        // IIC初始化
    result = bh1750_power_on(); // 打开BH1750电源
    current_mode = 0;
    return result;
}

// BH1750读取例程
void bh1750_read_example(void)
{
#if 1
    // 单次采集模式
    if(bh1750_single_read_light(BH1750_ONE_H_RES_MODE2, &current_light))
    {
        LOG("bh1750 single read light: %0.1f\n", current_light);
    }
    bh1750_delay(100);
#else
    // 连续采集模式
    if(bh1750_continuous_read_light(BH1750_CON_H_RES_MODE2, &current_light))
    {
        LOG("bh1750 continuous read light: %0.1f\n", current_light);
    }
    bh1750_delay(120); // 注：因为连续读取函数里面没有做延迟等待处理，因此这里的等待时间如果小于测量时间，那么读取到的值有可能是上一轮测量的值
#endif
}
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197

main.c :

#include "delay.h"
#include "sys.h"
#include "usart.h"
#include "bh1750.h"

int main(void)
{ 
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    delay_init();              
    uart_init(115200);      
    bh1750_init();
    while(1)
    {
        bh1750_read_example();
    }        
}    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.3 运行测试

通过逻辑分析仪抓取IIC通讯的波形，分别测试了一次H分辨率模式2和连续H分辨率模式2，结果如下：

1、一次H分辨率模式2时序测量
初始化设备：
先发送通电命令（0x01），再设置为单次 H 分辨率模式 2（0x21）。

读取光照值（设备地址为0x23）：

串口打印结果：

2、连续H分辨率模式2时序测量
初始化设备：
先发送通电命令（0x01），再设置为连续 H 分辨率模式 2（0x11）。

读取光照值（设备地址为0x23）：

串口打印结果：

3、其他测量
1、测量软件IIC时钟周期：
软件模拟IIC的速率约75kHz。
查看数据手册，BH7150对CLK时钟要求是小于等于400kHz，而IIC设备常用的速率是100k，200k和400k，速率慢点会更稳定，但通信时间会加长，因此最好根据实际情况调整。需要调快的话可以通过减少上面模拟IIC收发函数的CLK延时时间来实现。

2、测量硬件IIC时钟周期：
硬件IIC速率设置的是400kHz，实测很稳定。

测试结果：IIC波形没有异常，串口结果没有异常，BH1750工作一切正常。

2.4 常见问题

从我发布第一篇关于BH1750的文章以来，收到了非常多的私信和评论，也收集了不少问题，总结下来基本上都是IIC通信问题。

就拿我上面的测试用例来说，如果出现以下log，就说明STM32和BH1750的通信是失败的。（举个例子，不接入BH1750，让MCU自己跑，就会出现以下log，因为此时STM32就是访问不到从设备，正确连接设备以后，这个log就不会出现了）

排查方向：
1、检查STM32和BH1750各自的电源，接线是否正确，供电电压是否正常，可以借助万用表测量。
2、检查STM32使用的IIC的引脚和BH1750的IIC引脚是否一致且正确连接。
3、检查IIC总线上面是否有外部上拉电阻，阻值是否合理（一般2-10kΩ），如果用的是模块的话，可以看下模块的原理图，确认一下是否有上拉电阻。
4、检查BH1750的设备地址和代码配置的是否一致。
5、检查MCU和BH1750之间的接线是否正确且导通（之前有遇到过杜邦线内部断开的情况），可以借助万用表测量。
6、确认MCU和BH1750是否有损坏（之前有同学说BH1750模块被焊坏了）。
7、建议先用本文的测试用例跑一遍，因为这个代码经过测试，至少能保证软件的正确性，以此来排查硬件问题。有些同学是在我这移植了部分代码，或者在这基础上增加了其他代码，导致出现了bug。
8、如果以上方法都没用，就需要借助万用表或者逻辑分析仪，实际去抓取一下IIC通信的波形，首先要确认的是STM32是否发送了设备地址，BH1750是否有应答，如果没有，要么接线异常，要么地址不对，要么就是传感器坏了，大概率都是这些问题。

总结：在软件经过测试并保证正常运行的情况下，如果出现IIC通信异常问题（如上述log），归根结底还是硬件问题。

结束语

关于STM32如何驱动BH1750的讲解就到这里，如果还有什么问题，欢迎在评论区留言。

源码下载：
链接：https://pan.baidu.com/s/1aX2bYBAOgnkBlL2lzmGYjg
提取码：1234

如果这篇文章能够帮到你，就…你懂的。