1. Toy模板网首页
  2. > Toy博客

STM32模拟I2C协议获取HDC1080温度和湿度传感器数据

5月前 作者：PegasusYu 分类：Toy博客 阅读(56) 违法举报

这篇具有很好参考价值的文章主要介绍了STM32模拟I2C协议获取HDC1080温度和湿度传感器数据。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

STM32模拟I2C协议获取HDC1080温度和湿度传感器数据

HDC1080是一款温湿度传感器，具有如下特点：
STM32模拟I2C协议获取HDC1080温度和湿度传感器数据

STM32模拟I2C协议获取HDC1080温度和湿度传感器数据
其中温度和湿度经过出厂校准。这里介绍STM32模拟I2C总线协议访问HDC1080的HAL库实现范例。

HDC1080电路连接

HDC1080的内部原理及电路连接如下：
STM32模拟I2C协议获取HDC1080温度和湿度传感器数据
HDC1080具有低功耗特征，每次触发检测转换后进入睡眠状态，另外内部有一个加热电阻，在环境湿度高时，可以出发加热去湿度，从而增强温度检测部分的准确性。

HDC1080可以检测供电电压阀值，判断供电电压是否高于或低于2.8V，对于简单电池供电场合可以进行供电判断处理。

HDC1080寄存器说明

HDC1080有如下的一些寄存器，按作用分为读数，配置，读ID三种：
STM32模拟I2C协议获取HDC1080温度和湿度传感器数据
在触发读取温度寄存器操作时，除了会触发温度转换也会触发湿度转换，从而可以一次性将温度和湿度都读出来。

原始数据和常见格式的转换关系为：
STM32模拟I2C协议获取HDC1080温度和湿度传感器数据
STM32模拟I2C协议获取HDC1080温度和湿度传感器数据
这里采用STM32CUBEIDE开发环境，以STM32F103CBT6为例，介绍 HDC1080的访问和温湿度数据获取。

STM32工程基本配置

首先建立基本工程并初始化时钟系统：
STM32模拟I2C协议获取HDC1080温度和湿度传感器数据
STM32模拟I2C协议获取HDC1080温度和湿度传感器数据
选择两个管脚作为模拟I2C协议的管脚：
STM32模拟I2C协议获取HDC1080温度和湿度传感器数据
并配置USB虚拟串口作为打印输出接口：
STM32模拟I2C协议获取HDC1080温度和湿度传感器数据
STM32模拟I2C协议获取HDC1080温度和湿度传感器数据
STM32模拟I2C协议获取HDC1080温度和湿度传感器数据
STM32模拟I2C协议获取HDC1080温度和湿度传感器数据
保存并生成基本工程代码：
STM32模拟I2C协议获取HDC1080温度和湿度传感器数据

STM32工程代码

代码实现HDC1080访问函数，循环读取并打印出HDC1080的设备码，温度和湿度原始数据，温度和湿度的常见格式。

代码里所用的微秒延时函数，参考：STM32 HAL us delay（微秒延时）的指令延时实现方式及优化
代码里所用的浮点转字符处理函数，参考： STM32 UART串口printf函数应用及浮点打印代码空间节省 (HAL)

完整的main.c代码如下：

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2023 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.
  *
  ******************************************************************************
  */
//Written by Pegasus Yu in 2023
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "usb_device.h"

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

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
__IO float usDelayBase;
void PY_usDelayTest(void)
{
  __IO uint32_t firstms, secondms;
  __IO uint32_t counter = 0;

  firstms = HAL_GetTick()+1;
  secondms = firstms+1;

  while(uwTick!=firstms) ;

  while(uwTick!=secondms) counter++;

  usDelayBase = ((float)counter)/1000;
}

void PY_Delay_us_t(uint32_t Delay)
{
  __IO uint32_t delayReg;
  __IO uint32_t usNum = (uint32_t)(Delay*usDelayBase);

  delayReg = 0;
  while(delayReg!=usNum) delayReg++;
}

