嵌入式作业9

最新推荐文章于 2023-07-24 13:37:09 发布
最新推荐文章于 2023-07-24 13:37:09 发布
阅读量3k 收藏 1
点赞数 1
分类专栏： 笔记 文章标签： 单片机 stm32 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58222379/article/details/121545515
版权
本文详细介绍了STM32使用I2C协议与AHT20温湿度传感器进行通信的过程，包括硬件I2C和软件I2C的工作原理和实现方式，以及如何读取传感器数据并显示在串口上。通过代码展示了从初始化I2C到读取温湿度数据的完整步骤。
摘要由CSDN通过智能技术生成

目录

一、关于I2C总线

1.简介

I2C是Inter-Integrated Circuit的简称，读作：I-squared-C。由飞利浦公司于1980年代提出，为了让主板、嵌入式系统或手机用以连接低速周边外部设备而发展。

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

2.I2C协议的物理层和协议层

物理层：
I2C总线物理层由两根线组成：串行时钟线SCL、串行数据线SDA。由于这两根线都是开漏输出结构，因此必须都接上拉电阻到高电平，因此当总线处于空闲状态时，两根线都处于高电平状态。
下图为I2C总线的物理层示意图：
在这里插入图片描述
I2C 总线在物理连接上非常简单，分别由SDA(串行数据线)和SCL(串行时钟线)及上拉电阻组成。通信原理是通过对SCL和SDA线高低电平时序的控制，来产生I2C总线协议所需要的信号进行数据的传递。在总线空闲状态时，这两根线一般被上面所接的上拉电阻拉高，保持着高电平。
I2C通信方式为半双工，只有一根SDA线，同一时间只可以单向通信，485也为半双工，SPI和uart为双工。
在这里插入图片描述

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

开始条件：标识传输正式开始，当SCL处于高电平时，SDA由高电平变为低电平。这样所有Slave设备都会知道传输已经开始。

地址帧：地址帧总是在一次通信的最开始出现，通常包括7位的设备地址(MSB)和最后1位的读写控制位(1表示读，0表示写)。接下来是1位的NACK/ACK，当这8位地址发送完成后，Slave设备获得SDA的控制权，此时Slave设备应该在第9个时钟脉冲之前回复一个ACK(将SDA拉低)以表示数据接收正常，否则表示数据接受失败，控制权交由Master设备处理。

数据帧：在地址帧发送之后，就可以开始传送数据了。每个数据帧8位，数据帧的数量可以是任意的，直到产生停止条件。每一个8位数据传输完成之后，接收方就需要回复一个ACK/NACK。

停止条件：当所有数据都发送完成时，当SCL处于高电平时，SDA由低电平变为高电平。除了开始条件和停止条件，在正常的数据传输过程中，当SCL处于高电平时，SDA上的值不能变化，否则会意外产生停止条件。

重复开始条件：有时Master设备需要在一次通信中进行多次消息交换(例如切换读写操作等)，并且不希望其他Master设备干扰，这时可以使用重复开始条件。再一次通信中，Master设备可以产生多次开始条件来完成多次信息交换，最后在产生一个停止条件结束整个通信过程。
在这里插入图片描述

应答信号

主设备每发送完8bit数据后等待从设备的ACK，即在第9个clk，读取到SDA低电平为有效;主设备把clk拉低，并将sda换成输入模式（上拉电阻，默认高电平）读取第9位，clk再次拉高，读取从设备发来的ACK。这里又分两种情况：

1.写操作：主设备把clk拉高，等待读取ACK，从设备发现clk拉高后，就把sda拉低，告诉主设备，成功接收到8位数据。

2.读操作：主设备发送芯片地址和寄存器地址，这两个字节的ACK都是由从设备来拉低，同写操作;从设备开始向从设备发送数据，clk为低时，sda变化，主设备clk拉高时读取sda，ACK由主设备拉低;当从设备发送完一个字节后，主设备强制把ACK拉高，通知从设备不要需要再发了，从设备发现这个ACK没有被拉低，认为主设备接收错误，也就结束发送了，当然从设备自己也知道这是一个字节。

二、软件I2C和硬件I2C（I2C的两种方式）

1.硬件I2C

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

