1、HT1621电路分析

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

      HT1621驱动电路如下图所示：

图1

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

  h' Z* q0 p) H# X4 D

图2

2、字符显示原理

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

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

' _, ~7 F0 P7 D2 S* w* ^

图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)。

. K7 t$ R0 b* I& @  @" I- Q$ z

图4

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

, R: o' m1 ^: \2 r" @/ b

图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

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

# d0 R( j1 O" T! `8 I! M$ x

图6

3、显示的保持      

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

+ c/ b0 y& v7 W8 J

4、程序

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

, ?' d% y: I; q8 d5 j+ Z& @' R

图7

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

3 t% ~/ g4 j' p' A5 I

1. unsigned char Lcdram[32]=
   
2.     {
   ( q) Z( p; Z0 [4 S1 z' h
3.                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
   / a2 Q& x. S, B# b. o
4.                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
   
5.                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
   
6.                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
   0 ?* t9 m; F  ]; B6 I
7.     };
   5 v+ L/ \/ l8 W3 {5 W% o
8. 
   
9. const unsigned char Wendu[] = //温度0-9
   3 T  v1 E' C$ R# S+ I
10.     {
    6 H1 s. L1 t6 l7 \' j0 [
11.     0X5F, 0X50, 0X3D, 0X79, 0X72, 0X6B, 0X6F, 0X51, 0X7F, 0X7B
    
12.     };
    
13. ///////////////////////////////////////////////////驱动函数
    : E- s; n8 h. u
14. /*
    
15. *    LCD 模式写入
    
16. *    入口:MODE :COM(命令模式) DAT(数据模式)
    ; N4 \5 s. K: s: Q, L0 O8 F& N
17. *    出口:void
    % |" F& O4 a3 }. u6 W
18. */
    
19. void write_mode(unsigned char MODE)    //写入模式,数据or命令
    % v% g: F: E5 D, y- |+ d9 T
20. {
    # K! D" f! f  |7 T9 k2 Y% m
21.     GPIO_ResetBits(GPIOB, HT1621_WR);                                //    RW = 0;
    6 d5 ?+ ?& e7 x' p
22.     delay_us(10);
    4 U* D0 x' z- d6 G! W$ Z( N3 e: D
23.     GPIO_SetBits(GPIOB, HT1621_DATA);                                    //    DA = 1;
    
24.     GPIO_SetBits(GPIOB, HT1621_WR);                                    //    RW = 1;
    : K! f) j0 b1 c* E7 ]+ s( M# t
25.     delay_us(10);
    
26. 
    
27.     GPIO_ResetBits(GPIOB, HT1621_WR);                                //    RW = 0;
    
28.     delay_us(10);
    
29.     GPIO_ResetBits(GPIOB, HT1621_DATA);                                //    DA = 0;
    7 v8 i& G" x5 K* G+ K
30.     GPIO_SetBits(GPIOB, HT1621_WR);                                    //    RW = 1;
    
31.     delay_us(10);
    ' S% p; c. Y# j1 z' I5 d- l& C, j
32. 
    0 Z, R0 I5 J4 _* a
33.     GPIO_ResetBits(GPIOB, HT1621_WR);                                //    RW = 0;
    
34.     delay_us(10);
    
35. 
    ; w+ E# [+ l, T
36.     if (0 == MODE)
    1 z% [8 U, B2 d1 }/ b( \" d: M
37.     {
    * b- N& T; _; B
38.         GPIO_ResetBits(GPIOB, HT1621_DATA);                            //    DA = 0;
    6 ]- d2 K9 d$ z' ^0 R+ D2 T& Z, p% c
39.     }
    ! w* h2 k! o( ^3 z
40.     else
    
41.     {
      ^* Q% y, {! l8 K3 \0 q" Y/ e
42.         GPIO_SetBits(GPIOB, HT1621_DATA);                                //    DA = 1;
    / b+ `* B" ~4 ^
43.     }
    % B9 I8 p5 T/ o) e1 I/ C
44.     delay_us(10);
    ) \" I7 i/ j6 l1 H7 z
45.     GPIO_SetBits(GPIOB, HT1621_WR);                                    //    RW = 1;
    
46.     delay_us(10);
    
47. }
    9 S  g2 N2 B& W0 ]& a
48. 
    
49. /*
    " A1 N% e/ C" t1 f$ L  B
50. *    LCD 命令写入函数
    5 n7 E/ L  e3 ]
51. *    入口:cbyte ,控制命令字
    
52. *    出口:void
      X' |. N+ u( N4 R4 f4 q1 E
53. */
    
54. void write_command(unsigned char Cbyte)
    5 D7 E: I7 j" F7 ?5 c/ J/ t
55. {
    
56.     unsigned char i = 0;
    " Q2 ^# `4 d$ I# P
57. 
    
58.     for (i = 0; i < 8; i++)
    & o- M/ H# y1 v; P2 n* l! g& p
59.     {
    
60.         GPIO_ResetBits(GPIOB, HT1621_WR);
    
61.         if ((Cbyte >> (7 - i)) & 0x01)
    2 e. S" m: j" `  M
62.         {
    
63.             GPIO_SetBits(GPIOB, HT1621_DATA);
    1 u, o; M$ S. @. N# w
64.         }
    
65.         else
    ' p/ m. X9 q2 Y0 ]+ V  K; z. B
66.         {
    " G! W' P4 C) o# K$ N: }
67.             GPIO_ResetBits(GPIOB, HT1621_DATA);
    - m$ H/ i6 _& |: l1 A# K- z+ g9 @
68.         }
    
69.         delay_us(10);
    2 J9 l9 g/ E* w* M& y& w
70.         GPIO_SetBits(GPIOB, HT1621_WR);
    
71.         delay_us(10);
    , w# P5 T$ V4 l3 }
72.     }
    4 \0 b; T( v0 _) L
73.     GPIO_ResetBits(GPIOB, HT1621_WR);
    6 ~* I7 r: }3 u0 x2 `
74.     delay_us(10);
    6 d/ Y. j( \7 F: A8 N" ^
75.     GPIO_ResetBits(GPIOB, HT1621_DATA);
    " B9 q. o% ~5 x( l6 F7 ?
76.     GPIO_SetBits(GPIOB, HT1621_WR);
    8 i' A3 S" N  \2 J/ p& Z2 L+ S( R
77.     delay_us(10);
    5 K% h; a6 A$ `0 J3 t! Z
78. }
    
79. 
    7 }5 r! r+ W$ \% `( Y
80. /*
    . h' O% c8 M0 U& t# J0 y
81. *    LCD 地址写入函数
    
82. *    入口:cbyte,地址
    6 Q& k# ^6 O0 e) j. P8 k4 t- l
83. *    出口:void
    , [7 t8 B- e2 ?% e7 ~+ f/ O" ]% T
84. */
    
85. void write_address(unsigned char Abyte)
    ( z: e% R  |  R) U
86. {
    3 Z7 v$ B& Q0 ?) t
87.     unsigned char i = 0;
    
88.     Abyte = Abyte << 2;
    
89. 
    
90.     for (i = 0; i < 6; i++)
    
91.     {
    3 k1 k* o' J% W! |& M. R9 G
92.         GPIO_ResetBits(GPIOB, HT1621_WR);
    
93.         //delay_us(10);
    
94.         if ((Abyte >> (7 - i)) & 0x01)
    ) M% Z6 Z5 C: Z
95.         {
    
96.             GPIO_SetBits(GPIOB, HT1621_DATA);
    
97.         }
    2 F% c0 v9 \& g
98.         else
    
99.         {
    # R2 F: V* v6 M, _
100.             GPIO_ResetBits(GPIOB, HT1621_DATA);
     ) H4 S( g! ^# P6 g) Q. g+ }3 x
101.         }
     5 r! T& {4 C- w+ O. w+ o0 M
102.         delay_us(10);
     ! a" a. p" e/ F+ y% u8 G
103.         GPIO_SetBits(GPIOB, HT1621_WR);
     ; E/ K1 o5 x  p, C/ W
104.         delay_us(10);
     0 ?' }; Z  \: W! i# ]! v. c% z! U
105.     }
     ) Z- P/ y# b, H. x$ {
106. 
     
107. }
     
108. 
     
109. /*
     
110. *    LCD 数据写入函数
     8 i* O: m0 K& R0 U8 j/ I' t; k
111. *    入口:Dbyte,数据
     * R# U9 f( R4 f& R8 h$ K
112. *    出口:void
     8 H: Y: A! o, u# B& J
113. */
     
114. void write_data_8bit(unsigned char Dbyte)
     
115. {
       b0 i, x9 h- c( ?6 H. W
116.     int i = 0;
     
117. 
     
118.     for (i = 0; i < 8; i++)
     
119.     {
     ; ]) ~* {$ P3 {4 s" N
120.         GPIO_ResetBits(GPIOB, HT1621_WR);
     
121.         delay_us(10);
     3 o7 ]8 {5 i$ s; \% v2 R( i8 ~
122.         if ((Dbyte >> (7 - i)) & 0x01)
     7 U7 N; @+ z. d  o9 Z
123.         {
     
124.             GPIO_SetBits(GPIOB, HT1621_DATA);
     
125.         }
     
126.         else
     , r) B/ n; O5 O/ S
127.         {
     ) J8 X- J: i5 k; r) U2 W+ T
128.             GPIO_ResetBits(GPIOB, HT1621_DATA);
     
129.         }
     
130.         delay_us(10);
     
131.         GPIO_SetBits(GPIOB, HT1621_WR);
     : @$ }5 H/ e: d3 @/ m% G" M
132.         delay_us(10);
     9 r( }, a0 ?* {
133.     }
     5 I& X2 b& e6 _2 h9 x8 ?: l; {
134. }
     * ^9 J% \: c* M5 S+ @+ n
135. 
     
136. void write_data_4bit(unsigned char Dbyte)
     
137. {
     + {1 o7 B6 k7 a: I
138.     int i = 0;
     
139. 
     9 v/ F2 [& o0 \# c6 L
140.     for (i = 0; i < 4; i++)
     % s9 a: P+ a. t
141.     {
     
142.         GPIO_ResetBits(GPIOB, HT1621_WR);
     - ~$ r8 L$ Q6 R3 P( J) X6 c) M
143.         //delay_us(10);
     
144.         if ((Dbyte >> (3 - i)) & 0x01)
     * O- j/ V$ Y/ q" P: v% Q3 U
145.         {
     & u* Q7 }4 }+ h: a6 k7 U( M6 T
146.             GPIO_SetBits(GPIOB, HT1621_DATA);
     
147.         }
     ) }: U+ |) j5 Y: u6 T. S: d
148.         else
     8 D4 p+ }$ i- }1 m6 _7 R( ^' W1 B
149.         {
     
150.             GPIO_ResetBits(GPIOB, HT1621_DATA);
     
151.         }
     
152.         delay_us(10);
     
153.         GPIO_SetBits(GPIOB, HT1621_WR);
     
154.         delay_us(10);
     ) Y2 e8 Z1 s, j
155.     }
     
156. }
     
157. 
     9 C3 \& y; O1 L4 f* g' R
158. 
     & r, I- E* i' Y- o- `
159. 
     
160. //1621初始化
     / ]- ]$ C- O3 I! t( y. T9 a: W; t
161. void ht1621_init(void)
     
162. {
     + i* M" x4 g* D, P) l
163.         GPIO_InitTypeDef GPIO_InitStructure;// declare the structure
     1 C# c/ C% M* F6 ~8 q/ ~% V& w* g
164.         GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE);
     
165. 
     7 P* b; m! t6 B, M
166.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOB, ENABLE);
     ) p( |4 T7 [4 N# Q+ O8 ?
167.         memset(&GPIO_InitStructure, 0, sizeof(GPIO_InitTypeDef));
     2 l2 z- _2 F& u( x" @9 _
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;
     
171.         GPIO_Init(GPIOB, &GPIO_InitStructure);
     
172. 
     4 _1 V6 v0 l! a, V6 c
173.         memset(&GPIO_InitStructure, 0, sizeof(GPIO_InitTypeDef));
     9 A/ |; V/ U6 I, |# u" R
174.         GPIO_InitStructure.GPIO_Pin = HT1621_CS ;//| HT1621_IRQ
     + ~! A5 {2 X( ^4 O8 {
175.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
       a( s/ ~$ l5 l  V$ H' r0 G
176.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     1 t( O# l4 x+ Z; k0 M/ m. [
177.         GPIO_Init(GPIOA, &GPIO_InitStructure);
     0 P7 l9 }9 Y0 a( t& }. o
178. 
     
179. }
     % u" ]" r8 @/ s1 w2 R
180. 
     
181. /*
     . Z7 C7 V+ V! o  Q9 F% t+ `
182. *    LCD 初始化，对lcd自身做初始化设置
     8 s' D1 N) n# z, }/ M$ U: k
183. *    入口:void
     3 b0 C1 ?3 [$ E- I" e* F
184. *    出口:void
     
185. */
     
186. void lcd_init(void)
     + F+ K1 d# C  p0 Z) k. K* B
187. {
     9 I' n. q2 @& K9 }
188.     //////////////////////////////////////////////////////
       r% p" q/ _' v' N7 b' h  a7 l
189.     GPIO_SetBits(GPIOA, HT1621_CS);
     
190.     GPIO_SetBits(GPIOB, HT1621_WR);
     6 L8 U% `/ v( i. N: b, l- w
191.     GPIO_SetBits(GPIOB, HT1621_DATA);
     ' w, p+ X2 H0 s1 r3 H
192.     for (ii=0;ii<10000;ii++)
     + {' N, r! B1 u" P/ Z2 f# C
193.     {for(j=10;j>0;j--);}
     
194.     //////////////////////////////////////////////////////
     : q8 n. h, S5 o. U4 j' \
195.     GPIO_ResetBits(GPIOA, HT1621_CS);        //CS = 0;
     ' @2 A5 R- V# D/ q; `! F$ N
196.     //delay_us(10);
     
197.     for (ii=0;ii<10000;ii++)
     ; Q; _5 `6 N& E6 g# a
198.     {for(j=10;j>0;j--);}
     * G$ V5 @( J2 Z; X8 p2 n+ ~" l
199.     write_mode(COMMAND);    //命令模式
     
200.     write_command(0x01);    //Enable System
     . Z& ?# T# r' c1 n; S6 i
201.     write_command(0x03);    //Enable Bias
     
202.     write_command(0x04);    //Disable Timer
     
203.     write_command(0x05);    //Disable WDT
     
204.     write_command(0x08);    //Tone OFF
     2 Z) Q* ^- J* X7 h
205.     write_command(0x18);    //on-chip RC震荡
     4 ?* Z. p, u+ _) p. i% d
206.     write_command(0x29);    //1/4Duty 1/3Bias
     
207.     write_command(0x80);    //Disable IRQ
     - h+ p! f( X: ?
208.     write_command(0x40);    //Tone Frequency 4kHZ
     : K5 n5 S) K7 @. \! k  P+ ^; P
209.     write_command(0xE3);    //Normal Mode
     
210. 
     
211.     GPIO_SetBits(GPIOA, HT1621_CS);  //CS = 1;
     
212. }
     
213. 
     
214. /*
     
215. *    LCD 清屏函数
     1 |9 U& a4 M0 k. D. K
216. *    入口:void
     5 l3 i9 V( B# K6 a. [
217. *    出口:void
     
218. */
     
219. void lcd_clr(void)
     
220. {
     ; G& ]* E7 i* J7 ]
221.     write_addr_dat_n(0x0, 0x00, 32);//15
     ! b- _8 F9 u6 d* E
222. }
     
223. //用于温度区域写数据
     ) j% D7 h  B  ]
224. void write_addr_dat_n_wendu(unsigned char _addr, unsigned char _dat, unsigned char n)
     
225. {
     
226. 
     # z6 R* _! c5 r" q' {
227.     unsigned char i = 0;
     ! X9 \. B. k. G9 U/ n$ n0 b* H
228.     unsigned char _dat_temp1,_dat_temp2;
     $ \1 E( r6 W. V( p1 h
229. 
     
230.     //WriteLcdram(_addr, _dat);
     0 L, g4 P* w0 `3 r) T3 J% n) T
231. 
     
232. 
     
233. 
     
234.     GPIO_ResetBits(GPIOA, HT1621_CS);                                // CS = 0;
     
235.     write_mode(DAT);
     : b. ?1 y4 M1 G3 ?0 N$ y5 i
236. 
     1 _& o( G5 g6 B# Y
237.     if(Lcdram[_addr]==0x00)
     
238.     {
     
239.         WriteLcdram(_addr, _dat);
     * @2 E9 v. t) l
240.     }
     
241.         if((_addr%2)==0)
     
242.         {
     
243.             _dat_temp1=Lcdram[_addr];
     
244.             _dat_temp2=(_dat_temp1&0x08)|_dat;
     
245. 
     
246.             write_address(_addr);
     
247.             for (i = 0; i < n; i++)
     
248.         {
     
249.             write_data_4bit(_dat_temp2);
     6 |. a/ }2 K: x* f' j% f
250.         }
     : S# ~  ]1 w* L/ X
251.         GPIO_SetBits(GPIOA, HT1621_CS);                                    //CS = 1;
     
252. 
     ! f' O# E' g4 Y4 K0 a5 Y
253.         }
     
254.         else if((_addr%2)!=0)
     4 Z* P4 b! `0 W
255.         {
     , }. c0 k. S. I5 c- A
256.             write_address(_addr);
     - c4 _  k5 H4 T, [* j- B9 s
257.             for (i = 0; i < n; i++)
     " G5 }% L" L1 g* P1 C' N, B
258.         {
     
259.             write_data_4bit(_dat);
     2 ?7 e0 h4 b2 ?- h
260.         }
     1 }  [7 }% s" v3 b: u8 Q% m
261.         GPIO_SetBits(GPIOA, HT1621_CS);
     
262.         }
     - Q, t7 _5 A; C* K  l
263. 
     * L7 ^/ R: ^' ]# e6 Y, x: E+ o) G
264.         WriteLcdram(_addr, _dat_temp2);
     5 {; E% ~3 r4 w% @8 g
265. }
     
266. 
     0 I2 ?8 R$ q5 _; ]
267. //用于湿度区域写数据
     
268. void write_addr_dat_n_shidu(unsigned char _addr, unsigned char _dat, unsigned char n)
     * l/ s. U* Y* O  L8 C) v0 S
269. {
       ?0 R) |1 t# A6 Y. r. A! n' b- b
270. 
     & A, G5 y, p: P2 N
271.     unsigned char i = 0;
     3 D# L$ a: r3 I4 Y6 V+ k6 A$ I
272.     unsigned char _dat_temp1,_dat_temp2;
     # h% |" f& g, t/ w8 o$ V: A2 V2 m
273. 
     6 A3 d* s9 {" |
274.     //WriteLcdram(_addr, _dat);
     
275. 
     
276. 
     6 y% n" k+ n3 s, e3 S& Y
277. 
     
278.     GPIO_ResetBits(GPIOA, HT1621_CS);                                // CS = 0;
     
279.     write_mode(DAT);
     0 ?& w- B. [+ O: W
280. 
     , A% \9 d; u, Q2 R: D- L
281.     if(Lcdram[_addr]==0x00)
     - H# O3 R* G  o8 [
282.     {
     ' v4 u- C! s: }6 f/ o* G
283.         WriteLcdram(_addr, _dat);
     # a7 k- \9 O, q- ~3 Y: a
284.     }
     4 U# z# y$ O0 I7 o8 Q$ q+ j
285.         if((_addr%2)==0)
     
286.         {
     
287.             _dat_temp1=Lcdram[_addr];
     6 S, a# k% d9 y% U
288.             _dat_temp2=(_dat_temp1&0x01)|_dat;
     5 D3 a8 c: r1 U5 W, Y2 u. P+ ^
289. 
     
290.             write_address(_addr);
     % l: ]- W' g* d# N8 A
291.             for (i = 0; i < n; i++)
     + c0 K+ O& L+ G2 O
292.         {
     
293.             write_data_4bit(_dat_temp2);
     
294.         }
     $ h( h9 H6 U) m3 ?
295.         GPIO_SetBits(GPIOA, HT1621_CS);                                    //CS = 1;
     
296. 
     
297.         }
     - b1 t: r/ Y9 ]2 _5 d* L
298.         else if((_addr%2)!=0)
     ! n. i% y0 ~  g
299.         {
     
300.             write_address(_addr);
     
301.             for (i = 0; i < n; i++)
     
302.         {
     ! ]4 \; Z3 g- U0 ^8 z
303.             write_data_4bit(_dat);
     
304.         }
     ' `' t, n9 r# f  Z
305.         GPIO_SetBits(GPIOA, HT1621_CS);
     . a% d& d7 s( v# S5 y  V
306.         }
     
307. 
     
308.         WriteLcdram(_addr, _dat_temp2);
     % N: a7 J# x" j, ~# D! v3 p0 P+ n) `
309. }
     
310. 
     9 g) b) R1 r8 V1 k
311. 
     
312. //用于底部数字写数据
     5 U! a8 h( s3 Y+ K) k9 N) D
