发新帖我要提问
12
返回列表
打印
[其他ST产品]

STM32HAL库方式实现温湿度传感采集

[复制链接]
楼主: l63t89
手机看帖
扫描二维码
随时随地手机跟帖
21楼
l63t89|  楼主 | 2024-1-31 14:45 | 只看该作者 |只看大图 回帖奖励 |倒序浏览
最后，按照老方法生成工程就好了。这里参考之前的博客

使用特权

评论回复 赏
22楼
l63t89|  楼主 | 2024-1-31 14:45 | 只看该作者
最后我们点击“Project Manager”，设置好我们工程存放的路径，选择“MDK-ARM"方式打开。

使用特权

评论回复 赏
23楼
l63t89|  楼主 | 2024-1-31 14:46 | 只看该作者
再点击”Code Generator“，勾选以下选项，点击右上角，这样工程就建立好了

使用特权

评论回复 赏
24楼
l63t89|  楼主 | 2024-1-31 14:46 | 只看该作者
四、各函数代码导入与编写
4.1 模块函数导入
生产厂商已给AHT20的配置代码，我们需将其下载并导入到工程当中。

AHT20配置函数链接：

链接：https://pan.baidu.com/s/1846AHdi3J96m_txVhv1ahw?pwd=0231
提取码：0231

使用特权

评论回复 赏
25楼
l63t89|  楼主 | 2024-1-31 14:46 | 只看该作者
下载好后，我们把AHT这个文件夹粘贴到工程文件目录下

使用特权

评论回复 赏
26楼
l63t89|  楼主 | 2024-1-31 14:46 | 只看该作者
然后我们打开工程，点击三个箱子图案，取名"AHT"。

使用特权

评论回复 赏
27楼
l63t89|  楼主 | 2024-1-31 14:47 | 只看该作者
然后将AHT中两个文件加入到AHT组中

使用特权

评论回复 赏
28楼
l63t89|  楼主 | 2024-1-31 14:47 | 只看该作者
随后点击魔术棒，加入头文件路径“AHT

使用特权

评论回复 赏
29楼
l63t89|  楼主 | 2024-1-31 14:48 | 只看该作者
这样基本的导入就做好了，另外还需要在”Target“栏中打开”Use MicroLIB“

使用特权

评论回复 赏
30楼
l63t89|  楼主 | 2024-1-31 14:48 | 只看该作者
4.2 模块函数修改
本次实验使用的是HAL库，故我们先将AHT的c文件进行如下修改：#include "AHT20-21_DEMO_V1_3.h"
#include "gpio.h"
#include "i2c.h"


void Delay_N10us(uint32_t t)//延时函数
{
  uint32_t k;

   while(t--)
  {
    for (k = 0; k < 2; k++);//110
  }
}

void SensorDelay_us(uint32_t t)//延时函数
{
               
        for(t = t-2; t>0; t--)
        {
                Delay_N10us(1);
        }
}

void Delay_4us(void)                //延时函数
{       
        Delay_N10us(1);
        Delay_N10us(1);
        Delay_N10us(1);
        Delay_N10us(1);
}
void Delay_5us(void)                //延时函数
{       
        Delay_N10us(1);
        Delay_N10us(1);
        Delay_N10us(1);
        Delay_N10us(1);
        Delay_N10us(1);

}

void Delay_1ms(uint32_t t)                //延时函数
{
   while(t--)
  {
    SensorDelay_us(1000);//延时1ms
  }
}


//void AHT20_Clock_Init(void)                //延时函数
//{
//        RCC_APB2PeriphClockCmd(CC_APB2Periph_GPIOB,ENABLE);
//}

void SDA_Pin_Output_High(void)   //将PB7配置为输出 ， 并设置为高电平， PB7作为I2C的SDA
{
        GPIO_InitTypeDef  GPIO_InitStruct;
        GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;//推挽输出
        GPIO_InitStruct.Pin = GPIO_PIN_7;
        GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
        HAL_GPIO_Init(GPIOB,& GPIO_InitStruct);
        HAL_GPIO_WritePin(GPIOB,GPIO_PIN_7,GPIO_PIN_SET);
}