2.软件I2C

  • 直接使用 CPU 内核按照 I2C 协议的要求控制 GPIO 输出高低电平，从而模拟I2C。
    需要在控制产生 I2C 的起始信号时，控制作为 SCL 线的 GPIO 引脚输出高电平，然后控制作为 SDA 线的 GPIO 引脚在此期间完成由高电平至低电平的切换，最后再控制SCL 线切换为低电平，这样就输出了一个标准的 I2C 起始信号。

3.两者的区别

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

三、AHT20温湿度传感器

1.简介

在这里插入图片描述
在这里插入图片描述

2.引脚说明

6根引脚，名称与功能如下;
NC 保持悬空
vdd 为外接供电电源输入端
GND 地线
SCL I2C通信模式时钟信号,双向
SDA I2C通信模式数据信号，双向
NC 保持悬空
在这里插入图片描述

3.运行工程观察温湿度

  • 相关代码如下：
    main.c
#include "delay.h"
#include "usart.h"
#include "bsp_i2c.h"


int main(void)
{	
	delay_init();     //延时函数  
	uart_init(115200);	 //uart函数设置波特率问115200
	IIC_Init();
		while(1)
	{
		printf("温度湿度显示");
		read_AHT20_once();
		delay_ms(2000);
  }
}

usart.

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


//STM32F103o?D?°?ày3ì
//?aoˉêy°?±?ày3ì
/********** mcudev.taobao.com 3??·  ********/


// 	 
//è?1?ê1ó?ucos,?ò°üà¨????μ?í·???t?′?é.
#if SYSTEM_SUPPORT_UCOS
#include "includes.h"					//ucos ê1ó?	  
#endif
//	 
//STM32?a·￠°?
//′??ú13?ê??ˉ		   

// 	  
 

//
//?óè?ò???′ú??,?§3?printfoˉêy,??2?Dèòa????use MicroLIB	  
#if 1
#pragma import(__use_no_semihosting)             
//±ê×??aDèòaμ??§3?oˉêy                 
struct __FILE 
{ 
	int handle; 

}; 

FILE __stdout;       
//?¨ò?_sys_exit()ò?±ü?aê1ó?°??÷?ú?￡ê?    
void _sys_exit(int x) 
{ 
	x = x; 
} 
//???¨ò?fputcoˉêy 
int fputc(int ch, FILE *f)
{      
	while((USART1->SR&0X40)==0);//?-?··￠?í,?±μ?·￠?ííê±?   
    USART1->DR = (u8) ch;      
	return ch;
}
#endif 

/*ê1ó?microLibμ?·?·¨*/
 /* 
int fputc(int ch, FILE *f)
{
	USART_SendData(USART1, (uint8_t) ch);

	while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET) {}	
   
    return ch;
}
int GetKey (void)  { 

    while (!(USART1->SR & USART_FLAG_RXNE));

    return ((int)(USART1->DR & 0x1FF));
}
*/
 
#if EN_USART1_RX   //è?1?ê1?üá??óê?
//′??ú1?D??·t??3ìDò
//×￠òa,?áè?USARTx->SR?ü±ü?a?a??????μ?′í?ó   	
u8 USART_RX_BUF[USART_REC_LEN];     //?óê??o3?,×?′óUSART_REC_LEN??×??ú.
//?óê?×′ì?
//bit15￡?	?óê?íê3é±ê??
//bit14￡?	?óê?μ?0x0d
//bit13~0￡?	?óê?μ?μ?óDD§×??úêy??
u16 USART_RX_STA=0;       //?óê?×′ì?±ê??	  
  
void uart_init(u32 bound){
    //GPIO???úéè??
  GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	 
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);	//ê1?üUSART1￡?GPIOAê±?ó
     //USART1_TX   PA.9
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;	//?′ó?í?íìê?3?
    GPIO_Init(GPIOA, &GPIO_InitStructure);
   
    //USART1_RX	  PA.10
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//????ê?è?
    GPIO_Init(GPIOA, &GPIO_InitStructure);  

   //Usart1 NVIC ????

    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//?à??ó??è??3
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;		//×óó??è??3
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//IRQí¨μàê1?ü
	NVIC_Init(&NVIC_InitStructure);	//?ù?Y???¨μ?2?êy3?ê??ˉVIC??′??÷
  
   //USART 3?ê??ˉéè??

	USART_InitStructure.USART_BaudRate = bound;//ò?°?éè???a9600;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;//×?3¤?a8??êy?Y??ê?
	USART_InitStructure.USART_StopBits = USART_StopBits_1;//ò???í￡?1??
	USART_InitStructure.USART_Parity = USART_Parity_No;//?T????D￡?é??
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//?Tó2?têy?Yá÷????
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;	//ê?·￠?￡ê?

    USART_Init(USART1, &USART_InitStructure); //3?ê??ˉ′??ú
    USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//?a???D??
    USART_Cmd(USART1, ENABLE);                    //ê1?ü′??ú 

}



