最近项目中需要用到数码管显示，于是买了一个TM1637芯片驱动的四位数码显示模块，现将调试过程记录一下，方便以后参考。

使用的单片机是STM32F103C8T6最小系统
7 K' U1 r: Z7 |1 R. B


     使用的数码管模块是TM1637四位数码管显示模块
3 c) q& x5 P( a! R8 _) U4 i% h

3 }+ o& ]7 k# U' T  r- T. t
实际运行效果
* D& S* i+ ^5 d/ M- T
7 g5 [2 O2 T6 m& B8 C

下面先看一下TM1637和数码管连接的具体线路图
) W2 U8 t: J1 Y% O3 @6 b


! u% t; z' q$ p( t7 g! A        实际使用的模块没有带按键，只用了4个数码管，模块和单片机连接只需要4根线VCC、GND、CLK、DIO。芯片和单片机通信使用的是I2C总线，下面就来说一下如何通过I2C总线驱动这个数码管模块。

" q; \- X% D7 W$ L6 V/ y" l        为了方便移植，这里使用 IO口模拟I2C总线，所以首先要将延时函数准备好，延时函数使用任何一种方式都可以，可以根据自己的习惯使用自己的延时函数。
" _0 ]) d4 k2 D7 {( n
; a$ _) K8 k) Q$ P; @

1. /*
   0 F# h5 `0 g$ F7 x% h& r+ c; a8 g
2. * t : 定时时间
   
3. * Ticks : 多少个时钟周期产生一次中断
   # I# F5 ]. w: {2 h/ n2 [" }
4. * f : 时钟频率 72000000
   
5. * t = Ticks * 1/f = (72000000/1000000) * (1/72000000) = 1us
   / S. S9 B: W: L
6. */
   " c1 O% ^0 W4 C. t' [6 j- e* F
7. 
   . O' z6 T; q" R4 o
8. void SysTick_Delay_Us( __IO uint32_t us )
   
9. {
   
10.     uint32_t i;
    
11.     SysTick_Config( SystemCoreClock / 1000000 );
    6 u* @4 F+ ]8 _  p' }9 J+ U) T, O
12. 
    
13.     for( i = 0; i < us; i++ )
    6 h* J- A; \' X1 w5 t
14.     {
    . |( Q! U( I& I" Q: U2 m- X7 P
15.         // 当计数器的值减小到0的时候，CRTL寄存器的位16会置1
    
16.         while( !( ( SysTick->CTRL ) & ( 1 << 16 ) ) );
    ; P, k+ t  \; Y
17.     }
    4 M2 u" D+ N) w3 ^
18.     // 关闭SysTick定时器
    - z) k7 m8 ~$ J: ?4 w& p
19.     SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;
    
20. }
    6 x6 i* ?9 I! W& m; J. ]
21. 
    
