Stm32 Hal库AHT20 I2C驱动程序

最新推荐文章于 2024-04-30 18:52:53 发布

嵌入式冰箱

最新推荐文章于 2024-04-30 18:52:53 发布

阅读量1k

点赞数

文章标签： stm32 单片机嵌入式硬件 c++ c语言

本文链接：https://blog.csdn.net/qq_52590045/article/details/131192705

版权

1电源引脚(VDD,GND)

AHT20的供电范围为2.0-5.5V,推荐电压为3.3V，在VDD和GND之间必须加上去耦电容1uF，起到滤波作用。VDD比SDA和SCL优先上电或者同步上电，避免因为信号线(SCL/SDA)漏电电流灌入，导致芯片上电后处于非工作状态。

2串行时钟

CSLSCL 用于微处理器与AHT20之间的通讯同步。由于接口包含了完全静态逻辑，因而不存在最小SCL频率。

3串行数据

SDASDA 引脚用于传感器的数据输入和输出。当向传感器发送命令时，SDA在串行时钟SCL的上升沿有效，且当SCL为高电平时，SDA必须保持稳定。在SCL下降沿之后，SDA值可被改变。为确保通信安全，SDA的有效时间在SCL上升沿之前，和下降沿之后应该分别延长至TSUand THO-参考图17。当从传感器读取数据时，SDA在SCL变低以后有效 (TV),且维持到下一个SCL的下降沿。

为避免信号冲突，微处理器（MCU）必须只能驱动 SDA 和 SCL 在低电平，需要一个外部的上拉电阻（例如：2.0~10kΩ）将信号提拉至高电平，上拉电阻通常可能已包含在微处理器的 I/O 电路中。

4启动传感器

启动传感器第一步，将传感器上电，电压为所选择的 VDD电源电压(范围介于2.0V与5.5V之间)。上电后传感器最多需要20ms时间（此时SCL为高电平)以达到空闲状态即做好准备接收由主机 (MCU)发送的命令。

5启动/停止时序

每个传输序列都以Start状态作为开始并以Stop状态作为结束，如图18和图19。

6发送命令

