STM32学习之I2C-电子工程世界

分享到: 微博; QQ; 微信; LinkedIn

I2C总线是由NXP（原PHILIPS）公司设计，有十分简洁的物理层定义,其特性如下：

只要求两条总线线路：一条串行数据线SDA，一条串行时钟线SCL；
每个连接到总线的器件都可以通过唯一的地址和一直存在的简单的主机/从机关系软件设定地址，主机可以作为主机发送器或主机接收器；
它是一个真正的多主机总线，如果两个或更多主机同时初始化，数据传输可以通过冲突检测和仲裁防止数据被破坏；
串行的8 位双向数据传输位速率在标准模式下可达100kbit/s，快速模式下可达400kbit/s，高速模式下可达3.4Mbit/s；
连接到相同总线的IC 数量只受到总线的最大电容400pF 限制。

其典型的接口连线如下：

I2C的协议很简单：

数据的有效性

　　在传输数据的时候，SDA线必须在时钟的高电平周期保持稳定，SDA的高或低电平状态只有在SCL 线的时钟信号是低电平时才能改变。

起始和停止条件

　　SCL 线是高电平时，SDA 线从高电平向低电平切换，这个情况表示起始条件；

　　SCL 线是高电平时，SDA 线由低电平向高电平切换，这个情况表示停止条件。

字节格式

　　发送到SDA 线上的每个字节必须为8 位，每次传输可以发送的字节数量不受限制。每个字节后必须处理一个响应位。

应答响应　　

数据传输必须带响应，相关的响应时钟脉冲由主机产生。在响应的时钟脉冲期间发送器释放SDA 线（高）。　　

在响应的时钟脉冲期间，接收器必须将SDA 线拉低，使它在这个时钟脉冲的高电平期间保持稳定的低电平。

也就是说主器件发送完一字节数据后要接收一个应答位（低电平），从器件接收完一个字节后要发送一个低电平。

寻址方式(7位地址方式)

　　第一个字节的头7 位组成了从机地址，最低位（LSB）是第8 位，它决定了传输的普通的和带重复开始条件的7位地址格式方向。第一个字节的最低位是

“0”，表示主机会写信息到被选中的从机；

“1”表示主机会向从机读信息。

当发送了一个地址后，系统中的每个器件都在起始条件后将头7 位与它自己的地址比较，如果一样，器件会判定它被主机寻址，至于是从机接收器还是从机发送器，都由R/W 位决定。

仲裁

I2C是所主机总线，每个设备都可以成为主机，但任一时刻只能有一个主机。

stm32至少有一个I2C接口，提供多主机功能，可以实现所有I2C总线的时序、协议、仲裁和定时功能，支持标准和快速传输两种模式，同时与SMBus 2.0兼容。

本实验直接操作寄存器实现对I2C总线结构的EEPROM AT24c02的写入和读取。AT24c02相关操作详见单片机读取EEPROM(AT24C02)。

库函数实现使用stm32的两个I2C模拟I2C设备间的数据收发，并通过串口查看数据交换情况。

直接操作寄存器

首先需要配置I2C接口的时钟,相关寄存器如下：

I2C_CR2寄存器低五位：

FREQ[5:0]：I2C模块时钟频率，必须设置正确的输入时钟频率以产生正确的时序，允许的范围在2～36MHz之间：

000000：禁用 000001：禁用 000010：2MHz ... 100100：36MHz 大于100100：禁用。

用于设置I2C设备的输入时钟，本例使用的是PLCK1总线上的时钟所以为36Mhz;

时钟控制寄存器(I2C_CCR)低12位：

CCR[11:0]：快速/标准模式下的时钟控制分频系数(主模式)，该分频系数用于设置主模式下的SCL时钟。

在I2C标准模式或SMBus模式下：

Thigh = CCR ×TPCLK1

Tlow = CCR ×TPCLK1

时钟周期为 T = Thigh + Tlow;

例如：在标准模式下，FREQR = 36 即36Mhz,产生200kHz的SCL的频率

时钟控制分频系数 = Freqr /2/f f 为想得到的频率

配置好时钟，还需要配置本机地址，I2C支持7位地址和10位地址，这里用的是7位地址：

自身地址寄存器1(I2C_OAR1)[7:1]：接口地址，地址的7~1位。

其他相关操作参见代码，有详细注释：（system.h 和 stm32f10x_it.h 等相关代码参照 stm32 直接操作寄存器开发环境配置）