22. void SysTick_Delay_Ms( __IO uint32_t ms )
    ( W4 D  n0 k! T( ]0 Y
23. {
    
24.     uint32_t i;
    
25.     SysTick_Config( SystemCoreClock / 1000 );
    
26. 
    
27.     for( i = 0; i < ms; i++ )
    ! q7 v8 n% o6 ?( z3 u. c4 J7 M2 @7 e2 R
28.     {
    
29.         // 当计数器的值减小到0的时候，CRTL寄存器的位16会置1
    4 y& P5 [: j& o& x7 |
30.         // 当置1时，读取该位会清0
    
31.         while( !( ( SysTick->CTRL ) & ( 1 << 16 ) ) );
    ; c# w* n1 L2 u9 }: m+ W
32.     }
    
33.     // 关闭SysTick定时器
    
34.     SysTick->CTRL &= ~ SysTick_CTRL_ENABLE_Msk;
    
35. }
    

复制代码

. T1 L. e/ A$ M5 f7 ]7 A# E3 h        这里直接读取系统定时器的标志位来进行延时，设置系统定时器1us中断一次。直接判断系统的中断次数就可以实现us级的延时了。

' q$ e& C- G! I      下来就需要编写I2C的时序了，官方资料上也提提供了参考代码，这个代码也是参考官方代码修改的。

5 l9 I# m, @6 A6 s5 L; r* @      首先要定义需要用到的IO口，为了方便移植，将所用到的IO口直接在头文件中定义，需要更改IO口的时候，只需要在头文件中修改就行。
3 Z/ U+ e6 d/ F# m
4 D  i2 w7 s+ ~# ]

1. /* 定义IIC连接的GPIO端口, 用户只需要修改下面的代码即可改变控制的LED引脚 */
   
2. #define TM1637_CLK_GPIO_PORT            GPIOB                                /* GPIO端口 */
   / ?$ ~' }' k8 u7 r- W; U
3. #define TM1637_CLK_GPIO_CLK             RCC_APB2Periph_GPIOB                /* GPIO端口时钟 */
   
4. #define TM1637_CLK_GPIO_PIN                          GPIO_Pin_6
     J+ |! W; s# h" f
5. 
   
6. #define TM1637_DIO_GPIO_PORT            GPIOB                                      /* GPIO端口 */
   
7. #define TM1637_DIO_GPIO_CLK             RCC_APB2Periph_GPIOB                /* GPIO端口时钟 */
   
8. #define TM1637_DIO_GPIO_PIN                    GPIO_Pin_7

复制代码

在模拟时序的时候为了方便编写代码，将用到的时钟口和数据口也重新定义。

1. //使用 位带 操作
   
2. #define TM1637_CLK           PBout(6)
     ?3 \3 t9 i: b
3. #define TM1637_DIO           PBout(7)
   ; h+ h3 k4 O" h
4. #define TM1637_READ_DIO      PBin(7)
   % t2 Y7 s! p! [5 w( x/ @4 B2 P# c
5. 
   ( d6 K2 E, P7 c- L  l/ a1 @. W
6. //IO方向设置                                                                                   0011输出模式   1000上下拉输入模式
   . p  }" _2 G! B8 p* |
7. #define TM1637_DIO_IN()      {GPIOB->CRL&=0X0FFFFFFF;GPIOB->CRL|=(u32)8<<28;}
   
8. #define TM1637_DIO_OUT()     {GPIOB->CRL&=0X0FFFFFFF;GPIOB->CRL|=(u32)3<<28;}

复制代码

: h3 \4 l' n+ i! [5 v下来需要初始化 IO口
) W% _7 m' T  F
7 ?; ]6 \! O  n" o1 C  o

1. //端口初始化
   
2. void TM1637_Init( void )
   + W7 U, s2 N4 ?7 v+ d
3. {
   7 R- Q" G! \8 n4 D0 p# V0 B
4.     GPIO_InitTypeDef  GPIO_InitStructure;
   8 g/ \6 v% s7 H
5. 
   
6.     RCC_APB2PeriphClockCmd( TM1637_CLK_GPIO_CLK | TM1637_DIO_GPIO_CLK, ENABLE );
   6 ?8 R9 i& d7 ^- h9 T! \
7. 
   
8.     GPIO_InitStructure.GPIO_Pin = TM1637_CLK_GPIO_PIN | TM1637_DIO_GPIO_PIN;
   
9.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
   ! O" ]" b4 j# R
10.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
11.     GPIO_Init( TM1637_CLK_GPIO_PORT, &GPIO_InitStructure );
    , J) j9 p9 s' o# o
12. }

复制代码

* f4 d7 Y% i+ J" d" c下来模拟I2C的时序

1. 
   ; |4 o! }, t) C% ~5 \+ `
2. //起始位 CLK为高电平时，DIO由高变低
   
3. void TM1637_Start( void )
   
4. {
   ; H9 j" E; l- a( Q* A7 m8 t9 ~- N# v$ Y
5.     TM1637_DIO_OUT();
   $ \" ?9 n* i3 v2 t' z6 u
6.     TM1637_CLK = 1;
   1 F% b" u6 r& ~( Y( a3 O; A
7.     TM1637_DIO = 1;
   
8.     delay_us( 2 );
   
9.     TM1637_DIO = 0;
   
10. }
    4 V. O, E2 g& \! A* R7 s. m! B
11. 
    3 k  [" p; ~: X: e' G- Y
12. //等待应答 传输数据正确时，在第八个时钟下降沿，芯片内部会产生一个ACK信号，将DIO管脚拉低，在第九个时钟结束之后释放DIO总线。
    ) ~7 K& @) S! w
13. void TM1637_Ack( void )
    
14. {
    
15.     TM1637_DIO_IN();
    ; U5 F8 q3 b- m
16.     TM1637_CLK = 0;
    - a" n  k0 K) _- R  [/ C! z+ A
17.     delay_us( 5 );                                                                                                        //在第八个时钟下降沿之后延时 5us，开始判断 ACK 信号
    / u. K7 _, K1 ~. m7 c! P! x
18.     while( TM1637_READ_DIO );                                                                //等待应答位  这一行代码也可以不要 不影响实际使用效果 在使用软件仿真的时候需要屏蔽这句代码，否则程序就会卡在这里。
    
19.     TM1637_CLK = 1;
    
20.     delay_us( 2 );
    " i0 v4 G" E2 I+ x1 X3 g! Y
21.     TM1637_CLK = 0;
    1 _8 I* Q: Q' q& G' ~8 B* N" P
22. }
    5 {* Z  x  H2 y
23. 
    ; c# Y& e# ~0 w- Q9 f
24. //停止位 CLK为高电平时，DIO由低变高
    
25. void TM1637_Stop( void )
    
26. {
    8 v8 O* N3 L& [  R
27.     TM1637_DIO_OUT();
    
28.     TM1637_CLK = 0;
    
29.     delay_us( 2 );
    
30.     TM1637_DIO = 0;
    
31.     delay_us( 2 );
    - r7 ?( f# }- V' J
32.     TM1637_CLK = 1;
    & Y, I$ i+ V9 U, `8 v) }" A# ~
33.     delay_us( 2 );
    