void USART1_IRQHandler(void)                	//′??ú1?D??·t??3ìDò
	{
	u8 Res;
#ifdef OS_TICKS_PER_SEC	 	//è?1?ê±?ó?ú??êy?¨ò?á?,?μ?÷òaê1ó?ucosIIá?.
	OSIntEnter();    
#endif
	if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //?óê??D??(?óê?μ?μ?êy?Y±?D?ê?0x0d 0x0a?á?2)
		{
		Res =USART_ReceiveData(USART1);//(USART1->DR);	//?áè??óê?μ?μ?êy?Y
		
		if((USART_RX_STA&0x8000)==0)//?óê??′íê3é
			{
			if(USART_RX_STA&0x4000)//?óê?μ?á?0x0d
				{
				if(Res!=0x0a)USART_RX_STA=0;//?óê?′í?ó,??D??aê?
				else USART_RX_STA|=0x8000;	//?óê?íê3éá? 
				}
			else //?1??ê?μ?0X0D
				{	
				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;//?óê?êy?Y′í?ó,??D??aê??óê?	  
					}		 
				}
			}   		 
     } 
#ifdef OS_TICKS_PER_SEC	 	//è?1?ê±?ó?ú??êy?¨ò?á?,?μ?÷òaê1ó?ucosIIá?.
	OSIntExit();  											 
#endif
} 
#endif

usart.h：

#ifndef __USART_H
#define __USART_H
#include "stdio.h"	
#include "sys.h" 

//STM32F103o?D?°?ày3ì
//?aoˉêy°?±?ày3ì
/********** mcudev.taobao.com 3??·  ********/

//	 
//STM32?a·￠°?
//′??ú13?ê??ˉ		   

#define USART_REC_LEN  			200  	//?¨ò?×?′ó?óê?×??úêy 200
#define EN_USART1_RX 			1		    //ê1?ü￡¨1￡?/???1￡¨0￡?′??ú1?óê?
	  	
extern u8  USART_RX_BUF[USART_REC_LEN]; //?óê??o3?,×?′óUSART_REC_LEN??×??ú.??×??ú?a??DD·? 
extern u16 USART_RX_STA;         		//?óê?×′ì?±ê??	
//è?1???′??ú?D???óê?￡???2?òa×￠êíò???oê?¨ò?
void uart_init(u32 bound);
#endif

sys.c：

#include "sys.h"


//STM32F103o?D?°?ày3ì
//?aoˉêy°?±?ày3ì
/********** mcudev.taobao.com 3??·  ********/

//	 

//STM32?a·￠°?
//?μí3?D??·?×ééè???ˉ		   

//********************************************************************************  
void NVIC_Configuration(void)
{

    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);	//éè??NVIC?D??·?×é2:2???à??ó??è??￡?2???ìó|ó??è??

}

sys.h：

#ifndef __SYS_H
#define __SYS_H	
#include "stm32f10x.h"
//	 


//STM32F103o?D?°?ày3ì
//?aoˉêy°?±?ày3ì
/********** mcudev.taobao.com 3??·  ********/



// 	 

//0,2??§3?ucos
//1,?§3?ucos
#define SYSTEM_SUPPORT_UCOS		0		//?¨ò??μí3???t?Dê?·??§3?UCOS
																	    
	 
//??′?2ù×÷,êμ??51àà??μ?GPIO????1|?ü
//??ì?êμ??????,2???<<CM3è¨ít????>>μú????(87ò3~92ò3).
//IO?ú2ù×÷oê?¨ò?
#define BITBAND(addr, bitnum) ((addr & 0xF0000000)+0x2000000+((addr &0xFFFFF)<<5)+(bitnum<<2)) 
#define MEM_ADDR(addr)  *((volatile unsigned long  *)(addr)) 
#define BIT_ADDR(addr, bitnum)   MEM_ADDR(BITBAND(addr, bitnum)) 
//IO?úμ??·ó3é?
#define GPIOA_ODR_Addr    (GPIOA_BASE+12) //0x4001080C 
#define GPIOB_ODR_Addr    (GPIOB_BASE+12) //0x40010C0C 
#define GPIOC_ODR_Addr    (GPIOC_BASE+12) //0x4001100C 
#define GPIOD_ODR_Addr    (GPIOD_BASE+12) //0x4001140C 
#define GPIOE_ODR_Addr    (GPIOE_BASE+12) //0x4001180C 
#define GPIOF_ODR_Addr    (GPIOF_BASE+12) //0x40011A0C    
#define GPIOG_ODR_Addr    (GPIOG_BASE+12) //0x40011E0C    

