时间戳知识点+stm32实时时钟代码编写

bai_lan_ya

已于 2024-10-02 16:05:22 修改

阅读量817

点赞数 13

文章标签： c++ c语言

于 2024-10-02 16:01:33 首次发布

本文链接：https://blog.csdn.net/bai_lan_ya/article/details/142678118

版权

一，Unix时间戳

1，Unix 时间戳（Unix Timestamp）

定义为从UTC/GMT的1970年1月1日0时0分0秒开始所经过的秒数，不考虑闰秒时间戳存储在一个秒计数器中，秒计数器为32位/64位的整型变量世界上所有时区的秒计数器相同，不同时区通过添加偏移来得到当地时间

2，GMT（Greenwich Mean Time）

格林尼治标准时间是一种以地球自转为基础的时间计量系统。它将地球自转一周的时间间隔等分为24小时，以此确定计时标准

3，UTC（Universal Time Coordinated）

协调世界时是一种以原子钟为基础的时间计量系统。它规定铯133原子基态的两个超精细能级间在零磁场下跃迁辐射9,192,631,770周所持续的时间为1秒。当原子钟计时一天的时间与地球自转一周的时间相差超过0.9秒时，UTC会执行闰秒来保证其计时与地球自转的协调一致

4，C语言中的time.h函数模块

为我们提供了时间获取和时间戳转换的相关函数，以方便地进行秒计数器、日期时间和字符串之间的转换

以上是关于时间戳的各个函数之间的转换关系

其中，localtime()（当地时间）是在gmtime()（格林尼治时间）的基础上根据东西经的时区加或减上时差的

struct tm
{
    int tm_sec;   // seconds after the minute - [0, 60] including leap second
    int tm_min;   // minutes after the hour - [0, 59]
    int tm_hour;  // hours since midnight - [0, 23]
    int tm_mday;  // day of the month - [1, 31]
    int tm_mon;   // months since January - [0, 11]
    int tm_year;  // years since 1900
    int tm_wday;  // days since Sunday - [0, 6]
    int tm_yday;  // days since January 1 - [0, 365]
    int tm_isdst; // daylight savings time flag
};

在time.h的头文件中，已经将以上关于时间转换的函数封装好了，所以我们只需要直接调用即可

#include "stdio.h"
#include "time.h"

time_t time_cnt;//时间戳默认使用64位寄存器存储变量
struct tm time_date;
char *time_str;

int main(void)
{
	//time_cnt = time(NULL);
	//time(&time_cnt);

	time_cnt = 1672588795;//设置时间戳
	printf("%d\n", time_cnt);

	time_date = *localtime(&time_cnt);//此函数可以将秒计数器转换为日期
	printf("%d\n", time_date.tm_year + 1900);//从1900年开始计算的
	printf("%d\n", time_date.tm_mon + 1);
	printf("%d\n", time_date.tm_mday );
	printf("%d\n", time_date.tm_hour );
	printf("%d\n", time_date.tm_min );
	printf("%d\n", time_date.tm_sec );
	printf("%d\n", time_date.tm_wday );

	time_cnt = mktime(&time_date);//将日期时间转化为秒计数器
	printf("%d\n", time_cnt);

	time_str = ctime(&time_cnt);//将日期时间以字符串的形式展示
	printf(time_str);

	time_str = asctime(&time_date);//将日期时间以字符串的形式展示
	printf(time_str);

	char t[50];
	strftime(t, 50, "%H-%M-%S", &time_date);
	printf(t);

	return 0;
}

当然，我们还可以使用时间戳转换工具来验证我们的代码是否正确

时间戳 UNIX时间戳转换 (Unix timestamp)时间戳转换工具 iP138在线工具

在单片机中，我们最常使用的函数是localtime()和gmtime()（格林尼治时间）

二，时间戳在单片机上的使用

1,BKP备份寄存器

BKP可用于存储用户应用程序数据。