34.     TM1637_DIO = 1;
    , ]0 P  d5 O1 d+ f+ J: e
35. }
    
36. //输入数据在CLK的低电平变化，在CLK的高电平被传输。
    
37. //每传输一个字节，芯片内部在第八个时钟下降沿产生一个ACK
    ' O$ S$ _* C1 S1 c- Z; ~) ?
38. // 写一个字节
    1 u3 h6 D. q# E" @' u) b
39. void TM1637_WriteByte( unsigned char oneByte )
    
40. {
    , N$ H1 a' {+ u1 [+ I
41.     unsigned char i;
    
42.     TM1637_DIO_OUT();
    3 |1 X# F1 n% L: g
43.     for( i = 0; i < 8; i++ )
    
44.     {
    
45.         TM1637_CLK = 0;
    
46.         if( oneByte & 0x01 )                                                                        //低位在前
    ( m$ }/ g% V2 i$ J
47.         {
    
48.             TM1637_DIO = 1;
    
49.         }
    2 O; j/ y9 L4 x6 \: C( P
50.         else
    
51.         {
    
52.             TM1637_DIO = 0;
    
53.         }
    : |( R( X- f1 J: p6 }3 Y' w
54.         delay_us( 3 );
    
55.         oneByte = oneByte >> 1;
    , c8 k5 \7 l- v
56.         TM1637_CLK = 1;
    # o" m  R0 [: i2 U( O& q# I
57.         delay_us( 3 );
    
58.     }
    + O% B) u& _9 s$ [, G4 k9 G, H: b
59. }
    ' ~/ t7 U+ q. z0 a+ l$ l; M

复制代码

, h3 x" m5 h& C; P) p& E7 o) S         需要用到的时序主要有开始位、停止位、等待应答位、写一个字节。通过上面这四个函数就可以直接操作TM1637芯片了。

          根据官方的资料，有两种写数据的方式，第一种是地址自加，第二种是地址固定。先来实现地址自加的模式。



        根据这个时序看，首先要发送起始位，接着发送设置数据命令，下来等待应答，最后发送停止位。下来在发送起始位、设置地址命令、等待应答，发送显示数据1、等待应答、发送显示数据2，等待应答，……发送显示数据N、等待应答、停止位、起始位、发送显示命令、等待应答、停止位。
% B" o" K, o$ R0 V* k
       下面看看官方的命令表



/ c2 h: t3 ], z        根据上面命令表可以看出，数据命令中，自动地址增加命令 B6为1，其他的都为0。也就是0x40就是地址自增命令。接下来看地址命令，显示地址从00---05表示6个数码管的地址，此时B7和B6必须为1，也就是显示地址范围是0xC0-----0xC5。最后是显示控制，这个命令是控制开关显示和亮度的。开显示需要B7和B3为1，也就是0x88,最后3位0--7表示8级亮度。这样显示控制的值的范围就是0x88-----0x8F。

* ^( V8 b4 S; E8 e8 a7 r9 m         命令分析完之后就可以编写代码了

1. //写显示寄存器  地址自增
   
2. void TM1637_Display_INC( void )
   
3. {
   2 C1 F# u+ T' T
4.     unsigned char i;
   3 T9 R7 n: N0 g4 z$ l) V
5.     TM1637_Start();
   + E4 `" f5 x% x8 |% u  M1 Q
6.     TM1637_WriteByte( 0x40 );                                                                        //写数据到显示寄存器 40H 地址自动加1 模式,44H 固定地址模式,本程序采用自加1模式
   & ~4 X# D! N0 ]# Q
7.     TM1637_Ack();
   ' @8 {  o6 c5 {3 o  _
8.     TM1637_Stop();
   
9. 
   4 ]) N- D; w' A% a7 p
10.     TM1637_Start();
    : S6 b1 x5 e, m5 ^
11.     TM1637_WriteByte( 0xC0 );                                                                        //地址命令设置 显示地址 00H
    
12.     TM1637_Ack();
    * w) X0 y0 _' g/ k
13. 
    
14.     for( i = 0; i < 6; i++ )                                                                        //地址自加，不必每次都写地址
    / [: t5 g( X9 s0 ]* X
15.     {
      F) E0 r0 |- F% ]  N2 E" T6 v; I
16.         TM1637_WriteByte( disp_num);                        //发送数据   disp_num[]中存储6个数码管要显示的内容
    
17.         TM1637_Ack();
    " g8 \6 U- B/ `8 R( b; B) X9 e7 |; c
18.     }
    
19.     TM1637_Stop();
    
20. 
    
21.     TM1637_Start();
    
22.     TM1637_WriteByte( 0x88 | 0x07 );                                        //开显示，最大亮度-----调节脉冲宽度控制0---7  脉冲宽度14/16
    
23.     TM1637_Ack();
    
24.     TM1637_Stop();
    
25. 
    ! D1 w- S# p; g+ n9 x0 F4 p
26. }

复制代码