#define GPIOA_IDR_Addr    (GPIOA_BASE+8) //0x40010808 
#define GPIOB_IDR_Addr    (GPIOB_BASE+8) //0x40010C08 
#define GPIOC_IDR_Addr    (GPIOC_BASE+8) //0x40011008 
#define GPIOD_IDR_Addr    (GPIOD_BASE+8) //0x40011408 
#define GPIOE_IDR_Addr    (GPIOE_BASE+8) //0x40011808 
#define GPIOF_IDR_Addr    (GPIOF_BASE+8) //0x40011A08 
#define GPIOG_IDR_Addr    (GPIOG_BASE+8) //0x40011E08 
 
//IO?ú2ù×÷,????μ￥ò?μ?IO?ú!
//è·±￡nμ??μD?óú16!
#define PAout(n)   BIT_ADDR(GPIOA_ODR_Addr,n)  //ê?3? 
#define PAin(n)    BIT_ADDR(GPIOA_IDR_Addr,n)  //ê?è? 

#define PBout(n)   BIT_ADDR(GPIOB_ODR_Addr,n)  //ê?3? 
#define PBin(n)    BIT_ADDR(GPIOB_IDR_Addr,n)  //ê?è? 

#define PCout(n)   BIT_ADDR(GPIOC_ODR_Addr,n)  //ê?3? 
#define PCin(n)    BIT_ADDR(GPIOC_IDR_Addr,n)  //ê?è? 

#define PDout(n)   BIT_ADDR(GPIOD_ODR_Addr,n)  //ê?3? 
#define PDin(n)    BIT_ADDR(GPIOD_IDR_Addr,n)  //ê?è? 

#define PEout(n)   BIT_ADDR(GPIOE_ODR_Addr,n)  //ê?3? 
#define PEin(n)    BIT_ADDR(GPIOE_IDR_Addr,n)  //ê?è?

#define PFout(n)   BIT_ADDR(GPIOF_ODR_Addr,n)  //ê?3? 
#define PFin(n)    BIT_ADDR(GPIOF_IDR_Addr,n)  //ê?è?

#define PGout(n)   BIT_ADDR(GPIOG_ODR_Addr,n)  //ê?3? 
#define PGin(n)    BIT_ADDR(GPIOG_IDR_Addr,n)  //ê?è?



void NVIC_Configuration(void);



#endif

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

bsp_i2c.h：

#ifndef __BSP_I2C_H
#define __BSP_I2C_H

#include "sys.h"
#include "delay.h"
#include "usart.h"
//ê1ó?IIC1 1ò??M24C02,OLED,LM75AD,HT1382    PB6,PB7
 
#define SDA_IN()  {GPIOB->CRL&=0X0FFFFFFF;GPIOB->CRL|=(u32)8<<28;}
#define SDA_OUT() {GPIOB->CRL&=0X0FFFFFFF;GPIOB->CRL|=(u32)3<<28;}
 
//IO2ù×÷oˉêy	 
#define IIC_SCL    PBout(6) //SCL
#define IIC_SDA    PBout(7) //SDA	 
#define READ_SDA   PBin(7)  //ê?è?SDA 


//IIC?ùóD2ù×÷oˉêy
void IIC_Init(void);                //3?ê??ˉIICμ?IO?ú				 
void IIC_Start(void);				//·￠?íIIC?aê?D?o?
void IIC_Stop(void);	  			//·￠?íIICí￡?1D?o?
void IIC_Send_Byte(u8 txd);			//IIC·￠?íò???×??ú
u8 IIC_Read_Byte(unsigned char ack);//IIC?áè?ò???×??ú
u8 IIC_Wait_Ack(void); 				//IICμè′yACKD?o?
void IIC_Ack(void);					//IIC·￠?íACKD?o?
void IIC_NAck(void);				//IIC2?·￠?íACKD?o?
 
