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

使用的单片机是STM32F103C8T6最小系统


, t6 J( b7 a- M8 N; O# G' H( V
     使用的数码管模块是TM1637四位数码管显示模块
2 D& ?2 B, D( O& P, e' E& Y

7 R5 ~; z2 `- W8 f) |
9 ]) L* C3 D. P) j4 \实际运行效果
4 B: [8 Q3 R) N$ l* U  j# l1 k

9 S* P$ \. Q- y  t/ @8 l
% N" l, D: D- H- x下面先看一下TM1637和数码管连接的具体线路图

6 k9 w' Q; R8 b$ ~* J9 F% I& o

        实际使用的模块没有带按键，只用了4个数码管，模块和单片机连接只需要4根线VCC、GND、CLK、DIO。芯片和单片机通信使用的是I2C总线，下面就来说一下如何通过I2C总线驱动这个数码管模块。
  D6 H2 m. O8 u) T" V
' T1 t  h0 u9 P- o+ V        为了方便移植，这里使用 IO口模拟I2C总线，所以首先要将延时函数准备好，延时函数使用任何一种方式都可以，可以根据自己的习惯使用自己的延时函数。
( B2 S, I9 B2 N% N2 v+ [" M4 t! E5 \: Z
) z" Y4 p2 r1 W0 |4 J5 D& {

1. /*
   0 |- @! }: ]$ Z. [' Z/ O* |& T( U
2. * t : 定时时间
   ( G4 E7 Y* U4 @8 P5 [" {
3. * Ticks : 多少个时钟周期产生一次中断
   
4. * f : 时钟频率 72000000
   
5. * t = Ticks * 1/f = (72000000/1000000) * (1/72000000) = 1us
   
6. */
   , l( ?( c; \( u- u0 t
7. 
   
8. void SysTick_Delay_Us( __IO uint32_t us )
   
9. {
     P+ I% U, n& z* s" u
10.     uint32_t i;
    & S1 ~& d8 ^7 j4 G1 J" P4 r! R/ {
11.     SysTick_Config( SystemCoreClock / 1000000 );
    * d" e) ?: R  j' L" j
12. 
    
13.     for( i = 0; i < us; i++ )
    8 f: x) q- J0 e+ q, e/ ~
14.     {
    - O. R7 H- w) S
15.         // 当计数器的值减小到0的时候，CRTL寄存器的位16会置1
    
16.         while( !( ( SysTick->CTRL ) & ( 1 << 16 ) ) );
    
17.     }
    
18.     // 关闭SysTick定时器
    2 N' v. b0 O6 O8 h  P8 N) o, Z- D
19.     SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;
    + q! A$ Z# p* A& Q
20. }
    
21. 
    
22. void SysTick_Delay_Ms( __IO uint32_t ms )
    
23. {
    
24.     uint32_t i;
    
25.     SysTick_Config( SystemCoreClock / 1000 );
    
26. 
    
27.     for( i = 0; i < ms; i++ )
    
28.     {
    1 p" v% }. @3 W( ~- F! p
29.         // 当计数器的值减小到0的时候，CRTL寄存器的位16会置1
    # z6 w! ~# @) d' B* W. B. v
30.         // 当置1时，读取该位会清0
    . C! r5 @# s* q* \
31.         while( !( ( SysTick->CTRL ) & ( 1 << 16 ) ) );
    8 ^" \# B% s+ E: w  d% v& B
32.     }
    7 {8 U( N  C5 X( }- l, d
33.     // 关闭SysTick定时器
    
34.     SysTick->CTRL &= ~ SysTick_CTRL_ENABLE_Msk;
    
35. }
    

复制代码

# G& x& j2 r  E( f; R+ f3 T        这里直接读取系统定时器的标志位来进行延时，设置系统定时器1us中断一次。直接判断系统的中断次数就可以实现us级的延时了。

" v: i( p$ n6 C0 u      下来就需要编写I2C的时序了，官方资料上也提提供了参考代码，这个代码也是参考官方代码修改的。

$ s7 I( {. ]' Z; w& M, a, ]# d8 W      首先要定义需要用到的IO口，为了方便移植，将所用到的IO口直接在头文件中定义，需要更改IO口的时候，只需要在头文件中修改就行。

1. /* 定义IIC连接的GPIO端口, 用户只需要修改下面的代码即可改变控制的LED引脚 */
   
2. #define TM1637_CLK_GPIO_PORT            GPIOB                                /* GPIO端口 */
   , r5 ~; Q1 A& A4 [5 V
3. #define TM1637_CLK_GPIO_CLK             RCC_APB2Periph_GPIOB                /* GPIO端口时钟 */
   % {+ |8 A& n  r0 V- `, ~
4. #define TM1637_CLK_GPIO_PIN                          GPIO_Pin_6
   ( g# }) u8 w' h$ z
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

复制代码

9 c) N! |2 w/ \% F) y在模拟时序的时候为了方便编写代码，将用到的时钟口和数据口也重新定义。
# C0 w- ^0 Q+ y7 `

1. //使用 位带 操作
   
2. #define TM1637_CLK           PBout(6)
   
3. #define TM1637_DIO           PBout(7)
   
4. #define TM1637_READ_DIO      PBin(7)
   8 d% O. d" A5 w2 ~
5. 
   
6. //IO方向设置                                                                                   0011输出模式   1000上下拉输入模式
   4 c  S. ^: P! {( `% @  \  Z
7. #define TM1637_DIO_IN()      {GPIOB->CRL&=0X0FFFFFFF;GPIOB->CRL|=(u32)8<<28;}
   6 T9 r! v! @# Q8 N  Z: M
8. #define TM1637_DIO_OUT()     {GPIOB->CRL&=0X0FFFFFFF;GPIOB->CRL|=(u32)3<<28;}

复制代码

  q* e, ^2 }  P  _% }* |) U+ {下来需要初始化 IO口
( l' S3 B2 j0 Y" Q2 O2 M
: u6 G( v, d: B9 z! D' h

1. //端口初始化
   
2. void TM1637_Init( void )
   5 J" ~+ S3 u/ j! I- |
3. {
   3 X% ~* }/ }" s' j# T/ o
4.     GPIO_InitTypeDef  GPIO_InitStructure;
   
5. 
   2 P/ C9 x0 {0 @) I
6.     RCC_APB2PeriphClockCmd( TM1637_CLK_GPIO_CLK | TM1637_DIO_GPIO_CLK, ENABLE );
   , K! N, `+ n9 Q) o- ]3 |6 D: |1 l8 a
7. 
   
8.     GPIO_InitStructure.GPIO_Pin = TM1637_CLK_GPIO_PIN | TM1637_DIO_GPIO_PIN;
   
9.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
   - l6 o6 p* z- k: U8 L: O+ F
10.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    5 a; J! U9 c/ M% V% n
11.     GPIO_Init( TM1637_CLK_GPIO_PORT, &GPIO_InitStructure );
    
12. }

