STM32基于HAL库的IIC协议读取温湿度

已于 2023-11-09 09:36:22 修改
阅读量2.3k 收藏 25
点赞数 3
分类专栏： STM32F103C8T6 文章标签： stm32 嵌入式硬件 单片机
于 2023-11-09 09:25:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63323712/article/details/134297054
版权

目录

一、解决的问题

二、12C总线通信协议

1、什么是12C协议 ：

 2、12C总线的物理层：

 3、12C总线的协议层：

 4、 I2C的两种方式——硬件I2C和软件I2C：

三、搭建STM32开发环境（HAL库环境）

四、 利用HAL库新建一个温湿度采集工程 

 五、完善keil工程

 六、电路连接与运行结果展示

1、电路连接与配置： 

2、烧录运行结果展示：

七、总结

八、参考资料 

一、解决的问题

       学习I2C总线通信协议，使用STM32F103完成基于I2C协议的AHT20温湿度传感器的数据采集，并将采集的温度-湿度值通过串口输出。具体任务：

1）解释什么是“软件I2C”和“硬件I2C”？ （阅读野火配套教材的第23章“I2C--读写EEPROM”原理章节）

2）阅读AHT20数据手册，编程实现：每隔2秒钟采集一次温湿度数据，并通过串口发送到上位机（win10）。

二、12C总线通信协议

1、什么是12C协议 ：

        I2C总线是一种双向的同步串行总线，它支持设备之间的短距离通信，经常用于处理器和一些外围设备之间的接口通信。I2C总线的标准通信速率是100Kbps，快速模式是400Kbps，高速模式支持3.4Mbps。I2C总线支持多设备的通信，而且各个设备之间的SCL和SDA线都是线与关系。I2C总线上扩展的器件的数量主要由电容负载来决定，其负载能力为400pF。I2C总线具有极低的电流消耗。

 2、12C总线的物理层：

       I2C总线物理层由两根线组成：串行时钟线SCL、串行数据线SDA。由于这两根线都是开漏输出结构，因此必须都接上拉电阻到高电平，因此当总线处于空闲状态时，两根线都处于高电平状态。下图为I2C总线的物理层示意图：

它的物理层有如下特点：
(1) 它是一个支持设备的总线。“总线”指多个设备共用的信号线。在一个 I2C 通讯总线中，可连接多个 I2C 通讯设备，支持多个通讯主机及多个通讯从机。
(2) 一个 I2C 总线只使用两条总线线路，一条双向串行数据线(SDA) ，一条串行时钟线(SCL)。数据线即用来表示数据，时钟线用于数据收发同步。

(3) 每个连接到总线的设备都有一个独立的地址，主机可以利用这个地址进行不同设备之间的访问。
(4) 总线通过上拉电阻接到电源。当 I2C 设备空闲时，会输出高阻态，而当所有设备都空闲，都输出高阻态时，由上拉电阻把总线拉成高电平。
(5) 多个主机同时使用总线时，为了防止数据冲突，会利用仲裁方式决定由哪个设备占用总线。
(6) 具有三种传输模式：标准模式传输速率为 100kbit/s ，快速模式为 400kbit/s ，高速模式下可达 3.4Mbit/s，但目前大多 I 2 C 设备尚不支持高速模式。
(7) 连接到相同总线的 IC 数量受到总线的最大电容 400pF 限制 。 

 3、12C总线的协议层：

       I2C总线上的每一个设备都可以作为主设备或者从设备，而且每一个设备都会对应一个唯一的设备地址。通常的我们将CPU模块作为主设备，而挂接在总线上的其他设备作为从设备。I2C总线上的主设备与从设备之间以8字节为单位进行双向数据传输，并且每个单位后还须跟着一位ACK位。其中数据在SCL处于低电平时被放到SDA数据线上，在SCL处于高电平时进行数据的采样。下图是I2C总线8位数据传输协议时序图。：

        其实I2C也是支持10位地址空间的。对于10位地址的传输时序，需要2个地址帧完成地址的传输，其他和8位的传输协议相同。下图为10位地址传输时序图：

       I2C 的协议定义了通讯的起始和停止信号、数据有效性、响应、仲裁、时钟同步和地址广播等环节。

  • 通讯的起始和停止信号：

        当 SCL 线是高电平时 SDA 线从高电平向低电平切换，这个情况表示通讯的起始。当 SCL 是高电平时 SDA线由低电平向高电平切换，表示通讯的停止。起始和停止信号一般由主机产生。

  •  数据有效性

        I2C使用 SDA信号线来传输数据，使用 SCL信号线进行数据同步。见图 24-6。SDA数据线在 SCL的每个时钟周期传输一位数据。传输时，SCL为高电平的时候 SDA表示的数据有效，即此时的SDA为高电平时表示数据“1”，为低电平时表示数据“0”。当SCL为低电平时，SDA的数据无效，一般在这个时候 SDA进行电平切换，为下一次表示数据做好准备。 

