重点

最新推荐文章于 2024-08-02 20:11:31 发布
置顶 LittleBlack6
最新推荐文章于 2024-08-02 20:11:31 发布
阅读量211
点赞数
文章标签： stm32
本文链接：https://blog.csdn.net/qq_43012492/article/details/109106072
版权
//led.h//
#ifndef __LED_H
#define __LED_H

void LED_Init();

#endif;

//led.c//
#include "led.h"
#include "stm32f10x.h" 

void LED_Init()
{
	GPIO_InitTypeDef  GPIO_InitStructure;
	 
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_GPIOC, ENABLE);	    //使能PA端口时钟

	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;			  	// LE端口配置 高电平锁存器传送数据，低电平锁存器不传送数据
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; 	 	//推挽输出
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;		//IO口速度为10MHz
	GPIO_Init(GPIOD, &GPIO_InitStructure);			     	//初始化GPIOD
	
	GPIO_InitStructure.GPIO_Pin = 0XFF00;			    	//PC8~PC15端口配置
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; 	 	//推挽输出
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;	 	//IO口速度为10MHz
	GPIO_Init(GPIOC, &GPIO_InitStructure);
	
	GPIOD->ODR |= (1<<2);//打开锁存器
	GPIOC->ODR |= 0XFF00;//初始值全灭  LED低电平有效
	GPIOD->ODR &= ~(1<<2);//关闭锁存器
}

//beep.h//
#ifndef __BEEP_H
#define __BEEP_H
#include "stm32f10x.h"

#define BeepOn() GPIOB->ODR &= ~(1<<4)
#define BeepOff() GPIOB->ODR |= (1<<4)

void BEEP_Init();

#endif

//beep.c//
#include "beep.h"
#include "stm32f10x.h"

void BEEP_Init()
{
	GPIO_InitTypeDef  GPIO_InitStructure;
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO|RCC_APB2Periph_GPIOB, ENABLE);	    //使能复用PB端口时钟  使能要在恢复服用之前
	GPIO_PinRemapConfig(GPIO_Remap_SWJ_NoJTRST, ENABLE);	//将PB4复用回普通IO口


	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;			  	//蜂鸣器  低电平有效
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; 	 	//推挽输出
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;		//IO口速度为10MHz
	GPIO_Init(GPIOB, &GPIO_InitStructure);			     	//初始化GPIOD
	GPIOB->ODR |= (1<<4);									//初始化蜂鸣器  低有效
}

/*主函数---按键1控制蜂鸣器响一段时间*/

u32 Beep_Num = 100;	//蜂鸣器响的时间ms
u8 Beep_Flag = 0;	//蜂鸣器响的标志位
int main(void)
{
	KEY_Init();		
	BEEP_Init();
	while(1)
	{
		if(KEY_FLAG) //按键扫描
		{
			KEY_FLAG = 0;	
			KEY_Reading();
		}
		
		if(trg == 0x01)
		{
			Beep_Flag = 1;
		}
		
		if(Beep_Flag == 1)//蜂鸣器响100ms
		{
			if(Beep_Num == 0)
			{
				BeepOff();
				Beep_Flag = 0;
				Beep_Num = 100;
			}
			else
			{
				BeepOn();
			}
		}
	}
}

extern u8 KEY_FLAG;
extern u8 Beep_Flag;
extern u32 Beep_Num;
void SysTick_Handler(void)
{
	static u8 Key_Num = 0;
	TimingDelay--;
	if(++Key_Num == 50)
	{
		Key_Num = 0;
		KEY_FLAG = 1;
	}
	if(Beep_Flag == 1)
	{
		Beep_Num --;
	}
}

//key.h//
#ifndef __KEY_H
#define __KEY_H

#define KEY1 GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0)
#define KEY2 GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_8)
#define KEY3 GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_1)
#define KEY4 GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_2)
#define KEYINPUT KEY1|(KEY2<<1)|(KEY3<<2)|(KEY4<<3)|0XF0 //将四个按键的IO口附在0xf0的后四位上，分别为KEY4/3/2/1

void KEY_Init();
void KEY_Reading();

#endif

//key.c//
#include "key.h"
#include "stm32f10x.h"

u8 trg = 0;
u8 cont = 0;

