top of page
Search

Interfacing AHT25 Temperature and Humidity sensor with STM32F407

Updated: Oct 4, 2024

AHT25 sensor

The AHT25 is a digital temperature and humidity sensor which communicates with microcontrollers using the I2C protocol.


Technical parameters

Supply voltage

DC : 2.2 - 5.5V

Measuring range (humidity)

0 ~ 100% RH

Measuring range (temperature)

-40 ~ + 80 ℃

Humidity accuracy

± 2 % RH ( 25 ℃ )

Temperature accuracy

± 0.3 ℃

Resolution

temperature: 0.01℃ Humidity: 0.024%RH

Output signal

I2C signal

How Does the AHT25 Work?

The AHT25 measures both temperature and humidity using MEMS semiconductor capacitive humidity sensor element and a standard temperature sensor element.

The sensor outputs the results via a digital I2C interface in a combined 6-byte data frame, which consists of:

  • 20 bits for humidity data.

  • 20 bits for temperature data.

  • 1 byte for CRC validation.


Steps to take reading from the sensor


  • After the transmission is started, the first byte of the I2C transmission is the 7-bit I2C device address 0x38 and an SDA direction bit x (read R: ‘1’, write W: ‘0’).

  •  Provide soft reset by sending the command 0xBA to clear all the bits.

  • Wait for a minimum of 100ms.

  • Next get a byte (8 bits) of status word by sending 0x71. If the status word AND(&) 0x18 are not equal to 0x18, initialize the 0x1B, 0x1C, 0x1E registers refering to the official website.

#define AHT25_ADDRESS		(0x38 << 1U) //I2C 7bit Address
#define AHT25_RESET		(0xBA)	    //Reset command
#define AHT25_INIT_CMD		(0x71)	    //Initialization command

uint8_t status = 0; //Variable to store the status

//soft reset
HAL_I2C_Master_Transmit(&hi2c1, AHT25_ADDRESS, (uint8_t*) AHT25_RESET, 1,100);

//Wait for a minimum of 100ms
HAL_Delay(100);

//Get a byte (8 bits) of status word by sending 0x71
HAL_I2C_Master_Transmit(&hi2c1, AHT25_ADDRESS, (uint8_t*) AHT25_INIT_CMD, 1,100);

//check whether status AND 0x18 is equal to 0x18
HAL_I2C_Master_Receive(&hi2c1, AHT25_ADDRESS, &status, 1, 100);
if ((status & 0x18) == 0x18) {
printf("Initialization successful.\r\n");
}
else
{
	printf("Initialization Failed.Initialize the 0x1B, 0x1C and 0x1E registers.\r\n");
}

  • Wait for 10ms, then send 0xAC command (trigger measurement). This command parameter has two bytes, the first byte is 0x33, and the second byte is 0x00.

//Array with trigger command and other command bytes
uint8_t trigger_cmd[3] = { 0xAC, 0x33, 0x00 }; 

//Wait for 10ms
HAL_Delay(10);

//send 0xAC command (trigger measurement) along with the other bytes
HAL_I2C_Master_Transmit(&hi2c1, AHT25_ADDRESS, trigger_cmd, 3, 100);

  • Wait 80ms for the measurement to be completed, if the read status word Bit [7] is 0, it means the measurement is completed, and then six bytes can be read continuously; otherwise, continue to wait.

//Wait for 80ms
HAL_Delay(80);

//Read status byte
HAL_I2C_Master_Receive(&hi2c1, AHT25_ADDRESS, &status, 1, 100);

//check if 7th bit is 0, if its 1 read the status bit inside infinitely
while ((status & (1 << 7))) {
	HAL_I2C_Master_Receive(&hi2c1, AHT25_ADDRESS, &status, 1, 100);
}

  • If the measurement is completed the sensor sends 6 bytes of data.The first 20 bits is for Humidity, next twenty bits is for temperature and the remaining 8 bits is for CRC calculation.


  • We will be storing the 6 bytes in an array and we will extract the bits according to the above mentioned.

