实时时钟_实时时钟模块 - CSDN
精华内容
参与话题
  • 关于实时时钟模块DS1302使用心得

    万次阅读 多人点赞 2017-10-22 23:45:16
    最近在做万年历,用到实时时钟DS1302模块,花了两天时间看资料和写驱动,想记录一下我的学习经过,顺便做一下总结。 首先就是在图书馆查各种资料,于是查到的大多是这些,主要时硬件方面的资料:   ...

    最近在做万年历,用到实时时钟DS1302模块,花了两天时间看资料和写驱动,想记录一下我的学习经过,顺便做一下总结。

    首先就是在图书馆查各种资料,于是查到的大多是这些,主要时硬件方面的资料:

     

     

    其实能查到很多资料,但是能为我们所用的不是很多。在使用一个芯片时,我一般时按照一下步骤去学习:

    1、芯片介绍;

    2、查看引脚定义;

    3、外围电路

    4、分析时序图;

    5、模仿着编写驱动程序,然后自己动手写驱动。

    6、实现功能。

    下面我就按照这个顺序去学习这款芯片;

    一、芯片介绍

    DS1302是DALLAS(达拉斯)公司出的一款涓流充电时钟芯片,2001年DALLAS被MAXIM(美信)收购,因此我们看到的DS1302的数据手册既有DALLAS的标志,又有MAXIM的标志;
    DS1302实时时钟芯片广泛应用于电话、传真、便携式仪器等产品领域,他的主要性能指标如下:
    1、DS1302是一个实时时钟芯片,可以提供秒、分、小时、日期、月、年等信息,并且还有软年自动调整的能力,可以通过配置AM/PM来决定采用24小时格式还是12小时格式。
    2、拥有31字节数据存储RAM。
    3、串行I/O通信方式,相对并行来说比较节省IO口的使用。
    4、DS1302的工作电压比较宽,大概是2.0V~5.5V都可以正常工作。采用双电源供电,当主电源比备用电源高0.2V时,由主电源供电,否则采用备用电源,一般是一个纽扣电池。
    5、DS1302这种时钟芯片功耗一般都很低,它在工作电压2.0V的时候,工作电流小于300nA。
    6、DS1302共有8个引脚,有两种封装形式,一种是DIP-8封装,芯片宽度(不含引脚)是300mil,一种是SOP-8封装,有两种宽度,一种是150mil,一种是208mil。

    二、引脚定义

    三、外围电路

    一般与单片机IO口相连时要加上拉电阻,提高 IO 口的驱动能力,这样信号比较稳定,计时也比较准确。

    四、分析时序图

    这是单字节写入的时序图,可见,先拉高使能端,进行使能选择,然后在时钟上升沿写入一个字节。

    DS1302在进行读写操作时最少读写两个字节,第一个是控制字节,就是一个命令,说明是读还是写操作,第二个时需要读写的数据。

    对于单字节写,只有在SCLK为低电平时才能将 CE 置高电平,所以刚开始将SCLK 置低,CE置高,然后把需要写入的字节送入 IO口,然后跳变SCLK,在SCLK下降沿时,写入数据

     

    五、编写驱动程序

    有了 上面的分析,我们就可以学着编写驱动程序了,可以把驱动程序分为几个模块来写,由底层慢慢往上累加,比如,我们先编写单个字节的读写操作,在编写整个数据的读写,

    复制代码
    #include "DS1302.h"
    
    //*******************
    void ds1302_writebyte(uchar byte){
        uint i;
        uint t = 0x01;
        for(i=0;i<8;i++){
            SCIO = byte & t;        
            t<<=1;
            DOWN();       //下降沿完成一个位的操作
        }
        SCIO = 1;//确保释放io引脚
    }
    //********************
    void ds1302_writedata(uchar addr,uchar data_){
        
        CE = 0;        nop();    
        SCLK = 0;    nop();    
        CE = 1;        nop();    //使能片选信号
        ds1302_writebyte((addr<<1)|0x80);    //方便后面写入
        ds1302_writebyte(data_);
        CE = 0;        nop();//传送数据结束
    
    }
    //*************************
    uchar ds1302_readbyte(){
        uint i;
        uchar data_ = 0;
        uint t = 0x01;     
        for(i=0;i<7;i++){     //c51好像不支持直接在for循环里面直接定义变量
    
            if(SCIO){
    
                data_ = data_ | t;    //低位在前,逐位读取,刚开始不对,估计是这个的问题
            }                
            t<<=1;
            DOWN();
        }
         return data_;
    }
    
    
    //************************
    uchar ds1302_readdata(uchar addr){
    
        uchar data_ = 0;
    
        CE = 0;     nop();
        SCLK = 0;  nop();
        CE = 1;      nop();
        ds1302_writebyte((addr<<1)|0x81);
        data_ = ds1302_readbyte();
        CE = 0;       nop();
        SCLK = 1;  nop();
        SCIO = 0;  nop();
        SCIO = 1;  nop();
    
        return data_;
    }
    
    //*********************
    void init_ds1302(){
    
         uchar i;
         CE = 0;   //初始化引脚
         SCLK = 0; 
         i  = ds1302_readdata(0x00);  //读取秒寄存器,秒在最低位
         if((i & 0x80 != 0)){
    
             ds1302_writedata(7,0x00); //撤销写保护,允许写入数据
            for(i = 0;i<7;i++){
    
                ds1302_writedata(i,init_time[i]);
            }
         }    
    }
    
    //**************
    void ds1302_readtime(){       //读取时间
          uint i;
          for(i = 0;i<7;i++){
    
                 init_time[i] = ds1302_readdata(i);
          }
    }
    复制代码

    其中头文件为:

    复制代码
    #ifndef __DS1302_H
    #define __DS1302_H
    
    #include "reg52.h"
    #include "intrins.h"
    
    
    #define uint unsigned int
    #define uchar unsigned char
    #define nop() _nop_()
    
    #define UP() {SCLK = 0;nop();SCLK = 1;nop();} //上升沿  ,使用宏定义函数时最后一定家分号
    #define DOWN() {SCLK = 1;nop();SCLK = 0;nop();} //下降沿
    
     //这个模块内没有集成上拉电阻,使用时最好接上2
    sbit CE = P2^5;//RET,使能输入引脚,当读写时,置高位
    sbit SCIO = P2^6;//IO     ,双向通信引脚,读写数据都是通过这个完成
    sbit SCLK = P2^7;//SCLK,时钟信号
    
    
    //为什么有时候好好的,也会出错显示少了分号呢?还气人啊!!!!
    
    void ds1302_writebyte(uchar byte);//写一个字节; 
    void ds1302_writedata(uchar addr,uchar data_);//给某地址写数据,data是c51内部的关键字,表示将变量定义在数据存储区,故此处用data_;
    uchar ds1302_readbyte();//读一个字节
    uchar ds1302_readdata(uchar addr);//读取某寄存器数据     ;
    void init_ds1302();
    void ds1302_readtime();
    
    
    extern uchar init_time[];
    
    #endif
    复制代码

     

    六、功能实现

     功能实现就简单了,就是加上主函数嘛,然后加上我们可以亲眼看见并感知的模块,比如用数码管显示时间:

    复制代码
    #include "DS1302.h"
    
    #define DIG P0
    sbit LSA = P2^2;
    sbit LSB = P2^3;
    sbit LSC = P2^4;
    
    
    
    uchar init_time[] = {0x50,0x15,0x14,0x22,0x10,0x06,0x17};//初始化的时间    //秒 分 时 日 月 周 年 
    uchar code DIG_CODE[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f}; //数码管数字表
    uint disp[8]={0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f,0x3f};//把要显示的数字传给他    
    uchar Num=0;
    uint count_flag = 0;     //中断溢出次数
    
    void time0_init();//定时器0初始化
    void display();//数码管显示时间
    
    void main(void){
        
         init_ds1302();     //初始化时写入起始时间
         time0_init();
    
         while(1){
                display();
         }
    }
    
    //***************
    void display(){
                
         ds1302_readtime();    //读取时间
        disp[7] = DIG_CODE[init_time[0]&0x0f];
        disp[6] = DIG_CODE[init_time[0]>>4];
        disp[5] = 0X40;        //显示一个横线
        disp[4] = DIG_CODE[init_time[1]&0x0f];
        disp[3] = DIG_CODE[init_time[1]>>4];
        disp[2] = 0X40;
        disp[1] = DIG_CODE[init_time[2]&0x0f];
        disp[0] = DIG_CODE[init_time[2]>>4];
    }
    //******************
    void time0_init(){
    
        TMOD=0X02;//选择为定时器模式,工作方式2,8位自动重装模式,仅用TRX打开启动。
        TH0=0X9C;    //给定时器赋初值,定时100us,0x9c就是156,就是还需计数100次产生溢出,就是0.1ms
        TL0=0X9C;    
        ET0=1;//打开定时器0中断允许
        EA=1;//打开总中断
        TR0=1;//打开定时器
    }
    
    void DigDisplay() interrupt 1    //中断入口函数,扫描以实现动态显示
    {
    //定时器在工作方式二会自动重装初,所以不用在赋值。
    //    TH0=0X9c;//给定时器赋初值,定时0.1ms
    //    TL0=0X00;
    
        count_flag++;    
        if(count_flag==1)
        {
            count_flag = 0;
            DIG=0; 
            switch(Num)     //位选,选择点亮的数码管,
            {
                case(7):
                    LSA=0;LSB=0;LSC=0; break;
                case(6):
                    LSA=1;LSB=0;LSC=0; break;
                case(5):
                    LSA=0;LSB=1;LSC=0; break;
                case(4):
                    LSA=1;LSB=1;LSC=0; break;
                case(3):
                    LSA=0;LSB=0;LSC=1; break;
                case(2):
                    LSA=1;LSB=0;LSC=1; break;
                case(1):
                    LSA=0;LSB=1;LSC=1; break;
                case(0):
                    LSA=1;LSB=1;LSC=1; break;    
            }
    
            DIG=disp[Num]; //段选,选择显示的数字。
            Num++;
            if(Num>7)
                Num=0;
        }    
    }
    复制代码

     

     总结一下:

    这个芯片基本上不是很难,但是想要用的灵活,用的上手,还是得多练的,最好是先把上面的驱动程序对着时序图自己分析一遍,然后自己亲手编写一下。

    还有就是看数据手册,一个芯片所能用到的数据,在数据手册上基本都能查到。资料谁都能查到,就看怎么用了。

    展开全文
  • STM32之RTC实时时钟

    万次阅读 多人点赞 2018-08-31 16:41:25
    STM32之RTC实时时钟 ...

    STM32之RTC实时时钟

    RTC实时时钟简介:
    STM32的RTC外设,实质是一个掉电后还继续运行的定时器,从定时器的角度来看,相对于通用定时器TIM外设,它的功能十分简单,只有计时功能(也可以触发中断).但是从掉电还能继续运行来看,它是STM32中唯一一个具有这个功能功能的外设.(RTC外设的复杂之处不在于它的定时,而在于它掉电还可以继续运行的特性)
    所谓掉电,是指电源Vpp断开的情况下,为了RTC外设掉电可以继续运行,必须给STM32芯片通过VBAT引脚街上锂电池.当主电源VDD有效时,由VDD给RTC外设供电.当VDD掉电后,由VBAT给RTC外设供电.无论由什么电源供电,RTC中的数据始终都保存在属于RTC的备份域中,如果主电源和VBA都掉电,那么备份域中保存的所有数据都将丢失.(备份域除了RTC模块的寄存器,还有42个16位的寄存器可以在VDD掉电的情况下保存用户程序的数序,系统复位或电源复位时,这些数据也不会被复位).
    从RTC的定时器特性来说,它是一个32位的计数器,只能向上计数.他使用的时钟源有三种,分别为:
    1,高速外部时钟的128分频:HSE/128;
    2,低速内部时钟LSI;
    3,低速外部时钟LSE;
    使用HSE分频时钟或者LSI的时候,在主电源VDD掉电的情况下,这两个时钟来源都会受到影响,因此没法保证RTC正常工作.所以RTC一般都时钟低速外部时钟LSE,频率为实时时钟模块中常用的32.768KHz,因为32768 = 2^15,分频容易实现,所以被广泛应用到RTC模块.(在主电源VDD有效的情况下(待机),RTC还可以配置闹钟事件使STM32退出待机模式).

    RTC工作过程:
    这里写图片描述

    RTC架构:
    图中浅灰色的部分都是属于备份域的,在VDD掉电时可在VBAT的驱动下继续运行.这部分仅包括RTC的分频器,计数器,和闹钟控制器.若VDD电源有效,RTC可以触发RTC_Second(秒中断)、RTC_Overflow(溢出事件)和RTC_Alarm(闹钟中断).从结构图可以看到到,其中的定时器溢出事件无法被配置为中断.如果STM32原本处于待机状态,可由闹钟事件或WKUP事件(外部唤醒事件,属于EXTI模块,不属于RTC)使它退出待机模式.闹钟事件是在计数器RTC_CNT的值等于闹钟寄存器RTC_ALR的值时触发的.
    因为RTC的寄存器是属于备份域,所以它的所有寄存器都是16位的.它的计数RTC_CNT的32位由RTC_CNTL和RTC_CNTH两个寄存器组成,分别保存计数值的低16位和高16位.在配置RTC模块的时钟时,把输入的32768Hz的RTCCLK进行32768分频得到实际驱动计数器的时钟TR_CLK = RTCCLK/37768 = 1Hz,计时周期为1秒,计时器在TR_CLK的驱动下计数,即每秒计数器RTC_CNT的值加1(常用)

    由于备份域的存在,使得RTC核具有了完全独立于APB1接口的特性,也因此对RTC寄存器的访问要遵守一定的规则.
    系统复位后,禁止访问后备寄存器和RCT,防止对后卫区域(BKP)的意外写操作.(执行以下操作使能对后备寄存器好RTC的访问):
    1,设置RCC_APB1ENR寄存器的PWREN和BKPEN位来使能电源和后备接口时钟.
    2,设置PWR_CR寄存器的DBP位使能对后备寄存器和RTC的访问.
    设置为可访问后,在第一次通过APB1接口访问RTC时,必须等待APB1与RTC外设同步,确保被读取出来的RTC寄存器值是正确的,如果在同步之后,一直没有关闭APB1的RTC外设接口,就不需要再次同步了.
    如果内核要对RTC寄存器进行任何的写操作,在内核发出写指令后,RTC模块在3个RTCCLK时钟之后,才开始正式的写RTC寄存器操作.我们知道RTCCLK的频率比内核主频低得多,所以必须要检查RTC关闭操作标志位RTOFF当这个标志被置1时,写操作才正式完成.
    (以上操作在STM32库里面都有库函数,不需要具体的查阅寄存器~~~~)

    UNIX时间戳:
    假如从现在起,把计数器RTC_CNT的计数值置0,然后每秒加1,RTC_CNT什么时候会溢出? RTC_CNT是一个32位寄存器,可存储的最大值为(2^32-1),这样的话就是在2^32秒之后溢出,大概换算为:
    Time = 2^32/365/24/60/60大约等于136年
    假如某个时刻读取到计数器的数值为X = 60*60*24*2(2天),又知道计数器是在2016年1月1日的0时0分0秒置0的,那么根据计数器的这个相对时间数值,可以计算得到这个时刻是2016年1月3日的0时0分0秒了,而计数器会在(2016+136)年左右溢出.(如果我们穿越回到2016年1月1日,如果还在使用这个计数器提供事件的话就会出问题啦.).
    定时器被置0的这个事件被称为计时元年,相对计时元年经过的秒数称为时间戳.

    PS:
    大多数操作系统都是利用时间戳和计时元年来计算当前时间的,而这个时间戳和计时元年大家都取了同一个标准——UNIX时间戳和UNIX计时元年.UNIX 计时元年被设置为格林威治时间1970年1月1日0时0分0秒,大概是为了纪念UNIX的诞生吧.而UNIX时间戳即为当前时间相对于UNIX计时元年经过的秒数.在这个计时系统中,使用的是有符号的32位整型变量来保存UNIX时间戳的,即实际可用计数位数比我们上面例子中的少了一位,少了这一位,UNIX 计时元年也相对提前了,这个计时方法在2038年1月19日03时14分07秒将会发生溢出.这个时间离我们并不远,UNIX时间戳被广泛应用到各种系统中,溢出可能会导致系统发生严重错误,差不多到这个时候,记得注意这个问题呀.

    实例分析:
    利用RTC提供北京时间:
    RTC外设这个连续计数的计数器,在相应软件配置下,可提供时钟日历的功能,修改计数器的值则可以重新设置系统当前的时间和日期.而 由于它的时钟配置系统(RCC_BDCR 寄存器)是在备份域,在系统复位或从待机模式唤醒后RTC的设置和时间维持不变,利用它,可以实现实时时钟的功能.

    main函数:
    struct rtc_time systmtime;
    int main(void)
    {
    /串口配置/
    USART1_Config();
    /配置RTC秒中断优先级/
    NVIC_Configuration();
    //RTC检测及配置
    RTC_CheckAndConfig(&systmtime);
    //刷新时间
    Time_Show(&systmtime);
    }
    main函数流程:
    1,用到了串口,配置好串口(代码和之前的例程一样);
    2,配置RTC秒中断优先级,这里设置主优先级为1,次优先级为0(只用到一个RTC,中断随便写都可以).(代码和之前的中断例程相似,只不过中断通道不一样,这里使用的中断通道是RTC_IRQn);
    3,查看RTC外设是否在本次VDD上电前被配置过,如果没有被配置过,则需要输入当前时间,重新初始化RTC和配置时间;
    4,配置好RTC后,根据秒中断设置的标志位,每隔1秒向终端更新一次;

    事件管理结构体 rtc_time
    struct rtc_time
    {
    int tm_sec;
    int tm_min;
    int tm_hour;
    int tm_mday;
    int tm_mon;
    int tm_year;
    int tm_wday;
    }
    这个类型的结构体有时,分,秒,日,月,年及星期7个成员.当需要给RTC的计时器重新配置时间时(更改时间戳),肯定不会询问用户现在距离UNIX计时元年过了多少秒,而是向用户询问现在的公元纪年,以及所在时区的事件.根据RTC计时器向用户输出时间.
    这就是 rtc_time 这个结构体的作用,配置RTC时,保存用户输入的时间,其它函数通过它求出UNIX时间戳,写入RTC,RTC正常运行后,需要输出时间时,其它函数通过RTC获取UNIX时间戳,转化成用友好的时间表示方式保存在这个结构体上.

    PS:
    起始在C语言标准库ANSI C中,也有类似的结构体所以 struct tm,位于标准的time.h文件中,转化函数是mktime()和localtime(),分别把tm结构体成员转化成时间戳和用时间戳转化成结构体成员.

    检查RTC RTC_CheckAndConfig()

    void RTC_CheckAndConfig(struct rtc_time *tm)
    {
    /检查备份寄存器BKP_DR1,内容不为0xA5A5,则需要重新配置时间并且询问用户调整时间/
    if(BKP_ReadBackupRegister(BKP_DR1) != 0xA5A5)
    {
    printf(“\r\n\r\n RTC not yet configured….”);
    /* RTC 配置 */
    RTC_Configuration();
    printf(“\r\n\r\n RTC configured….”);
    /* 用户输入时间*/
    Time_Adjust(tm);
    /再往备份寄存器BKP_DR1写入0xA5A5/
    BKP_WriteBackupRegister(BKP_DR1, 0xA5A5);
    }
    /启动无需设置新时钟/
    else
    {
    /检查是否掉电重启/
    if (RCC_GetFlagStatus(RCC_FLAG_PORRST) != RESET)
    {
    printf(“\r\n\r\n Power On Reset occurred….”);
    }
    /检查是否Reset复位/
    else if (RCC_GetFlagStatus(RCC_FLAG_PINRST) != RESET)
    {
    printf(“\r\n\r\n External Reset occurred….”);
    }
    printf(“\r\n No need to configure RTC….”);
    /等待寄存器同步/
    RTC_WaitForSynchro();
    /允许RTC秒中断/
    RTC_ITConfig(RTC_IT_SEC, ENABLE);
    /等待上次RTC寄存器写操作完成/
    RTC_WaitForLastTask();
    }
    /定义了时钟输出宏,则配置校正时钟输出到 PC13,用于RTC时钟频率的校准或调整时间补偿/
    #ifdef RTCClockOutput_Enable
    /使能PWR和BKP的时钟/
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
    /允许访问BKP备份域/
    PWR_BackupAccessCmd(ENABLE);
    /输出64分频时钟/
    BKP_RTCOutputConfig(BKP_RTCOutputSource_CalibClock);
    #endif
    RCC_ClearFlag();
    }
    if语句调用BKP_ReadBackupRegister()读取RTC备份域寄存器里面的值,判断备份寄存器里面的是否正确,根据后面代码,如果配置成功,会向备份域寄存器写入数值0xA5A5.
    (这个数值在VDD掉电后仍然会保存,如果VBAT也掉电,那么备份域,RTC所有寄存器将被复位,这时这个寄存器的值就不会等于0xA5A5了,RTC的计数器的值也是无效的.
    简单的说,就是写入的这个数值用作标志RTC是否从未被配置或配置是否已经失效,然后写入任何数值到任何一个备份域寄存器,只要检查的时候与写入值匹配就行了)

    RTC未被配置或者配置已经失效的情况:
    1,如果RTC从未被配置或者配置已经失效(备份域寄存器写入值等于0xA5A5)这两种情况其中一种为真的话,则调用RTC_Configuration()来初始化RTC,配置RTC外设的控制参数,时钟分频等,并往电脑的超级终端打印出相应的调试信息;
    2,初始化好RTC之后,调用函数 Time_Adjust() 让用户键入(通过超级终端输入)时间值;
    3,输入时间值后,Time_Adjust() 函数把用户输入的北京时间转化为UNIX时间戳,并把这个UNIX时间戳写入到RTC外设的计数寄存器RTC_CNT.接着RTC外设在这个时间戳的基础上,每秒对RTC_CNT加1,RTC时钟就运行起来了,并且在VDD掉电还运行,以后需要知道时间就直接读取RTC的计时值,就可以计算出时间了;
    4,设置好时间后,调用BKP_WriteBackupRegister()把0xA5A5这个值写入备份域寄存器,作为配置成功的标志;

    确认RTC曾经被配置过的情况:
    1,调用RCC_GetFlagStatus检测是上电复位还是按键复位,根据不同的复位情况在超级终端中打印出不同的调试信息(两种复位都不需要重新设置RTC里面的时间值);
    2,调用RTC_WaitForSynchro等待APB1接口与RTC外设同步,上电后第一次通过APB1接口访问RTC时必须要等待同步;
    3,同步完成后调用RTC_ITConfig()使能RTC外设的秒中断(使能RTC的秒中断是一个对RTC外设寄存器的写操作);
    4,进行写操作以后,必须调用RTC_WaitForLastTask()来等待,确保写操作完成;

    在下面有一个条件编译选项询问是否需要output RTCCLK/64 on Tamper pin,这是RTC的时钟输出配置,在rtc的头文件定义 RTCClockOutput_Enable这个宏,PC13引脚会输出RTCCLK的64分频时钟,主要是用于RTC时钟频率的校准或调整时间补偿.
    (如果需要用到这个时钟信号的话,只需要在头文件定义RTCClockOutput_Enable这个宏就行了,不要定义为0值就行了~~~~)

    初始化RTC RTC_Configuration():
    void RTC_Configuration(void)
    {
    /使能PWR和BKP时钟/
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);
    /对备份域进行软件复位/
    PWR_BackupAccessCmd(ENABLE);
    /对备份域进行软件复位/
    BKP_DeInit();
    /* 使能低速外部时钟 LSE */
    RCC_LSEConfig(RCC_LSE_ON);
    /* 等待LSE起振稳定 */
    while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET)
    {}
    /* 选择LSE作为 RTC 外设的时钟*/
    RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
    /* 使能RTC时钟 */
    RCC_RTCCLKCmd(ENABLE);
    /* 等待RTC寄存器与APB1同步*/
    RTC_WaitForSynchro();
    /* 等待对RTC的写操作完成*/
    RTC_WaitForLastTask();
    /* 使能RTC秒中断 */
    RTC_ITConfig(RTC_IT_SEC, ENABLE);
    /* 等待对RTC的写操作完成 */
    RTC_WaitForLastTask();
    /* 设置RT 时钟分频: 使RTC定时周期为1秒 */
    RTC_SetPrescaler(32767);
    /* RTC 周期 = RTCCLK/RTC_PR = (32.768 KHz)/(32767+1) */
    /等待对RTC的写操作完成 /
    RTC_WaitForLastTask();
    }
    在这个初始化函数里,没有见到熟悉的初始化结构体,对RTC的每一个初始化参数都是使用相应的库函数来配置的.RTC作为备份域的一份子,在访问前首先要使能备份域、电源管理外设的时钟,设置备份域访问权限,作为定时器,初始化时必须要选择好时钟来源,时钟分频.

    时间调节Time_Adjust():
    void Time_Adjust(struct rtc_time *tm)
    {
    /* 等待前面可能的 RTC 写操作完成 */
    RTC_WaitForLastTask();
    /* 利用串口,在终端向用户询问当前北京时间(年月日时分秒),
    写入到 rtc_time 型结构体 */
    Time_Regulate(tm);
    /* 计算输入的日期是星期几,把rtc_time型结构体填充完整 */
    GregorianDay(tm);
    /* 根据输入日期,计算出 UNIX 时间戳,修改当前 RTC 计数寄存器内容*/
    RTC_SetCounter(mktimev(tm));
    /* 等待 RTC 写操作完成 */
    RTC_WaitForLastTask();
    }
    这里流程就是使用Time_Regulate()从终端获取当前北京时间,然后根据用户的输入,调用函数mktimev()根据用户输入的年,月,日,时,.分,秒数据,计算出相应的UNIX时间戳,最后调用库函数RTC_SetCounter()把这个UNIX时间戳写入到计数器RTC_CNT,RTC就正式运行了.

    获取时间Time_Regulate():
    void Time_Reglate(struct rtc_time *tm)
    {
    u32 Tmp_YY = 0xFF, Tmp_MM = 0xFF, Tmp_DD = 0xFF, Tmp_HH =0xFF, Tmp_MI = 0xFF, Tmp_SS = 0xFF;

    printf("\r\n==========Time Settings==================");
    
    printf("\r\n 请输入年份(Please Set Years): 20");
    while (Tmp_YY == 0xFF)
    {
    Tmp_YY = USART_Scanf(99);
    }
    printf("\n\r 年份被设置为: 20%0.2d\n\r", Tmp_YY);
    tm->tm_year = Tmp_YY+2000;
    
    Tmp_MM = 0xFF;
    printf("\r\n 请输入月份(Please Set Months): ");
    while (Tmp_MM == 0xFF)
    {
    Tmp_MM = USART_Scanf(12);
    }
    printf("\n\r 月份被设置为: %d\n\r", Tmp_MM);
    tm->tm_mon= Tmp_MM;
    
    Tmp_DD = 0xFF;
    printf("\r\n 请输入日期(Please Set Dates): ");
    while (Tmp_DD == 0xFF)
    {
    Tmp_DD = USART_Scanf(31);
    }
    printf("\n\r 日期被设置为: %d\n\r", Tmp_DD);
    tm->tm_mday= Tmp_DD;
    
    Tmp_HH = 0xFF;
    printf("\r\n 请输入时钟(Please Set Hours): ");
    while (Tmp_HH == 0xFF)
    {
    Tmp_HH = USART_Scanf(23);
    }
    printf("\n\r 时钟被设置为: %d\n\r", Tmp_HH );
    tm->tm_hour= Tmp_HH;
    
    Tmp_MI = 0xFF;
    printf("\r\n 请输入分钟(Please Set Minutes): ");
    while (Tmp_MI == 0xFF)
    {
    Tmp_MI = USART_Scanf(59);
    }
    printf("\n\r 分钟被设置为: %d\n\r", Tmp_MI);
    tm->tm_min= Tmp_MI;
    
    Tmp_SS = 0xFF;
    printf("\r\n 请输入秒钟(Please Set Seconds): ");
    while (Tmp_SS == 0xFF)
    {
    Tmp_SS = USART_Scanf(59);
    }
    printf("\n\r 秒钟被设置为: %d\n\r", Tmp_SS);
    tm->tm_sec= Tmp_SS; 
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55

    }
    这里就是在里面从终端获取用户输入的时间,要留意的是,从终端输入的ASCII码,而不是实际数值(在USART_Scanf里面做处理)

    PS:这里补上USART_Scanf()的代码,之前串口篇的时候好像没有附上
    static uint8_t USART_Scanf(uint32_t value)
    {
    uint32_t index = 0;
    uint32_t tmp[2] = {0, 0};
    while (index < 2)
    {
    while (USART_GetFlagStatus(USART1, USART_FLAG_RXNE) ==RESET)
    {}

        tmp[index++] = (USART_ReceiveData(USART1));
        /*数字0到9的ASCII码为0x30至0x39*/
        if((tmp[index - 1] < 0x30) || (tmp[index -1] > 0x39))
        {
            printf("\n\rPlease enter valid number between 0 and 9 -->: ")
            index--;
        }
    }
    /* 计算输入字符的 ASCII 码转换为数字*/
    index = (tmp[1] - 0x30) + ((tmp[0] - 0x30) * 10);
    
    if (index > value)
    {
        printf("\n\rPlease enter valid number between 0 and %d", value);
        return 0xFF;
    }
    return index;   
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    }

    计算UNIX时间戳mktimev():
    从用户端获取了北京时间后,就可以用它换成 UNIX 时间戳了,但不能忽略一个重要的问题——时差.UNIX时间戳的计时元年是以标准时间(GMT 时区)为准的,而北京时间为 GMT+8,即时差为+8小时.为了保证我们写入到RTC_CNT的是标准的UNIX时间戳(主要是为了兼容),以北京时间转化出的秒数要减去8*60*60才是标准的UNIX时间戳.
    u32 mktimev(struct rtc_time *tm)
    {
    if (0 >= (int) (tm->tm_mon -= 2))
    {
    tm->tm_mon += 12;
    tm->tm_year -= 1;
    }
    /计算出输入的北京时间的一共的秒数/
    return((( (u32)(tm->tm_year/4 - tm->tm_year/100 + tm->tm_year/400 + 367*tm->tm_mon/12 + tm->tm_mday)
    + tm->tm_year*365 - 719499)*24 + tm->tm_hour)*60 + tm->tm_min)*60 + tm->tm_sec-8*60*60;
    /8*60*60把输入的北京时间转换为标准时间在写入计时器中,确保计时器的数据为标准UNIX时间戳/
    }
    8*60*60把输入的北京事件转换为标准事件在写入计时器中,确保计时器的数据为标准UNIX时间戳,如果向使用其他时区,则根据不同哟的时区修改这个值.
    返回值最终被写入到RTC_CNT计数器中RTC_SetCounter(mktimev(tm));

    输出时间到终端Time_Show():
    void Time_Show(struct rtc_time *tm)
    {
    while (1)
    {
    /每个1s/
    if(TimeDisplay == 1)
    {
    /显示时间/
    Time_Display(RTC_GetCounter(),tm);
    TimeDisplay = 0;
    }
    }
    }
    TimeDisplay是RTC秒中断标志,RTC的秒中断被触发后,进入中断服务函数,把这个变量 TimeDisplay置1.这个函数是死循环检查这个标志,变为1时,调用Time_Display()显示最新时间,实现每隔1秒向终端更新一次时间,更新完后再把 TimeDisplay置0,等待下次秒中断.

    RTC秒中断服务函数:
    void RTC_IRQHandler(void)
    {
    if (RTC_GetITStatus(RTC_IT_SEC) != RESET)
    {
    /* 清除秒中断标志 */
    RTC_ClearITPendingBit(RTC_IT_SEC);
    /* 把标志位置 1 */
    TimeDisplay = 1;
    /* 等待写操作完成 */
    RTC_WaitForLastTask();
    }
    }
    在这个函数中并没有任何对RTC_CNT的操作,如果VDD掉电,RTC是无法触发秒中断的,所以想利用秒中断的方案实现实时时钟是不现实的,秒中断最适合用在类似本例程的触发显示的时间更新场合,而不是用于计数.

    显示时间Time_Display():
    void Time_Display(uint32_t TimeVar,struct rct_time *tm)
    {
    static uint32_t FirstDisplay = 1;
    uint32_t BJ_TimeVar;
    uint8_t str[15]; // 字符串暂存

    /* 把标准时间转换为北京时间*/
    BJ_TimeVar =TimeVar + 8*60*60;
    /*利用时间戳转换为北京时间*/
    to_tm(BJ_TimeVar, tm);
    
    if((!tm->tm_hour && !tm->tm_min && !tm->tm_sec) || (FirstDisplay))
    {
        GetChinaCalendar((u16)tm->tm_year, (u8)tm->tm_mon, (u8)tm->tm_mday, str);
    
        printf("\r\n\r\n 今天农历:%0.2d%0.2d,%0.2d,%0.2d", str[0], str[1], str[2], str[3]);
    
        GetChinaCalendarStr((u16)tm->tm_year,(u8)tm->tm_mon,(u8)tm->tm_mday,str);
        printf(" %s", str);
    
        if(GetJieQiStr((u16)tm->tm_year, (u8)tm->tm_mon, (u8)tm->tm_mday, str))
        {
            printf(" %s\n\r", str);
        }
        FirstDisplay = 0;
    }
    printf("\r UNIX 时间戳 = %d ,当前时间为: %d 年(%s 年) %d%d日 (星期%s) %0.2d:%0.2d:%0.2d",TimeVar,tm->tm_year, zodiac_sign[(tm->tm_year-3)%12], tm->tm_mon, tm->tm_mday,WEEK_STR[tm->tm_wday], tm->tm_hour,tm->tm_min, tm->tm_sec);
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    }
    这里的第一个输入参数为UNIX时间戳,在Time_Show()调用的时候,利用库函数RTC_GetCounter()读取了RTC_CNT的当前数值,并把这个计数值作为Time_Dispaly()的输入参数.
    根据配置,RTC_CNT的计数值是标准时间GMT的UNIX时间戳,为了计算北京时间,在使用RTC_CNT计数值转换北京时间时,要加上时差(BJ_TimeVar =TimeVar + 8*60*60;).之后,把这个变量 BJ_TimeVar作为函数 to_tm()的输入参数,把时间戳转换成年,月,日,时,分,秒的格式,并保存到时间结构体中.
    (to_tm()(纯算法)和GetChinaCalendar()这里就不展开了,需要的话可以留言我会发送给你)

    PS:
    如果要使用普通的51芯片实现实时时钟,需要借助时钟芯片,DS1302或DS12C887,在STM32里面只要用到一个定时器就搞掂了!!!

    原文章地址:https://blog.csdn.net/linzhihan7410/article/details/52195857

    展开全文
  • 实时时钟是一个独立的定时器。RTC模块拥有一组连续计数的计数器,在相应软件配置下,可提供时钟日历的功能。修改计数器的值可以重新设置系统当前的时间和日期。 RTC模块和时钟配置系统(RCC_BDCR寄存器)处于后备区域...

    目录

    概述

    主要特性

    读RTC寄存器

    配置RTC寄存器


    概述

    实时时钟是一个独立的定时器。RTC模块拥有一组连续计数的计数器,在相应软件配置下,可提供时钟日历的功能。修改计数器的值可以重新设置系统当前的时间和日期。

    RTC模块和时钟配置系统(RCC_BDCR寄存器)处于后备区域,即在系统复位或从待机模式唤醒后,RTC的设置和时间维持不变。

    系统复位后,对后备寄存器和RTC的访问被禁止,这是为了防止对后备区域(BKP)的意外写操作。执行以下操作将使能对后备寄存器和RTC的访问:

    ● 设置寄存器RCC_APB1ENR的PWREN和BKPEN位,使能电源和后备接口时钟

    ● 设置寄存器PWR_CR的DBP位,使能对后备寄存器和RTC的访问。

    Stm32F103R6之实时时钟(RTC)

    图 1RTC框图

    主要特性

    ● 可编程的预分频系数:分频系数最高为220。

    ● 32位的可编程计数器,可用于较长时间段的测量。

    ● 2个分离的时钟:用于APB1接口的PCLK1和RTC时钟(RTC时钟的频率必须小于PCLK1时钟频率的四分之一以上)。

    ● 可以选择以下三种RTC的时钟源:

    ─ HSE时钟除以128;

    ─ LSE振荡器时钟;

    ─ LSI振荡器时钟。

    ● 2个独立的复位类型:

    ─ APB1接口由系统复位;

    ─ RTC核心(预分频器、闹钟、计数器和分频器)只能由后备域复位。

    ● 3个专门的可屏蔽中断:

    ─ 闹钟中断,用来产生一个软件可编程的闹钟中断。

    ─ 秒中断,用来产生一个可编程的周期性中断信号(最长可达1秒)。

    ─ 溢出中断,指示内部可编程计数器溢出并回转为0的状态。

    读RTC寄存器

    RTC核完全独立于RTC APB1接口。

    软件通过APB1接口访问RTC的预分频值、计数器值和闹钟值。但是,相关的可读寄存器只在与RTC APB1时钟进行重新同步的RTC时钟的上升沿被更新。RTC标志也是如此的。 这意味着,如果APB1接口曾经被关闭,而读操作又是在刚刚重新开启APB1之后,则在第一次的内部寄存器更新之前,从APB1上读出的RTC寄存器数值可能被破坏了(通常读到0)。下述几种情况下能够发生这种情形:

    ● 发生系统复位或电源复位

    ● 系统刚从待机模式唤醒。

    ● 系统刚从停机模式唤醒。

    所有以上情况中,APB1接口被禁止时(复位、无时钟或断电)RTC核仍保持运行状态。

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

    配置RTC寄存器

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

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

    配置过程:

    1. 查询RTOFF位,直到RTOFF的值变为’1’

    2. 置CNF值为1,进入配置模式

    3. 对一个或多个RTC寄存器进行写操作

    4. 清除CNF标志位,退出配置模式

    5. 查询RTOFF,直至RTOFF位变为’1’以确认写操作已经完成。

    仅当CNF标志位被清除时,写操作才能进行,这个过程至少需要3个RTCCLK周期。

    展开全文
  • 实时时钟RTC

    2020-04-01 18:13:47
    外围设备控制器芯片(ICH)内部,集成了实时时钟电路(RTC),以及两个CMOS组成的静态存储器(CMOS RAM),通常为128B;RTC负责计时,由1个32.768kHz的石英晶体振荡器驱动,经分频后用于CMOS RAM进行每秒一次的时间刷新; ...

    1.简述

    外围设备控制器芯片(ICH)内部,集成了实时时钟电路(RTC),以及两个CMOS组成的静态存储器(CMOS RAM),通常为128B;
    RTC负责计时,由1个32.768kHz的石英晶体振荡器驱动,经分频后用于CMOS RAM进行每秒一次的时间刷新;
    CMOS RAM中时间信息如下表所示,前10字节为常规时间信息:

    偏移地址 内容 偏移地址 内容
    0x00 0x07
    0x01 闹钟秒 0x08
    0x02 0x09
    0x03 闹钟分 0x0A 寄存器A
    0x04 0x0B 寄存器B
    0x05 闹钟时 0x0C 寄存器C
    0x06 星期 0x0D 寄存器D

    2.访问

    CMOS RAM访问须通过两个端口访问:索引端口0x70/0x74,数据端口0x71/0x75;
    端口0x70的位7用于允许或禁止NMI,寄存器ABCD为8位寄存器,ABD可读可写,C只读;
    RTC芯片中断信号通向8259从片IR0,在计算机启动期间,BIOS初始化中断控制器:主片中断号设为从0x08开始,从片中断号从0x70开始
    ==>启动后,RTC中断号默认0x70

    展开全文
  • RTC实时时钟(LCD显示)

    千次阅读 2018-12-09 15:41:50
    实时时钟(RTC)是一个独立的定时器。RTC模块拥有一组连续计数的计数器,在相应软件配置下,可提供时钟日历的功能。修改计数器的值可以重新设置系统当前的时间和日期。 RTC模块和时钟配置系统(RCC_BDCR寄存器)处...
  • 实时时钟DS1302详细介绍

    千次阅读 2018-05-28 22:19:32
    来源于:http://www.51hei.com/bbs/dpj-22465-1.html 在前面的课程中我们已经...那么除了这些在前面新学到的时钟概念外,还有一个我们早已熟悉的不能再熟悉的时钟概念——年-月-日 时:分:秒,就是我们的钟表和日...
  • RTC实时时钟特征与原理

    千次阅读 2019-09-01 20:10:54
    RTC模块拥有一个连续计数的计数器,在相应的软件配置下,可以提供时钟日历的功能。修改计数器的值可以重新设置当前时间和日期。 RTC模块和时钟配置系统(RCC_BDCR寄存器)是在后备区域,即在系统复位或从待机模式唤醒...
  • 【STM32】RTC实时时钟,步骤超细详解,一文看懂RTC

    千次阅读 多人点赞 2020-04-24 23:01:42
    RTC (Real Time Clock):实时时钟 RTC是个独立的定时器。RTC模块拥有一个连续计数的计数器,在相应的软件配置下,可以提供时钟日历的功能。修改计数器的值可以重新设置当前时间和日期 RTC还包含用于管理低功耗模式的...
  • 《STM32中文参考手册V10》-第16章 实时时钟(RTC)   RTC实时时钟 RTC实时时钟简介 实时时钟是一个独立的定时器。RTC模块拥有一组连续计数的计数器,在相应软件配置下,可提供时钟日历的功能。修改计数器的值...
  • 实时时钟:RTC时钟,用于提供年、月、日、时、分、秒和星期等的实时时间信息,由后备电池供电,当你晚上关闭系统和早上开启系统时,RTC仍然会保持正确的时间和日期。 系统时钟:是一个存储于系统内存中的逻辑时钟...
  • RTC(Real-Time Clock) 实时时钟。RTC是集成电路,通常称为时钟芯片。在一个嵌入式系统中,通常采用RTC来提供可靠的系统时间,包括时分秒和年月日等,而且要求在系统处于关机状态下它也能正常工作(通常采用后备电池...
  • STM32-(27):RTC实时时钟

    2019-05-30 20:24:16
    实时时钟的缩写是RTC(Real_Time Clock) 实时时钟是一个独立的定时器。RTC模块拥有一组连续计数的计数器,在相应软件配置下,可提供时钟日历的功能。修改计数器的值可以重新设置系统当前的时间和日期 RTC由两个...
  • rtc实时时钟和单片机时钟的区别  实时时钟是指给日期及时间计数器累加的时钟,通常是32768Hz,系统时钟是指单片机内部的主时钟,给各个模块提供工作时钟的基础,CPU时钟是指经过CPU的PLL后将系统时钟改变为CPU工作...
  • 关于RTC(实时时钟

    2020-05-13 11:06:45
    它为人们提供精确的实时时间或为电子系统提供精确的时间基准,目前实时时钟大多采用精度较高的晶体振荡器作为时钟源。 RTC的晶振:(硬件结构) 任何实时时钟的核心都是晶振,晶振频率为32768 Hz 。它为分频计数器...
  • SOC RTC时钟——为什么实时时钟的晶振都是32.768KHZ呢? 0. 实时时钟(RTC,Real Time Clock) 实时时钟的缩写是RTC(Real_Time Clock)。RTC 是集成电路,通常称为时钟芯片 1. 晶振 晶振一般叫做晶体谐振器,是一种...
  • STM32 RTC实时时钟

    万次阅读 2016-10-06 10:09:05
    今天是周天,哈尔滨阴天转阵雨。。博主原本准备今天去逛街的。原因你懂的→_→ 接下来进入今天的正题(博主用的是战舰STM32库函数版):博主今天将会和大家讨论两个知识点: ... 1、STM32的实时时钟(RTC)是
  • 1、大多数单片机都只有系统时钟一个。就是CPU的各节拍工作时序的驱动源了。这个频率一般为几MHz。速度比较快,其目的无非是让单片机快点干活。...2、实时时钟,是单片机计时的时钟或独立的可被单片机访问的时钟。它
  • 实时时钟 -- “RTC”的使用

    千次阅读 2016-09-13 20:29:55
    一、实时时钟DS1302简介 1. DS1302是美国DALLAS公司推出的一种高性能、低功耗、带RAM的实时时钟电路。 2. 特点 a> DS1302可以对年月日周时分秒计数。时间最多计时到2100年。 b> 工作电压:2.0 ~ 5.5 V。 c> ...
  • C语言经典程序设计(源代码)之实时时钟1111
  • STM32学习笔记一一RTC实时时钟

    千次阅读 2020-07-04 11:56:59
    STM32 的实时时钟(RTC)是一个独立的定时器。 STM32 的 RTC 模块拥有一组连续计数的计数器,在相应软件配置下,可提供时钟日历的功能。修改计数器的值可以重新设置系统当前的时间和日期。 RTC 模块和时钟配置系统 ...
1 2 3 4 5 ... 20
收藏数 47,688
精华内容 19,075
关键字:

实时时钟