313. void write_addr_dat_n_others(unsigned char _addr, unsigned char _dat, unsigned char n)
     
314. {
     # q' }! g; r8 H, @! w6 h
315. 
     
316.     unsigned char i = 0;
     * ^  \; f4 N6 N1 n
317.     unsigned char _dat_temp1,_dat_temp2;
     3 U& D0 u$ p9 P$ V) s; q+ U
318.     GPIO_ResetBits(GPIOA, HT1621_CS);                                // CS = 0;
     ( x: ]3 ?0 o6 [+ ^% w
319.     write_mode(DAT);
     
320. 
     
321.     if(Lcdram[_addr]==0x00)
     : _5 g1 Z+ t1 x+ B
322.     {
     & t  u4 z* P3 x  t! O) e, p
323.         WriteLcdram(_addr, _dat);
     0 ?2 Z  [! A5 r( f! O
324. 
     2 V# f. q  [9 V( @
325.     }
     
326.         if((_addr%2)==0)
     / P- L1 q+ V7 T7 G$ D/ Q2 f6 n
327.         {
     
328.             _dat_temp1=Lcdram[_addr];
     
329.             _dat_temp2=(_dat_temp1&0x01)|_dat;
     $ g( v5 x! i* P) q" Q+ _! ?
330. 
       ]$ O! C  P- [% Y6 |4 N
331.             write_address(_addr);
     
332.             for (i = 0; i < n; i++)
     / n( p' `" c/ l6 b* _+ k* X3 y
333.         {
     8 j6 J( Y# i) s( u6 Z" [: Q% Y' `) L
334.             write_data_4bit(_dat_temp2);
     : r" \' z4 f( T5 N1 W7 W6 k
335.         }
     7 p, T2 e3 H9 D0 |  U4 q/ Y
336.         GPIO_SetBits(GPIOA, HT1621_CS);                                    //CS = 1;
     2 p* e- X6 t8 i5 M) G* k
337. 
     
338.         }
     
339.         else if((_addr%2)!=0)
     
340.         {
     
341.             write_address(_addr);
     9 {" Z1 w- W7 R1 {
342.             for (i = 0; i < n; i++)
     $ D2 i3 S2 g! O& Q  k
343.         {
     & M! C; S3 m0 }' |
344.             write_data_4bit(_dat);
     
345.         }
     
346.         GPIO_SetBits(GPIOA, HT1621_CS);
     
347.         }
     9 @  t% U2 C4 [
348. 
     
349.         //WriteLcdram(_addr, _dat);
     & H  ~3 t! ?& Z
350.         WriteLcdram(_addr, _dat_temp2);
     ! Q* n& Q! ]) [, D
351. }
     ' W- D5 N4 \9 l5 k7 o- P
352. 
     
353. //用于字符写数据
     
354. void write_addr_dat_n_char(unsigned char _addr, unsigned char _dat, unsigned char state)
     # J# `; }: \- k* \3 O
355. {
     
356. 
     6 I0 l$ Z! s4 G1 Q
357.     unsigned char i = 0;
     
358.     unsigned char _dat_temp1,_dat_temp2;
     + J# l( P4 ~2 o& T+ ]
359. 
     
360. 
     5 V! C: D9 ~3 |) t2 `
361.         GPIO_ResetBits(GPIOA, HT1621_CS);                                // CS = 0;
     & p8 \" A; _8 `3 b1 Z  Z
362.          write_mode(DAT);
     8 @+ E+ a# \0 f6 o
363. 
     ! {2 X" M, z; h( ?; F0 n
364.                 _dat_temp1=Lcdram[_addr];
     
365.             if(state==1)
     * l. r8 m* k* L$ `1 s! B
366.             {
     . \6 U4 M# Z: Q, Z+ `! w
367. 
     
368.                 _dat_temp2=(_dat_temp1|_dat);
     
369.             }
     
370.             else if(state==0)
     ) ^2 T. A0 b" M
371.             {
     
372.                 _dat_temp2=(_dat_temp1&(~_dat));
     
373.             }
     . E6 p  {0 C9 M  O; n9 g4 l
374.                  write_address(_addr);
     % ~& f$ ?% O# L; H7 j- z, B
375. 
     . D+ o4 G$ R3 [8 b9 V5 r  o
376.                 for (i = 0; i < 1; i++)
     ' \2 I' c6 ^3 Z0 E5 }4 _
377.             {
     5 _6 t3 v1 X9 A5 i  |& H/ H: b
378.                 write_data_4bit(_dat_temp2);
     - x" |. U, Y6 B4 }4 e0 G5 e0 p
379.             }
     4 M4 K* k/ A; d( D: b( E5 h' ^
380.             GPIO_SetBits(GPIOA, HT1621_CS);                                    //CS = 1;
     
381.             WriteLcdram(_addr, _dat_temp2);
     
382. 
     
383. 
     1 r( C1 @3 ~: z( a! z! S
384. 
     
385. 
     7 S: S* o% D3 W( m" {- s" d0 R2 n
386. }
     
387. //显示温度
     
388. //入口：pos，显示位置，地址0、2、4分别为从右到左的三个数字
       O& K! n' B7 k2 f
389. //            num：要显示的一位数
     
390. void Display_Wendu_1(unsigned char add, unsigned char num )
       O# B( Q( P6 }, D, V+ p1 A% j
391. {
     ; z' T7 r' t* c* R3 W3 Z
392.     unsigned char n,i,j;
     " u. v: n6 {+ V7 M, w% t' U
393.     n=getChr_Wendu(num);
     - D' H/ f% s5 V) v6 H$ p
394.     i=(n&0xF0)>>4;
     $ C7 T3 Y' w9 m
395.     j=n&0x0F;
     ) j8 x: k8 E* d
396.     write_addr_dat_n_wendu(add,i,1);
     ' F5 p! R9 N+ E3 r! i
397.     write_addr_dat_n_wendu(add+1,j,1);
     
398. 
     
399. }
     & ^8 c2 p5 G1 c7 L
400. 
     
401. 
     
402. //温度数据转换，lcd.c内部使用
     6 L4 U- P0 A: q4 d2 J  }2 M
403. unsigned char getChr_Wendu(unsigned char c)
     
404. {
     
405.      unsigned char i;
     2 R% h. m8 h6 \  R9 O
406.         for ( i = 0; i < 10; ++i)
     6 X& K" x. v  x$ p) u6 Z9 L" V+ D% |
407.         {
     
408.             if (c == i)
     ; U1 x' d! }& a) m
409.             {
     
410.                 return Wendu[i];
     
411.             }
     
412.         }
     ' [$ E4 o4 @- B) @
413.     }
     
414. 
     
415. //更新lcdram数组
     ' K. n: y6 R8 F# @8 F
416. void WriteLcdram(unsigned char add, unsigned char data)
     
417. {
     
418. 
     " k. `& `, }3 `9 B8 ?
419.     Lcdram[add]=data;
     
420. 
     0 _, S9 n9 @/ Y& L  u5 v  F* q7 H
421. }

复制代码

3 z: z, b% J8 D; Q3 M

4 I( y! H0 ]+ f/ a! g7 K

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