9 c, Y$ c- E2 O* U/ Y: [) G        发送数据显示命令和显示亮度命令时都需要停止位，但是发送地址命令和显示数据内容时，是不需要停止位的，可以连续发送。数据循环发送结束后再发送停止位就行。其中 disp_num[]数组中依次存放6个数码管需要显示的内容。这样如下需要改变哪个数码管显示的内容是，只需要给disp_num[]数组中的对应位置重新赋值就行。
1 U1 m, w4 C" s* Y+ D' A3 r( {
0 x. ^/ r, W3 Y2 A      下面编写地址固定的写数据模式
/ M* C5 K& l, o  F/ Y
: `" ^/ `& P# B; C( U& l

1 l- S5 e7 K# @6 S$ h     时序和上面地址自增的基本一样，只是设置数据的命令不同，根据上面的命令表格可以看出，地址固定命令B6和B2都为1，也就是0x44。  

$ [+ h) t! t6 y* p* p5 ~- w

1. //写显示寄存器  地址不自增
   # g) \* O8 m. q+ e
2. // add 数码管的地址 0--5
   * {7 o, l; m; b7 J$ n2 l, l- K
3. // value 要显示的内容
   
4. void TM1637_Display_NoINC( unsigned char add, unsigned char value )
   
5. {
   
6.     unsigned char i;
   
7.     TM1637_Start();
   , A5 l7 i5 J4 a8 k# j1 P( ]0 U
8.     TM1637_WriteByte( 0x44 );                                                                //写数据到显示寄存器 40H 地址自动加1 模式,44H 固定地址模式,本程序采用自加1模式
   
9.     TM1637_Ack();
   
10.     TM1637_Stop();
    
11. 
    
12.     TM1637_Start();
    + Z, Q  `$ y$ K
13.     TM1637_WriteByte( 0xC0 | add );                                        //地址命令设置 显示地址 C0H---C5H
    $ t  r( j# r) I. |; W' J* e
14.     TM1637_Ack();
    
15. 
    ( Z% I6 j/ v6 E- L  s) k0 w) F
16.     TM1637_WriteByte( value );                                                         //发送数据   value存储要显示的内容
    4 z3 l+ `6 ~0 O- p7 l* T# |$ {
17.     TM1637_Ack();
      V! R; `# D  i8 K0 ^3 ^
18.     TM1637_Stop();
    : X/ e+ r2 r! r! G
19. 
    
20.     TM1637_Start();
    2 G" y* a* l7 V5 J1 M
21.     TM1637_WriteByte( 0x88 | 0x07 );                                                        //开显示，最大亮度-----调节脉冲宽度控制0---7  脉冲宽度14/16
    4 I% }6 w" q6 z* `( G
22.     TM1637_Ack();
    0 o* u" J6 t- Q& H+ {0 F- D9 y
23.     TM1637_Stop();
    
24. }

复制代码

      地址固定模式每次只写一个固定的地址，地址值是由低三位值控制的，所以这里将高5位的值固定不变，只需要将低3位的值和高5位的值进行位或运算就行。这样在传递地址参数的时候，只需要发送0--5就可以了。同样亮度的设置也是用这个方法，亮度值由低3位值决定，将低3位值和高5位值进行位或运算。设置亮度的时候直接发送0--7就行。这里亮度没有使用参数，直接使用的是定值。想要改变亮度，可以把亮度也设置为参数传递进来。
3 K5 V7 k" a4 ]* F) M. O$ ]9 j) @
9 l: o$ e" `8 C8 p" d      到这里就可以直接调用这两个函数，控制数码管显示了。
6 W% h! d& F# ~) y% g2 E& [
- ?  e, b1 q6 n- x! \" {$ _) K为了方便查看代码，下面贴出完整代码TM1637.c完整代码
7 ^; X- K, t1 n0 F. O* f
$ ~' H% Q% A: n# P2 [+ \0 e1 ?

1. #include "TM1637.h"
   2 T7 c4 l  h$ J
2. #include "bsp_SysTick.h"
   3 f2 _+ m% g; X
3. 
   8 T+ z6 ~9 S6 S2 G- \
4. unsigned char tab[] =
   
5. {
   
6.     0x3F,/*0*/
   
7.     0x06,/*1*/
   / W4 K8 \' B/ w3 y
8.     0x5B,/*2*/
   
9.     0x4F,/*3*/
   4 L( t6 [- y) E& U$ m6 j% x
10.     0x66,/*4*/
    " \1 d+ a8 _. }' u8 W+ L  Y
11.     0x6D,/*5*/
    
12.     0x7D,/*6*/
    
13.     0x07,/*7*/
    
14.     0x7F,/*8*/
    6 F" m/ L  u( H+ s
15.     0x6F,/*9*/
    
16.     0x77,/*10 A*/
    ' ^) m0 U0 S1 d$ |- z4 f
17.     0x7C,/*11 b*/
    ) `: g& c8 h" L1 a
18.     0x58,/*12 c*/
    % M& v9 H4 u) z
19.     0x5E,/*13 d*/
    $ Y9 d, N6 N1 {% ~$ O
20.     0x79,/*14 E*/
    8 Q8 S/ ^) o( H: h  q. C+ |! Y- Q" g
21.     0x71,/*15 F*/
    
22.     0x76,/*16 H*/
    ( C3 z; b8 Z! y, I4 H5 T. n) M7 x, A; D
23.     0x38,/*17 L*/
    ( D+ w0 t# u% b
24.     0x54,/*18 n*/
    * A7 }1 m* H. ]* v% N
25.     0x73,/*19 P*/
    4 S) \. {& S+ x' c# H6 l
26.     0x3E,/*20 U*/
    
27.     0x00,/*21 黑屏*/
    * X5 Y/ m3 |$ o( X
28. };
    
29. 
    % P' X0 j( Q  p0 _- e. P
30. // 最高位设置为1时显示 数码管上的":" 符号
    ! M9 |6 W9 W+ E
31. unsigned char disp_num[] = {0x3F, 0x06 | 0x80, 0x5B, 0x4F, 0x66, 0x6D};                        //存放6个数码管要显示的内容
    
32. 
    + w& n2 K6 q1 U' k6 L
33. //端口初始化
    
34. void TM1637_Init( void )
    / P6 c3 F  w9 \
35. {
    
36. 
    
37.     GPIO_InitTypeDef  GPIO_InitStructure;
    
38. 
    
39.     RCC_APB2PeriphClockCmd( TM1637_CLK_GPIO_CLK | TM1637_DIO_GPIO_CLK, ENABLE );
    
40. 
    % j8 ?1 d$ ~# n8 O3 r
41.     GPIO_InitStructure.GPIO_Pin = TM1637_CLK_GPIO_PIN | TM1637_DIO_GPIO_PIN;
    2 Z7 c! q: q/ O* e
42.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    
43.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    7 O/ ~7 H" b- @  t2 J- {% q- `8 @
44.     GPIO_Init( TM1637_CLK_GPIO_PORT, &GPIO_InitStructure );
    
45. }
    
46. 
    / W7 j+ W$ Z8 k/ V7 r6 x# M
47. //起始位 CLK为高电平时，DIO由高变低
    3 J; v* E. w8 r
48. void TM1637_Start( void )
    
49. {
    ; a* w3 b' p) R0 t+ z5 q4 z# [6 C
50.     TM1637_DIO_OUT();
    6 P4 l. A/ s9 ~0 T* y
51.     TM1637_CLK = 1;
    - Q& H" q5 C" c0 T' T  v8 p6 f
52.     TM1637_DIO = 1;
    
53.     delay_us( 2 );
    
54.     TM1637_DIO = 0;
    1 t# C5 W# `/ R: |
55. }
    
56. 
    
57. //等待应答 传输数据正确时，在第八个时钟下降沿，芯片内部会产生一个ACK信号，将DIO管脚拉低，在第九个时钟结束之后释放DIO总线。
    9 ^5 Q% A# p& |+ A
58. void TM1637_Ack( void )
    
59. {
    
60.     TM1637_DIO_IN();
    
61.     TM1637_CLK = 0;
    8 H3 Z; J1 ~6 ^) p' q# |. F
62.     delay_us( 5 );                                                                                                        //在第八个时钟下降沿之后延时 5us，开始判断 ACK 信号
    1 m% Y  [5 o$ e  q* e/ i  a1 m# j) f
63.     while( TM1637_READ_DIO );                                                                //等待应答位  这一行代码也可以不要 不影响实际使用效果 在使用软件仿真的时候需要屏蔽这句代码，否则程序就会卡在这里。
    # E$ t5 i$ u2 G
64.     TM1637_CLK = 1;
    
65.     delay_us( 2 );
    ( Q  G/ B5 y4 h- d
66.     TM1637_CLK = 0;
    
67. }
    - E8 I1 O# ~& W' Y
68. 
    
69. //停止位 CLK为高电平时，DIO由低变高
    
70. void TM1637_Stop( void )
    
71. {
    
72.     TM1637_DIO_OUT();
    
73.     TM1637_CLK = 0;
    
74.     delay_us( 2 );
    
75.     TM1637_DIO = 0;
    5 Q7 _5 L+ y/ \$ g( e7 B
76.     delay_us( 2 );
    * e) [5 u% A/ i' H& r4 z
77.     TM1637_CLK = 1;
    
78.     delay_us( 2 );
    
79.     TM1637_DIO = 1;
    
80. }
    
81. //输入数据在CLK的低电平变化，在CLK的高电平被传输。
    " I- ~. ~( a: N7 u: J9 H+ G
82. //每传输一个字节，芯片内部在第八个时钟下降沿产生一个ACK
    
83. // 写一个字节
    
84. void TM1637_WriteByte( unsigned char oneByte )
    / ]' N/ ]& A% M$ r. P& k' J
85. {
    # J+ F1 w+ o* x" X0 W4 F
86.     unsigned char i;
    7 M/ u; k% W* w3 |
87.     TM1637_DIO_OUT();
    $ @! ^, n1 d% Q0 K  m. P6 h. p$ Z
88.     for( i = 0; i < 8; i++ )
    2 N. m' j! t, w5 V' o
89.     {
    * p& X3 L& i9 v0 M' E& V$ [& _% n
90.         TM1637_CLK = 0;
    8 X: n' {* N, s1 l. k
91.         if( oneByte & 0x01 )                                                                        //低位在前
    
92.         {
    
93.             TM1637_DIO = 1;
    
94.         }
    
95.         else
    
96.         {
    ) z5 r3 a$ I- ^
97.             TM1637_DIO = 0;
    * T. |8 l6 @  q2 }5 f! A' ?% o- P1 c8 a
98.         }
    
99.         delay_us( 3 );
    7 _3 _7 K' l2 ~+ [
100.         oneByte = oneByte >> 1;
     
101.         TM1637_CLK = 1;
     , V( g* M. h9 u7 M: o' C
102.         delay_us( 3 );
     ) L1 Q. }( t; G9 P1 d
103.     }
     / n- f1 q  W# J, k6 b
104. }
     + M6 w; G* X2 e4 h% x
105. 
     5 {1 ?, \( r' _4 F* J8 h
106. //写显示寄存器  地址自增
     + C* g" |: D$ }. a' A
107. void TM1637_Display_INC( void )
     
108. {
     $ g5 R0 K/ e5 M+ E& ^
109.     unsigned char i;
     9 r& J4 {7 ^" E+ a
110.     TM1637_Start();
     # `" f3 s" |- O+ n0 q9 E8 r% U
111.     TM1637_WriteByte( 0x40 );                                                                        //写数据到显示寄存器 40H 地址自动加1 模式,44H 固定地址模式,本程序采用自加1模式
     9 T4 J6 L' i% @7 w+ d' |( T6 ^' m  j
112.     TM1637_Ack();
     
113.     TM1637_Stop();
     
114.     TM1637_Start();
     1 n9 x7 \3 o( ]7 w+ }9 E8 Y
115.     TM1637_WriteByte( 0xC0 );                                                                        //地址命令设置 显示地址 00H
     
116.     TM1637_Ack();
     
117. 
     , w0 g: b# L  ?! Y
118.     for( i = 0; i < 6; i++ )                                                                        //地址自加，不必每次都写地址
     
119.     {
     
120. TM1637_WriteByte( disp_num );                        //发送数据   disp_num[]中存储6个数码管要显示的内容
     
121.         TM1637_Ack();
     ( I7 l% {$ m! h$ u
122.     }
     
123.     TM1637_Stop();
     6 a1 t1 _7 f) S4 F. D0 @" R
124. #if 0
     1 B; L: d: Y! H" @0 p* ^  t: _
125.     TM1637_Start();
     
126.     TM1637_WriteByte( 0x88 | 0x07 );                                        //开显示，最大亮度-----调节脉冲宽度控制0---7  脉冲宽度14/16
     : h3 g2 X8 Y" p0 H- D: X
127.     TM1637_Ack();
     1 p$ f6 ^. ~: K: ^  ?' w+ B  u+ L6 n5 ?
128.     TM1637_Stop();
     
129. #endif
     8 W. [! b1 c8 ~; A+ @
130. }
     
131. 
     2 o2 {3 T; L4 W8 e" H3 L# K' g4 {
132. //写显示寄存器  地址不自增
     / H" d; }- L0 |7 B9 g# S, h
133. // add 数码管的地址 0--5
     
134. // value 要显示的内容
     + U7 k6 W$ O' j; \2 L) {3 I+ i
135. void TM1637_Display_NoINC( unsigned char add, unsigned char value )
     
136. {
     
137.     unsigned char i;
     
138.     TM1637_Start();
     
139.     TM1637_WriteByte( 0x44 );                                                                //写数据到显示寄存器 40H 地址自动加1 模式,44H 固定地址模式,本程序采用自加1模式
     ) K/ j! z8 V5 \% d
140.     TM1637_Ack();
     6 A1 Q& Z5 T" f5 `
141.     TM1637_Stop();
     
142. 
     8 e! g. e) o) m* t  f
143.     TM1637_Start();
     6 Q) w! z9 M; n+ L( c0 h8 R, A4 R' }
144.     TM1637_WriteByte( 0xC0 | add );                                        //地址命令设置 显示地址 C0H---C5H
     , q; D  p9 |7 J+ M( x" _) B
145.     TM1637_Ack();
     ; N* b. U% {0 ^$ Z
146. 
     6 h! H  F" b! M6 y9 l9 M) `
147.     TM1637_WriteByte( value );                                                         //发送数据   value存储要显示的内容
     2 F, v0 `& h' p
148.     TM1637_Ack();
     
149.     TM1637_Stop();
     
150. #if 0
     
151.     TM1637_Start();
     
152.     TM1637_WriteByte( 0x88 | 0x07 );                                                        //开显示，最大亮度-----调节脉冲宽度控制0---7  脉冲宽度14/16
       w9 d% ~0 n, ^6 U8 x/ j
153.     TM1637_Ack();
     
154.     TM1637_Stop();
     
155. #endif
     
156. }
     
157. 
     7 k! G7 `9 h! x, F$ F5 a9 E* Q# e
158. // level : 设置亮度等级  0---7
     
159. void TM1637_SetBrightness( unsigned char level )
     % s0 q- @( V4 L- N" {* G
160. {
     
161.     TM1637_Start();
     
162.     TM1637_WriteByte( 0x88 | level );                                                        //开显示，最大亮度-----调节脉冲宽度控制0---7  脉冲宽度14/16
     
163.     TM1637_Ack();
     
164.     TM1637_Stop();
     
165. }
       a4 \; q. {" i
166. 
     
167. 
     0 x/ P& u: f$ r; l* ]( l1 T
168. 
     6 V0 L7 s' t9 b4 E5 B
169. 
     
170. //读按键  读按键时，时钟频率应小于 250K，先读低位，后读高位。
     , ~3 i1 j$ N. q3 |( r/ G
171. unsigned char TM1637_ScanKey( void )
     
172. {
     & u$ B1 v! K" g/ l1 I2 `
173.     unsigned char reKey, i;
     
174.     TM1637_Start();
     
175.     TM1637_WriteByte( 0x42 );                                                //读键扫数据
     9 B9 e  c& r" W2 C
176.     TM1637_Ack();
     
177.     TM1637_DIO = 1;                                                                                        //在读按键之前拉高数据线
     / }9 `& X# N" U, s
178.     TM1637_DIO_IN();
     
179.     for( i = 0; i < 8; i++ )                                                //从低位开始读
     ; v% `  V+ [8 _/ R: N2 }
180.     {
     - w, L. Y0 p! S; \: J& h" |) {
181.         TM1637_CLK = 0;
     8 y* ~$ e' o% E; @8 Q! _
182.         reKey = reKey >> 1;
     7 y' @" x2 z7 |( v0 k' O
183.         delay_us( 30 );
     
184.         TM1637_CLK = 1;
     2 t6 C, p) t5 w8 s& E
185.         if( TM1637_READ_DIO )
     $ z% ^9 X. g* B# E  [% Q, m* g
186.         {
     
187.             reKey = reKey | 0x80;
     
188.         }
     # `: [  l; S. q
189.         else
     , O6 Q# e2 F' f/ w6 f% I
190.         {
     
191.             reKey = reKey | 0x00;
     
192.         }
     6 U  V. r) A, I
193.         delay_us( 30 );
       b& I! ?6 v. L4 I
194.     }
     
195.     TM1637_Ack();
     7 I& z$ }$ q; D4 K
196.     TM1637_Stop();
     4 w. q% E- p8 X8 o& E
197.     return( reKey );
     " ~, k1 q# W" P' O
198. }
     % c3 d# @$ |: `
199. 
     : V. v$ c2 Y. _& W
200. 
     
201. //按键处理函数，按键数据低位在前高位在后
     8 A  z0 W6 \% d
202. unsigned char TM1637_KeyProcess( void )
     & h9 e6 R7 N  s' r
203. {
     : ^0 f) Y( {# e: ^3 _
204.     unsigned char temp;
     
205.     unsigned char keyNum = 0;
     5 s; ~5 V8 G. W) J% X9 O& i0 d" s; P
206.     temp = TM1637_ScanKey();                                 //读取按键返回值
     . O/ B1 _, H* @' G- C3 j, R7 t
207.     if( temp != 0xff )
     
208.     {
     + O9 @! ]6 J: q& T$ z
209.         switch( temp )
     . i% D; n! Y9 C4 C
210.         {
     
211.         case 0xf7 :                                                        //K1与SG1对应按键按下
     
212.             keyNum = 1;
     
213.             break;
     ; [/ \- J& p2 v  @% }6 `' Q, G
214.         case 0xf6 :                                                         //K1与SG2对应按键按下
     * e4 O6 L! T2 j( v) _. n" d; I& ?
215.             keyNum = 2;
     
216.             break;
     / B) ~0 ^/ G0 ~  t
217.         case 0xf5 :                                                        //K1与SG3对应按键按下
     
218.             keyNum = 3;
     
219.             break;
     , {3 E8 i. X) \% J! t# W
220.         case 0xf4 :                                                        //K1与SG4对应按键按下
     
221.             keyNum = 4;
     ' R' [$ O( y3 G/ }
222.             break;
     0 J5 b  ?6 N- W4 _% \
223.         case 0xf3 :                                                        //K1与SG5对应按键按下
     
224.             keyNum = 5;
     
225.             break;
       A& N7 G: ^& L: C7 i. D7 s
226.         case 0xf2 :                                                         //K1与SG6对应按键按下
     
227.             keyNum = 6;
     : A  D3 s0 c0 ^
228.             break;
     , @5 _, ?- S3 M% e- O  p# ]
229.         case 0xf1 :                                                        //K1与SG7对应按键按下
     
230.             keyNum = 7;
     ' }$ U: z/ o. X3 ]$ ^7 W
231.             break;
     
232.         case 0xf0 :                                                        //K1与SG8对应按键按下
     
233.             keyNum = 8;
     
234.             break;
     2 G* [$ g# W% S, W
235. 
     
236.         case 0xef :                                                         //K2与SG1对应按键按下
     
237.             keyNum = 9;
     ( C- E3 C3 |# c( a! r& V" M
238.             break;
     
239.         case 0xee :                                                        //K2与SG2对应按键按下
     
240.             keyNum = 10;
     
241.             break;
     " o/ \& _' c1 q& m0 d# H
242.         case 0xed :                                                        //K2与SG3对应按键按下
     
243.             keyNum = 11;
     
244.             break;
     ( ]) y, c* c1 J' N3 B6 m
245.         case 0xec :                                                         //K2与SG4对应按键按下
     
246.             keyNum = 12;
     " D0 I9 k& h5 ]1 W: m5 u5 I
247.             break;
     
248.         case 0xeb :                                                        //K2与SG5对应按键按下
     
249.             keyNum = 13;
     
250.             break;
     
251.         case 0xea :                                                        //K2与SG6对应按键按下
     
252.             keyNum = 14;
     
253.             break;
     
254.         case 0xe9 :                                                        //K2与SG7对应按键按下
     
255.             keyNum = 15;
     
256.             break;
     . y/ _4 D  V6 ~: v3 m, B& S6 @3 B% x
257.         case 0xe8 :                                                        //K2与SG8对应按键按下
     
258.             keyNum = 16;
     4 F* P9 b6 b! M5 E2 T
259.             break;
     
260.         default   :
     
261.             keyNum = 0;
     
262.             break;
     , n; P) B" _; ~( O/ G6 `
263.         }
     8 Y6 e! `% r5 ]- j
264.     }
     - C* @& m/ q* L& }7 K# \
265.     return keyNum;
     
266. }

复制代码

" G6 A5 A6 R; F! L下面是主函数代码
: }' [. N2 o4 M- Y, o9 x4 O

1. #include "stm32f10x.h"
   
2. #include "bsp_led.h"
   
3. #include "bsp_SysTick.h"
   9 q8 t. s$ S& v
4. #include "TM1637.h"
   
5. 
   9 P1 B% W. n9 B! k1 Y5 K7 a
6. int main( void )
   2 K7 C" l) s& F( Q8 y
7. {
   
8.     u8 flag_s = 0;
   
9.     NVIC_PriorityGroupConfig( NVIC_PriorityGroup_2 );
   8 j( ~. J! Z6 s
10.     LED_GPIO_Config();
    
11.     TM1637_Init();
    : y. U1 W, @+ b; S* S6 y. T$ Z
12. 
    
13. //    delay_config();                                                //使用方法二延时的时候调用
    ' B" G. W) Z  |% ~" z7 ?+ q
14. 
    
15.     while ( 1 )
    
16.     {
    
17. #if 1
    ; F. ?$ d* Q- P( a- N6 U+ d
18.         LED1( ON );
    , P5 [2 @5 Y3 c& c, `: z6 ]
19.         delay_ms( 1000 );
    
20.         LED1( OFF );
    3 \; ?8 D9 ^( M) f
21. 
    
22.         flag_s = ~flag_s;
    6 p4 }0 ]- j( C1 h6 O
23.         disp_num[0] = tab[0];
    ! A6 v& }0 F, F5 @3 |! K
24.         if( flag_s )
    
25.                                         disp_num[1] = tab[1] | 0x80;                                //最高位设置为1 显示":"
    + g" h" V: \7 i3 O/ R8 _
26.         else
    7 t+ |0 r: l& A. \/ S& V1 H( [: O. T/ {
27.             disp_num[1] = tab[1];
    
28.         disp_num[2] = tab[2];
    
29.         disp_num[3] = tab[3];
    1 ?* f3 Z. R" O  Z9 c
30.         TM1637_Display_INC();
    
31.         TM1637_SetBrightness( 3 );                                        //设置亮度等级 0---7
    
32. 
    
33. #else                        //延时精确测试代码
    2 t8 e, [! q4 m3 C% }
34. 
    2 l* j  M. d7 B9 k, I; X% @/ u6 V
35.         LED1_ON;
    
36.         delay_us( 1 );
    
37.         LED1_OFF;
    7 l7 V6 U) e0 @; K% Q
38.         delay_us( 1 );
    8 [* f9 L/ @7 k! A: a1 V- Z0 W
39. 
    ) U! j+ f! w% b
40. #endif
    
41.     }
    
42. 
    2 B1 |! F1 h( X# g$ P/ k! K( O4 q
43. }
    ) B4 T5 y1 f  c1 `. @$ p8 r

复制代码

" R3 d0 ]; g1 t       主函数中设置四个数码管依次显示0、1、2、3，冒号是在第二个数码管的dp引脚接着，dp为最高位，所以给最高位写1就可以点亮时钟的冒号。通过一个标志位控制冒号1秒钟闪烁一次。
# g3 w/ k  Y0 J7 e  {: E