/*当没有按键按下时，KEYINPUT为0xff；read_data = (KEYINPUT)^(0xff);（异或） = 0x00；trg = 0x00&0x00 = 0x00；cont = 0x00；*/
/*当按键4按下时，KEYINPUT为0xf7; read_data = 0x08；计算trg的cont为按键未按下时的cont：trg = 0x08&(0x08^0x00) = 0x08；cont = 0x08依次列推，按键3、2、1按下分别 trg 为0x04、0x02、0x01*/
/*当按键4长按时，第二次进入按键扫描时，按键4 trg = 0x08&(0x08^0x08) = 0x00；cont的值保持不变，按键4、3、2、1分别长按：cont = 0x08、0x04、0x02、0x01*/
/*按键短按的标志位为trg	按键长按的标志位为cont*/
/*在SYSTICK中断处理函数每50ms进行一次按键扫描*/

void KEY_Reading()
{
	u8 read_data = (KEYINPUT)^(0xff);
	trg = read_data&(read_data^cont);
	cont = read_data;
}

void KEY_Init()
{
	GPIO_InitTypeDef GPIO_InitStructure;
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOB,ENABLE);
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_8;
	GPIO_InitStructure.GPIO_Mode =  GPIO_Mode_IPU;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA,&GPIO_InitStructure);
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1|GPIO_Pin_2;
	GPIO_Init(GPIOB,&GPIO_InitStructure);	
}

/*主函数---短按---长按*/

u8 KEY_FLAG = 0;	//按键扫描标志位
u8 time_count = 0;	//长按时间累加位
int main(void)
{
	KEY_Init();
	while(1)
	{
		if(KEY_FLAG) 		//按键扫描
		{
			KEY_FLAG = 0;	
			KEY_Reading();
		}
		if(trg == 0x01)		//按键1短按
		{
			
		}
		if(cont == 0x01 & KEY_FLAG)	//按键1长按
		{
			time_count ++;
			if(time_count == 20)//50ms进行一次按键扫描，长按时间为1s触发
			{
				time_count = 0;
				
			}
		}
	}
}

/*系统定时器中断处理函数*/

extern u8 KEY_FLAG;
void SysTick_Handler(void)
{
	static u8 Key_Num = 0;
	TimingDelay--;
	if(++Key_Num == 50)
	{
		Key_Num = 0;
		KEY_FLAG = 1;
	}
}

//ADC//
//main.c//
#include "stm32f10x.h"
#include "lcd.h"
#include "io.h"
#include "stdio.h"
u8 ADC_Flag = 0;
u32 TimingDelay = 0;

float adc_val;
u8 string[20];
void Delay_Ms(u32 nTime);

//Main Body
int main(void)
{
	SysTick_Config(SystemCoreClock/1000);

	Delay_Ms(200);
	
	STM3210B_LCD_Init();
	LCD_Clear(Blue);
	LCD_SetBackColor(Blue);
	LCD_SetTextColor(White);
	ADC1_Init();
	
	while(1)
	{
		if(ADC_Flag == 1)
		{
			ADC_Flag = 0;
			adc_val = Get_Adc(ADC_Channel_8)*3.3/4096;
			sprintf((char*)string, "ADC_VAL : %.2f      ", adc_val);
			LCD_DisplayStringLine(Line3, string);
			
		}
	}
}

void Delay_Ms(u32 nTime)
{
	TimingDelay = nTime;
	while(TimingDelay != 0);	
}

//it.c//
extern u8 ADC_Flag;
void SysTick_Handler(void)
{
	static u16 adc_sum = 0;
	TimingDelay--;
	if(++adc_sum == 500)
	{
		adc_sum = 0;
		ADC_Flag = 1;
	}
}


//adc.h//
#ifndef __IO_H
#define __IO_H
#include "stm32f10x.h"
void ADC1_Init();
u16 Get_Adc(u8 channel);
#endif 


//adc.c//
#include "io.h"


