IIC协议读取温湿度数据

已于 2023-11-15 17:27:56 修改
阅读量98 收藏
点赞数
文章标签： stm32 嵌入式硬件
于 2023-11-15 17:24:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72338354/article/details/134424284
版权

一、引言
随着物联网技术的快速发展，对环境参数的监测变得越来越重要。其中，温度和湿度是两个最基本的参数，对于许多应用来说，实时监测并控制这些参数是至关重要的。基于I2C协议的AHT20温湿度传感器是一款高精度、低功耗的传感器，广泛应用于各种环境监测系统中。本文旨在探讨基于I2C协议的AHT20温湿度传感器的数据采集实验，并总结实验结果。
二、实验目标
本次实验的目标是探究基于I2C协议的AHT20温湿度传感器如何实现数据采集，并通过编程实现对传感器数据的读取和处理。我们希望通过这次实验，能够深入理解温湿度传感器的工作原理及使用方法，掌握I2C协议的基础知识和应用，提升我们的实践能力和解决问题的能力。
三、实验原理
AHT20温湿度传感器是基于I2C协议的一款数字传感器，可以将温度和湿度转换成数字信号，通过I2C总线与主机设备进行通信。传感器具有高精度、低功耗、抗干扰能力强等优点。通过编程，我们可以读取传感器发送的数字信号，并转换为温度和湿度的实际值。
在这里插入图片描述

STM32的硬件IIC和软件IIC都可以用来实现IIC通信，但它们有一些不同之处。
一、简单比较
A、硬件IIC
硬件IIC是由STM32内部的硬件模块实现的，使用CPU的时钟信号来控制数据传输和时序，通信速度较快，可以达到几十MHz的速度。硬件IIC的实现相对简单，无需编写复杂的代码，因此在实现IIC通信时，硬件IIC通常是首选的方式。硬件IIC的主要优点有：
1、速度快，可以实现高速通信；
2、实现简单，无需编写复杂的代码；
3、稳定性好，不容易出现通信错误。
B、软件IIC
软件IIC是由CPU的GPIO模拟实现的，通过CPU的软件来控制时序和数据传输，通信速度相对较慢，一般在几十kHz到几百kHz之间。软件IIC的实现相对复杂，需要编写复杂的代码，因此在实现IIC通信时，软件IIC通常是在硬件IIC无法满足需求时才采用的方式。软件IIC的主要优点有：
1、可以实现多路IIC通信，硬件IIC一般只能实现单路通信；
2、可以在STM32的任何GPIO上实现IIC通信，相对灵活；
3、可以实现任意时序，更加灵活。
总的来说，硬件IIC和软件IIC各有优缺点，选择哪种方式要根据具体的应用需求进行选择。如果需要高速通信，建议选择硬件IIC；如果需要多路通信或者灵活的时序控制，建议选择软件IIC。
二、各自实现方式
A、硬件IIC
在这里插入图片描述

