关闭

stm32 RTC实时时钟[操作寄存器+库函数]

2973人阅读 评论(0) 收藏 举报
分类:
"RTC"是Real Time Clock 的简称,意为实时时钟。stm32提供了一个秒中断源和一个闹钟中断源。
 
RTC的技术器是一个32位的计数器,使用32.768khz的外部晶振。
 
2038年问题
 
 在计算机应用上,2038年问题可能会导致某些软件在2038年无法正常工作。所有使用UNIX时间表示时间的程序都将受其影响,因为它们以自1970年1月1日经过的秒数(忽略闰秒)来表示时间。这种时间表示法在类Unix(Unix-like)操作系统上是一个标准,并会影响以其C编程语言开发给其他大部份操作系统使用的软件。
    在大部份的32位操作系统上,此“time_t”数据模式使用一个有正负号的32位元整数(signedint32)存储计算的秒数。也就是说最大可以计数的秒数为 2^31次方 可以算得:
                2^31/3600/24/365 ≈ 68年
所以依照此“time_t”标准,在此格式能被表示的最后时间是2038年1月19日03:14:07,星期二(UTC)。超过此一瞬间,时间将会被掩盖(wrap around)且在内部被表示为一个负数,并造成程序无法工作,因为它们无法将此时间识别为2038年,而可能会依个别实作而跳回1970年或1901年。
 
    对于PC机来说,时间开始于1980年1月1日,并以无正负符号的32位整数的形式按秒递增,这与UNIX时间非常类似。可以算得:
                 2^32/3600/24/365 ≈ 136年
到2116年,这个整数将溢出。
 
    Windows NT使用64位整数来计时。但是,它使用100纳秒作为增量单位,且时间开始于1601年1月1日,所以NT将遇到2184年问题。
 
苹果公司声明,Mac在29,940年之前不会出现时间问题!
 
        由于RTC是一个32位计数器,同样其计时时间是有限的。库函数中使用到了C标准时间库,时间库中的计时起始时间是1900年,可以知道时间库中不是用 有符号位的32位整数来表示时间的,否则在1968年就已经溢出了。如果用32位无符号整数计时,其溢出时间为2036年左右,所以会遇到这个问题。
 
    直接操作寄存器中,可以自由设定这个时间戳起始的年份,RTC的32位寄存器存储的只是距离这个起始年份的总秒数,所以不会遇到这个问题。而且可以用无符号32位的二进制表示时间,这意味着此类系统的时间戳可以表示更多的秒数。但是由于其使用32位寄存器表示秒数,最大只能计时到136年后。
 
本例实现使用stm32每秒输出一次当前的时间,并设置一个闹钟,到时间时输出提醒信息。
 

直接操作寄存器
 
RTC实时时钟的操作原则是 在每次读写前都要保证上一次读写完成。
 