User/main.c

#include

02	#include "system.h"

03	#include "usart.h"

04	#include "i2c.h"

06	#define LED1 PAout(4)

07	#define LED2 PAout(5)

08	#define LED3 PAout(6)

09	#define LED4 PAout(7)

11	void Gpio_Init(void);

13	int main(void)

{

16	Rcc_Init(9); //系统时钟设置

18	Usart1_Init(72,9600);

20	Nvic_Init(1,0,I2C1_EV_IRQChannel,4); //设置抢占优先级为1，响应优先级为0，中断分组为4

22	Nvic_Init(0,0,I2C1_ER_IRQChannel,4); //设置I2C错误中断抢占优先级为0

24	Gpio_Init();

26	I2c_Init(0x30); //设置I2C1地址为0x30

28	I2c_Start();

while(1);

}

34	void Gpio_Init(void)

{

36	RCC->APB2ENR \|= 1<<2; //使能PORTA时钟

37	RCC->APB2ENR \|= 1<<3; //使能PORTB时钟;

40	GPIOA->CRL &= 0x0000FFFF; // PA0~3设置为浮空输入，PA4~7设置为推挽输出

41	GPIOA->CRL \|= 0x33334444;

44	GPIOB->CRL &= 0x00FFFFFF; //PB6 I2C1_SCL ,PB7 I2C1_SDL

45	GPIOB->CRL \|= 0xFF000000; //复用开漏输出

47	//USART1 串口I/O设置

49	GPIOA -> CRH &= 0xFFFFF00F; //设置USART1 的Tx(PA.9)为第二功能推挽，50MHz；Rx(PA.10)为浮空输入

50	GPIOA -> CRH \|= 0x000008B0;

}

User/stm32f10x_it.c

001	#include "stm32f10x_it.h"

002	#include "system.h"

003	#include "stdio.h"

004	#include "i2c.h"

005

006	#define LED1 PAout(4)

007	#define LED2 PAout(5)

008	#define LED3 PAout(6)

009	#define LED4 PAout(7)

010

011	#define ADDRS_R 0xA1 //读操作地址

012	#define ADDRS_W 0xA0 //写操作地址

013

014	u8 go = 0; //操作步骤标记

015

016	void I2C1_EV_IRQHandler(void) //I2C1 Event Interrupt

017

{

018	u16 clear = 0;

019

020	if(I2C1 -> SR1 & 1<<0 ) //已发送起始条件,写数据寄存器的操作将清除该位

021

{

022	printf("rn I2C1 Start .. rn");

023

024	switch(go)

025

{

026

case 0:{

027	I2c_Write(ADDRS_W); //写入从机地址,写指令操作地址

028

break;

029

}

030

case 1:{

031	I2c_Write(ADDRS_W); //写入从机地址,写指令操作地址

032

break;

033

}

034

case 2:{

035	I2c_Write(ADDRS_R); //写入从机地址,读数据操作地址

036

break;

037

}

038

}

039

040

}

041

042	if(I2C1 -> SR1 & 1<<1 ) //从机地址已发送

043

{

044	printf("rn I2C1 has send address .. rn");

045	clear = I2C1 -> SR2; //读取SR2可以清除该位中断

046

047	switch(go)

048

{

049

case 0:{

050	I2c_Write(0x01); //写入待写入的EEPROM单元地址

051

break;

052

}

053

054

case 1:{

055	I2c_Write(0x01); //写入待写入的EEPROM单元地址

056

break;

057

}

058

case 2:{

059	delay(100000);

060	printf("rn Read 0x%X from At24c02 ,Address 0x01 .. rn",I2c_Read());

061	I2c_Stop();

062

break;

063

}

064

}

065

066

}

067

068	if(I2C1 -> SR1 & 1<<2 ) //字节发送结束发送地址字节时，不触发此中断

069

{

070

071	//printf("rn I2C1 send byte success .. rn");

072	switch(go)

073

{

074

case 0:{

075	I2c_Write(0x86); //写入数据

076	printf("rn Write 0x%X to At24c02 ,Address 0x01 .. rn",0x86);

077	//I2c_Stop();

078

079	delay(10000);

080

go = 1;

081	I2c_Start();

082

break;

083

}

084

085

case 1:{

086

087	delay(10000);

088

go = 2;

089	I2c_Start();

090

break;

091

}

092

case 2:{

093

094

break;

095

}

096

}

097

098

}

099

100	delay(100000);

101

LED3 = 1;

102

103	//I2C1 -> CR2 &= ~(1<<9); //事件中断关闭

104

}