//array for storing the 6 bytes
uint8_t raw_reading[6];

//variables to store the raw values of humidity and temperature.
uint32_t raw_humidity;
uint32_t raw_temperature;

// Temporary variable for intermediate processing
uint8_t temp_val;

// Receive 6 bytes of data from the AHT25 sensor
HAL_I2C_Master_Receive(&hi2c1, AHT25_ADDRESS, raw_reading, 6, 100);


// The first byte (raw_reading[0]) contains the status and is not used for temperature/humidity calculation.


// Start processing humidity data from the second byte (humidity high byte)
raw_humidity = raw_reading[1];    

// Shift and combine with the third byte (humidity low byte)
raw_humidity = (raw_humidity << 8) | raw_reading[2];  

// Extract the upper 4 bits of the fourth byte (humidity fraction)
temp_val = raw_reading[3] & 0xF0;             
  
// Shift and add the fraction bits to complete the humidity data
raw_humidity = (raw_humidity << 4) | (temp_val >> 4); 

// Extract the lower 4 bits of the fourth byte (temperature high byte)
temp_val = raw_reading[3] & 0x0F;  



// Start temperature data processing with the extracted bits
raw_temperature = temp_val;                   
  
// Shift and combine with the fifth byte (temperature mid byte)
raw_temperature = (raw_temperature << 8) | raw_reading[4];  
  
// Shift and combine with the sixth byte (temperature low byte)
raw_temperature = (raw_temperature << 8) | raw_reading[5];

  • After receiving six bytes, the next byte is the CRC check data. The user can read it out as needed.

  • If the receiving end needs CRC check, an ACK will be sent after the sixth byte is received otherwise send NACK to end, the initial value of CRC is 0XFF, and the CRC8 check polynomial is: 

CRC[7:0] = 1 + X^4 + X^5 + X^8

  • CRC is not implemented in this tutorial.


  • Calculate the temperature and humidity value uisng the below formula.

//Humidity calculation from raw value
humidity = (raw_humidity / 1048576.0) * 100.0;

//Temperature calculation from raw value
temperature = (((raw_temperature / 1048576.0) * 200.0) - 50.0);

Full Source Code


/* USER CODE BEGIN Header */
/**
 ******************************************************************************
 * @file           : main.c
 * @brief          : Main program body
 ******************************************************************************
 * @attention
 *
 * Copyright (c) 2024 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.
 *
 *
 * 7bit Address				-	0011 1000	-	0x38
 * Initialization Command		-	1110 001		-	0x71
 * Trigger Measurement			-	1010 1100 	- 	0xAC
 * Soft Reset					- 	1011 1010 	- 	0xBA
 * PB6 						- 	SCL
 * PB7 						- 	SDA
 *
 *
 ******************************************************************************
 */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"

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

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

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

#define AHT25_ADDRESS		(0x38 << 1U)
#define AHT25_RESET		(0xBA)
#define AHT25_INIT_CMD		(0x71)

/* USER CODE END PD */

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

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
I2C_HandleTypeDef hi2c1;

/* USER CODE BEGIN PV */