当VDD（2.0~3.6V）电源被切断，他们仍然由VBAT（1.8~3.6V）维持供电。

当系统在待机模式下被唤醒，或系统复位或电源复位时，他们也不会被复位

TAMPER引脚产生的侵入事件将所有备份寄存器内容清除

RTC引脚输出RTC校准时钟、RTC闹钟脉冲或者秒脉冲

存储RTC时钟校准寄存器

用户数据存储容量：20字节（中容量和小容量）/ 84字节（大容量和互联型）

stm32f103c8t6中的容量是中容量，可以存储少量数据

下面来介绍一下基本结构：

橙色部分是后备区域，在stm32芯片中，当VDD主电源掉电时，后备区域依然可以有VBAT的备用电池供电，当VDD主电源上电时，后备区域供电会由VBAT切换到VDD，也就是主电源供电时，VBAT不会用到，这样可以节省电池容量
BKP主要有控制寄存器，状态寄存器，数据寄存器和RTC时钟校准寄存器
其中数据寄存器是主要部分，用来存储数据的，每个数据寄存器都是16位的（即一个数据寄存器可以存储两个字节）

2，RTC实时时钟

2.1 RTC（Real Time Clock）实时时钟介绍

RTC是一个独立的定时器，可为系统提供时钟和日历的功能（可联想51单片机的DS1302）
RTC和时钟配置系统处于后备区域，系统复位时数据不清零，VDD（2.0~3.6V）断电后可借助VBAT（1.8~3.6V）供电继续走时
32位的可编程计数器，可对应Unix时间戳的秒计数器
20位的可编程预分频器，可适配不同频率的输入时钟（加入预分频器，给RTCCLK降频率，保证分频器给计数器的频率为1Hz,保证计数正确）
可选择三种RTC时钟源：（接入RCCCLK）
- HSE时钟除以128（通常为8MHz/128）
- LSE振荡器时钟（通常为32.768KHz）
- LSI振荡器时钟（40KHz）

关于RTC时钟源，我们参考RCC时钟树原理图

下面我们来介绍时钟分频：

高速时钟（HSE,HSI）：一般提供内部程序运行和主要外设使用
低速时钟（LSI,LSE）：一般提供看门狗，RTC使用
RTCCLK三个来源：

OSC引脚接的HSE（外部高速晶振，8Mhz）,通过128分频，可以产生RTCCLK信号
OSC32引脚，接上外部低速晶振，可以直接产生信号提供给RTC，OSC32的晶振是内部RTC的专用时钟（计数器从1计数到32767，会自然溢出，产生1Hz信号,这样可以不要设计目标值，可以简化电路设计，同时也可以运用VBAT备用电源）
LSI内部低速晶振，一般精确度没有外部晶振高，所有LSI给RTCCLK可以当作一个备选方案

2.2 RTC的简单框图：

后备区域是核心的，分频和计数计时的部分
右边是中断输出使能和NVIC部分，上面是APB1总线读写部分
下面是和PWR关联的部分，RTC的闹钟可以唤醒设备，退出待机模式
RTC_PRL：重装载寄存器（用来写入计数目标值，用来配置几分频，例如写入6那就是7分频，因为是从0开始算起）
RTC_DIV：余数寄存器（用来不断地计数，也是一个自减计数器，每来一个输入时钟，DIV的值自减一次，自减到0时，再来一个输入时钟，DIV会溢出，输出一个脉冲信号，同时DIV从PRL获取重装值，回到重装值继续自减）
32位可编程计数器：看做Unix时间戳的秒计数器
RTC_ALR：闹钟寄存器（32位，与CNT同宽，用来设置闹钟）
RTC_Second:秒中断，表示每秒进行一次中断
RTC_Overflow:32位溢出中断（到2106年数据溢出才会产生中断）
RTC_Alarm:闹钟中断，当计数器和闹钟值相等时，触发中断，同时，闹钟信号可以把设备从待机模式唤醒