105

106	void I2C1_ER_IRQHandler(void) //I2C1 Error Interrupt

107

{

108	delay(100000);

109

LED4 = 1;

110

111	if(I2C1->SR1 & 1<<10) //应答失败

112

{

113	printf("rn ACK ERROR .. rn");

114

115	I2C1->SR1 &=~(1<<10); //清除中断

116

}

117

118	if(I2C1->SR1 & 1<<14) //超时

119

{

120	printf("rn Timeout .. rn");

121

122	I2C1->SR1 &=~(1<<14); //清除中断

123

}

124

125	if(I2C1->SR1 & 1<<11) //过载/欠载

126

{

127	printf("rn Overrun/Underrun .. rn");

128	I2C1->SR1 &=~(1<<11); //清除中断

129

}

130

131	if(I2C1->SR1 & 1<<9) //仲裁丢失

132

{

133	printf("rn Arbitration lost .. rn");

134	I2C1->SR1 &=~(1<<9); //清除中断

135

}

136

137	if(I2C1->SR1 & 1<<8) //总线出错

138

{

139	printf("rn Bus error .. rn");

140	I2C1->SR1 &=~(1<<8); //清除中断

141

}

142

143

144

}

Library/src/i2c.c

view source print ?

01	#include "i2c.h"

03	void I2c_Init(u16 Addr )

{

06	RCC -> APB1ENR \|= 1<<21; //打开I2C1时钟

07	//RCC -> APB1ENR \|= 1<<22; //打开I2C2时钟

09	RCC->APB1RSTR \|= 1<<21; //复位I2C1

10	RCC->APB1RSTR &= ~(1<<21); //复位结束I2C1

11	//RCC->APB1RSTR \|= 1<<22; //复位I2C2

13	//I2C1 -> CR1 \|= 1<<15; //复位寄存器

15	//I2C模块时钟频率,2～36MHz之间

16	I2C1 -> CR2 \|= 36 ; //000000：禁用 000001：禁用 000010：2MHz ... 100100：36MHz

19	I2C1 -> CCR \|= 0<<15; //I2C主模式 0：标准模式的I2C 1：快速模式的I2C

20	//I2C1 -> CCR \|= 1<<14; //快速模式时的占空比 0 Tlow/Thigh = 2 1 Tlow/Thigh = 16/9

22	//得到200kHz频率

23	I2C1 -> CCR \|= 90<<0; //时钟控制分频系数 = PCLK1 /2/f f 为想得到的频率

25	//主模式最大上升时间

26	I2C1 -> TRISE \|= 37; //最大允许SCL上升时间为1000ns，故TRISE[5:0]中必须写入(1us/(1/36)us = 36+1)。

28	I2C1 -> CR1 \|= 1<<10; //打开ACK应答,在接收到一个字节后返回一个应答

29	I2C1 -> CR1 \|= 1<<6; //广播呼叫使能

31	I2C1 -> OAR1 \|= 0<<15; //寻址模式 1 响应10位地址 0 响应7位地址

33	I2C1 -> OAR1 \|= 1<<14; //必须始终由软件保持为 1

35	I2C1 -> OAR1 \|= Addr <<1 ; //设置接口地址的 7~1位

37	//I2C1 -> OAR1 \|= 0 ; //设置10位地址模式时地址第0位

38	//I2C1 -> OAR1 \|= 0<<8; //设置10位地址模式时地址第9~8位

40	//I2C1 -> CR2 \|= 1<<10; //缓冲器中断使能

41	I2C1 -> CR2 \|= 1<<9; //事件中断使能

42	I2C1 -> CR2 \|= 1<<8; //出错中断使能

44	I2C1 -> CR1 \|= 1<<0; //开启I2C1

}

48	void I2c_Start()

{

51	I2C1 -> CR1 \|= 1<<8; //I2C1产生起始条件

}

54	void I2c_Stop()

{

56	I2C1 -> CR1 \|= 1<<9; //I2C1产生停止条件

}

60	void I2c_Write(u8 data)

{

62	I2C1 -> DR = data;

}

65	u8 I2c_Read()

{

67	while(!(I2C1 -> SR1 & 1<<6)); //接收到数据标志位

69	return I2C1 -> DR;

}