在启动传输后，随后传输的I2C首字节包括7位2的IC设备地址0x38和一个SDA方向位 x(读R：‘1'，写W:‘0’)。在第8个SCL时钟下降沿之后，通过拉低 SDA引脚 (ACK位)，指示传感器数据接收正常。在发送测量命令0xAC之后，MCU必须等到测量完成,基本的命令在表9中进行概述。表10为从机返回的状态位说明。

7传感器读取流程

1.上电后要等待40ms，读取温湿度值之前，首先要看状态字的校准使能位Bit[3]是否为1(通过发送0x71可以获取一个字节的状态字)，如果不为1，要发送0xBE命令(初始化)，此命令参数有两个字节，第一个字节为0x08，第二个字节为0x00,然后等待10ms。2.直接发送 0xAC命令(触发测量)，此命令参数有两个字节，第一个字节为 0x33，第二个字节为0x00。3.等待80ms待测量完成，如果读取状态字Bit[7]为0，表示测量完成，然后可以连续读取六个字节；否则继续等待。4.当接收完六个字节后，紧接着下一个字节是CRC校验数据，用户可以根据需要读出，如果接收端需要CRC校验，则在接收完第六个字节后发ACK应答，否则发NACK结束，CRC初始值为0XFF

计算温湿度值。注：在第一步的校准状态检验只需要上电时检查，在正常采集过程无需操作。

8软复位

开电源的情况下，重新启动传感器系统。在接收到这个命令之后，传感器系统开始重新初始化，并恢复默认设置状态，软复位所需时间不超过20毫秒。

9信号转换

相对湿度转换相对湿度RH 都可以根据SDA 输出的相对湿度信号 SRH 通过如下公式计算获得（结果以%RH表示）

温度转换温度T 都可以通过将温度输出信号 ST 代入到下面的公式计算得到（结果以温度 ℃ 表示）

//AHT20.c

#include "bsp_i2c.h"
#include "delay.h"

uint8_t ack_status=0;
uint8_t readByte[6];
uint8_t AHT20_status=0;

uint32_t H1=0; //Humility
uint32_t T1=0; //Temperature

uint8_t AHT20_OutData[4];
uint8_t AHT20sendOutData[10] = {0xFA, 0x06, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF};

void IIC_Init(void)
{
   GPIO_InitTypeDef GPIO_InitStructure;
   RCC_APB2PeriphClockCmd(   RCC_APB2Periph_GPIOB, ENABLE );

   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7;
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ; //ÍÆÍìÊä³ö
   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   GPIO_Init(GPIOB, &GPIO_InitStructure);

   IIC_SCL=1;
   IIC_SDA=1;

}
//²úÉúIICÆðÊ¼ÐÅºÅ
void IIC_Start(void)
{
   SDA_OUT(); //sdaÏßÊä³ö
   IIC_SDA=1;
   IIC_SCL=1;
   delay_us(4);
    IIC_SDA=0;//START:when CLK is high,DATA change form high to low
   delay_us(4);
   IIC_SCL=0;//Ç¯×¡I2C×ÜÏß£¬×¼±¸·¢ËÍ»ò½ÓÊÕÊý¾Ý
}
//²úÉúIICÍ£Ö¹ÐÅºÅ
void IIC_Stop(void)
{
   SDA_OUT();//sdaÏßÊä³ö
   IIC_SCL=0;
   IIC_SDA=0;//STOP:when CLK is high DATA change form low to high
    delay_us(4);
   IIC_SCL=1;
   IIC_SDA=1;//·¢ËÍI2C×ÜÏß½áÊøÐÅºÅ
   delay_us(4);
}
//µÈ´ýÓ¦´ðÐÅºÅµ½À´
//·µ»ØÖµ£º1£¬½ÓÊÕÓ¦´ðÊ§°Ü
// 0£¬½ÓÊÕÓ¦´ð³É¹¦
u8 IIC_Wait_Ack(void)
{
   u8 ucErrTime=0;
   SDA_IN(); //SDAÉèÖÃÎªÊäÈë
   IIC_SDA=1;delay_us(1);
   IIC_SCL=1;delay_us(1);
   while(READ_SDA)
   {
       ucErrTime++;
       if(ucErrTime>250)
       {
           IIC_Stop();
           return 1;
       }
   }
   IIC_SCL=0;//Ê±ÖÓÊä³ö0
   return 0;
}
//²úÉúACKÓ¦´ð
void IIC_Ack(void)
{
   IIC_SCL=0;
   SDA_OUT();
   IIC_SDA=0;
   delay_us(2);
   IIC_SCL=1;
   delay_us(2);
   IIC_SCL=0;
}
//²»²úÉúACKÓ¦´ð
void IIC_NAck(void)
{
   IIC_SCL=0;
   SDA_OUT();
   IIC_SDA=1;
   delay_us(2);
   IIC_SCL=1;
   delay_us(2);
   IIC_SCL=0;
}
//IIC·¢ËÍÒ»¸ö×Ö½Ú
//·µ»Ø´Ó»úÓÐÎÞÓ¦´ð
//1£¬ÓÐÓ¦´ð
//0£¬ÎÞÓ¦´ð
void IIC_Send_Byte(u8 txd)
{
u8 t;
       SDA_OUT();
IIC_SCL=0;//ÀµÍÊ±ÖÓ¿ªÊ¼Êý¾Ý´«Êä
for(t=0;t<8;t++)
{
IIC_SDA=(txd&0x80)>>7;
txd<<=1;
       delay_us(2); //¶ÔTEA5767ÕâÈý¸öÑÓÊ±¶¼ÊÇ±ØÐëµÄ
       IIC_SCL=1;
       delay_us(2);
       IIC_SCL=0;
       delay_us(2);
}
}
//¶Á1¸ö×Ö½Ú£¬ack=1Ê±£¬·¢ËÍACK£¬ack=0£¬·¢ËÍnACK
u8 IIC_Read_Byte(unsigned char ack)
{
   unsigned char i,receive=0;
   SDA_IN();//SDAÉèÖÃÎªÊäÈë
for(i=0;i<8;i++ )
   {
IIC_SCL=0;
delay_us(2);
       IIC_SCL=1;
receive<<=1;
if(READ_SDA)receive++;
       delay_us(1);
}
   if (!ack)
           IIC_NAck();//·¢ËÍnACK
   else
           IIC_Ack(); //·¢ËÍACK
   return receive;
}

void IIC_WriteByte(uint16_t addr,uint8_t data,uint8_t device_addr)
{
   IIC_Start();

   if(device_addr==0xA0) //eepromµØÖ·´óÓÚ1×Ö½Ú
       IIC_Send_Byte(0xA0 + ((addr/256)<<1));//·¢ËÍ¸ßµØÖ·
   else
       IIC_Send_Byte(device_addr);   //·¢Æ÷¼þµØÖ·
   IIC_Wait_Ack();
   IIC_Send_Byte(addr&0xFF); //·¢ËÍµÍµØÖ·
   IIC_Wait_Ack();
   IIC_Send_Byte(data); //·¢ËÍ×Ö½Ú
   IIC_Wait_Ack();
IIC_Stop();//²úÉúÒ»¸öÍ£Ö¹Ìõ¼þ
   if(device_addr==0xA0) //
       delay_ms(10);
   else
       delay_us(2);
}

uint16_t IIC_ReadByte(uint16_t addr,uint8_t device_addr,uint8_t ByteNumToRead) //¶Á¼Ä´æÆ÷»ò¶ÁÊý¾Ý
{
       uint16_t data;
       IIC_Start();
       if(device_addr==0xA0)
           IIC_Send_Byte(0xA0 + ((addr/256)<<1));
       else
           IIC_Send_Byte(device_addr);
       IIC_Wait_Ack();
       IIC_Send_Byte(addr&0xFF); //·¢ËÍµÍµØÖ·
       IIC_Wait_Ack();

       IIC_Start();
       IIC_Send_Byte(device_addr+1);   //·¢Æ÷¼þµØÖ·
       IIC_Wait_Ack();
       if(ByteNumToRead == 1)//LM75ÎÂ¶ÈÊý¾ÝÎª11bit
       {
           data=IIC_Read_Byte(0);
       }
       else
           {
               data=IIC_Read_Byte(1);
               data=(data<<8)+IIC_Read_Byte(0);
           }
       IIC_Stop();//²úÉúÒ»¸öÍ£Ö¹Ìõ¼þ
       return data;
}

/**********
*ÉÏÃæ²¿·ÖÎªIO¿ÚÄ£¿éI2CÅäÖÃ
*
*´ÓÕâÒÔÏÂ¿ªÊ¼ÎªAHT20µÄÅäÖÃI2C
*º¯ÊýÃûÓÐIICºÍI2CµÄÇø±ð£¬Çë×¢Òâ£¡£¡£¡£¡£¡
*
*2020/2/23×îºóÐÞ¸ÄÈÕÆÚ
*
***********/
void read_AHT20_once(void)
{
   delay_ms(10);

   reset_AHT20();
   delay_ms(10);

   init_AHT20();
   delay_ms(10);

   startMeasure_AHT20();
   delay_ms(80);

   read_AHT20();
   delay_ms(5);
}

void reset_AHT20(void)
{

   I2C_Start();

   I2C_WriteByte(0x70);
   ack_status = Receive_ACK();
   if(ack_status) printf("1");
   else printf("1-n-");
   I2C_WriteByte(0xBA);
   ack_status = Receive_ACK();
       if(ack_status) printf("2");
   else printf("2-n-");
   I2C_Stop();

   /*
   AHT20_OutData[0] = 0;
   AHT20_OutData[1] = 0;
   AHT20_OutData[2] = 0;
   AHT20_OutData[3] = 0;
   */
}

void init_AHT20(void)
{
   I2C_Start();

   I2C_WriteByte(0x70);
   ack_status = Receive_ACK();
   if(ack_status) printf("3");
   else printf("3-n-");
   I2C_WriteByte(0xE1);
   ack_status = Receive_ACK();
   if(ack_status) printf("4");
   else printf("4-n-");
   I2C_WriteByte(0x08);
   ack_status = Receive_ACK();
   if(ack_status) printf("5");
   else printf("5-n-");
   I2C_WriteByte(0x00);
   ack_status = Receive_ACK();
   if(ack_status) printf("6");
   else printf("6-n-");
   I2C_Stop();
}

void startMeasure_AHT20(void)
{
   //------------
   I2C_Start();

   I2C_WriteByte(0x70);
   ack_status = Receive_ACK();
   if(ack_status) printf("7");
   else printf("7-n-");
   I2C_WriteByte(0xAC);
   ack_status = Receive_ACK();
   if(ack_status) printf("8");
   else printf("8-n-");
   I2C_WriteByte(0x33);
   ack_status = Receive_ACK();
   if(ack_status) printf("9");
   else printf("9-n-");
   I2C_WriteByte(0x00);
   ack_status = Receive_ACK();
   if(ack_status) printf("10");
   else printf("10-n-");
   I2C_Stop();
}

void read_AHT20(void)
{
   uint8_t i;

   for(i=0; i<6; i++)
   {
       readByte[i]=0;
   }

   //-------------
   I2C_Start();

   I2C_WriteByte(0x71);
   ack_status = Receive_ACK();
   readByte[0]= I2C_ReadByte();
   Send_ACK();

   readByte[1]= I2C_ReadByte();
   Send_ACK();

   readByte[2]= I2C_ReadByte();
   Send_ACK();

   readByte[3]= I2C_ReadByte();
   Send_ACK();

   readByte[4]= I2C_ReadByte();
   Send_ACK();

   readByte[5]= I2C_ReadByte();
   SendNot_Ack();
   //Send_ACK();

   I2C_Stop();

   //--------------
   if( (readByte[0] & 0x68) == 0x08 )
   {
       H1 = readByte[1];
       H1 = (H1<<8) | readByte[2];
       H1 = (H1<<8) | readByte[3];
       H1 = H1>>4;

       H1 = (H1*1000)/1024/1024;

       T1 = readByte[3];
       T1 = T1 & 0x0000000F;
       T1 = (T1<<8) | readByte[4];
       T1 = (T1<<8) | readByte[5];

       T1 = (T1*2000)/1024/1024 - 500;

       AHT20_OutData[0] = (H1>>8) & 0x000000FF;
       AHT20_OutData[1] = H1 & 0x000000FF;

       AHT20_OutData[2] = (T1>>8) & 0x000000FF;
       AHT20_OutData[3] = T1 & 0x000000FF;
   }
   else
   {
       AHT20_OutData[0] = 0xFF;
       AHT20_OutData[1] = 0xFF;

       AHT20_OutData[2] = 0xFF;
       AHT20_OutData[3] = 0xFF;
       printf("Ê§°ÜÁË");

   }
   printf("\r\n");
   printf("ÎÂ¶È:%d%d.%d",T1/100,(T1/10)%10,T1%10);
   printf("Êª¶È:%d%d.%d",H1/100,(H1/10)%10,H1%10);
   printf("\r\n");
}

uint8_t Receive_ACK(void)
{
   uint8_t result=0;
   uint8_t cnt=0;

   IIC_SCL = 0;
   SDA_IN();
   delay_us(4);

   IIC_SCL = 1;
   delay_us(4);

   while(READ_SDA && (cnt<100))
   {
       cnt++;
   }

   IIC_SCL = 0;
   delay_us(4);

   if(cnt<100)
   {
       result=1;
   }
   return result;
}

void Send_ACK(void)
{
   SDA_OUT();
   IIC_SCL = 0;
   delay_us(4);

   IIC_SDA = 0;
   delay_us(4);

   IIC_SCL = 1;
   delay_us(4);
   IIC_SCL = 0;
   delay_us(4);

   SDA_IN();
}

void SendNot_Ack(void)
{
   SDA_OUT();
   IIC_SCL = 0;
   delay_us(4);

   IIC_SDA = 1;
   delay_us(4);

   IIC_SCL = 1;
   delay_us(4);

   IIC_SCL = 0;
   delay_us(4);

   IIC_SDA = 0;
   delay_us(4);
}

void I2C_WriteByte(uint8_t input)
{
   uint8_t i;
   SDA_OUT();
   for(i=0; i<8; i++)
   {
       IIC_SCL = 0;
       delay_ms(5);

       if(input & 0x80)
       {
           IIC_SDA = 1;
           //delaymm(10);
       }
       else
       {
           IIC_SDA = 0;
           //delaymm(10);
       }

       IIC_SCL = 1;
       delay_ms(5);

       input = (input<<1);
   }

   IIC_SCL = 0;
   delay_us(4);

   SDA_IN();
   delay_us(4);
}

uint8_t I2C_ReadByte(void)
{
   uint8_t resultByte=0;
   uint8_t i=0, a=0;

   IIC_SCL = 0;
   SDA_IN();
   delay_ms(4);

   for(i=0; i<8; i++)
   {
       IIC_SCL = 1;
       delay_ms(3);

       a=0;
       if(READ_SDA)
       {
           a=1;
       }
       else
       {
           a=0;
       }

       //resultByte = resultByte | a;
       resultByte = (resultByte << 1) | a;

       IIC_SCL = 0;
       delay_ms(3);
   }

   SDA_IN();
   delay_ms(10);

   return resultByte;
}

void set_AHT20sendOutData(void)
{
   /* --------------------------
   * 0xFA 0x06 0x0A temperature(2 Bytes) humility(2Bytes) short Address(2 Bytes)
   * And Check (1 byte)
   * -------------------------*/
   AHT20sendOutData[3] = AHT20_OutData[0];
   AHT20sendOutData[4] = AHT20_OutData[1];
   AHT20sendOutData[5] = AHT20_OutData[2];
   AHT20sendOutData[6] = AHT20_OutData[3];

//   AHT20sendOutData[7] = (drf1609.shortAddress >> 8) & 0x00FF;
//   AHT20sendOutData[8] = drf1609.shortAddress & 0x00FF;

//   AHT20sendOutData[9] = getXY(AHT20sendOutData,10);
}

void I2C_Start(void)
{
   SDA_OUT();
   IIC_SCL = 1;
   delay_ms(4);

   IIC_SDA = 1;
   delay_ms(4);
   IIC_SDA = 0;
   delay_ms(4);

   IIC_SCL = 0;
   delay_ms(4);
}

void I2C_Stop(void)
{
   SDA_OUT();
   IIC_SDA = 0;
   delay_ms(4);

   IIC_SCL = 1;
   delay_ms(4);

   IIC_SDA = 1;
   delay_ms(4);
}

//AHT20.h

#ifndef __BSP_I2C_H

#define __BSP_I2C_H

#include "sys.h"

#include "delay.h"

#include "usart.h"

//Ê¹ÓÃIIC1 ¹ÒÔØM24C02,OLED,LM75AD,HT1382 PB6,PB7

#define SDA_IN() {GPIOB->CRL&=0X0FFFFFFF;GPIOB->CRL|=(u32)8<<28;}

#define SDA_OUT() {GPIOB->CRL&=0X0FFFFFFF;GPIOB->CRL|=(u32)3<<28;}

//IO²Ù×÷º¯Êý

#define IIC_SCL PBout(6) //SCL

#define IIC_SDA PBout(7) //SDA

#define READ_SDA PBin(7) //ÊäÈëSDA

//IICËùÓÐ²Ù×÷º¯Êý

void IIC_Init(void); //³õÊ¼»¯IICµÄIO¿Ú

void IIC_Start(void); //·¢ËÍIIC¿ªÊ¼ÐÅºÅ

void IIC_Stop(void); //·¢ËÍIICÍ£Ö¹ÐÅºÅ

void IIC_Send_Byte(u8 txd); //IIC·¢ËÍÒ»¸ö×Ö½Ú

u8 IIC_Read_Byte(unsigned char ack);//IIC¶ÁÈ¡Ò»¸ö×Ö½Ú

u8 IIC_Wait_Ack(void); //IICµÈ´ýACKÐÅºÅ

void IIC_Ack(void); //IIC·¢ËÍACKÐÅºÅ

void IIC_NAck(void); //IIC²»·¢ËÍACKÐÅºÅ

void IIC_WriteByte(uint16_t addr,uint8_t data,uint8_t device_addr);

uint16_t IIC_ReadByte(uint16_t addr,uint8_t device_addr,uint8_t ByteNumToRead);//¼Ä´æÆ÷µØÖ·£¬Æ÷¼þµØÖ·£¬Òª¶ÁµÄ×Ö½ÚÊý

void read_AHT20_once(void);

void reset_AHT20(void);

void init_AHT20(void);

void startMeasure_AHT20(void);

void read_AHT20(void);

uint8_t Receive_ACK(void);

void Send_ACK(void);

void SendNot_Ack(void);

void I2C_WriteByte(uint8_t input);

uint8_t I2C_ReadByte(void);

void set_AHT20sendOutData(void);

void I2C_Start(void);

void I2C_Stop(void);

#endif

//main.c

#include "delay.h"
#include "usart.h"
#include "bsp_i2c.h"

int main(void)
{
   delay_init(); //ÑÓÊ±º¯Êý³õÊ¼»¯
   uart_init(115200);   //´®¿Ú³õÊ¼»¯Îª115200
   IIC_Init();
       while(1)
   {
       printf("¿ªÊ¼²âÁ¿£¬ÇëÉÔµÈ£º");
       read_AHT20_once();
       delay_ms(1500);
}
}

嵌入式冰箱

关注

0
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
0
评论
Stm32 Hal库AHT20 I2C驱动程序

1.上电后要等待40ms，读取温湿度值之前，首先要看状态字的校准使能位Bit[3]是否为1(通过发送0x71可以获取一个字节的状态字)，如果不为1，要发送0xBE命令(初始化)，此命令参数有两个字节，第一个字节为0x08，第二个字节为0x00,然后等待10ms。4.当接收完六个字节后，紧接着下一个字节是CRC校验数据，用户可以根据需要读出，如果接收端需要CRC校验，则在接收完第六个字节后发ACK应答，否则发NACK结束，CRC初始值为0XFF。在SCL下降沿之后，SDA值可被改变。
复制链接

扫一扫