2.3 RTC基本结构图简化

2.4 RTC推荐的硬件电路设计

根据参考手册，我们可以设计以下电路进行设计

2.5 RTC操作注意事项

执行以下操作将使能对BKP和RTC的访问：

设置RCC_APB1ENR的PWREN和BKPEN，使能PWR和BKP时钟

设置PWR_CR的DBP，使能对BKP和RTC的访问

若在读取RTC寄存器时，RTC的APB1接口曾经处于禁止状态，则软件首先必须等待RTC_CRL寄存器中的RSF位（寄存器同步标志）被硬件置1

必须设置RTC_CRL寄存器中的CNF位，使RTC进入配置模式后，才能写入RTC_PRL、RTC_CNT、RTC_ALR寄存器

对RTC任何寄存器的写操作，都必须在前一次写操作结束后进行。可以通过查询RTC_CR寄存器中的RTOFF状态位，判断RTC寄存器是否处于更新中。仅当RTOFF状态位是1时，才可以写入RTC寄存器

三，读写备份寄存器的代码展示

1，介绍stm32中BKP相关的库函数

void BKP_DeInit(void);//可以将BKP的数据清零，恢复缺省配置函数的用途
void BKP_TamperPinLevelConfig(uint16_t BKP_TamperPinLevel);//配置TamperPin的有效电平，即高电平触发或者低电平触发
void BKP_TamperPinCmd(FunctionalState NewState);//是否开启侵入检测功能，若要侵入，需要先配置TAMPER的有效电平，再使能侵入检测功能
void BKP_ITConfig(FunctionalState NewState);//是否开启中断
void BKP_RTCOutputConfig(uint16_t BKP_RTCOutputSource);//时钟输出功能的配置
void BKP_SetRTCCalibrationValue(uint8_t CalibrationValue);//写入RTC校准寄存器
void BKP_WriteBackupRegister(uint16_t BKP_DR, uint16_t Data);//写备份寄存器
uint16_t BKP_ReadBackupRegister(uint16_t BKP_DR);//读备份寄存器
FlagStatus BKP_GetFlagStatus(void);//获取标志位
void BKP_ClearFlag(void);//清除标志位
ITStatus BKP_GetITStatus(void);//中断标志位
void BKP_ClearITPendingBit(void);//清除中断标志位

void PWR_BackupAccessCmd(FunctionalState NewState);//本章节需要使用到的函数：备份寄存器访问使能

2，开始配置BKP寄存器

2.1 以下代码可以初步的展示

写入数据后可以存储数据，复位后也能够再次读取到写入的数据

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"

int main(void)
{
	/*模块初始化*/
	OLED_Init();		//OLED初始化
	
	OLED_ShowString(1,1,"W:");
	OLED_ShowString(2,1,"R:");
	
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR,ENABLE);//开启时钟
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_BKP,ENABLE);
	
	PWR_BackupAccessCmd(ENABLE);
    BKP_WriteBackupRegister(BKP_DR1,0x1234);//中容量的芯片DR范围是1~10
	OLED_ShowHexNum(1,1,BKP_ReadBackupRegister(BKP_DR1),4);
	
	while (1)
	{
		
	}
}

2.2 加入按键调试的代码

按键代码

#include "stm32f10x.h"                  // Device header
#include "Delay.h"

/**
  * 函    数：按键初始化
  * 参    数：无
  * 返 回 值：无
  */
void Key_Init(void)
{
	/*开启时钟*/
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);		//开启GPIOB的时钟
	
	/*GPIO初始化*/
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_11;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStructure);						//将PB1和PB11引脚初始化为上拉输入
}

/**
  * 函    数：按键获取键码
  * 参    数：无
  * 返 回 值：按下按键的键码值，范围：0~2，返回0代表没有按键按下
  * 注意事项：此函数是阻塞式操作，当按键按住不放时，函数会卡住，直到按键松手
  */
