最近终于又腾出时间写写学习笔记了，其实当时写是最好的，能对出的问题更深刻，现在呜呜呜。忘差不多了。主要的问题就是 STM32不像51 不需要设置输入输出模式，直接操作IO就行，但是STM32 得设置，就是因为对这个不了解 所以卡了一两天。STM32要根据不用应用状态设置不同的模式。
& u( h8 |% Q1 v- t" Z; L
DS1302时钟模块相关介绍
基本介绍
概述
DS1302 可慢速充电实时时钟芯片包含实时时钟/日历和 31 字节的非易失性静态 RAM。它经过一个简
单的串行接口与微处理器通信。实时时钟/日历可对秒，分，时，日，周，月，和年进行计数，对于小于
31 天的月，月末的日期自动进行调整，还具有闰年校正的功能。时钟可以采用 24 小时格式或带 AM（上
午）/PM（下午）的 12 小时格式。31 字节的== RAM== 可以用来临时保存一些重要数据。使用同步串行通信，
* q* i0 j) p% X简化了 DS1302 与微处理器的通信。与时钟/RAM 通信仅需3 根线：（1）RST（复位），（2）I/O（数据线）
% {) _- [* T' [/ A% t% T和（3）SCLK（串行时钟）。数据可以以每次一个字节的单字节形式或多达 31 字节的多字节形式传输。DS1302
  y: v+ o/ m& K$ Q! P& D/ f9 d9 _能在非常低的功耗下工作，消耗小于 1µW 的功率便能保存数据和时钟信息。

' Y. R4 n, \! U; S9 C" u7 }4 |1 y特点
/ l) b$ f+ D) q0 g: Z, p- N3 d
3 {5 J5 ~) M, E* f

各引脚功能



各引脚的功能：
( m6 c  o# Y. w, `8 t& |Vcc1:主电源；Vcc2:备份电源。 当Vcc2>Vcc1+0.2V时，由Vcc2向DS1302供电，当Vcc2<Vcc1时，由Vcc1向DS1302供电。
1 y  @+ Y; ~: PSCLK: 串行时钟，输入，控制数据的输入与输出；
  k# y; _0 |3 ~* |, LI/O: 三线接口时的双向数据线；
% }" a/ P5 b& ?) x: i$ JCE: 输入信号，在读和写的器件必须为高。该引脚有两个功能：1.开始控制字访问移位寄存器的控制逻辑；2.提供结束单字节或多字节数据传输的方法。

4 W7 _8 [+ i- f* u. X: J相关寄存器
有关日历、时间的寄存器共有12个，其中有7个寄存器（读时81H——8DH，写时80H——8CH==）存放的数据格式是BCD码形式。如图所示


* ?) `$ H8 S0 K+ b7 J小时寄存器
位7用于定义DS1302是采用12小时模式还是24小时模式。高：12小时模式。在12小时模式时，位5 为1时，表示PM。在24小时模式时，为5是第二个10小时位。
  d5 U6 R- i" O
" r9 _0 m1 x& o# F- @秒寄存器
的就位7定义为时钟暂停标志（CH）。1：时钟振荡器停止，DS1302进入低功耗状态，当该位置为0时，时钟开始运行。
8 u) t) _# b: x5 `
控制寄存器
4 Q3 s+ \7 q. T2 q6 R的位7是写保护位（WP），其他7位均置0，对时钟和RAM进行写操作时，WP必须为0，也就是关闭写保护，当WP为1时，就是只读模式。

DS1302相关的RAM地址
+ u$ n* J2 I; _' M/ h& r+ pDS1302中附加31字节静态RAM的地址如下图


( \/ X2 @7 v* R3 d3 _) P
- ^: B5 Z* v# y# SDS1302的工作模式寄存器
所谓的突发模式(BURST模式)就是一次性传送多个字节的时钟信号和RAM数据。比如我可以一次性把时间和日期写入，也可以一次性的读出时间和日期。

+ d- K& q9 d0 [) z5 e

通过对 31（十进制）位地址寻址（地址/命令位于 1 至 5=逻辑 1），可以把时钟/日历或 RAM 寄存器规定为多字节方式。如前所述，位 6 规定时钟或 RAM 而位 0 规定读或写。在时钟\日历寄存器中的地址 9 至 31或 RAM 寄存器中的地址 31 不能存储数据。在多字节方式中读或写从地址 0 的位 0 开始。当以多字节方式写时钟寄存器时，必须按数据传送的次序写最先 8 个寄存器。意思就是写我们不是只有7个吗？时分秒、年月日、周一共七个 但是吧它得字节数为8 所有要写够8次。
8 Q4 @: O1 R5 b( {+ \/ ^' Z$ f但是，当以多字节方式写 RAM 时，为了传送数据不必写所有 31 个字节。不管是否写了全部 31 个字节，所写的每一个字节都将传送至 RAM。
1 C% ^5 P! g' f+ L) e! D


2 C7 g3 r1 \4 e& f0 kDS1302充电寄存器
这个我没整过，全部复制手册的。哈哈
, n# b* W; W5 y) J- F- g# j
' L0 R# a/ e* s* S这个寄存器控制 DS1302 的慢速充电特性。图 4 的简化电路表示慢速充电器的基本组成。慢速充电选择（TCS）位（位 4-7）控制慢速充电器的选择。为了防止偶然的因素使之工作，只有 1010 模式才能使慢
3 P. B  ]+ y. d' Q( S速充电器工作，所有其它的模式将禁止慢速充电器。DS1302 上电时，慢速充电器被禁止。二极管选择（DS）位（位 2-3）选择是一个二极管还是两个二极管连接在 Vcc2 与 Vcc1 之间。如果 DS 为 01，那么选择一个二极管；如果 DS 为 10，则选择两个二极管。如果 DS 为 00 或 11，那么充电器被禁止，与 TCS 无关。RS 位（位0-1）选择连接在 Vcc2 与 Vcc1 之间的电阻。电阻选择（RS）位选择的电阻如下：
# E6 ]! t. V5 q1 D5 q. P. W
& ]3 v- z+ n7 a7 ]8 J7 |

