之前用51驱动过DS1302，没用多久就输出了正确的时间。当时以为这块芯片其实没啥，很简单。但是现在用STM32做项目，用到同样的芯片，以为这有何难，只要把那个程序拿过来复制黏贴改一下IO设置不就行了？但是事情远没有想想的那么简单。               

经过3天的挣扎，现在才知道当时自己是多么天真。

好了，废话少说了，进入正题。

首先DS1302读写方式属于3线SPI。CE、SCK、IO。其中IO口属于双向IO口，我们读写都要经过这个IO口。在用51开发的时候，因外他是准双向IO，不需要我们额外关心他的输入输出设置。需要输出的时候直接写            P0^1 = 1;   

需要检测外部输入的时候直接写       if(P0^1 == 1)   ,

都很方便，但是方便的同时带来的是读写速度上的限制。那么在STM32中，每个IO口都有8种输出模式。复杂的同时也意味着每一种模式都是专门定制的，带来了速度上的优势。所以在移植这个程序的时候，就需要注意这个双向IO的设置问题。一开始我也不是很懂，各种百度查资料，各种问人。最后才知道有两种方式可以实现双向的IO读写设置。

第一：

1. #define DS1302_DATIN        PBin(6)  
   ( v8 Q0 D+ o" u4 P  J
2. #define DS1302_DATOUT       PBout(6)
   
3. 
   
4. #define DS1302_DAT_INPUT()     {GPIOB->CRL&= 0XF0FFFFFF;GPIOB->CRL|= 8<<24;}  //设置成上拉或者下拉输入模式,需要外接上拉电阻
   # K+ Y+ M. l) M' @4 O
5. #define DS1302_DAT_OUTPUT()    {GPIOB->CRL&= 0XF0FFFFFF;GPIOB->CRL|= 3<<24;}  //设置成最大50M的通用推挽输出

复制代码

% u7 D! W9 f) ~# Q/ S- ^/ S# X

通过简单的寄存器操作，可以实现输入输出的快速切换。需要在端口处接上拉电阻。

第二：

1. GPIO_InitTypeDef GPIO_InitStruct;  
   " o! }, _+ v4 g* |7 \  J$ F
2.    
   9 T# v% F, ~+ A4 l6 i# l0 [( N$ w
3.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);  
   : \3 L6 _. @. l% r: J* Q
4. 
   " r# w! j* Q8 q3 l
5.     GPIO_InitStruct.GPIO_Pin = DS1302_IO_PIN;         //这里最好设成开漏，当然也可以普通推挽，但是需要后面一直切换输入输出模式
   