void PY_usDelayOptimize(void)
{
  __IO uint32_t firstms, secondms;
  __IO float coe = 1.0;

  firstms = HAL_GetTick();
  PY_Delay_us_t(1000000) ;
  secondms = HAL_GetTick();

  coe = ((float)1000)/(secondms-firstms);
  usDelayBase = coe*usDelayBase;
}

void PY_Delay_us(uint32_t Delay)
{
  __IO uint32_t delayReg;

  __IO uint32_t msNum = Delay/1000;
  __IO uint32_t usNum = (uint32_t)((Delay%1000)*usDelayBase);

  if(msNum>0) HAL_Delay(msNum);

  delayReg = 0;
  while(delayReg!=usNum) delayReg++;
}



/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
#define us_num 10

#define SCL_OUT_H HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_SET)
#define SCL_OUT_L HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_RESET)
#define SDA_OUT_H HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, GPIO_PIN_SET)
#define SDA_OUT_L HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, GPIO_PIN_RESET)
#define SDA_IN HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1)

void I2C_Init(void)
{
	SDA_OUT_H;
	SCL_OUT_H;
	PY_Delay_us_t(1000000) ;
}

void I2C_Start(void)
{
	PY_Delay_us_t(us_num) ;
	SDA_OUT_H;
	SCL_OUT_H;
	PY_Delay_us_t(us_num/2) ;
	SDA_OUT_L;
	PY_Delay_us_t(us_num/2) ;
	SCL_OUT_L;
}

void I2C_Stop(void)
{
	SCL_OUT_L;
	PY_Delay_us_t(us_num) ;
	SDA_OUT_L;
	PY_Delay_us_t(us_num) ;
	SCL_OUT_H;
	PY_Delay_us_t(us_num) ;
	SDA_OUT_H;
	PY_Delay_us_t(us_num) ;
}

void I2C_Write_Ack(void)
{

    PY_Delay_us_t(us_num/2) ;
	SDA_OUT_L;
	PY_Delay_us_t(us_num/2) ;
	SCL_OUT_H;
	PY_Delay_us_t(us_num) ;
	SCL_OUT_L;
	SDA_OUT_H;

}

uint8_t I2C_Read_Ack(void)
{
	uint8_t status=0;

	SCL_OUT_L;
	PY_Delay_us_t(us_num/2) ;
	SDA_OUT_H;
	PY_Delay_us_t(us_num/2) ;
	status = SDA_IN;
	SCL_OUT_H;
	PY_Delay_us_t(us_num) ;
	SCL_OUT_L;
	SDA_OUT_L;

	return status;

}


void I2C_Send_Byte(uint8_t txd)
{


    for(uint8_t i=0;i<8;i++)
    {
    	PY_Delay_us_t(us_num/2) ;
        if((txd&0x80)>>7) SDA_OUT_H;
        else SDA_OUT_L;
        txd<<=1;
        PY_Delay_us_t(us_num/2) ;
        SCL_OUT_H;
        PY_Delay_us_t(us_num) ;
		SCL_OUT_L;
    }

    SDA_OUT_L;
}

uint8_t I2C_Read_Byte(unsigned char rdack)
{
	uint8_t rxd=0;


    for(uint8_t i=0;i<8;i++ )
	{
    	SCL_OUT_L;
    	PY_Delay_us_t(us_num/2) ;
    	SDA_OUT_H;
    	PY_Delay_us_t(us_num/2) ;
    	SCL_OUT_H;
        rxd<<=1;
        if(SDA_IN) rxd++;
        PY_Delay_us_t(us_num) ;
    }

    SCL_OUT_L;
    SDA_OUT_H;

    if (rdack) I2C_Write_Ack();

    return rxd;
}
void HDC1080_WRITE_REG(uint8_t WrAddr, uint16_t data)
{
	  uint8_t daddr = 0x80; //HDC1080 device address (0x40<<1)

	  I2C_Start();
	  I2C_Send_Byte(daddr);
	  I2C_Read_Ack();
  	  I2C_Send_Byte(WrAddr);
  	  I2C_Read_Ack();
  	  I2C_Send_Byte(data>>8);
  	  I2C_Read_Ack();
  	  I2C_Send_Byte(data);
  	  I2C_Read_Ack();
  	  I2C_Stop();

}