void SDA_Pin_Output_Low(void)  //将P7配置为输出  并设置为低电平
{
        GPIO_InitTypeDef  GPIO_InitStruct;
        GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;//推挽输出
        GPIO_InitStruct.Pin = GPIO_PIN_7;
        GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
        HAL_GPIO_Init(GPIOB,& GPIO_InitStruct);
        HAL_GPIO_WritePin(GPIOB,GPIO_PIN_7,GPIO_PIN_RESET);
}

void SDA_Pin_IN_FLOATING(void)  //SDA配置为浮空输入
{
        GPIO_InitTypeDef  GPIO_InitStruct;
        GPIO_InitStruct.Mode = GPIO_MODE_INPUT;//浮空
        GPIO_InitStruct.Pin = GPIO_PIN_7;
        GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
        HAL_GPIO_Init( GPIOB,&GPIO_InitStruct);
}


void SCL_Pin_Output_High(void) //SCL输出高电平，P14作为I2C的SCL
{
        HAL_GPIO_WritePin(GPIOB,GPIO_PIN_6,GPIO_PIN_SET);
}

void SCL_Pin_Output_Low(void) //SCL输出低电平
{
        HAL_GPIO_WritePin(GPIOB,GPIO_PIN_6,GPIO_PIN_RESET);
}

void Init_I2C_Sensor_Port(void) //初始化I2C接口,输出为高电平
{       
        GPIO_InitTypeDef  GPIO_InitStruct;
        GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;//推挽输出
        GPIO_InitStruct.Pin = GPIO_PIN_7;
        GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
        HAL_GPIO_Init(GPIOB,& GPIO_InitStruct);
        HAL_GPIO_WritePin(GPIOB,GPIO_PIN_15,GPIO_PIN_SET);

       
        GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;//推挽输出
        GPIO_InitStruct.Pin = GPIO_PIN_6;
        GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
        HAL_GPIO_Init(GPIOB,& GPIO_InitStruct);
        HAL_GPIO_WritePin(GPIOB,GPIO_PIN_15,GPIO_PIN_SET);
       
}
void I2C_Start(void)                 //I2C主机发送START信号
{
        SDA_Pin_Output_High();
        SensorDelay_us(8);
        SCL_Pin_Output_High();
        SensorDelay_us(8);
        SDA_Pin_Output_Low();
        SensorDelay_us(8);
        SCL_Pin_Output_Low();
        SensorDelay_us(8);   
}


void AHT20_WR_Byte(uint8_t Byte) //往AHT20写一个字节
{
        uint8_t Data,N,i;       
        Data=Byte;
        i = 0x80;
        for(N=0;N<8;N++)
        {
                SCL_Pin_Output_Low();
                Delay_4us();       
                if(i&Data)
                {
                        SDA_Pin_Output_High();
                }
                else
                {
                        SDA_Pin_Output_Low();
                }       
                       
    SCL_Pin_Output_High();
                Delay_4us();
                Data <<= 1;
                 
        }
        SCL_Pin_Output_Low();
        SensorDelay_us(8);   
        SDA_Pin_IN_FLOATING();
        SensorDelay_us(8);       
}       


uint8_t AHT20_RD_Byte(void)//从AHT20读取一个字节
{
                uint8_t Byte,i,a;
        Byte = 0;
        SCL_Pin_Output_Low();
       
        SDA_Pin_IN_FLOATING();
        SensorDelay_us(8);       
       
        for(i=0;i<8;i++)
        {
    SCL_Pin_Output_High();
               
                Delay_5us();
                a=0;
               
                //if(GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_15)) a=1;
                if(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_7)) a=1;
                Byte = (Byte<<1)|a;
               
                //SCL_Pin_Output_Low();
                HAL_GPIO_WritePin(GPIOB,GPIO_PIN_6,GPIO_PIN_RESET);
                Delay_5us();
        }
  SDA_Pin_IN_FLOATING();
        SensorDelay_us(8);       
        return Byte;
}