代码较多,使用到的寄存器请参见手册  (system.h 和 stm32f10x_it.h 等相关代码参照 stm32 直接操作寄存器开发环境配置
 
User/main.c
#include <stm32f10x_lib.h>	
#include "system.h"
#include "usart.h" 
#include "rtc.h"	 

#define LED1 PAout(4)
#define LED2 PAout(5)

void Gpio_Init(void);

extern const u8* Week_Table[7];

int main(void)
{				  


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

	Usart1_Init(72,9600);

	Nvic_Init(0,0,RTC_IRQChannel,0);	  //设置中断

   	
	Gpio_Init();

	Rtc_Init();	

	//Rtc_TIME_AutoSet();				//将当前编译时间作为RTC开始时间
	Rtc_TIME_Set(2012,7,7,20,50,0);		//设定开始时间 参数说明:年,月,日,时,分,秒
	
	Rtc_ALARM_Set(2012,7,7,20,50,30);	//设定闹钟事件时间		   							

	LED1 = 1;
	
	while(1);		
}


void Gpio_Init(void)
{
	RCC->APB2ENR|=1<<2;    //使能PORTA时钟 	

	GPIOA->CRL&=0x0000FFFF; // PA0~3设置为浮空输入,PA4~7设置为推挽输出
	GPIOA->CRL|=0x33334444; 
	
	//USART1 串口I/O设置

	GPIOA -> CRH&=0xFFFFF00F;   //设置USART1 的Tx(PA.9)为第二功能推挽,50MHz;Rx(PA.10)为浮空输入
	GPIOA -> CRH|=0x000008B0;	  
} 
User/stm32f103x_it.c
#include "stm32f10x_it.h"
#include "system.h"
#include "stdio.h"
#include "rtc.h"

#define LED1 PAout(4)
#define LED2 PAout(5)
#define LED3 PAout(6)
#define LED4 PAout(7)

//extern void Wwdg_Feed(void);
//extern u16 Read_Bkp(u8 reg);
extern void Rtc_Get(void);
extern const u8* Week_Table[7];

void RTC_IRQHandler(void)
{

	if(RTC->CRL&0x0001)					//秒钟中断
	{
		LED4 = !LED4;
		Rtc_Get();

		printf("\r\n Time : %d - %d - %d,%d : %d : %d ,Today is %s \r\n",
	
	            timer.year,
	
	            timer.month,
	
	            timer.date,
	
	            timer.hour,
	
	            timer.minute,
	
	            timer.second,
				Week_Table[timer.week]
		);		
	}

	if(RTC->CRL&0x0002)					//闹钟中断
	{
		LED3 = 1; 
			
		printf("\r\nIt's time to do sth.\r\n");	

		RTC->CRL &= ~(0x0002);			//清除闹钟中断	

	}

	RTC->CRL &= 0x0FFA; 				//清除溢出,秒钟中断

	while(!(RTC->CRL &(1<<5)));			//等待RTC寄存器操作完成

}
Library/src/rtc.c
#include <stm32f10x_lib.h>	
#include "rtc.h"
#include "stdio.h"

tm timer;					//定义时钟结构体,主函数直接可以调用此结构体读出时间

//平年的月份日期表,月份缩写表
const u8 Days_Table[12]={31,28,31,30,31,30,31,31,30,31,30,31};
const u8 Month_Table[12][3]={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};

const u8* Week_Table[7]={"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"};

//月修正数据表																		 
u8 const _Week[12]={0,3,3,6,1,4,6,2,5,0,3,5}; 

void Rtc_Init(void)
{
	RCC->APB1ENR |= 1<<28;	//使能PWR时钟
	RCC->APB1ENR |= 1<<27;  //使能BKP时钟,RTC校准在BKP相关寄存器中
 	PWR->CR |= 1<<8;		//取消BKP相关寄存器写保护

	//RCC->BDCR |= 1<<16;	//备份区域软复位
	//RCC->BDCR |= ~(1<<16);	//备份区域软复位结束

	RCC->BDCR |= 1<<0;		//外部低速时钟(LSE)使能

	while(!(RCC->BDCR & 0x02));	//等待外部时钟就绪

	RCC->BDCR |= 1<<8;			//LSE作为RTC时钟
	RCC->BDCR |= 1<<15;			//RTC时钟使能

	while(!(RTC->CRL & (1<<5)));	//等待RTC寄存器最后一次操作完成
	while(!(RTC->CRL & (1<<3)));	//等待RTC寄存器同步完成

	RTC->CRH |= 0x07;				//允许溢出中断[2],闹钟中断[1],秒中断[0],CRH寄存器低三位有效	

	while(!(RTC->CRL & (1<<5)));	//等待RTC寄存器最后一次操作完成

	RTC->CRL |=  1<<4;				//进入配置模式
	RTC->PRLH = 0x0000;				
	RTC->PRLL = 32767;				//设定分频值

	//Rtc_TIME_AutoSet();				//将当前编译时间写入寄存器
	//Rtc_TIME_Set(2012,7,7,20,50,0);	//年,月,日,时,分,秒

	RTC->CRL &= ~(1<<4);			//退出配置模式,开始更新RTC寄存器
	while(!(RTC->CRL & (1<<5)));	//等待RTC寄存器最后一次操作完成

}


//设定RTC开始计时时间
void Rtc_TIME_Set(u16 year,u8 month,u8 date,u8 hour,u8 minute, u8 second)
{
		u32 sec;	

	    sec = Date_TO_Sec(year,month,date,hour,minute,second);
	
		//printf("\nRtc TIME Set  Sec = %x\n",sec);
	
		RCC->APB1ENR |= 1<<28;							//使能PWR时钟,方便独立调用此函数
		RCC->APB1ENR |= 1<<27;							//使能BKP时钟
		PWR->CR |= 1<<8;								//取消写保护
	
		RTC-> CRL |= 1<<4;								//允许配置
		
		RTC-> CNTL = sec&0xffff;						//取低16位
		RTC-> CNTH = sec>>16;							//取高16位
	
		RTC-> CRL &= ~(1<<4);							//开始RTC寄存器更新
	
		while(!(RTC->CRL&(1<<5)));						//等待RTC寄存器操作完成 	
}




//判断是否是闰年函数
//
//判断方法:
//		普通年能整除4且不能整除100的为闰年。(如2004年就是闰年,1900年不是闰年)
//		世纪年能整除400的是闰年。(如2000年是闰年,1900年不是闰年)
//
//返回: 1,是闰年 	0,不是闰年
u8 Is_LeapYear(u16 year)
{			  
	if(year%4==0) 				//必须能被4整除
	{ 
		if(year%100==0) 
		{ 
			if(year%400==0)
				return 1;		//如果以00结尾,还要能被400整除 	   
			else 
				return 0;   
		}else{ 
			return 1;   
		}
	}else{
		 return 0;	
	}
}


//将时间转化为到1970年1月1日的总秒数
//Bugs:此函数秒数会多20左右,所以函数返回值做了校正,校正后没有问题
//待优化
u32 Date_TO_Sec(u16 year,u8 month,u8 date,u8 hour,u8 minute, u8 second)
{
	u16 t;
	u32 sec;

	if(year >= 1970 && year<= 2106)		  //判断是否为合法年份,RTC的时间是从1970开始,只能由32位表示秒数,最大只能到2106年左右
	{
		for(t= 1970 ;t<year;t++) 		  //所有年份秒数累加
		{
			if(Is_LeapYear(t))			  //判断是否为闰年

				sec += 31622400; 
			else 	
				sec += 31536000;		
		}	


		for(t=0;t<month-1;t++)						   //月份秒数累加
		{
			sec += (u32) Days_Table[t]*86400;			
			if(Is_LeapYear(year) && t== 1) 				//闰年加一天的秒钟数
				sec += 86400;							
	
		}
	
		sec += (u32)(date-1)*86400;						//本月日期的秒数累加
		sec += (u32)(hour)*3600;
		sec += (u32)(minute)*60;
		sec += second;
	}

	return sec-20;										//校正20秒,原因不详

}



//自动获取当前时间配置RTC
//可以根据MDK关键字获取时间  
//__DATE__  获取编译日期, 格式为: Jul 7 2012  
//__TIME__  获取编译时间, 格式为: 14:54:44 

void Rtc_TIME_AutoSet()
{
   	u16 year,i=0,j=0;
	u8  mon,date,sec,min,hour;

	u8 *_date = __DATE__;
	u8 *_time = __TIME__;

   	for(i=0;i<12;i++)
	{
		for(j=0;j<3;j++)
		{
			if(Month_Table[i][j] == _date[j]) mon = i;	//得到月份
		}
	}


	if(_date[4]==' '){ 			//得到日期
		date=_date[5]-'0'; 		//-'0'操作将字符型转换为整型,参考ASCII码的转换,eg '7'-'0' =7
	}else{ 
		date=10*(_date[4]-'0')+_date[5]-'0';
	}
		  

	year=1000*(_date[7]-'0')+100*(_date[8]-'0')+10*(_date[9]-'0')+_date[10]-'0';  //得到年份	   
	hour=10*(_time[0]-'0')+_time[1]-'0';  										  //得到小时
	min=10*(_time[3]-'0')+_time[4]-'0';  										  
	sec=10*(_time[6]-'0')+_time[7]-'0'; 
	

	//printf("\n%d-%d-%d  %d:%d:%d\n",year,mon,date,hour,min,sec);

	Rtc_TIME_Set(year,mon,date,hour,min,sec);
}


//获取RTC时间
void Rtc_Get()
{
	u32 secs,days,temp,years = 1970,months = 0;		

	secs = RTC->CNTH; 	//读取RTC的当前时间值(距1970年的总秒数)
	secs <<= 16;
	secs += RTC->CNTL;

	//printf("\nRtc_Get  Sec = %x\n",secs);

	days = secs/86400;
	if(days > 0)			//超过一天
	{
		temp = days;
		while(temp >= 365)	
		{
			if(Is_LeapYear(years))				//是闰年
			{
				if(temp >= 366) 
					temp -=	366;	//闰年的天数
				else
					break;
			}else{
			 	temp -= 365;
			}		 	
			years++;
		}
		
		timer.year = years;			  //得到年份

		while(days >= 28)
		{
			if(Is_LeapYear(years) && months ==1)	   //判断是否为闰年的第二月
			{
				if(temp >= 29) 
					temp -= 29;	
				else
					break;
			}else{
				if(temp >= Days_Table[months]) 		
					temp -= Days_Table[months];
				else
					break;
			}

			months++;	
		}

		timer.month = months+1;				//得到月数
 		timer.date  = temp+1;				//得到日期
	}

	temp = secs % 86400;					//得到剩余秒数
	timer.hour = temp/3600;					//得到小时
	timer.minute = (temp%3600)/60;			
	timer.second = (temp%3600)%60;
	timer.week = Rtc_DAY_Get(timer.year,timer.month,timer.date);

				
}

//判断当前为星期几					

u8 Rtc_DAY_Get(u16 year,u8 month,u8 day)
{	
	u16 temp;
	u8 yearH,yearL;
	
	yearH = year/100;	
	yearL = year%100; 

	// 如果为21世纪,年份数加100  
	if( yearH > 19 ) yearL += 100;

	// 所过闰年数只算1900年之后的  

	temp = yearL+yearL/4;
	temp = temp%7; 
	temp = temp + day + _Week[month-1];

	if( yearL%4 == 0 && month < 3 ) temp--;

	return(temp%7);
}

//设定闹钟时间

void Rtc_ALARM_Set(u16 year,u8 month,u8 date,u8 hour,u8 minute, u8 second)
{

		u32 sec;	

	    sec = Date_TO_Sec(year,month,date,hour,minute,second);


		RTC-> CRL |= 1<<4;								//允许配置

		//while(!(RTC->CRL&(1<<5)));						//RTOFF为1 才可以写入ALRL和ALRH寄存器
		
		RTC-> ALRL = sec&0xffff;						//取低16位
		RTC-> ALRH = sec>>16;							//取高16位
	
		RTC-> CRL &= ~(1<<4);							//开始RTC寄存器更新
	
		while(!(RTC->CRL&(1<<5)));						//等待RTC寄存器操作完成

}
Library/inc/rtc.h
#include <stm32f10x_lib.h>	

typedef struct
{
	u8 hour;
	u8 minute;
	u8 second;

	u16 year;
	u8  month;
	u8 	date;
	u8	week;
}tm;

extern tm timer;

void Rtc_Init(void);
void Rtc_TIME_Set(u16 year,u8 month,u8 date,u8 hour,u8 minute, u8 second);
u8 Is_LeapYear(u16 year);
u32  Date_TO_Sec(u16 year,u8 month,u8 date,u8 hour,u8 minute, u8 second);
void Rtc_TIME_AutoSet(void);
void Rtc_Get(void);
void Rtc_ALARM_Set(u16 year,u8 month,u8 date,u8 hour,u8 minute, u8 second);
u8 Rtc_DAY_Get(u16 year,u8 month,u8 day);
这里用到了MDK的两个关键字 __DATE__ 和 __TIME__获得当前编译的日期和时间,详见代码注释
 
库函数操作
 
ANSI C语言所提供的time.h的头文件中关于unix时间戳是从1900年开始的,和直接操作寄存器不同,所以如果unix时间戳中读出年份为100,则正确年份为1900+100=2000
 
代码如下:
 
main.c
#include "stm32f10x.h"
#include "stdio.h"
#include "time.h"

#define	 PRINTF_ON  1

void RCC_Configuration(void);
void GPIO_Configuration(void);
void NVIC_Configuration(void);
void USART_Configuration(void);
void RTC_Configuration(void);

void TimeShow(void);

void SetAlarm(struct tm t);
void SetCalendarTime(struct tm t);
void SetUnixTime(time_t);
struct tm  ConvUnixToCalendar(time_t t);
u32 ConvCalendarToUnix(struct tm t);
u32 GetUnixTime(void);


vu32  Display;

struct tm CurrentTime = {0,30,10,11,4,2011};
struct tm AlarmTime = {5,30,10,11,4,2011};


int main(void)
{
  	RCC_Configuration();
  	GPIO_Configuration();
	NVIC_Configuration();
	USART_Configuration();
	RTC_Configuration();
	
	SetCalendarTime(CurrentTime);
	SetAlarm(AlarmTime); 
	while(1){ TimeShow(); }
}

void TimeShow(void)
{
	u32	Time = 0;
	if(Display)
	{
		Time = GetUnixTime();
		CurrentTime = ConvUnixToCalendar(Time);

		printf("\r\n Time : %d - %d - %d,%d : %d : %d \r\n",
			CurrentTime.tm_year,
			CurrentTime.tm_mon,
			CurrentTime.tm_mday,
			CurrentTime.tm_hour,
			CurrentTime.tm_min,
			CurrentTime.tm_sec);
		Display = 0;
	}
}

void SetCalendarTime(struct tm t) 
{
	SetUnixTime(ConvCalendarToUnix(t));
}

void SetUnixTime(time_t t)
{
	RTC_WaitForLastTask();
	RTC_SetCounter((u32)t);
	RTC_WaitForLastTask();
}

void SetAlarm(struct tm t)
{
	RTC_WaitForLastTask();
	RTC_SetAlarm(ConvCalendarToUnix(t));
	RTC_WaitForLastTask();
}

u32 GetUnixTime(void)
{
	return (u32)RTC_GetCounter();
}

u32 ConvCalendarToUnix(struct tm t)
{
	t.tm_year -=1900;
	return mktime(&t);
}

struct tm  ConvUnixToCalendar(time_t t)
{
	struct tm *t_tm;
	t_tm = localtime(&t);
	t_tm->tm_year += 1900;
	return *t_tm;
}


void GPIO_Configuration(void)
{
  	GPIO_InitTypeDef GPIO_InitStructure;                                                                                                                                                                                                                                                    
  	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); 
}