void ADC1_Init()
{
	GPIO_InitTypeDef GPIO_InitStruct;
	ADC_InitTypeDef ADC_InitStruct;
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1|RCC_APB2Periph_GPIOB, ENABLE);
	
	RCC_ADCCLKConfig(RCC_PCLK2_Div6);
	
	GPIO_InitStruct.GPIO_Pin = GPIO_Pin_0;
	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AIN;
	GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStruct);
	
	ADC_InitStruct.ADC_Mode = ADC_Mode_Independent;
	ADC_InitStruct.ADC_ScanConvMode = DISABLE;
	ADC_InitStruct.ADC_ContinuousConvMode = DISABLE;
	ADC_InitStruct.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
	ADC_InitStruct.ADC_DataAlign = ADC_DataAlign_Right;
	ADC_InitStruct.ADC_NbrOfChannel = 1;
	ADC_Init(ADC1, &ADC_InitStruct );
	
	ADC_Cmd(ADC1, ENABLE);
	
	ADC_ResetCalibration(ADC1);
	while(ADC_GetResetCalibrationStatus(ADC1));
	ADC_StartCalibration(ADC1);
	while(ADC_GetCalibrationStatus(ADC1));
}

u16 Get_Adc(u8 channel)
{
	u16 temp;
	ADC_RegularChannelConfig(ADC1, channel, 1, ADC_SampleTime_239Cycles5);
	ADC_SoftwareStartConvCmd(ADC1, ENABLE);
	while(ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == 0);
	temp = ADC_GetConversionValue(ADC1);
	ADC_SoftwareStartConvCmd(ADC1, DISABLE);
	return temp;
}
	
//E2Prom//

//main.c//
#include "stm32f10x.h"
#include "lcd.h"
#include "io.h"

u8 hour = 67;
u8 min = 68;
u8 sec = 69;

u32 TimingDelay = 0;

void Delay_Ms(u32 nTime);

//Main Body
int main(void)
{
	i2c_init();
	STM3210B_LCD_Init();
	LCD_Clear(Blue);
	LCD_SetBackColor(Blue);
	LCD_SetTextColor(White);
	
	SysTick_Config(SystemCoreClock/1000);
	_24c02_Write(0x01, hour);
	Delay_Ms(5);
	_24c02_Write(0x30, min);
	Delay_Ms(5);
	_24c02_Write(0x20, sec);
	Delay_Ms(5);
	LCD_ClearLine(Line0);
	LCD_ClearLine(Line1);
	LCD_ClearLine(Line2);
	LCD_ClearLine(Line3);
	LCD_DisplayChar(Line0, 150, _24c02_Read(0x01));
	Delay_Ms(5);
	LCD_DisplayChar(Line1, 166, _24c02_Read(0x30));
	Delay_Ms(5);
	LCD_DisplayChar(Line2, 182, _24c02_Read(0x20));
	Delay_Ms(5);
	while(1);
}


void Delay_Ms(u32 nTime)
{
	TimingDelay = nTime;
	while(TimingDelay != 0);	
}

//io.h//
#ifndef __IO_H_
#define __IO_H_
#include "stm32f10x.h"

void _24c02_Write(u8 address,u8 data);
u8 _24c02_Read(u8 address);

#endif

//io.c//
#include "io.h"
#include "lcd.h"
#include "i2c.h"

void LED_Init(void)
{
	
}

void _24c02_Write(u8 address,u8 data)
{
	I2CStart();				//开启I2C总线
	I2CSendByte(0xa0);		//写操作
	I2CWaitAck();
	I2CSendByte(address);	//发送数据存储地址
	I2CWaitAck();
	I2CSendByte(data);		//发送数据位置
	I2CWaitAck();
	I2CStop();
}

u8 _24c02_Read(u8 address)
{
	u8 temp;
	I2CStart();
	I2CSendByte(0xa0);
	I2CWaitAck();
	I2CSendByte(address);
	I2CWaitAck();
	
	I2CStart();
	I2CSendByte(0xa1);
	I2CWaitAck();
	temp = I2CReceiveByte();
	I2CWaitAck();
	I2CStop();	
	return temp;
}

//比较PWM//
//main.c//
#include "stm32f10x.h"
#include "lcd.h"
#include "timer.h"

u32 TimingDelay = 0;

void Delay_Ms(u32 nTime);

//Main Body
int main(void)
{
	SysTick_Config(SystemCoreClock/1000);
	
	PWM_TIM2_Iint(71, 3000, 80, 3000, 80);	//CH3输出1KHz、占空比50%，CH4输出3KHz、占空比80%
	while(1);
}

//
void Delay_Ms(u32 nTime)
{
	TimingDelay = nTime;
	while(TimingDelay != 0);	
}

//it.c//
extern u16 CH3_Val;
extern u16 CH4_Val;
extern u16 CH3_Duty;
extern u16 CH4_Duty;
u8 ch3_channel_flag = 1;
u8 ch4_channel_flag = 1;
		