如果 RS 为 00，充电器被禁止，与 TCS 无关。
6 t5 `' G. I; U& t; ~& B二极管和电阻的选择用户根据电池和超容量电容充电所需的最大电流决定。最大充电电流可以如下列
6 H0 c" ?  X( c0 A所说明的那样进行计算。假定 5V 系统电源加到 Vcc2 而超容量电容接至 Vcc1。再假设慢速充电器工作时在Vcc2 和 Vcc1 之间接有一个二极管和电阻 R1。因而最大电流可计算如下：
Imax =（5.0V-二极管压降）/R1
/ E  l" V/ e7 B4 ?5 V=（5.0V-0.7V）/2kΩ
= 2.2mA
显而易见，当超容量电容充电时，Vcc2 和 Vcc1 之间的电压减少，因而充电电流将会减小。

6 r+ v; Y- Y0 l3 g4 i7 W9 y5 ?时序图
我们首先得给DS1302时钟模块写入时间和日期，然后呢这个时钟会自己走，我们之后只需要读取时间和日期即可。我们直接看时序图 编写代码

1 e6 ]/ P& k! z9 ~; N' |. c

单字节写时序
数据输入
跟随在输入写命令字节的 8 个 SCLK 周期之后，在下 8 个 SCLK 周期的上升沿输入数据。如果有额外的SCLK 周期，它们将被忽略。输入从位 0 开始。

7 u5 u) O# e3 {  m9 v9 s/ U, f



上面时序图是前8位是地址，后8位是数据。
我们根据上面的时序图 来编写 单字节写的一个函数
根据上面的编写一些代码
1 b+ ?8 v" Y' G% v1 n5 d" M
% ?' X9 n- z3 s( X5 s, k1 E0 m. ?

1. /******************************************************************
   9 P) a; [: F5 Y/ l' v
2. 描述: DS1302 写一字节 函数
   
3. *******************************************************************/
   ( @- K/ e/ w8 `, g
4. void ds1302_write_byte(uint8_t addr_or_data)
   7 {' R4 [5 u9 q0 c% a1 j1 U0 ^8 x( O, F
5. {
   ; d. R) ~+ Y- _" t
6.         uint8_t i;
   ) N: Z) w$ c1 |- g
7.         DS1302_SET_OUT;                //DS1302设置成输出模式(推挽输出)
   . k2 o& {, L  L5 s  ~/ z
8.         for(i=0;i<8;i++)
   
9.         {
   % j6 f* Z& \  A1 Y; R8 B' P
10.                 if(addr_or_data & 0x01)                //从低位开始传输
    , l- w1 i5 w; }3 M1 c
11.                 {
    + V2 v! a, v) u7 F, ~# y* [  {
12.                         DS1302_DAT_HIGH;                //DAT引脚拉高电平
    3 T8 R' L  o, |2 d" i5 k! K6 f' O
13.                 }
      Y+ O9 I0 F! W/ G+ @% }
14.                 else
    " i: f- l. }0 x
15.                 {
    
16.                         DS1302_DAT_LOW;                        //DAT引脚拉低电平
    ) |  g0 W0 u! j+ M3 [
17.                 }
    7 d; h1 Q- c9 W/ `
18.                 addr_or_data >>= 1;                //右移一位 为下一位写做准备
    
19.                 DS1302_CLK_HIGH;                //拉高时钟表示已经发送 让对方读
    
20.                 DS1302_CLK_LOW;                        //拉低时钟准备继续放新的数据位
    5 c4 d8 M' I( v: q/ j5 }; @0 b
21.         }
    0 y- |5 ]" `: M- y6 ~( V
22. }
    5 v$ B/ ?; Q: K! M% C: j; ^
23. 
    
24. /******************************************************************
    & `8 P8 l! M/ g/ n. V( Y
25. 描述: DS1302 写命令 函数
    + L! S( d7 _1 u2 N. J+ H, {
26. *******************************************************************/
    & a- T# y! g7 Z
27. void ds1302_write_cmd(uint8_t addr,uint8_t dat)
    # ^$ b- {9 T! `# V
28. {
    * M' E! d1 f  s6 C5 K/ s: Q" \( }
29.         DS1302_RST_LOW;                //RST拉低
    " U' `7 T( }4 b$ l5 x
30.         DS1302_CLK_LOW;                //时钟SCLK也拉低
    # H0 r% o; {, x
31.         DS1302_RST_HIGH;        //准备开始写
    
32.         ds1302_write_byte(addr);        //写入要写的地址
    ( a" d" H/ ~. }- G7 y/ F2 K' K/ E
33.         ds1302_write_byte(dat);                //写入地址的数据
    
34.         DS1302_RST_LOW;                //关闭 表示结束        
    , y( ]  p* s, Y: T/ V2 D0 y7 p
35. }

复制代码

) E# @* A' w3 d7 l, h

) D/ ^; j* Z8 z, Y1 ~' @' ?7 B看上面的图，比如我想写入时 为18点 时的写寄存器是84H 数据就是18点 但是DS1302存储格式为 BCD 码那就是 0x18。
那写入 时 为18点 的代码则是：
4 T2 m" [" o" ^

1. ds1302_write_cmd(0x84,0x18); //设置当前 时  为 18点

复制代码

单字节读时序
# _# b7 Q% A0 B; z/ Z$ h  x

1. /******************************************************************
   ( E' \6 ~+ @% q6 F$ \$ x2 i
2. 描述: DS1302 读一字节 函数
   
3. *******************************************************************/
   / o, P* X7 u% X* p2 J' I
4. uint8_t ds1302_read_byte(void)
   ( ]; X# K) w& X/ X" A) S; @
5. {
   
6.         uint8_t i;
   
7.         uint8_t dat = 0;//用于存放读取到的数据
   
8.         DS1302_SET_IN;        //这里DAT引脚要设置输入模式了(上拉输入) 浮空输入我试过也可以
   + Z. [3 |7 r# S  O
9.         for(i=0;i<8;i++)
   6 t" O* c! {: {; N; g: O/ B
10.         {
    
11.                 dat >>= 1;                //左移一次 低位开始 共有效左移7次
    7 ?% u& }5 r8 Y; b
12.                 if( GPIO_ReadInputDataBit(DS1302_DAT_PORT, DS1302_DAT_PIN) == SET)
    ' Q, M2 Z5 {! s
13.                 {
    8 e$ Z* S) l0 K) M" L
14.                         dat = dat | 0x80;
    - N: i7 y2 e1 r* I$ ~  z& z; l& E
15.                 }
    
16. //                else
    # Y6 c& I' v2 o