每次数据传输都以字节为单位，每次传输的字节数不受限制。

  • 地址及数据方向 

       12C 总线上的每个设备都有自己的独立地址，主机发起通讯时，通过 SDA 信号线发送设备地址(SLAVE_ADDRESS)来查找从机。I2C 协议规定设备地址可以是 7 位或 10 位，实际中 7 位的地址应用比较广泛。紧跟设备地址的一个数据位用来表示数据传输方向，它是 数据方向位(R/W)，第 8位或第 11位。数据方向位为“1”时表示主机由从机读数据，该位为“0”时表示主机向从机写数据.

       读数据方向时，主机会释放对 SDA 信号线的控制，由从机控制 SDA 信号线，主机接收信号，写数据方向时，SDA由主机控制，从机接收信号。

  • 响应 

        I2C 的数据和地址传输都带响应。响应包括“应答(ACK)”和“非应答(NACK)”两种信号。作为数据接收端时，当设备(无论主从机)接收到 I2C传输的一个字节数据或地址后，若希望对方继续发送数据，则需要向对方发送“应答(ACK)”信号，发送方会继续发送下一个数据；若接收端希望结束数据传输，则向对方发送“非应答(NACK)”信号，发送方接收到该信号后会产生一个停止信号，结束信号传输。 

       传输时主机产生时钟，在第 9 个时钟时，数据发送端会释放 SDA 的控制权，由数据接收端控制 SDA，若 SDA 为高电平，表示非应答信号(NACK)，低电平表示应答信号(ACK)

 4、 I2C的两种方式——硬件I2C和软件I2C：

  • 硬件I2C

        一块硬件电路，硬件I2C对应芯片上的I2C外设，有相应I2C驱动电路，其所使用的I2C管脚也是专用的，硬件（固件）I2C是直接调用内部寄存器进行配置直接利用 STM32 芯片中的硬件 I2C 外设。

硬件I2C的使用
       只要配置好对应的寄存器，外设就会产生标准串口协议的时序。在初始化好 I2C 外设后，只需要把某寄存器位置 1，此时外设就会控制对应的 SCL 及 SDA 线自动产生 I2C 起始信号，不需要内核直接控制引脚的电平。

  • 软件I2C

       软件IIC 软件IIC通信指的是用单片机的两个I/O端口模拟出来的IIC，用软件控制管脚状态以模拟I2C通信波形，软件模拟寄存器的工作方式。直接使用 CPU 内核按照 I2C 协议的要求控制 GPIO 输出高低电平，从而模拟I2C。

软件I2C的使用
       需要在控制产生 I2C 的起始信号时，控制作为 SCL 线的 GPIO 引脚输出高电平，然后控制作为 SDA 线的 GPIO 引脚在此期间完成由高电平至低电平的切换，最后再控制SCL 线切换为低电平，这样就输出了一个标准的 I2C 起始信号。

  • 两者的差别

       硬件 I2C 直接使用外设来控制引脚，可以减轻 CPU 的负担。不过使用硬件I2C 时必须使用某些固定的引脚作为 SCL 和 SDA，软件模拟 I2C 则可以使用任意 GPIO 引脚，相对比较灵活。对于硬件I2C用法比较复杂，软件I2C的流程更清楚一些。如果要详细了解I2C的协议，使用软件I2C可能更好的理解这个过程。在使用I2C过程，硬件I2C可能通信更加快，更加稳定。

