嵌入式学习⑦——基于IIC的温湿度检测

最新推荐文章于 2024-04-15 22:13:08 发布
最新推荐文章于 2024-04-15 22:13:08 发布
阅读量542 收藏 5
点赞数
分类专栏： 阿为 文章标签： stm32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/syw6666666/article/details/111473219
版权

基于IIC的温湿度检测

目录

一. IIC总线通信协议

IIC（Inter-Integrated Circuit）其实是IICBus简称，所以中文应该叫集成电路总线，它是一种串行通信总线，使用多主从架构，由飞利浦公司在1980年代为了让主板、嵌入式系统或手机用以连接低速周边设备而发展。
I²C的正确读法为“I平方C”（“I-squared-C”），而“I二C”（“I-two-C”）则是另一种错误但被广泛使用的读法。自2006年10月1日起，使用I²C协议已经不需要支付专利费，但制造商仍然需要付费以获取I²C从属设备地址。
I2C串行总线一般有两根信号线，一根是双向的数据线SDA，另一根是时钟线SCL。所有接到I2C总线设备上的串行数据SDA都接到总线的SDA上，各设备的时钟线SCL接到总线的SCL上。

1. 软件IIC

软件IIC 是通过GPIO，软件模拟寄存器的工作方式，而硬件（固件）IIC是直接调用内部寄存器进行配置。如果要从具体硬件上来看，可以去看下芯片手册。因为固件IIC的端口是固定的，所以会有所区别。

2. 硬件IIC

所谓硬件IIC对应芯片上的IIC外设，有相应IIC驱动电路，其所使用的IIC管脚也是专用的；软件IIC一般是用GPIO管脚，用软件控制管脚状态以模拟IIC通信波形。

硬件IIC的效率要远高于软件的，而软件IIC由于不受管脚限制，接口比较灵活。

至于如何区分它们

  1. 可以看底层配置，比如IO口配置，如果配置了IO口的功能（IIC功能）那就是固件IIC，否则就是模拟

  2. 可以看IIC写函数，看里面有木有调用现成的函数或者给某个寄存器赋值，如果有，则肯定是固件IIC功能，没有的话肯定是数据一个bit一个bit模拟发生送的，肯定用到了循环，则为模拟。

  3. 根据代码量判断，模拟的代码量肯定比固件的要大。
    硬件IIC用法比较复杂，模拟IIC的流程更清楚一些。

  4. 硬件IIC速度比模拟快，并且可以用DMA

  5. 模拟IIC可以在任何管脚上，而硬件只能在固定管脚上。

    软件IIC是程序员使用程序控制SCL,SDA线输出高低电平，模拟IIC协议的时序。一般较硬件IIC稳定，但是程序较为繁琐，但不难。硬件IIC程序员只要调用IIC的控制函数即可，不用直接的去控制SCL,SDA高低电平的输出。但是有些单片机的硬件IIC不太稳定，调试问题较多。

    参考自：硬件IIC和软件IIC区别

二. stm32外接AHT20进行温度采集

1.实作器材

STM32 MINI开发板
AHT20温湿度采集芯片

根据AHT20的线路图进行连线
在这里插入图片描述

2.硬件连接

将AHT20芯片通过连接线接到PC上
在这里插入图片描述

3.代码实现

此工程基于STM32例程编写，以实现以下功能：

  1. 每隔2秒钟采集一次温湿度数据

  2. 并通过串口发送到上位机

例程代码实现如下：

main.c

#include "delay.h"
#include "usart.h"
#include "i2c.h"


int main(void)
{	
	delay_init();    
	uart_init(115200);	 
	IIC_Init();
		while(1)
	{
		printf("野火STM32指南者基于I2C协议的AHT20温湿度传感器开始测量：");
		read_AHT20_once();
		delay_ms(1500);
  }
}

delay.c

