工作中经常要用到大量的数码管，点阵，LED

7 y- h  l6 y+ h3 y4 y

一般都是用74系列的芯片去驱动，因为公司的项目需求找了这颗芯片现在分享驱动和原理图过

) J1 C6 H; `! L2 X$ u5 ^

1. enum Brightness
   ; R/ J, m" f! E" u1 ^' [
2. {
   ) t+ i( i1 A6 s. S! W6 ]
3.     Level1 = 0x88,
   ! b& o+ a: d/ {7 O- H5 h
4.     Level2,
   
5.     Level3,
   8 q5 ?- K% V; G- i
6.     Level4,
   
7.     Level5,
   
8.     Level6,
   
9.     Level7,
   8 i- z$ O: `, H5 r
10.     Level8,
    
11.     LEDOFF = 0x80
      B) a' E! w' `/ Y
12. };
    
13. 
    ) z9 P$ V4 E( C
14. uint8_t NUM[11][5] =
    7 P% c! K! z5 G( A6 r1 o' l
15. {
    . `5 t" U; I: U4 p, l9 a! [- `
16.   {0xFF, 0x41, 0x41, 0x41, 0xFF},//0
    * {7 [8 k& u! g$ T
17.   {0x00, 0x00, 0x7F, 0x00, 0x00},//1
    5 T, i6 B# a5 c, p: J4 B; [
18.   {0x79, 0x49, 0x49, 0x49, 0x4F},//2
    
19.   {0x49, 0x49, 0x49, 0x49, 0xFF},//3
    
20.   {0x0F, 0x08, 0x08, 0x08, 0xFF},//4
    
21.   {0x4F, 0x49, 0x49, 0x49, 0x79},//5
    3 B4 D6 E. X8 o  b) X, U
22.   {0xFF, 0x49, 0x49, 0x49, 0x79},//6
    . N6 j, v+ W$ d' g$ k
23.   {0x01, 0x01, 0x01, 0x01, 0xFF},//7
    # _% [) ]* `* ^' W
24.   {0xFF, 0x49, 0x49, 0x49, 0xFF},//8
    
25.   {0x4F, 0x49, 0x49, 0x49, 0xFF},//9
    
26.   {0x00, 0x00, 0x22, 0x00, 0x00},//:
    3 [' [& B, O' K$ \4 g& n) Q
27. };
    
28. 
    
29. void TM1640_GPIO_Init(void)
    
30. {
    + b7 [- v* g; X
31.   GPIO_Init(GPIOA, (GPIO_Pin_TypeDef)(GPIO_PIN_1), GPIO_MODE_OUT_PP_HIGH_FAST);
    
32.   GPIO_Init(GPIOA, (GPIO_Pin_TypeDef)(GPIO_PIN_2), GPIO_MODE_OUT_PP_HIGH_FAST);
    " ~3 ^' z$ y2 H5 M" H9 I! v4 t
33.   GPIO_Init(GPIOC, (GPIO_Pin_TypeDef)(T2_Din | T2_Clk), GPIO_MODE_OUT_PP_HIGH_FAST);
    
34. }
    0 I) V; D* Z% u; n  [0 R
35. 
    
36. 
    : o7 a: v. ]4 T2 ~
