树莓派基础实验32：DS1302实时时钟模块实验

一、介绍

  现在有很多流行的串行时钟芯片，如DS1302，DS1307，PCF8485等，由于简单的接口，低成本和易用性，他们被广泛应用于电话、传真、便携式仪器等产品领域。在本实验中，我们将使用DS1302实时时钟（RTC）模块获取当前日期和时间。

  DS1302可以用于数据记录，特别是对某些具有特殊意义的数据点的记录，能实现数据与出现该数据的时间同时记录。这种记录对长时间的连续测控系统结果的分析，及对异常数据出现的原因的查找具有重要意义。

  传统的数据记录方式是隔时采样或定时采样，没有具体的时间记录，因此，只能记录数据而无法准确记录其出现的时间；若采用单片机计时，一方面需要采用计数器，占用硬件资源，另一方面需要设置中断、查询等，同样耗费单片机的资源，而且，某些测控系统可能不允许。但是，如果在系统中采用时钟芯片DS1302，则能很好地解决这个问题。

二、组件

★Raspberry Pi 3主板*1

★树莓派电源*1

★40P软排线*1

★DS1302实时时钟模块*1

★面包板*1

★跳线若干

三、实验原理

DS1302实时时钟模块 DS1302时钟模块原理图

1. DS1302的特点

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

DS1302的引脚封装图

  7、当供电电压是5V的时候，兼容标准的TTL电平标准，这里的意思是，可以完美的和单片机进行通信。
   8、由于DS1302是DS1202的升级版本，所以所有的功能都兼容DS1202。此外DS1302有两个电源输入，一个是主电源， 另外一个是备用电源，比如可以用电池或者大电容，这样是为了保证系统掉电的情况下，我们的时钟还会继续走。如果使用的是充电电池，还可以在正常工作时，设置充电功能，给我们的备用电池进行充电。

  DS1302的特点第二条“拥有31字节数据存储RAM”，这是DS1302额外存在的资源。这31字节的RAM相当于一个存储器一样，我们编写单片机程序的时候，可以把我们想存储的数据存储在DS1302里边，需要的时候读出来，这块功能和EEPROM有点类似，相当于一个掉电丢失数据的“EEPROM”，如果我们的时钟电路加上备用电池，那么这31个字节的RAM就可以替代EEPROM的功能了。

  DS1302一共有8个引脚，下边要根据引脚分布图和典型电路图来介绍一下每个引脚的功能：

DS1302的8个引脚

  DS1302的电路一个重点就是时钟电路，它所使用的晶振是一个32.768k的晶振，晶振外部也不需要额外添加其他的电容或者电阻电路了。时钟的精度，首先取决于晶振的精度以及晶振的引脚负载电容。如果晶振不准或者负载电容过大过小，都会导致时钟误差过大。在这一切都搞定后，最终一个考虑因素是晶振的温漂。随着温度的变化，晶振往往精度会发生变化，因此，在实际的系统中，其中一种方法就是经常校对。比如我们所用的电脑的时钟，通常我们会设置一个选项“将计算机设置于internet时间同步”。选中这个选项后，一般可以过一段时间，我们的计算机就会和internet时间校准同步一次。

2. DS1302寄存器

  对DS1302的操作就是对其内部寄存器的操作，DS1302内部共有12个寄存器，其中有7个寄存器与日历、时钟相关，存放的数据位为BCD码形式。此外，DS1302还有年份寄存器、控制寄存器、充电寄存器、时钟突发寄存器及与RAM相关的寄存器等。时钟突发寄存器可一次性顺序读/写除充电寄存器以外的寄存器。

  DS1302的一条指令一个字节8位，其中第7位(即最高位)是固定1，这一位如果是0的话，那写进去是无效的。第6位是选择RAM还是CLOCK的，这里主要讲CLOCK时钟的使用，它的RAM功能我们不用，所以如果选择CLOCK功能，第6位是0，如果要用RAM，那第6位就是1。从第5到第1位，决定了寄存器的5位地址，而第0位是读写位，如果要写，这一位就是0，如果要读，这一位就是1。