6.     GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_OD;     //开漏输出，需要接上拉，不需要切换输入输出了。
   ( T  R+ H+ P8 l7 A2 y' E$ t
7.     GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;    //输出速度50MHz  
   9 K6 t4 o/ w% ~( O( |; r% [
8.     GPIO_Init(DS1302_PORT, &GPIO_InitStruct);

复制代码

$ t* K: G; Y5 ]1 V1 r  [

把IO配置成开漏输出模式。必须外接上拉电阻，不然读出的全是低电平。这样就不用一直切换输入输出模式，可以直接像51那样，直接使用。

双向IO的配置基本上就是上面所说的两种情况，但是可能还有其他方式，但是我目前就只知道这个方式，后面学习了在补充。

配置完IO之后就开始对IO进行操作，从而读写DS1302，获取实时时间。读写的时候特别需要注意。网上很多教程都没有提到这一点，估计是太基础了吧。但是这个小小的问题却困扰了我很长时间。就是在进行对DS1302的写命令和数据的操作的时候，我们需要按照从低位到高位依次发送数据。发送数据的时候：

在51里面我们经常会这样写：{    SCIO = byte_1 & 0x01;　　byte_1 >> = 1;    }

那么在32中我们可以这样写吗？：   {    PBout(6) =  byte_1 & 0x01;　　byte_1 >> = 1;    }

绝对不行。虽然看上去没有什么问题，也不会报错，但是却就是不同正确通信。很气人。

原因是PBout(6)这样的操作是属于STM32的位带操作。但是在CM3中不允许位带操作赋值除0和1以外的数。

也就是说上面那种操作方式是给  PBout(6) 赋值2,3,4，之类的数，但是stm32却不能理解这是什么意思。因为它只认识0和1！！！

所以我们可以简单的这样处理：

1. if((byte_1 & t) != 0)     //之前的问题出在这里，32的位带操作不能赋值0和1之外的值。
   
2.         {
   
3.             DS1302_DATOUT = 1;
   
4.         }
   / q8 t- u" W( a- V( q
5.         else
   $ j/ `; [9 `/ T( ]+ D9 j
6.         {
   
7.             DS1302_DATOUT = 0;
   / Y) y9 d' I& C' P
8.         }

复制代码

; I/ F6 h. {0 T* F6 o# F: H% _

这样就可以正常通信了。但是如果不能像上面那样处理的话，现象是一直读出85这个数。关于读出85这个数，除了上面我提到的这种特殊情况，网上还是有很多人有这方面的经验的，我总结了一下，大致是下面这几种情况：

1、读取完时间后没有把DATA_IO引脚拉低。导致显示问号和85等一些乱七八糟的东西。但是我加了。
2、电压不够，小于4.6V。但是这个网上有争议，我接的是5V，实测4.8V，应该没问题。
+ r' t) @' r! h# v3、没有接上拉电阻。我只在需要双向IO的地方加了上拉电阻，利用的是板子上预留的IIC的SDA，上面有一个4.7K的上拉，我把IO接在了这里。应该也没问题
4、仿真时序不对。但是我之前用这个时序在51上面实现过一样的功能，现在移植到32上应该也没什么问题啊，延时时间也仿真了，严格按照1us的延时仿真的。

但是在我的实验过程中还是发现了很多其他的现象，再次也记录下来，防止有人遇到相同的问题，就能不浪费那么多时间。

1、确实要注意DS1302的电压，最好不要用STM32开发板上面的3.3V，反正我是没做出来。如果用外部电源给DS1302供电的话，需要将外部电源和开发板共地，不然读出全是85.

2、DS1302如果需要修改时间。需要把初始化函数里面的上电保护去掉，再次下载重置的时间，然后再把上电保护那段给添加上去，防止复位后时间被重置。

目前我的问题就是这么多。在一一解决了上述问题之后，就能准确的读取时间了，实测一天24H误差不超过2s，还是很准的了。

好了，下面就是源程序了。

首先是DS1302的头文件，主要是一些位带操作和预定义

1. #ifndef __DS1302_H
   . ^* ?) H3 p6 C* j! t8 a
2. #define __DS1302_H
   
3. 
   
4. #include <stm32f10x.h>
   
5. #include "hardware.h"
   
6. 
   
7. //相对应的IO口配置
   
8. #define DS1302_PORT         GPIOB
   
9. 
   
10. #define DS1302_SCK_PIN         GPIO_Pin_7        //时钟
    ) l) y) m+ Q6 w( i7 x
11. #define DS1302_IO_PIN         GPIO_Pin_6    //双向IO口，
    
12. #define DS1302_CE_PIN         GPIO_Pin_5   //片选使能，当需要读写的时候，置高位
    
13. 
    ' l  h- y7 w/ @- u+ N& T+ a
14. #define DS1302_SCK          PBout(7)  //位带操作，可直接给高低电平，但是切记不能给0.1之外的数。切记
    
15. #define DS1302_CE           PBout(5)
    
16. #define DS1302_DATIN        PBin(6)  
    
17. #define DS1302_DATOUT       PBout(6)
    $ v. \  Z+ A7 j+ c) J# o' Q$ E; M
18. //存放时间
    
19. typedef struct _time{
    
20. 
    $ ?7 i0 R/ {5 w. g% V, o' Z3 y. {
21.     u8 second;
    0 q% j: G5 f- Z' Z& Y
22.     u8 minute;
    
23.     u8 hour;
    $ H: U- l  _) H4 B& s& B! w
24.     u8 date;
    ) t4 e5 a4 F  y/ e/ h. G5 w! E