uint16_t HDC1080_READ_REG(uint8_t RdAddr)
{
      uint8_t D[2];
	  uint8_t daddr = 0x80; //HDC1080 device address (0x40<<1)

	  I2C_Start();
	  I2C_Send_Byte(daddr);
	  I2C_Read_Ack();
  	  I2C_Send_Byte(RdAddr);
  	  I2C_Read_Ack();

  	  I2C_Start();
	  I2C_Send_Byte(daddr+1);
	  I2C_Read_Ack();
	  D[0]=I2C_Read_Byte(1);
	  D[1]=I2C_Read_Byte(0);
  	  I2C_Stop();

	  return (D[0]<<8|D[1]);
}

uint16_t HDC1080_READ_REG_DEVICE_ID(void)
{
	return HDC1080_READ_REG(0xFF);  //0x1050
}

#define Retrieve_Mode


void HDC1080_Heater_Enable(void)
{
	uint16_t reg_content;
	reg_content = HDC1080_READ_REG(0x02);
	reg_content |= 0x2000;
	HDC1080_WRITE_REG(0x02, reg_content);
}

void HDC1080_Heater_Disable(void)
{
	uint16_t reg_content;
	reg_content = HDC1080_READ_REG(0x02);
	reg_content &= 0xdfff;
	HDC1080_WRITE_REG(0x02, reg_content);
}

uint8_t HDC1080_READ_REG_Battery_Vol(void)
{
	uint16_t reg_content;
	reg_content = HDC1080_READ_REG(0x02);

	if(reg_content&0x0800) return 1; //Battery voltage < 2.8V (read only)
	else return 0; //Battery voltage > 2.8V
}

#define OP_Delay_us 20000
void HDC1080_READ_DATA(uint16_t * temperature, uint16_t * moisture)
{
	  uint8_t daddr = 0x80; //HDC1080 device address (0x40<<1)
	  uint8_t D[4];

	  I2C_Start();
	  I2C_Send_Byte(daddr);
	  I2C_Read_Ack();
	  I2C_Send_Byte(0x00);
	  I2C_Read_Ack();
	  I2C_Stop();

	  PY_Delay_us_t(OP_Delay_us); //Conversion Time, RHCT>=6.5ms for 14 bit resolution

  	  I2C_Start();
	  I2C_Send_Byte(daddr+1);
	  I2C_Read_Ack();
	  D[0]=I2C_Read_Byte(1);
	  D[1]=I2C_Read_Byte(1);
	  D[2]=I2C_Read_Byte(1);
	  D[3]=I2C_Read_Byte(0);
  	  I2C_Stop();

  	  *temperature = (D[0]<<8|D[1]);
  	  *moisture =  (D[2]<<8|D[3]);

}

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
/*
*Convert float to string type
*Written by Pegasus Yu in 2022
*stra: string address as mychar from char mychar[];
*float: float input like 12.345
*flen: fraction length as 3 for 12.345
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
void py_f2s4printf(char * stra, float x, uint8_t flen)
{
	uint32_t base;
	int64_t dn;
	char mc[32];

	base = pow(10,flen);
	dn = x*base;
	sprintf(stra, "%d.", (int)(dn/base));
	dn = abs(dn);
	if(dn%base==0)
	{
		for(uint8_t j=1;j<=flen;j++)
		{
			stra = strcat(stra, "0");
		}
		return;
	}
	else
	{
		if(flen==1){
			sprintf(mc, "%d", (int)(dn%base));
			stra = strcat(stra, mc);
			return;
		}

		for(uint8_t j=1;j<flen;j++)
		{
			if((dn%base)<pow(10,j))
			{
				for(uint8_t k=1;k<=(flen-j);k++)
				{
					stra = strcat(stra, "0");
				}
				sprintf(mc, "%d", (int)(dn%base));
				stra = strcat(stra, mc);
				return;
			}
		}
		sprintf(mc, "%d", (int)(dn%base));
		stra = strcat(stra, mc);
		return;
	}
}

/* USER CODE END PM */

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