17. //                {
    # J% \% p, }4 O, i0 ]; d8 T7 T" t
18. //                        dat = dat & 0x7f;
    
19. //                }
    
20.                 DS1302_CLK_HIGH;        //时钟拉高
    
21.                 DS1302_CLK_LOW;                //时钟拉低 准备判断下一位数据
    
22.         }
    
23.         return dat;        //返回读取到的数据
    ' Q$ j7 j, }9 s0 `
24. }
    
25. /*DS1302读取数据函数*/
    
26. unsigned char ds1302_read_data(unsigned char addr)
    9 M! }  `, E' u) D
27. {
    
28.         unsigned char data; //用于存放接收的数据
    
29.         RST = 0; //RST拉低
    
30.         SCLK = 0; //时钟SCLK也拉低
    7 k2 j; {: ?1 q% t. `: n# e
31.         RST = 1; //准备开始写        
    . C- w( W+ y- y
32.         ds1302_write_byte(addr);         //写入要读取的地址
    
33.         data = ds1302_read_byte(data); //读取地址的数据
    * c) x& _( l8 G
34.         RST = 0;//关闭 表示结束
    $ _: j' h! z1 L+ l" O
35.         
    # m/ ?9 q3 ^. G
36.         return data;        //返回读取到的数据
    
37. }
    
38. /******************************************************************
    
39. 描述: DS1302 读数据 函数
    
40. 参数: addr:要读取数据的地址
    
41. *******************************************************************/
    
42. uint8_t ds1302_read_data(uint8_t addr)
    
43. {
    
44.         uint8_t dat = 0;                //用于存放读取到的数据
    6 i$ x* G& V) X2 ~( W- T0 r4 X
45.         DS1302_RST_LOW;                        //RST拉低
      I& c6 u5 G- l5 \# @5 e0 G
46.         DS1302_CLK_LOW;                        //CLK拉高
    
47.         DS1302_RST_HIGH;                //RST拉高 开始
    2 e1 _: k+ B3 L( R
48.         ds1302_write_byte(addr);        //先写要读取的数据的地址
    
49.         dat = ds1302_read_byte();        //然后进行读取数据
    ' B& d% `1 ]4 u0 O, b7 n8 }
50.         DS1302_RST_LOW;                        //RST拉低 结束
    ; z: ]2 h4 ?' q% k
51.         return dat;        //返回读取到的数据
    0 `% ?) G5 a" f. L9 h
52. }

复制代码

8 `+ W  B7 Y# H% e7 a: u我们想读取时 里面时间 看看现在是几点 时 读寄存器是85H
. ^) V/ E( ^1 p
0 c6 Y  b. V, U/ \1 ^$ f

1. time = ds1302_read_data(0x85);
   7 E+ ]) G" |8 [1 ?+ P
2. /*time就是当前小时数据啦*/

复制代码

6 T+ Q- p* z) [% K( r& B! ~

写保护寄存器
当我们进行写的时候 比如写入当前的小时时间 当前的秒啊 啥的 就必须 WP位为0

2 L+ `7 ?  X6 w) P3 |2 Q例如:设置DS1302当前的小时为 12点 那么BCD码就是 0X12

1. /*在写入之前 我们必须要让 WP这位 置 0  
   
2.   也就是关闭写保护 寄存器0X8E*/
   - B9 U! ~$ O: j, R
3. ds1302_write_cmd(0X8E,0X00);        //关闭写保护
   6 D! ]; G6 i  D! N0 v0 N+ [4 w
4. 
   1 O6 J. Z; T  T$ p$ [
5. /*设置DS1302时间*/
   ) u! F- C- ~4 W4 u( @
6. ds1302_write_cmd(0X84,0x12);        //设置当前小时为 12点
   ' Y2 F4 [+ O. G. g3 V7 \
7. 
   
8. /*那我们再设置完DS1302时间我们一般就 WP 位置1
   
9.   开始写保护(只读模式)防止错改时间*/
   
10. ds1302_write_cmd(0X8E,0X80);        //开启写保护(只读模式)  

复制代码

写保护寄存器的位 7 是写保护位。开始 7 位（位 0-6）置为零，在读操作时总是读出零。在对时钟或
4 ]: Y' F! k3 C2 s2 s% @功能 字节数 脉冲数
# y, B+ k# Q0 a( W, vCLOCK 8 72
RAM 31 256
# b9 t5 Q1 u  s9 ^DS1302
! e5 F8 e; {+ y) \0 ?/ l6 lRAM 进行写操作之前，位 7 必须为零。当它为高电平时，写保护位禁止对任何其它寄存器进行写操作。
( U7 h  _# _4 c, k! s* e- Y2 G
: J" o3 f" \0 o: o时钟/日历多字节（Burst）方式
所谓的突发模式(BURST模式)就是一次性传送多个字节的时钟信号和RAM数据。比如我可以一次性把时间和日期写入，也可以一次性的读出时间和日期。
这里没写。。。。。略过0.0

7 c2 U" Q5 v# |0 q# a


BCD转十进制和十进制转BCD
由于DS1302是以BCD码存放的，那么如果我们读出来为了方便查看我这里是转十进制。
写入的时候 先十进制转BCD 再写入
读出的时候 先BCD转十进制 再运用
这样我们就可以一直是十进制啦。
  R+ v& Q: O; I$ ~% }) U' o# H7 A7 e
十进制转BCD
2 ^2 ~/ ~$ w# \! g. S比如 12 转成 BCD 也就是 0X12了对吧。
7 Q, k; j9 n4 {9 T5 Y那么其实就是 取出十位 1 然后放到高4位 然后取出个位 2 放到低4位
就是十六进制 0X12 代码如下

1 N, `; R& E0 a) M

1. /******************************************************************
   
2. 描述: 十进制 转 BCD 函数 例如 12 转成 0X12
   
3. 参数: dec:需要转换的十进制数据 转换的个数
   ' \0 v; D* a! V$ O. p+ g, n
4. *******************************************************************/
   
5. void dec_to_bcd(uint8_t *dec,uint8_t times)
   : E4 y7 b# U0 ~( V1 z) M
6. {
   
7.         uint8_t i;
   
8.         for(i=0;i<times;i++)
   
9.         {
   
10.                 dec<i> = ((dec<i>/10)<<4) | (dec<i>%10);
    
11.         }
    
12. }
    
13. 
    
14. /********************运用*************************/
    , ~/ g3 v, ~% E6 }4 D0 C