void RTC_Configuration(void)
{
	PWR_BackupAccessCmd(ENABLE);
	BKP_DeInit();
	RCC_LSEConfig(RCC_LSE_ON);
	while(RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET);
	RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
	RCC_RTCCLKCmd(ENABLE);

	RTC_WaitForSynchro();
	RTC_WaitForLastTask();

	RTC_ITConfig(RTC_IT_SEC|RTC_IT_ALR,ENABLE);
	RTC_WaitForLastTask();

	RTC_SetPrescaler(32767);
	RTC_WaitForLastTask();
}


void RCC_Configuration(void)
{
	/* 定义枚举类型变量 HSEStartUpStatus */
	ErrorStatus HSEStartUpStatus;

  	/* 复位系统时钟设置*/
  	RCC_DeInit();
  	/* 开启HSE*/
  	RCC_HSEConfig(RCC_HSE_ON);
  	/* 等待HSE起振并稳定*/
  	HSEStartUpStatus = RCC_WaitForHSEStartUp();
	/* 判断HSE起是否振成功,是则进入if()内部 */
  	if(HSEStartUpStatus == SUCCESS)
  	{
    	/* 选择HCLK(AHB)时钟源为SYSCLK 1分频 */
    	RCC_HCLKConfig(RCC_SYSCLK_Div1); 
    	/* 选择PCLK2时钟源为 HCLK(AHB) 1分频 */
    	RCC_PCLK2Config(RCC_HCLK_Div1); 
    	/* 选择PCLK1时钟源为 HCLK(AHB) 2分频 */
    	RCC_PCLK1Config(RCC_HCLK_Div2);
    	/* 设置FLASH延时周期数为2 */
    	FLASH_SetLatency(FLASH_Latency_2);
    	/* 使能FLASH预取缓存 */
    	FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
    	/* 选择锁相环(PLL)时钟源为HSE 1分频,倍频数为9,则PLL输出频率为 8MHz * 9 = 72MHz */
    	RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);
    	/* 使能PLL */ 
    	RCC_PLLCmd(ENABLE);
    	/* 等待PLL输出稳定 */
    	while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET);
    	/* 选择SYSCLK时钟源为PLL */
    	RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
    	/* 等待PLL成为SYSCLK时钟源 */
    	while(RCC_GetSYSCLKSource() != 0x08);
  	} 
  	/* 打开APB2总线上的GPIOA时钟*/
  	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1, ENABLE);

	RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR|RCC_APB1Periph_BKP, ENABLE);
		
}

 
void USART_Configuration(void)
{
	USART_InitTypeDef USART_InitStructure;
	USART_ClockInitTypeDef USART_ClockInitStructure;

	USART_ClockInitStructure.USART_Clock = USART_Clock_Disable;
	USART_ClockInitStructure.USART_CPOL = USART_CPOL_Low;
	USART_ClockInitStructure.USART_CPHA = USART_CPHA_2Edge;                                                                                                                                                      
	USART_ClockInitStructure.USART_LastBit = USART_LastBit_Disable;
	USART_ClockInit(USART1 , &USART_ClockInitStructure);

	USART_InitStructure.USART_BaudRate = 9600;
	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_Cmd(USART1,ENABLE);
}