实现硬件IIC的代码需要使用STM32的内部硬件模块
具体步骤如下：
配置GPIO用于IIC通信，将SCL和SDA引脚分别配置为复用推挽输出模式；
配置I2C控制器，包括I2C时钟频率、I2C地址、I2C工作模式等参数；启动I2C控制器，并发送数据或接收数据。
B、软件IIC
实现软件IIC的代码需要通过GPIO模拟IIC时序，具体步骤如下：
配置GPIO用于IIC通信，将SCL和SDA引脚分别配置为推挽输出模式；
实现IIC起始信号、停止信号、发送ACK信号、发送数据、接收数据等操作；
编写具体的IIC外设读写函数，根据需要调用起始信号、停止信号、发送数据、接收数据等操作。
STM32基于I2C协议的AHT20温湿度传感器的数据采集
思路
硬件连接：
将STM32与AHT20温湿度传感器通过I2C总线连接。
确保STM32的I2C引脚（如SDA和SCL）与AHT20传感器的对应引脚相连。\n初始化I2C：
在STM32的代码中，初始化I2C总线，配置STM32的I2C引脚和参数。
设置I2C的时钟频率和其他相关参数。
配置AHT20传感器：
发送I2C启动信号，并发送AHT20传感器的I2C地址。
向AHT20传感器发送配置命令，例如设置测量模式和频率等。
读取温湿度数据：
向AHT20传感器发送读取数据的命令。从AHT20传感器接收温湿度数据，可以通过I2C的读取操作完成。
解析接收到的数据，获取温湿度值。
处理数据：
将接收到的原始数据转换为实际的温度和湿度值。
可以使用AHT20传感器提供的公式和计算方法进行转换。
输出数据：
将获取的温湿度值通过串口、LCD显示屏或其他外设进行输出。
可以通过串口发送数据到计算机进行实时监测和记录。
循环采集：
在代码中设置循环，以固定的时间间隔重复执行数据采集和处理操作。
可以使用延时函数或定时器来控制采集频率。
以上是一个基本的实验思路，可以根据具体的STM32开发板和编程环境进行相应的配置和代码编写。在实际实验中，还需要注意电源供应、信号线连接的正确性以及根据AHT20传感器的数据手册来正确配置和读取传感器的数据。
代码：
bsp_i2c.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 ;   //¨ª?¨ª¨¬¨º?3?
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStructure);
 
	IIC_SCL=1;
	IIC_SDA=1;
 
}
//2¨²¨¦¨²IIC?e¨º?D?o?
void IIC_Start(void)
{
	SDA_OUT();     //sda??¨º?3?
	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¡Á¨¹??¡ê?¡Á?¡À?¡¤¡é?¨ª?¨°?¨®¨º?¨ºy?Y 
}	  
//2¨²¨¦¨²IIC¨ª¡ê?1D?o?
void IIC_Stop(void)
{
	SDA_OUT();//sda??¨º?3?
	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¡Á¨¹???¨¢¨º?D?o?
	delay_us(4);							   	
}
//¦Ì¨¨¡äy¨®|¡äeD?o?¦Ì?¨¤¡ä
//¡¤¦Ì???¦Ì¡êo1¡ê??¨®¨º?¨®|¡äe¨º¡ì¡ã¨¹
//        0¡ê??¨®¨º?¨®|¡äe3¨¦1|
u8 IIC_Wait_Ack(void)
{
	u8 ucErrTime=0;
	SDA_IN();      //SDA¨¦¨¨???a¨º?¨¨?  
	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;//¨º¡À?¨®¨º?3?0 	   
	return 0;  
} 
//2¨²¨¦¨²ACK¨®|¡äe
void IIC_Ack(void)
{
	IIC_SCL=0;
	SDA_OUT();
	IIC_SDA=0;
	delay_us(2);
	IIC_SCL=1;
	delay_us(2);
	IIC_SCL=0;
}
//2?2¨²¨¦¨²ACK¨®|¡äe		    
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¡¤¡é?¨ª¨°???¡Á??¨²
//¡¤¦Ì??¡ä¨®?¨²¨®D?T¨®|¡äe
//1¡ê?¨®D¨®|¡äe
//0¡ê??T¨®|¡äe			  
void IIC_Send_Byte(u8 txd)
{                        
    u8 t;   
		SDA_OUT(); 	    
    IIC_SCL=0;//¨¤-¦Ì¨ª¨º¡À?¨®?a¨º?¨ºy?Y¡ä?¨º?
    for(t=0;t<8;t++)
    {              
        IIC_SDA=(txd&0x80)>>7;
        txd<<=1; 	  
		delay_us(2);   //??TEA5767?a¨¨y???¨®¨º¡À??¨º?¡À?D?¦Ì?
		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¨¦¨¨???a¨º?¨¨?
  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);	    //¡¤¡é?¡Â?t¦Ì??¡¤
	IIC_Wait_Ack(); 
	IIC_Send_Byte(addr&0xFF);   //¡¤¡é?¨ª¦Ì¨ª¦Ì??¡¤
	IIC_Wait_Ack(); 
	IIC_Send_Byte(data);     //¡¤¡é?¨ª¡Á??¨²							   
	IIC_Wait_Ack();  		    	   
  IIC_Stop();//2¨²¨¦¨²¨°???¨ª¡ê?1¨¬??t 
	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)  //?¨¢??¡ä??¡Â?¨°?¨¢¨ºy?Y
{	
		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);	    //¡¤¡é?¡Â?t¦Ì??¡¤
		IIC_Wait_Ack();
		if(ByteNumToRead == 1)//LM75???¨¨¨ºy?Y?a11bit
		{
			data=IIC_Read_Byte(0);
		}
		else
			{
				data=IIC_Read_Byte(1);
				data=(data<<8)+IIC_Read_Byte(0);
			}
		IIC_Stop();//2¨²¨¦¨²¨°???¨ª¡ê?1¨¬??t	    
		return data;
}