/* USER CODE BEGIN PV */

/* USER CODE END PV */

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

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
char * degree = "°";
/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */
   uint16_t DEVID;
   char console[256];
   char fconsole[256];

   uint16_t D_T;
   uint16_t D_M;

   float F_T;
   float F_M;
  /* 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_USB_DEVICE_Init();
  /* USER CODE BEGIN 2 */
  PY_usDelayTest();
  PY_usDelayOptimize();


  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
	  DEVID = HDC1080_READ_REG_DEVICE_ID();
	  sprintf(console, "\r\nDevice ID = 0x%x\r\n", DEVID);
	  while(CDC_Transmit_FS((uint8_t* )console, strlen(console))==USBD_BUSY) PY_Delay_us_t(1);
	  PY_Delay_us_t(500000);

	  HDC1080_READ_DATA(&D_T, &D_M);
	  sprintf(console, "\r\nTemperature Read Value = 0x%x\r\nMoisture Read Value = 0x%x", D_T, D_M);
	  while(CDC_Transmit_FS((uint8_t* )console, strlen(console))==USBD_BUSY) PY_Delay_us_t(1);


	  F_T = (float)D_T*165/65536-40;
	  py_f2s4printf(fconsole, F_T, 2);
	  sprintf(console, "\r\nTemperature = %s%s", fconsole, degree);
	  while(CDC_Transmit_FS((uint8_t* )console, strlen(console))==USBD_BUSY) PY_Delay_us_t(1);
	  F_M = (float)D_M*100/65536;
	  py_f2s4printf(fconsole, F_M, 2);
	  sprintf(console, "\r\nMoisture = %s%%\r\n", fconsole);
	  while(CDC_Transmit_FS((uint8_t* )console, strlen(console))==USBD_BUSY) PY_Delay_us_t(1);

	  PY_Delay_us_t(500000);

    /* USER CODE END WHILE */

    /* 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};
  RCC_PeriphCLKInitTypeDef PeriphClkInit = {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();
  }
  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USB;
  PeriphClkInit.UsbClockSelection = RCC_USBCLKSOURCE_PLL_DIV1_5;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  {
    Error_Handler();
  }
}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};
/* USER CODE BEGIN MX_GPIO_Init_1 */
/* USER CODE END MX_GPIO_Init_1 */

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

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0|GPIO_PIN_1, GPIO_PIN_SET);

  /*Configure GPIO pins : PB0 PB1 */
  GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

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

测试效果

代码的打印输出：
STM32模拟I2C协议获取HDC1080温度和湿度传感器数据

例程下载

STM32F103模拟I2C协议获取HDC1080温湿度传感器数据例程

–End–文章来源地址https://www.toymoban.com/news/detail-511778.html