void NVIC_Configuration(void)
{
	NVIC_InitTypeDef NVIC_InitStructure;

	NVIC_InitStructure.NVIC_IRQChannel = RTC_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);

}





#if	 PRINTF_ON

int fputc(int ch,FILE *f)
{
	USART_SendData(USART1,(u8) ch);
	while(USART_GetFlagStatus(USART1,USART_FLAG_TC) == RESET);
	return ch;
}

#endif
stm32f10x_it.c:

#include "stm32f10x_it.h"

#include "stdio.h"

extern vu32 Display;

void RTC_IRQHandler(void)
{
	if(RTC_GetFlagStatus(RTC_FLAG_ALR) != RESET){
		printf("\r\nIt's time to do sth.\r\n");		
	}else{
		Display =1 ;
	
	}

	RTC_ClearITPendingBit(RTC_IT_ALR|RTC_IT_SEC);
}
0
0
查看评论
发表评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场

stm32 RTC实时时钟[操作寄存器+库函数]

"RTC"是Real Time Clock 的简称,意为实时时钟。stm32提供了一个秒中断源和一个闹钟中断源。   RTC的技术器是一个32位的计数器,使用32.768khz的外部晶振。   ...
  • qutiezhu
  • qutiezhu
  • 2016-08-30 21:26
  • 2973