/**********
*¨¦???2?¡¤??aIO?¨²?¡ê?¨¦I2C????
*
*¡ä¨®?a¨°????a¨º??aAHT20¦Ì?????I2C
*o¡¥¨ºy??¨®DIICo¨ªI2C¦Ì???¡Àe¡ê???¡Á¡é¨°a¡ê?¡ê?¡ê?¡ê?¡ê?
*
*2020/2/23¡Á?o¨®DT??¨¨??¨²
*
***********/
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("lyy");

	}
	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);
}

main.c

#include "delay.h"
#include "usart.h"
#include "bsp_i2c.h"
#include "stm32f10x.h"   // Device headerint 
main(void) 
{	
    delay_init();     //?¨®¨º¡Ào¡¥¨ºy3?¨º??¡¥	  	
    uart_init(115200);	 //¡ä??¨²3?¨º??¡¥?a115200	
    IIC_Init();		
    while(1)	
    {		
    printf("温度湿度显示：");		
    read_AHT20_once();		
    delay_ms(1500);  
    }
}

实验效果

petal_20231115_163932

总结
通过本次实验，我们深入了解了基于I2C协议的AHT20温湿度传感器的数据采集过程，并掌握了如何通过编程实现对传感器数据的读取和处理。实验结果表明，AHT20传感器具有高精度、低功耗、抗干扰能力强等优点，适用于各种环境监测系统。同时，我们也验证了I2C协议在数据通信中的有效性。在未来的工作中，我们可以进一步探索如何将这种传感器应用于更多的领域，例如农业、工业、医疗等。此外，我们还可以研究如何通过优化算法和提高精度来提高数据采集的可靠性。