15. //日期和时间定义22年5月27日14点22分0秒周五                  
    
16. uint8_t ds1302_time[8] = {22,5,27,14,22,00,2};//年 月 日 时 分 秒 周
    
17. 
    1 ?# G- p% d' k" h1 D/ W
18. /*写入先转成BCD在写入*/
    
19. dec_to_bcd(ds1302_time,7);        //将时间十进制转成BCD格式 一共7个
    
20. </i></i></i>

复制代码

& k) Q. d7 n) _4 V. |BCD转十进制

1. /******************************************************************
   
2. 描述: BCD 转 十进制 函数 例如 0X24 转成 24
   
3. 参数: dec:需要转换的BCD数据 转换的个数
   
4. *******************************************************************/
   
5. void bcd_to_dec(uint8_t *bcd,uint8_t times)
   
6. {
   * g, x" t- u- c& E- Q! c% k
7.         uint8_t i;
   ( I7 o0 n/ s0 y5 i
8.         for(i=0;i<times;i++)
   
9.         {
   
10.                 bcd = ((bcd>>4)*10) + (bcd&0x0f);
    
11.         }
    
12. }
    " u8 U$ i) E9 }5 J
13. 
    
14. /********************运用*************************/
    
15. uint8_t hour;        //存放小时
    
16. hour = ds1302_read_data(0X85);        //读取小时
    
17. bcd_to_dec(&hour ,1);                        //将BCD码转成十进制 转1个
    ( P0 t+ _; S2 E) c$ x

复制代码

9 R3 T$ W' l7 e- ~4 `代码
6 k3 T: X' h. H; d4 I9 X部分代码呈现

ds1302.c

1. #include "ds1302.h"
   ; v# ?9 r% Y- K* j  [) u
2. 
   
3. //日期和 时间 定义                   年 月 日 时 分 秒 周
   $ I' J" J+ ^7 p4 v4 n
4. uint8_t ds1302_time[8] = {22,4,19,14,22,00,0X02};
   
5. 
   0 \* F8 ^6 o+ R& u/ L7 t3 w: G* V
6. /******************************************************************
   
7. 描述: DS1302 DAT设置成输入模式 函数
   
8. *******************************************************************/
   
9. void ds1302_set_input_mode(void)
   
10. {
    
11.         GPIO_InitTypeDef DS1302_Struction;                                //定义结构体成员
    
12.         RCC_APB2PeriphClockCmd(DS1302_DAT_RCC, ENABLE);        //打开时钟
    * R* P7 _/ u( p# e" `
13.         
    ( r8 X1 k. D- f- s" o+ Y9 f
14.         DS1302_Struction.GPIO_Pin  = DS1302_DAT_PIN;                //引脚
    7 J3 q* X) n( a5 Y, N! ]
15.         DS1302_Struction.GPIO_Mode = GPIO_Mode_IPU;                        //上拉输入 或者 浮空输入 GPIO_Mode_IN_FLOATING 都可以
    " ?( U7 e. a* _- a
16.                
    
17.         GPIO_Init(DS1302_DAT_PORT,&DS1302_Struction);                //对成员进行初始化        
    
18. }
    " x. x. W& c# G) w6 {
19. 
    
20. 
    
21. /******************************************************************
    5 d. R+ N  \8 r
22. 描述: DS1302 DAT设置成输出模式 函数
    
23. *******************************************************************/
    
24. void ds1302_set_output_mode(void)
    ; B& ^' p- l8 {$ O( J
25. {
    
26.         GPIO_InitTypeDef DS1302_Struction;                                //定义结构体成员
    - G  @/ N0 v9 [( _% c
27.         RCC_APB2PeriphClockCmd(DS1302_DAT_RCC, ENABLE);        //打开时钟
    
28.         
    
29.         DS1302_Struction.GPIO_Pin  = DS1302_DAT_PIN;                //引脚
    ' i. d, F& r6 Z  v- A! R
30.         DS1302_Struction.GPIO_Mode = GPIO_Mode_Out_PP;                //推挽输出
    + y8 _6 ^" I4 {0 `- q; I  b
31.         DS1302_Struction.GPIO_Speed = GPIO_Speed_50MHz;                //速率        
    - \2 M2 _, ?, f
32. 
    
33.         GPIO_Init(DS1302_DAT_PORT,&DS1302_Struction);                //对成员进行初始化        
    , N3 J/ f3 l3 M. f$ v4 s' K; C
34. }
    
35. 
    9 p* {5 q$ |2 G
36. 
    
37. /******************************************************************
    ' M: l/ l+ n1 M' U4 ], I: w1 O. y
38. 描述: DS1302 配置 函数
    
39. *******************************************************************/
    
40. void ds1302_config(void)
    $ K1 `  s( `5 u' i
41. {
    3 Q2 k& ]1 g& @8 x" y; h1 q
42.         GPIO_InitTypeDef DS1302_Struction;                                //定义结构体成员
    * G, ]6 ]- X+ m6 Z" O
43. 
    
44.         RCC_APB2PeriphClockCmd(DS1302_CLK_RCC, ENABLE);        //打开时钟
    2 Q" F- [7 l9 T3 i
45.         RCC_APB2PeriphClockCmd(DS1302_DAT_RCC, ENABLE);        //打开时钟
    
46.         RCC_APB2PeriphClockCmd(DS1302_RST_RCC, ENABLE);        //打开时钟
    1 ?/ r9 o2 l2 t5 e# s' J5 H* E, i# Z% z9 p
47. 
    / x$ ?! R3 n- E" u1 L9 w6 _
48.         //DS1302 CLK
    
49.         DS1302_Struction.GPIO_Pin  = DS1302_CLK_PIN;                //引脚
    # n5 ?+ m" {$ L$ u; C! W
50.         DS1302_Struction.GPIO_Mode = GPIO_Mode_Out_PP;                //推挽输出        
    
51.         DS1302_Struction.GPIO_Speed = GPIO_Speed_50MHz;         //50MHz
    
52.         GPIO_Init(DS1302_CLK_PORT,&DS1302_Struction);                //对成员进行初始化               
    + P. j- n8 P# `1 A; O
53.         //DS1302 DAT
    
54.         DS1302_Struction.GPIO_Pin  = DS1302_DAT_PIN;                //引脚
    
55.         DS1302_Struction.GPIO_Mode = GPIO_Mode_Out_PP;                //推挽输出        
    
56.         DS1302_Struction.GPIO_Speed = GPIO_Speed_50MHz;         //50MHz
    
57.         GPIO_Init(DS1302_DAT_PORT,&DS1302_Struction);                //对成员进行初始化        
    3 [3 x; U1 f0 v5 Y* b' W
58.         //DS1302 RST
    " c) J2 W  p- G  Q
59.         DS1302_Struction.GPIO_Pin  = DS1302_RST_PIN;                //引脚
    
60.         DS1302_Struction.GPIO_Mode = GPIO_Mode_Out_PP;                //推挽输出        
    + Z. r: N$ L& [0 K% h
61.         DS1302_Struction.GPIO_Speed = GPIO_Speed_50MHz;         //50MHz
    5 A: V' U* d* F  ]0 E# L6 {  y
62.         GPIO_Init(DS1302_RST_PORT,&DS1302_Struction);                //对成员进行初始化        
    2 {: t" w! g7 J' f
63. 
    2 G! t3 @. E6 {( @3 |. }- }. O. |
64. }
    
65. /******************************************************************
    
66. 描述: DS1302 写一字节 函数
    - r' _7 w& Y; Q/ e- z* j
67. *******************************************************************/
    
68. void ds1302_write_byte(uint8_t addr_or_data)
    ! G# _2 V. \: N% Z( @& E
69. {
    6 P9 X$ }# B, \2 |- v. I, {
70.         uint8_t i;
    
71.         DS1302_SET_OUT;
    . |) x0 f: G, r
72.         for(i=0;i<8;i++)
    ; f) X$ V6 c/ R7 O7 k
73.         {
    
74.                 if(addr_or_data & 0x01)                //从低位开始传输
    
75.                 {
    ; ?4 p. j+ S: G$ Q0 Q' F, u
76.                         DS1302_DAT_HIGH;
    
77.                 }
    
78.                 else
    ) v, V- x6 W6 ]7 z: I
79.                 {
    
80.                         DS1302_DAT_LOW;
    ! G$ S- O, ~6 s0 G/ F
81.                 }
    
82.                 addr_or_data >>= 1;                //右移一位
    9 A6 ~6 j# X1 L' H
83.                 DS1302_CLK_HIGH;                //拉高时钟表示已经发送
    
84.                 DS1302_CLK_LOW;                        //拉低时钟准备继续放新的数据位
    1 }$ F& E; U" g5 c
85.         }
    