72	void I2c_End() //关闭I2C

{

74	I2C1 -> CR1 &= ~(1<<0);

}

Library/inc/i2c.h

#include

3	void I2c_Init(u16 Addr );

5	void I2c_Start(void);

6	void I2c_Stop(void);

7	void I2c_Write(u8 data);

8	u8 I2c_Read(void);

9	void I2c_End(void);

串口接收数据如下：

I2C1 Start ..

I2C1 has send address ..

Write 0x86 to At24c02 ,Address 0x01 ..

I2C1 Start ..

I2C1 has send address ..

I2C1 Start ..

I2C1 has send address ..

Read 0x86 from At24c02 ,Address 0x01 ..

库函数操作

main.c

001	#include "stm32f10x.h"

002	#include "stdio.h"

003

004	#define PRINTF_ON 1

005

006	void RCC_Configuration(void);

007	void GPIO_Configuration(void);

008	void USART_Configuration(void);

009	void I2C_Configuration(void);

010	void NVIC_Configuration(void);

011

012

013	u8 I2C1_ADDRESS = 0x30; //7位 I2C 地址

014	u8 I2C2_ADDRESS = 0x31;

015

016	#define Size 4

017

018	vu8 I2C1_Buffer_Tx[Size] = {1,2,3,4};

019	vu8 I2C2_Buffer_Rx[Size] = {0};

020

021	u32 BufferSize = Size ;

022

023	int main(void)

024

{

025	RCC_Configuration();

026	GPIO_Configuration();

027	USART_Configuration();

028	I2C_Configuration();

029	NVIC_Configuration();

030

031	I2C_GenerateSTART(I2C1,ENABLE);

032

033

while(1);

034

}

035

036	void I2C_Configuration(void)

037

{

038	I2C_InitTypeDef I2C_InitStructure;

039

040	I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;

041	I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;

042	I2C_InitStructure.I2C_OwnAddress1 = I2C1_ADDRESS;

043	I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;

044	I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;

045	I2C_InitStructure.I2C_ClockSpeed = 200000;

046	I2C_Init(I2C1,&I2C_InitStructure);

047

048	I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;

049	I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;

050	I2C_InitStructure.I2C_OwnAddress1 = I2C2_ADDRESS;

051	I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;

052	I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;

053	I2C_InitStructure.I2C_ClockSpeed = 200000;

054	I2C_Init(I2C2,&I2C_InitStructure);

055

056

057	I2C_ITConfig(I2C1,I2C_IT_EVT\|I2C_IT_BUF,ENABLE);

058	I2C_ITConfig(I2C2,I2C_IT_EVT\|I2C_IT_BUF,ENABLE);

059

060	I2C_Cmd(I2C1,ENABLE);

061	I2C_Cmd(I2C2,ENABLE);

062

}

063

064	void NVIC_Configuration(void)

065

{

066	NVIC_InitTypeDef NVIC_InitStructure;

067

068	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);

069

070	NVIC_InitStructure.NVIC_IRQChannel = I2C1_EV_IRQn;

071	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;

072	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;

073	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

074	NVIC_Init(&NVIC_InitStructure);

075

076	NVIC_InitStructure.NVIC_IRQChannel = I2C2_EV_IRQn;

077	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;

078	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;

079	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

080	NVIC_Init(&NVIC_InitStructure);

081

}

082

083	void GPIO_Configuration(void)

084

{

085	GPIO_InitTypeDef GPIO_InitStructure;

086

087	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

088

089	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6\|GPIO_Pin_7;

090	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;

091	GPIO_Init(GPIOB , &GPIO_InitStructure);

092

093	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10\|GPIO_Pin_11;

094	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

095	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;

096	GPIO_Init(GPIOB , &GPIO_InitStructure);

097

098

099	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;

100	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

101	GPIO_Init(GPIOA , &GPIO_InitStructure);

102

103	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;

104	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;

105	GPIO_Init(GPIOA , &GPIO_InitStructure);

106

}

107

108	void RCC_Configuration(void)

109