void TIM2_IRQHandler(void)	//中断函数名打错调试时会卡在B.，从启动文件中找中断函数的函数名
{
	u16 capture;
	if(TIM_GetITStatus(TIM2, TIM_IT_CC3) == 1)//这里是获取中断状态
	{
		TIM_ClearITPendingBit(TIM2, TIM_IT_CC3);
		capture = TIM_GetCapture3(TIM2);	//得到CH3通道的计数值
		if(ch3_channel_flag)
		{
			TIM_SetCompare3(TIM2, capture + CH3_Duty);	//加上有效电平周期的计数值
		}
		else
		{
			TIM_SetCompare3(TIM2, capture + CH3_Val - CH3_Duty);	//加上无效电平周期的计数值
		}
		ch3_channel_flag ^= 1;
	}
	
	if(TIM_GetITStatus(TIM2, TIM_IT_CC4) == 1)
	{
		TIM_ClearITPendingBit(TIM2, TIM_IT_CC4);
		capture = TIM_GetCapture4(TIM2);	//得到CH4通道的计数值
		if(ch4_channel_flag)
		{
			TIM_SetCompare4(TIM2, capture + CH4_Duty);
		}
		else
		{
			TIM_SetCompare4(TIM2, capture + CH4_Val - CH4_Duty);
		}
		ch4_channel_flag ^= 1;
	}
}

//timer.h//
#ifndef __TIMER_H
#define __TIMER_H
#include "stm32f10x.h"

void PWM_TIM2_Iint(u8 psc, u16 ch3_fre, u8 ch3_duty, u16 ch4_fre, u8 ch4_duty);
#endif

//timer.c//
#include "timer.h"

u16 CH3_Val;	//通道3的周期计数值
u16 CH4_Val;	//通道4的周期计数值
u16 CH3_Duty;	//通道3的占空比计数值
u16 CH4_Duty;	//通道4的占空比计数值

/*输出比较PWM波，同一定时器不同通道，频率不同，占空比不同*/
/*函数的参数： 预分频系数， CH3频率， CH3占空比， CH4频率， CH4占空比*/
void PWM_TIM2_Iint(u8 psc, u16 ch3_fre, u8 ch3_duty, u16 ch4_fre, u8 ch4_duty)
{
	GPIO_InitTypeDef GPIO_InitStructure;			//IO口初始化结构体
	NVIC_InitTypeDef NVIC_InitStructure;			//中断初始化结构体
	TIM_TimeBaseInitTypeDef Time_BaseInitStructure;	//TIM基础类型初始化结构体
	TIM_OCInitTypeDef TIM_OCInitStructure;			//TIM输出比较初始化结构体
	
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);	//使能TIM2时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);	// 使能GPIOA时钟
	
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2|GPIO_Pin_3;	//TIM_CH3、TIM_CH4
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;			//复用推挽输出
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;				//TIM2中断
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;	//先占优先级
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;			//从优先级
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
	
	Time_BaseInitStructure.TIM_Period = 0xffff;					//自动重装值给到最大
	Time_BaseInitStructure.TIM_Prescaler = psc;					//预分频值
	Time_BaseInitStructure.TIM_ClockDivision = 0x0;				//设置时钟分割
	Time_BaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;//向上计数
	TIM_TimeBaseInit(TIM2, &Time_BaseInitStructure);
	
	CH3_Val = 72000000/(psc+1)/ch3_fre;	//通道3的周期计数值
	CH4_Val = 72000000/(psc+1)/ch4_fre;	//通道4的周期计数值
	CH3_Duty = CH3_Val*ch3_duty/100;	//通道3的占空比计数值
	CH4_Duty = CH4_Val*ch4_duty/100;	//通道4的占空比计数值
	
	TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_Toggle;			//翻转(TIM输出比较触发模式 )在计数值达到CHX_Duty前为高电平，达到CHX_Duty后翻转，达到CHX_Val后翻转
	TIM_OCInitStructure.TIM_Pulse = CH3_Val;					//设置CH3的周期
	TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_Low;
	TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;//比较输出使能
	TIM_OC3Init(TIM2, &TIM_OCInitStructure);

	TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_Toggle;
	TIM_OCInitStructure.TIM_Pulse = CH4_Val;
	TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
	TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;	//使能和上面的使能不同，不是ENABLE
	TIM_OC4Init(TIM2, &TIM_OCInitStructure);						//初始化函数要与所用通道相对应
	
	TIM_SetCounter(TIM2, 0X0);	//定时器计数值清零
	TIM_SetCompare3(TIM2, 0X0);	//定时器通道3的比较值清零
	TIM_SetCompare4(TIM2, 0X0);	//定时器通道4的比较值清零
	
	TIM_Cmd(TIM2, ENABLE);								//使能TIM2
	TIM_ITConfig(TIM2, TIM_IT_CC3|TIM_IT_CC4, ENABLE);	//使能通道2、通道3比较中断
}