注：本次实验通过软件I2C模拟实现！！！

三、搭建STM32开发环境（HAL库环境）

 请参考我的这篇博客：STM32使用HAL库点亮流水灯-CSDN博客

四、 利用HAL库新建一个温湿度采集工程 

（1）打开STM32CubeMX，在主界面点击：ACCESS TO MCU SELECTOR:

（2）选择的单片机型号以及点击开始工程项目：  

 （3）配置时钟，进入上面的RCC，有两个时钟，一个是hse和lse，将hse那里设Crystal/Ceramic Resonator：

（4）点击system core，进入SYS，在debug下选择serial wire： 

 （5）配置USART1，我们使用USART1进行数据传输：

（6）I2C配置： 

 （7）NIVC配置，如下图所示：

 （8）GPIO配置，配置PC13，如下图所示：

（9）进入CLK Configuration (时钟配置)中，进行时钟配置 ：

（10）进入Project Manager(工程管理)，进行工程设置点击生成工程与代码。注意：路径不能包含中文和空格，不然生成的工程文件无法在Keil中打开；

 五、完善keil工程

（1） 去奥松官网下载AHT20芯片代码与芯片的相关信息介绍文档：
http://www.aosong.com/class-36-2.html

官方代码使用的是PB14,PB15引脚，需要修改引脚为PB6,PB7 才可以正常使用。

（2）进入到下载的AHT20芯片代码文件夹中，复制如图所示两个C语言代码文件：

（3）找到刚刚利用HAL库生成的工程文件，在其中找到Core文件夹下的Inc文件夹，并且进入其中 ，将AHT20-21_DEMO_V1_3.h复制在此Inc文件夹下：

（4）找到刚刚利用HAL库生成的工程文件，在其中找到Core文件夹下的Src文件夹，并且进入其中 ，将AHT20-21_DEMO_V1_3.c复制在此Src文件夹下：

（5）进入到 keil5工程文件中，双击如图所示处进行添加AHT20-21_DEMO_V1_3.c文件：

接着在弹出的框中，按下图所示进行操作： 

添加结果，可以看到已经成功添加进来了：

（6）双击打开main.c和AHT20-21_DEMO_V1_3.c文件，按下图所示进行操作同时打开AHT20-21_DEMO_V1_3.h头文件：

 （7）重写main.c文件代码，完整代码如下：

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2022 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#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);    
		//等待发送结束	
		while(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_TC)!=SET){
		}		

    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)
{
  /* USER CODE BEGIN 1 */
	uint32_t CT_data[2]={0,0};
	volatile int  c1,t1;
	Delay_1ms(500);
  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  
  MX_USART1_UART_Init();
  MX_DMA_Init();
  MX_I2C1_Init();	
  MX_USART1_UART_Init();
	
  /* USER CODE BEGIN 2 */
  AHT20_Init();
	Delay_1ms(500);

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */
		//AHT20_Read_CTdata(CT_data);       //不经过CRC校验，直接读取AHT20的温度和湿度数据    推荐每隔大于1S读一次
		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(".");
//		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);
		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");
		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);
    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

/**
  * @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 */

（8）修改AHT20-21_DEMO_V1_3.c代码，完整文件代码如下：

/*******************************************/
/*@版权所有：广州奥松电子有限公司          */
/*@作者：温湿度传感器事业部                */
/*@版本：V1.2                              */
/*******************************************/
//#include "main.h" 
#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);
}

 （9）修改AHT20-21_DEMO_V1_3.h代码，完整文件代码如下：

#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

 六、电路连接与运行结果展示

1、电路连接与配置： 