void IIC_WriteByte(uint16_t addr,uint8_t data,uint8_t device_addr);
uint16_t IIC_ReadByte(uint16_t addr,uint8_t device_addr,uint8_t ByteNumToRead);//??′??÷μ??·￡??÷?tμ??·￡?òa?áμ?×??úêy  


void  read_AHT20_once(void);
void  reset_AHT20(void);
void  init_AHT20(void);	
void  startMeasure_AHT20(void);
void  read_AHT20(void);
uint8_t  Receive_ACK(void);
void  Send_ACK(void);
void  SendNot_Ack(void);
void I2C_WriteByte(uint8_t  input);
uint8_t I2C_ReadByte(void);	
void  set_AHT20sendOutData(void);
void  I2C_Start(void);
void  I2C_Stop(void);
#endif

delay.c：

#include "delay.h"
#include "sys.h"

//STM32F103o?D?°?ày3ì
//?aoˉêy°?±?ày3ì
/********** mcudev.taobao.com 3??·  ********/


// 	 
//è?1?ê1ó?ucos,?ò°üà¨????μ?í·???t?′?é.
#if SYSTEM_SUPPORT_UCOS
#include "includes.h"					//ucos ê1ó?	  
#endif
//	 

//STM32?a·￠°?
//ê1ó?SysTickμ???í¨??êy?￡ê????ó3ù??DD1üàí
//°üà¨delay_us,delay_ms

// 	 
static u8  fac_us=0;//us?óê±±?3?êy
static u16 fac_ms=0;//ms?óê±±?3?êy
#ifdef OS_CRITICAL_METHOD 	//è?1?OS_CRITICAL_METHOD?¨ò?á?,?μ?÷ê1ó?ucosIIá?.
//systick?D??·t??oˉêy,ê1ó?ucosê±ó?μ?
void SysTick_Handler(void)
{				   
	OSIntEnter();		//??è??D??
    OSTimeTick();       //μ÷ó?ucosμ?ê±?ó·t??3ìDò               
    OSIntExit();        //′￥·￠è????D??èí?D??
}
#endif

//3?ê??ˉ?ó3ùoˉêy
//μ±ê1ó?ucosμ?ê±oò,′?oˉêy?á3?ê??ˉucosμ?ê±?ó?ú??
//SYSTICKμ?ê±?ó1ì?¨?aHCLKê±?óμ?1/8
//SYSCLK:?μí3ê±?ó
void delay_init()	 
{

#ifdef OS_CRITICAL_METHOD 	//è?1?OS_CRITICAL_METHOD?¨ò?á?,?μ?÷ê1ó?ucosIIá?.
	u32 reload;
#endif
	SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);	//????ía2?ê±?ó  HCLK/8
	fac_us=SystemCoreClock/8000000;	//?a?μí3ê±?óμ?1/8  
	 
#ifdef OS_CRITICAL_METHOD 	//è?1?OS_CRITICAL_METHOD?¨ò?á?,?μ?÷ê1ó?ucosIIá?.
	reload=SystemCoreClock/8000000;		//?????óμ???êy′?êy μ￥???aK	   
	reload*=1000000/OS_TICKS_PER_SEC;//?ù?YOS_TICKS_PER_SECéè?¨ò?3?ê±??
							//reload?a24????′??÷,×?′ó?μ:16777216,?ú72M??,??o?1.86s×óóò	
	fac_ms=1000/OS_TICKS_PER_SEC;//′ú±íucos?éò??óê±μ?×?éùμ￥??	   
	SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;   	//?a??SYSTICK?D??
	SysTick->LOAD=reload; 	//??1/OS_TICKS_PER_SEC???D??ò?′?	
	SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;   	//?a??SYSTICK    
#else
	fac_ms=(u16)fac_us*1000;//·?ucos??,′ú±í????msDèòaμ?systickê±?óêy   
#endif
}								    