复制代码

* H0 f) J+ M: A7 P下来模拟I2C的时序

1. 
   
2. //起始位 CLK为高电平时，DIO由高变低
   
3. void TM1637_Start( void )
   6 x+ g2 |, m$ q
4. {
   
5.     TM1637_DIO_OUT();
   
6.     TM1637_CLK = 1;
   
7.     TM1637_DIO = 1;
   ) ?+ H* _% ?' f5 U) V6 D# ~
8.     delay_us( 2 );
   ' l9 b' M9 K  r& {2 f! o& l
9.     TM1637_DIO = 0;
   - P! ?' J- R$ r' B+ s- x6 M
10. }
    
11. 
    
12. //等待应答 传输数据正确时，在第八个时钟下降沿，芯片内部会产生一个ACK信号，将DIO管脚拉低，在第九个时钟结束之后释放DIO总线。
    8 k& n8 X6 g& `# F" o0 z  @4 Q
13. void TM1637_Ack( void )
    
14. {
    % ?5 i% J# V! N/ t
15.     TM1637_DIO_IN();
    
16.     TM1637_CLK = 0;
    
17.     delay_us( 5 );                                                                                                        //在第八个时钟下降沿之后延时 5us，开始判断 ACK 信号
    
18.     while( TM1637_READ_DIO );                                                                //等待应答位  这一行代码也可以不要 不影响实际使用效果 在使用软件仿真的时候需要屏蔽这句代码，否则程序就会卡在这里。
    7 ~9 @, T9 H: U/ G8 f3 D8 R
19.     TM1637_CLK = 1;
    ( k0 K2 B( n; J/ d" l3 m
20.     delay_us( 2 );
    
21.     TM1637_CLK = 0;
    8 D! V9 p1 \3 M% {
22. }
    
23. 
    + [! k9 N3 O' f9 u& N2 d% |* F
24. //停止位 CLK为高电平时，DIO由低变高
    ( R' m  C/ {! I
25. void TM1637_Stop( void )
    4 L. b. G5 ^" ^# ~$ c- m
26. {
    
27.     TM1637_DIO_OUT();
    . Y% R/ E  J# h6 R. R
28.     TM1637_CLK = 0;
    
29.     delay_us( 2 );
    
30.     TM1637_DIO = 0;
    & {# |6 u/ C' v) @  V
31.     delay_us( 2 );
    ) n6 l, w9 {2 |
32.     TM1637_CLK = 1;
    6 S8 s, J. ^5 r2 d6 i
33.     delay_us( 2 );
    
34.     TM1637_DIO = 1;
    
35. }
    2 p$ P2 K1 j2 a; |( t5 W6 Y
36. //输入数据在CLK的低电平变化，在CLK的高电平被传输。
    
37. //每传输一个字节，芯片内部在第八个时钟下降沿产生一个ACK
    ; I' d- Q- B1 @* v: r9 _$ t; X0 B
38. // 写一个字节
    
39. void TM1637_WriteByte( unsigned char oneByte )
    + R+ I; q( _- H. k0 h
40. {
    
41.     unsigned char i;
    ( W1 g0 d7 W1 F6 i8 g
42.     TM1637_DIO_OUT();
    
43.     for( i = 0; i < 8; i++ )
    8 x' ]3 E% G) t  i. [' |
44.     {
    
45.         TM1637_CLK = 0;
    - q" _+ C7 l4 P1 z) U
46.         if( oneByte & 0x01 )                                                                        //低位在前
    # [% z" f/ g2 V+ f; M# l1 z
47.         {
    
48.             TM1637_DIO = 1;
    
49.         }
    
50.         else
    
51.         {
    
52.             TM1637_DIO = 0;
    9 P7 b8 `: f3 i* X  }1 \