37. void Delay(uint16_t nCount)
    4 Q% i/ X1 s( M1 j% Q+ d- x, o7 b
38. {
    - V% Y7 h9 w2 s, c, p+ g) V
39.   while (nCount != 0)
    
40.   {
    
41.     nCount--;      
    $ a: V( \1 K. ^/ B  p# b" Q- P
42.   }
    
43. }
    
44. 
    % K% y/ Y4 r  w$ n7 [- _
45. void TM1640_Start(void)
    . Z: g. G/ o# j& ~/ X
46. {
    / ]. {3 Y& L5 x; t$ G1 j1 w
47.   GPIO_WriteHigh(GPIOA, T1_Clk);
    
48.   Delay(10);
    . Y& m& @/ j8 |7 V; F# H
49.   GPIO_WriteHigh(GPIOA, T1_Din);
    , V4 z2 z' k* j" g2 K
50.   Delay(10);
    % y: z% V  a. H8 E4 ~4 T. U
51.   GPIO_WriteLow(GPIOA, T1_Din);
    . E2 ~- v6 v' ?
52.   Delay(10);  
    
53.   GPIO_WriteLow(GPIOA, T1_Clk);
    
54.   Delay(10);
    # @5 l& h0 \( z2 V! d
55. }
    
56. 
    
57. void TM1640_Stop(void)
    . t: v9 F1 e  ]% w
58. {
    
59.   GPIO_WriteLow(GPIOA, T1_Clk);
    , ], L6 _4 s% B8 w3 j
60.   Delay(10);
    
61.   GPIO_WriteLow(GPIOA, T1_Din);
    8 Z& m( c: g* A
62.   Delay(10);
    ) X' d) b1 t+ s( |" c8 V% h9 {
63.   GPIO_WriteHigh(GPIOA, T1_Clk);
    * u) e0 V. b& b7 t! w) ^5 c8 ]. j- \
64.   Delay(10);
    
65.   GPIO_WriteHigh(GPIOA, T1_Din);
    - \, h2 d# u" ^$ J0 n3 E
66.   Delay(10);
    9 c" _6 P" @- ]7 ^! U* c
67. }
    . ?0 J& y, k- |; o
68. 
    
69. void TM1640_2_Start(void)
    9 _; L) P* R; C+ w! J
70. {
    " l+ Z( n7 j) u3 r0 F2 m8 P) K* b# e
71.   GPIO_WriteHigh(GPIOC, T2_Clk);
    
72.   Delay(10);
    . h. e2 F8 r! k% \
73.   GPIO_WriteHigh(GPIOC, T2_Din);
    
74.   Delay(10);
    
75.   GPIO_WriteLow(GPIOC, T2_Din);
    + v4 j% R) b. ?* p5 V
76.   Delay(10);  
    : `0 t& m) J( `) H6 N2 k' g; j% f
77.   GPIO_WriteLow(GPIOC, T2_Clk);
    
78.   Delay(10);
    3 J% ~1 {# E) b
79. }
    * p& ]. {3 L2 x+ Y' ]
80. 
    2 A. A8 g' t$ f$ z1 k
81. void TM1640_2_Stop(void)
    ; }/ \7 e7 F7 A3 l: j
82. {
    
83.   GPIO_WriteLow(GPIOC, T2_Clk);
    % a/ V" b5 P" Y, B
84.   Delay(10);
    + E# y! T# O- A& K+ Z1 s
85.   GPIO_WriteLow(GPIOC, T2_Din);
    
86.   Delay(10);
    
87.   GPIO_WriteHigh(GPIOC, T2_Clk);
    9 g4 G6 d. d" w7 g5 r+ O4 N5 @% P# T
88.   Delay(10);
    % t! z& o+ {. }; g9 k  v1 ]# t
89.   GPIO_WriteHigh(GPIOC, T2_Din);
    
90.   Delay(10);
    
91. }
    7 A# E2 g$ L+ Z: b1 Y5 F7 m
92. 
    
93. 
    
94. void TM1640_Write_Byte(uint8_t dat)
    
95. {
    ( g- Z/ Y2 b) Q9 e# f
96.   uint8_t i;
    % A: y9 }' V: L: ?6 q/ n& f