uint8_t Receive_ACK(void)   //看AHT20是否有回复ACK
{
        uint16_t CNT;
        CNT = 0;
        SCL_Pin_Output_Low();       
        SDA_Pin_IN_FLOATING();
        SensorDelay_us(8);       
        SCL_Pin_Output_High();       
        SensorDelay_us(8);       
        while((HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_7))  && CNT < 100)
        CNT++;
        if(CNT == 100)
        {
                return 0;
        }
        SCL_Pin_Output_Low();       
        SensorDelay_us(8);       
        return 1;
}

void Send_ACK(void)                  //主机回复ACK信号
{
        SCL_Pin_Output_Low();       
        SensorDelay_us(8);       
        SDA_Pin_Output_Low();
        SensorDelay_us(8);       
        SCL_Pin_Output_High();       
        SensorDelay_us(8);
        SCL_Pin_Output_Low();       
        SensorDelay_us(8);
        SDA_Pin_IN_FLOATING();
        SensorDelay_us(8);
}

void Send_NOT_ACK(void)        //主机不回复ACK
{
        SCL_Pin_Output_Low();       
        SensorDelay_us(8);
        SDA_Pin_Output_High();
        SensorDelay_us(8);
        SCL_Pin_Output_High();       
        SensorDelay_us(8);               
        SCL_Pin_Output_Low();       
        SensorDelay_us(8);
    SDA_Pin_Output_Low();
        SensorDelay_us(8);
}

void Stop_I2C(void)          //一条协议结束
{
        SDA_Pin_Output_Low();
        SensorDelay_us(8);
        SCL_Pin_Output_High();       
        SensorDelay_us(8);
        SDA_Pin_Output_High();
        SensorDelay_us(8);
}

uint8_t AHT20_Read_Status(void)//读取AHT20的状态寄存器
{

        uint8_t Byte_first;       
        I2C_Start();
        AHT20_WR_Byte(0x71);
        Receive_ACK();
        Byte_first = AHT20_RD_Byte();
        Send_NOT_ACK();
        Stop_I2C();
        return Byte_first;
}

uint8_t AHT20_Read_Cal_Enable(void)  //查询cal enable位有没有使能
{
        uint8_t val = 0;//ret = 0,
  val = AHT20_Read_Status();
         if((val & 0x68)==0x08)
                 return 1;
   else  return 0;
}

void AHT20_SendAC(void) //向AHT20发送AC命令
{

        I2C_Start();
        AHT20_WR_Byte(0x70);
        Receive_ACK();
        AHT20_WR_Byte(0xac);//0xAC采集命令
        Receive_ACK();
        AHT20_WR_Byte(0x33);
        Receive_ACK();
        AHT20_WR_Byte(0x00);
        Receive_ACK();
        Stop_I2C();

}

//CRC校验类型：CRC8/MAXIM
//多项式：X8+X5+X4+1
//Poly：0011 0001  0x31
//高位放到后面就变成 1000 1100 0x8c
//C现实代码：
uint8_t Calc_CRC8(uint8_t *message,uint8_t Num)
{
        uint8_t i;
        uint8_t byte;
        uint8_t crc=0xFF;
  for(byte=0; byte<Num; byte++)
  {
    crc^=(message[byte]);
    for(i=8;i>0;--i)
    {
      if(crc&0x80) crc=(crc<<1)^0x31;
      else crc=(crc<<1);
    }
  }
        return crc;
}