86. }
    . W) @8 a; _; l* ?% x
87. 
    
88. /******************************************************************
    , R# F7 q7 `  E" V. V+ @2 r
89. 描述: DS1302 写命令 函数
    
90. *******************************************************************/
    
91. void ds1302_write_cmd(uint8_t addr,uint8_t dat)
    
92. {
    
93.         DS1302_RST_LOW;
    
94.         DS1302_CLK_LOW;
    4 P7 f6 S) @- m: u7 Z
95.         DS1302_RST_HIGH;
    # n. D3 d6 h! t- L
96.         ds1302_write_byte(addr);
    
97.         ds1302_write_byte(dat);
    ) d6 g- ^2 v9 g  }# Y5 }* E5 B5 g4 x0 M
98.         DS1302_RST_LOW;
    4 t8 N$ `6 b' _4 |2 f( ]1 v/ [
99. }
    
100. 
     7 [. H  j- s" J( G
101. /******************************************************************
     % Q# J. \2 X7 Y; k7 p( I6 y
102. 描述: DS1302 读一字节 函数
     
103. *******************************************************************/
     
104. uint8_t ds1302_read_byte(void)
     1 {; s* J( Y4 {9 s" D- J' V
105. {
     
106.         uint8_t i;
     
107.         uint8_t dat = 0;
     . r; G5 |& _0 C: e1 I
108.         DS1302_SET_IN;
     
109.         for(i=0;i<8;i++)
     ' z/ r+ H$ @. }; F0 a" b3 W& ^
110.         {
     9 ?/ ]* z% r3 t7 K5 M6 A
111.                 dat >>= 1;                //左移一次 低位开始 共有效左移7次
     
112.                 if( GPIO_ReadInputDataBit(DS1302_DAT_PORT, DS1302_DAT_PIN) == SET)
     2 z5 z1 y* c4 @- `
113.                 {
     ; q* }% H2 s( Q8 ~8 [8 t3 \
114.                         dat = dat | 0x80;
     
115.                 }
     
116. //                else
     
117. //                {
     
118. //                        dat = dat & 0x7f;
     ) G. C! f# f  e0 u6 ?3 N7 B
119. //                }
     
120.                 DS1302_CLK_HIGH;
     , X/ [; L% h. n) j- t8 I
121.                 DS1302_CLK_LOW;
     & ]; z$ r7 p9 M; K6 {
122.         }
     
123.         return dat;
     9 [7 u) a- ?2 f% g% I
124. }
     
125. 
     4 M7 c9 h$ ^# |# t
126. 
     # |* b* W0 s$ i% a
127. /******************************************************************
     
128. 描述: DS1302 读数据 函数
     
129. *******************************************************************/
     
130. uint8_t ds1302_read_data(uint8_t addr)
     
131. {
       P' w+ C3 K/ L- F7 }6 C* g2 N( M
132.         uint8_t dat = 0;
     
133.         DS1302_RST_LOW;
     6 s& y4 }$ j+ Z
134.         DS1302_CLK_LOW;
     
135.         DS1302_RST_HIGH;
     
136.         ds1302_write_byte(addr);
     4 d  H3 h# S# B9 i' u
137.         dat = ds1302_read_byte();
     
138.         DS1302_RST_LOW;
     
139.         return dat;
     6 S9 d$ |& R+ T4 L( m7 u: L
140. }
     
141. 
     ( R. K# ~+ C4 x5 j$ \+ {& f
142. /******************************************************************
     , k) A9 {) @* u) Z% o4 i
143. 描述: BCD 转 十进制 函数 例如 0X24 转成 24
     : }) {. B) E) M
144. *******************************************************************/
     
145. void bcd_to_dec(uint8_t *bcd,uint8_t times)
     
146. {
     
147.         uint8_t i;
     
148.         for(i=0;i<times;i++)
     
149.         {
     + h, I; }9 C5 l
150.                 bcd = ((bcd>>4)*10) + (bcd&0x0f);
     
151.         }
     : Y  W, _7 x2 ~
152. }
     