m0_72338354
关注
IIC协议读取温湿度数据(HAL库)
m0_63647460的博客
11-09 356
I2C协议，引脚少，硬件实现简单，可扩展性强，不需要USART、CAN等通讯协议的外部收发设备，现被广泛的使用在系统内多个集成电路（IC）间的通讯。对于通讯协议，我们也以分层的方式来理解，最基本的是把它分为物理层和协议层。物理层规定通讯系统中具有机械、电子功能部分的特性，确保原始数据在物理媒体的传输。协议层主要规定通讯逻辑，统一收发双方的数据打包、解包标准。简单来说物理层规定我们用嘴巴还是用肢体来交流，协议层则规定我们用中文还是英文来交流。
通过IIC协议读取温湿度数据
ggggjggggj的博客
11-14 162
在本实验中，我们将介绍使用STM32微控制器和AHT20温度和湿度传感器，根据I2C协议在实验室收集温度和湿度数据。通过这个实验，我们可以学习如何在STM32上设置I2C通信，然后如何初始化AHT20传感器，以及如何读取和解析AHT20发送的温度和湿度数据。通过这个实验，我们将深入了解STM32微控制器和AHT20温度和湿度传感器的工作原理和应用方法。通过实际操作，我们将掌握基于I2C协议的数据采集方法，并改进我们的嵌入式系统和物联网应用程序开发能力。
STM32基于IIC协议读取温湿度数据
Yokuershi的博客
11-07 212
I2C"是一种常见的串行通信协议，用于在不同的集成电路（IC）之间传输数据。有两种主要的I2C实现方式，即"软件I2C"和"硬件I2C”，它们在通信方式和实现方式上有所不同。此次实验内容为通过STM32微控制器使用I2C协议读取与AHT20温湿度传感器连接的温度和湿度数据。在连接硬件时，务必小心，确保正确接线，防止损坏设备。在代码编写中，注意I2C通信的初始化和配置，以确保通信的顺利进行。根据AHT20传感器的数据手册，正确解析温湿度数据。
实验：IIC协议读取温湿度数据
qq_68130187的博客
11-19 131
这里我们使用的是HAL库的方式来实现，需要注意的是前面在STM32CubeMX里面的项目配置，我们需要把端口配置好，这样的话进入keil才没有问题，同时我们也需要去尽量了解代码，懂得其一些基本原理，那么本次实验就是比较成功的。使用： 需要在控制产生 I2C 的起始信号时，控制作为SCL 线的 GPIO 引脚输出高电平，然后控制作为 SDA 线的 GPIO 引脚在此期间完成由高电平至低电平的切换，最后再控制SCL线切换为低电平，这样就输出了一个标准的 I2C 起始信号。
STM32_实验2_printf函数重定向输出
2301_78590609的博客
10-14 575
以上是为了打印调试信息添加的串口重映射配置。
STM32L010F4 最小系统设计
不浮夸，不将就，认真对待学知识的我们
10-14 1038
画一个 STM32L010F4 的测试板子...... by 矜辰所致
小米电机与STM32——CAN通信
doudou2weiwei的博客
10-12 1581
背景介绍：为了利用小米电机，搭建机械臂的关节，需要学习小米电机的使用方法。计划采用STM32驱动小米电机，实现指定运动，为此需要了解他们之间的通信方式，指令写入方法等。花了很多时间学习，但网络上相关资料很少，且对于我这类基础一般的同学，注释不够详细。为此，我认真研读了电机的说明书，参考相关的博文，实现了电机的CAN通信，特作此记录。
【STM32 HAL库】MPU6050姿态解算 卡尔曼滤波
AbaAbaxxx_的博客
10-10 1487
本篇文章基于卡尔曼滤波的原理详解与公式推导，来详细的解释下如何使用卡尔曼滤波来解算MPU6050的姿态。
STM32中的DMA数据转运——下篇
m0_62710548的博客
10-11 951
在上篇文章中，我们讨论了STM32中的DMA（直接存储器访问）及其工作原理、存储器类型和总线设计。接下来，我们将更深入地探讨DMA的具体配置方法、常见应用场景以及一些实际设计中的注意事项。
【STM32 Blue Pill编程实例】-SD卡文件读写（SPI接口）
视觉与物联智能
10-11 186
在本文中，我们将介绍如何将 microSD 卡与 STM32 Blue Pill 连接，并在STM32CubeIDE中对SD卡进行编程控制。 在文章中将使用模提 SPI 接口SD卡模块，该模块可将 SD 卡模块与任何支持 SPI 通信接口的微控制器连接。 对于需要存储大尺寸文件的应用程序来说，使用 microSD 卡变得非常方便。
STM32外设应用详解
Chujun123528的博客
10-10 1838
STM32微控制器集成了多种外设接口，这些外设按照功能和用途可以分为通用外设、通信外设和模拟外设三大类。通用外设定时器/计数器：用于产生定时脉冲、测量时间间隔或计数事件。STM32的定时器具有多种工作模式，如定时器模式、计数器模式和PWM模式等。通过配置定时器的预分频器、自动重装载寄存器等参数，可以实现精确的定时功能。看门狗定时器：用于监控系统运行状态，防止系统死锁或异常运行。看门狗定时器通过定期复位计数器来检测系统是否正常运行，如果计数器在规定时间内没有被复位，则触发复位信号，重新启动系统。
STM32移植RT-Thread实现PWM波的输出
weixin_44176501的博客
10-11 585
HAL库的配置必须要做的 SYS/RCC/USART 然后在配置个TIM的PWM输出这里的Clock Source并没有开启，因为开启后发现stm32f1xx_hal_msp.c中只有HAL_TIM_MspInit而没有HAL_TIM_PWM_MspInit,感觉很奇怪，不知道F4或者其他芯片什么样，网络上里面有开启的有没开启的，我觉得可能是实时操作系统版本的问题，大家可以关注一下时钟是否开启了。HAL库中配置的哪个就在这里开启哪个。
嵌入式硬件设计详解
shiming8879的博客
10-10 1740
嵌入式硬件设计是一个复杂而精细的过程，涉及需求分析、核心元件选择、原理图设计、PCB设计、硬件调试以及优化与迭代等多个环节。通过科学的设计方法和严谨的测试流程，可以设计出性能稳定、功耗低、可靠性高的嵌入式系统硬件平台。未来，随着物联网、人工智能、5G等技术的不断发展，嵌入式系统将在更多领域得到应用。因此，嵌入式硬件设计也需要不断创新和进步，以适应新的应用需求和技术挑战。例如，在物联网应用中，需要设计低功耗、高可靠性的无线通信模块；在人工智能应用中，需要设计高性能、低功耗的神经网络加速器；
Java 代码实现了一个简单的文本编辑器-可运行
10-17
Java 代码实现了一个简单的文本编辑器
MATLAB实现基于Attention-LSTM的多特征分类预测（含完整的程序和代码详解）
10-17
内容概要：本文详细介绍了如何使用MATLAB实现基于Attention机制的LSTM模型进行多特征分类预测。主要内容包括程序设计思路、代码实现、模型构建与训练、模型评估及可视化、以及简单的GUI界面设计。模型可以在多个领域应用，如金融数据分析、医疗诊断等。 适合人群：对深度学习和分类预测感兴趣的科研人员和开发人员，具备一定的MATLAB和深度学习基础。 使用场景及目标：适用于需要处理时间序列数据并进行分类预测的项目。目标是通过Attention-LSTM模型提高分类准确率，同时提供直观的可视化结果和友好的用户界面。 其他说明：文中提供了详细的代码实现和注释，读者可以通过实践加深对模型的理解。此外，还讨论了模型优化和未来的研究方向。
基于Flask和SQLAlchemy 的简易仓库管理系统源码(期末课程设计).zip
最新发布
10-17
基于Flask和SQLAlchemy 的简易仓库管理系统源码(期末课程设计).zip 1.多数小白下载后，在使用过程，可能会遇到些小问题，若自己解决不了，请及时私信描述你的问题，我会第一时间提供帮助，也可以远程指导 2.项目代码完整可靠，谈不上高分、满分(多数为夸大其词），但难度适中，满足一些毕设、课设要求，且属于易上手的优质项目，项目内基本都有说明文档，按照操作即可，遇到困难也可私信交流 3.适用人群：各大计算机相关专业行业的在校学生、高校老师、公司程序员等下载使用 4.特别是那种爱钻研学习的学霸，强烈推荐此项目，可以二次开发提升自己。如果确定自己是学渣，拿来作毕设、课设直接用也无妨，但自己还是尽可能弄懂项目最好！
硬件IIC读取温湿度传感器代码
06-03
以下是一份基于STM32的硬件IIC读取温湿度传感器的代码示例： ```c #include "main.h" #include "i2c.h" #define HTU21D_ADDRESS 0x80 // HTU21D传感器地址 // HTU21D传感器命令 #define HTU21D_TRIGGER_TEMP_HOLD...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值