uint8_t Key_GetNum(void)
{
	uint8_t KeyNum = 0;		//定义变量，默认键码值为0
	
	if (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_1) == 0)			//读PB1输入寄存器的状态，如果为0，则代表按键1按下
	{
		Delay_ms(20);											//延时消抖
		while (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_1) == 0);	//等待按键松手
		Delay_ms(20);											//延时消抖
		KeyNum = 1;												//置键码为1
	}
	
	if (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_11) == 0)			//读PB11输入寄存器的状态，如果为0，则代表按键2按下
	{
		Delay_ms(20);											//延时消抖
		while (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_11) == 0);	//等待按键松手
		Delay_ms(20);											//延时消抖
		KeyNum = 2;												//置键码为2
	}
	
	return KeyNum;			//返回键码值，如果没有按键按下，所有if都不成立，则键码为默认值0
}

主代码

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "Key.h"

uint8_t KeyNum;
uint16_t ArrayWrite[]={0x1234,0x5678};//按键按下一次后写入的数据
uint16_t ArrayRead[2];

int main(void)
{
	/*模块初始化*/
	OLED_Init();		//OLED初始化
	Key_Init();
	
	OLED_ShowString(1,1,"W:");
	OLED_ShowString(2,1,"R:");
	
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR,ENABLE);//开启时钟
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_BKP,ENABLE);
	
	PWR_BackupAccessCmd(ENABLE);
	
	while (1)
	{
		KeyNum=Key_GetNum();//获取键码值
		
		if(KeyNum==1)//按键按下
		{
			ArrayWrite[0]++;//变换测试数据
			ArrayWrite[1]++;
			
			BKP_WriteBackupRegister(BKP_DR1,ArrayWrite[0]);//将测试数据分别写入DR1,DR2
			BKP_WriteBackupRegister(BKP_DR2,ArrayWrite[1]);
			
			OLED_ShowHexNum(1,3,ArrayWrite[0],4);//显示写入的数据
			OLED_ShowHexNum(1,8,ArrayWrite[1],4);
		}
		ArrayRead[0]=BKP_ReadBackupRegister(BKP_DR1);//读取数据
		ArrayRead[1]=BKP_ReadBackupRegister(BKP_DR2);
		
		OLED_ShowHexNum(2,3,ArrayRead[0],4);//显示读取的数据
		OLED_ShowHexNum(2,8,ArrayRead[1],4);
	}
}

3，实时时钟

3.1 相关函数的介绍

void RCC_LSEConfig(uint8_t RCC_LSE);//配置LSE外部低速时钟
void RCC_LSICmd(FunctionalState NewState);//配置内部低速时钟，如果外部时钟不起振，可以调用这个函数
void RCC_RTCCLKConfig(uint32_t RCC_RTCCLKSource);//RTCCLK配置时钟源
void RCC_RTCCLKCmd(FunctionalState NewState);//RTCCLK启动时钟

FlagStatus RCC_GetFlagStatus(uint8_t RCC_FLAG);//获取标志位

void RTC_ITConfig(uint16_t RTC_IT, FunctionalState NewState);//配置中断输出
void RTC_EnterConfigMode(void);//进入配置模式，将CRL中的CNF为1，进入配置模式
void RTC_ExitConfigMode(void);//退出配置模式，将CNF位清0
uint32_t  RTC_GetCounter(void);//获取CNT计数器的值
void RTC_SetCounter(uint32_t CounterValue);//写入计数器的值，一般用来设置时间
void RTC_SetPrescaler(uint32_t PrescalerValue);//写入预分频器，这个值写入到预分频器的PRL重装寄存器中，用来配置预分频系数
void RTC_SetAlarm(uint32_t AlarmValue);写入闹钟值
uint32_t  RTC_GetDivider(void);//读取预分频器中的DIV余数寄存器，一般为了获得更加细致的时间
void RTC_WaitForLastTask(void);//等待上次操作完成，直到RTOFF状态位为1
void RTC_WaitForSynchro(void);//等待同步，清除RSF标志位，循环，直到RSF为1
FlagStatus RTC_GetFlagStatus(uint16_t RTC_FLAG);//下面都是关于标志位的函数
void RTC_ClearFlag(uint16_t RTC_FLAG);
ITStatus RTC_GetITStatus(uint16_t RTC_IT);
void RTC_ClearITPendingBit(uint16_t RTC_IT);