153. 
     
154. /******************************************************************
     0 c8 T& T1 m8 L# N
155. 描述: 十进制 转 BCD 函数 例如 12 转成 0X12
     
156. *******************************************************************/
     
157. void dec_to_bcd(uint8_t *dec,uint8_t times)
     
158. {
     
159.         uint8_t i;
     / O" j3 \( F) B) P# r
160.         for(i=0;i<times;i++)
     
161.         {
     
162.                 dec = ((dec/10)<<4) | (dec%10);
     & q4 A( d! w- J2 ~+ h3 V
163.         }
     # X5 ^. h' p, `7 v& @( U. F: a6 R1 O( U
164. }
     
165. 
     
166. 
     1 k" w6 K( @+ A: c: P/ [' @2 l. J4 h
167. 
     + ]3 x# d3 Z3 j- A0 Q- {, t# T
168. 
     
169. /******************************************************************
     
170. 描述: DS1302 初始化 日期和时间 函数
     
171. *******************************************************************/
     
172. void ds1302_init(void)
     
173. {
     
174.         ds1302_config();        //引脚配置
     - d) M& `. w) b/ }' w7 i
175. 
     
176.         dec_to_bcd(ds1302_time,7);        //十进制转BCD码
     . @0 t3 N0 W0 k
177.         ds1302_write_cmd(DS1302_WRITE_PROTECT,0x00); //关闭写保护        
     # D+ \$ {8 z1 S8 l9 p) h8 [
178.         
     
179.         ds1302_write_cmd(DS1302_WRITE_YEAR,        ds1302_time[0]);        //年
     - \$ {% [$ l/ K5 Q+ D  v% @4 L3 x( @# H+ f
180.         ds1302_write_cmd(DS1302_WRITE_MONTH,ds1302_time[1]);        //月
     0 N; P5 H9 p( |
181.         ds1302_write_cmd(DS1302_WRITE_DAY,        ds1302_time[2]);          //日
     ' z& T5 m) ]+ K0 ?+ M9 V
182.         ds1302_write_cmd(DS1302_WRITE_HOUR,        ds1302_time[3]);           //时
     
183.         ds1302_write_cmd(DS1302_WRITE_MINUTE,ds1302_time[4]);         //分
     9 b% r& w: `9 s9 o' o& s
184.         ds1302_write_cmd(DS1302_WRITE_SECOND,ds1302_time[5]);          //秒
     2 j. o4 ?0 ^8 v) e0 A. V
185.         ds1302_write_cmd(DS1302_WRITE_WEEK,        ds1302_time[6]);          //周        
     : h8 }0 F( h1 m+ j) w
186. 
     / s6 G( O# h$ N$ g% X
187.         ds1302_write_cmd(DS1302_WRITE_PROTECT,0x80); //开启写保护        
     9 [+ b3 u8 ^- v9 h
188. }
     - X0 N. z* ]1 r. t$ S
189. 
     
190. /******************************************************************
     8 C9 l; I; h& r/ Z
191. 描述: DS1302 读取 日期和时间 函数
     6 a- f) q6 ^  _! G
192. *******************************************************************/
     
193. void ds1302_read(void)
     . w  z4 U8 b& i' \+ V/ F
194. {
     % I3 w2 J9 d/ q& M/ @7 ~
195.         ds1302_time[0] = ds1302_read_data(DS1302_READ_YEAR);  //读取年
     3 L9 m) _5 k. \! }1 a' ]
196.         ds1302_time[1] = ds1302_read_data(DS1302_READ_MONTH); //读取月
     , e0 ^4 k( U+ F- m  H( d
197.         ds1302_time[2] = ds1302_read_data(DS1302_READ_DAY);   //读取日
     
198.         ds1302_time[3] = ds1302_read_data(DS1302_READ_HOUR);  //读取时
     
199.         ds1302_time[4] = ds1302_read_data(DS1302_READ_MINUTE);//读取分
     
200.         ds1302_time[5] = ds1302_read_data(DS1302_READ_SECOND);//读取秒
     
201.         ds1302_time[6] = ds1302_read_data(DS1302_READ_WEEK);  //读取周
     
202. 
     
203.         bcd_to_dec(ds1302_time,7);        //BCD码转成十进制
     
204. }
     / N  m9 v6 K7 m' n% v
205. 
     $ i; B, h; Q; h' G8 t  T# [0 \% s# j1 W

复制代码

ds1302.h

1. #ifndef __DS1302_H
   5 H5 R( ~4 G9 ~
2. #define __DS1302_H
   
3. #include "stm32f10x.h"
   ) y" W. Q/ n! `# n9 M
4. 
   2 X' p0 T6 O/ q" p" m# J
5. #define DS1302_CLK_RCC                RCC_APB2Periph_GPIOB                //时钟
   
6. #define DS1302_CLK_PORT                GPIOB                                                //端口
   / |6 Q& }/ P3 I
7. #define DS1302_CLK_PIN                GPIO_Pin_13                                        //引脚
     S9 ^# W% s6 O- _9 N2 Y0 p) H
8. 
   
9. #define DS1302_DAT_RCC                RCC_APB2Periph_GPIOB                //时钟
   
10. #define DS1302_DAT_PORT                GPIOB                                                //端口
    % S1 [! v1 O0 ]* J% Y
