芯耀
与非AI
85
# STM32应用开发——BH1750光照传感器详解
@[TOC](目录)
## 前言
几年前我发布了一篇关于STM32+BH1750光照传感器的博客，因为大学时期经验欠缺，无论是代码还是博客，都有很多不足之处，也收到了非常多同学的反馈。于是我重新整理了代码和文章，这是一个全新版本。
## 1 硬件介绍
### 1.1 BH1750简介
注：这个模块只适用于室内环境或者学习使用，户外场景下会超量程。
BH1750的引脚如下：
| 引脚号 | 名称 | 功能 |
|:---|:----|:--|
| 1 | VCC | 电源正 |
| 2 | ADDR | 地址端口 |
| 3 | GND | 电源负 |
| 4 | SDA | IIC数据线 |
| 5 | DVI | IIC端口参考电压 |
| 6 | SCL | IIC时钟线 |
参考外围电路如下：
### 1.2 硬件接线
| STM32 | BH1750 | 功能 |
|:--------|:-----|:--------|
| VCC | VCC | 电源正，3.3V供电 |
| GND | GND | 电源负 |
| PB6 | SCL | IIC时钟线，必须外接上拉电阻 |
| PB7 | SDA | IIC数据线，必须外接上拉电阻 |
| GND | ADDR | 地址端口 |
注：BH1750用的是模块，模块上已经有接上拉电阻了，因此STM32这边就不需要再接了。另外，ADDR引脚默认有一个下拉电阻，因此不接地其实也是没关系的。
BH1750模块的电路图如下：
## 2 软件编程
### 2.1 软件原理
BH1750是一个IIC设备，通讯协议遵循标准IIC协议。只需要着重关注设备地址，发送命令，读取寄存器即可。
#### 2.1.1 IIC设备地址
所有IIC设备都有一个专属的设备地址，BH1750也不例外，BH1750一共有2个设备地址，可以通过芯片的ADDR引脚切换。
数据手册原文如下：
翻译过来的话，设备地址的配置如下：
| ADDR引脚电平 | 7bit地址 | 8bit地址 |
|:------------|:------------|:------------|
| 高电平 | 0x5C | 0xB8 |
| 低电平 | 0x23 | 0x46 |
<font color=#ff33ff>注：这里解释一下7bit地址和8bit地址。
IIC设备的地址一般来说都只有7位，也就是7bit地址，BH1750数据手册上面写的也是7bit地址。
但是设备地址并不是单独使用的，在地址后面需要补1个读写位（不懂的先看下IIC通信协议），也就相当于把7bit的地址左移了1位，那么得到的值就是8bit地址。
所以，在IIC进行读写的时候，要用7bit地址还是8bit地址取决于你这个读写函数里面有没有对这个地址进行移位操作。</font>
#### 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种测量模式，每种模式有各自的特点，详见下表：
| 测量模式 | 精度 | 测量时间 | 备注 |
|:--------|:-----|:--------|:-----|
| 一次H分辨率模式 | 1 lx | 120ms | 该模式配置完成后会自动进行一次测量，测量完成后会切换到断电模式 |
| 一次H分辨率模式2 | 0.5 lx | 120ms | 该模式配置完成后会自动进行一次测量，测量完成后会切换到断电模式 |
| 一次L分辨率模式 | 4 lx | 16ms | 该模式配置完成后会自动进行一次测量，测量完成后会切换到断电模式 |
| 连续H分辨率模式 | 1 lx | 120ms | 该模式配置完成后会自动进行连续测量，无需重复配置 |
| 连续H分辨率模式2 | 0.5 lx | 120ms | 该模式配置完成后会自动进行连续测量，无需重复配置 |
| 连续L分辨率模式 | 4 lx | 16ms | 该模式配置完成后会自动进行连续测量，无需重复配置 |
总结：
L分辨率模式采集时间短，但精度差，适用于采集光照变化大且变化非常快的场景。
H分辨率模式采集时间长，但精度高，适用于光照变化速度不快的场景。
一次采集模式适用于采集间隔时间长或者需要省电的场景。
连续采集模式适用于对设备节能没有要求的大多数场景。
### 2.2 测试代码
根据上述原理，编写测试代码，主要的代码清单如下：
| 文件名 | 代码内容 |
|:------------|:------------|
| iic_software.h | 定义了软件IIC所需的引脚定义和电平设置，方便修改IO或者移植 |
| iic_software.c | 软件IIC代码主体 |
| iic_hardware.h | 定义了硬件IIC所需的引脚定义和电平设置，方便修改IO或者移植 |
| iic_hardware.c | 硬件IIC代码主体 |
| bh1750.h | 定义了BH1750的相关信息，如设备地址，命令等 |
| bh1750.c | BH1750驱动主体，底层调用软件IIC接口 |
| uart.c | 串口主体，用来打印测量过程和结果 |
| main.c | 主函数 |
<font color=#ff33ff>注：
1、除了串口的代码，其他代码全部都在下面贴出来了。串口的教程很多，这里就不细说了。
2、我这里采用软件IIC和硬件IIC两种方式测试，但实际上两种方式只能同时使用其中一种。
3、本文主要介绍如何驱动BH1750，尝试了几种测量模式，结果都由串口打印出来，不需要使用串口的话注释掉即可，如果需要现在在LCD屏或者OLED屏，请自行增加这部分的代码。</font>
**测试示例代码如下：**
<font color=#0033ff>iic_software.h :</font>
<font color=#AA88FF>注：打开宏`USE_SOFTWARE_IIC`，表示使用软件IIC。此时要注释掉`iic_hardware.h`的宏`USE_HARDWARE_IIC`。</font>
```c
#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
```
<font color=#0033ff>iic_software.c :</font>
```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
```
<font color=#0033ff>iic_hardware.h :</font>
<font color=#AA88FF>注：打开宏`USE_HARDWARE_IIC`，表示使用硬件IIC。此时要注释掉`iic_software.h`的宏`USE_SOFTWARE_IIC`。</font>
```c
#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
```
<font color=#0033ff>iic_hardware.c :</font>
```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
```
<font color=#0033ff>bh1750.h :</font>
```c
#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_RESET0x07// 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
```
<font color=#0033ff>bh1750.c :</font>
```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, ¤t_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, ¤t_light))
{
LOG("bh1750 continuous read light: %0.1f\n", current_light);
}
bh1750_delay(120); // 注：因为连续读取函数里面没有做延迟等待处理，因此这里的等待时间如果小于测量时间，那么读取到的值有可能是上一轮测量的值
#endif
}
```
<font color=#0033ff>main.c :</font>
```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();
}
}
```
### 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，实测很稳定。
<font color=#ff33ff>测试结果：IIC波形没有异常，串口结果没有异常，BH1750工作一切正常。</font>
### 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](https://pan.baidu.com/s/1aX2bYBAOgnkBlL2lzmGYjg)
提取码：1234
如果这篇文章能够帮到你，就.....你懂的。
阅读全文