使用STM32 HAL库读取RTC时间芯片SD3088

美信的RTC芯片看起来不错,但是贵。 威帆的这个不错,而且还可以给电池充电,便宜很多,淘宝上价格6元一片。我这项目对时间要求严格,就不使用1元多的芯片了。 网传STM32F1的I2C有Bug,模拟...
  • fengyu09
  • fengyu09
  • 2015-12-02 10:45
  • 3438

STM32 RTC实时时钟

今天是周天,哈尔滨阴天转阵雨。。博主原本准备今天去逛街的。原因你懂的→_→ 接下来进入今天的正题(博主用的是战舰STM32库函数版):博主今天将会和大家讨论两个知识点:       一、RTC时钟框图...
  • HouQi02
  • HouQi02
  • 2016-05-15 13:35
  • 9397

STM32的RTC实时时钟(直接操作寄存器)

  • 2017-11-28 18:08
  • 40KB
  • 下载

STM32+RTC(DS1302)实时时钟设计,整个工程(库函数)

  • 2017-12-25 13:02
  • 6.48MB
  • 下载

STM32的简单实时时钟RTC(STM32神舟IV号-库函数版)程序,亲测能用

  • 2017-11-27 20:57
  • 6.18MB
  • 下载

STM32的实时时钟RTC与农历年月日(STM32神舟IV号-库函数版)程序,亲测能用

  • 2017-11-27 20:59
  • 579KB
  • 下载