到了这里，关于STM32模拟I2C协议获取HDC1080温度和湿度传感器数据的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • stm32中的i2c协议

    stm32中的i2c协议

    协议通讯图 I2C上一个总线能挂载多个设备共用信号线，可以连接多个从机 只用了两个总线，一条双向串行数据线（SDA），一条串行时钟线(SCL)。数据线即用来表示数据，时钟线用于数据收发同步。 每个连接到总线的设备都有独立的地址，主机可以通过该地址进行访问 I2C空闲

    2024年01月22日
    浏览(25)
  • 【STM32】STM32学习笔记-I2C通信协议(31)

    【STM32】STM32学习笔记-I2C通信协议(31)

    I2C(Inter－Integrated Circuit)总线 是一种由NXP（原PHILIPS）公司开发的两线式串行总线，用于连接微控制器及其外围设备。多用于主控制器和从器件间的主从通信，在小数据量场合使用，传输距离短，任意时刻只能有一个主机等特性。 串行的 8 位双向数据传输位速率在标准模式下可

    2024年01月23日
    浏览(25)
  • STM32软件模拟I2C从机的实现方法

    STM32软件模拟I2C从机的实现方法

    在使用I2C通信时，一般会用到软件模拟I2C。目前网络上能搜索到的软件模拟I2C一般都是模拟I2C主机，很少有模拟I2C从机的例程。由于I2C主机在进行数据收发时，有明确的可预见性，也就是主机明确知道什么时候要进行数据的收发操作，而且I2C的同步时钟信号也是由主机产生的

    2024年02月01日
    浏览(15)

  • 【STM32学习】——I2C通信协议&MPU6050姿态传感器&软件I2C读写MPU6050

    ​   目录 前言 一、I2C通信协议 1.简介 2.硬件电路设计 3.I2C时序（软件）

    2024年02月16日
    浏览(22)
  • STM32 OLED显示汉字及屏幕滚动（I2C协议）

    STM32 OLED显示汉字及屏幕滚动（I2C协议）

    理解OLED屏显和汉字点阵编码原理，使用STM32F103的SPI或IIC接口实现以下功能： 显示自己的学号和姓名； 显示AHT20的温度和湿度； 上下或左右的滑动显示长字符。 STM32F103C8T6最小板 AHT20温湿度传感器 ST-LINK 仿真器 4针脚使用I2C通信协议的OLED屏 面包板 杜邦线 KEIL 5 字模软件 可以看

    2024年02月03日
    浏览(23)
  • 电脑传输数据STM32模拟I2C显示实时画面到OLED

    电脑传输数据STM32模拟I2C显示实时画面到OLED

    写的不好，还望大家指正，有的地方引用了一下大佬的代码。 一、所需硬件： STM32F103C8T6 USB转串口模块 OLED 128*64显示屏 STLINK 二、代码部分 1.stm32串口部分代码 2.stm32OLED屏幕部分代码 3.主程序 4.电脑通过opencv库截取电脑当前1080p一帧画面，并对图片二值化处理，通过电脑端编写

    2024年02月13日
    浏览(18)
  • STM32使用模拟I2C读取AS5600（深入讲解：带波形图）

    STM32使用模拟I2C读取AS5600（深入讲解：带波形图）

    首先我们要了解I2C的基本原理 当IIC处于空闲状态的时候，SDA和SCL都处于高电平状态， 当IIC通信开始信号，SCL保持高电平，SDA从高电平变成低电平（SCL=1，SDA=1-0）， 当IIC通信结束信号，SCL保持高电平，SDA从低电平变成高电平（SCL=1，SDA=0-1）。 IIC通信开始后，发送8位数据信号

    2024年02月01日
    浏览(21)
  • 基于HAL库的stm32的OLED显示屏显示（模拟I2C，四脚，0.96寸）

    基于HAL库的stm32的OLED显示屏显示（模拟I2C，四脚，0.96寸）

    参考视频：江科大oled程序移植stm32hal库，freertos学习，cpu使用率_哔哩哔哩_bilibili ​ STM32入门教程-2023持续更新中_哔哩哔哩_bilibili 高速和低速晶振均选择为陶瓷晶振即可。 不需更改初始化配置，因为模拟I2C初始化时会设置这两个引脚的电平 step1、step2完成后生成工程即可。 代

    2024年02月06日
    浏览(24)

  • STM32为基础的模拟I2C通用8bit和16bit读取以及多字节读取

    GPIO模拟I2C驱动的通用代码，I2C的寄存器地址有8位和16位的，主要解决了同一个MCU同时处理8位和16位寄存器地址芯片时候的驱动问题。 以上是结构体，作为参数，其中DevAddr是芯片地址，RegAddr是寄存器地址，data_len是写入或者读取的数据长度，data_buf是写入或者读出的数据缓冲

    2024年04月28日
    浏览(15)
  • HAL STM32 硬件I2C方式读取AS5600磁编码器获取角度例程

    HAL STM32 硬件I2C方式读取AS5600磁编码器获取角度例程

    📍相关篇《STM32 软件I2C方式读取AS5600磁编码器获取角度例程》 ✨stm32使用硬件I2C去读取角度数据，通过STM32CubeMX工具配置工程，读取角度数据，只需要调用一个函数，即可完成数据的读取。了解函数的用法以及从设备地址命令，上手十分快速和简单。 📌AS5600资料： https://p

    2024年04月26日
    浏览(30)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包