{

110	/* 定义枚举类型变量 HSEStartUpStatus */

111	ErrorStatus HSEStartUpStatus;

112

113	/* 复位系统时钟设置*/

114	RCC_DeInit();

115	/* 开启HSE*/

116	RCC_HSEConfig(RCC_HSE_ON);

117	/* 等待HSE起振并稳定*/

118	HSEStartUpStatus = RCC_WaitForHSEStartUp();

119	/* 判断HSE起是否振成功，是则进入if()内部 */

120	if(HSEStartUpStatus == SUCCESS)

121

{

122	/* 选择HCLK（AHB）时钟源为SYSCLK 1分频 */

123	RCC_HCLKConfig(RCC_SYSCLK_Div1);

124	/* 选择PCLK2时钟源为 HCLK（AHB） 1分频 */

125	RCC_PCLK2Config(RCC_HCLK_Div1);

126	/* 选择PCLK1时钟源为 HCLK（AHB） 2分频 */

127	RCC_PCLK1Config(RCC_HCLK_Div2);

128	/* 设置FLASH延时周期数为2 */

129	FLASH_SetLatency(FLASH_Latency_2);

130	/* 使能FLASH预取缓存 */

131	FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);

132	/* 选择锁相环（PLL）时钟源为HSE 1分频，倍频数为9，则PLL输出频率为 8MHz * 9 = 72MHz */

133	RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);

134	/* 使能PLL */

135	RCC_PLLCmd(ENABLE);

136	/* 等待PLL输出稳定 */

137	while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);

138	/* 选择SYSCLK时钟源为PLL */

139	RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);

140	/* 等待PLL成为SYSCLK时钟源 */

141	while(RCC_GetSYSCLKSource() != 0x08);

142

}

143	/* 打开APB2总线上的GPIOA时钟*/

144	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA\|RCC_APB2Periph_GPIOB\|RCC_APB2Periph_USART1, ENABLE);

145

146	//RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);

147

148	RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1\|RCC_APB1Periph_I2C2,ENABLE);

149	//RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR\|RCC_APB1Periph_BKP\|RCC_APB1Periph_WWDG\|RCC_APB1Periph_SPI2, ENABLE);

150

151

}

152

153

154	void USART_Configuration(void)

155

{

156	USART_InitTypeDef USART_InitStructure;

157	USART_ClockInitTypeDef USART_ClockInitStructure;

158

159	USART_ClockInitStructure.USART_Clock = USART_Clock_Disable;

160	USART_ClockInitStructure.USART_CPOL = USART_CPOL_Low;

161	USART_ClockInitStructure.USART_CPHA = USART_CPHA_2Edge;

162	USART_ClockInitStructure.USART_LastBit = USART_LastBit_Disable;

163	USART_ClockInit(USART1 , &USART_ClockInitStructure);

164

165	USART_InitStructure.USART_BaudRate = 9600;

166	USART_InitStructure.USART_WordLength = USART_WordLength_8b;

167	USART_InitStructure.USART_StopBits = USART_StopBits_1;

168	USART_InitStructure.USART_Parity = USART_Parity_No;

169	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;

170	USART_InitStructure.USART_Mode = USART_Mode_Rx\|USART_Mode_Tx;

171	USART_Init(USART1,&USART_InitStructure);

172

173	USART_Cmd(USART1,ENABLE);

174

}

175

176	#if PRINTF_ON

177

178	int fputc(int ch,FILE *f)

179

{

180	USART_SendData(USART1,(u8) ch);

181	while(USART_GetFlagStatus(USART1,USART_FLAG_TC) == RESET);

182	return ch;

183

}

184

185

#endif

stm32f10x_it.c

01	#include "stm32f10x_it.h"

02	#include "stdio.h"

04	extern u32 BufferSize ;

05	extern u8 I2C1_ADDRESS ;

06	extern u8 I2C2_ADDRESS ;

08	extern vu8 I2C1_Buffer_Tx[];

09	extern vu8 I2C2_Buffer_Rx[];

10	vu32 Tx_Counter = 0;

11	vu32 Rx_Counter = 0;

13	void I2C1_EV_IRQHandler(void)