10.RTC内部时钟—基于CT117E开发板的STM32库函数编程

RTC 正常工作的一般配置步骤如下: 1 )使能电源时钟和备份区域时钟。 前面已经介绍了,我们要访问 RTC 和备份区域就必须先使能电源时钟和备份区域时钟。 RCC_APB1PeriphCl...
  • m0_37398198
  • m0_37398198
  • 2017-01-26 10:54
  • 189

stm32 外部中断嵌套[操作寄存器+库函数]

stm32共有19个外部中断:   线0~15:对应外部I/O口的输入中断 线16:连接到PVD输出。PVD(Programmable Votage Detector),即可编程电压监测...
  • minyuanxiani
  • minyuanxiani
  • 2014-03-18 16:14
  • 1086

STM32---初学者用库函数好还是直接对寄存器操作比较好

首先,两个都是C语言。 从51过渡过来的话,就先说寄存器操作。每个MCU都有自己的寄存器,51是功能比较简单的一种,相应的寄存器也比较少,我们常用的就那么几个,像P0 P1 SMOD TMOD之类的,...
  • u010349006
  • u010349006
  • 2014-12-03 11:18
  • 2499
    最新评论
    个人资料
    • 访问:65273次
    • 积分:151
    • 等级:
    • 排名:千里之外
    • 原创:6篇
    • 转载:111篇
    • 译文:1篇
    • 评论:2条