25.     u8 month;
    6 `0 S% W9 q' l7 Q3 c9 Q- L
26.     u8 week;
    6 b, y) q. p  \! _. w
27.     u8 year;
    / c1 D" s4 _4 v& O( L9 L
28. 
    9 }) a* J: W" W/ c2 b
29. }my_time;
    
30. void DS1302_Init(void);
    - R; }- g4 w8 N1 P0 Q
31. void ds1302_readtime(void);
      U' r3 K* z* `0 K' i/ h
32. void display_real_time(void);  //显示实时时间
    ) x' A3 K6 u% l0 I4 L
33. 
    # o! h, B; q3 o( b, j8 X
34. #endif

复制代码

DS1302操作源文件：

1. #include "ds1302.h"
   
2. #include "spi.h"
   % {. z8 s3 N/ J. ^" k4 @
3. 
   
4. //READ_RTC_ADDR[7] = {0x81, 0x83, 0x85, 0x87, 0x89, 0x8b, 0x8d};//读取时间的命令地址，已经通过读写操作来直接实现这些地址
   
5. //WRITE_RTC_ADDR[7] = {0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c};//写时间的命令地址
   ; W* A7 f; q5 c% j
6. 
   6 N  f$ E/ T& r, `% O5 V
7. my_time TIME = {0};  //显示时间的结构体
   % N: x+ W$ d- ]2 T; x* L
8. u8 init_time[] = {0x00,0x28,0x21,0x27,0x12,0x06,0x17}; //初始化时间：秒 分 时 日 月 周 年
   
9. 
   
10. 
    0 j8 k; R+ A1 i* d
11. static void ds1302_gpio_init(void);
    $ p0 L! f' ?" z5 D  a, Z3 T$ I- m7 {
12. static void ds1302_writebyte(u8 byte_1);//写一个字节; byte是保留字，不能作为变量
    
13. static void ds1302_writedata(u8 addr,u8 data_);//给某地址写数据,data是c51内部的关键字，表示将变量定义在数据存储区，故此处用data_;
    . j2 A0 |# E2 f3 W6 T/ y( @  m/ ^
14. static u8 ds1302_readbyte(void);//读一个字节
    ( y+ X, s; D: Z& R& Z) a  d
15. static u8 ds1302_readdata(u8 addr);//读取某寄存器数据;
    
16. static void DS1302_delay_us(u16 time);  //简单延时1us
    
17. 
    # l5 Q6 F1 u. j; p) }
18. 
    3 K1 i" V! z( W
19. //基本IO设置
    ; F2 P' O  g7 U9 N4 k
20. static void ds1302_gpio_init(void)
    7 b, I" B, }: y; D* v- E
21. {
    
22.     GPIO_InitTypeDef GPIO_InitStruct;  
    8 z* ?" T" s; d
23.    
    
24.     //开启GPIOD的时钟  
    6 f% E( D  h# [1 p
25.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);  
      z& s$ j- p  X  e" d3 i2 F) M. }: w
26.    
    ! _" ^; ?/ t* @) |- q! g( z
27.     //设置GPIO的基本参数  
    + [; c/ t* [3 Q7 H" f
28.     GPIO_InitStruct.GPIO_Pin = DS1302_SCK_PIN | DS1302_CE_PIN ;  
    # Y0 _. X  U) N  A/ k. |
29.     GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;    //这两个普通端口设为推挽输出  
    0 E! S& v% x1 O& B1 T; Q
30.     GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;    //输出速度50MHz  
    
31.     GPIO_Init(DS1302_PORT, &GPIO_InitStruct);  
    
32. 
    
33.     GPIO_InitStruct.GPIO_Pin = DS1302_IO_PIN;         //这里最好设成开漏，当然也可以普通推挽，但是需要后面一直切换输入输出模式
    
34.     GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_OD;     //开漏输出，需要接上拉，不需要切换输入输出了。
    0 \9 ~. f* m" J; Z2 K5 Y
35.     GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;    //输出速度50MHz  
    
36.     GPIO_Init(DS1302_PORT, &GPIO_InitStruct);
    
37. 
    0 J  C' [: }+ t
38. }
    
39. 
    
40. //写一个字节
    " e7 Z" Y8 p9 d# x4 B
41. //数据和地址都是从最低位开始传输的
    
42. static void ds1302_writebyte(u8 byte_1)
    
43. {
    7 l' {  ^* G, w* E' b8 ~4 m' V
44.     u8 i = 0;
    ! O6 `. v8 t) b6 S- p
