/ b9 D0 P: V2 X
: S- U  F. Z, j4 w3 ^6 W# C2 G

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

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

; g5 x9 L- k) i# Q, F

1. enum Brightness
   
2. {
   
3.     Level1 = 0x88,
   
4.     Level2,
   
5.     Level3,
   
6.     Level4,
   
7.     Level5,
   
8.     Level6,
   7 N* Q3 s1 W* G, o% K
9.     Level7,
   / A; W/ w1 j9 P. o9 [8 X
10.     Level8,
    
11.     LEDOFF = 0x80
    " L0 a4 T0 [' B/ ]" x7 `# S4 ?
12. };
    4 E1 T) Q% v# ?1 V
13. 
    
14. uint8_t NUM[11][5] =
    9 S4 t/ Y! w$ [, d8 P: l
15. {
    3 J$ k5 Q5 a# a/ Y. U
16.   {0xFF, 0x41, 0x41, 0x41, 0xFF},//0
    
17.   {0x00, 0x00, 0x7F, 0x00, 0x00},//1
    
18.   {0x79, 0x49, 0x49, 0x49, 0x4F},//2
    # f0 j; `5 Q9 g% s7 G
19.   {0x49, 0x49, 0x49, 0x49, 0xFF},//3
    
20.   {0x0F, 0x08, 0x08, 0x08, 0xFF},//4
    * H9 Z( O7 p1 o; e5 ?6 `! f! o
21.   {0x4F, 0x49, 0x49, 0x49, 0x79},//5
    6 L% P6 v! m! T3 t7 B
22.   {0xFF, 0x49, 0x49, 0x49, 0x79},//6
    ) s4 C! O, s  c4 W
23.   {0x01, 0x01, 0x01, 0x01, 0xFF},//7
    
24.   {0xFF, 0x49, 0x49, 0x49, 0xFF},//8
    ) q4 @! S+ E+ d0 Y/ ]
25.   {0x4F, 0x49, 0x49, 0x49, 0xFF},//9
    9 F) ?$ |- d' m7 E' L) o' i
26.   {0x00, 0x00, 0x22, 0x00, 0x00},//:
    : h! V: Z- D8 j$ q
27. };
    . O. x' F9 v+ F# Y  [: z5 \
28. 
    # _9 c4 u5 R5 p0 d- _7 ]
29. void TM1640_GPIO_Init(void)
    
30. {
    7 l! j' E$ }: T& U$ p% U
31.   GPIO_Init(GPIOA, (GPIO_Pin_TypeDef)(GPIO_PIN_1), GPIO_MODE_OUT_PP_HIGH_FAST);
    ( z$ ?6 J) _1 ]. b/ ^
32.   GPIO_Init(GPIOA, (GPIO_Pin_TypeDef)(GPIO_PIN_2), GPIO_MODE_OUT_PP_HIGH_FAST);
    8 J8 q2 s9 A/ p* @1 Y
33.   GPIO_Init(GPIOC, (GPIO_Pin_TypeDef)(T2_Din | T2_Clk), GPIO_MODE_OUT_PP_HIGH_FAST);
    . x2 w# f) Z0 s1 ?+ X+ X
34. }
    ' k. |* Z/ V: L" k0 l; M' S7 v
35. 
    ' b9 f) T% }# u' i7 N5 R* j
36. 
    
37. void Delay(uint16_t nCount)
    * F9 F( {) s. P, g8 Z2 `
38. {
    
39.   while (nCount != 0)
    
40.   {
    
41.     nCount--;      
    5 U+ p  c( P. u+ B, i0 V" ^( O! ?0 d
42.   }
    
43. }
    / d- m: q. g0 q/ D) V
44. 
    
45. void TM1640_Start(void)
    
46. {
    7 {2 S, _! ~6 w7 Z5 c& E( D5 Q# p; l
47.   GPIO_WriteHigh(GPIOA, T1_Clk);
    
48.   Delay(10);
    
49.   GPIO_WriteHigh(GPIOA, T1_Din);
    + A2 _" H6 j5 i6 J* D- \  M8 U+ d
50.   Delay(10);
    
51.   GPIO_WriteLow(GPIOA, T1_Din);
    % l, F. J. o2 B6 p8 }# b5 h$ J
52.   Delay(10);  
    : ]3 M, X8 O7 T" e) A
53.   GPIO_WriteLow(GPIOA, T1_Clk);
    ( S5 Y4 \( K% n2 S
54.   Delay(10);
    
55. }
    
56. 
    
57. void TM1640_Stop(void)
    
58. {
    
59.   GPIO_WriteLow(GPIOA, T1_Clk);
    
60.   Delay(10);
    & o  m5 w; c) T  k8 D0 @3 ]
61.   GPIO_WriteLow(GPIOA, T1_Din);
    . p; D" Z( n; y' `+ Q0 q
62.   Delay(10);
    4 v% f( w, p! K$ o% T) q
63.   GPIO_WriteHigh(GPIOA, T1_Clk);
    
64.   Delay(10);
    
65.   GPIO_WriteHigh(GPIOA, T1_Din);
    
66.   Delay(10);
    " q7 H" i) m% H- p6 h; C/ c) _
67. }
    6 n3 \& W* u1 O
68. 
    
69. void TM1640_2_Start(void)
    & C7 R" o8 q( j1 a7 A
70. {
    3 ?2 e5 i. s, A' y) b+ W
71.   GPIO_WriteHigh(GPIOC, T2_Clk);
    9 U  x0 p$ D, {$ g1 [, m. y$ U
72.   Delay(10);
    
73.   GPIO_WriteHigh(GPIOC, T2_Din);
    
74.   Delay(10);
    $ u4 f+ }+ `7 x! l5 t  ~, J
75.   GPIO_WriteLow(GPIOC, T2_Din);
    % z! _6 N; V- w! h7 B
76.   Delay(10);  
    
77.   GPIO_WriteLow(GPIOC, T2_Clk);
    
78.   Delay(10);
    
79. }
    ) ]) `- K" F* k% S. m
80. 
    
81. void TM1640_2_Stop(void)
    
82. {
    9 \/ p0 M- c8 a6 T6 p% d
83.   GPIO_WriteLow(GPIOC, T2_Clk);
    
84.   Delay(10);
    ' z$ W8 ?" H( c; s5 x3 c" [4 O
85.   GPIO_WriteLow(GPIOC, T2_Din);
    
86.   Delay(10);
    
87.   GPIO_WriteHigh(GPIOC, T2_Clk);
    4 d/ s# Q: b  I# G! L
88.   Delay(10);
    ! @+ h  i! P% y. @
89.   GPIO_WriteHigh(GPIOC, T2_Din);
    8 M% l7 n7 H( F5 l
90.   Delay(10);
    
91. }
    & p7 O% r/ g+ i0 _" G  y& C
92. 
    + @) y( S. R- n
93. 
    + T9 i4 B! e- I: Z
94. void TM1640_Write_Byte(uint8_t dat)
    
95. {
    0 C, T2 _4 `/ k0 ^/ W. x- V
96.   uint8_t i;
    0 {9 Z  \( N8 j- P5 n
97.   for(i = 0; i < 8; i++)
    " M2 \0 S: E/ G; a2 ~7 E" s' K% y
98.   {
    
99.     GPIO_WriteLow(GPIOA, T1_Clk);   
    3 X, X& I0 U# _/ c. G
100.     if(dat & 0x01)
     0 [8 }8 s+ A0 C% F# d8 }9 ?
101.     {
     
102.       GPIO_WriteHigh(GPIOA, T1_Din);
     1 G( v3 M. R1 H2 R  E
103.     }
     
104.     else
     
105.     {
     # a' ~0 x& v2 q. l8 ]
106.       GPIO_WriteLow(GPIOA, T1_Din);
     ! D  c" V% r4 Z
107.     }
     
108.     Delay(10);
     + Z6 k- k( n6 T
109.     GPIO_WriteHigh(GPIOA, T1_Clk);
     
110.     Delay(10);
     7 T' T, G$ Q8 ^2 E
111.     dat >>= 1;
       L! [( ]' C  m# q  Z- B
112.   }
     6 r) I. H' n( m7 @" T+ i
113.   GPIO_WriteLow(GPIOA, T1_Clk);
     
114.   Delay(10);
     $ d) v  y/ h/ o0 P
115. }
     
116. 
     0 B% {# b, G9 P' s: D1 ^+ Y) L
117. void TM1640_2_Write_Byte(uint8_t dat)
     + @1 p* q7 u& ^* U# x7 U
118. {
     " a1 S3 ~" S/ B9 W
119.   uint8_t i;
     
120.   for(i = 0; i < 8; i++)
     
121.   {
     . H2 y" @0 F" z: [9 a
122.     GPIO_WriteLow(GPIOC, T2_Clk);   
     
123.     if(dat & 0x01)
     
124.     {
     : J3 a! M5 k" U9 G0 t: c
125.       GPIO_WriteHigh(GPIOC, T2_Din);
     
126.     }
     
127.     else
     7 ]2 Y" C2 N  ^4 `
128.     {
     4 v, x! _' g; }  x
129.       GPIO_WriteLow(GPIOC, T2_Din);
     + d: g: s/ p+ i5 \
130.     }
     
131.     Delay(10);
     1 t2 m4 F) @- A
132.     GPIO_WriteHigh(GPIOC, T2_Clk);
     4 Q1 O0 H* d0 j' A2 j7 k7 b
133.     Delay(10);
     ; _9 U5 ?' E2 D2 Q: i) P9 Y) B. K
134.     dat >>= 1;
     
135.   }
     " J( {0 ^/ s  T+ ], L$ ~' J7 X4 i
136.   GPIO_WriteLow(GPIOC, T2_Clk);
     
137.   Delay(10);
     
138. }
     
139. 
     0 Z( y# w2 j/ z9 q7 n
140. 
     ' c- w6 x2 S/ z, d; l# {
141. void TM1640_Init(void)
     
142. {
     
143.   TM1640_GPIO_Init();  
     
144.   Delay(10);
     
145.   TM1640_Start();
     ! u1 V7 k, d* G" N& N% p  P1 t+ R% o5 g
146.   TM1640_Write_Byte(Level8);
     
147.   TM1640_Stop();
     
148.   TM1640_2_Start();
     
149.   TM1640_2_Write_Byte(Level8);
     
150.   TM1640_2_Stop();
     
151. }
     8 B$ P/ S! I1 F
152. 
     7 ?! @5 R  N" x
153. 
     
154. void TM1640_Bit1(uint8_t *Dat)
     
155. {
     2 ~' f+ D0 o; n% P( N+ |
156.   uint8_t i;
     
157.   TM1640_Start();
     1 |7 k# c, B, b, Z, ]. W
158.   TM1640_Write_Byte(0x40);
     
159.   TM1640_Stop();
     
160.   Delay(10);
     ' g; n6 z' @. D4 [& [
161.   TM1640_Start();
     ' m, @! f0 W) S. a+ r$ j6 Y
162.   TM1640_Write_Byte(0xC0);
     ; w% u" l  o+ @( S6 Z6 D/ m1 |& B4 g
163.   for(i = 0; i < 5; i++)
     
164.   {
     1 }( c7 h/ n# F
165.     TM1640_Write_Byte(*(Dat++));
     
166.   }
     : B- U! h' y  z& N* S
167.   TM1640_Stop();
     / r& d5 s0 s! t4 Q
168. }
     
169. 
     0 t) {9 B$ D0 f# E- ?/ \+ @
170. void TM1640_Clear_C5(void)
     
171. {
     ; l4 H1 M$ Q2 s* j3 Y4 s$ C
172.   TM1640_Start();
     ) D% R) r2 g% o* E, B
173.   TM1640_Write_Byte(0x44);
     
174.   TM1640_Stop();
     ! _7 J! d7 {0 U/ G- k4 P* d0 g
175.   Delay(10);
     4 h+ n. x) l5 Z$ s* Y' L1 e6 B
176.   TM1640_Start();
     
177.   TM1640_Write_Byte(0xC5);
     ; J" Q6 j- X* a/ t, W
178.   TM1640_Write_Byte(0x00);
     9 p3 }# o  J" J, u0 B' l+ _" J
179.   TM1640_Stop();
     : N! {: |5 E' c, k$ I8 E
180.   TM1640_Start();
     
181.   TM1640_Write_Byte(0x44);
     
182.   TM1640_Stop();
     
183.   Delay(10);
     ( U; e. r1 ^* d. O. h) a) V3 o
184.   TM1640_Start();
     1 D+ V2 t- w4 F! g' y
185.   TM1640_Write_Byte(0xCD);
     ' U* ~5 X+ d; s$ c8 q
186.   TM1640_Write_Byte(0x00);
     ; j9 y( z2 q7 b4 }/ W  K) Y
187.   TM1640_Stop();
     , b6 H' c3 S+ }  V; M0 Y+ E$ z
188.   TM1640_2_Start();
     
189.   TM1640_2_Write_Byte(0xC4);
     * `5 w! D  z0 ~5 n  ]
190.   TM1640_2_Write_Byte(0x00);
     6 G: b7 q- Y  I7 E7 r$ I+ A3 ^
191.   TM1640_2_Stop();
     ! z$ A- `3 |; T- C
192. }
     8 P2 q6 ~2 z; B
193. 
     
194. void TM1640_ClearAll(void)
     
195. {
     
196.   uint8_t i;
     
197.   TM1640_Start();
     8 v$ l0 b1 I, m1 M2 E+ z: ^
198.   TM1640_Write_Byte(0x40);
     : k3 [# Z7 W7 n. N! X( o" K
199.   TM1640_Stop();
     
200.   Delay(10);
     
201.   TM1640_Start();
     % R0 U4 l7 e9 c$ M8 r3 u
202.   TM1640_Write_Byte(0xC0);
     
203.   for(i = 0; i < 16; i++)
     ' o, I6 t$ _9 v' x; ^$ n2 }6 N
204.   {
       p$ U: B1 ?4 \! `. z
205.     TM1640_Write_Byte(0x00);
       J6 N3 {( L6 P$ W
206.   }
     
207.   TM1640_Stop();
     $ D$ M" J  f% b& Z
208.   TM1640_2_Start();
     6 E% Y8 K* x$ e' _- ^% C
209.   TM1640_2_Write_Byte(0x40);
     5 X: V7 R) \+ i' @4 r' `  n) I
210.   TM1640_2_Stop();
     
211.   Delay(10);
     
212.   TM1640_2_Start();
     ' |& j$ A# B+ i5 r: A
213.   TM1640_2_Write_Byte(0xC6);
     * d1 l/ D- e4 \& I
214.   for(i = 0; i < 16; i++)
     ) h; D1 p, V5 K" Q6 m& G1 c2 K  B
215.   {
     9 D; ?/ f# _1 G- H, L
216.     TM1640_2_Write_Byte(0x00);
     ' G3 [1 n6 S" J0 L
217.   }
     
218.   TM1640_2_Stop();  
     % [( h) V4 k$ @4 Y: r
219. }
     0 H8 W8 G( I7 {, @6 L' b' O# `
220. 
     
221. void TM1640_Bit2(uint8_t *Dat)
     
222. {
     
223.   uint8_t i;
     
224.   TM1640_Start();
     
225.   TM1640_Write_Byte(0x40);
     3 \- f* e" \0 |6 ~% t, [+ E
226.   TM1640_Stop();
     
227.   Delay(10);
     
228.   TM1640_Start();
     
229.   TM1640_Write_Byte(0xC6);
     
230.   for(i = 0; i < 5; i++)
     
231.   {
       X, f$ o6 h0 M- t+ u8 q8 x
232.     TM1640_Write_Byte(*(Dat++));
     
233.   }
     9 V7 M4 a( O+ {  e/ K6 c$ c
234.   TM1640_Stop();
     0 g, a$ }/ w4 T6 K6 Z
235. }
     # X- n4 P/ y+ Z" A; i
236. 
     : }+ {# d9 @. |' D3 T0 x1 k( k
237. void TM1640_Bit3(uint8_t En)
     8 ?3 M$ q+ ?. U
238. {
     
239.   TM1640_Start();
     
240.   TM1640_Write_Byte(0x44);
     
241.   TM1640_Stop();
     . H7 X4 C/ L1 {5 ]$ J/ p2 g
242.   Delay(10);
     4 {' K% V, \9 D
243.   TM1640_Start();
     
244.   TM1640_Write_Byte(0xCC);
     
245.   if(En)
     
246.     TM1640_Write_Byte(NUM[10][2]);
     
247.   else
     
248.     TM1640_Write_Byte(0x00);
     
249.   TM1640_Stop();
     
250. }
     / L. c* \6 N3 Z
251. 
     
252. void TM1640_2_Bit4(uint8_t *Dat)
     
253. {
       v* q! x8 K7 x5 E* x
254.   uint8_t i;
     , k0 @# E( Y% _+ d' O
255.   TM1640_Start();
     
256.   TM1640_Write_Byte(0x44);
     
257.   TM1640_Stop();
     
258.   Delay(10);
     & H; r* o7 Z$ {" K/ E% C& f
259.   TM1640_Start();
     
260.   TM1640_Write_Byte(0xCE);
     ; A5 u  U; ?6 F4 H/ A- x+ C$ i# a
261.   TM1640_Write_Byte(*(Dat++));
     2 D4 G0 ?9 H1 R6 ~
262.   TM1640_Stop();
     
263.   TM1640_2_Start();
     
264.   TM1640_2_Write_Byte(0x44);
     5 h" Z: y* @  ^  a
265.   TM1640_2_Stop();
     8 n! \( q3 o5 m+ D+ |- c, X
266.   Delay(10);
     
267.   TM1640_2_Start();
     
268.   TM1640_2_Write_Byte(0xC0);
     # a6 N2 v. t* U7 s& V3 P% |. W
269.   for(i = 1; i < 5; i++)
     
270.   {
     
271.     TM1640_2_Write_Byte(*(Dat++));
     
272.   }
     4 O4 A. U. X9 Y
273.   TM1640_2_Stop();
     
274. }
     9 Q: e! v' a; z0 z9 E
275. 
     # s$ w1 k* z* q9 Y) L
276. void TM1640_2_Bit5(uint8_t *Dat)
     
277. {
     
278.   uint8_t i;
     4 T; n* s( |+ e- g! _; l
279.   TM1640_2_Start();
     
280.   TM1640_2_Write_Byte(0x40);
     
281.   TM1640_2_Stop();
     
282.   Delay(10);
     
283.   TM1640_2_Start();
     7 @6 h7 B* j$ f: J7 ~0 V: d0 B
284.   TM1640_2_Write_Byte(0xC5);
     
285.   for(i = 0; i < 5; i++)
       u: H4 s( w0 ]( d/ B( K
286.   {
     
287.     TM1640_2_Write_Byte(*(Dat++));
     
288.   }
     4 X4 u# B, Y. I+ _/ B4 h; v, k. \/ g
289.   TM1640_2_Stop();
     
290. }

复制代码

--------------------------------------------------------------------------------------------
# J; I' z5 ~( K, ]  F% x2 @

调试器都忘记放啦，做了几十片，大家可以看一下

zhao.zhao 发表于 2017-5-24 08:50
" ]; N( ^6 [' n. W% I6 G针对特定场合，这个芯片还是不错的，只是不知高电压的大的数码管支持吗

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

zhao.zhao 发表于 2017-5-21 14:10
$ K$ K9 C4 v; H8 X! w$ ?" q% u' s这个芯片扩展性不行，驱动有点麻烦，也许控制少量几个数码管或LED点阵屏可以，量多了就不行了，影响了其使 ...

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

zhao.zhao 发表于 2017-5-21 14:10
' ]: W" z& X) z( O. X这个芯片扩展性不行，驱动有点麻烦，也许控制少量几个数码管或LED点阵屏可以，量多了就不行了，影响了其使 ...

$ q( ]. V2 y% u* E  u你要怎么扩展，一颗芯片可以驱动128个LED灯，如果需要的可以用TM1680，可以控制384个点；

不错，学习了！

不知这个芯片的价格几何？
5 p. k% U7 E" w% B$ {

zhao.zhao 发表于 2017-5-20 14:54
不知这个芯片的价格几何？

0.8
& p! R% U5 S; z0 _8 Y& @1 p& y# P; T- J

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

0.8是多大量时的价格?

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

5 l. P; M' K  |" P& i4 j嗯，这家貌似有很多这样的芯片，，方便多了

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

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

Ljmp 发表于 2017-5-22 14:44
: G% A; a3 @. n! U欢迎大家使用，我们公司还有很多其他的LED驱动芯片；

我宣传有样片没

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

用过TM1650驱动4位数码管，I2C驱动，可以节省单片机IO口。
- I0 a: `5 r% Z应该和楼主TM1640功能类似吧

好像还不错