11. #define DS1302_DAT_PIN                GPIO_Pin_14                                        //引脚
    3 O% [; c% [: y( p9 n* Q
12. 
    
13. #define DS1302_RST_RCC                RCC_APB2Periph_GPIOB                //时钟
    
14. #define DS1302_RST_PORT                GPIOB                                                //端口
    0 g. }4 r( M% @1 U/ V
15. #define DS1302_RST_PIN                GPIO_Pin_15                                        //引脚
    
16. 
    ) E$ t# k& x. S3 }
17. 
    , S9 i$ h3 w6 Q/ k) \5 M; |8 |) l+ {
18. #define DS1302_CLK_HIGH                GPIO_SetBits(DS1302_CLK_PORT, DS1302_CLK_PIN)                        //引脚输出高电平
    . o6 \5 A, t$ c' V
19. #define DS1302_CLK_LOW                GPIO_ResetBits(DS1302_CLK_PORT, DS1302_CLK_PIN)                        //引脚输出低电平
    4 Z0 \( r9 v: G7 y* n$ Z
20. 
    6 c! }  V  o1 o$ m
21. #define DS1302_DAT_HIGH                GPIO_SetBits(DS1302_DAT_PORT, DS1302_DAT_PIN)                        //引脚输出高电平
    
22. #define DS1302_DAT_LOW                GPIO_ResetBits(DS1302_DAT_PORT, DS1302_DAT_PIN)                        //引脚输出低电平
    , D# a: l' ~$ {
23. 
    
24. #define DS1302_RST_HIGH                GPIO_SetBits(DS1302_RST_PORT, DS1302_RST_PIN)                        //引脚输出高电平
    
25. #define DS1302_RST_LOW                GPIO_ResetBits(DS1302_RST_PORT, DS1302_RST_PIN)                        //引脚输出低电平
    
26. 
    
27. #define DS1302_SET_IN                ds1302_set_input_mode()                                                        //设置输入模式
    , ^& A0 y7 M1 F5 z" Q
28. #define DS1302_SET_OUT                 ds1302_set_output_mode()                                                //设置输出模式               
    
29. 
    7 T" \$ {9 o% d
30. 
    
31. /*读相关寄存器地址*/
    
32. #define DS1302_READ_SECOND         0X81           //秒
    ( n3 O/ M5 f2 E' Y" s
33. #define DS1302_READ_MINUTE         0X83        //分
    & S9 Y. h1 d$ Y6 z+ l
34. #define DS1302_READ_HOUR           0X85        //时
    
35. #define DS1302_READ_DAY                0X87        //日
    
36. #define DS1302_READ_MONTH         0X89        //月
    
37. #define DS1302_READ_WEEK         0X8B        //周
    
38. #define DS1302_READ_YEAR         0X8D        //年
    
39. //#define DS1302_READ_TIME         0XBF        //读取全部时间
    
40. 
    ' A: Q+ y- Z& Z, P
41. /*写相关寄存器地址*/
    
42. #define DS1302_WRITE_SECOND 0X80           //秒
    6 H  u+ t4 d, q/ L$ O. z. T- e
43. #define DS1302_WRITE_MINUTE 0X82        //分
    & K/ ~( j- \3 Z( l# S$ K' ~
44. #define DS1302_WRITE_HOUR   0X84        //时
    6 C  E6 j  {, b9 X
45. #define DS1302_WRITE_DAY        0X86        //日
    
46. #define DS1302_WRITE_MONTH         0X88        //月
    
47. #define DS1302_WRITE_WEEK         0X8A        //周
    
48. #define DS1302_WRITE_YEAR         0X8C        //年
    
49. #define DS1302_WRITE_PROTECT 0X8E        //保护
    6 i8 k' D) l2 l
50. //#define DS1302_WRITE_TIME         0XBE         //写全部时间
    
51. 
    * w- Y4 |7 A/ X2 G
52. 
    ! g# {- O6 ^8 S% s
53. extern uint8_t ds1302_time[8];        //存放日期和时间
    
54. 
    8 L% \1 t& U  ~/ t+ Q9 T
55. void ds1302_write_byte(uint8_t addr_or_data);                        //DS1302 写一字节 函数
    ) R: @* D+ a( H
56. void ds1302_write_cmd(uint8_t addr,uint8_t dat);                //DS1302 写命令          函数
    . @* T) ], y& G  k
57. uint8_t ds1302_read_byte(void);                                                        //DS1302 读一字节 函数
    + S, d1 P8 g  b4 a
58. uint8_t ds1302_read_data(uint8_t addr);                                        //DS1302 写一字节 函数
    - O8 @) g# {" U
59. void bcd_to_dec(uint8_t *bcd,uint8_t times);                        //BCD 转 十进制 函数
    & w, W1 g- X6 d* v8 a
60. void dec_to_bcd(uint8_t *dec,uint8_t times);                        //十进制 转 BCD 函数
    & u$ |8 u; T0 g# L5 N4 G
61. void ds1302_init(void);                                                                        //DS1302 初始化日期和时间 函数
    - p; m7 x! H6 f0 L% }' e7 y" K
62. void ds1302_read(void);                                                                        //DS1302 读取  日期和时间 函数
    , s$ h( W4 D3 f5 W, ?
63. 
    
64. #endif

复制代码

" t" s7 @3 y$ l4 l- Dusart.c
9 C3 P0 `+ [" R) i( g. K! D

1. /* 配置串口1 优先级 函数 */
   
2. static void NVIC_USART1_configuration(void)
   
3. {
   
4.         NVIC_InitTypeDef NVIC_initStruction;
   + o% ~2 Y+ S1 A
5.         
   
6.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);                                //组
   
7.         NVIC_initStruction.NVIC_IRQChannel = USART1_IRQn;                        //串口1中断
   % a: }6 [$ i; \2 V5 k
8.         NVIC_initStruction.NVIC_IRQChannelPreemptionPriority = 0;   //主优先级
   
9.         NVIC_initStruction.NVIC_IRQChannelSubPriority = 0;                        //次优先级
   
10.         NVIC_initStruction.NVIC_IRQChannelCmd = ENABLE;                                //使能
    
11.         NVIC_Init(&NVIC_initStruction);
    
12. }
    
13. 
    
14. /* 配置串口1 函数*/
    
15. void usart1_init(uint32_t baudRate)
    ! [/ ^1 F2 T3 T. k6 ~
16. {
    
17.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);        //打开GPIOA时钟
    
18.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);        //打开串口1时钟
    ) e5 }# G2 p) _4 ?9 k
19.         
    4 W9 O/ j. R. U+ C1 ]
20.         GPIO_InitTypeDef GPIO_initStruction;
    
21.         USART_InitTypeDef USART_initStruction;
    
22. 
    
23.         /*配置GPIOA  TX */
    
24.         GPIO_initStruction.GPIO_Pin = USART1_TX;                 // TX
    ( i8 R7 i- {. o. q. @1 w2 ?5 \& D% u
25.         GPIO_initStruction.GPIO_Mode = GPIO_Mode_AF_PP; //复用推挽输出
    ( \& T( ?; N" I* ~3 Y) T
26.         GPIO_initStruction.GPIO_Speed = GPIO_Speed_50MHz;
    
27.         GPIO_Init(GPIOA, &GPIO_initStruction);
    
28.         
    
29.         /*配置GPIOA RX */
    
30.         GPIO_initStruction.GPIO_Pin = USART1_RX;                 // RX
    
31.         GPIO_initStruction.GPIO_Mode = GPIO_Mode_IN_FLOATING; //浮空输入
    
32.         GPIO_Init(GPIOA, &GPIO_initStruction);
    
33.         
    4 ~6 U1 T( \5 q4 O$ ]. q' X* ^; t+ n
34.         /*配置USART1 TX和RX */
    . W2 @" b: s# W9 y( Y
35.         USART_initStruction.USART_BaudRate = baudRate;        //波特率
    1 B1 L, m. K/ r: I7 a# g
36.         USART_initStruction.USART_WordLength = USART_WordLength_8b; //8位有效数据位
    
37.         USART_initStruction.USART_StopBits = USART_StopBits_1;        //1个停止位
    + ]; [4 r4 O* f1 b
38.         USART_initStruction.USART_Parity = USART_Parity_No;                //无奇偶校验位
    4 Q) Q  r$ O9 h- B7 [
39.         USART_initStruction.USART_HardwareFlowControl = USART_HardwareFlowControl_None; //不硬件控制流
    6 F- K( {6 v9 F
40.         USART_initStruction.USART_Mode = USART_Mode_Tx | USART_Mode_Rx; //发送 和 接收
    
41.         USART_Init(USART1, &USART_initStruction);
    " \8 H2 C. c) t  ^
42.         
    . \9 x& g4 V) U+ t* t
43.         NVIC_USART1_configuration();        //串口1中断优先级配置
    + \4 \4 P6 A" o  A" ?5 C! e; ^
44.         USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//使能接收中断
    $ |2 _/ @/ {4 D- ~  _! x1 b8 `# W
45.         USART_Cmd(USART1, ENABLE); //使能串口1
    
46. }
    
47. 
    
48. 
    
49. 
    + r* A. C7 Y0 l( W
50. /*重定向C库函数printf到串口*/
    2 Q, T6 ?5 g+ t* N& P7 w7 k
51. int fputc(int ch, FILE *f)
    7 Y  W6 d1 I+ C; k: n4 o
52. {
    0 B, \( N% @/ t% T  v) L3 r# D
53.         USART_SendData(USART1, (uint8_t)ch);; //发送一字节到串口
    
54.         while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET); //等待发送寄存器为空 证明发送完
    ) c: E: m! ]* p+ R