45.     u8 t = 0x01;
    5 ^5 `$ |$ C- o" d
46.    
    
47.     for(i = 0;i<8;i++)
    3 `! J5 W0 [. P& `
48.     {
    
49.         if((byte_1 & t) != 0)     //之前的问题出在这里，32的位带操作不能赋值0和1之外的值。
    
50.         {
    
51.             DS1302_DATOUT = 1;
    3 Z# ?5 }/ W6 k) T3 R' c
52.         }
    
53.         else
    4 I5 X7 z6 b7 m1 T
54.         {
    % d; U( k9 i+ U$ O  V8 E
55.             DS1302_DATOUT = 0;
    + c: b: M( c  O5 W# r( f
56.         }
    
57.         
    
58.         DS1302_delay_us(2);
    
59.         DS1302_SCK = 1;  //上升沿写入
    
60.         DS1302_delay_us(2);
    ) e( G# b! h# ^
61.         DS1302_SCK = 0;
    * A: W) |8 `8 x
62.         DS1302_delay_us(2);
    5 ^& v- ^& D5 A2 l
63.         
    
64.         t<<= 1;
    
65.     }
    
66.     DS1302_DATOUT = 1;      //释放IO，后面读取的话会准确很多
    
67.     DS1302_delay_us(2);     //因为如果写完之后IO被置了低电平，开漏输出模式下读取的时候会有影响，最好先拉高，再读取
    2 {6 m: u: q" V/ d! Y/ Z8 K
68. }
    ) v) Z$ F/ R8 B1 P
69. 
    
70. //地址写数据
    * N& `. d, m( M0 C7 q) o
71. static void ds1302_writedata(u8 addr,u8 data_)
    
72. {   
    
73.     DS1302_CE = 0;        DS1302_delay_us(2);   
    
74.     DS1302_SCK = 0;        DS1302_delay_us(2);   
    0 e6 r8 y5 m( e3 C% n
75.     DS1302_CE = 1;        DS1302_delay_us(2);    //使能片选信号
    
76.    
    # w" ?1 x: Y( p9 o% g3 a
77.     ds1302_writebyte((addr<<1)|0x80);    //方便后面写入,转化之后是地址寄存器的值，
    & ?& a( ]3 I. K% ?5 k2 l
78.     ds1302_writebyte(data_);
    8 y6 X1 |" k9 f, S5 A$ m
79.     DS1302_CE = 0;        DS1302_delay_us(2);//传送数据结束，失能片选
    
80.     DS1302_SCK = 0;     DS1302_delay_us(2);//拉低，准备下一次写数据
    
81. }
    6 Y$ k7 N" e# {& n  Q: P+ K
82. 
    7 I4 X0 U& @3 s5 o) a' o
83. //读取一个字节,上升沿读取
    
84. static u8 ds1302_readbyte(void)
    
85. {
    
86.     u8 i = 0;
    1 O! R% m+ u' {# x# G  A
87.     u8 data_ = 0;
    
88.    
    
89. //因为上面已经把端口设置为开漏，电路外部接了山拉电阻，可以不切换输入输出模式，直接使用。
    
90.     //    DS1302_DAT_INPUT();  
    ; P1 N" J2 f0 g) W: k' [: M: D
91.    
    1 r: h9 C( M: b) K" k8 W2 `