97.   for(i = 0; i < 8; i++)
    7 V& Q( h9 p; g4 c" Q
98.   {
    
99.     GPIO_WriteLow(GPIOA, T1_Clk);   
    ) `) W8 ]* j( [$ s
100.     if(dat & 0x01)
     
101.     {
     
102.       GPIO_WriteHigh(GPIOA, T1_Din);
     
103.     }
     " n0 Y* M6 ?% ^+ p4 e" \4 B
104.     else
     9 [; r) W3 P+ z3 b. @' ?) O
105.     {
     $ T! V. M. j6 Y
106.       GPIO_WriteLow(GPIOA, T1_Din);
     " v# [/ u/ V7 N. t. L. d
107.     }
     7 o9 h6 \- J. F2 b
108.     Delay(10);
     4 x- A( `4 e& V0 i* u/ b
109.     GPIO_WriteHigh(GPIOA, T1_Clk);
     
110.     Delay(10);
     
111.     dat >>= 1;
     . S$ Z  n4 j  j1 b7 i0 R
112.   }
     + [. W9 n% F1 \: z' d
113.   GPIO_WriteLow(GPIOA, T1_Clk);
     
114.   Delay(10);
     
115. }
     
116. 
     
117. void TM1640_2_Write_Byte(uint8_t dat)
     
118. {
     
119.   uint8_t i;
     / X3 w; y, C, X0 `) O
120.   for(i = 0; i < 8; i++)
     7 g, q7 G2 k; a0 N9 s
121.   {
     ( l( L6 c! V5 i+ n8 W4 H
122.     GPIO_WriteLow(GPIOC, T2_Clk);   
     5 o0 L6 B3 a; J1 ^) o
123.     if(dat & 0x01)
     2 A; t/ d8 p# O" C& x6 Z) S. F) r
124.     {
     
125.       GPIO_WriteHigh(GPIOC, T2_Din);
     
126.     }
     ) G- c! c) W3 v! w! E: p
127.     else
     
128.     {
     
129.       GPIO_WriteLow(GPIOC, T2_Din);
     0 K1 {$ {& p2 F* ~# }3 e6 u
130.     }
     
131.     Delay(10);
     
132.     GPIO_WriteHigh(GPIOC, T2_Clk);
     
133.     Delay(10);
     
134.     dat >>= 1;
     
135.   }
     
136.   GPIO_WriteLow(GPIOC, T2_Clk);
     
137.   Delay(10);
     
138. }
     ! f* \7 F7 T$ w
139. 
     ' |4 u% l8 q: |3 @; B( d
140. 
     9 f8 F8 J( |$ C' E7 F2 |
141. void TM1640_Init(void)
     
142. {
     0 N  B6 W# r6 X$ A2 v
143.   TM1640_GPIO_Init();  
     . q% K; ?- z- ?; [* M
144.   Delay(10);
     " J: `* F6 y9 ?% @1 C
145.   TM1640_Start();
     
146.   TM1640_Write_Byte(Level8);
     6 ^& @1 t! ]: D0 a/ Y/ D
147.   TM1640_Stop();
     
148.   TM1640_2_Start();
     
149.   TM1640_2_Write_Byte(Level8);
     1 S1 r. y9 h3 _! j: I' d2 i
150.   TM1640_2_Stop();
     
151. }
     
152. 
     
153. 
     
154. void TM1640_Bit1(uint8_t *Dat)
     # S1 ^# }7 L/ w
155. {
     " j, [. G, Z# t) J1 G8 ?: F
156.   uint8_t i;
     
157.   TM1640_Start();
     
158.   TM1640_Write_Byte(0x40);
     7 M  q) S+ ^% U! T# t
159.   TM1640_Stop();
     + k5 l- C5 k# l# ]3 c
160.   Delay(10);
     5 ^' u! j3 }+ h8 c- c0 W% f4 I
161.   TM1640_Start();
     ( F$ y+ g8 \7 q7 n# n
162.   TM1640_Write_Byte(0xC0);
     
163.   for(i = 0; i < 5; i++)
     ( e9 j8 d9 b; k0 C2 T
164.   {
     % t" w1 _7 C- p
165.     TM1640_Write_Byte(*(Dat++));
     + T3 ]- G2 A" K. G3 e
166.   }
       R; M5 H+ @. ]% x- l- s