#ifdef OS_CRITICAL_METHOD	//ê1ó?á?ucos
//?óê±nus
//nus?aòa?óê±μ?usêy.		    								   
void delay_us(u32 nus)
{		
	u32 ticks;
	u32 told,tnow,tcnt=0;
	u32 reload=SysTick->LOAD;	//LOADμ??μ	    	 
	ticks=nus*fac_us; 			//Dèòaμ??ú??êy	  		 
	tcnt=0;
	told=SysTick->VAL;        	//????è?ê±μ???êy?÷?μ
	while(1)
	{
		tnow=SysTick->VAL;	
		if(tnow!=told)
		{	    
			if(tnow<told)tcnt+=told-tnow;//?aà?×￠òaò???SYSTICKê?ò???μY??μ???êy?÷?í?éò?á?.
			else tcnt+=reload-tnow+told;	    
			told=tnow;
			if(tcnt>=ticks)break;//ê±??3?1y/μèóúòa?ó3ùμ?ê±??,?òí?3?.
		}  
	}; 									    
}
//?óê±nms
//nms:òa?óê±μ?msêy
void delay_ms(u16 nms)
{	
	if(OSRunning==TRUE)//è?1?osò??-?ú?üá?	    
	{		  
		if(nms>=fac_ms)//?óê±μ?ê±??′óóúucosμ?×?éùê±???ü?ú 
		{
   			OSTimeDly(nms/fac_ms);//ucos?óê±
		}
		nms%=fac_ms;				//ucosò??-?T·¨ìá1??a?′D?μ??óê±á?,2éó???í¨·?ê??óê±    
	}
	delay_us((u32)(nms*1000));	//??í¨·?ê??óê±,′?ê±ucos?T·¨???ˉμ÷?è.
}
#else//2?ó?ucosê±
//?óê±nus
//nus?aòa?óê±μ?usêy.		    								   
void delay_us(u32 nus)
{		
	u32 temp;	    	 
	SysTick->LOAD=nus*fac_us; //ê±???ó??	  		 
	SysTick->VAL=0x00;        //??????êy?÷
	SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;          //?aê?μ1êy	 
	do
	{
		temp=SysTick->CTRL;
	}
	while(temp&0x01&&!(temp&(1<<16)));//μè′yê±??μ?′?   
	SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;       //1?±???êy?÷
	SysTick->VAL =0X00;       //??????êy?÷	 
}
//?óê±nms
//×￠òanmsμ?·??§
//SysTick->LOAD?a24????′??÷,?ùò?,×?′ó?óê±?a:
//nms<=0xffffff*8*1000/SYSCLK
//SYSCLKμ￥???aHz,nmsμ￥???ams
//??72Mì??t??,nms<=1864 
void delay_ms(u16 nms)
{	 		  	  
	u32 temp;		   
	SysTick->LOAD=(u32)nms*fac_ms;//ê±???ó??(SysTick->LOAD?a24bit)
	SysTick->VAL =0x00;           //??????êy?÷
	SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;          //?aê?μ1êy  
	do
	{
		temp=SysTick->CTRL;
	}
	while(temp&0x01&&!(temp&(1<<16)));//μè′yê±??μ?′?   
	SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;       //1?±???êy?÷
	SysTick->VAL =0X00;       //??????êy?÷	  	    
} 
#endif

delay.h：

#ifndef __DELAY_H
#define __DELAY_H 			   
#include "sys.h"
//	 

//STM32F103o?D?°?ày3ì
//?aoˉêy°?±?ày3ì
/********** mcudev.taobao.com 3??·  ********/


//ê1ó?SysTickμ???í¨??êy?￡ê????ó3ù??DD1üàí
//°üà¨delay_us,delay_ms

// 	 
void delay_init(void);
void delay_ms(u16 nms);
void delay_us(u32 nus);

#endif

在bsp_i2c.c函数中包含对传感器内容的编写，主要有传感器的初始化和读写数据程序：
初始化：

void  read_AHT20_once(void)
{
	delay_ms(10);

	reset_AHT20();//重置AHT20芯片
	delay_ms(10);

	init_AHT20();//初始化AHT20芯片
	delay_ms(10);

	startMeasure_AHT20();//开始测试AHT20芯片
	delay_ms(80);

	read_AHT20();//读取AHT20采集的到的数据
	delay_ms(5);
}

读写数据：