3.2 代码展示

#include "stm32f10x.h"                  // Device header
#include <time.h>

uint16_t MyRTC_Time[] = {2023, 1, 1, 23, 59, 55};	//定义全局的时间数组，数组内容分别为年、月、日、时、分、秒

void MyRTC_SetTime(void);				//函数声明

/**
  * 函    数：RTC初始化
  * 参    数：无
  * 返 回 值：无
  */
void MyRTC_Init(void)
{
	/*开启时钟*/
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);		//开启PWR的时钟
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_BKP, ENABLE);		//开启BKP的时钟
	
	/*备份寄存器访问使能*/
	PWR_BackupAccessCmd(ENABLE);							//使用PWR开启对备份寄存器的访问
	
	if (BKP_ReadBackupRegister(BKP_DR1) != 0xA5A5)			//通过写入备份寄存器的标志位，判断RTC是否是第一次配置
															//if成立则执行第一次的RTC配置
	{
		RCC_LSEConfig(RCC_LSE_ON);							//开启LSE时钟
		while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) != SET);	//等待LSE准备就绪
		
		RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);				//选择RTCCLK来源为LSE
		RCC_RTCCLKCmd(ENABLE);								//RTCCLK使能
		
		RTC_WaitForSynchro();								//等待同步
		RTC_WaitForLastTask();								//等待上一次操作完成
		
		RTC_SetPrescaler(32768 - 1);						//设置RTC预分频器，预分频后的计数频率为1Hz
		RTC_WaitForLastTask();								//等待上一次操作完成
		
		MyRTC_SetTime();									//设置时间，调用此函数，全局数组里时间值刷新到RTC硬件电路
		
		BKP_WriteBackupRegister(BKP_DR1, 0xA5A5);			//在备份寄存器写入自己规定的标志位，用于判断RTC是不是第一次执行配置
	}
	else													//RTC不是第一次配置
	{
		RTC_WaitForSynchro();								//等待同步
		RTC_WaitForLastTask();								//等待上一次操作完成
	}
}

//如果LSE无法起振导致程序卡死在初始化函数中
//可将初始化函数替换为下述代码，使用LSI当作RTCCLK
//LSI无法由备用电源供电，故主电源掉电时，RTC走时会暂停
/* 
void MyRTC_Init(void)
{
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_BKP, ENABLE);
	
	PWR_BackupAccessCmd(ENABLE);
	
	if (BKP_ReadBackupRegister(BKP_DR1) != 0xA5A5)
	{
		RCC_LSICmd(ENABLE);
		while (RCC_GetFlagStatus(RCC_FLAG_LSIRDY) != SET);
		
		RCC_RTCCLKConfig(RCC_RTCCLKSource_LSI);
		RCC_RTCCLKCmd(ENABLE);
		
		RTC_WaitForSynchro();
		RTC_WaitForLastTask();
		
		RTC_SetPrescaler(40000 - 1);
		RTC_WaitForLastTask();
		
		MyRTC_SetTime();
		
		BKP_WriteBackupRegister(BKP_DR1, 0xA5A5);
	}
	else
	{
		RCC_LSICmd(ENABLE);				//即使不是第一次配置，也需要再次开启LSI时钟
		while (RCC_GetFlagStatus(RCC_FLAG_LSIRDY) != SET);
		
		RCC_RTCCLKConfig(RCC_RTCCLKSource_LSI);
		RCC_RTCCLKCmd(ENABLE);
		
		RTC_WaitForSynchro();
		RTC_WaitForLastTask();
	}
}*/