void AHT20_Read_CTdata(uint32_t *ct) //没有CRC校验，直接读取AHT20的温度和湿度数据
{
                volatile uint8_t  Byte_1th=0;
        volatile uint8_t  Byte_2th=0;
        volatile uint8_t  Byte_3th=0;
        volatile uint8_t  Byte_4th=0;
        volatile uint8_t  Byte_5th=0;
        volatile uint8_t  Byte_6th=0;
         uint32_t RetuData = 0;
        uint16_t cnt = 0;
        AHT20_SendAC();//向AHT10发送AC命令
        Delay_1ms(80);//延时80ms左右       
    cnt = 0;
        while(((AHT20_Read_Status()&0x80)==0x80))//直到状态bit[7]为0，表示为空闲状态，若为1，表示忙状态
        {
                SensorDelay_us(1508);
                if(cnt++>=100)
                {
                 break;
                 }
        }
        I2C_Start();
        AHT20_WR_Byte(0x71);
        Receive_ACK();
        Byte_1th = AHT20_RD_Byte();//状态字，查询到状态为0x98,表示为忙状态，bit[7]为1；状态为0x1C，或者0x0C，或者0x08表示为空闲状态，bit[7]为0
        Send_ACK();
        Byte_2th = AHT20_RD_Byte();//湿度
        Send_ACK();
        Byte_3th = AHT20_RD_Byte();//湿度
        Send_ACK();
        Byte_4th = AHT20_RD_Byte();//湿度/温度
        Send_ACK();
        Byte_5th = AHT20_RD_Byte();//温度
        Send_ACK();
        Byte_6th = AHT20_RD_Byte();//温度
        Send_NOT_ACK();
        Stop_I2C();

        RetuData = (RetuData|Byte_2th)<<8;
        RetuData = (RetuData|Byte_3th)<<8;
        RetuData = (RetuData|Byte_4th);
        RetuData =RetuData >>4;
        ct[0] = RetuData;//湿度
        RetuData = 0;
        RetuData = (RetuData|Byte_4th)<<8;
        RetuData = (RetuData|Byte_5th)<<8;
        RetuData = (RetuData|Byte_6th);
        RetuData = RetuData&0xfffff;
        ct[1] =RetuData; //温度

}


void AHT20_Read_CTdata_crc(uint32_t *ct) //CRC校验后，读取AHT20的温度和湿度数据
{
                volatile uint8_t  Byte_1th=0;
        volatile uint8_t  Byte_2th=0;
        volatile uint8_t  Byte_3th=0;
        volatile uint8_t  Byte_4th=0;
        volatile uint8_t  Byte_5th=0;
        volatile uint8_t  Byte_6th=0;
        volatile uint8_t  Byte_7th=0;
         uint32_t RetuData = 0;
         uint16_t cnt = 0;
        // uint8_t  CRCDATA=0;
         uint8_t  CTDATA[6]={0};//用于CRC传递数组
       
        AHT20_SendAC();//向AHT10发送AC命令
        Delay_1ms(80);//延时80ms左右       
    cnt = 0;
        while(((AHT20_Read_Status()&0x80)==0x80))//直到状态bit[7]为0，表示为空闲状态，若为1，表示忙状态
        {
                SensorDelay_us(1508);
                if(cnt++>=100)
                {
                 break;
                }
        }
       
        I2C_Start();

        AHT20_WR_Byte(0x71);
        Receive_ACK();
        CTDATA[0]=Byte_1th = AHT20_RD_Byte();//状态字，查询到状态为0x98,表示为忙状态，bit[7]为1；状态为0x1C，或者0x0C，或者0x08表示为空闲状态，bit[7]为0
        Send_ACK();
        CTDATA[1]=Byte_2th = AHT20_RD_Byte();//湿度
        Send_ACK();
        CTDATA[2]=Byte_3th = AHT20_RD_Byte();//湿度
        Send_ACK();
        CTDATA[3]=Byte_4th = AHT20_RD_Byte();//湿度/温度
        Send_ACK();
        CTDATA[4]=Byte_5th = AHT20_RD_Byte();//温度
        Send_ACK();
        CTDATA[5]=Byte_6th = AHT20_RD_Byte();//温度
        Send_ACK();
        Byte_7th = AHT20_RD_Byte();//CRC数据
        Send_NOT_ACK();                           //注意: 最后是发送NAK
        Stop_I2C();
       
        if(Calc_CRC8(CTDATA,6)==Byte_7th)
        {
        RetuData = (RetuData|Byte_2th)<<8;
        RetuData = (RetuData|Byte_3th)<<8;
        RetuData = (RetuData|Byte_4th);
        RetuData =RetuData >>4;
        ct[0] = RetuData;//湿度
        RetuData = 0;
        RetuData = (RetuData|Byte_4th)<<8;
        RetuData = (RetuData|Byte_5th)<<8;
        RetuData = (RetuData|Byte_6th);
        RetuData = RetuData&0xfffff;
        ct[1] =RetuData; //温度
               
        }
        else
        {
                ct[0]=0x00;
                ct[1]=0x00;//校验错误返回值，客户可以根据自己需要更改
        }//CRC数据
}


