1、HT1621电路分析

      HT1621为32×4即128点内存映像LCD驱动器，包含内嵌的32×4位显示RAM内存和时基发生器以及WDT看门狗定时器．

      HT1621驱动电路如下图所示：

& n, k+ I& ?: E& {- k8 L. h

图1

          与单片机相连接控制的有9脚CS，3脚WR，12脚DATA，其功能描述如下表。

+ O5 m$ U5 @& F' ]# x" @# e

图2

2、字符显示原理

         液晶管点亮和熄灭原理分别为在对应的RAM地址中写1和写0．首先需要清楚所驱动控制的液晶的COM-SEG对应关系，然后需要了解HT1621的32×4RAM地址映射。

         例如要控制的液晶的装脚成品图部分如下：

) O! }, v8 }$ U5 x' X

图3

        着重看一个液晶数码管，我们了解原理就行。可以看到图3中是第2个液晶数码管，有7段，分别为A,B,C,D,E,F,G。也就分别为下面COM\SEG地址对应关系图中的2A,2B,2C,2D,2E,2F,2G。

        液晶的显示字符的部分COM公共端输出口和SEG段输出口的分布如下表所示，同理我们可以看到例如:2D对应(SEG5,COM0),2E对应(SEG5,COM1),2F对应(SEG5,COM2),2A对应(SEG5,COM3),2C对应(SEG4,COM1),2G对应(SEG4,COM2),2B对应(SEG4,COM3)。

/ o& b2 ]' d2 o+ K

图4

         搞清楚我们要控制的对象之后那，  HT1621的RAM 地址映射如下图所示：

图5

        可以清楚的看到要控制液晶段对应SEG号作为6位地址，COM号对应作为4位数据写入，此时注意4位数据的高低位。写数据到RAM命令格式为：101+6位RAM地址+4位数据，其中RAM地址为SEG序号．

        例如我们在图3的第二个液晶数码管上显示数字，首先我们根据图3得到地址映射关系，先写入地址SEG4中的四位数据(COM3,COM2,COM1,COM0),再写如地址SEG5中的四位数据(COM3,COM2,COM1,COM0),对应关系如下：

SEG4				SEG5
COM3	COM2	COM1	COM0	COM3	COM2	COM1	COM0
2B	2G	2C	T10	2A	2F	2E	2D

) ]- G7 p& R" ^' [- \; y1 _

        所以如果在图3中显示“5”，则在显示的液晶段对应地址上写1，不显示写0，如下图所示。所以SEG4地址应写入的数据为0110 ，SEG5地址应写入数据1101。

- t% t& f: _  e8 O2 }& m7 a

7 \: I) P/ L" @5 y5 g5 X9 M

图6

3、显示的保持      

     写数据过程需要保证写前无关位数据的保持，因此在单片机程序中开辟32×4数组作为虚拟ARM，存储写前LCD显示数据．通过与清零，或置位操作实现，例如6位地址Address当前显示的数据为Data_last ．若Xi(i=0,1,2,3) 位需要保持，则Xi为1，否则Xi为0．写入的数据为Data_now，变换公式为:

( \5 K* m, m: f: }

4、程序

      主要的程序编写流程如下：

: Z7 N- ~- r8 u, }9 \

图7

            程序的参考步骤：①Display_Wendu_1②write_addr_dat_n_wendu③write_mode④write_address⑤write_data_4bit，其中Lcdram数组为建立的虚拟数组。