uint8_t trigger_cmd[3] = { 0xAC, 0x33, 0x00 };
uint8_t status = 0;
uint8_t raw_reading[6];
float temperature, humidity;
uint32_t raw_humidity;
uint32_t raw_temperature;

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_I2C1_Init(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 */

	/* 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_GPIO_Init();
	MX_I2C1_Init();
	/* USER CODE BEGIN 2 */

	HAL_I2C_Master_Transmit(&hi2c1, AHT25_ADDRESS, (uint8_t*) AHT25_RESET, 1,100);
	HAL_Delay(100);
	HAL_I2C_Master_Transmit(&hi2c1, AHT25_ADDRESS, (uint8_t*) AHT25_INIT_CMD, 1,100);
	HAL_I2C_Master_Receive(&hi2c1, AHT25_ADDRESS, &status, 1, 100);
	if ((status & 0x18) == 0x18) {
		printf("Initialization successful.\r\n");

	} else {
		printf("Initialization Failed.Initialize the 0x1B, 0x1C and 0x1E registers.\r\n");
	}

	/* USER CODE END 2 */

	/* Infinite loop */
	/* USER CODE BEGIN WHILE */
	while (1) {
		/* USER CODE END WHILE */

		/* USER CODE BEGIN 3 */

		HAL_Delay(10);
		HAL_I2C_Master_Transmit(&hi2c1, AHT25_ADDRESS, trigger_cmd, 3, 
.100);

		HAL_Delay(80);
		HAL_I2C_Master_Receive(&hi2c1, AHT25_ADDRESS, &status, 1, 100);

		while ((status & (1 << 7))) {
			HAL_I2C_Master_Receive(&hi2c1, AHT25_ADDRESS, &status, 1, 100);
		}

		HAL_I2C_Master_Receive(&hi2c1, AHT25_ADDRESS, raw_reading, 6, 100);
		uint8_t temp_val;
		raw_humidity = raw_reading[1];
		raw_humidity = (raw_humidity << 8) | raw_reading[2];
		temp_val = raw_reading[3] & 0xF0;
		raw_humidity = (raw_humidity << 4) | (temp_val >> 4);

		temp_val = raw_reading[3] & 0x0F;
		raw_temperature = temp_val;
		raw_temperature = (raw_temperature << 8) | (raw_reading[4]);
		raw_temperature = (raw_temperature << 8) | (raw_reading[5]);

		humidity = (raw_humidity / 1048576.0) * 100.0;
		temperature = (((raw_temperature / 1048576.0) * 200.0) - 50.0);
		printf("Humidity : %f \r\n", humidity);
		printf("Temperature : %f \r\n\n", temperature);

		HAL_Delay(2000);
	}
	/* USER CODE END 3 */
}

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

	/** Configure the main internal regulator output voltage
	 */
	__HAL_RCC_PWR_CLK_ENABLE();
	__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

	/** Initializes the RCC Oscillators according to the specified parameters
	 * in the RCC_OscInitTypeDef structure.
	 */
	RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
	RCC_OscInitStruct.HSIState = RCC_HSI_ON;
	RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
	RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
	RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
	RCC_OscInitStruct.PLL.PLLM = 8;
	RCC_OscInitStruct.PLL.PLLN = 168;
	RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
	RCC_OscInitStruct.PLL.PLLQ = 7;
	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_DIV4;
	RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;

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

/**
 * @brief I2C1 Initialization Function
 * @param None
 * @retval None
 */
static void MX_I2C1_Init(void) {

	/* USER CODE BEGIN I2C1_Init 0 */

	/* USER CODE END I2C1_Init 0 */

	/* USER CODE BEGIN I2C1_Init 1 */

	/* USER CODE END I2C1_Init 1 */
	hi2c1.Instance = I2C1;
	hi2c1.Init.ClockSpeed = 100000;
	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();
	}
	/* USER CODE BEGIN I2C1_Init 2 */

	/* USER CODE END I2C1_Init 2 */

}

/**
 * @brief GPIO Initialization Function
 * @param None
 * @retval None
 */
static void MX_GPIO_Init(void) {
	/* USER CODE BEGIN MX_GPIO_Init_1 */
	/* USER CODE END MX_GPIO_Init_1 */

	/* GPIO Ports Clock Enable */
	__HAL_RCC_GPIOA_CLK_ENABLE();
	__HAL_RCC_GPIOB_CLK_ENABLE();

	/* USER CODE BEGIN MX_GPIO_Init_2 */
	/* USER CODE END MX_GPIO_Init_2 */
}

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

Comments

bottom of page