DS1302的地址指令格式

  DS1302时钟的寄存器，其中8个和时钟有关的，5位地址分别是00000一直到00111这8个地址，还有一个寄存器的地址是01000，这是涓流充电所用的寄存器，我们这里不讲。在DS1302的数据手册里的地址，直接把第7位、第6位和第0位值给出来了，所以指令就成了80H、81H那些了，最低位是1，那么表示读，最低位是0表示写。

DS1302寄存器的存储格式

  寄存器一：最高位CH是一个时钟停止标志位。如果我们的时钟电路有备用电源部分，上电后，我们要先检测一下这一位，如果这一位是0，那说明我们的时钟在系统掉电后，由于备用电源的供给，时钟是持续正常运行的；如果这一位是1，那么说明我们的时钟在系统掉电后，时钟部分不工作了。若我们的Vcc1悬空或者是电池没电了，当我们下次重新上电时，读取这一位，那这一位就是1，我们可以通过这一位判断时钟在单片机系统掉电后是否持续运行。剩下的7位高3位是秒的十位，低4位是秒的个位，这里注意再提一次，DS1302内部是BCD码，而秒的十位最大是5，所以3个二进制位就够了。
  寄存器二：bit7没意义，剩下的7位高3位是分钟的十位，低4位是分钟的个位。
  寄存器三：bit7是1的话代表是12小时制，是0的话代表是24小时制，bit6固定是0，bit5在12小时制下0代表的是上午，1代表的是下午，在24小时制下和bit4一起代表了小时的十位，低4位代表的是小时的个位。
  寄存器四：高2位固定是0，bit5和bit4是日期的十位，低4位是日期的个位。
  寄存器五：高3位固定是0，bit4是月的十位，低4位是月的个位。
  寄存器六：高5位固定是0，低3位代表了星期。
  寄存器七：高4位代表了年的十位，低4位代表了年的个位。这里特别注意，这里的00到99年指的是2000年到2099年。
  寄存器八：bit7是一个保护位，如果这一位是1，那么是禁止给任何其他的寄存器或者那31个字节的RAM写数据的。因此在写数据之前，这一位必须先写成0。

3. DS1302的时序

   物理上，DS1302的通信接口由3个口线组成，即RST，SCLK，I/O。其中RST从低电平变成高电平启动一次数据传输过程，SCLK是时钟线，I/O是数据线。这个DS1302的通信线定义和SPI很像，事实上，DS1302的通信是SPI的变异种类，它用了SPI的通信时序，但是通信的时候没有完全按照SPI的规则来，下面我们介绍DS1302的变异SPI通信方式。

单字节读和单字节写时序

  请注意数据是对时钟信号敏感的，而且一般数据是在下降沿写入，上升沿读出。平时SCLK保持低电平，当需要写命令或者写数据时，在时钟输出变为高电平之前先输出数据；当需要读数据时，在时钟输出变为高电平之前采样读取数据。

四、实验步骤

  第1步：连接电路。

树莓派	T型转接板	BMP180气压传感器
GPIO4	G23	SCL（CLK）
GPIO5	G24	SDA（DAT）
GPIO6	G25	RST
5V	5V	VCC
GND	GND	GND

DS1302实验电路图 DS1302实验实物接线图

  第2步：DS1302的Python程序比较复杂，我们先编写一个模块ds1302.py，在里面创建一个类DS1302()，在里面编写读取时钟信息等方法。

'''
RTC_DS1302                                                              
'''
'''
------------------------------------------------------------------------
'''
'''
控制处理实时时钟DS1302的类。               
'''

import time
import RPi.GPIO
from datetime import datetime