（1）温湿度采集模块AHT20与STM32的连接如下图所示： 

这里附上AHT20的引脚简介图：

 （2）USB转TTL在电脑上的配置以及与STM32的连接参考我的这篇博客：

STM32使用HAL库中断控制串口通信-CSDN博客

 （3）连接好的电路实物图如下所示：

2、烧录运行结果展示：

七、总结

        通过本次实验，详细了解并且实践了I2C总线协议，以及AHT20温湿度传感器的使用，受益匪浅。I2C总线上允许连接多个微处理器以及各种外围设备，如存储器、LED及LCD驱动、A/D及D/A转换器等。为了保证数据可靠地传送，任一时刻总线只能由某一台主机控制，各微处理器应该在总线空闲时发送数据。

       自己在每做一次STM32的实践或者实验，或者说每更一篇STM32的博客，都是在边学边做边进步的路上。希望阅读本文的你也也也是一样。 完！！！

八、参考资料 

1、stm32通过I2C接口实现温湿度（AHT20）的采集_aht21能够检测室内温度-CSDN博客

2、 STM32F103通过IIC协议实现温湿度（AHT20）的采集_aht20例程_Justinlevy的博客-CSDN博客

3、STM32F103基于I2C协议的AHT20温湿度传感器的数据采集_dht20程序_醉意丶千层梦的博客-CSDN博客 

4、【精选】【嵌入式15】I2C总线通信协议及实操stm32通过I2C实现温湿度（AHT20）采集_xcom读取i2c_噗噗的罐子的博客-CSDN博客 