#include "delay.h"
#include "sys.h"
#if SYSTEM_SUPPORT_UCOS
#include "includes.h"	  
#endif
static u8  fac_us=0;
static u16 fac_ms=0;
#ifdef OS_CRITICAL_METHOD 	
void SysTick_Handler(void)
{				   
	OSIntEnter();		
    OSTimeTick();      
    OSIntExit();      
#endif

void delay_init()	 
{

#ifdef OS_CRITICAL_METHOD 	
	u32 reload;
#endif
	SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);	
	fac_us=SystemCoreClock/8000000;	 
	 
#ifdef OS_CRITICAL_METHOD 	
	reload=SystemCoreClock/8000000;		  
	reload*=1000000/OS_TICKS_PER_SEC;
	fac_ms=1000/OS_TICKS_PER_SEC;	   
	SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;
	SysTick->LOAD=reload;
	SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk; 
#else
	fac_ms=(u16)fac_us*1000;
#endif
}								    

#ifdef OS_CRITICAL_METHOD		    								   
void delay_us(u32 nus)
{		
	u32 ticks;
	u32 told,tnow,tcnt=0;
	u32 reload=SysTick->LOAD;	    	 
	ticks=nus*fac_us;   		 
	tcnt=0;
	told=SysTick->VAL; 
	while(1)
	{
		tnow=SysTick->VAL;	
		if(tnow!=told)
		{	    
			if(tnow<told)tcnt+=told-tnow;
			else tcnt+=reload-tnow+told;	    
			told=tnow;
			if(tcnt>=ticks)break;
		}  
	}; 									    
}

void delay_ms(u16 nms)
{	
	if(OSRunning==TRUE)    
	{		  
		if(nms>=fac_ms)
		{
   			OSTimeDly(nms/fac_ms);
		}
		nms%=fac_ms;		
	}
	delay_us((u32)(nms*1000));	
}
#else	    								   
void delay_us(u32 nus)
{		
	u32 temp;	    	 
	SysTick->LOAD=nus*fac_us;   		 
	SysTick->VAL=0x00;        
	SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;    
	do
	{
		temp=SysTick->CTRL;
	}
	while(temp&0x01&&!(temp&(1<<16)));
	SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;   
	SysTick->VAL =0X00;    
}

void delay_ms(u16 nms)
{	 		  	  
	u32 temp;		   
	SysTick->LOAD=(u32)nms*fac_ms;
	SysTick->VAL =0x00;     
	SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;      
	do
	{
		temp=SysTick->CTRL;
	}
	while(temp&0x01&&!(temp&(1<<16))); 
	SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;   
	SysTick->VAL =0X00;       	  	    
} 
#endif

usart.c

#include "sys.h"
#include "usart.h"


#if SYSTEM_SUPPORT_UCOS
#include "includes.h"			
#if 1
#pragma import(__use_no_semihosting)                            
struct __FILE 
{ 
	int handle; 

}; 

FILE __stdout;       
void _sys_exit(int x) 
{ 
	x = x; 
} 
int fputc(int ch, FILE *f)
{      
	while((USART1->SR&0X40)==0);//Ñ­»··¢ËÍ,Ö±µ½·¢ËÍÍê±Ï   
    USART1->DR = (u8) ch;      
	return ch;
}
#endif 

#if EN_USART1_RX  	
u8 USART_RX_BUF[USART_REC_LEN];  
u16 USART_RX_STA=0;   
  
void uart_init(u32 bound){
  GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	 
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);	
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; 
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;	
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOA, &GPIO_InitStructure);  
    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;	
	NVIC_Init(&NVIC_InitStructure);
	USART_InitStructure.USART_BaudRate = bound;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
	USART_InitStructure.USART_StopBits = USART_StopBits_1;
	USART_InitStructure.USART_Parity = USART_Parity_No;
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;	

    USART_Init(USART1, &USART_InitStructure); 
    USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
    USART_Cmd(USART1, ENABLE); 

}
void USART1_IRQHandler(void)  
	{
	u8 Res;
#ifdef OS_TICKS_PER_SEC	
	OSIntEnter();    
#endif
	if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) 
		{
		Res =USART_ReceiveData(USART1);//(USART1->DR);	
		
		if((USART_RX_STA&0x8000)==0)
			{
			if(USART_RX_STA&0x4000)
				{
				if(Res!=0x0a)USART_RX_STA=0;
				else USART_RX_STA|=0x8000;
				}
			else 
				{	
				if(Res==0x0d)USART_RX_STA|=0x4000;
				else
					{
					USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;
					USART_RX_STA++;
					if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;  
					}		 
				}
			}   		 
     } 