167.   TM1640_Stop();
     3 U. d! r% I6 ~! B0 Y7 n0 D4 i
168. }
     8 u* _# p4 u# s8 Z; t5 d6 f* a8 T
169. 
     
170. void TM1640_Clear_C5(void)
     $ a5 F/ V* h. B; k
171. {
     * F/ G' L- U1 e' E. H9 h
172.   TM1640_Start();
     " ], u5 Y, R5 M5 O  a
173.   TM1640_Write_Byte(0x44);
     
174.   TM1640_Stop();
     
175.   Delay(10);
     
176.   TM1640_Start();
     , F( N9 `/ r* ?  W8 B4 d
177.   TM1640_Write_Byte(0xC5);
     
178.   TM1640_Write_Byte(0x00);
     
179.   TM1640_Stop();
     
180.   TM1640_Start();
     
181.   TM1640_Write_Byte(0x44);
     3 f; n9 o) B; g/ e+ N
182.   TM1640_Stop();
     7 V4 |8 ^$ \. g8 T( ?$ s
183.   Delay(10);
     " l+ v  ~" T1 }4 i6 O
184.   TM1640_Start();
     
185.   TM1640_Write_Byte(0xCD);
     9 k2 J  h. q7 Q9 J
186.   TM1640_Write_Byte(0x00);
     % Y- a5 p& `" o
187.   TM1640_Stop();
     ! p, L9 P0 @4 a" V
188.   TM1640_2_Start();
     
189.   TM1640_2_Write_Byte(0xC4);
     ; U9 X( I: K/ H- Y
190.   TM1640_2_Write_Byte(0x00);
     
191.   TM1640_2_Stop();
     ! l9 q( e( n9 R# K$ D
192. }
     $ @/ m9 K) C$ o8 l
193. 
     & o2 `8 G% V- P$ S- i& Y. W& k$ m
194. void TM1640_ClearAll(void)
     
195. {
     ; v6 X1 X, Y0 y) A/ K% G
196.   uint8_t i;
     
197.   TM1640_Start();
     
198.   TM1640_Write_Byte(0x40);
     0 y, a# m0 X. ]9 B2 w/ ~  T. L% ~
199.   TM1640_Stop();
     
200.   Delay(10);
     % O) p& ?9 S# ?4 p5 C9 o. F* R
201.   TM1640_Start();
     * _+ z0 F; O, z7 ~: ]
202.   TM1640_Write_Byte(0xC0);
     
203.   for(i = 0; i < 16; i++)
     ! o; t8 m* J* c+ J0 U2 m" F
204.   {
     " V" i1 \. N8 p/ g( Z0 u
205.     TM1640_Write_Byte(0x00);
     
206.   }
     3 y$ D( }, q$ S& t, \; i
207.   TM1640_Stop();
     " g8 u# C3 n4 o5 }
208.   TM1640_2_Start();
     
209.   TM1640_2_Write_Byte(0x40);
     $ `/ U: u% u; y5 B
210.   TM1640_2_Stop();
     ( h* q- U2 J+ T% J. a1 K1 Y( z
211.   Delay(10);
     
212.   TM1640_2_Start();
     4 S( Y8 E) C& F1 o8 @
213.   TM1640_2_Write_Byte(0xC6);
     
214.   for(i = 0; i < 16; i++)
     3 h, o) m& d, q* v$ L2 N/ p
215.   {
     . z9 r& R9 a/ `" E7 j( ~; @  {" ^
216.     TM1640_2_Write_Byte(0x00);
     , c2 H! [. i6 s
217.   }
     / s# z, L' L" P. O6 k& `$ o
218.   TM1640_2_Stop();  
     . u! }$ k3 z& M" a9 Y1 R
219. }
     
220. 
     8 V# U" X' Q. O$ j/ `2 v: c
221. void TM1640_Bit2(uint8_t *Dat)
       E# c  p+ [. D& ~
222. {
     
223.   uint8_t i;
     6 u: h% @4 s9 B0 Q9 u1 o) D6 Q; G
224.   TM1640_Start();
     
225.   TM1640_Write_Byte(0x40);
     ! T2 y4 L$ e/ M% ^
226.   TM1640_Stop();
     * A/ _2 }0 H* c$ q; `
227.   Delay(10);
     - ~3 ]# W) H; ~- h1 `
228.   TM1640_Start();
     3 ]2 f# D5 f- g; X0 D/ g
229.   TM1640_Write_Byte(0xC6);
     2 g" X. a, w# w  S! }
230.   for(i = 0; i < 5; i++)
     
231.   {
     
232.     TM1640_Write_Byte(*(Dat++));
     % a* o5 _) A. h% y; S
233.   }
     