void read_AHT20(void)
{
	uint8_t   i;

	for(i=0; i<6; i++)
	{
		readByte[i]=0;
	}

	//-------------
	I2C_Start();//I2C启动

	I2C_WriteByte(0x71);//I2C写数据
	ack_status = Receive_ACK();//收到的应答信息
	readByte[0]= I2C_ReadByte();//I2C读取数据
	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();//I2C停止函数

	//--------------
	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");
	//根据AHT20芯片中，温度和湿度的计算公式，得到最终的结果，通过串口显示
	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");
}

结果

在这里插入图片描述
在这里插入图片描述

  • 烧录
    在这里插入图片描述

温湿度展示

在这里插入图片描述
可以看到结果显示程序陆续读取到温湿度信息，
当我们对着传感器哈气会发现显示的温度微微变化，湿度上升幅度很大。

#四、 总结
通过这次实验，学习了I2C总线通信协议，使用STM32F103完成基于I2C协议的AHT20温湿度传感器的数据采集，并将采集的温度-湿度值通过串口输出。
熟悉了keil的操作以及串口的调试。
同时还要连线要仔细，不要连错了。
嵌入式系统作业9*

ANK空檩
关注
专栏目录
嵌入式作业
07-09
嵌入式作业-嵌入式系统开发中的排序和查找算法 嵌入式作业是指在嵌入式系统中执行的作业，涉及到对数组的排序和查找。这里我们将讨论两个常用的算法：冒泡排序和二分查找算法。 冒泡排序算法 冒泡排序算法是一种...
嵌入式技术大作业-智能家居 proteus仿真,Arduino版
03-31
在这个“嵌入式技术大作业-智能家居 proteus仿真,Arduino版”项目中，我们将探讨几个关键知识点。 首先，密码锁是系统中的一个重要组件，它涉及到安全认证技术。在嵌入式系统中，密码锁可能通过微控制器（如Arduino...
通过串口实现printf函数，中断实现串口数据接收
weixin_44651073的博客
07-05 4537
通过串口实现printf函数，中断实现串口数据接收
STM32 fputc函数(重定向)
Cypher的博客
11-28 4019
在需要用到显示功能的代码中，用printf写法会快很多。 struct __FILE { int handle; }; FILE __stdout; //定义_sys_exit()以避免使用半主机模式 void _sys_exit(int x) { x = x; } //重定义fputc函数 int fputc(int ch, FILE *f){ ...
printf函数在STM32中用来打印输出的调试信息
lj1986817902的博客
05-22 1718
printf函数在STM32中用来打印输出的调试信息 代码如下所示： //在非os操作系统的情况下调用该函数即可 #if 1 #pragma import(__use_no_semihosting) //标准库需要的支持函数 struct __FILE { int handle; }; FILE __stdout; //定义_sys_exit()以避免使用半主机模式 void _sys_exit(int x) {
STM32 printf 方法重定向到串口UART
IOsetting的专栏
04-28 1111
在嵌入式系统中调试代码是很麻烦的一件事, 如果能方便地输出调试信息(与调试者交互), 能使极大加快问题排查的过程. 串口在嵌入式领域是一个比较重要的通讯接口. 因为没有显示设备, 在单片机的程序里调用printf()打印内容是不可见的，但我们可以利用它的外设来实现printf()，比如串口, 串口基本上大多数单片机都有, 通常用串口来打印内容. 通过重写fputc()函数来实现. fputc()...
解释一下printf()函数 fputs() 标准输入输出stdout stdin stderr
dianqicyuyan的博客
08-18 3505
printf为C语言中的库函数，需要包含头文件stdio.h，能够发送格式化输出到标准输出stdout，printf函数的声明如下。 printf函数的定义调用了fputs函数 我们在STM32单片机上面使用printf函数时，需要对fputs进行重定向，重定向为输出到串口，然后再通过串口转USB把数据输出到电脑上串口工具 u8 print_level=2;//打印开关 FILE __stdout; //加入以下代码，支持printf函数 #pragma import(__use_no_semiho
嵌入式作业嵌入式作业.doc
06-12
嵌入式作业嵌入式作业.doc 本文将对 ARM 指令系统的特点、协处理器的作用、Thumb 指令、RISC 指令的特点、立即数和直接地址等知识点进行详细的解释和分析。 1. ARM 指令系统的特点 ARM 指令系统属于 RISC 指令...
基于WHEELTEC B570 平衡小车的嵌入式作业代码+文档说明（高分项目）
最新发布
10-30
基于WHEELTEC B570 平衡小车的嵌入式作业代码+文档说明（高分项目）基于WHEELTEC B570 平衡小车的嵌入式作业代码+文档说明（高分项目）基于WHEELTEC B570 平衡小车的嵌入式作业代码+文档说明（高分项目）基于...
STM32入门：STM32F401CDU6库函数工程文件搭建
混子还在路上
10-24 1655
学习分享，一起成长！以上为小编的总结分享，若存在不当之处，请批评指正！根据下图的结构进行复制粘贴操作，代码部分在本文末有贴出来，时延采用的 Systick 定时器，代码详解可参考文章 《文件下载（使用part1即可）
cortex-m3,4 ITM printf 使用
chiooo的专栏
02-09 1713
include “stdio.h”struct __FILE { int handle; /* Add whatever you need here */ }; FILE __stdout; FILE __stdin;int fputc(int ch, FILE *f) { if (DEMCR
keil5串口printf重定向使用注意
weixin_55576473的博客
07-24 863
当我们加入重定向函数后，使用printf仍然没有输出结果，则还需要以下步骤。
STM32串口printf函数重定向
爱吃鱼的猫
06-08 1214
在进行MCU处理器的程序调试时，免不了需要使用串口打印调试信息到PC端进行程序代码运行状态的追踪监视，使用串口自身的发送函数进行输出打印，难免不是很灵活，一般情况下对printf函数进行重定向，打印调试信息。 printf函数是由C语言标准库实现的，使用时需要包含头文件include <stdio.h>,在C语言标准库中定义了三类终端，stdin,stdout,stderr,其中printf默认输出数据到stdout终端中，我门可以通过修改printf底层函数fputc(),来使printf函
【STM32】printf函数重定向至UART 打印设备状态LOG
徐腾腾的博客
08-26 1847
这样做的好处：可以很好的监控设备，以适当取代麻烦的debug； 用printf()函数代替串口发送，更易用 很简单，分两步 1.选择支持printf重定向的库 （1）在Target中选择Use MicroLIB （2）或者在usart.c中添加 #pragma import(__use_no_semihosting) //标准库需要的支持函数 struct __FILE { int handle; }; FILE __stdou.
linux创建文件结构体,Linux file 结构体和 inode 结构体,Go语言入门技术,Go语言基础...
weixin_36016076的博客
05-01 204
在设备驱动程序中，一般需要关心两个结构体：file 和 inode。1. file 结构体file 结构体代表一个打开的文件，系统中每个打开的文件在内核空间都有一个关联的 struct file。它由内核在打开文件时创建，并传递给在文件上进行操作的任何函数。在文件的所有实例都关闭后，内核释放这个数据结构。注：在内核和驱动源代码中，struct file 的指针通常被命名为 file 或 filp(...
在STM32上使用printf的两种方法
热门推荐
xyzjacky的博客
12-24 5万+
单片机的开发中，很多时候我们需要看单片机的工作情况，比如看寄存器的变化，看局部变量或者全局变量，又或者程序的逻辑设计有问题，没有按预设进行某一个步骤，此时要查看程序跑到哪一个步骤里去了，等等，我们都需要查看与验证。通常我们会查用两种办法，一种是debug，一种是把要查看的信息利用某种数据接口打印出来。 debug的好处很多，不足之处也有，好处是直接看内存、看寄存器（要...
16. 串口通信实验讲解
蓝胖子 (*^_^*)的博客
03-06 1172
串口配置的一般步骤 //加入以下代码,支持printf函数,而不需要选择use MicroLIB #if 1 #pragma import(__use_no_semihosting) //标准库需要的支持函数 struct __FILE { int handle; }; FILE __stdout; //定义_sys_exit()以避免使用半主机模式 _sys_exit(int x) { x .
jlink 驱动_Jlink使用技巧之虚拟串口功能
weixin_39958559的博客
12-03 512
前言串口调试是单片机开发过程必不可少的一个功能，一般是使用一个UART-TTL的串口模块来实现串口的功能，其实下载调试使用的Jlink仿真器也可以实现串口调试的功能，本篇文章将介绍如何使用Jlink实现虚拟串口功能。ITM简介ITM是ARM Cortex-M系列内核芯片中的一种全新的调试功能，可以方便的通过调试器来实现printf调试功能。来自STM32中文参考手册的介绍： ITM ( 指令跟踪微...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值