//USART//
//main.c//
#include "stm32f10x.h"
#include "lcd.h"
#include "usart.h"

u32 TimingDelay = 0;
extern u8 RXBUF[20];
extern u8 flag;
extern u8 num;
u8 i;
void Delay_Ms(u32 nTime);
u8 KEY_FLAG = 0;	//按键扫描标志位
u8 time_count = 0;	//长按时间累加位
//Main Body
int main(void)
{
	SysTick_Config(SystemCoreClock/1000);

	Delay_Ms(200);
	
	STM3210B_LCD_Init();
	LCD_Clear(Blue);
	LCD_SetBackColor(White);
	LCD_SetTextColor(Black);	
	USART2_Init(9600);
	while(1)
	{
		
		if(flag)
		{
				LCD_ClearLine(Line3);
				LCD_DisplayStringLine(Line4, RXBUF);
				USART2_SendString(RXBUF);
				for(i=0;i<19;i++)
				{
					RXBUF[i] = '0';
				}
				RXBUF[19] = '.';
				LCD_DisplayStringLine(Line5, RXBUF);
				USART2_SendString(RXBUF);				
				flag = 0;
				num = 0;
								

		}		
	}
}


void Delay_Ms(u32 nTime)
{
	TimingDelay = nTime;
	while(TimingDelay != 0);	
}

//it.c//
extern u8 KEY_FLAG;
void SysTick_Handler(void)
{
	static u8 Key_Num = 0;
	TimingDelay--;
	if(++Key_Num == 50)
	{
		Key_Num = 0;
		KEY_FLAG = 1;
	}
}

u8 RXBUF[20];
u8 flag = 0;
u8 num = 0;
void USART2_IRQHandler(void)
{
	u8 temp;
	if(USART_GetITStatus(USART2, USART_IT_RXNE) == SET)
	{
		USART_ClearITPendingBit(USART2, USART_IT_RXNE);
		temp = USART_ReceiveData(USART2);
		if(temp == '.')
		{
			flag = 1;
		}
		if(flag == 0)
		{
			RXBUF[num] = temp;
			num ++;
		}
	}
}

//usart.h//
#ifndef __USART_H
#define __USART_H
#include "stm32f10x.h"

void USART2_Init(u32 bond);
void USART2_SendString(u8 *str);

#endif

//usart.c//
#include "usart.h"

void USART2_Init(u32 baud)	//输入参数：波特率
{
	GPIO_InitTypeDef GPIO_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	USART_InitTypeDef USART_InitStructure; 
	
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);	//中文参考手册2.1系统架构
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
	
	NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
	NVIC_Init(&NVIC_InitStructure);
	
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;		//TX
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;		//RX
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	USART_InitStructure.USART_BaudRate = baud;
	USART_InitStructure.USART_Mode = USART_Mode_Rx|USART_Mode_Tx;
	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_Init(USART2, &USART_InitStructure);
	USART_Cmd(USART2, ENABLE);
	USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);	
}

void USART2_SendString(u8 *str)
{
	u8 index = 0;
	while(str[index] != '\0')
	{
		USART_SendData(USART2, str[index]);
		while(USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET);	//等待数据发送完成，发送完成为SET = 1
		index ++;
	}
	
}

//RTC//
//MAIN.C//
#include "stm32f10x.h"
#include "lcd.h"
#include "RTC.h"
#include "stdio.h"

u32 TimingDelay = 0;
void Delay_Ms(u32 nTime);

extern u8 HH;//时
extern u8 MM;	//分
extern u8 SS;	//秒
u8 text[20];	