92.     DS1302_SCK = 0;
    ! Q' K( o! y0 w' p2 v' @
93.     DS1302_delay_us(3);
    
94.     for(i=0;i<7;i++)   //这里发现设为8的话输出数据不对，很乱
    7 b/ t3 L: b9 k. C1 I. O3 ]
95.     {
    
96.         if((DS1302_DATIN) == 1)
    " k) y: w& J# w2 ?& d" U) s( ^
97.         {
    
98.             data_ = data_ | 0x80;    //低位在前，逐位读取,刚开始不对，估计是这个的问题
    
99.         }
    - u* c2 Z9 L0 R* y
100.         data_>>= 1;
     
101.         DS1302_delay_us(3);
     
102.         
     $ |! j3 B8 Y/ s5 j5 \1 k/ h
103.         DS1302_SCK = 1;
       y, a9 G( w2 C% m# O6 E& U
104.         DS1302_delay_us(3);
     7 `" ^9 b; X2 v0 M3 w# N5 o
105.         DS1302_SCK = 0;
     8 [; I3 b" ^8 \
106.         DS1302_delay_us(3);
     
107.     }
     
108.      return (data_);
     : t5 `) C- r! C
109. }
     ) v9 P, B8 Q; e
110. 
     
111. //读取寄存器的值
     
112. static u8 ds1302_readdata(u8 addr)
     
113. {
     
114.     u8 data_ = 0;
     
115. 
     & v; S3 G7 t  ]" x- @
116.     DS1302_CE = 0;        DS1302_delay_us(2);
     8 J0 ?- f0 t: ~# b' O
117.     DS1302_SCK = 0;        DS1302_delay_us(2);
     " L8 y. {- ?  s: }0 w% Y! Q9 ~
118.     DS1302_CE = 1;        DS1302_delay_us(2);   //读写操作时CE必须为高，切在SCK为低时改变
     
119.    
     
120.     ds1302_writebyte((addr<<1)|0x81);   //写入读时间的命令
     1 b  ]# {8 z. u" K1 L$ i
121.     data_ = ds1302_readbyte();
     
122.    
     . g# Y) \* `5 _( s; Z
123.     DS1302_SCK = 1;      DS1302_delay_us(2);
     6 W1 S2 O0 n9 O3 h; d
124.     DS1302_CE = 0;        DS1302_delay_us(2);
     
125.     DS1302_DATOUT = 0;  DS1302_delay_us(3);  //这里很多人说需要拉低，但是我发现去掉这个也可以显示啊，不过为了保险，还是加上。
     
126.     DS1302_DATOUT = 1;  DS1302_delay_us(2);
     7 |' ~& S5 l& {9 p3 I; Y
127. 
     
128.     return data_;
     8 U( E0 B/ g+ {  O0 ]$ ?: T/ `2 c
129. }
     / V6 b. H$ T& X2 ~
130. 
     
131. void DS1302_Init(void)
     9 Q9 d1 o. t- S2 ~/ x$ l
132. {
     5 c  w% h" J# O" g0 F$ A
133.      u8 i = 0;
     
134.    
     
135.     ds1302_gpio_init();  //端口初始化
     
136.    
     
137.     DS1302_CE = 0;  DS1302_delay_us(2);
     
138.     DS1302_SCK = 0; DS1302_delay_us(2);  
     ) x. v6 _& S  R% i- n
139.    
     
140.     i  = ds1302_readdata(0x00);  //读取秒寄存器,
     
141. 
     ( q  P+ C: U8 I0 G
142.      if((i & 0x80) != 0)//通过判断秒寄存器是否还有数据来决定下次上电的时候是否初始化时间，就是掉电保护
     
143.     {
     " K$ x8 g2 A4 b' Z6 i. L+ V4 `; j
144.          ds1302_writedata(7,0x00); //撤销写保护，允许写入数据,0x8e,0x00
     
145. 
     
146.         for(i = 0;i<7;i++)
     
147.         {
     
148.             ds1302_writedata(i,init_time[i]);
     
149.         }
     , X3 h+ @4 j/ ], T4 C