STM32用HAL库函数实现硬件IIC
qq_59757948的博客
04-26 4076
这篇笔记我主要介绍代码实现，想要了解原理的请自己看视频，我不过多赘述了。
STM32的HAL库模拟IIC
STcien的博客
05-19 1835
一.代码分析 /* *延时nus *入口参数： * nus:要延时的us数 */ void delay_us(uint32_t nus); /* *延时nms *入口参数： * nms:要延时的ms数 */ void delay_ms(uint32_t nms); /* * IIC1 GPIO 初始化 * SCL——PB6 * SDA——PB7 */ void IIC1_Init(void) { GPIO_InitTypeDef GPIO_InitStruct = {0}; __
【STM32】AT24C256硬件I2C读写，基于HAL库
我的博客
10-15 7381
STM32F103C8T6单片机使用HAL库配合CubeMX对AT24C256模块进行读写，存储容量256Kb即32KB（32K字节）。模块的原理图如下驱动协议是IIC，考虑开启硬件IIC进行通信，笔者选择使用IIC2。
STM32 HAL库I2C函数使用详解
最新发布
duierrorshuobu的博客
03-15 838
I2C（Inter-Integrated Circuit）是一种串行通信协议，由飞利浦公司开发，用于在多个集成电路（IC）之间进行通信。它使用两根线：串行数据线（SDA）和串行时钟线（SCL），具有接口简单、占用引脚少、通信速率适中等优点，广泛应用于各种电子设备中。STM32微控制器内置了I2C外设，通过HAL库可以方便地实现I2C通信。初始化函数：用于配置I2C外设的参数，如时钟速度、地址模式等。数据传输函数：用于在主设备和从设备之间进行数据的读写操作。中断处理函数。
STM32HAL库--IIC实验(速记版)
荒野
06-26 1305
IIC(Inter-Integrated Circuit)总线是一种由 PHILIPS 公司开发的两线式串行总线，用于连接微控制器以及其外围设备。IIC 是由数据线 SDA和时钟线 SCL构成的串行总线。IIC 总线有如下特点：① 数据线用来传输数据，时钟线用来同步数据收发。② 总线上每个器件都有唯一器件地址，只需知道器件地址，根据时序即可实现微控制器与器件之间的通信。③ 数据线 SDA 和时钟线 SCL都是双向线路空闲时都是 SDA 和 SCL 都是高电平。
stm32-HAL库IIC通信-at24c02
Hrilug的博客
11-15 2930
若配置的方向传输位为“写数据” 方向，即图22-2的情况，广播完地址，接收到应答 信号后，主机开始正式向从机传输数据(DATA)，数据包的大小为8 位。若配置的方向传输位为 “读数据” 方向，即图22-3的情况，广播完地址，接收到应答信 号后，从机开始向主机返回数据，数据包大小也 8 位。在PC总线上，每个设备的地址都是唯一的，当主机广播的地址与某个设备地 址相同时，这个设备就被选中了，没被选中的设备将会忽略之后的数据信号。该位为1时，则相反，即主机由从机读取数据。就因为这个折腾我好久！
STM32 (基于HAL库) 硬件IIC读写任意AT24CXX芯片
weixin_56565733的博客
04-25 9609
HAL任意AT24Cxx芯片读写： 原理我就不讲了，直接实操： 一、配置 1、使用STM32CUBEMX进行引脚配置，IIC配置如下： 2、利用串口进行数据查看，串口配置如下： 3、时钟我们选择最高72MHZ，这里没有硬性要求都可以。 4、配置完成，生成keil工程代码即可。 到此配置完成。 二、代码 编写驱动文件： HAL_24CXX.c文件代码如下： /*********************************** 适用范围：仅HAL适用 ***********************
STM32基于IIC协议读取温湿度数据
Yokuershi的博客
11-07 283
I2C"是一种常见的串行通信协议，用于在不同的集成电路（IC）之间传输数据。有两种主要的I2C实现方式，即"软件I2C"和"硬件I2C”，它们在通信方式和实现方式上有所不同。此次实验内容为通过STM32微控制器使用I2C协议读取与AHT20温湿度传感器连接的温度和湿度数据。在连接硬件时，务必小心，确保正确接线，防止损坏设备。在代码编写中，注意I2C通信的初始化和配置，以确保通信的顺利进行。根据AHT20传感器的数据手册，正确解析温湿度数据。
0048基于STM32F103单片机IIC读取AHT10温湿度传感器值的程序代码.rar
12-27
1、STM32F103通过IIC接口与AHT10温湿度传感器进行通讯，读取传感器温湿度值。 2、代码使用KEIL开发，当前在STM32F103C8T6运行，如果是STM32F103其他型号芯片，依然适用，请自行更改KEIL芯片型号以及FLASH容量即可。 ...
STM32基于IIC的温湿度读取以及OLED显示
bibido_的博客
12-13 1186
I2C总线是一种半双工（Half-Duplex）协议，意味着数据在任何时刻只能单向传输。双线制通信：SDA（数据线）和SCL（时钟线）。主从结构：I2C总线可以支持多个设备，其中一个设备作为主设备（Master），控制时钟线，其他设备为从设备（Slave）。地址分配：每个I2C设备都有一个唯一的地址，通常为7位或10位。同步传输：主设备控制SCL线的时钟信号，确保数据传输按时序进行。I2C协议是一个简单、灵活的串行总线通信协议，广泛应用于嵌入式系统中的低速设备通信。
stm32 IIC协议读取温湿度数据
m0_74103610的博客
12-16 900
IIC也称I2C，是一个多主从的串行总线，由飞利浦公司发明的通讯总线，属于半双工同步传输类总线，仅由两条线就能完成多机通讯，一条SCL时钟线，另外一条双向数据线SDA，IIC总线要求每个设备SCL/SDA线都是漏极开路模式，因此必须带上拉电阻才能正常工作。I2C协议占用引脚少，硬件实现简单，可扩展性强，I2C数据传输速率有标准模式(100kbps)、快速模式(400kbps)和高速模式(3.4Mbps)。
IO口模拟IIC实现STH2x温度采集（基于STM32F4 HAL库）
08-28
基于STM32F4芯片HAL库，main中创建任务sht_task，如果没有使用系统，可以把sht_task任务直接改成main函数。 实际用的SHT20，本来想用主机模式采集温度，没调通，后来改成非主机模式采集温度了。 这不是完整工程。
STM32HAL_BH1750驱动_模拟IIC
04-24
基于HAL库的BH1750驱动代码，通讯方式为模拟IIC，非常适合在使用hal库的stm开发版上移植（仅需改IO）
STM32 HAL库 硬件I2C对MPU6050的使用
11-02
通过STM32 Cubermx 实现 硬件I2C对MPU6050的操作，包括DMP的移植，程序代码注释详细，有部分程序代码摘录于正点原子的函数， 基于STM32F407ZG 芯片开发
stm32l051 温湿度传感器接入HAL库
08-08
在本项目中，我们将使用STM32L051与AM231X温湿度传感器进行通信，通过HAL库实现模拟IIC（Inter-Integrated Circuit）总线，从而读取并显示传感器数据。 首先，我们需要了解HAL库。HAL库是ST公司为STM32微控制器设计...
第六节：STM32基于HAL库的IIC通信
热门推荐
Kevin_8_Lee的博客
04-19 1万+
STM32 IIC通信； CubeMX配置, HAL库， IAR或者Keil编程 CubeMX系列使用经验分享
STM32 HAL库IIC驱动
Setul
12-02 4818
关于STM32的IIC驱动，网上有很多争论，究竟是使用STM32自带的硬件IIC还是用IO口和软件模拟IIC呢？下面这个图形象展示了这些争论。总结一些：ST为了规避IIC硬件的专利问题，将其设计地有点复杂，但是其提供的标准驱动库并没有很好地适配，导致出现一些BUG。但是下图中那位叫theuit的网友指出了：**“难道ST不知道吗？到底有没有改呢？”**目前，至少从我测试的结果来看，可以得到结论：用HAL库来驱动ST的IIC没问题！ 首先，我们给出两种IIC器件。 第一种是带器件中带有寄存器的一类，对这
STM32 HAL库--IIC协议读取温湿度数据
Dylan_hs的博客
11-12 468
使用STM32F103完成基于I2C协议的AHT20温湿度传感器的数据采集，并将采集的温度-湿度值通过串口输出。
stm32的hal库软件模拟iic通信学习（以M24C02/AT24C02为例） 从数据手册到配置到代码看这一个就够啦
qq_64777806的博客
03-05 2745
关于iic的概念我就不多说了，csdn很多资料。我将讲述英语不会的情况下如何查看英文的手册从原理到代码一步一步记录如何与芯片进行通信。在阅读本篇文章时，请去学习iic的通信规范，不然比较难懂。
stm32f103c8t6 hal库硬件IIC配置例程
02-27
<think>好的，用户需要了解STM32F103C8T6使用HAL库配置硬件IIC的例程。首先，我得回忆一下STM32的硬件IIC配置步骤。HAL库虽然简化了操作，但配置步骤还是有几个关键点需要注意的，比如GPIO初始化、IIC参数设置、时钟配置等。 用户可能已经有一定的STM32开发经验，但可能在使用硬件IIC时遇到了问题，比如通信失败或者配置错误。常见的硬件IIC问题包括引脚配置错误、时钟速度设置不当、中断或DMA配置问题等。因此，在回答中需要详细说明每个步骤，确保用户能够正确配置。 接下来要考虑用户可能使用的开发环境，比如STM32CubeMX，这会大大简化配置过程。但用户可能需要手动编写代码的部分，所以需要提供代码示例，并解释每个函数的作用。例如，HAL_I2C_Init()函数可能会检查硬件是否就绪，需要确保返回值为HAL_OK。 另外，硬件IIC在实际应用中常用来连接传感器或其他外设，比如EEPROM或OLED屏幕。用户可能需要了解如何发送和接收数据，所以需要给出基本的读写函数示例，比如HAL_I2C_Master_Transmit和HAL_I2C_Master_Receive，并说明参数的含义。 还需要提醒用户注意常见的错误，比如上拉电阻是否正确连接，时钟频率是否匹配从设备的要求，以及地址设置是否正确（7位地址需要左移一位）。此外，HAL库的IIC函数可能因为超时导致问题，建议用户在使用时检查超时设置，或者考虑使用中断或DMA方式提高效率。 最后，要确保提供的代码经过验证，避免用户直接复制后无法运行。可能需要提到如果遇到问题，应该检查硬件连接，使用逻辑分析仪或示波器抓取信号，以及查阅STM32的参考手册和HAL库文档。总结来说，回答需要结构清晰，步骤明确，涵盖配置、初始化和基本使用，同时指出常见问题和解决方法，帮助用户顺利实现硬件IIC功能。</think>以下是基于STM32F103C8T6和HAL库的硬件IIC配置步骤及示例代码： --- ### **1. CubeMX配置** **步骤说明：** 1. 打开STM32CubeMX，新建工程选择STM32F103C8T6 2. 配置时钟源： - 外部高速晶振（HSE）8MHz - 系统时钟设置为72MHz（需在Clock Configuration中配置） 3. 配置I2C接口： - 选择I2C1模式为"I2C" - 设置SCL引脚（默认PB6）、SDA引脚（默认PB7） 4. 参数配置： - Timing Configuration选择"Standard Mode"（默认100kHz） - 或手动设置寄存器值：0x2000090E（推荐） 5. 生成代码时选择HAL库 --- ### **2. 代码实现** **初始化配置示例：** ```c // I2C句柄声明 I2C_HandleTypeDef hi2c1; void MX_I2C1_Init(void) { hi2c1.Instance = I2C1; hi2c1.Init.ClockSpeed = 100000; // 100kHz hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2; hi2c1.Init.OwnAddress1 = 0; // 主模式无需设置从地址 hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT; hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE; hi2c1.Init.OwnAddress2 = 0; hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE; hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE; if (HAL_I2C_Init(&hi2c1) != HAL_OK) { Error_Handler(); } } ``` **GPIO自动配置（通过CubeMX生成）** --- ### **3. 常用API函数** ```c // 主设备发送数据 HAL_I2C_Master_Transmit(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size, uint32_t Timeout); // 主设备接收数据 HAL_I2C_Master_Receive(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size, uint32_t Timeout); // 带内存地址的读取（常用于EEPROM） HAL_I2C_Mem_Read(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint8_t *pData, uint16_t Size, uint32_t Timeout); ``` --- ### **4. 典型应用示例（以AT24C02 EEPROM为例）** ```c #define EEPROM_ADDRESS 0xA0 // 7位地址左移1位 + 写标志位 // 写入数据 uint8_t writeBuf[2] = {0x00, 0x55}; // 地址0x00写入0x55 HAL_I2C_Master_Transmit(&hi2c1, EEPROM_ADDRESS, writeBuf, 2, 100); // 读取数据 uint8_t readData; HAL_I2C_Mem_Read(&hi2c1, EEPROM_ADDRESS, 0x00, I2C_MEMADD_SIZE_8BIT, &readData, 1, 100); ``` --- ### **5. 注意事项** 1. **硬件连接**：必须外接4.7kΩ上拉电阻（SCL和SDA线） 2. **地址格式**：HAL库使用完整的8位地址（7位地址左移1位） 3. **时序问题**：若通信失败可尝试： - 降低时钟频率（如改为50kHz） - 调整I2C_TIMING寄存器值 4. **超时处理**：合理设置Timeout参数或使用中断/DMA模式 5. **复位处理**：通信异常时调用`HAL_I2C_DeInit()`和`HAL_I2C_Init()`复位I2C外设 --- ### **调试建议** 1. 使用逻辑分析仪抓取I2C波形 2. 检查返回状态： ```c if(HAL_I2C_GetError(&hi2c1) != HAL_I2C_ERROR_NONE){ // 错误处理 } ``` 3. 参考手册重点关注：I2C状态寄存器（SR1/SR2）和CR1/CR2寄存器配置 完整工程建议通过CubeMX生成后添加应用逻辑，可有效避免底层配置错误。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值