{

15	switch(I2C_GetLastEvent(I2C1))

{

17	case I2C_EVENT_MASTER_MODE_SELECT: //已发送启始条件

{

19	I2C_Send7bitAddress(I2C1,I2C2_ADDRESS,I2C_Direction_Transmitter);

break;

}

22	case I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED: //已发送从机地址

{

24	printf("rn The I2C1 has send data %d rn",I2C1_Buffer_Tx[Rx_Counter]);

25	I2C_SendData(I2C1,I2C1_Buffer_Tx[Tx_Counter++]);

break;

}

28	case I2C_EVENT_MASTER_BYTE_TRANSMITTED: //第一个数据已发送

{

30	if(Tx_Counter

{

32	printf("rn The I2C1 has send data %d rn",I2C1_Buffer_Tx[Rx_Counter]);

33	I2C_SendData(I2C1,I2C1_Buffer_Tx[Tx_Counter++]);

}else{

36	I2C_GenerateSTOP(I2C1,ENABLE);

37	I2C_ITConfig(I2C1,I2C_IT_EVT\|I2C_IT_BUF,DISABLE); //计数发送的个数

}

break;

}

42	default: {break;}

}

47	void I2C2_EV_IRQHandler(void)

{

49	switch(I2C_GetLastEvent(I2C2))

{

51	case I2C_EVENT_SLAVE_RECEIVER_ADDRESS_MATCHED: //收到匹配的地址数据

{

break;

}

55	case I2C_EVENT_SLAVE_BYTE_RECEIVED: //收到数据

{

57	if(Rx_Counter < BufferSize )

{

59	I2C2_Buffer_Rx[Rx_Counter] = I2C_ReceiveData(I2C2);

60	printf("rn The I2C2 has received data %d rn",I2C2_Buffer_Rx[Rx_Counter++]); //计数收到的个数

}

break;

}

64	case I2C_EVENT_SLAVE_STOP_DETECTED: //收到结束条件

{

66	I2C_ClearFlag(I2C2,I2C_FLAG_STOPF);

67	I2C_ITConfig(I2C1,I2C_IT_EVT\|I2C_IT_BUF,DISABLE);

break;

}

71	default: {break;}

}

关键字：STM32 I2C 引用地址：STM32学习之I2C

上一篇：STM32 IIC 详解之 stm32 IIC 从机模式
下一篇：【STM32CUBEMX】 I2C Slave 实现

推荐阅读最新更新时间：2024-03-16 16:26

STM32 FreeModbus RTU从机移植以及UART配置

FreeModbus的具体介绍就不提了。至于为什么要移植，大概就是因为移植比较快，而且比较稳定，可以减少因为自己编写出现的漏洞。但是FreeModbus 1.5版本是没有主机的，因此移植的时候只可以做从机。网上有几个关于Modbus主机的源代码，回头等我弄好了再更新。 ================================== 理论上来说，此处我移植了全部，但是只调试了RTU部分，因此其他部分不做赘述。移植过程： 1.将modbus目录下所有文件拷贝加入工程。 2.对modbus中的include下的mbconfig.h进行编辑，裁剪其中需要的模块。（此处我没有进行裁剪，因此选项都是默认） 3.将

[单片机]

<font color='red'>STM32</font> FreeModbus RTU从机移植以及UART配置

stm32之TFT触摸屏：通过LCD_ShowChar显示的过程分析

使用TFT触摸屏时，想要对字符串，图形或者数字进行显示时，发现他们的库函数中都有一个最重要的函数LCD_ShowChar，貌似目前很少有人分析这个函数，虽然简单但是还是有点绕的。先贴一下这个函数的代码，由于函数显示分为叠加显示和非叠加显示，原理类似，所以只分析非叠加方式的部分应该就都懂了。 void LCD_ShowChar(u16 x,u16 y,u8 num,u8 size,u8 mode) { u8 temp,t1,t; u16 y0=y; u16 colortemp=POINT_COLOR; num=num-' ';//得到偏移后的值 if(!mode) //非叠加方式 {

[单片机]

<font color='red'>stm32</font>之TFT触摸屏：通过LCD_ShowChar显示的过程分析

STM32的高级定时器里面死区的概念

“死区”的概念 PWM 脉宽调制在电力电子中，最常用的就是整流和逆变。这就需要用到整流桥和逆变桥。以两电平为例，每个桥臂上有两个电力电子器件，比如IGBT。这两个IGBT不能同时导通，否则就会出现短路的情况。因此，设计带死区的PWM波可以防止上下两个器件同时导通。也就是说，当一个器件导通后关闭，再经过一段死区，这时才能让另一个导通。死区,简单解释通常,大功率电机、变频器等，末端都是由大功率管、IGBT等元件组成的H桥或3相桥。每个桥的上半桥和下半桥是是绝对不能同时导通的，但高速的PWM驱动信号在达到功率元件的控制极时，往往会由于各种各样的原因产生延迟的效果，造成某个半桥元件在应该关断时没有关断，造成功率元件烧毁。死区就是在

[单片机]

详解STM32堆栈

学习STM32单片机的时候，总是能遇到“堆栈”这个概念。分享本文，希望对你理解堆栈有帮助。对于了解一点汇编编程的人，就可以知道，堆栈是内存中一段连续的存储区域，用来保存一些临时数据。堆栈操作由PUSH、POP两条指令来完成。而程序内存可以分为几个区：栈区（stack）堆区（Heap）全局区（static）文字常亮区程序代码区程序编译之后，全局变量，静态变量已经分配好内存空间，在函数运行时，程序需要为局部变量分配栈空间，当中断来时，也需要将函数指针入栈，保护现场，以便于中断处理完之后再回到之前执行的函数。栈是从高到低分配，堆是从低到高分配。普通单片机与STM32单片机中堆栈的区别普通单片机启动时，不需要用b

[单片机]

stm32之nRF24L01无线模块(1)：SPI2到SPI1的移植

本来要接着写滴答定时器的，但是趁热打铁写下SPI2到SPI1的移植。为什么SPI2到SPI1的移植要放在nRF24L01模块里写呢，因为无线模块最重要的数据传输就是通过SPI实现的。为什么需要移植呢，因为即使是一个厂家的板子，不同型号之间它的无线模块引脚也有可能是不同的，顺便稿下移植，加深下理解。SPI2移植到SPI1呢，自己做的时候遇到了一些问题，就从遇到的问题顺便讲下初始化。 1.引脚问题看stm32的手册，不知道为什么，无论在GPIO还是在SPI里都没有看到这个引脚的问题（初学者有可能移植的时候可能纳闷为什么是这些引脚），只有在引脚复用AFIO那里才提了一下，如下图这样才知道SPI1的引脚，但是

[单片机]

<font color='red'>stm32</font>之nRF24L01无线模块(1)：SPI2到SPI1的移植

stm32单片机进入休眠（STOP）模式后无法下载程序等问题解决

利用stm32单片机的休眠模式，使单片机间歇的休眠从而实现低功耗的目的。往往会出现进入休眠后无法唤醒，导致下一次程序烧不进去。通常的解决办法是：一般的开发板或单片机最小系统都会有复位键，按住复位键，点下载，然后松开复位键即可。我遇到的问题是：误入了stm32（STM32L051C6T6）的STOP模式，又没有写入相应的唤醒方法，导致后续的程序不能下载。使用MDK5 点击load时总会出现No target connected。自己设计的最小系统又没有加入复位键。。。有以下几种解决办法： 1、可以将单片机的NRST引脚引出来，外接复位键。（关于引脚查看可用ST官方软件STM32cubeMX，很方便） 2、通过IS

[单片机]

STM32之NVIC中断优先级的介绍

STM32 1.说在前面 1.中断：中断就是CPU在处理一件事的时候，遇到紧急情况，所以就去响应而处理另外一件事（粗略介绍） 2.对于51而言，只有5个中断源，所以难度不算太大，但是，对于CM3内核支持256个中断（16个内核中断加240个内部中断） stm32F103而言，有着60会让可屏蔽中断，所以相对来说比较复杂 2.对于中断的部分寄存器的简单介绍 typedef struct { __IO uint32_t ISER ; /*! Offset: 0x000 Interrupt Set Enable Register */ uint32_t RESERVED0

[单片机]

<font color='red'>STM32</font>之NVIC中断优先级的介绍

STMCU应用过程中与电源相关的案例分享

我们在从事STM32单片机的应用开发及调试过程中，往往会碰到各类异常。其中有不少比例的问题跟电源有关。对于一个电子产品而言，电源部分很关键、很重要，但在实际开发调试中，我们偶尔会有意无意的忽视它。这里分享几个实际案例，以加强刺激，加深印象。毕竟因为电源问题可能导致的异常很多很多，这里分享几个案例算是抛砖引玉，希望大家在调试中对电源方面加以重视。个人认为，往往电源出问题时导致的异常时并不太好分析。多数时候异常表现得更为诡异或没章法。注：下面提到的案例中异常原因都与电源有关，但并不是说出现类似异常时一定是电源的原因。下面主要分享五个基于STM32应用的案例。案例1：STM32芯片的PLL无法正常工作。有人使用STM3

[单片机]