class DS1302:

    CLK_PERIOD = 0.00001

    DOW = [ "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday" ]


    def __init__(self, scl=23, rst=25, io=24):
        self.scl = scl
        self.rst = rst
        self.io = io
        # 关闭GPIO警告。
        RPi.GPIO.setwarnings(False)
        # 配置树莓派GPIO接口。
        RPi.GPIO.setmode(RPi.GPIO.BCM)
        # 初始化 DS1302 通信。
        self.init_ds1302()
        # 确保写保护已关闭。
        self.write_byte(int("10001110", 2))
        self.write_byte(int("00000000", 2))
        # 确保涓流充电模式被关闭。
        self.write_byte(int("10010000", 2))
        self.write_byte(int("00000000", 2))
        # 结束 DS1302 通信。
        self.end_ds1302()
        self.datetime = {}

    def CloseGPIO(self):
        '''
        在结束前关闭 Raspberry Pi GPIO 。
        '''
        RPi.GPIO.cleanup()


    def init_ds1302(self):
        '''
        使用DS1302 RTC启动一个事务。
        '''
        RPi.GPIO.setup(self.scl, RPi.GPIO.OUT, initial=0)
        RPi.GPIO.setup(self.rst, RPi.GPIO.OUT, initial=0)
        RPi.GPIO.setup(self.io, RPi.GPIO.OUT, initial=0)
        RPi.GPIO.output(self.scl, 0)
        RPi.GPIO.output(self.io, 0)
        time.sleep(self.CLK_PERIOD)
        RPi.GPIO.output(self.rst, 1)


    def end_ds1302(self):
        '''
        使用DS1302 RTC结束一个事务。
        '''
        RPi.GPIO.setup(self.scl, RPi.GPIO.OUT, initial=0)
        RPi.GPIO.setup(self.rst, RPi.GPIO.OUT, initial=0)
        RPi.GPIO.setup(self.io, RPi.GPIO.OUT, initial=0)
        RPi.GPIO.output(self.scl, 0)
        RPi.GPIO.output(self.io, 0)
        time.sleep(self.CLK_PERIOD)
        RPi.GPIO.output(self.rst, 0)


    def write_byte(self, Byte):
        '''
        将一个字节的数据写入DS1302 RTC。
        '''
        for Count in range(8):
            time.sleep(self.CLK_PERIOD)
            RPi.GPIO.output(self.scl, 0)

            Bit = Byte % 2
            Byte = int(Byte / 2)
            time.sleep(self.CLK_PERIOD)
            RPi.GPIO.output(self.io, Bit)

            time.sleep(self.CLK_PERIOD)
            RPi.GPIO.output(self.scl, 1)
        
    def read_byte(self):
        '''
        将一个字节的数据读入DS1302 RTC。
        '''
        RPi.GPIO.setup(self.io, RPi.GPIO.IN, pull_up_down=RPi.GPIO.PUD_DOWN)

        Byte = 0
        for Count in range(8):
            time.sleep(self.CLK_PERIOD)
            RPi.GPIO.output(self.scl, 1)

            time.sleep(self.CLK_PERIOD)
            RPi.GPIO.output(self.scl, 0)
            
            time.sleep(self.CLK_PERIOD)
            Bit = RPi.GPIO.input(self.io)
            Byte |= ((2 ** Count) * Bit)

        return Byte


    def write_ram(self, Data):
        '''
        向RTC RAM写一条消息。
        '''
        # Initiate DS1302 communication.
        self.init_ds1302()
        # Write address byte.
        self.write_byte(int("11111110", 2))
        # Write data bytes.
        for Count in range(len(Data)):
            self.write_byte(ord(Data[Count:Count + 1]))
        for Count in range(31 - len(Data)):
            self.write_byte(ord(" "))
        # End DS1302 communication.
        self.end_ds1302()

    def read_ram(self):
        '''
        向RTC RAM读一条消息。
        '''
        # Initiate DS1302 communication.
        self.init_ds1302()
        # Write address byte.
        self.write_byte(int("11111111", 2))
        # Read data bytes.
        Data = ""
        for Count in range(31):
            Byte = self.read_byte()
            Data += chr(Byte)
        # End DS1302 communication.
        self.end_ds1302()
        return Data


    def set_datetime(self, year, month, day,  hour, minute, second, dayOfWeek=0):
        '''
        写日期和时间给RTC，这里我放弃了星期几的设置，传递的默认值。
        '''
        if not self.check_sanity():
            return False
        # Initiate DS1302 communication.
        self.init_ds1302()
        # Write address byte.
        self.write_byte(int("10111110", 2))
        # Write seconds data.
        self.write_byte((second % 10) | int(second / 10) * 16)
        # Write minute data.
        self.write_byte((minute % 10) | int(minute / 10) * 16)
        # Write hour data.
        self.write_byte((hour % 10) | int(hour / 10) * 16)
        # Write day data.
        self.write_byte((day % 10) | int(day / 10) * 16)
        # Write month data.
        self.write_byte((month % 10) | int(month / 10) * 16)
        # Write day of week data.
        self.write_byte((dayOfWeek % 10) | int(dayOfWeek / 10) * 16)
        # Write year data.
        self.write_byte((year % 100 % 10) | int(year % 100 / 10) * 16)
        # Make sure write protect is turned off.
        self.write_byte(int("00000000", 2))
        # Make sure trickle charge mode is turned off.
        self.write_byte(int("00000000", 2))
        # End DS1302 communication.
        self.end_ds1302()


    def get_datetime(self):
        '''
        从RTC中读取日期和时间。
        '''
        # Initiate DS1302 communication.
        self.init_ds1302()
        # Write address byte.
        self.write_byte(int("10111111", 2))
        # Read date and time data.
        Data = ""

        Byte = self.read_byte()
        second = (Byte % 16) + int(Byte / 16) * 10
        Byte = self.read_byte()
        minute = (Byte % 16) + int(Byte / 16) * 10
        Byte = self.read_byte()
        hour = (Byte % 16) + int(Byte / 16) * 10
        Byte = self.read_byte()
        day = (Byte % 16) + int(Byte / 16) * 10
        Byte = self.read_byte()
        month = (Byte % 16) + int(Byte / 16) * 10
        Byte = self.read_byte()
        day_of_week = ((Byte % 16) + int(Byte / 16) * 10) - 1
        Byte = self.read_byte()
        year = (Byte % 16) + int(Byte / 16) * 10 + 2000

        # End DS1302 communication.
        self.end_ds1302()
        return datetime(year, month, day, hour, minute, second)

    def check_sanity(self):
        "检查时钟是否正常。如果时钟正常则返回True，否则返回False"
        dt = self.get_datetime()
        if dt.year == 2000 or dt.month == 0 or dt.day == 0:
            return False
        if dt.second == 80:
            return False
        return True