/**
  * 函    数：RTC设置时间
  * 参    数：无
  * 返 回 值：无
  * 说    明：调用此函数后，全局数组里时间值将刷新到RTC硬件电路
  */
void MyRTC_SetTime(void)
{
	time_t time_cnt;		//定义秒计数器数据类型
	struct tm time_date;	//定义日期时间数据类型
	
	time_date.tm_year = MyRTC_Time[0] - 1900;		//将数组的时间赋值给日期时间结构体
	time_date.tm_mon = MyRTC_Time[1] - 1;
	time_date.tm_mday = MyRTC_Time[2];
	time_date.tm_hour = MyRTC_Time[3];
	time_date.tm_min = MyRTC_Time[4];
	time_date.tm_sec = MyRTC_Time[5];
	
	time_cnt = mktime(&time_date) - 8 * 60 * 60;	//调用mktime函数，将日期时间转换为秒计数器格式
													//- 8 * 60 * 60为东八区的时区调整
	
	RTC_SetCounter(time_cnt);						//将秒计数器写入到RTC的CNT中
	RTC_WaitForLastTask();							//等待上一次操作完成
}

/**
  * 函    数：RTC读取时间
  * 参    数：无
  * 返 回 值：无
  * 说    明：调用此函数后，RTC硬件电路里时间值将刷新到全局数组
  */
void MyRTC_ReadTime(void)
{
	time_t time_cnt;		//定义秒计数器数据类型
	struct tm time_date;	//定义日期时间数据类型
	
	time_cnt = RTC_GetCounter() + 8 * 60 * 60;		//读取RTC的CNT，获取当前的秒计数器
													//+ 8 * 60 * 60为东八区的时区调整
	
	time_date = *localtime(&time_cnt);				//使用localtime函数，将秒计数器转换为日期时间格式
	
	MyRTC_Time[0] = time_date.tm_year + 1900;		//将日期时间结构体赋值给数组的时间
	MyRTC_Time[1] = time_date.tm_mon + 1;
	MyRTC_Time[2] = time_date.tm_mday;
	MyRTC_Time[3] = time_date.tm_hour;
	MyRTC_Time[4] = time_date.tm_min;
	MyRTC_Time[5] = time_date.tm_sec;
}

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "MyRTC.h"

int main(void)
{
	/*模块初始化*/
	OLED_Init();		//OLED初始化
	MyRTC_Init();		//RTC初始化
	
	/*显示静态字符串*/
	OLED_ShowString(1, 1, "Date:XXXX-XX-XX");
	OLED_ShowString(2, 1, "Time:XX:XX:XX");
	OLED_ShowString(3, 1, "CNT :");
	OLED_ShowString(4, 1, "DIV :");
	
	while (1)
	{
		MyRTC_ReadTime();							//RTC读取时间，最新的时间存储到MyRTC_Time数组中
		
		OLED_ShowNum(1, 6, MyRTC_Time[0], 4);		//显示MyRTC_Time数组中的时间值，年
		OLED_ShowNum(1, 11, MyRTC_Time[1], 2);		//月
		OLED_ShowNum(1, 14, MyRTC_Time[2], 2);		//日
		OLED_ShowNum(2, 6, MyRTC_Time[3], 2);		//时
		OLED_ShowNum(2, 9, MyRTC_Time[4], 2);		//分
		OLED_ShowNum(2, 12, MyRTC_Time[5], 2);		//秒
		
		OLED_ShowNum(3, 6, RTC_GetCounter(), 10);	//显示32位的秒计数器
		OLED_ShowNum(4, 6, RTC_GetDivider(), 10);	//显示余数寄存器
	}
}