1. unsigned char Lcdram[32]=
   ! F5 y: O( b5 X/ i
2.     {
   8 k$ d9 z- U7 A& S  V+ k; _1 }
3.                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
   * Q5 m, H7 h* ^8 I" q
4.                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
   
5.                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
   0 O9 Z# ^, ?! ]9 p
6.                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
   5 K3 [2 q- K1 X6 [$ q2 L1 X
7.     };
   3 O! ~% U  }3 @/ k' l  h
8. 
   , \! A+ R7 M! G$ e1 f: ?, S
9. const unsigned char Wendu[] = //温度0-9
   ' T' n1 a; d; B+ h$ B
10.     {
    / n5 F( I1 Z& `% T5 ?/ @
11.     0X5F, 0X50, 0X3D, 0X79, 0X72, 0X6B, 0X6F, 0X51, 0X7F, 0X7B
    0 C$ J" Y& \, c0 A
12.     };
    
13. ///////////////////////////////////////////////////驱动函数
    ; ?. _) |$ D/ n8 W
14. /*
    0 N, S8 P. Q8 @+ _
15. *    LCD 模式写入
    
16. *    入口:MODE :COM(命令模式) DAT(数据模式)
    9 _* e4 e) E6 d9 e) V
17. *    出口:void
    
18. */
    % y9 W6 c0 c- d4 f5 h& _
19. void write_mode(unsigned char MODE)    //写入模式,数据or命令
    ! q- C! Y. A, h+ ?/ Z" K
20. {
    
21.     GPIO_ResetBits(GPIOB, HT1621_WR);                                //    RW = 0;
    
22.     delay_us(10);
    ) n) z* I: o  [" f& @
23.     GPIO_SetBits(GPIOB, HT1621_DATA);                                    //    DA = 1;
    
24.     GPIO_SetBits(GPIOB, HT1621_WR);                                    //    RW = 1;
    $ \5 a6 I1 v& {
25.     delay_us(10);
    
26. 
    
27.     GPIO_ResetBits(GPIOB, HT1621_WR);                                //    RW = 0;
    + K, C2 q4 q7 M* _: L4 C, @3 R% a, Z
28.     delay_us(10);
    
29.     GPIO_ResetBits(GPIOB, HT1621_DATA);                                //    DA = 0;
    % E6 p6 Z; a$ n& _( J
30.     GPIO_SetBits(GPIOB, HT1621_WR);                                    //    RW = 1;
    
31.     delay_us(10);
    . e7 U- A! ^4 W8 p3 A- y
32. 
    
33.     GPIO_ResetBits(GPIOB, HT1621_WR);                                //    RW = 0;
    ; p# K1 u7 r4 z+ \8 h7 }
34.     delay_us(10);
    
35. 
    
36.     if (0 == MODE)
    
37.     {
    
38.         GPIO_ResetBits(GPIOB, HT1621_DATA);                            //    DA = 0;
    
39.     }
    " S# K! P0 R+ T. f
40.     else
    5 y% i% D* D5 A2 y1 |
41.     {
    ) G5 u% ~' a  y, w7 {: A) q
42.         GPIO_SetBits(GPIOB, HT1621_DATA);                                //    DA = 1;
    
43.     }
    , L6 I! k2 d" ?  K0 c3 Y" k
44.     delay_us(10);
    3 ?/ D9 e1 X; a3 T2 B$ Q
45.     GPIO_SetBits(GPIOB, HT1621_WR);                                    //    RW = 1;
    
46.     delay_us(10);
    
47. }
    
48. 
    
49. /*
    
50. *    LCD 命令写入函数
    3 v9 [1 c2 O. }# X
51. *    入口:cbyte ,控制命令字
    5 q7 o# b1 `7 D1 [
52. *    出口:void
    
53. */
    
54. void write_command(unsigned char Cbyte)
    # N5 \2 b* v8 ?
55. {
    / L" D7 M1 s6 z3 N( v8 \
56.     unsigned char i = 0;
    
57. 
    
58.     for (i = 0; i < 8; i++)
    + F. t$ {1 b- D7 G$ P8 z
59.     {
    % G; g4 y4 g  P  _+ T/ m
60.         GPIO_ResetBits(GPIOB, HT1621_WR);
    0 n- F' s: [" P. P: _
61.         if ((Cbyte >> (7 - i)) & 0x01)
    
62.         {
    6 d/ ]9 |9 J9 g* [
63.             GPIO_SetBits(GPIOB, HT1621_DATA);
    9 K8 H/ h9 y1 l7 K& d
64.         }
    
65.         else
    
66.         {
    
67.             GPIO_ResetBits(GPIOB, HT1621_DATA);
    & R3 t! E: ~6 _  Y
68.         }
    + e7 q+ G" |& z4 I7 B) Q0 }
69.         delay_us(10);
    
70.         GPIO_SetBits(GPIOB, HT1621_WR);
    7 y. b1 V2 H, U( Z! L, f. G
71.         delay_us(10);
    
72.     }
    : U$ Z+ ^$ y- L# j# A3 S2 g
73.     GPIO_ResetBits(GPIOB, HT1621_WR);
    
74.     delay_us(10);
    
75.     GPIO_ResetBits(GPIOB, HT1621_DATA);
    
76.     GPIO_SetBits(GPIOB, HT1621_WR);
    
77.     delay_us(10);
      `$ M# P' Z/ S) o/ `; t! [
78. }
    
79. 
    9 H' _% K  M5 F% \. z
80. /*
    - _; Q3 N7 C, H$ Z; n7 w+ T/ A% J
81. *    LCD 地址写入函数
    $ g, u0 {' B3 K
82. *    入口:cbyte,地址
    # o) w& ]) _$ u" B: `6 o( N
83. *    出口:void
    
84. */
    
85. void write_address(unsigned char Abyte)
    
86. {
    
87.     unsigned char i = 0;
    ( q5 \( x( c! [9 N+ R' g
88.     Abyte = Abyte << 2;
    4 a+ x$ x3 }. Y% d8 H0 D. G
89. 
    
90.     for (i = 0; i < 6; i++)
    # ]( T  |, u. }; J0 k
91.     {
    ; r( X$ d6 o- e( l$ j4 a2 j# Q' T7 d
92.         GPIO_ResetBits(GPIOB, HT1621_WR);
    . U0 L0 `4 I; S5 `7 @; e  s
93.         //delay_us(10);
    
94.         if ((Abyte >> (7 - i)) & 0x01)
    * k* `7 a' f9 G% t
95.         {
    
96.             GPIO_SetBits(GPIOB, HT1621_DATA);
    ! W" X2 M6 e+ S3 K' r. b, M
97.         }
    
98.         else
    % L# d$ R$ g) H% b4 ]3 ?+ J
99.         {
    
100.             GPIO_ResetBits(GPIOB, HT1621_DATA);
     
101.         }
     + h2 k* `9 c5 E3 Z1 I- Q
102.         delay_us(10);
     1 P3 b3 t/ A5 R# i# K& H
103.         GPIO_SetBits(GPIOB, HT1621_WR);
     7 B" R' _! k  P  l
104.         delay_us(10);
     1 ?& C9 A  K7 Q3 m4 N: g
105.     }
     , B- x( o9 X' }9 s/ x0 t
106. 
     
107. }
     
108. 
     1 j  P( r- w2 w4 _8 g
109. /*
     / P% k% R3 Y" H
110. *    LCD 数据写入函数
     
111. *    入口:Dbyte,数据
     7 `& }* E7 R. s$ i3 L- U
112. *    出口:void
     % E# T; R( `- G! X
113. */
     
114. void write_data_8bit(unsigned char Dbyte)
     9 {3 k6 B6 G: t- j6 ]
115. {
     : L4 k" p! ]4 s% t  |; u' C9 z
116.     int i = 0;
     4 Z- i( D: {" `& s0 [
117. 
     
118.     for (i = 0; i < 8; i++)
     ! u% R7 g/ V9 @# P7 M7 l6 A
119.     {
     
120.         GPIO_ResetBits(GPIOB, HT1621_WR);
     ' a0 m# \  g- y; W4 j* x
121.         delay_us(10);
     2 ~/ n5 ~; l+ C) e/ |  f8 N/ d5 I
122.         if ((Dbyte >> (7 - i)) & 0x01)
     9 c. ~" |5 t% q
123.         {
     - U# `; M( [* _% i  Q$ i
124.             GPIO_SetBits(GPIOB, HT1621_DATA);
     
125.         }
     
126.         else
     " |) Z" o/ Z% p: n8 m
127.         {
     5 }! k$ H* u: a! j3 H
128.             GPIO_ResetBits(GPIOB, HT1621_DATA);
     " A" t% J* O' `7 H# `
129.         }
     
130.         delay_us(10);
     
131.         GPIO_SetBits(GPIOB, HT1621_WR);
     4 B$ r4 N- R8 k
132.         delay_us(10);
       q6 C# i# j+ s
133.     }
     
134. }
     
135. 
     - P- }) S$ m, [8 x7 J# @
136. void write_data_4bit(unsigned char Dbyte)
     , ]8 n8 P9 m, O
137. {
     9 p# f) i$ C' o
138.     int i = 0;
     # z) X" ^% }- ^) g# G" J6 f1 {
139. 
     
140.     for (i = 0; i < 4; i++)
     
141.     {
     
142.         GPIO_ResetBits(GPIOB, HT1621_WR);
     
143.         //delay_us(10);
     
144.         if ((Dbyte >> (3 - i)) & 0x01)
     & G# |/ y7 ^0 X
145.         {
     
146.             GPIO_SetBits(GPIOB, HT1621_DATA);
     
147.         }
     
148.         else
     
149.         {
     ) D( d/ n2 h7 k3 t0 ?# x
150.             GPIO_ResetBits(GPIOB, HT1621_DATA);
     
151.         }
     ) ]  N0 t" O. e  I7 U3 x. {  G
152.         delay_us(10);
     
153.         GPIO_SetBits(GPIOB, HT1621_WR);
     ; ^0 y1 ~3 m  x) f: m
154.         delay_us(10);
     
155.     }
     ! ~/ K7 ^5 y, C5 K/ {# n9 h: N: S" ]
156. }
     
157. 
     ' H: H+ M2 y' S8 W/ e6 M- P( t1 K
158. 
     
159. 
     
160. //1621初始化
     # t& I5 ^6 R3 u' k1 Q  n2 Z
161. void ht1621_init(void)
     
162. {
     3 @1 [9 }, o0 T* ?; g% i
163.         GPIO_InitTypeDef GPIO_InitStructure;// declare the structure
     
164.         GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE);
     
165. 
     4 `) q4 r$ U( b' m6 s
166.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOB, ENABLE);
     
167.         memset(&GPIO_InitStructure, 0, sizeof(GPIO_InitTypeDef));
     . w8 S& @9 K9 ?
168.         GPIO_InitStructure.GPIO_Pin =  HT1621_WR | HT1621_DATA ;//| HT1621_IRQ
     
169.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
     
170.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     ; U4 c6 R4 S: ^* e( Y
171.         GPIO_Init(GPIOB, &GPIO_InitStructure);
     " g3 V9 [. v5 F2 M# e4 {
172. 
     
173.         memset(&GPIO_InitStructure, 0, sizeof(GPIO_InitTypeDef));
     
174.         GPIO_InitStructure.GPIO_Pin = HT1621_CS ;//| HT1621_IRQ
     % h% R) D8 w# F4 ~' T# q
175.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
     
176.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     
177.         GPIO_Init(GPIOA, &GPIO_InitStructure);
     / X- Q$ V$ Q! I: i
178. 
     
179. }
     
180. 
     
181. /*
     # u# T! T0 \* j7 C2 h
182. *    LCD 初始化，对lcd自身做初始化设置
     
183. *    入口:void
     
184. *    出口:void
     7 X3 E$ M, Y. ], ]$ }$ n
185. */
     
186. void lcd_init(void)
     5 z/ `# H. }! A7 @) h; Y+ s
187. {
     
188.     //////////////////////////////////////////////////////
     6 F2 ~9 U0 J8 }0 e1 D
189.     GPIO_SetBits(GPIOA, HT1621_CS);
     2 s) y+ B4 x  m  B0 I, S
190.     GPIO_SetBits(GPIOB, HT1621_WR);
     5 l( O1 P7 p0 R% [2 S* o  r+ m
191.     GPIO_SetBits(GPIOB, HT1621_DATA);
     : K* `6 m* e0 L  P1 C
192.     for (ii=0;ii<10000;ii++)
     ' k7 Y& z8 y2 X1 F2 u0 F% U
193.     {for(j=10;j>0;j--);}
     $ u( ?" T1 _# a) V) c
194.     //////////////////////////////////////////////////////
     ! U. X, G" b2 Y3 k. W- v
195.     GPIO_ResetBits(GPIOA, HT1621_CS);        //CS = 0;
     . S7 j2 b7 V9 k, `, X% Q: b- E: F
196.     //delay_us(10);
     
197.     for (ii=0;ii<10000;ii++)
     ) f, L( S- O+ }/ ~: w( V
198.     {for(j=10;j>0;j--);}
     8 i7 ], M, O' V/ k( a
199.     write_mode(COMMAND);    //命令模式
     
200.     write_command(0x01);    //Enable System
     , U+ m$ d* \8 T& p
201.     write_command(0x03);    //Enable Bias
     
202.     write_command(0x04);    //Disable Timer
     6 `0 r$ ], l4 k7 c& a+ s0 v" E! @
203.     write_command(0x05);    //Disable WDT
     ) G+ H$ P' P. @' N2 R6 S4 c
204.     write_command(0x08);    //Tone OFF
     ! B: i, b/ l& t
205.     write_command(0x18);    //on-chip RC震荡
     
206.     write_command(0x29);    //1/4Duty 1/3Bias
     ! ~5 y# g1 F  J4 V2 `  a
207.     write_command(0x80);    //Disable IRQ
     
208.     write_command(0x40);    //Tone Frequency 4kHZ
     ) X7 _: k& q, l( S! v
209.     write_command(0xE3);    //Normal Mode
     3 R* t( t" @0 }
210. 
     6 n9 T+ _$ Q2 W
211.     GPIO_SetBits(GPIOA, HT1621_CS);  //CS = 1;
     + w: \' t5 O9 l; l, n* f1 e7 Z
212. }
     
213. 
     
214. /*
     
215. *    LCD 清屏函数
     0 q# O3 U" S& l; z4 i
216. *    入口:void
     
217. *    出口:void
     
218. */
     
219. void lcd_clr(void)
     & R; r0 U, g4 F
220. {
     
221.     write_addr_dat_n(0x0, 0x00, 32);//15
     5 v) t/ |+ T. Q' O& N6 K/ p# Y5 S; g; e
222. }
     , C% a+ r+ A8 l7 J. f
223. //用于温度区域写数据
     
224. void write_addr_dat_n_wendu(unsigned char _addr, unsigned char _dat, unsigned char n)
     8 N& _" V: ?1 w7 g* C
225. {
     + G9 t- ]5 B7 d8 O8 C* s
226. 
     # B7 e' R( C0 H( |, D# h
227.     unsigned char i = 0;
     ' K# m5 P1 x8 q) l5 W, f9 m" j
228.     unsigned char _dat_temp1,_dat_temp2;
     , e4 x) v7 B  Z5 B
229. 
     $ H/ F) Q) M8 O$ X' a
230.     //WriteLcdram(_addr, _dat);
     . E. g9 s  j8 J& x( a$ Q9 x
231. 
     9 a9 s% ]( G: R" J
232. 
     
233. 
     
234.     GPIO_ResetBits(GPIOA, HT1621_CS);                                // CS = 0;
     
235.     write_mode(DAT);
     & \$ [( t& a" V! T2 p# `
236. 
     
237.     if(Lcdram[_addr]==0x00)
     
238.     {
     3 F6 S/ y. `6 b$ b5 ^( E6 `* R, K
239.         WriteLcdram(_addr, _dat);
     
240.     }
     + @: z8 @/ T1 `# N# q4 \$ l/ A* ]/ u
241.         if((_addr%2)==0)
     : @" z3 b9 X: o* o1 @8 e( v2 M/ ]
242.         {
     : K. h. L" f; L3 r& L, P
243.             _dat_temp1=Lcdram[_addr];
     
244.             _dat_temp2=(_dat_temp1&0x08)|_dat;
     
245. 
     - \% V8 f- y' w! O+ K
246.             write_address(_addr);
     
247.             for (i = 0; i < n; i++)
     1 @5 p9 o6 U0 P) H' P6 U9 G6 W
248.         {
     * h) ]6 v  M" Z- Q0 M: m
249.             write_data_4bit(_dat_temp2);
     
250.         }
     4 n' s8 l8 b" x; }# o
251.         GPIO_SetBits(GPIOA, HT1621_CS);                                    //CS = 1;
     
252. 
     
253.         }
     
254.         else if((_addr%2)!=0)
     : R3 Z8 c1 _+ ^' k
255.         {
     9 I* g: c, E4 E) |& s
256.             write_address(_addr);
     8 G- }- C2 w; Q- [' o1 K
257.             for (i = 0; i < n; i++)
     
258.         {
     
259.             write_data_4bit(_dat);
     
260.         }
     
261.         GPIO_SetBits(GPIOA, HT1621_CS);
     
262.         }
     . M6 o7 _4 V$ h* ?+ O3 V
263. 
     
264.         WriteLcdram(_addr, _dat_temp2);
     # Y- w) @% B4 `
265. }
     3 ~( g8 i$ v5 `5 u* ?8 W* n
266. 
     ) T$ ~5 U1 q5 a
267. //用于湿度区域写数据
     
268. void write_addr_dat_n_shidu(unsigned char _addr, unsigned char _dat, unsigned char n)
     
269. {
     
270. 
     
271.     unsigned char i = 0;
     
272.     unsigned char _dat_temp1,_dat_temp2;
     # C% |9 @9 V$ j. e
273. 
     - j* |2 T7 N! Z7 {
274.     //WriteLcdram(_addr, _dat);
     
275. 
     % Y" J  v4 w8 U
276. 
     
277. 
     
278.     GPIO_ResetBits(GPIOA, HT1621_CS);                                // CS = 0;
     . r) `+ e" }* O3 |  G: [$ G  d( ]
279.     write_mode(DAT);
     6 ~! V0 D, y7 i0 z+ D6 L
280. 
     
281.     if(Lcdram[_addr]==0x00)
     
282.     {
     + h% f: `! s( m: _8 a/ z9 j
283.         WriteLcdram(_addr, _dat);
     
284.     }
     - @: Z; R- |; D* m4 y
285.         if((_addr%2)==0)
     + ^: U1 j& r- }1 E) k
286.         {
     # M% y6 \8 t% r, r! |, l5 M' b: o3 H
287.             _dat_temp1=Lcdram[_addr];
     
288.             _dat_temp2=(_dat_temp1&0x01)|_dat;
     
289. 
     
290.             write_address(_addr);
     
291.             for (i = 0; i < n; i++)
     
292.         {
     1 o1 E7 O( ~" M! B
293.             write_data_4bit(_dat_temp2);
     4 ~3 o4 [' t+ R
294.         }
     - N9 G9 t" _; H  R' Z) ~5 e+ }, |
295.         GPIO_SetBits(GPIOA, HT1621_CS);                                    //CS = 1;
     ' I* m3 _( ]" v+ J
296. 
     
297.         }
     
298.         else if((_addr%2)!=0)
     5 ^8 Z2 I$ x- K& Z
299.         {
     
300.             write_address(_addr);
     % d) m! d( U+ R2 d# @9 w
301.             for (i = 0; i < n; i++)
     $ [2 ?& h5 K8 G8 @  \
302.         {
     9 }5 u6 v7 F+ ^6 K* V  {
303.             write_data_4bit(_dat);
     $ n  m4 R1 z+ Q1 S/ P
304.         }
     
305.         GPIO_SetBits(GPIOA, HT1621_CS);
     4 [- V, {2 h6 Z0 m
306.         }
     
307. 
     8 q) K0 m0 A8 X9 O# \3 F
308.         WriteLcdram(_addr, _dat_temp2);
     
309. }
     
310. 
     # w1 I( q" Q# S3 U
311. 
     + D8 J% J8 M6 {
312. //用于底部数字写数据
     6 ~" B9 e; ?+ ?! ]" v
313. void write_addr_dat_n_others(unsigned char _addr, unsigned char _dat, unsigned char n)
     
314. {
     4 I2 `6 n0 Y3 F2 a) z
315. 
     3 V& I' i2 E9 g1 |, F( W* u) E
316.     unsigned char i = 0;
     
317.     unsigned char _dat_temp1,_dat_temp2;
     6 J. B* H) g- n
318.     GPIO_ResetBits(GPIOA, HT1621_CS);                                // CS = 0;
     
319.     write_mode(DAT);
     $ U& _, w6 ?1 q1 d
320. 
     
321.     if(Lcdram[_addr]==0x00)
     8 [& h7 B8 }1 i5 K2 C
322.     {
     
323.         WriteLcdram(_addr, _dat);
     ( V9 b" k9 M2 i6 g
324. 
     
325.     }
     0 P  c2 |2 O5 ~3 K7 i! s5 f
326.         if((_addr%2)==0)
     
327.         {
     5 Y) B- j7 H! Q' e/ ^
328.             _dat_temp1=Lcdram[_addr];
     - k' R) g1 U1 [' h2 N; G8 x
329.             _dat_temp2=(_dat_temp1&0x01)|_dat;
     ' }9 J+ T/ D; z, I/ c( W
330. 
     
331.             write_address(_addr);
     / R: e' _% V- [* s
332.             for (i = 0; i < n; i++)
     
333.         {
     
334.             write_data_4bit(_dat_temp2);
     4 l  e; z& A) o
335.         }
     # _5 f3 z( W, |$ A& c
336.         GPIO_SetBits(GPIOA, HT1621_CS);                                    //CS = 1;
     
337. 
     
338.         }
     
339.         else if((_addr%2)!=0)
     
340.         {
     
341.             write_address(_addr);
     ! A  a& G+ M( `0 p3 o! t
342.             for (i = 0; i < n; i++)
     1 p  a4 V, e& s& n* k
343.         {
     5 N! d/ v' T; B5 K; K
344.             write_data_4bit(_dat);
     
345.         }
     
346.         GPIO_SetBits(GPIOA, HT1621_CS);
     # {1 v# `' e  B' ?6 ?
347.         }
     
348. 
     % W" u4 T; y, B9 \% a4 h
349.         //WriteLcdram(_addr, _dat);
     
350.         WriteLcdram(_addr, _dat_temp2);
     
351. }
     / O/ U1 }! P2 F$ T# e1 S. X( r1 K8 P
352. 
     ( _* i' X) j: S
353. //用于字符写数据
     
354. void write_addr_dat_n_char(unsigned char _addr, unsigned char _dat, unsigned char state)
     
355. {
     
356. 
     ) h4 I3 T! R9 E8 ^+ G/ {. i
357.     unsigned char i = 0;
     / |( L2 c6 }, T% X! x
358.     unsigned char _dat_temp1,_dat_temp2;
     3 W8 U  N5 H- ]* o/ T! @
359. 
     ! c) p* o6 K3 Z2 U0 [% {. ~9 V
360. 
     " F) R" o$ N- Z
361.         GPIO_ResetBits(GPIOA, HT1621_CS);                                // CS = 0;
       j/ b/ d* y; S
362.          write_mode(DAT);
     
363. 
       M' Q7 O+ w& W- N. I4 T8 x: l
364.                 _dat_temp1=Lcdram[_addr];
     # |; _; V6 ^) W+ _& c
365.             if(state==1)
     
366.             {
     ' S% `  L% }: {& M, K
367. 
     6 g* y4 B; I& p
368.                 _dat_temp2=(_dat_temp1|_dat);
     " _6 v: ?8 Q" `! b3 E' Z; E: C
369.             }
     
370.             else if(state==0)
     
371.             {
     1 ?( m: e# }6 D/ P
372.                 _dat_temp2=(_dat_temp1&(~_dat));
     1 ]' z8 t% o- j# C, H
373.             }
     + V* {7 A, l: R1 ~! Z- V5 s
374.                  write_address(_addr);
     , w. ]2 J, E- z: }# M$ n+ N& H
375. 
     ' r& W9 T" a6 d- F
376.                 for (i = 0; i < 1; i++)
     
377.             {
     
378.                 write_data_4bit(_dat_temp2);
     & ]+ k  p" W/ ]0 `5 B7 A5 k
379.             }
     
380.             GPIO_SetBits(GPIOA, HT1621_CS);                                    //CS = 1;
     
381.             WriteLcdram(_addr, _dat_temp2);
     2 |7 H' V7 e# b) z7 n
382. 
     $ w1 `- ^4 l2 M
383. 
     ! j5 P9 g" O; Z
384. 
     - b7 L2 S7 L: p! ~% Z# O6 ]
385. 
     
386. }
     
387. //显示温度
     
388. //入口：pos，显示位置，地址0、2、4分别为从右到左的三个数字
     
389. //            num：要显示的一位数
     
390. void Display_Wendu_1(unsigned char add, unsigned char num )
     
391. {
     
392.     unsigned char n,i,j;
     
393.     n=getChr_Wendu(num);
     
394.     i=(n&0xF0)>>4;
     - K: V* O5 ]9 V$ V: k$ Q
395.     j=n&0x0F;
     
396.     write_addr_dat_n_wendu(add,i,1);
     
397.     write_addr_dat_n_wendu(add+1,j,1);
     1 m3 m1 U0 g4 H" y( X7 t$ I
398. 
     . m/ X/ n/ i- d1 v
399. }
     - z& Q' U3 n% Z; \  i4 P2 E; m# |$ [
400. 
     & E! N+ H; C( E* l" J& V
401. 
     
402. //温度数据转换，lcd.c内部使用
     
403. unsigned char getChr_Wendu(unsigned char c)
     
404. {
     
405.      unsigned char i;
     
406.         for ( i = 0; i < 10; ++i)
     - ]$ @" y2 N; ?9 h  S
407.         {
     
408.             if (c == i)
     
409.             {
     
410.                 return Wendu[i];
     
411.             }
     
412.         }
     
413.     }
     - U' q8 a; z' [8 a2 v! z+ ?
414. 
     
415. //更新lcdram数组
     7 m' g( B+ E* N- ~
416. void WriteLcdram(unsigned char add, unsigned char data)
     
417. {
     
418. 
     5 x+ g  p! M$ T/ ?- `
419.     Lcdram[add]=data;
     
420. 
     $ V+ y) y0 u* |! W% c0 a- G9 b# Q$ \
421. }

复制代码

1 _  }" X8 ~6 i- I: D

  C1 o( s& W1 t

ST有自带段码液晶驱动型号吗？