文章详细介绍了如何使用STM32L431RCT6微控制器通过I2C协议与SHT20温湿度传感器进行通信。首先解释了I2C协议的基本原理，包括起始和停止信号、从设备地址及数据传输过程。然后，讨论了STM32L431RCT6的I2C引脚分配以及SHT20的传感器引脚配置。接着，提供了SHT20驱动代码的编写步骤，包括发送和接收数据的函数实现。最后，提到了使用GPIO模拟I2C通信的驱动代码。
一、先了解I2C协议
由时钟线SCL和数据线SDA构成的通信线路,利用上拉电阻将它们拉成高电平（表示总线空闲）
I2C总线可以有多个从设备，且每个从设备都有一个唯一的7bit地址物理识别，因为I2C地址全0为广播地址，所以I2C总线理论上最多能带2^7-1=127个从设备
（I2C：半双工通信的同步串行通信协议，采用电平信号，数据传输采用大端方式MSB，先发高位数据）
I2C总线通信时序：
I2C协议的起始信号（start）：当SCL保持高电平时，SDA出现一个下降沿，产生起始位
I2C协议的停止信号（stop）：当SCL保持高电平时，SDA出现一个上升沿，产生停止位
（停止通信后，总线空闲，处于高电平）
主设备向从设备发送从设备地址信号，在收到从设备的应答信号后通讯连接才建立成功
若未收到应答则表示寻址失败。
希望继续，则给出“应答（ACK）”信号，即SDA为低电平
不希望继续，则给出“非应答（NACK）”信号，即SDA为高电平
（建立通信后才开始传输数据位）
（读写方向位：RW，0为写操作，1为读操作）
主机发送数据流程：
1、主机在检测到总线为空闲时，发送一个启动信号"S"，开始一次通信的开始
2、主机接着发送一个从设备地址，它由7bit物理地址和1bit读写控制位R/W组成(此时RW=0)（发送的地址有7位的物理地址和1位的读写方向号）
3、相对应的从机收到命令字节后向主机回馈应答信号ACK(ACK=D)
4、主机收到从机的应答信号后开始发送第一个字节的数据；
5、从机收到数据后返回一个应答信号ACK；
6、主机收到应答信号后再发送下一个数据字节；
7、主机发完最后一个字节并收到ACK后，向从机发送一个停止信号P结束本次通信并释放总线；
8、从机收到p信号后也退出与主机之间的通信；
主机接收数据流程：
1、主机发送启动信号后，接着发送地址字节(其中R/W=1) :
2、对应的从机收到地址字节后，返回一个应答信号并向主机发送数据；
3、主机收到数据后向从机反馈一个应答信号ACK:
4、从机收到应答信号后再向主机发送下一个数据:
5、当主机完成接收数据后，向从机发送一个NAK，从机收到非应答信号后便停止发送；
6、主机发送非应答信号后，再发送一个停止信号，释放总线结束通信
stm32l431rct6的i2c引脚分配（本例我们使用引脚PB6和PB7为例）
二、了解sht20
stm32l431rct6的温湿度传感器引脚分配
三、开整
记得把串口使能了（这里我使用的是串口1），如下，其他的我相信你们都配好了（ctr+s就可以直接生成代码哦）
1、在 Core/Src 下创建并编写 SHT20 温湿度传感器的驱动源文件 sht20.c
sht20.c代码如下
#include<stdio.h>
#include "stm32l4xx_hal.h"
#include "sht20.h"
#include "tim.h"
/* 通过该宏控制是使用 HAL 库里的 I2C 接口还是使用 GPIO 模拟串口的接口*/
#define CONFIG_GPIO_I2C
#ifdef CONFIG_GPIO_I2C
#include "gpioi2c.h"
#else
#include "i2c.h"
#endif
/*采样*/
int SHT20_Sample_data(uint8_t cmd, float *data)
{
uint8_t buff[2];
float sht20_data=0.0;
int rv;
/*主设备向发送从设备地址信号，这里sht20的写地址是0x80,成功则返回1个字节*/
rv=I2C_Master_Transmit(0x80,&cmd,1);
if(0!=rv)
{
return -1;
}
if(cmd==0xf3)
{
HAL_Delay(85);
}
else if(cmd==0xf5)
{
HAL_Delay(29);
}
/*主设备向发送从设备地址信号，这里sht20的读地址是0x81,成功则返回2个字节，分别是温湿度的整数
*和小数，并且数据放在buff中*/
rv=I2C_Master_Receive(0x81,buff,2);
if(0!=rv)
{
return -1;
}
sht20_data=buff[0];
sht20_data=ldexp(sht20_data,8);
sht20_data+=buff[1]&0xFC;
if(cmd==0xf3) //0xf3为读温度的信号
{
*data=(-46.85+175.72*sht20_data/65536);//计算温度的公式
}
else if(cmd==0xf5) //0xf5为读湿度的信号
{
*data=(-6.0+125.0*sht20_data/65536);//计算湿度的公式
}
return *data;
}2、同理，在 Core/Inc 下创建并编写 SHT20 温湿度传感器的驱动头文件 sht20.h
sht20.h代码如下：
#ifndef INC_SHT20_H_
#define INC_SHT20_H_
#include "stm32l4xx_hal.h"
#define add_w 0x80 //地址写
#define add_r 0x81 //地址读
#define measure_temp 0xf3 //读取温度
#define measure_hum 0xf5 //读取湿度
#define user_code_w 0xe6
#define user_code_r 0xe7
#define RST_code 0xfe //复位
int SHT20_Sample_data(uint8_t cmd, float *data);
#endif /* INC_SHT20_H_ */
3、同理，在 Core/Src 下创建并编写 GPIO 模拟 I2C 驱动源文件 gpioi2c.c
gpioi2c.c代码如下：
#include <stdio.h>
#include "stm32l4xx_hal.h"
#include "tim.h" /* delay_us() implement */
#include "gpio.h"
#include "gpioi2c.h"
#define I2C_CLK_STRETCH_TIMEOUT 50
#define CONFIG_GPIO_I2C_DEBUG
#ifdef CONFIG_GPIO_I2C_DEBUG
#define i2c_print(format,args...) printf(format, ##args)
#else
#define i2c_print(format,args...) do{} while(0)
#endif
/* GPIO Simulate I2C Bus pins */
typedef struct i2c_gpio_s
{
GPIO_TypeDef *group;
uint16_t scl; /* SCL */
uint16_t sda; /* SDA */
} i2c_gpio_t;
static i2c_gpio_t i2c_pins = { GPIOB, GPIO_PIN_6/*SCL*/, GPIO_PIN_7/*SDA*/ };
#define SDA_IN() do{ GPIO_InitTypeDef GPIO_InitStruct = {0}; \
GPIO_InitStruct.Pin = i2c_pins.sda; \
GPIO_InitStruct.Mode = GPIO_MODE_INPUT; \
GPIO_InitStruct.Pull = GPIO_PULLUP; \
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; \
HAL_GPIO_Init(i2c_pins.group, &GPIO_InitStruct); \
}while(0)
#define SDA_OUT() do{ GPIO_InitTypeDef GPIO_InitStruct = {0}; \
GPIO_InitStruct.Pin = i2c_pins.sda; \
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; \
GPIO_InitStruct.Pull = GPIO_PULLUP; \
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; \
HAL_GPIO_Init(i2c_pins.group, &GPIO_InitStruct); \
}while(0)
#define SCL_OUT() do{ GPIO_InitTypeDef GPIO_InitStruct = {0}; \
GPIO_InitStruct.Pin = i2c_pins.scl; \
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; \
GPIO_InitStruct.Pull = GPIO_PULLUP; \
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; \
HAL_GPIO_Init(i2c_pins.group, &GPIO_InitStruct); \
}while(0)
#define SCL_H() HAL_GPIO_WritePin(i2c_pins.group, i2c_pins.scl, GPIO_PIN_SET)
#define SCL_L() HAL_GPIO_WritePin(i2c_pins.group, i2c_pins.scl, GPIO_PIN_RESET)
#define SDA_H() HAL_GPIO_WritePin(i2c_pins.group, i2c_pins.sda, GPIO_PIN_SET)
#define SDA_L() HAL_GPIO_WritePin(i2c_pins.group, i2c_pins.sda, GPIO_PIN_RESET)
#define READ_SDA() HAL_GPIO_ReadPin(i2c_pins.group, i2c_pins.sda)
#define READ_SCL() HAL_GPIO_ReadPin(i2c_pins.group, i2c_pins.scl)
static inline uint8_t I2c_WaitWhileClockStretching(uint16_t timeout)
{
while( timeout-- > 0 )
{
if( READ_SCL() )
break;
delay_us(1);
}
return timeout ? NO_ERROR : BUS_ERROR;
}
/* StartCondition(S) */
uint8_t I2c_StartCondition()
{
uint8_t rv = NO_ERROR;
SDA_OUT();
SCL_OUT();
/* StartCondition(S): A high to low transition on the SDA line while SCL is high.
_______
SCL: |___
_____
SDA: |_____
*/
SDA_H();
delay_us(1);
SCL_H();
delay_us(1);
#ifdef I2C_CLK_STRETCH_TIMEOUT
rv = I2c_WaitWhileClockStretching(I2C_CLK_STRETCH_TIMEOUT);
if( rv )
{
i2c_print("ERROR: %s() I2C bus busy\n", __func__);
return rv;
}
#endif
SDA_L();
delay_us(2);
SCL_L();
delay_us(2);
return rv;
}
/* StopCondition(P) */
uint8_t I2c_StopCondition(void)
{
uint8_t rv = NO_ERROR;
SDA_OUT();
/* StopCondition(P): A low to high transition on the SDA line while SCL is high.
_____
SCL: ___|
_____
SDA: ______|
*/
SCL_L();
SDA_L();
delay_us(2);
SCL_H();
delay_us(2);
#ifdef I2C_CLK_STRETCH_TIMEOUT
rv = I2c_WaitWhileClockStretching(I2C_CLK_STRETCH_TIMEOUT);
if( rv )
{
i2c_print("ERROR: %s() I2C bus busy\n", __func__);
}
#endif
SDA_H();
delay_us(2);
return rv;
}
uint8_t I2c_WriteByte(uint8_t byte)
{
uint8_t rv = NO_ERROR;
uint8_t mask;
/* Data line changes must happened when SCL is low */
SDA_OUT();
SCL_L();
/* 1Byte=8bit, MSB send: bit[7]-->bit[0] */
for(mask=0x80; mask>0; mask>>=1)
{
if((mask & byte) == 0)
{
SDA_L();
}
else
{
SDA_H();
}
delay_us(5); // data set-up time (t_SU;DAT)
SCL_H();
delay_us(5); // SCL high time (t_HIGH)
#ifdef I2C_CLK_STRETCH_TIMEOUT
rv = I2c_WaitWhileClockStretching(I2C_CLK_STRETCH_TIMEOUT);
if( rv )
{
i2c_print("ERROR: %s() I2C bus busy\n", __func__);
goto OUT;
}
#endif
SCL_L();
delay_us(5); // data hold time(t_HD;DAT)
}
/* clk #9 wait ACK/NAK from slave */
SDA_IN();
SCL_H(); // clk #9 for ack
delay_us(5); // data set-up time (t_SU;DAT)
#ifdef I2C_CLK_STRETCH_TIMEOUT
rv = I2c_WaitWhileClockStretching(I2C_CLK_STRETCH_TIMEOUT);
if( rv )
{
i2c_print("ERROR: %s() I2C bus busy\n", __func__);
goto OUT;
}
#endif
/* High level means NAK */
if( READ_SDA() )
rv = ACK_ERROR;
OUT:
SCL_L();
delay_us(20);
return rv;
}
uint8_t I2c_ReadByte(uint8_t *byte, uint8_t ack)
{
uint8_t rv = NO_ERROR;
uint8_t mask;
*byte = 0x00;
SDA_IN();
/* 1Byte=8bit, MSB send: bit[7]-->bit[0] */
for(mask = 0x80; mask > 0; mask >>= 1)
{
SCL_H(); // start clock on SCL-line
delay_us(1); // clock set-up time (t_SU;CLK)
#ifdef I2C_CLK_STRETCH_TIMEOUT
rv = I2c_WaitWhileClockStretching(I2C_CLK_STRETCH_TIMEOUT);
if( rv )
{
i2c_print("ERROR: %s() I2C bus busy\n", __func__);
goto OUT;
}
#endif
if(READ_SDA())
*byte |= mask; // read bit
SCL_L();
delay_us(2); // data hold time(t_HD;DAT)
}
/* clk #9 send ACK/NAK to slave */
if(ack == ACK)
{
SDA_OUT();
SDA_L(); // send Acknowledge if necessary
}
else if( ack == NAK )
{
SDA_OUT();
SDA_H(); // send NotAcknowledge if necessary
}
delay_us(1); // data set-up time (t_SU;DAT)
SCL_H(); // clk #9 for ack
delay_us(2); // SCL high time (t_HIGH)
#ifdef I2C_CLK_STRETCH_TIMEOUT
rv = I2c_WaitWhileClockStretching(I2C_CLK_STRETCH_TIMEOUT);
if( rv )
{
i2c_print("ERROR: %s() I2C bus busy\n", __func__);
}
#endif
OUT:
SCL_L();
delay_us(2); // wait to see byte package on scope
return rv;
}
uint8_t I2c_SendAddress(uint8_t addr)
{
return I2c_WriteByte(addr);
}
int I2C_Master_Receive(uint8_t addr, uint8_t *buf, int len)
{
int i;
int rv = NO_ERROR;
uint8_t byte;
I2c_StartCondition();
rv = I2c_SendAddress(addr);
if( rv )
{
i2c_print("Send I2C read address failure, rv=%d\n", rv);
goto OUT;
}
#ifdef I2C_CLK_STRETCH_TIMEOUT
/* wait while clock streching */
rv = I2c_WaitWhileClockStretching(I2C_CLK_STRETCH_TIMEOUT);
if( rv )
{
i2c_print("ERROR: %s() I2C wait clock stretching failure, rv=%d\n", __func__, rv);
return rv;
}
#endif
for (i=0; i<len; i++)
{
if( !I2c_ReadByte(&byte, ACK) )
{
buf[i] = byte;
}
else
goto OUT;
}
OUT:
I2c_StopCondition();
return rv;
}
int I2C_Master_Transmit(uint8_t addr, uint8_t *data, int bytes)
{
int i;
int rv = NO_ERROR;
if(!data)
{
return PARM_ERROR;
}
i2c_print("I2C Mastr start transimit [%d] bytes data to addr [0x%02x]\n", bytes, addr);
I2c_StartCondition();
rv = I2c_SendAddress(addr);
if( rv )
{
goto OUT;
}
for (i=0; i<bytes; i++)
{
if( NO_ERROR != (rv=I2c_WriteByte(data[i])) )
{
break;
}
}
OUT:
I2c_StopCondition();
return rv;
}4、同理，在 Core/Inc 下创建并编写 GPIO 模拟 I2C 头文件 gpioi2c.h
gpioi2c.h代码如下：
enum
{
NO_ERROR = 0x00, // no error
PARM_ERROR = 0x01, // parameter out of range error
ACK_ERROR = 0x02, // no acknowledgment error
CHECKSUM_ERROR = 0x04, // checksum mismatch error
TIMEOUT_ERROR = 0x08, // timeout error
BUS_ERROR = 0x10, // bus busy
};
enum
{
ACK_NONE, /* Without ACK/NAK Reply */
ACK, /* Reply with ACK */
NAK, /* Reply with NAK */
};
extern int I2C_Master_Receive(uint8_t addr, uint8_t *buf, int len);
extern int I2C_Master_Transmit(uint8_t addr, uint8_t *data, int bytes);5、修改main.c中的代码，找到下列相应位置，添加如图代码即可
编写好之后，点击运行代码
将程序烧录至开发板
串口调试助手连接板子，在板子上按复位键就可以看到打印信息了，如下：
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