void AHT20_Init(void)   //初始化AHT20
{       
        Init_I2C_Sensor_Port();
        I2C_Start();
        AHT20_WR_Byte(0x70);
        Receive_ACK();
        AHT20_WR_Byte(0xa8);//0xA8进入NOR工作模式
        Receive_ACK();
        AHT20_WR_Byte(0x00);
        Receive_ACK();
        AHT20_WR_Byte(0x00);
        Receive_ACK();
        Stop_I2C();

        Delay_1ms(10);//延时10ms左右

        I2C_Start();
        AHT20_WR_Byte(0x70);
        Receive_ACK();
        AHT20_WR_Byte(0xbe);//0xBE初始化命令，AHT20的初始化命令是0xBE,   AHT10的初始化命令是0xE1
        Receive_ACK();
        AHT20_WR_Byte(0x08);//相关寄存器bit[3]置1，为校准输出
        Receive_ACK();
        AHT20_WR_Byte(0x00);
        Receive_ACK();
        Stop_I2C();
        Delay_1ms(10);//延时10ms左右
}
void JH_Reset_REG(uint8_t addr)
{
       
        uint8_t Byte_first,Byte_second,Byte_third;
        I2C_Start();
        AHT20_WR_Byte(0x70);//原来是0x70
        Receive_ACK();
        AHT20_WR_Byte(addr);
        Receive_ACK();
        AHT20_WR_Byte(0x00);
        Receive_ACK();
        AHT20_WR_Byte(0x00);
        Receive_ACK();
        Stop_I2C();

        Delay_1ms(5);//延时5ms左右
        I2C_Start();
        AHT20_WR_Byte(0x71);//
        Receive_ACK();
        Byte_first = AHT20_RD_Byte();
        Send_ACK();
        Byte_second = AHT20_RD_Byte();
        Send_ACK();
        Byte_third = AHT20_RD_Byte();
        Send_NOT_ACK();
        Stop_I2C();
       
  Delay_1ms(10);//延时10ms左右
        I2C_Start();
        AHT20_WR_Byte(0x70);///
        Receive_ACK();
        AHT20_WR_Byte(0xB0|addr);//寄存器命令
        Receive_ACK();
        AHT20_WR_Byte(Byte_second);
        Receive_ACK();
        AHT20_WR_Byte(Byte_third);
        Receive_ACK();
        Stop_I2C();
       
        Byte_second=0x00;
        Byte_third =0x00;
}

void AHT20_Start_Init(void)
{
        JH_Reset_REG(0x1b);
        JH_Reset_REG(0x1c);
        JH_Reset_REG(0x1e);
}

使用特权

评论回复 赏
31楼
l63t89|  楼主 | 2024-1-31 14:48 | 只看该作者
头文件修改如下#ifndef _AHT20_DEMO_
#define _AHT20_DEMO_

#include "main.h"  

void Delay_N10us(uint32_t t);//延时函数
void SensorDelay_us(uint32_t t);//延时函数
void Delay_4us(void);                //延时函数
void Delay_5us(void);                //延时函数
void Delay_1ms(uint32_t t);       
void AHT20_Clock_Init(void);                //延时函数
void SDA_Pin_Output_High(void)  ; //将PB15配置为输出 ， 并设置为高电平， PB15作为I2C的SDA
void SDA_Pin_Output_Low(void);  //将P15配置为输出  并设置为低电平
void SDA_Pin_IN_FLOATING(void);  //SDA配置为浮空输入
void SCL_Pin_Output_High(void); //SCL输出高电平，P14作为I2C的SCL
void SCL_Pin_Output_Low(void); //SCL输出低电平
void Init_I2C_Sensor_Port(void); //初始化I2C接口,输出为高电平
void I2C_Start(void);                 //I2C主机发送START信号
void AHT20_WR_Byte(uint8_t Byte); //往AHT20写一个字节
uint8_t AHT20_RD_Byte(void);//从AHT20读取一个字节
uint8_t Receive_ACK(void);   //看AHT20是否有回复ACK
void Send_ACK(void)        ;          //主机回复ACK信号
void Send_NOT_ACK(void);        //主机不回复ACK
void Stop_I2C(void);          //一条协议结束
uint8_t AHT20_Read_Status(void);//读取AHT20的状态寄存器
uint8_t AHT20_Read_Cal_Enable(void);  //查询cal enable位有没有使能
void AHT20_SendAC(void); //向AHT20发送AC命令
uint8_t Calc_CRC8(uint8_t *message,uint8_t Num);
void AHT20_Read_CTdata(uint32_t *ct); //没有CRC校验，直接读取AHT20的温度和湿度数据
void AHT20_Read_CTdata_crc(uint32_t *ct); //CRC校验后，读取AHT20的温度和湿度数据
void AHT20_Init(void);   //初始化AHT20
void JH_Reset_REG(uint8_t addr);///重置寄存器
void AHT20_Start_Init(void);///上电初始化进入正常测量状态
#endif

