嵌入式作业9
目录
一、关于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("rn");
printf("温度:%d%d.%d",T1/100,(T1/10)%10,T1%10);
printf("湿度:%d%d.%d",H1/100,(H1/10)%10,H1%10);
printf("rn");
}
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("rn");
//根据AHT20芯片中，温度和湿度的计算公式，得到最终的结果，通过串口显示
printf("温度:%d%d.%d",T1/100,(T1/10)%10,T1%10);
printf("湿度:%d%d.%d",H1/100,(H1/10)%10,H1%10);
printf("rn");
}
结果
- 烧录
温湿度展示
可以看到结果显示程序陆续读取到温湿度信息，
当我们对着传感器哈气会发现显示的温度微微变化，湿度上升幅度很大。
#四、 总结
通过这次实验，学习了I2C总线通信协议，使用STM32F103完成基于I2C协议的AHT20温湿度传感器的数据采集，并将采集的温度-湿度值通过串口输出。
熟悉了keil的操作以及串口的调试。
同时还要连线要仔细，不要连错了。
嵌入式系统作业9*
本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
THE END
二维码