53.         }
    
54.         delay_us( 3 );
    
55.         oneByte = oneByte >> 1;
    & A2 r6 R  _+ z% l8 N; \
56.         TM1637_CLK = 1;
    , P" s# j' U2 B/ I5 G
57.         delay_us( 3 );
    1 _. K% M7 c/ H# ?* S
58.     }
    
59. }
    & C& Q6 ?  t& _1 q7 K

复制代码

8 @7 w& x! i* p         需要用到的时序主要有开始位、停止位、等待应答位、写一个字节。通过上面这四个函数就可以直接操作TM1637芯片了。

          根据官方的资料，有两种写数据的方式，第一种是地址自加，第二种是地址固定。先来实现地址自加的模式。
& I5 M! Z$ [* ]+ Z1 c3 p# f' B- _

  l- F! x; U9 z  }5 D
        根据这个时序看，首先要发送起始位，接着发送设置数据命令，下来等待应答，最后发送停止位。下来在发送起始位、设置地址命令、等待应答，发送显示数据1、等待应答、发送显示数据2，等待应答，……发送显示数据N、等待应答、停止位、起始位、发送显示命令、等待应答、停止位。
+ j( P  f9 E/ H! J' k5 ?6 ^
       下面看看官方的命令表

$ b4 C+ u6 O& B2 W6 j+ @; X

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

         命令分析完之后就可以编写代码了

$ D" ~2 L/ _& \' W4 Y5 T

1. //写显示寄存器  地址自增
     ^8 {$ B6 Y! F( X
2. void TM1637_Display_INC( void )
   5 @4 f2 y3 g# A* m. f& ^; r+ @
3. {
   
4.     unsigned char i;
   + B! y- y: d1 W
5.     TM1637_Start();
   
6.     TM1637_WriteByte( 0x40 );                                                                        //写数据到显示寄存器 40H 地址自动加1 模式,44H 固定地址模式,本程序采用自加1模式
   
7.     TM1637_Ack();
   ; ~. F6 B& {) S# @/ k; Y/ S  C( \
8.     TM1637_Stop();
   
9. 
   3 f, d: p$ a8 G9 m! l2 D
10.     TM1637_Start();
    
11.     TM1637_WriteByte( 0xC0 );                                                                        //地址命令设置 显示地址 00H
    
12.     TM1637_Ack();
    
13. 
    % p% }" V1 {: o0 S# e/ X. q
14.     for( i = 0; i < 6; i++ )                                                                        //地址自加，不必每次都写地址
    
15.     {
    
16.         TM1637_WriteByte( disp_num);                        //发送数据   disp_num[]中存储6个数码管要显示的内容
    
17.         TM1637_Ack();
    # v0 e& Q# d; ^# F* w/ j) O
18.     }
    # Z' Y% ^. x; Y
19.     TM1637_Stop();
    9 V' R) r1 f! ~, f1 y5 Q1 |
20. 
    / w2 r1 _9 A0 B( b
21.     TM1637_Start();
    
22.     TM1637_WriteByte( 0x88 | 0x07 );                                        //开显示，最大亮度-----调节脉冲宽度控制0---7  脉冲宽度14/16
    1 a: v, G) X4 G# [
23.     TM1637_Ack();
    
24.     TM1637_Stop();
    $ M+ n: _! m' `/ }# d1 X( m
25. 
    6 J8 A- q  s9 q' i1 M
26. }

复制代码

* {8 t- q0 h6 {% \: m1 N, g, g0 }( f        发送数据显示命令和显示亮度命令时都需要停止位，但是发送地址命令和显示数据内容时，是不需要停止位的，可以连续发送。数据循环发送结束后再发送停止位就行。其中 disp_num[]数组中依次存放6个数码管需要显示的内容。这样如下需要改变哪个数码管显示的内容是，只需要给disp_num[]数组中的对应位置重新赋值就行。
- V: d( ^1 {0 t
  ~; Z4 z; t$ w3 U+ a      下面编写地址固定的写数据模式


1 C" [: A+ D4 E( q* [
     时序和上面地址自增的基本一样，只是设置数据的命令不同，根据上面的命令表格可以看出，地址固定命令B6和B2都为1，也就是0x44。  

; Y) i; D: W& k( a% X/ m* _

1. //写显示寄存器  地址不自增
   
2. // add 数码管的地址 0--5
   
3. // value 要显示的内容
   
4. void TM1637_Display_NoINC( unsigned char add, unsigned char value )
   
5. {
   , F$ w( \, x$ P/ e5 C  [4 Z
6.     unsigned char i;
   
7.     TM1637_Start();
   % q3 U# E$ m/ @( m) f3 M, i$ j
8.     TM1637_WriteByte( 0x44 );                                                                //写数据到显示寄存器 40H 地址自动加1 模式,44H 固定地址模式,本程序采用自加1模式
   
9.     TM1637_Ack();
   5 A. |: x- N( e7 `. j. N4 @" Q
10.     TM1637_Stop();
    ) }$ S" e' u7 b; I9 D  |5 x
11. 
    3 s6 r# {0 L; d0 b, I  T! Q' i
12.     TM1637_Start();
    
13.     TM1637_WriteByte( 0xC0 | add );                                        //地址命令设置 显示地址 C0H---C5H
    7 S  W3 L, }4 R2 f* d- j
14.     TM1637_Ack();
    5 `' z6 ^0 v/ N3 M9 `4 C
15. 
    
16.     TM1637_WriteByte( value );                                                         //发送数据   value存储要显示的内容
    
17.     TM1637_Ack();
    
18.     TM1637_Stop();
    
19. 
    
20.     TM1637_Start();
    
21.     TM1637_WriteByte( 0x88 | 0x07 );                                                        //开显示，最大亮度-----调节脉冲宽度控制0---7  脉冲宽度14/16
    
22.     TM1637_Ack();
    6 T. u# C7 V* v  X) Y' z
23.     TM1637_Stop();
    7 j! L, q0 l! W; e
24. }

复制代码

2 i8 |& A7 b& p! C2 R7 d      地址固定模式每次只写一个固定的地址，地址值是由低三位值控制的，所以这里将高5位的值固定不变，只需要将低3位的值和高5位的值进行位或运算就行。这样在传递地址参数的时候，只需要发送0--5就可以了。同样亮度的设置也是用这个方法，亮度值由低3位值决定，将低3位值和高5位值进行位或运算。设置亮度的时候直接发送0--7就行。这里亮度没有使用参数，直接使用的是定值。想要改变亮度，可以把亮度也设置为参数传递进来。

9 y7 s+ B- q# A3 c      到这里就可以直接调用这两个函数，控制数码管显示了。

为了方便查看代码，下面贴出完整代码TM1637.c完整代码

2 t$ x' W, M7 [( q

1. #include "TM1637.h"
   1 E8 C3 W; T. q- O/ t3 L! @
2. #include "bsp_SysTick.h"
   
3. 
   
4. unsigned char tab[] =
   : `# n" y" D6 c% L
5. {
   
6.     0x3F,/*0*/
   
7.     0x06,/*1*/
   
8.     0x5B,/*2*/
   
9.     0x4F,/*3*/
   , A( F. k- q" A, a$ i5 ]! v
10.     0x66,/*4*/
    : m& _; P* X6 `  K8 r
11.     0x6D,/*5*/
    
12.     0x7D,/*6*/
    
13.     0x07,/*7*/
    
14.     0x7F,/*8*/
    
15.     0x6F,/*9*/
    1 w7 A' A5 [! c7 q( G+ z2 p( b
16.     0x77,/*10 A*/
    
17.     0x7C,/*11 b*/
    
18.     0x58,/*12 c*/
    
19.     0x5E,/*13 d*/
    
20.     0x79,/*14 E*/
    2 Q5 n  P- F. b/ f) b
21.     0x71,/*15 F*/
    0 v" u8 S+ m4 l4 k) q
22.     0x76,/*16 H*/
    ) }( L/ W% c2 {* Y$ V/ ?( y( G$ ]% n
23.     0x38,/*17 L*/
    / e  X. F3 g  @0 K# F' d
24.     0x54,/*18 n*/
    5 C0 `4 ~2 y3 m' p# A; j
25.     0x73,/*19 P*/
      \4 ^5 t( E4 g8 n
26.     0x3E,/*20 U*/
    % G2 u& z5 G( |0 `
27.     0x00,/*21 黑屏*/
    
28. };
    
29. 
    
30. // 最高位设置为1时显示 数码管上的":" 符号
    
31. unsigned char disp_num[] = {0x3F, 0x06 | 0x80, 0x5B, 0x4F, 0x66, 0x6D};                        //存放6个数码管要显示的内容
    
32. 
    + @$ h) E; Y1 v$ b
33. //端口初始化
    
34. void TM1637_Init( void )
    
35. {
    , S' |4 e; a4 x- Z
36. 
    2 X- o# J0 H; m; s: z1 I
37.     GPIO_InitTypeDef  GPIO_InitStructure;
    $ n" O: z/ ~+ G" L" Q
38. 
    
39.     RCC_APB2PeriphClockCmd( TM1637_CLK_GPIO_CLK | TM1637_DIO_GPIO_CLK, ENABLE );
    - F3 r6 g8 k! a  ~: L
40. 
    
41.     GPIO_InitStructure.GPIO_Pin = TM1637_CLK_GPIO_PIN | TM1637_DIO_GPIO_PIN;
    + h& x* Z( j' t0 a
42.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    
43.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
44.     GPIO_Init( TM1637_CLK_GPIO_PORT, &GPIO_InitStructure );
    . S2 h* \2 n  H1 N* j
45. }
    0 l7 p2 Z0 ^- |; |" H7 H
46. 
    
47. //起始位 CLK为高电平时，DIO由高变低
    
48. void TM1637_Start( void )
    
49. {
    
50.     TM1637_DIO_OUT();
    ( J0 }. `" e" A! j
51.     TM1637_CLK = 1;
    - u# H: ^' a/ k8 U
52.     TM1637_DIO = 1;
    
53.     delay_us( 2 );
    + n9 z8 u: F0 r% ]) j* o" S
54.     TM1637_DIO = 0;
    ! V& h  |( E8 P9 s
55. }
    
56. 
    
57. //等待应答 传输数据正确时，在第八个时钟下降沿，芯片内部会产生一个ACK信号，将DIO管脚拉低，在第九个时钟结束之后释放DIO总线。
    
58. void TM1637_Ack( void )
    
59. {
    9 m" z" y8 W' t9 W
60.     TM1637_DIO_IN();
    
61.     TM1637_CLK = 0;
    
62.     delay_us( 5 );                                                                                                        //在第八个时钟下降沿之后延时 5us，开始判断 ACK 信号
    & J, I% E' ~& `: p
63.     while( TM1637_READ_DIO );                                                                //等待应答位  这一行代码也可以不要 不影响实际使用效果 在使用软件仿真的时候需要屏蔽这句代码，否则程序就会卡在这里。
    6 \. c3 @" p1 i) g! ?+ `
64.     TM1637_CLK = 1;
    " m% F& ~0 q+ c+ c" W" P
65.     delay_us( 2 );
    
66.     TM1637_CLK = 0;
    3 N; o8 M# P/ t: l( Q
67. }
    2 r4 Y& R" ~) u  e& v
68. 
    ) U' v, r) w) U9 n( j  w; Y0 W- b- o
69. //停止位 CLK为高电平时，DIO由低变高
    
70. void TM1637_Stop( void )
    
71. {
    + r" M3 K$ v! p# {7 B
72.     TM1637_DIO_OUT();
    
73.     TM1637_CLK = 0;
      O4 S7 ~7 a2 l6 N+ e5 x* ~4 Y2 c
74.     delay_us( 2 );
    ! h7 P  m2 U: c% o
75.     TM1637_DIO = 0;
    + Z! J& Y& k2 [
76.     delay_us( 2 );
    
77.     TM1637_CLK = 1;
    
78.     delay_us( 2 );
    
79.     TM1637_DIO = 1;
    
80. }
    
81. //输入数据在CLK的低电平变化，在CLK的高电平被传输。
    
82. //每传输一个字节，芯片内部在第八个时钟下降沿产生一个ACK
    
83. // 写一个字节
    % X0 U+ W& v2 w, c1 z9 s* p
84. void TM1637_WriteByte( unsigned char oneByte )
    # x/ m* v; _7 Z. Q/ {
85. {
    0 r- t% v7 H, i$ f& F8 N5 N$ Z
86.     unsigned char i;
    3 `2 f+ i7 s( B9 d9 \( w$ V
87.     TM1637_DIO_OUT();
    
88.     for( i = 0; i < 8; i++ )
    
89.     {
    
90.         TM1637_CLK = 0;
    9 F" P# X) ]& b  Z0 m5 @
91.         if( oneByte & 0x01 )                                                                        //低位在前
    
92.         {
    % @$ O. @" _. p! A" s  \7 @* R
93.             TM1637_DIO = 1;
    " y* i4 y4 W, ~5 U8 h
94.         }
    4 O$ M8 ?- @4 _: N! M
95.         else
    - D2 d9 `3 O* H( q
96.         {
    / |/ O5 A2 ~2 Y3 t7 w# \
97.             TM1637_DIO = 0;
    7 F9 T. Q# o& m9 ?+ S/ H- D
98.         }
    7 q1 Z" W! j7 o
99.         delay_us( 3 );
    
100.         oneByte = oneByte >> 1;
     5 K3 ?) i4 @5 z' i3 Q
101.         TM1637_CLK = 1;
     
102.         delay_us( 3 );
     
103.     }
     
104. }
     - q) }4 }: V: T3 J+ G3 [
105. 
     1 N' _/ O4 _( Y% p
106. //写显示寄存器  地址自增
     
107. void TM1637_Display_INC( void )
     
108. {
     8 R: P! ?, x0 L/ q' o/ f
109.     unsigned char i;
     
110.     TM1637_Start();
     * B  [7 Y0 [& I0 j. N2 z
111.     TM1637_WriteByte( 0x40 );                                                                        //写数据到显示寄存器 40H 地址自动加1 模式,44H 固定地址模式,本程序采用自加1模式
     
112.     TM1637_Ack();
     4 Z  Y; C1 b  @( F+ d
113.     TM1637_Stop();
     
114.     TM1637_Start();
     
115.     TM1637_WriteByte( 0xC0 );                                                                        //地址命令设置 显示地址 00H
     
116.     TM1637_Ack();
     
117. 
     $ z4 I- r: J; J3 B1 W3 n
118.     for( i = 0; i < 6; i++ )                                                                        //地址自加，不必每次都写地址
     % |4 b0 u; [  A% M$ @. U, W% Y
119.     {
     2 R' g% R/ c, `: ~/ x' b; ~
120. TM1637_WriteByte( disp_num );                        //发送数据   disp_num[]中存储6个数码管要显示的内容
     6 @: a" X- e5 B7 D/ w; T
121.         TM1637_Ack();
     # @2 W0 r% v5 p  n
122.     }
     : U1 o$ Q, Y3 H9 g3 q; J0 ?
123.     TM1637_Stop();
     
124. #if 0
     * ]$ h0 o7 q' f$ N3 ?, r; i
125.     TM1637_Start();
     * m9 j7 q' }2 u
126.     TM1637_WriteByte( 0x88 | 0x07 );                                        //开显示，最大亮度-----调节脉冲宽度控制0---7  脉冲宽度14/16
     
127.     TM1637_Ack();
     
128.     TM1637_Stop();
     + U/ s3 Y9 {" \( d
129. #endif
     ' F0 F. ]5 _* z5 T
130. }
     ( w6 B" M3 v- K0 [  D+ y, Y
131. 
     4 Q" I- p! B0 p& g; {; b6 R) P
132. //写显示寄存器  地址不自增
     ; C  f" j, b9 g& ~; `( T0 X
133. // add 数码管的地址 0--5
     
134. // value 要显示的内容
     , @8 K8 G" L4 o4 Y$ y# y/ f- s! A8 M; n
135. void TM1637_Display_NoINC( unsigned char add, unsigned char value )
     
136. {
     0 c6 N' }- y1 p6 O7 Q
137.     unsigned char i;
       J# a. E/ Q/ ?+ @
138.     TM1637_Start();
     
139.     TM1637_WriteByte( 0x44 );                                                                //写数据到显示寄存器 40H 地址自动加1 模式,44H 固定地址模式,本程序采用自加1模式
     
140.     TM1637_Ack();
     
141.     TM1637_Stop();
     : X! K1 @9 c) r  q
142. 
     ' v! w$ P& E; {( U6 y( M
143.     TM1637_Start();
     
144.     TM1637_WriteByte( 0xC0 | add );                                        //地址命令设置 显示地址 C0H---C5H
     8 Y8 \7 f7 g! x& L; E0 T" h
145.     TM1637_Ack();
     0 v% |8 M: ?, B  k. `
146. 
     
147.     TM1637_WriteByte( value );                                                         //发送数据   value存储要显示的内容
     3 L3 D- p- |1 c, J+ @
148.     TM1637_Ack();
     
149.     TM1637_Stop();
     
150. #if 0
     # Q5 D- D8 I* s' Z' {9 G% \: S
151.     TM1637_Start();
     3 e4 f7 g4 M+ {; [
152.     TM1637_WriteByte( 0x88 | 0x07 );                                                        //开显示，最大亮度-----调节脉冲宽度控制0---7  脉冲宽度14/16
     4 `# ~( L$ X$ e
153.     TM1637_Ack();
     
154.     TM1637_Stop();
     4 J- s( c+ `6 _% O
155. #endif
     
156. }
     # O$ m$ D; x0 x: _* P6 `# x
157. 
     
158. // level : 设置亮度等级  0---7
     5 n; n' D$ f. X8 q" Q
159. void TM1637_SetBrightness( unsigned char level )
     
160. {
     
161.     TM1637_Start();
     
162.     TM1637_WriteByte( 0x88 | level );                                                        //开显示，最大亮度-----调节脉冲宽度控制0---7  脉冲宽度14/16
     
163.     TM1637_Ack();
     
164.     TM1637_Stop();
     
165. }
     
166. 
     
167. 
     : Q) z$ j0 s) a! P
168. 
     
169. 
     ) y7 Y  j1 h; s
170. //读按键  读按键时，时钟频率应小于 250K，先读低位，后读高位。
     ' }6 {0 N- X( x9 Y
171. unsigned char TM1637_ScanKey( void )
     3 c/ K5 i/ O/ }
172. {
     # h* Q: O4 q& u  f  F- ^* X4 V
173.     unsigned char reKey, i;
     
174.     TM1637_Start();
     0 N8 a$ [0 w2 Z$ S9 Q
175.     TM1637_WriteByte( 0x42 );                                                //读键扫数据
     
176.     TM1637_Ack();
     
177.     TM1637_DIO = 1;                                                                                        //在读按键之前拉高数据线
     
178.     TM1637_DIO_IN();
     
179.     for( i = 0; i < 8; i++ )                                                //从低位开始读
     / @6 s( j" R4 B- G7 [
180.     {
     
181.         TM1637_CLK = 0;
     
182.         reKey = reKey >> 1;
     
183.         delay_us( 30 );
     
184.         TM1637_CLK = 1;
     
185.         if( TM1637_READ_DIO )
     ( T* a1 }" s( x. K/ I
186.         {
     0 u) O) j! w+ m  V/ N; }, L
187.             reKey = reKey | 0x80;
     
188.         }
     ( T0 y: [; z% T" z
189.         else
     ( _- B0 M1 \) m
190.         {
     ) }" ?/ ]0 e8 o9 |: i; u
191.             reKey = reKey | 0x00;
     
192.         }
     & D7 J5 d) M% J) _3 n1 r, ?
193.         delay_us( 30 );
     3 y, R+ t1 S! L; q7 u
194.     }
     
195.     TM1637_Ack();
     9 _& u" Q! C; o/ u3 d9 O  M
196.     TM1637_Stop();
     
197.     return( reKey );
     
198. }
       q* R& D; @# e" y! q! C
199. 
     
200. 
     7 M# L' }( w4 `7 @
201. //按键处理函数，按键数据低位在前高位在后
     
202. unsigned char TM1637_KeyProcess( void )
     , x2 x' y& \8 h7 T4 x/ Z6 u2 u
203. {
     
204.     unsigned char temp;
     3 k. s9 L7 `. y4 }  s& E$ ~6 m8 A+ H
205.     unsigned char keyNum = 0;
       j: k% j% u& m( G
206.     temp = TM1637_ScanKey();                                 //读取按键返回值
     
207.     if( temp != 0xff )
     9 e. z& d+ P  D( `' ]5 n
208.     {
     
209.         switch( temp )
     7 q7 W: D7 ~3 \1 b6 M
210.         {
     7 i2 x7 U8 V- ]; G+ P4 C  |) t( b
211.         case 0xf7 :                                                        //K1与SG1对应按键按下
     
212.             keyNum = 1;
     
213.             break;
     , |+ |" v. K/ r  P
214.         case 0xf6 :                                                         //K1与SG2对应按键按下
     
215.             keyNum = 2;
     ' N+ I* v! w( M, ^: J
216.             break;
     . J& {$ v( h" q( J. Y
217.         case 0xf5 :                                                        //K1与SG3对应按键按下
     & |$ y" J' ]8 T$ K. z2 P3 }
218.             keyNum = 3;
     * l! s7 N- v7 g! f( p* b. B& c( x
219.             break;
     0 u! \( a7 H8 v( ^7 |+ b) T
220.         case 0xf4 :                                                        //K1与SG4对应按键按下
     
221.             keyNum = 4;
     
222.             break;
     % B: g6 I) M; z( E3 ~3 J
223.         case 0xf3 :                                                        //K1与SG5对应按键按下
     , H* K5 S( K# {
224.             keyNum = 5;
     . f5 q: C' G; g+ z
225.             break;
     
226.         case 0xf2 :                                                         //K1与SG6对应按键按下
     , ?* W$ {1 T3 z- y& i
227.             keyNum = 6;
     ( Z0 e, Z* i( _& [
228.             break;
     
229.         case 0xf1 :                                                        //K1与SG7对应按键按下
     + K$ K) _  s9 ]* {8 X
230.             keyNum = 7;
     
231.             break;
     # L" v8 I- j% m( ^, G
232.         case 0xf0 :                                                        //K1与SG8对应按键按下
     
233.             keyNum = 8;
     % x7 }- X1 \9 V
234.             break;
     6 M1 w$ G, c$ o3 z+ G$ ~
235. 
     
236.         case 0xef :                                                         //K2与SG1对应按键按下
     ! g! b( S: |" X7 l+ o
237.             keyNum = 9;
     
238.             break;
     0 D2 n) x8 j4 `. Z7 p* q: [
239.         case 0xee :                                                        //K2与SG2对应按键按下
     
240.             keyNum = 10;
     - P/ p9 h+ K6 K4 Y& j/ O" W" l" {8 _
241.             break;
     
242.         case 0xed :                                                        //K2与SG3对应按键按下
     " V8 N7 m% m( E  Z3 s' m
243.             keyNum = 11;
     4 R/ g) Z" q3 N
244.             break;
     
245.         case 0xec :                                                         //K2与SG4对应按键按下
     " b, R2 m3 d5 ^0 |2 ]
246.             keyNum = 12;
     
247.             break;
       Q) d# N0 g/ n  Z% f7 I+ w- u
248.         case 0xeb :                                                        //K2与SG5对应按键按下
     - |: {6 k0 t" E- O. J: N- ]( w
249.             keyNum = 13;
     9 Y4 I7 V% I5 S% n
250.             break;
     - D( w( z! T) J
251.         case 0xea :                                                        //K2与SG6对应按键按下
     
252.             keyNum = 14;
     ; B2 P' `6 [1 \
253.             break;
     
254.         case 0xe9 :                                                        //K2与SG7对应按键按下
     3 P) {; A$ B1 S# \0 @+ p5 M/ R
255.             keyNum = 15;
     
256.             break;
     
257.         case 0xe8 :                                                        //K2与SG8对应按键按下
     ; ]! B6 c, Q" z1 f+ O1 @* d
258.             keyNum = 16;
     
259.             break;
     $ o5 \: z' {5 Y6 P* G$ _
260.         default   :
     + K2 E- M) k" C: z1 g
261.             keyNum = 0;
     
262.             break;
     ; l- `* q( C. p6 t, A/ J
263.         }
     
264.     }
     
265.     return keyNum;
     4 B! Q! c; u! t6 t0 W
266. }

复制代码

0 c1 _1 b' y+ w9 e% J& v下面是主函数代码
# N9 T, K! O! t$ g2 y5 k

1. #include "stm32f10x.h"
   ; O" e/ b1 `- v  J
2. #include "bsp_led.h"
   * G  j5 f7 @# ~
3. #include "bsp_SysTick.h"
   ; f( z/ T: e& x3 b( E3 ?  i/ y
4. #include "TM1637.h"
   , Z6 F8 e+ T# d1 |9 i; l& h2 z
5. 
   
6. int main( void )
   . M% B' J+ ?: E  O  H6 _/ a
7. {
   
8.     u8 flag_s = 0;
   
9.     NVIC_PriorityGroupConfig( NVIC_PriorityGroup_2 );
   
10.     LED_GPIO_Config();
    
11.     TM1637_Init();
    # I7 N8 O8 v' c' S& M2 j0 C& p, ~
12. 
    
13. //    delay_config();                                                //使用方法二延时的时候调用
    
14. 
    
15.     while ( 1 )
    
16.     {
    / [) Z1 G; K8 @5 x+ M" n8 D" ?/ }
17. #if 1
    6 n# ]& o& @% D6 `9 u
18.         LED1( ON );
    - |) f' z- c( x8 U
19.         delay_ms( 1000 );
    / w' Q$ K6 N# \( ]) `. S& @
20.         LED1( OFF );
    
21. 
    # O" }1 w3 g2 ]. T; o& R- d, B, n
22.         flag_s = ~flag_s;
    1 R# T* v# R0 [$ K. C. R. _$ M3 I
23.         disp_num[0] = tab[0];
    ; h4 Y- G7 @) Y3 E" ^- T
24.         if( flag_s )
    
25.                                         disp_num[1] = tab[1] | 0x80;                                //最高位设置为1 显示":"
    1 \5 S5 P( A, f, a/ e
26.         else
    
27.             disp_num[1] = tab[1];
    
28.         disp_num[2] = tab[2];
    $ [0 _: s; b. V8 y; ]! q2 g, p9 Y
29.         disp_num[3] = tab[3];
    5 [1 C+ g2 o, D
30.         TM1637_Display_INC();
    $ ?) T! G! S8 h( G/ h7 Q
31.         TM1637_SetBrightness( 3 );                                        //设置亮度等级 0---7
    9 Q' h+ t/ P8 T
32. 
    
33. #else                        //延时精确测试代码
    
34. 
    . K2 S: `- C- @, y
35.         LED1_ON;
    
36.         delay_us( 1 );
    - M. H) l/ N, I+ j
37.         LED1_OFF;
    
38.         delay_us( 1 );
    
39. 
    9 t' |  |* s% z0 ]+ M' e5 s
40. #endif
    
41.     }
    
42. 
    2 K$ h0 r* V; V
43. }
    9 F, D, I) @1 g( t! I2 J

复制代码

4 m  c. _5 f' e- ]. k) }+ x  |       主函数中设置四个数码管依次显示0、1、2、3，冒号是在第二个数码管的dp引脚接着，dp为最高位，所以给最高位写1就可以点亮时钟的冒号。通过一个标志位控制冒号1秒钟闪烁一次。
& ?- r+ ?% y# Y9 Q  f+ }