//Main Body
int main(void)
{
	SysTick_Config(SystemCoreClock/1000);
	
	STM3210B_LCD_Init();
	Delay_Ms(100);
	LCD_Clear(White);
	LCD_SetTextColor(White);
	LCD_SetBackColor(Blue);
    
	LCD_ClearLine(Line0);	//让123456行背景均为Blue
	LCD_ClearLine(Line1);	
	LCD_ClearLine(Line2);
	LCD_ClearLine(Line3);
	LCD_ClearLine(Line4);
	LCD_ClearLine(Line5);
	LCD_DisplayStringLine(Line1,"      RTC DEMO      ");
	LCD_DisplayStringLine(Line3,"  RTC_Calendar_Test  ");

	LCD_SetTextColor(Blue);
	LCD_SetBackColor(Cyan);
	LCD_ClearLine(Line6);	//让78910行背景均为Cyan
	LCD_ClearLine(Line7);
	LCD_ClearLine(Line8);
	LCD_ClearLine(Line9);

	RTC_Configuration();
	NVIC_Configuration();
	
	while(1)
	{
		sprintf(text,"   Time: %02d:%02d:%02d",HH, MM, SS);
		LCD_DisplayStringLine(Line7,text);
	}
}


//
void Delay_Ms(u32 nTime)
{
	TimingDelay = nTime;
	while(TimingDelay != 0);	
}

//it.c//
extern u8 HH;	//时
extern u8 MM;	//分
extern u8 SS;	//秒

void RTC_IRQHandler()
{
	if(RTC_GetITStatus(RTC_IT_SEC) != RESET)
	{
		RTC_ClearITPendingBit(RTC_IT_SEC);
		if(SS == 59)
		{
			SS = 0;	
			if(MM == 59)
			{
				MM = 0;
				if(HH == 23)
				{
					HH = 0;
				}
				else
				{
					HH ++;
				}
			}
			else
			{
				MM ++;
			}
		}
		else 
		{
			SS ++;
		}
	}
}

//rtc.h//
#ifndef __RTC_H
#define __RTC_H

void RTC_Configuration();
void NVIC_Configuration();
#endif

//rtc.c//
#include "RTC.h"
#include "stm32f10x.h"

u8 HH = 23;	//时
u8 MM = 59;	//分
u8 SS = 57;	//秒

void RTC_Configuration()	//配置RTC
{
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_BKP|RCC_APB1Periph_PWR, ENABLE);	//使能BKP和PWR时钟
	PWR_BackupAccessCmd(ENABLE);			//BKP备份区域使能
	BKP_DeInit();							//复位BKP寄存器
	
	RCC_LSICmd(ENABLE);						//使能内部低速时钟
	while(RCC_GetFlagStatus(RCC_FLAG_LSIRDY)== RESET);	//等待内部低速时钟就绪
	RCC_RTCCLKConfig(RCC_RTCCLKSource_LSI);	//设置RTC时钟为内部低速时钟
	RCC_RTCCLKCmd(ENABLE);					//使能RTC时钟
	
	RTC_WaitForSynchro();					//等待APB1时钟和RTC时钟同步
	RTC_WaitForLastTask();					//等待寄存器操作完成
	
	RTC_ITConfig(RTC_IT_SEC, ENABLE);		//RTC时钟秒中断使能
	RTC_WaitForLastTask();					//等待寄存器操作完成
	
	RTC_SetPrescaler(40000-1);				//RTC period = RTCCLK/RTC_PR = (40 KHz)/(39999+1)   40M时钟分频产生秒时基
	RTC_WaitForLastTask();					//等待寄存器操作完成
	
	RTC_SetCounter(HH*3600+MM*60+SS);		//设置秒计数寄存器值
	RTC_WaitForLastTask();					//等待寄存器操作完成
}	

void NVIC_Configuration()
{
	NVIC_InitTypeDef NVIC_InitStructure;						//中断初始化结构体
	
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);				//设置中断优先级级分组，不设置默认组0
	
	NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;				//RTC中断
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;	//抢占优先级
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;			//响应优先级
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;				//RTC通道被使能
	NVIC_Init(&NVIC_InitStructure);
}
LittleBlack6
关注
0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
重点

//led.h//#ifndef __LED_H#define __LED_Hvoid LED_Init();#endif;//led.c//#include "led.h"#include "stm32f10x.h" void LED_Init(){ GPIO_InitTypeDef GPIO_InitStructure; RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_GPIOC, ENABLE)
复制链接

扫一扫