#ifdef OS_TICKS_PER_SEC	 
	OSIntExit();  											 
#endif
} 
#endif

i2c.c

#include "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 ;   //ÍÆÍìÊä³ö
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStructure);
 
	IIC_SCL=1;
	IIC_SDA=1;
 
}
void IIC_Start(void)
{
	SDA_OUT();  
	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;
}	  

void IIC_Stop(void)
{
	SDA_OUT();
	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;
	delay_us(4);							   	
}
u8 IIC_Wait_Ack(void)
{
	u8 ucErrTime=0;
	SDA_IN();  
	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;
	return 0;  
} 
void IIC_Ack(void)
{
	IIC_SCL=0;
	SDA_OUT();
	IIC_SDA=0;
	delay_us(2);
	IIC_SCL=1;
	delay_us(2);
	IIC_SCL=0;
}
//²»²úÉúACKÓ¦´ð		    
void IIC_NAck(void)
{
	IIC_SCL=0;
	SDA_OUT();
	IIC_SDA=1;
	delay_us(2);
	IIC_SCL=1;
	delay_us(2);
	IIC_SCL=0;
}					 				     	  
void IIC_Send_Byte(u8 txd)
{                        
    u8 t;   
		SDA_OUT(); 	    
    IIC_SCL=0;
    for(t=0;t<8;t++)
    {              
        IIC_SDA=(txd&0x80)>>7;
        txd<<=1; 	  
		delay_us(2); 
		IIC_SCL=1;
		delay_us(2); 
		IIC_SCL=0;	
		delay_us(2);
    }	 
} 	    
u8 IIC_Read_Byte(unsigned char ack)
{
	unsigned char i,receive=0;
	SDA_IN();
  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();
	else
			IIC_Ack(); 
	return receive;
} 
void IIC_WriteByte(uint16_t addr,uint8_t data,uint8_t device_addr)
{
	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_Send_Byte(data); 					   
	IIC_Wait_Ack();  		    	   
  IIC_Stop();
	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)  
{	
		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);
		IIC_Wait_Ack();
		if(ByteNumToRead == 1)
		{
			data=IIC_Read_Byte(0);
		}
		else
			{
				data=IIC_Read_Byte(1);
				data=(data<<8)+IIC_Read_Byte(0);
			}
		IIC_Stop();//²úÉúÒ»¸öÍ£Ö¹Ìõ¼þ	    
		return data;
}
void  read_AHT20_once(void)
{
	delay_ms(10);
	startMeasure_AHT20();
	delay_ms(80);
    read_AHT20();
	delay_ms(5);
}
void  startMeasure_AHT20(void)
{
	I2C_Start();

	I2C_WriteByte(0x70);
	ack_status = Receive_ACK();
	if(ack_status);
	else printf("7-n-");
	I2C_WriteByte(0xAC);
	ack_status = Receive_ACK();
	if(ack_status);
	else printf("8-n-");
	I2C_WriteByte(0x33);
	ack_status = Receive_ACK();
	if(ack_status);
	else printf("9-n-");
	I2C_WriteByte(0x00);
	ack_status = Receive_ACK();
	if(ack_status);
	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("失败了");

	}
	printf("\r\n");
	printf("当前温度为:  %d%d.%d",T1/100,(T1/10)%10,T1%10);
	printf("\r\n");
	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)
{
	AHT20sendOutData[3] = AHT20_OutData[0];
	AHT20sendOutData[4] = AHT20_OutData[1];
	AHT20sendOutData[5] = AHT20_OutData[2];
	AHT20sendOutData[6] = AHT20_OutData[3];
}


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

sys.c

#include "sys.h"
void NVIC_Configuration(void)
{
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);	
}

将以上代码编译烧录至STM32后，进行运行

在这里插入图片描述

三. 总结

这次的学习我了解了什么是硬件I2C、什么是软件I2C
通过对IIC的学习，我也认识到了很多关于集成电路总线的知识