使用特权

评论回复 赏
32楼
l63t89|  楼主 | 2024-1-31 14:48 | 只看该作者
4.3 主函数编写
打开工程的”main.c“，写入以下代码#include "main.h"
#include "dma.h"
#include "i2c.h"
#include "usart.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include<stdio.h>
#include "AHT20-21_DEMO_V1_3.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
int fputc(int ch, FILE *f)

{

  HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 0xffff);

  return ch;

}
/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
        uint32_t CT_data[2]={0,0};
        volatile int  c1,t1;
        Delay_1ms(500);
  HAL_Init();
  
  SystemClock_Config();
  MX_USART1_UART_Init();
  MX_DMA_Init();
  MX_I2C1_Init();       
  MX_USART1_UART_Init();
       
  AHT20_Init();
        Delay_1ms(500);




  while (1)
  {
   
                AHT20_Read_CTdata_crc(CT_data);  //crc校验后，读取AHT20的温度和湿度数据
       

                c1 = CT_data[0]*1000/1024/1024;  //计算得到湿度值c1（放大了10倍）
                t1 = CT_data[1]*2000/1024/1024-500;//计算得到温度值t1（放大了10倍）
                printf("正在检测");
                HAL_Delay(100);
                printf("\r\n");
                HAL_Delay(1000);
                printf("温度:%d%d.%d",t1/100,(t1/10)%10,t1%10);
                printf("湿度:%d%d.%d",c1/100,(c1/10)%10,c1%10);
                printf("\r\n");
                HAL_Delay(1000);
                printf("等待");
                HAL_Delay(100);
                printf(".");
                HAL_Delay(100);
                printf(".");
                HAL_Delay(100);
                printf(".");
                HAL_Delay(100);
                printf(".");
                HAL_Delay(100);
                printf(".");
                HAL_Delay(100);
                printf(".");
                HAL_Delay(100);
                printf(".");
                HAL_Delay(100);
                printf(".");
                HAL_Delay(100);
                printf(".");
                HAL_Delay(100);
                printf(".");
                printf("\r\n");
                HAL_Delay(1000);
  }

}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

使用特权

评论回复 赏
33楼
l63t89|  楼主 | 2024-1-31 14:48 | 只看该作者
五、烧录结果及演示
5.1 硬件连接方式
厂商给出了硬件连接方式

使用特权

评论回复 赏
34楼
l63t89|  楼主 | 2024-1-31 14:49 | 只看该作者

使用特权

评论回复 赏
35楼
l63t89|  楼主 | 2024-1-31 14:49 | 只看该作者
5.2 烧录结果

使用特权

评论回复 赏
36楼
l63t89|  楼主 | 2024-1-31 14:50 | 只看该作者
六、总结
通过本次实验，已经基本了解I2C的通信协议，了解了基本的I2C的通信模式和基本时序单元规则，如何触发、读写以及终止等指令，对老师所给的新型模块也有基本的认识与了解。虽然对具体的原理了解不深，但能够通过基本的SDA和SCL引脚对模块进行控制和读取数据。总而言之这次试验收获还是很大的，也让我觉得HAL库是越来越简单。

使用特权

评论回复 赏
12
返回列表
发新帖 我要提问
高级模式
B Color Image Link Quote Code 收费 Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则