150.     }
     
151.          ds1302_writedata(7,0x80);//打开写保护功能，防止干扰造成的数据写入。
     6 Z8 x/ n6 `; Y$ p& Q
152. }
     0 j2 Z; P1 J1 Z( F! I. b
153. 
     # S: |1 H. M4 @- o) z
154. //************
     / M  F7 I, ~" s: X- n8 F$ z" p
155. void ds1302_readtime(void)   //读取时间
     . e9 Y. u6 b' e) J
156. {
     
157.       u8 i;
     1 W- a" Q! r" N- a
158.       for(i = 0;i<7;i++)
     
159.       {
     $ t: q/ A* W7 V# [! M; A
160.          init_time[i] = ds1302_readdata(i);
     
161.       }
     " R4 i4 W/ t+ z5 E: [" t
162. }
     , p( n" \( d0 w9 X6 K5 s
163. 
     
164. static void DS1302_delay_us(u16 time)
     , _; j# n4 z- X3 `$ b
165. {   
     : I9 Z: T4 D- Q( m, B; d! ~
166.    u16 i = 0;  
     $ k' j9 J; T" H3 P  u( G
167.    while(time--)
     ' K! t) F' s/ p+ m& n  n
168.    {
     
169.       i = 5;  //自己定义
     
170.       while(i--);
     + }5 ^8 P' a7 ]3 ?$ l& j
171.    }
     9 c& h/ p1 `2 c, p9 r' N3 g9 f
172. }
     
173. 
     / i! y- Y7 X. \% K7 o
174. //显示实时时间
     
175. void display_real_time(void)
     
176. {
     7 W2 _7 z; ]) U' D3 H
177.    
     
178.     ds1302_readtime();   //先获取时间到缓冲区
     
179.    
     
180.     //BCD码转换ASCII码
     2 J* R% ^3 l% f! ~, D! D& l& X
181.     TIME.year =  ((init_time[6]&0x70)>>4)*10 + (init_time[6]&0x0f); //高三位加低四位
     ' \  l. @2 Z1 ]) g% c
182.     TIME.month = ((init_time[4]&0x70)>>4)*10 + (init_time[4]&0x0f);
     $ @3 Y3 K# X; ?3 Y* d+ M
183.     TIME.date =  ((init_time[3]&0x70)>>4)*10 + (init_time[3]&0x0f);
     
184.     TIME.week =  ((init_time[5]&0x70)>>4)*10 + (init_time[5]&0x0f);
     
185.     TIME.hour =  ((init_time[2]&0x70)>>4)*10 + (init_time[2]&0x0f);
     
186.     TIME.minute = ((init_time[1]&0x70)>>4)*10 + (init_time[1]&0x0f);
     
187.     TIME.second = ((init_time[0]&0x70)>>4)*10 + (init_time[0]&0x0f);
     - o% a6 d( v" w$ \7 O- B5 b
188.       
     & E9 n6 V; C! H% o& a- m: X5 i
189.     OLED_ShowNum(48,0,TIME.hour,2,16);
     
190.    
     
191.     OLED_ShowChar(64,0,':');
     
192. 
     
193.     OLED_ShowNum(72,0,TIME.minute,2,16);
     
194.    
     3 n( K! L2 q9 n$ w1 _5 u
195.     OLED_ShowChar(88,0,':');
     + V0 V' T1 p" N7 r
196.    
     ; K- k  A3 W, f* |
197.     OLED_ShowNum(96,0,TIME.second,2,16);
     ! u. o5 {1 @. p& R; L  _/ L9 ~  e7 C
198.    
     # S1 P+ Z, e1 Q( u
199. }

复制代码

$ t; |$ q/ P) K) U

在驱动DS1302的时候，我遇到的基本上就是上面这些情况了。如果还有朋友遇到其他情况，可以一起讨论。

) ?9 `* C; c5 r  J$ x$ R

9 f( b6 A2 a6 O- r! k; h