55.         
    7 I1 _. J+ s! o, j+ T; P0 _: t9 c
56.         return ch;
    : J' b( P, _) ^
57. }
    
58. 
    / m1 Q3 x3 `% ^% M3 E
59. /*重定向C库函数 scanf到串口*/
    , r( o9 m4 J; B! t
60. int fgetc(FILE *f)
    $ Y! }, c# y: V4 E- z
61. {
    
62.         while(USART_GetFlagStatus(USART1, USART_FLAG_RXNE) == RESET); //如果读数据寄存器非空
    3 R8 N$ V- G6 Y3 {, [
63.         return (int)USART_ReceiveData(USART1);
    
64. }

复制代码

usart.h
: o( p( F# ^* Y5 h8 f2 e5 d

1. #ifndef __USART_H
   
2. #define __USART_H
   
3. #include "stm32f10x.h"
   
4. #include "stdio.h"
   5 }' L3 N; t$ O+ f5 l0 D' V
5. 
   . S4 @8 k, ]  x
6. #define USART1_TX        GPIO_Pin_9
   
7. #define USART1_RX        GPIO_Pin_10
   & I" q2 {7 X+ G% q4 j
8. 
   7 u$ p* n! @0 J/ ?
9. void usart1_init(uint32_t baudRate);
   
10. 
    + x( I; e4 r: `! j9 `5 N/ ?) u1 T
11. 
      Y! p/ }4 |  B' V1 B, ]2 W$ ?
12. #endif

复制代码

main.c

1. #include "stm32f10x.h"
   
2. #include "delay.h"
   
3. #include "ds1302.h"
   ' R" H$ v  E% T1 X! i
4. #include "usart.h"
   
5. int  main()
   8 C* I" y. D! W$ W2 c7 P# L
6. {
   2 o# I# {) v- X, ]
7.         ds1302_init();                        //DS1302初始化
   
8.         usart1_init(115200);        //串口1初始化
   
9.         while(1)
   , ?4 N% C' J: Q7 G5 f
10.         {
    7 r$ {/ b4 e& l  ]1 k8 a
11.                 ds1302_read();        //读取日期和时间
    2 ^0 W  `- ~& h$ W4 X+ g- H$ u) D
12.                 printf("20%d年%d月%d日 %d时%d分%d秒 星期%d\r\n",ds1302_time[0],ds1302_time[1],ds1302_time[2],ds1302_time[3],ds1302_time[4],ds1302_time[5],ds1302_time[6]);
    3 O+ ?7 l  I( D3 _
13.                 delay_ms(500);
    3 I- ]9 l1 t9 K$ ^2 B
14.         }  
    
15. }

复制代码

/ C: V6 c" l0 J; B3 j# ?3 K项目展示
运行结果
% b9 |' G8 f$ V3 Q' A2 _7 M7 M5 A

  Y3 u. e, A: u( O
. T$ Y3 @0 _- ~总结和注意事项
, u* t  P7 i. J) R& @一：以前玩51比较多，STM32玩得少，主要的区别是STM32有多个模式，不同场景需要切换不同模式来进行。比如这里的DS1302 CLK 和 RST 这种直接一直推挽输出没问题，但是DAT引脚则不行了，咱们去拉低拉高是推挽输出，但是到我们读取这个DAT电平则需要设置成上拉输入。（浮空貌似也行）不像51不用考虑 直接操作。
二：如果你发现采取样不准，请检查是否把DS1302的 VCC接到STM32的5V引脚。
三：重定向printf(); 如果你发现并没有输出数据。那么请查看一下你是否勾选了（如下图）
2 X1 h5 K" ]) U' q

3 L0 W* a- w, s  h2 u! X5 Z
学了51 其实上手32不难，反正我觉得还可以，就是配置啥的麻烦了一丢丢主要是IO的模式

————————————————
; H1 U5 B! N1 @* f转载：皮卡丘吉尔
& `8 W: q+ m0 c9 |1 D
( ]3 K+ b  e9 ?5 h# i