234.   TM1640_Stop();
     3 l$ K* w3 [3 z  W- h
235. }
     
236. 
     6 u; V7 ?0 _8 w
237. void TM1640_Bit3(uint8_t En)
     # X& {0 o6 h$ d' P- e! \& z
238. {
     
239.   TM1640_Start();
     4 g1 l7 j( r, H  v5 ^
240.   TM1640_Write_Byte(0x44);
     ! T- ~( N- I) Y$ n; V+ A; L$ T, Z% ]
241.   TM1640_Stop();
     
242.   Delay(10);
     
243.   TM1640_Start();
     0 B9 R( _9 a/ b& A! L, X# L$ f! e- B* j
244.   TM1640_Write_Byte(0xCC);
     . f- Q' p$ y7 {/ Z
245.   if(En)
     
246.     TM1640_Write_Byte(NUM[10][2]);
     
247.   else
     
248.     TM1640_Write_Byte(0x00);
     
249.   TM1640_Stop();
     
250. }
     
251. 
     + l" o/ R- N  O: c# q, f5 ~( U
252. void TM1640_2_Bit4(uint8_t *Dat)
     
253. {
     $ J( q2 r* {- A
254.   uint8_t i;
     5 a2 v, o# `+ Q% C5 I& J
255.   TM1640_Start();
     9 `9 k8 U* G9 y* s4 S" c
256.   TM1640_Write_Byte(0x44);
     
257.   TM1640_Stop();
     ! ]* ?9 G* r$ U, B7 g: `  W
258.   Delay(10);
     1 c; f  C  G' Z! S$ V: I7 _) A/ @
259.   TM1640_Start();
     
260.   TM1640_Write_Byte(0xCE);
     * G" P) V2 ~5 O# t( ^0 ]" A; L; m+ C, A
261.   TM1640_Write_Byte(*(Dat++));
     ( Y9 i) U$ I( R  i
262.   TM1640_Stop();
     & P3 W1 @0 n3 Q& a! ^  ~; ]0 h  V( i
263.   TM1640_2_Start();
     
264.   TM1640_2_Write_Byte(0x44);
     
265.   TM1640_2_Stop();
     . X- A* D& Y3 `0 J7 A4 G1 a3 U( k$ g
266.   Delay(10);
     . Z, e& k% P% G- K2 ~
267.   TM1640_2_Start();
     
268.   TM1640_2_Write_Byte(0xC0);
     
269.   for(i = 1; i < 5; i++)
     ! ~0 z( b% y+ K+ c
270.   {
     
271.     TM1640_2_Write_Byte(*(Dat++));
     ' r5 x8 U" M5 v2 }( @  Z
272.   }
     
273.   TM1640_2_Stop();
     * N6 @/ @0 \; O% j) i3 Q) p
274. }
     9 X0 J$ ]  I9 n) L8 g
275. 
     & L2 @+ p% \; p' Y3 X  b1 [/ J4 @
276. void TM1640_2_Bit5(uint8_t *Dat)
     2 ^2 ?+ h6 e0 x' Z4 w% q- R
277. {
     1 p1 ~0 s* ]2 q- ^- v, E
278.   uint8_t i;
     
279.   TM1640_2_Start();
     $ b9 b8 W* Y1 ~& e0 C% \
280.   TM1640_2_Write_Byte(0x40);
     + t1 m( Y7 L# T
281.   TM1640_2_Stop();
     
282.   Delay(10);
     
283.   TM1640_2_Start();
     
284.   TM1640_2_Write_Byte(0xC5);
     
285.   for(i = 0; i < 5; i++)
     9 o2 V# J2 f1 M1 F
286.   {
     
287.     TM1640_2_Write_Byte(*(Dat++));
     : Z$ M) M) |' ]) }2 N1 `2 S
288.   }
     5 P& v$ y8 q  ~
289.   TM1640_2_Stop();
     
290. }

复制代码

--------------------------------------------------------------------------------------------
: L  \& S) D$ e. U* A$ J% S* \

% F/ p+ i; k7 E6 W$ l+ ]; W9 j: h调试器都忘记放啦，做了几十片，大家可以看一下

$ j# w, Z6 B" T

zhao.zhao 发表于 2017-5-24 08:50
) a- }7 G/ @+ K6 }9 Z/ R$ e针对特定场合，这个芯片还是不错的，只是不知高电压的大的数码管支持吗

