本文介绍了一种基于AHT20温度传感器的I2C总线通信实现方法，详细展示了STM32微控制器与AHT20通过I2C协议交互的具体过程，包括初始化、数据读取等关键步骤。
基于AHT20的温度传感器
1.I2C总线协议
I2C总线协议：
I2C协议规定，总线上数据的传输必须以一个起始信号作为开始条件，以一个结束信号作为传输的停止条件。起始和结束信号总是由主设备产生(意味着从设备不可以主动通信？所有的通信都是主设备发起的，主可以发出询问的command，然后等待从设备的通信)。
起始和结束信号产生条件：总线在空闲状态时，SCL和SDA都保持着高电平，当SCL为高电平而SDA由高到低的跳变，表示产生一个起始条件；当SCL为高而SDA由低到高的跳变，表示产生一个停止条件。在起始条件产生后，总线处于忙状态，由本次数据传输的主从设备独占，其他I2C器件无法访问总线；而在停止条件产生后，本次数据传输的主从设备将释放总线，总线再次处于空闲状态。起始和结束如图所示：
在了解起始条件和停止条件后，我们再来看看在这个过程中数据的传输是如何进行的。前面我们已经提到过，数据传输以字节为单位。主设备在SCL线上产生每个时钟脉冲的过程中将在SDA线上传输一个数据位，当一个字节按数据位从高位到低位的顺序传输完后，紧接着从设备将拉低SDA线，回传给主设备一个应答位， 此时才认为一个字节真正的被传输完成。当然，并不是所有的字节传输都必须有一个应答位，比如：当从设备不能再接收主设备发送的数据时，从设备将回传一个否 定应答位。数据传输的过程如图所示：
在前面我们还提到过，I2C总线上的每一个设备都对应一个唯一的地址，主从设备之间的数据传输是建立在地址的基础上，也就是说，主设备在传输有效数据之前要先指定从设备的地址，地址指定的过程和上面数据传输的过程一样，只不过大多数从设备的地址是7位的，然后协议规定再给地址添加一个最低位用来表示接下来数据传输的方向，0表示主设备向从设备写数据，1表示主设备向从设备读数据。向指定设备发送数据的格式如图所示：(每一最小包数据由9bit组成，8bit内容+1bit ACK, 如果是地址数据，则8bit包含1bit方向)
2.基于AHT20的温度传感器。
main.c
#include "stm32f10x.h"
#include "stm32f10x_usart.h"
#include "misc.h"
#include "stdio.h"
#include "delay.h"
#include "bsp_i2c.h"
#include "ATH20.h"
void RCC_Configuration(void);
void GPIO_Configuration(void);
GPIO_InitTypeDef GPIO_InitStructure;
#pragma import(__use_no_semihosting)
struct __FILE
{
int handle;
};
FILE __stdout;
_sys_exit(int x)
{
x = x;
}
int fputc(int ch, FILE *f)
{
while(USART_GetFlagStatus(USART1,USART_FLAG_TC)==RESET);
USART_SendData(USART1,(uint8_t)ch);
return ch;
}
void uart_init(u32 bound)
{
//GPIO端口设置
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE); //使能USART1，GPIOA时钟
USART_DeInit(USART1); //复位串口1
//USART1_TX PA.9
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用推挽输出
GPIO_Init(GPIOA, &GPIO_InitStructure); //初始化PA9
//USART1_RX PA.10
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
GPIO_Init(GPIOA, &GPIO_InitStructure); //初始化PA10
//USART 初始化设置
USART_InitStructure.USART_BaudRate = bound;//一般设置为9600;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; //收发模式
USART_Init(USART1, &USART_InitStructure); //初始化串口
USART_Cmd(USART1, ENABLE); //使能串口
}
int main(void)
{
uint8_t ret = 0;
float P,T,ALT;
uint32_t CT_data[2];
int c1,t1;
uint8_t LED_Stat = 0;
RCC_Configuration(); //设置系统时钟
GPIO_Configuration(); //IO口设
I2C_Bus_Init();
uart_init(115200);
ret = ATH20_Init();
if(ret == 0)
{
printf("ATH20传感器初始化错误\n");
while(1);
}
while(1)
{
/* 读取 ATH20 传感器数据*/
while(ATH20_Read_Cal_Enable() == 0)
{
ATH20_Init();//如果为0再使能一次
SoftDelay_ms(30);
}
ATH20_Read_CTdata(CT_data); //读取温度和湿度
c1 = CT_data[0] * 1000 / 1024 / 1024; //计算得到湿度值（放大了10倍,如果c1=523，表示现在湿度为52.3%）
t1 = CT_data[1] * 200 *10 / 1024 / 1024 - 500;//计算得到温度值（放大了10倍，如果t1=245，表示现在温度为24.5℃）
printf("***************************\n");
printf("AHT20温湿度传感器测试数据:\n");
printf("温度: %d.%d ℃\n",(t1/10),(t1%10));
printf("湿度: %d.%d %%\n",(c1/10),(c1%10));
printf("\n");
SoftDelay_ms(1000);//每隔两秒读一次数
if(LED_Stat == 0)
{
LED_Stat = 1;
GPIO_ResetBits(GPIOC, GPIO_Pin_2);
}
else
{
LED_Stat = 0;
GPIO_SetBits(GPIOC, GPIO_Pin_2);
}
}
}
void RCC_Configuration(void)
{
SystemInit();
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC
| RCC_APB2Periph_GPIOD| RCC_APB2Periph_GPIOE , ENABLE);
}
void GPIO_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_7; //状态LED1
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; //通用推挽输出模式
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; //输出模式最大速度50MHz
GPIO_Init(GPIOC, &GPIO_InitStructure);
}
AHT20.C
#include "ATH20.h"
#include "bsp_i2c.h"
#include "bsp_i2c.h"
#include "delay.h"
#include "misc.h"
#include "stdio.h"
uint8_t ATH20_Read_Status(void)//读取AHT10的状态寄存器
{
uint8_t Byte_first;
Sensors_I2C_ReadRegister(ATH20_SLAVE_ADDRESS, 0x00, 1,&Byte_first);
return Byte_first;
}
uint8_t ATH20_Read_Cal_Enable(void)
{
uint8_t val = 0;//ret = 0,
val = ATH20_Read_Status();
if((val & 0x68) == 0x08) //判断NOR模式和校准输出是否有效
return 1;
else
return 0;
}
void ATH20_Read_CTdata(uint32_t *ct) //读取AHT10的温度和湿度数据
{
uint32_t RetuData = 0;
uint16_t cnt = 0;
uint8_t Data[10];
uint8_t tmp[10];
tmp[0] = 0x33;
tmp[1] = 0x00;
Sensors_I2C_WriteRegister(ATH20_SLAVE_ADDRESS,StartTest, 2, tmp); //P0 口中断不使能
SoftDelay_ms(75);//等待75ms
cnt = 0;
while(((ATH20_Read_Status()&0x80) == 0x80))//等待忙状态结束
{
SoftDelay_ms(1);
if(cnt++ >= 100)
{
break;
}
}
Sensors_I2C_ReadRegister(ATH20_SLAVE_ADDRESS, 0x00, 7,Data);
RetuData = 0;
RetuData = (RetuData|Data[1]) << 8;
RetuData = (RetuData|Data[2]) << 8;
RetuData = (RetuData|Data[3]);
RetuData = RetuData >> 4;
ct[0] = RetuData;
RetuData = 0;
RetuData = (RetuData|Data[3]) << 8;
RetuData = (RetuData|Data[4]) << 8;
RetuData = (RetuData|Data[5]);
RetuData = RetuData&0xfffff;
ct[1] = RetuData;
}
uint8_t count;
uint8_t ATH20_Init(void)
{
uint8_t tmp[10];
SoftDelay_ms(40);
tmp[0] = 0x08;
tmp[1] = 0x00;
Sensors_I2C_WriteRegister(ATH20_SLAVE_ADDRESS,INIT, 2, tmp); //P0 口中断不使能
SoftDelay_ms(500);
count = 0;
while(ATH20_Read_Cal_Enable() == 0)//需要等待状态字status的Bit[3]=1时才去读数据。如果Bit[3]不等于1 ，发软件复位0xBA给AHT10，再重新初始化AHT10，直至Bit[3]=1
{
Sensors_I2C_WriteRegister(ATH20_SLAVE_ADDRESS,SoftReset, 0, tmp);
SoftDelay_ms(200);
Sensors_I2C_WriteRegister(ATH20_SLAVE_ADDRESS,INIT, 2, tmp);
count++;
if(count >= 10)
return 0;
SoftDelay_ms(500);
}
return 1;
}
bsp_i2c
#include "bsp_i2c.h"
#include "stm32f10x_i2c.h"
#include "delay.h"
#include "misc.h"
#include "stdio.h"
#define mdelay SoftDelay_ms
#define Soft_I2C_SDA_STATE GPIO_ReadInputDataBit(Soft_I2C_PORT, Soft_I2C_SDA)
#define Soft_I2C_DELAY Soft_I2C_Delay(100000)
#define Soft_I2C_NOP Soft_I2C_Delay(10)
#define Soft_I2C_READY 0x00
#define Soft_I2C_BUS_BUSY 0x01
#define Soft_I2C_BUS_ERROR 0x02
#define Soft_I2C_NACK 0x00
#define Soft_I2C_ACK 0x01
static void Soft_I2C_Delay(uint32_t dly)
{
while(--dly); //dly=100: 8.75us; dly=100: 85.58 us (SYSCLK=72MHz)
}
static unsigned short RETRY_IN_MLSEC = 55;
/**
* @brief 设置iic重试时间
* @param ml_sec：重试的时间，单位毫秒
* @retval 重试的时间，单位毫秒
*/
void Set_I2C_Retry(unsigned short ml_sec)
{
RETRY_IN_MLSEC = ml_sec;
}
/**
* @brief 获取设置的iic重试时间
* @param none
* @retval none
*/
unsigned short Get_I2C_Retry(void)
{
return RETRY_IN_MLSEC;
}
static void Soft_I2C_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
GPIO_InitStructure.GPIO_Pin = Soft_I2C_SCL | Soft_I2C_SDA; //配置使用的I2C口
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; //设置I2C口最大允许输出速度
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD; //设置I2C为开漏输出
GPIO_Init(Soft_I2C_PORT, &GPIO_InitStructure);
Soft_I2C_SCL_1;
Soft_I2C_SDA_1;
Soft_I2C_DELAY;
}
void I2C_Bus_Init(void)
{
Set_I2C_Retry(5);
Soft_I2C_Configuration();
}
static uint8_t Soft_I2C_START(void)
{
Soft_I2C_SDA_1;
Soft_I2C_NOP;
Soft_I2C_SCL_1;
Soft_I2C_NOP;
if(!Soft_I2C_SDA_STATE)
return Soft_I2C_BUS_BUSY;
Soft_I2C_SDA_0;
Soft_I2C_NOP;
Soft_I2C_SCL_0;
Soft_I2C_NOP;
if(Soft_I2C_SDA_STATE)
return Soft_I2C_BUS_ERROR;
return Soft_I2C_READY;
}
static void Soft_I2C_STOP(void)
{
Soft_I2C_SDA_0;
Soft_I2C_NOP;
Soft_I2C_SCL_1;
Soft_I2C_NOP;
Soft_I2C_SDA_1;
Soft_I2C_NOP;
}
static void Soft_I2C_SendACK(void)
{
Soft_I2C_SDA_0;
Soft_I2C_NOP;
Soft_I2C_SCL_1;
Soft_I2C_NOP;
Soft_I2C_SCL_0;
Soft_I2C_NOP;
}
static void Soft_I2C_SendNACK(void)
{
Soft_I2C_SDA_1;
Soft_I2C_NOP;
Soft_I2C_SCL_1;
Soft_I2C_NOP;
Soft_I2C_SCL_0;
Soft_I2C_NOP;
}
/**
* @brief 等待应答信号到来
* @retval 返回值：1，接收应答失败
* 0，接收应答成功
*/
uint8_t Soft_I2C_Wait_Ack(void)
{
uint8_t ucErrTime=0;
Soft_I2C_SDA_1;
Soft_I2C_NOP;
Soft_I2C_SCL_1;
Soft_I2C_NOP;
while(Soft_I2C_SDA_STATE)
{
ucErrTime ++;
if(ucErrTime > 250)
{
Soft_I2C_STOP();
return Soft_I2C_BUS_ERROR;
}
}
Soft_I2C_SCL_0;//时钟输出0
return 0;
}
static uint8_t Soft_I2C_SendByte(uint8_t soft_i2c_data)
{
uint8_t i;
Soft_I2C_SCL_0;
for(i=0; i<8; i++)
{
if(soft_i2c_data & 0x80)
Soft_I2C_SDA_1;
else
Soft_I2C_SDA_0;
soft_i2c_data <<= 1;
Soft_I2C_NOP;
Soft_I2C_SCL_1;
Soft_I2C_NOP;
Soft_I2C_SCL_0;
Soft_I2C_NOP;
}
return Soft_I2C_Wait_Ack();
}
static uint8_t Soft_I2C_ReceiveByte(void)
{
uint8_t i,soft_i2c_data;
Soft_I2C_SDA_1;
Soft_I2C_SCL_0;
soft_i2c_data = 0;
for(i=0; i<8; i++)
{
Soft_I2C_SCL_1;
Soft_I2C_NOP;
soft_i2c_data <<= 1;
if(Soft_I2C_SDA_STATE)
soft_i2c_data |= 0x01;
Soft_I2C_SCL_0;
Soft_I2C_NOP;
}
Soft_I2C_SendNACK();
return soft_i2c_data;
}
static uint8_t Soft_I2C_ReceiveByte_WithACK(void)
{
uint8_t i,soft_i2c_data;
Soft_I2C_SDA_1;
Soft_I2C_SCL_0;
soft_i2c_data = 0;
for(i=0; i<8; i++)
{
Soft_I2C_SCL_1;
Soft_I2C_NOP;
soft_i2c_data <<= 1;
if(Soft_I2C_SDA_STATE)
soft_i2c_data |= 0x01;
Soft_I2C_SCL_0;
Soft_I2C_NOP;
}
Soft_I2C_SendACK();
return soft_i2c_data;
}
static uint8_t Soft_DMP_I2C_Write(uint8_t soft_dev_addr, uint8_t soft_reg_addr, uint8_t soft_i2c_len,unsigned char *soft_i2c_data_buf)
{
uint8_t i, result = 0;
Soft_I2C_START();
result = Soft_I2C_SendByte(soft_dev_addr << 1 | I2C_Direction_Transmitter);
if(result != 0) return result;
result = Soft_I2C_SendByte(soft_reg_addr);
if(result != 0) return result;
for (i=0; i<soft_i2c_len; i++)
{
result = Soft_I2C_SendByte(soft_i2c_data_buf[i]);
if (result != 0) return result;
}
Soft_I2C_STOP();
return 0x00;
}
static uint8_t Soft_DMP_I2C_Read(uint8_t soft_dev_addr, uint8_t soft_reg_addr, uint8_t soft_i2c_len,unsigned char *soft_i2c_data_buf)
{
uint8_t result;
Soft_I2C_START();
result = Soft_I2C_SendByte(soft_dev_addr << 1 | I2C_Direction_Transmitter);
if(result != 0) return result;
result = Soft_I2C_SendByte(soft_reg_addr);
//printf("addr:0x%x\n",result);
if(result != 0) return result;
Soft_I2C_START();
result = Soft_I2C_SendByte(soft_dev_addr << 1 | I2C_Direction_Receiver);
if(result != 0) return result;
while (soft_i2c_len)
{
if (soft_i2c_len == 1)
*soft_i2c_data_buf = Soft_I2C_ReceiveByte();
else
*soft_i2c_data_buf = Soft_I2C_ReceiveByte_WithACK();
soft_i2c_data_buf ++;
soft_i2c_len --;
}
Soft_I2C_STOP();
return 0x00;
}
/**
* @brief 向IIC设备的寄存器连续写入数据，带超时重试设置，供mpu接口调用
* @param Address: IIC设备地址
* @param RegisterAddr: 寄存器地址
* @param RegisterLen: 要写入数据的长度
* @param RegisterValue: 要指向写入数据的指针
* @retval 0正常，非0异常
*/
int Sensors_I2C_WriteRegister(unsigned char slave_addr,
unsigned char reg_addr,
unsigned short len,
const unsigned char *data_ptr)
{
char retries = 0;
int ret = 0;
unsigned short retry_in_mlsec = Get_I2C_Retry();
tryWriteAgain:
ret = 0;
ret = Soft_DMP_I2C_Write( slave_addr, reg_addr, len, ( unsigned char *)data_ptr);
if(ret && retry_in_mlsec)
{
if( retries++ > 4 )
return ret;
mdelay(retry_in_mlsec);
goto tryWriteAgain;
}
return ret;
}
/**
* @brief 向IIC设备的寄存器连续读出数据,带超时重试设置，供mpu接口调用
* @param Address: IIC设备地址
* @param RegisterAddr: 寄存器地址
* @param RegisterLen: 要读取的数据长度
* @param RegisterValue: 指向存储读出数据的指针
* @retval 0正常，非0异常
*/
int Sensors_I2C_ReadRegister(unsigned char slave_addr,
unsigned char reg_addr,
unsigned short len,
unsigned char *data_ptr)
{
char retries = 0;
int ret = 0;
unsigned short retry_in_mlsec = Get_I2C_Retry();
tryReadAgain:
ret = 0;
ret = Soft_DMP_I2C_Read( slave_addr, reg_addr, len, ( unsigned char *)data_ptr);
if(ret && retry_in_mlsec)
{
if( retries++ > 4 )
return ret;
mdelay(retry_in_mlsec);
goto tryReadAgain;
}
return ret;
}
下面是温度采集的串口通信
总结
本次代码是根据SHT20代码改变来的，比较了我们用的AHT20和SHT20的使用手册，修改了一系列参数和物理地址，最终还是运行起来了。
扫一扫
6231
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