漆黑の黑炎龙
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SHT11（IIC协议的温湿度传感器）简介和编程方法
zgrjkflmkyc的专栏
09-03 5万+
SHT11是瑞士Scnsirion公司推出的一款数字温湿度传感器芯片。该芯片广泛应用于暖通空调、汽车、消费电子、自动控制等领域。共主要特点如下： ◆高度集成，将温度感测、湿度感测、信号变换、A／D转换和加热器等功能集成到一个芯片上； ◆提供二线数字符串行接口SCK和DATA，接口简单，支持CRC传输校验，传输可靠性高； ◆测量精度可编程调节，内置A／D转换器(分辨率为8～12位，可以通过对芯
IIC学习之SHT30温湿度传感器(基于STM32)配套资料
01-12
https://blog.csdn.net/qq_36973838/article/details/135546011
基于STM32 嵌入式实验DHT11温湿度传感器测量湿度
06-25
DTH11测量实时湿度，最大湿度，最小湿度，通过矩阵键盘设置报警湿度值，在LCD彩屏上显示
嵌入式实验（二）：基于IIC（软件）的AHT20温湿度传感器的数据采集
qq_44701643的博客
12-22 712
嵌入式作业（八）1. IIC2. 基于软件IIC的温湿度信息采集keil程序硬件连接实验结果3. 实验总结 1. IIC IIC（Inter-Integrated Circuit）集成电路总线，它是一种串行通信总线，使用多主从架构，由飞利浦公司在1980年代为了让主板、嵌入式系统或手机用以连接低速周边设备而发展。 什么是IIC IIC 总线支持任何 IC 生产过程 （NMOS CMOS 双极性 )两线――串行数据 (SDA) 和串行时钟(SCL) 线在连接到总线的器件间传递信息 每个器件都有一个唯一的
串口通信和I2C
最新发布
2302_77099705的博客
04-15 1215
串口通信(Serial Communication)，是指外设和计算机间通过数据信号线、地线等按位进行传输数据的一种通信方式，属于串行通信方式。串口是一种接口标准，它规定了接口的电气标准，没有规定接口插件电缆以及使用的协议。串口通信的接口标准有很多，有 RS-232C、 RS-232、 RS-422A、 RS-485 等。常用的是 RS-232 和 RS-485。RS-232 其实是 RS-232C 的改进，原理是一样的。这里我们就以 RS-232C 接口进行讲解。
嵌入式温度检测.
03-26
随着社会经济的发展，人民生活水平不断提高，瓜果、蔬菜及花卉的社会需求数量和品质要求也不断提高，。但随着人口的增加，我国耕地面积不断减少，气候的不适宜，也是农作物产量得不到提高。于是农业温室得到迅速发展，这些温室都是在充分利用屏障技术和高产栽培技术的基础上发展起来的，其收入很难再有大的提高。要改变这种状况，将现代计算机技术引入农业温室，实现农业温室的计算机综合控制，是最有效的途径之一。本文介绍的温室环境监测系统，能实现对温室环境的监测和控制，其具有如下功能：能对周围温度、空气湿度、光照强度、二氧化碳等进行测量并记录，并简单调节相应参数，使其适合农作物生长
IIC实现温湿度测量
MisakaMikotto的博客
01-03 188
作业
嵌入式作业十二（IIC协议采集温湿度）
11-19
嵌入式作业十二（IIC协议采集温湿度）
0048基于STM32F103单片机IIC读取AHT10温湿度传感器值的程序代码.rar
12-27
1、STM32F103通过IIC接口与AHT10温湿度传感器进行通讯，读取传感器温湿度值。 2、代码使用KEIL开发，当前在STM32F103C8T6运行，如果是STM32F103其他型号芯片，依然适用，请自行更改KEIL芯片型号以及FLASH容量即可。 ...
基于GD32F103采用模拟IIC驱动SHT30实现温湿度采集（工程已测试）
12-21
各种函数都封装好了，直接调用就行，里边各种命令配置都写好的，改个引脚就行，不改也可以，直接用杜邦线接上去就可以读数据了，超级方便，需要硬件IIC也可以，我得CSDN里有链接。
基于STM32的SHT20温湿度读取IIC
12-15
基于stm32f103zet6的SHT20/30数据的简单读取和显示，通讯方式为IIC。例程自写可用，内附实物连接图
基于ARM的温湿度检测系统
10-12
可以实现对环境中温湿度的监测，判断其是否在所设定的温度范围内；若要超出范围则进行报警；并且记录所采集的温度湿度信息并可以将数据上传至上位机中。利用上位机界面可显示当前采集的数据。
HDC1080驱动 温湿度 STM32 IIC I2C
12-05
更新内容：增加小数点输出，文件为HDC1080温湿度传感器的C语言STM32驱动程序，已经调试成功！！！I2C接口，可以正常配置寄存器，读取温度值，内含非常详细的注释。
基于IIC实现温湿度采集
LIKE的博客
12-14 1105
基于IIC实现温湿度采集
基于IIC总线的温湿度传感器，你用过吗
程序员小哈的专栏
01-12 3541
大家好，我是程序员小哈。 又到了知识分享时间，今天我给大家分享一个温湿度传感器模块，我们之前分享过DHT11和DHT21两款温湿度传感器，它俩是基于单总线输出信号的传感器模块，只需要一个GPIO即可实现温湿度数据的获取。 本文即将介绍的 ZS05 模块，是一个基于IIC总线的温湿度传感器模块。 管脚定义 引脚 名称 含义 实际连接 1 VCC 供电，2.7~5.5V 3.3V 2 SDA 数据引脚 PB7 3 GND 电源地 GND 4 SCL 时钟脚 PB6 同类产品对比
基于iic的通信的温湿度显示
摸鱼专家
12-07 384
思路 基于stm32芯片 利用DHT11测温模块把数值显示在OLED显示屏上 硬件 硬件部分可以点我这篇帖子链接 关于OLED显示的 硬件部分 本实验多加了个温湿度感应模块 元件图 总效果图 软件部分 （需要工程文件评论区留邮箱免费分享） 贴出部分代码 //主函数 #include "delay.h" #include "sys.h" #include "oled.h" #include "bmp.h" #include "key.h" #include "dht11.h" #include "usar
基于I2C的温湿度采集初体验
uvyou的博客
12-22 389
基于I2C的温湿度采集初体验实验准备AHT20I2C总线通信协议I2C硬件与软件的对比实验要求硬件连线代码实现实验成果总结 实验准备 本次实验需要用到主要器件为STM32核心板，AHT20 对于STM32我们已经使用了几次，有了一定了解，接下来了解AHT20芯片 AHT20 AHT20，新一代温湿度传感器在尺寸与智能方面建立了新的标准：它嵌入了适于回流焊 的双列扁平无引脚SMD封装，底面3x3mm ，高度1.0mm。传感器输出经过标定的数字信号，标准 I2C 格式。 AHT20优点如下： 完全标定 数字输出
基于I2C的温湿度采集（AHT20）
qq_57289359的博客
11-20 7247
目录 一、I2C总线通信协议 1、I2C介绍 2.I2C物理层 3.I2C协议层 4、软件IIC和硬件IIC 二、AHT20温湿度采集程序的实现 三、电路连接以及结果演示 四、参考文献 一、I2C总线通信协议 1、I2C介绍 IIC(Inter－Integrated Circuit)总线是一种由NXP（原PHILIPS）公司开发的两线式串行总线，用于连接微控制器及其外围设备。多用于主控制器和从器件间的主从通信，在小数据量场合使用，传输距离短，任意时刻只能有一个主机等...
串口通信，IIC通信，SPI通信的简单区别
热门推荐
qq_45511100的博客
05-04 1万+
一、串口通信 串口通信就是RS-232通信，只有两根线txd和rxd，通信双方必须设定相同的波特率，传输距离比较近。 二、IIC通信 IIC通信是最简单的串行通信协议，只需要一根数据线和一根时钟线，就可以完成半双工通讯，一根是双向的数据线SDA，一根是时钟线SCL。 三、SPI通信 SPI是串行外设接口，可以理解成一种通信协议，也就是用来传输数据的。一般使用4条线，串行时钟线SCK、主机输入/从机输出数据线MISO、主机输出/从机输入数据线MOSI、低电平有效的从机选择线CS。 ...
硬件IIC读取温湿度传感器代码
06-03
以下是一份基于STM32的硬件IIC读取温湿度传感器的代码示例： ```c #include "main.h" #include "i2c.h" #define HTU21D_ADDRESS 0x80 // HTU21D传感器地址 // HTU21D传感器命令 #define HTU21D_TRIGGER_TEMP_HOLD...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值