def format_time(dt):
    if dt is None:
        return ""
    fmt = "%m/%d/%Y %H:%M"
    return dt.strftime(fmt)
    
def parse_time(s):
    fmt = "%m/%d/%Y %H:%M"
    return datetime.strptime(s, fmt)

  第3步：编写实际控制程序，导入上面的模块ds1302。运行本文件，不断循环读取并打印时钟信息。

#!/usr/bin/env python
from datetime import datetime
import time

import ds1302 #导入模块ds1302

rtc = ds1302.DS1302()   #通过模块ds1302中的类DS1302()创建一个实例rtc

def setup():
    ''' 写入初始时间 '''
    print ''
    print ''
    print rtc.get_datetime()
    print ''
    print ''
    a = raw_input( "Do you want to setup date and time?(y/n) ")
    if a == 'y' or a == 'Y':
        date = raw_input("Input date:(YYYY MM DD) ")
        time = raw_input("Input time:(HH MM SS) ")
        date = date.split()
        time = time.split()
        print ''
        print ''
                
        rtc.set_datetime(int(date[0]),int(date[1]), int(date[2]),\
                         int(time[0]), int(time[1]), int(time[2]))

        
        dt = rtc.get_datetime()
        print "You set the date and time to:", dt

def loop():
    ''' 显示实时时间 '''
    while True:
        a = rtc.get_datetime()
        print a
        time.sleep(1)

def destory():
    GPIO.cleanup()              # Release resource

if __name__ == '__main__':      # Program start from here
    setup()
    try:
        loop()
    except KeyboardInterrupt:   
        destory()

  实验结果示例：

实验结果