如果是一个段串联几个，就要用扩流，或者用灯饰类的芯片；下面一张图是用TM1812做的，驱动4寸数码管，12通道的，一段串联3个LED灯； 数码管不多可以用9通道的
7 O% ~& S6 A$ a


' c: \# _4 M2 W& S

zhao.zhao 发表于 2017-5-21 14:10
2 v' v/ ]  B4 K/ }: M这个芯片扩展性不行，驱动有点麻烦，也许控制少量几个数码管或LED点阵屏可以，量多了就不行了，影响了其使 ...

驱动非常简单啊，点阵一个5排，我带了25排，差不多就是带25个数码管了，也很好，总线速率也很快，并没有 出现你说的那种不行

zhao.zhao 发表于 2017-5-21 14:10
5 B( b0 G& m0 ?, H: s4 _9 a' v这个芯片扩展性不行，驱动有点麻烦，也许控制少量几个数码管或LED点阵屏可以，量多了就不行了，影响了其使 ...

/ Z% a2 M6 k5 i7 h8 d3 s你要怎么扩展，一颗芯片可以驱动128个LED灯，如果需要的可以用TM1680，可以控制384个点；

不错，学习了！

不知这个芯片的价格几何？
3 x, X, g; P0 W! d

zhao.zhao 发表于 2017-5-20 14:54
6 Y$ m! T# F2 [8 \6 Q4 y/ I, O6 u% I不知这个芯片的价格几何？

9 D' |; g/ o, i2 S& u% F7 \+ N) B0.8
; f2 H. n8 x  V8 s1 D

这种芯片挺不错，尤其还LED和按键同时驱动，我们公司也用到了。

0.8是多大量时的价格?

寂寞，点燃一支烟 发表于 2017-5-20 19:05
这种芯片挺不错，尤其还LED和按键同时驱动，我们公司也用到了。

嗯，这家貌似有很多这样的芯片，，方便多了

这个芯片扩展性不行，驱动有点麻烦，也许控制少量几个数码管或LED点阵屏可以，量多了就不行了，影响了其使用范围。

欢迎大家使用，我们公司还有很多其他的LED驱动芯片；

Ljmp 发表于 2017-5-22 14:44
欢迎大家使用，我们公司还有很多其他的LED驱动芯片；

我宣传有样片没

我指的是在LED显示屏上使用，这个量很大的

用过TM1650驱动4位数码管，I2C驱动，可以节省单片机IO口。
应该和楼主TM1640功能类似吧

好像还不错