$ ~" ^9 y5 x5 e5 y' r" }一、常见显示器类型介绍

# X! o0 ~6 _/ J& O8 a9 }" e& E显示器属于输出设备，它是一种将特定电子信息输出到屏幕上再反射到人眼的显示工具。常见显示器有三类：CRT显示器、LCD液晶显示器和LED点阵显示器。
! l( P; r& Y) O- r1 A& E& j& x, C# U
CRT显示器：CRT显示器是靠电子束激发屏幕内表面的荧光粉来显示图像的，由于荧光粉被点亮后很快会熄灭，所以电子枪必须循环地不断激发这些点。
% J! `( y4 U9 i" x0 P# w8 e. F& e
+ V  s4 g& X8 O% [- v
" Y& P+ ]8 a4 \+ x; ^0 ~/ x1 Q
$ ]$ c7 f, {- Z+ F; j# [& ?, ^% wLCD显示器：液晶显示器，简称 LCD(Liquid Crystal Display)，相对于上一代 CRT显示器，LCD 显示器具有功耗低、体积小、承载的信息量大及不伤眼的优点，因而它成为了现在的主流电子显示设备，其中包括电视、电脑显示器、手机屏幕及各种嵌入式设备的显示器。

: j# w; H8 J* K  r) w! _6 [


, n8 X+ m( T9 |液晶是一种介于固体和液体之间的特殊物质，它是一种有机化合物，常态下呈液态，但是它的分子排列却和固体晶体一样非常规则，因此取名液晶。如果给液晶施加电场，会改变它的分子排列，从而改变光线的传播方向，配合偏振光片，它就具有控制光线透过率的作用，再配合彩色滤光片，改变加给液晶电压大小，就能改变某一颜色透光量的多少。利用这种原理，做出可控红、绿、蓝光输出强度的显示结构，把三种显示结构组成一个显示单位，通过控制红绿蓝的强度，可以使该单位混合输出不同的色彩，这样的一个显示单位被称为像素。注意: 液晶本身是不发光的，所以需要有一个背光灯提供光源。
  E# Q, O$ P" O. m
  }. ]; ~9 F, j' X8 C

. D$ `! V) `1 l2 d, ]  D+ TLED显示器：LED点阵彩色显示器的单个像素点内包含红绿蓝三色LED灯，通过控制红绿蓝颜色的强度进行混色，实现全彩颜色输出，多个像素点构成一个屏幕。由于每个像素点都是LED灯自发光的，所以在户外白天也显示得非常清晰，但由于LED灯体积较大，导致屏幕的像素密度低，所以它一般只适合用于广场上的巨型显示器。相对来说，单色的LED点阵显示器应用得更广泛，如公交车上的信息展示牌、店广告牌等。
% L. P  m) }' h# ~7 _
  T2 f( k* F8 a( EOLED显示器：新一代的OLED显示器与LED点阵彩色显示器的原理类似，但由于它采用的像素单元是“有机发光二极管”(Organic Light Emitting Diode)，所以像素密度比普通LED点阵显示器高得多。OLED显示器具有不需要背光源、对比度高、轻薄、视角广及响应速度快等优点。待到生产工艺更加成熟时，必将取代现在液晶显示器的地位。

5 p% s" L3 a7 y" a

/ D. S% M- d! n二、显示器的基本参数

) {9 Y3 e. L# B  o. n) T像素：是组成图像的最基本单元要素，显示器的像素指它成像最小的点，即前面讲解液晶原理中提到的一个显示单元。
: v( _# W1 |5 v/ [4 w% ~3 |/ c
8 D6 O  r$ |4 y2 z  x- z* @% Q/ r分辨率： 一些嵌入式设备的显示器常常以“行像素值x列像素值”表示屏幕的分辨率。如分辨率800x480表示该显示器的每一行有800个像素点，每一列有480个像素点，也可理解为有800列，480行。
: E% i. y: ^& J! \) k% J% x


1 ~) g; o* m$ k' Q  t6 B8 P色彩深度：指显示器的每个像素点能表示多少种颜色，一般用“位”(bit)来表示。如单色屏的每个像素点能表示亮或灭两种状态(即实际上能显示2种颜色)，用1个数据位就可以表示像素点的所有状态，所以它的色彩深度为1bit，其它常见的显示屏色深为16bit、24bit。
" _1 A% `" k  {. V  H8 x( U
显示器尺寸：显示器的大小一般以英寸表示，如5英寸、21英寸、24英寸等，这个长度是指屏幕对角线的长度，通过显示器的对角线长度及长宽比可确定显示器的实际长宽尺寸
5 M3 a+ I/ k, [. m( N
显存：液晶屏中的每个像素点都是数据，在实际应用中需要把每个像素点的数据缓存起来，再传输给液晶屏，一般会使用 SRAM 或 SDRAM 性质的存储器，而这些专门用于存储显示数据的存储器，则被称为显存。显存一般至少要能存储液晶屏的一帧显示数据。

' Q# L$ F/ U* R' ?如分辨率为 800x480 的 液 晶 屏  使 用 RGB888 格 式 显 示 ， 它 的 一 帧 显 示 数 据 大 小 为 ：3（字节）x800x480=1152000 字 节 ；若 使 用 RGB565 格 式 显 示 ， 一 帧 显 示 数 据 大 小 为 ：2（字节）x800x480=768000 字节。
5 `" c  K# q; Q4 ~7 q" Y
: B3 ?; m  c/ i* o, m( a. D& a一般来说，外置的液晶控制器会自带显存，而像 STM32F429等集成液晶控制器的芯片可使用内部 SRAM或外扩 SDRAM用于显存空间

# e* q6 B8 l( W( N
三、TFT-LCD控制框图

6 s2 d; O; z3 b# U4 W! d* qSTM32F429 系列的芯片不需要额外的液晶控制器（可以理解为常规意义上的显卡），也就是说它把专用液晶控制器的功能集成到STM32F429芯片内部了，可以理解为电脑的CPU集成显卡。而 STM32F407 系列的芯片由于没有集成液晶控制器到芯片内部，所以它只能驱动自带控制器的屏幕，可以理解为电脑的外置显卡。

带有液晶控制器的显示面板工作时，STM32将数据写到LCD控制器的显存里，LCD控制器将显存中的数据渲染到显示面板上进行显示。而不带液晶控制器的面板，也就是MCU自集成了液晶控制器，MCU会在自己的内存中开辟一部分用作为液晶控制器的显存。


: H& I- z& ]2 r# j# O
% N* d5 W6 _" k- o四、TFT-LCD控制原理TFT-LCD结构：完整的显示屏由液晶显示面板、电容触摸面板以及 PCB底板构成

% C! C9 I) e+ [. K* H& ?+ r1.液晶显示面板：用于显示图像，文字的彩色显示设备
7 t+ b: c) G* n: `6 Z
2.触摸面板：触摸面板带有触摸控制芯片，该芯片处理触摸信号并通过引出的信号线与外部器件通讯，触摸面板中间是透明的，它贴在液晶面板上面，一起构成屏幕的主体
! @% H; I" A) K) {( [
# t3 N8 v% _9 w- K* R: P3.PCB 底板：PCB 底板上可能会带有“液晶控制器芯片”因为控制液晶面板需要比较多的资源，所以大部分低级微控制器都不能直接控制液晶面板，需要额外配套一个专用液晶控制器来处理显示过程，外部微控制器只要把它希望显示的数据直接交给液晶控制器即可。而不带液晶控制器的PCB底板，只有小部分的电源管理电路，液晶面板的信号线与外部微控制器相连，直接控制。
! @$ o- I8 A  d( w



( g- i2 s6 X. \6 M: u五、RGB-LCD控制原理



RGB信号线：RGB信号线各有8根，分别用于表示液晶屏一个像素点的红、绿、蓝颜色分量。使用红绿蓝颜色分量来表示颜色是一种通用的做法，打开Windows系统自带的画板调色工具，可看到颜色的红绿蓝分量值，常见的颜色表示会在“RGB”后面附带各个颜色分量值的数据位数，如RGB565格式表示红绿蓝的数据线数分别为5、6、5根，一共为16个数据位，可表示216种颜色；如果液晶屏的种颜色分量的数据线有8根，那它表示RGB888格式，一共24位数据线，可表示的颜色为224种。

; i) i. q, |% e# z& J' G: y

同步时钟信号CLK：液晶屏与外部使用同步通讯方式，以CLK信号作为同步时钟，在同步时钟的驱动下，每个时钟传输一个像素点数据。
- L" Z4 m% ]  x; N. T/ u6 V
- X2 g& b: M* }# {5 \: c; z" u. G水平同步信号HSYNC：水平同步信号HSYNC(Horizontal Sync)用于表示液晶屏一行像素数据的传输结束，每传输完成液晶屏的一行像素数据时，HSYNC会发生电平跳变，如分辨率为800x480的显示屏(800列，480行)，传输一帧的图像HSYNC的电平会跳变480次。
# I6 |! c4 N, g) N
; F% Y9 k# J  }0 w垂直同步信号VSYNC：垂直同步信号VSYNC(Vertical Sync)用于表示液晶屏一帧像素数据的传输结束，每传输完成一帧像素数据时，VSYNC会发生电平跳变。其中“帧”是图像的单位，一幅图像称为一帧，在液晶屏中，一帧指一个完整屏液晶像素点。人们常常用“帧/秒”来表示液晶屏的刷新特性，即液晶屏每秒可以显示多少帧图像，如液晶屏以60帧/秒的速率运行时，VSYNC每秒钟电平会跳变60次。

' b' a: w7 F' t# u数据使能信号DE：数据使能信号DE(Data Enable)用于表示数据的有效性，当DE信号线为高电平时，RGB信号线表示的数据有效。
( d3 G2 p; k. j
3 T$ d5 X! Q$ q$ n
, g: M8 v8 z4 Q4 z7 Q8 \0 X" ~LCD数据传输时序

/ }0 j7 |* C& N9 T4 t一个VSYNC（即一帧）包含若干个HSYNC（即若干行），而一个HSYNC包含若干个像素点（一个24位数据）
- S4 }  `# m3 Q. x# {( m


4 _- ?" j: i! S5 {% n液晶屏显示的图像可看作一个矩形，液晶屏有一个显示指针，它指向将要显示的像素。显示指针的扫描方向方向从左到右、从上到下，一个像素点一个像素点地描绘图形。这些像素点的数据通过RGB数据线传输至液晶屏，它们在同步时钟CLK的驱动下一个一个地传输到液晶屏中，交给显示指针，传输完成一行时，水平同步信号HSYNC电平跳变一次，而传输完一帧时VSYNC电平跳变一次。
9 o6 Z# K. e6 Q9 ]
4 W1 g; D/ z) ^+ j$ c
" y3 {9 x+ ?. x/ d6 G) A
液晶显示指针在行与行之间，帧与帧之间切换时需要延时，而且HSYNC及VSYNC信号本身也有宽度，这些时间参数说明见下表：

8 K6 c) u! e% d" N3 C, \

六、SSD1963液晶控制器
6 q; D% ~' x# v& ]
% w3 m. Q. \( i% y& O4 \液晶驱动芯片或LCD驱动器，其内部有着较大的缓存空间可以存储文字、图像等数据，并能够将这些信息送入液晶模块进行显示，由于专用的芯片，因此速度往往比较快。

LCD驱动芯片的主要功能就是对主机发送过来的数据/命令，进行变换，变成每个像素的RGB数据，使之在屏幕上显示出来。常见的液晶驱动芯片有ILI932、ILI9328、SSD1963、HX8347、ILI9341、NT5510等。

SSD1963特性：内部包含1215KB frame buffer（显存）、支持分辨率为864*480的显示屏、支持像素位深为24bpp的显示模式（RGB888）。后面我们使用4.3寸TFT LCD真彩屏（分辨率480x272 ）RGB565的方式进行实验。



8080传输效率比SPI传输效率更高，因此管脚足够的情况下采用8080时序

STM32与LCD电器连线图如下：

" J# J/ [2 O( o- j


8080时序-写数据/命令


2 F- z0 }9 f+ Y9 f3 W/ Y; V, J

1. //用GPIO管脚模拟8080时序
   
2. 
   : ?1 }0 K& D/ a$ f8 B
3. void LCD_WR_Byte(uint8_t dat, uint8_t cmd)
   
4. {
   ! z. G* q0 L+ x8 ~% ~
5.   LCD_Data_Out(dat);        //放入数据  
   3 G% q; Z7 Z; N
6. if(cmd)  
   
7.       LCD_DC_Set();        //传命令      
   0 X9 T4 S. ^) x
8. else
   
9.       LCD_DC_Clr();       //传数据
   
10. 
    
11. LCD_CS_Clr();           //拉低片选
    
12. LCD_WR_Clr();           //写使能
    
13. LCD_WR_Set();           //WR产生上升沿，数据锁存  
    , |$ c9 l2 p; ]5 C+ X& L
14. LCD_CS_Set();           //取消片选  
    & d1 ~6 X$ N7 F/ ]" T
15. LCD_DC_Set();           //复位DC信号线   
    . X% @: I7 B6 [
16. }

复制代码

注：STM32通过8080接口与SSD1963 芯片进行通讯，实现对液晶屏的控制。通讯的内容主要包括命令和显存数据，显存数据即各个像素点的RGB565内容；命令是指对SSD1963的控制指令，MCU 可通过8080接口发送命令编码控制 SSD1963的工作方式，例如复位指令、设置光标指令、睡眠。
' R. J5 G; o4 N: `
9 A. v! W' K1 \; X/ IFSMC模拟8080时序



6 ]# E& A% h0 C7 W& t& O重要的时序参数如下：时间相对长一点，也不能过大，否则屏幕刷新时间就会变成长，视觉上表现卡顿。
* {6 h+ K$ L3 ~1 ^2 O


8 M  o2 D  J$ R. {# P. w+ O* r9 F
( {# b# T* k, X+ H$ L
对于FSMC和8080接口，前四种信号线都是完全一样的，仅仅是FSMC的地址信号线A[25:0]与8080的数据/命令选择线D/C#有区别。为了模拟出8080时序，我们可以把FSMC的A0地址线（选择地址线的一条）与SSD1963芯片8080接口的D/C#信号线连接，那么当A0为高电平时(即D/C#为高电平)，数据线D[15:0]的信号会被SSD1963理解为数据，若A0为低电平时(即D/C#为低电平)，传输的信号则会被理解为命令。

关于如何让控制A0电平的高低，首先要清楚，LCD控制器的片选连入到FSMC的NE4管脚。所以当发出0x6C000000-0x6FFF FFFF之间的地址时NE4输出低电平，选中LCD控制器，那么A0作为原来地址线的最低位，要调整地址使得A0为0。
* K8 c- p$ O& v- T7 k; h2 y


可以看到显示器在传输过程中并没有高低字节控制的选项（在读写SRAM的过程中，使用掩码信号LB#与UB#指示要访问目标地址的高、低字节部分），也就是说液晶控制器（显存）与MCU之间一次就要传输16位数据。
& w; T9 e  t4 G2 C
在实际控制时，以上地址计算方式还不完整，根据《STM32 参考手册》对 FSMC 访问NOR FLASH （LCD读写数据的方式与NOR FLASN几乎是一样的，都是16位，但是FSMC 访问NOR FLASH具有高低字节控制选项）的说明STM32 内部访问地址时使用的是内部 HADDR 总线， HADDR[25:0] 包含外部存储器地址。由于 HADDR 为字节地址（一次传输8位），而存储器按字寻址，所以根据存储器数据宽度不同，实际向存储器发送的地址也将有所不同，如下表所示。

因此发出一个地址后，只看第二低位。最低位表示一个字节的单位，而第二低位表示两个字节的单位。读者可类比10进制数取余，十进制数的读到最后一位表示几个1，而读到倒数第二位表示几个10，这样回到二进制，读到最后一位表示有几个字节，读到第二低位表示有多少个字（2字节，而又刚刚好对应二进制，没有余数）。

; ^3 Z! |1 ]) T* A若读者当下理解困难可记住结论：发出一个地址后会自动对该地址左移1位，就是真正的地址，如果还想保持原来的地址，在发地址之前先把地址右移。

. Q# R. [9 R' R2 y5 B0x6C000000    低电平表示命令         

0x6C000002    高电平表示数据
* Q, T8 M4 ~) k2 c* _" F
: Q! T3 Z4 A4 _* r- l3 L
7 v/ K4 ^9 e! D) _4 n
. b8 K* i+ w5 f1 |8 O2 a* G" L
2 h5 E& |* D3 Q: xLCD 测试
, G# C6 O3 {# F, C  X
/ B. U; d$ ~" D步骤：

1.配置RCC

2.配置FSMC
! B2 {9 p$ [- p5 x1 M



3 e1 f" O7 }& {6 r& k
! E" F: ^3 i( {8 h0 k根据上图进行时序大小的设定，图中单位是ns，（读者需根据不同发开发设备进行调试，没有固定值）
1 i- d+ @( u# y( W2 k
9 z$ ]8 \! Q- [( |' z8 Y# \

; F8 S9 [* O2 {; r! B3.编程

. d2 y+ g+ I! P. X4 K2 n: T! R, D+ B! s

1. //lcd.c
   , J1 j* w- @& B8 V# \6 d. W  x& s
2. 
   ) ?! [& J2 K7 J  G3 Y
3. #include "lcd.h"
     a9 S. N& K8 D6 x6 s
4. #include "font.h"
   0 U; l- h4 m- R
5. #include "stdlib.h"
   7 X# }' ~7 Y1 @; j3 N% U8 T
6. 
   5 Y% t7 ^, k" @3 Q4 }$ y
7. #define MAX_HZ_POSX 480
   2 ]7 v6 _# K, D5 O4 a
8. #define MAX_HZ_POSY 227
   2 e: Y8 ?# |2 r+ M
9. 
   
10. #define LCD_RAM    *(__IO uint16_t *) (0x6C000002)    //数据寄存器
    
11. #define LCD_REG    *(__IO uint16_t *) (0x6C000000)//指令寄存器
    " {, g* Z, ^- f
12. 
    # {, E* h2 ~, x% u- T! a2 i
13. #define rw_data_prepare()               write_cmd(34)
    ) x5 ?' t1 N# T, E% |- q- L
14. 
    
15. void write_cmd(unsigned short cmd);
    $ E) T  Z! l3 a
16. unsigned short read_data(void);
    
17. unsigned short DeviceCode;
    ; }+ o% b2 v% v- c+ u  Y$ [
18. 
    3 B" y) x5 _6 _
19. 
    & O) V& a( D" |0 o/ b8 l3 v& Q9 s# O
20. /*
    # G% K+ \5 K4 }, S2 X
21. *
    
22. */
    , L* c5 X5 {* E% O0 e
23. void write_cmd(unsigned short cmd)
    & a4 _3 P+ f0 G  k" ^2 K; ~
24. {
    8 _! c1 u4 h# i8 A" N$ A
25. LCD_REG = cmd;
    
26. }
    ) D4 W5 _: O/ b, `  m' S
27. 
    
28. unsigned short read_data(void)
    6 i0 J3 P4 d6 {  j6 r9 V: v, v
29. {
    
30. unsigned short temp;
    0 j2 c5 J' N- y7 J  D. d
31. temp = LCD_RAM;
    0 l: t4 \2 d/ h9 T% U; C
32. temp = LCD_RAM;
    ) J2 z1 u" T  k* t- }
33. return temp;
    ) D) X: [: H: B3 W6 @. f$ i; E& `
34. }
    1 C% ?. {' o9 v# h  v- F1 S3 J
35. 
    ' u' h6 F5 ^7 I
36. void write_data(unsigned short data_code )
    9 H+ j) G2 Y& }( E
37. {
    1 M6 D: k* j0 N5 s5 N
38. LCD_RAM = data_code;
    
39. }
    2 X( w* u$ }- D' g. Z
40. 
    2 Z2 @/ ~4 @1 J7 X" X1 A
41. void write_reg(unsigned char reg_addr,unsigned short reg_val)
    
42. {
    
43. write_cmd(reg_addr);
    
44. write_data(reg_val);
    
45. }
    # E, `, G& J1 p; C
46. 
    
47. unsigned short read_reg(unsigned char reg_addr)
    " }  O- ~- m/ R0 _* e7 Z# \5 r
48. {
    2 r2 q  Q) {  C4 b* I' p
49. unsigned short val=0;
    # }8 K6 E8 `0 F( v0 ~
50. write_cmd(reg_addr);
    
51. val = read_data();
    . I$ u: g5 ?: F
52. return (val);
    
53. }
    2 a7 N) m' p1 F
54. 
    0 K/ u" X+ {4 X
55. 
    , Y8 y' A0 `$ A5 b& h5 ]+ M
56. void lcd_SetCursor(unsigned int x,unsigned int y)
    # N7 Z: S/ C5 |6 S  X, S3 f7 F% Y
57. {
    
58. write_reg(0x004e,x);    /* 0-239 */
    " s1 i9 `4 x( m  _+ C% W
59. write_reg(0x004f,y);    /* 0-319 */
    / n! c3 m$ n2 {+ K
60. }
    
61. /*读取指定地址的GRAM */
    
62. static unsigned short lcd_read_gram(unsigned int x,unsigned int y)
    : a. y9 [7 w0 E2 j
63. {
    7 H* m7 b; E4 L6 U: g
64. unsigned short temp;
    0 L' j) j8 n3 G' P5 Y
65. lcd_SetCursor(x,y);
    
66. rw_data_prepare();
    
67. /* dummy read */
    0 ?' {, g) v  W4 C! s
68. temp = read_data();
    
69. temp = read_data();
    
70. return temp;
    . |( R" K& b% G# s" K  W
71. }
    * P4 f+ f  _+ k/ [/ T" @
72. static void lcd_data_bus_test(void)
    
73. {
    
74. unsigned short temp1;
    : `9 j1 F& e" M
75. unsigned short temp2;
    2 q2 t8 H; v( o; N
76. /* wirte */
    $ O% O0 z: Q1 z# x& u
77. lcd_SetCursor(0,0);
    
78. rw_data_prepare();
    
79. write_data(0x5555);
    ' ^4 y7 k% Y% k
80. 
    # T8 N6 @+ v% n+ R" B8 ^& s
81. lcd_SetCursor(1,0);
    ; ]  c6 c' B% V5 Z
82. rw_data_prepare();
    
83. write_data(0xAAAA);
    
84. 
    
85. /* read */
    
86. lcd_SetCursor(0,0);
    1 n: \8 j1 l( T
87. temp1 = lcd_read_gram(0,0);
    ! M1 E1 \. h8 Z8 o
88. temp2 = lcd_read_gram(1,0);
    " P8 \2 s: E. {9 |" d* k0 C
89. 
    
90. if( (temp1 == 0x5555) && (temp2 == 0xAAAA) )
    
91. {
    & d3 b4 _* z1 c
92. //printf(" data bus test pass!\r\n");
    * q1 Z9 }7 Q& Z5 h' ^9 I, d1 H
93. }
    
94. else
    ( X/ m3 m, w0 X/ n
95. {
    
96. //printf(" data bus test error: %04X %04X\r\n",temp1,temp2);
    
97. }
    
98. }
    
99. 
    4 C9 S% K5 O  X  q4 u6 d
100. void lcd_clear(unsigned short Color)
     
101. {
     $ _& a$ F$ b1 J$ @
102.   unsigned int count;
     
103. 
       {2 V2 N0 E) f7 m9 G
104. write_cmd(0x002a); //发送列地址：起始-结束
     
105. write_data(0);   
     , k+ a4 O" g* ^5 ~
106. write_data(0);
     
107. write_data(HDP>>8);   
     " M7 P2 \8 Y* G. W: B+ D9 a/ J5 c% [
108. write_data(HDP&0x00ff);
     
109. 
     : G) ~/ v- v6 ^/ Z- w
110. 
     . M5 C$ ?# M2 z2 X" Y  \
111.   write_cmd(0x002b); //发送行地址：起始-结束
     
112. write_data(0);   
     
113. write_data(0);
     
114. write_data(VDP>>8);   
     
115. write_data(VDP&0x00ff);
     
116. 
     0 @2 W" f# v! Q# \4 Q# a+ r
117. write_cmd(0x002c);//写frame buffer命令
     
118. 
     2 {1 Y& {+ F. g0 @6 ]
119. for(count=0;count<130560;count++){
     4 b! R/ E! b0 \7 ]  G
120. 
     
121. write_data(Color);
     
122. }
     
123. }
     
124. 
     
125. void lcd_init(void)
     8 ]0 D) ?& E7 ]8 H% A" i
126. {
     
127. 
     
128. //GPIO_SetBits(GPIOF,GPIO_Pin_9);
     
129. HAL_Delay(50);
     
130. DeviceCode = read_reg(0x0000);
     
131. 
     
132.   write_cmd(0x002b);
     ; c* [1 |' b, O# b6 L0 Q9 T# n
133. write_data(0);
     7 o$ C, Z6 T7 k  @. d9 @
134. 
     ) |6 U# q7 i  @4 g7 d, ~
135. HAL_Delay(50); // delay 50 ms
     ' @( O8 V' x, ~- y! S
136. write_cmd(0x00E2);//PLL multiplier, set PLL clock to 120M
     6 p9 J; ^2 f$ v9 H9 T/ V
137. write_data(0x001D);//N=0x36 for 6.5M, 0x23 for 10M crystal
     
138. write_data(0x0002);
     ! b2 P, a! Z+ r, y9 Y
139. write_data(0x0004);
     . M- M$ |. |' h: [4 J" X
140. 
     + k4 s' A6 H! S' P% n. y0 ~
141. write_cmd(0x00E0);//PLL enable
     
142. write_data(0x0001);
     
143. HAL_Delay(10);
     
144. write_cmd(0x00E0);
     ; i' z! E" l5 M9 {, ?! _) ]6 w
145. write_data(0x0003);
     / W7 n7 E' B6 q6 g2 J; X" M  o( L
146. HAL_Delay(12);
     
147. write_cmd(0x0001);  //software reset
     
148. HAL_Delay(10);
     ( G) @+ b2 ?$ d( h, D. [: i8 F
149. write_cmd(0x00E6);//PLL setting for PCLK, depends on resolution
     7 g; o, V& f( g4 C) y( j9 g1 f
150. //LCD_WriteRAM(0x0001);
       ^8 z- H7 O8 y7 S
151. //LCD_WriteRAM(0x0033);
     ' |4 d5 Q4 k' M* e8 S3 Q0 r9 _
152. //LCD_WriteRAM(0x0032);
       @8 w. n" d7 h: ?
153. write_data(0x0000);
     ) K- A. ^9 p5 U" \
154. write_data(0x00D9);
     6 f& C# B/ i4 A4 u) U; L
155. write_data(0x0016);
     ; }0 a# i% |3 i4 U' N' G
156. 
     1 `/ w/ G, M; ~7 W+ `
157. write_cmd(0x00B0);//LCD SPECIFICATION
     
158. write_data(0x0020);
     , F* Z1 `: d# E0 s. c6 N. \
159. write_data(0x0000);
     
160. write_data((HDP>>8)&0X00FF);//Set HDP
     ( Z6 Y3 |$ ?  F0 `/ @% X: g
161. write_data(HDP&0X00FF);
     
162.     write_data((VDP>>8)&0X00FF);//Set VDP
     6 _, k5 O3 B. _. }# @' m
163. write_data(VDP&0X00FF);
     ' S3 V8 T; @. o4 y  m8 ~
164.     write_data(0x0000);
     
165. 
     
166. write_cmd(0x00B4);//HSYNC
     ! c$ `+ A9 K+ T! N* [
167. write_data((HT>>8)&0X00FF); //Set HT
     
168. write_data(HT&0X00FF);
     . d) I, i  [  o4 u
169. write_data((HPS>>8)&0X00FF);//Set HPS
     ; R+ `; |$ o- f$ H0 p- K
170. write_data(HPS&0X00FF);
     
171. write_data(HPW);//Set HPW
     ) x) G3 i3 N$ y5 m, X9 t
172. write_data((LPS>>8)&0X00FF); //Set HPS
     
173. write_data(LPS&0X00FF);
     % d: _5 O1 i. z  a8 P" Q
174. write_data(0x0000);
     6 z5 q' K4 l- U/ \+ \! v# G& p  Z
175. 
     
176. write_cmd(0x00B6);//VSYNC
     
177. write_data((VT>>8)&0X00FF);   //Set VT
     ' M% m5 w, H9 b' E5 i0 H
178. write_data(VT&0X00FF);
     
179. write_data((VPS>>8)&0X00FF); //Set VPS
     
180. write_data(VPS&0X00FF);
     , i% B/ V! S# L& m
181. write_data(VPW);//Set VPW
     / A+ a! a# [$ Q( H
182. write_data((FPS>>8)&0X00FF);//Set FPS
     
183. write_data(FPS&0X00FF);
     
184. 
     
185. //=============================================
     
186. 
     
187. //=============================================
     
188. write_cmd(0x00BA);
     
189. write_data(0x0005);           //0x000F);    //GPIO[3:0] out 1
     9 ^6 y5 u1 ?% c. i. |  m
190. 
     
191. write_cmd(0x00B8);
     3 g2 ], \! S1 A5 y& J1 }$ I
192. write_data(0x0007);    //GPIO3=input, GPIO[2:0]=output
     ( w; Q/ N! x) d) l
193. write_data(0x0001);    //GPIO0 normal
     
194. 
     
195. write_cmd(0x0036); //rotation
     # m( X% a* a6 g
196. write_data(0x0000);
     ) }4 S8 x3 d* ^$ c; L) |8 o' ^4 {
197. 
     ) c  k3 ~6 @+ o0 L: s- d' |
198. HAL_Delay(50);
     
199. 
     , F: s- `' U( f2 {7 q0 ~8 U" d
200. write_cmd(0x00BE); //set PWM for B/L
     : M' Q& w; L4 P, P. _$ Q+ D# g: c
201. write_data(0x0006);
     / i6 r6 P- j  k! ?9 X
202. write_data(0x0080);
     7 S: U' E/ z& h% w7 n, D
203. 
     - J0 w. N, a* _, w
204. write_data(0x0001);
     4 [" t9 Y- R3 r- t, m; l
205. write_data(0x00f0);
     
206. write_data(0x0000);
     . k/ c1 B9 A. e: T, J- |
207. write_data(0x0000);
     ' J9 [7 F) b& R# J# t# R- ?
208. 
     / g8 v# V- p# ~3 A; s) p0 g: T
209. write_cmd(0x00d0);//设置动态背光控制设置
     
210. write_data(0x000d);
     
211. 
     
212. write_cmd(0x00F0); //pixel data interface
     
213. write_data(0x0003);//03:16位 02:位»
     
214. 
     
215. write_cmd(0x0029); //display on
     . g/ q* i* G1 m. r
216. 
     - ?# n0 h) \' z- S5 w
217. //lcd_data_bus_test();
     
218. lcd_clear(Yellow);//初始化全屏填充颜色
     2 c# e' i. }% }$ |
219. }
     
220. /*********************************************************************************************************
     , d/ M# r) J) c! D' b
221. ** Functoin name:       LCD_SetCursor
     ; i' I* L7 |2 n4 b% A# Y8 r
222. ** Descriptions:        设置做标
     
223. ** input paraments:     Xpos、Ypos坐标
     ; {6 }/ z7 s) t7 h" X# c
224. ** output paraments:    无   
     / e* M: e! u" f3 w, x2 n5 e
225. ** Returned values:     无
     3 X* `* A% s" [. f
226. *********************************************************************************************************/
     
227. 
     
228. void LCD_SetCursor(uint16_t Xpos, uint16_t Ypos)
     % f2 E% A7 e% s  Z
229. {
     " _" R' w0 A: ^. ]" l
230. write_cmd(0x002A);
     
231. write_data(Xpos>>8);   
     # w) u( e* n) O5 j5 I- _0 T2 k
232. write_data(Xpos&0x00ff);
     % ~5 a+ E$ ^4 {/ p0 G# R1 ^% R/ j
233. write_data(479>>8);   
     , b1 J+ v4 A" L: R$ @1 {& r+ {
234. write_data(479&0x00ff);
     ' W, s$ q; H2 f. X" s. L$ M( K7 G
235. 
     4 P% [6 J) P# t  K4 t
236.   write_cmd(0x002b);
     $ S) [& p3 D: o) F  [
237. write_data(Ypos>>8);   
     
238. write_data(Ypos&0x00ff);
     
239. write_data(271>>8);   
     2 x' [: |, y3 M& Q
240. write_data(271&0x00ff);
     
241. }
     & [+ S% h! s/ ^
242. /*********************************************************************************************************
     
243. ** Functoin name:       LCD_DrawPoint
     8 @; M8 c' w# r' n* |
244. ** Descriptions:        画点
     . ~2 G4 o! k3 k$ T$ f# p& F) k8 `
245. ** input paraments:     x.y:画点的坐标
     ; ^9 B) h8 _' G7 ?$ ?
246. color:颜色
     
247. ** output paraments:    无   
     9 O' f3 H2 B. e1 t; D- {
248. ** Returned values:     无
     / I# f% |% J. D- y3 b/ a0 N% y0 d* S
249. *********************************************************************************************************/
     $ L# |/ n' @& ^( S7 S2 D5 h6 o
250. 
     . C6 L; Z8 E1 k7 E$ y) N. A; A
251. void LCD_DrawPoint(uint16_t xsta, uint16_t ysta, uint16_t color)
     1 _. k3 ]) ?& ]
252. {
     
253. LCD_SetCursor(xsta, ysta);  /*设置光标位置 */
     
254. write_data_Prepare();          /*开始写入GRAM */
     
255. write_data(color);
     $ @, m6 }; J. Y( ~0 n  M
256. 
     
257. }
     
258. 
     ( W2 f2 \! w$ ~! a- ?" x/ A* j; Y
259. 
     * R" m8 ?& `8 I
260. /**
     
261. *名称:void WriteOneHz(uint16_t x0, uint16_t y0, uint8_t *pucMsk, uint16_t PenColor, uint16_t BackColor)
     
262. *参数:x0,y0起始坐标
     
263.    *pucMsk   指向
     
264.    PenColor  字符颜色
     7 Q6 v% e, Y+ q4 K! s. e5 A3 J
265.    BackColor 背景颜色
     
266. *功能:
     # I, \+ R6 F+ n% f4 q
267. *备注：此函数不能单独作为汉字字符显示  
     ; i) [& d+ o% C( c; k
268. **/
     4 g- M5 T* ]) d3 E4 Y  Y4 E
269. void WriteOneHz(uint16_t x0, uint16_t y0, uint8_t *pucMsk, uint16_t PenColor, uint16_t BackColor)
     
270. {
     1 R+ `. p3 D  o9 P
271.     uint16_t i,j;
     
272.     uint16_t mod[16];                                      /* 当前字模 16*16 */
     
273.     uint8_t *pusMsk;                                       /* 当前字库地址  */
     
274.     uint16_t y;
     
275. 
     # m4 T5 B, U# q2 E7 F
276.     pusMsk = pucMsk;
     + @6 K& r" N. }* _$ \* K
277. 
     ( F4 v9 E& x8 t- F
278. 
     
279.     for(i=0; i<16; i++)                   /*保存当前汉字点阵字模式       */
     ( V6 Z' w" B9 g$ W- \7 t5 e
280.     {
     
281.         mod = (*pusMsk << 8) | (*(pusMsk + 1));  /*取得当前字模，合并为半字对齐访问    */     
     8 {& i' f) I; c& \: [
282. pusMsk = pusMsk+2;
     
283.     }
     
284.     y = y0;
     ) C+ N; c0 V8 \. T$ a4 p+ f
285.     for(i=0; i<16; i++)                                    /* 16行   */
     
286.     {                                             
     
287.         for(j=0; j<16; j++)                                /* 16列   */
     + R" R4 I) X  h' ^
288.         {
     - D+ `( \( [; U
289. if((mod << j) & 0x8000)       /* 显示第1行，共16个点*/
     
290. {
     - ~5 a% S1 n  e; {# ^
291. LCD_DrawPoint(x0+j, y0+i, PenColor);
     
292. }
     
293. else
     % L6 a% G; w! z5 n0 @
294. {
     ) _- }$ |3 ]) k9 U% y$ E  |
295. LCD_DrawPoint(x0+j, y0+i, BackColor);
     , S: m4 _# a& M- `" g8 o( ~: h' D: j) o
296. }
     
297.         }
     
298.         y++;
     0 b* A( g% X/ [6 i1 x" q% s5 ^( @
299.     }
     
300. }
     
301. /**
     ; V; c# |$ f- p' H: I5 W
302. *名称: uint16_t findHzIndex(uint8_t *hz)
     % [* [2 b; s, A8 p1 y. W7 w
303. *参数:hz
     
304. *功能:索引汉字存储的内存地址
       e) e- [  N) K$ r# ]
305. *备注
     # e- l' W4 Q* J7 n: n* G8 v
306. **/
     
307. uint16_t findHzIndex(uint8_t *hz)     /* 在自定义汉字库查找要显示的汉字的位置 */                                                   
     * S: O5 ?. e* l
308. {
     
309. uint16_t i=0;
     
310. FNT_GB16 *ptGb16 = (FNT_GB16 *)GBHZ_16;/*ptGb16指向BHZ_16*/
     ! a- i4 Q( g+ _9 e' {& c
311. while(ptGb16.Index[0] > 0x80)
     - Y. n( k1 r& c' r( m$ W
312. {
     0 d! n; f7 t' a+ |" o3 K
313. if ((*hz == ptGb16.Index[0]) && (*(hz+1) == ptGb16.Index[1]))
     
314.                 /*汉字用两位来表示地址码*/
     0 w% c* R' Q0 h
315. {
     
316. return i;
     
317. }
     
318.     i++;
     , f2 h, s; V5 X0 _( d( o, Y( X' N2 \
319.     if(i > (sizeof((FNT_GB16 *)GBHZ_16) / sizeof(FNT_GB16) - 1))  /*搜索下标约束*/
     5 _; D9 u& D! w6 s& e+ y
320.     {
     1 O7 |1 T3 u, j/ D* P- F+ e9 @  h
321. break;
     * t0 |) b5 m& ~; d
322.     }
     
323. }
     7 I3 D# X7 t; r' S( T( i
324. return 0;
     " E/ p! s7 N5 |) z. Z
325. }
     7 {, b  r- T8 }7 r
326. /**
     : t- {1 D% C  t/ M6 ?4 k
327. *名称:void LCD_ShowHzString(uint16_t x0, uint16_t y0, uint8_t *pcStr, uint16_t PenColor, uint16_t BackColor)
     7 `& I4 J. z' O0 ^+ R0 \+ n
328. *参数：x0,y0   起始坐标
     
329.    pcStr     指向
     
330.    PenColor  字体颜色
     
331.    BackColor 字体背景
     * z7 `9 S% b. w! V3 Z
332. *功能：显示汉字字符串
     " v$ V8 K4 c- q+ z6 @  t6 o
333. *备注：这个函数不能单独调用      
     
334. **/
     " E8 D$ G! N0 ]) [9 y% w
335. void LCD_ShowHzString(uint16_t x0, uint16_t y0, uint8_t *pcStr, uint16_t PenColor, uint16_t BackColor)
     
336. {
     
337. uint16_t usIndex;
     
338. uint8_t size = 16;
     
339. FNT_GB16 *ptGb16 = 0;   
     
340.     ptGb16 = (FNT_GB16 *)GBHZ_16;
     + ]) q3 y+ f, w9 q
341. 
     " ~9 O$ h3 u! O" ~. Z
342. if(x0>MAX_HZ_POSX){x0=0;y0+=size;}/*超出x轴字体最小单位，换行*/
     
343.         if(y0>MAX_HZ_POSY){y0=x0=0;lcd_clear(White);}   /*超出r轴字体最小单位，回到原点,并且清屏*/
     
344. 
     
345.          usIndex = findHzIndex(pcStr);
     / `& x3 `$ @/ P5 o2 K' \
346. WriteOneHz(x0, y0, (uint8_t *)&(ptGb16[usIndex].Msk[0]),  PenColor, BackColor); /* 显示字符*/
     - O$ x$ E( x# ?# S& v$ P
347. }
     " T8 U+ W9 S* _
348. /**
     ) Q/ m, Z& c( j+ N3 \& E4 e/ }
349. *名称:void LCD_ShowChar(uint8_t x, uint16_t y, uint8_t num, uint8_t size, uint16_t PenColor, uint16_t BackColor)
     
350. *参数:x,y      起始坐标x:0~234 y:0~308£©
     0 L0 e8 p8 C7 i2 C2 e. N+ I
351.    num       字符AsCII码值
     " X( A, |& w6 i0 S4 b
352.    size      字符大小，使用默认8*16
     
353.    PenColor  字体颜色
     
354.    BackColor 字体背景颜色
     
355. *功能:
     
356. *备注:注意屏幕大小
     
357. **/
     
358. void LCD_ShowChar(uint16_t x, uint16_t y, uint8_t num, uint8_t size, uint16_t PenColor, uint16_t BackColor)
     . S. G" N% K/ q; \. C' }4 a+ Q
359. {      
     4 V) a2 v5 t( z) E
360. #define MAX_CHAR_POSX (272-8)
     & u1 W1 z3 y) u2 B
361. #define MAX_CHAR_POSY (480-16)
     
362.     uint8_t temp;
     
363.     uint8_t pos,t;
     
364.     if(x>MAX_CHAR_POSX||y>MAX_CHAR_POSY)return;   
     6 m: B- D3 d* t; p) C
365. num=num-' ';                         /*得到偏移后的值*/
     
366. for(pos=0;pos<size;pos++)
     & @- g6 g% v9 v+ ]& V
367. {
     
368. if(size==12)
     
369. temp=asc2_1206[num][pos];/*调用1206字体*/
     
370. else
     * T' u: _! g2 v% Q  ?% Z) I9 T4 {
371. temp=asc2_1608[num][pos];/*调用1608字体*/
     : b6 m7 t: `& H
372. for(t=0;t<size/2;t++)
     
373.     {                 
     9 n$ @7 _0 h& a. f2 C; q: X
374.       if(temp&0x01) /*从低位开始*/
     ; H+ R- m4 K& [" n- `9 s
375.      {
     " u) A3 @) {5 h  n2 [" D
376. LCD_DrawPoint(x+t, y+pos, PenColor);  /*画字体颜色，一个点*/
     
377.      }
     / D) x3 P" u  l! i$ ]" G1 q
378.     else
     # g9 ^2 R, I0 a7 Y( M. a
379. LCD_DrawPoint(x+t, y+pos, BackColor);/*画背景颜色，一个点*/     
     3 L. A3 P: X8 n. P4 I1 t/ `
380. temp>>=1;
     , M; _3 B# J; M6 X+ _
381.     }
     
382. }
     
383. }
     
384. /**
     8 j5 x1 [2 n; [
385. 名称:void LCD_ShowCharString(uint16_t x, uint16_t y, const uint8_t *p, uint16_t PenColor, uint16_t BackColor)
     2 N8 Y  @. e2 C1 S2 w
386. 参数:x,y      起始坐标
     5 f2 c- _9 D2 Y3 F, @$ h1 O
387.       p        指向字符串起始地址·
     
388.       PenColor  字符颜色
     
389.       BackColor 背景颜色
     0 }* ~; @0 B7 Y5 Y: n0 \
390. 功能:
     
391. 备注:用16字体，可以调节 此函数不能单独调用
     
392. **/
     
393. void LCD_ShowCharString(uint16_t x, uint16_t y, const uint8_t *p, uint16_t PenColor, uint16_t BackColor)
     
394. {   
     ! K" \  f% b1 U- T0 B/ t
395. uint8_t size = 16;     /*---字符大小默认16*8---*/
     
396. 
     
397.     if(x>MAX_HZ_POSX){x=0;y+=size;}/*超出x轴字体最小单位，换行*/
     8 J( i5 Q- @/ u3 B
398.     if(y>MAX_HZ_POSY){y=x=0;lcd_clear(White);} /*超出y轴字体最小单位，回到原点，并且清屏*/
     + q+ m" Q9 p9 d' y1 l$ g' x7 k/ K
399.     LCD_ShowChar(x, y, *p, size, PenColor, BackColor);/*0表示非叠加方式*/
     
400. }
     
401. 
     
402. /**
     
403. *名称:ºvoid LCD_ShowString(uint16_t x0, uint16_t y0, uint8_t *pcstr, uint16_t PenColor, uint16_t BackColor)
     ; G7 `5 n6 p! ?& {9 \$ u
404. *参数:x,y      起始坐标
     
405.       pcstr    字符串指针
     5 [7 H3 y! n! }# e. ~7 }0 I8 c
406.       PenColor  字符颜色
     2 @; @/ X1 m# ^4 |. q5 r- O" z" X9 w
407.       BackColor 背景颜色
     , N& G$ \. z1 c! x& {5 m
408. *功能:调用字符串和汉字显示函数，实现字符串显示
     
409. *备注
     7 X3 O+ k1 T8 n5 B- y$ _
410. **/
     
411. void LCD_ShowString(uint16_t x0, uint16_t y0, uint8_t *pcStr, uint16_t PenColor, uint16_t BackColor)
     
412. {
     6 e. k5 F1 P. G' e* T" V
413. while(*pcStr!='\0')
     
414. {
     
415. if(*pcStr>0x80) /*显示汉字*/
     
416. {
     
417. LCD_ShowHzString(x0, y0, pcStr, PenColor, BackColor);
     
418. pcStr += 2;
     8 u1 O: q2 M' \% e/ W, ]2 }
419. x0 += 16;
     
420. }
     
421. else           /*显示字符*/
     
422. {
     
423. LCD_ShowCharString(x0, y0, pcStr, PenColor, BackColor);
     $ z* T" d& p5 |0 `" }% S
424. pcStr +=1;
     
425. x0+= 8;
     * m7 p1 m! O/ M
426. }
     " g8 O; e/ q& c4 V( w* P8 `, g
427. 
     
428. }
     
429. 
     2 V! ]2 x5 G6 E& x- f
430. }
     6 U9 t( Y. D) b2 L# |7 m
431. //
     ! r- J7 s/ J! K
432. ///*********************************************************************************************************
     ( c. b3 r: J, w/ H8 S2 o' {5 X
433. //** Functoin name:       write_data_Prepare
     & d5 t6 V; A" x  `* S
434. //** Descriptions:        写数据开始
     
435. //** input paraments:     无
     . g* _. f: S+ ?, `
436. //** output paraments:    无   
     ) b$ ~3 J- E0 ^1 F0 U
437. //** Returned values:     无
     
438. //*********************************************************************************************************/
     . i! h/ X: w7 f( A
439. 
     
440. void write_data_Prepare(void)
     0 W& G) b! j6 |7 Q$ d1 |
441. {
     : S) l7 K! Y/ }5 k6 a! O
442. write_cmd(0x002C);
     
443. }
     
444. /*********************************************************************************************************
     & K4 y3 U, L. j9 H$ L1 S! _
445. ** Functoin name:       LCD_WindowMax
     6 P- X0 y5 ^2 z
446. ** Descriptions:        设置窗口
     
447. ** input paraments:     窗口的位置
     
448. ** output paraments:    无   
     + C  z% k8 w2 W2 |3 L4 R  F
449. ** Returned values:     无
     4 l& v# _0 E1 `6 \  p; d
450. *********************************************************************************************************/
     
451. void LCD_WindowMax (unsigned int xsta,unsigned int xend, unsigned int ysta,unsigned int yend)
     + L2 J+ C( c5 g
452. {
     # X6 j& P  c; B
453. write_cmd(0X002A);
     $ f' [8 q4 B' u+ V! I
454. write_data(xsta>>8);
     
455. write_data(xsta&0X00FF);
     
456. write_data(xend>>8);
     
457. write_data(xend&0X00FF);
     
458. 
     ! r# A: S- F0 p( Z, c
459. write_cmd(0X002B);
     4 ^2 q; t8 g& M& Z
460. write_data(ysta>>8);
     
461. write_data(ysta&0X00FF);
     
462. write_data(yend>>8);
     , N& L2 i2 A7 _- P
463. write_data(yend&0X00FF);
     - {6 |4 P4 y3 c
464. }
     & n* P5 l2 \1 q
465. /*********************************************************************************************************
     
466. ** Functoin name:     LCD_Fill
     
467. ** Descriptions:      填充窗口
     ) x) ]: u  y7 m* D6 r
468. ** input paraments:   窗口的位置
     
469.   colour£:    颜色
     & a6 L, q  X1 [9 o, g' l9 k
470. ** output paraments:    无   
     : e3 `* I: F4 M1 ^; |8 q! M4 ?% l# ?3 Y; y) X
471. ** Returned values:     无
     0 c) T. [+ k7 H: E3 V" T. S
472. *********************************************************************************************************/
     
473. 
     ! D0 q: p3 {1 P: F8 N2 V
474. 
     
475. void LCD_Fill(uint16_t xsta, uint16_t xend, uint16_t ysta,  uint16_t yend, uint16_t colour)
     & ?  y; E* Y3 c; m8 c
476. {                    
     8 K) ~: t% F! j7 e! J
477.     uint32_t n;
     0 g7 T$ |& x, y& t
478. 
     8 J# z; s6 m* y6 G
479. /*设置窗口*/
     
480. LCD_WindowMax (xsta,  xend,  ysta, yend);
     ; W  a/ @7 N& S3 T" N. ?
481. write_data_Prepare();         /*开始写入GRAM*/
     " Q8 Y0 H2 N+ n$ f' m: n% D4 I4 G
482. 
     + p, n8 p& u5 a, \
483. n=(uint32_t)(yend-ysta+1)*(xend-xsta+1);
     " i8 I% c: f* ?( i
484. 
     " r8 H1 i2 j5 H! s' c
485. while(n--){write_data(colour);} /*显示所填充的颜色*/
     * }5 R" K' E4 S# ]2 j
486. }
       O; u3 |* K5 e( I" [( O! i
487. 
     ; h' B8 w; Y! b; A4 m+ x2 ^( V0 K
488. 
     
489. /*********************************************************************************************************
     5 }  {! Y# [! k5 A  H" A% }  O
490. ** Functoin name:       LCD_DrawLine
     
491. ** Descriptions:        指定坐标（两点）画线
     . L, @4 i3 F# @6 |) S. z# G
492. ** input paraments:     xsta X起始坐标
     
493.                         ysta Y起始坐标
     
494.                         xend X终点坐标
     % B3 r0 y' _4 z% K8 b6 g( {
495.                         yend Y终点坐标
     " u; E5 {' i3 I& j0 j
496.                         colour颜色
     
497. ** output paraments:    无  
     5 h+ b9 u2 J0 P- `8 Y
498. ** Returned values:     无
     & @/ }; C6 S0 r" n/ Y
499. *********************************************************************************************************/
     
500. 
     8 |2 e5 A' E8 g* G$ f
501. void LCD_DrawLine(uint16_t xsta, uint16_t xend, uint16_t ysta,uint16_t yend, uint16_t color)
     
502. {
     9 K' s" M$ l- K# h; c0 f( H
503.     uint16_t x, y, t;
     
504. if((xsta==xend)&&(ysta==yend))
     
505. LCD_DrawPoint(xsta, ysta, color);
     1 A' {# n; a* G. _, z
506. else
     ( I4 ^" z3 X. ?7 b3 |; y- p
507. if(abs(yend-ysta)>abs(xend-xsta))//斜率大于1  
     3 R. @% c0 v$ v# e2 z
508. {
     4 g  u( G* |5 `( K- p
509. if(ysta>yend)
     
510. {
     ( Y. R: x6 T- K/ u3 C
511. t=ysta;
     
512. ysta=yend;
     
513. yend=t;
     7 d  Z3 n9 J- R2 `  {+ i" ?7 S
514. t=xsta;
     
515. xsta=xend;
     
516. xend=t;
     
517. }
     % O- S1 R0 R# R4 {" g
518. for(y=ysta;y<yend;y++)            /*以y轴为基准*/
     
519. {
     5 r2 c# \6 {* o8 ^3 z& q1 }8 Y8 ]8 }  E
520. x=(uint32_t)(y-ysta)*(xend-xsta)/(yend-ysta)+xsta;
     
521. LCD_DrawPoint(x, y, color);  
     
522. }
     . }! Z3 B) t  z# O) e( G+ h! c( a6 c
523. }
     & n  v0 C5 }; {$ H; r
524. else     /*斜率小于等于1*/
     
525. {
     
526. if(xsta>xend)
     
527. {
     
528. t=ysta;
     5 u) _* a/ X2 G' z3 b' Q8 o! U
529. ysta=yend;
     
530. yend=t;
     
531. t=xsta;
     , ~, Q/ [1 m, R6 |5 t
532. xsta=xend;
     7 z" C+ m1 A. {! x
533. xend=t;
     , _9 Q/ }% W1 }! J
534. }   
     2 _* b6 }$ x& l" p* Y
535. for(x=xsta;x<=xend;x++)  /*以x轴为基准/
     " A! T, d% L  b5 M8 O
536. {
     1 o' A" s; w6 h; _
537. y =(uint32_t)(x-xsta)*(yend-ysta)/(xend-xsta)+ysta;
     
538. LCD_DrawPoint(x, y, color);
     $ B- s( Z# ^7 K" m7 Z! X
539. }
     
540. }
     
541. }
     , T; S, b/ ?& \$ f
542. /**
     
543. 
     
544. *名称:void Draw_Circle(uint16_t x0, uint16_t y0, uint8_t r)
     + b' ~! M3 b, q3 j3 h" G, @
545. *参数:x0 中心点横坐标
     
546.       y0 中心点纵坐标
     ) D. ?9 T3 f' Y5 b
547.       r  半径
     
548. *返回:无
     
549. *功能:在指定位置画一个指定大小的圆
     ( s  h! A  P3 X" }% v) _
550. *备注:加入颜色参数，是否填充等
     ' C4 x8 z5 P( H" q: Y9 W) m
551. **/
     1 |, t% H2 L; n0 Z9 A/ N
552. void Draw_Circle(uint16_t x0, uint16_t y0, uint8_t r, uint16_t color)
     ' B# Y! ~/ h5 \
553. {
     
554. int a,b;
     ; {/ G& ]4 S; r* \7 z6 p
555. int di;
     
556. a=0;b=r;  
     ' Q. q# c2 A$ q( g* L# W; O
557. di=3-(r<<1);             /*判断下个点位置标志*/
     
558. while(a<=b)
     
559. {
     + k$ v" o7 o. ~; f2 O% _
560. LCD_DrawPoint(x0-b, y0-a, color);             //3           
     
561. LCD_DrawPoint(x0+b, y0-a, color);             //0           
     
562. LCD_DrawPoint(x0-a, y0+b, color);             //1      
     
563. LCD_DrawPoint(x0-b, y0-a, color);             //7           
     0 v$ e" I% ~4 \( d  l8 L/ U  A; o! z
564. LCD_DrawPoint(x0-a, y0-b, color);             //2            
     9 r$ H8 A' N' R6 Z
565. LCD_DrawPoint(x0+b, y0+a, color);             //4               
     2 f  J: X" M0 M( p
566. LCD_DrawPoint(x0+a, y0-b, color);             //5
     " r; z2 Y: V1 H  C8 q: W2 c' ~
567. LCD_DrawPoint(x0+a, y0+b, color);             //6
     ; S; {$ @1 L& k# Z8 Q7 L
568. LCD_DrawPoint(x0-b, y0+a, color);            
     
569. a++;
     
570. 
     
571. /*使用Bresenham算法画圆*/     
     + [7 V: ~/ W; W) F9 t* ]& y
572. if(di<0)di +=4*a+6;  
     
573. else
     
574. {
     : B& a! l* I5 b& Q
575. di+=10+4*(a-b);   
     " O+ ~) X; {: ~2 ~3 \) o- A
576. b--;
     3 F) p: e4 e! K
577. }
     ; J, q# L$ z7 o( v; \
578. LCD_DrawPoint(x0+a, y0+b, color);
     
579. }
     
580. }
     
581. /**
     5 t; v5 I  V' e/ k9 ^5 E
582. 
     
583. *名称:void LCD_DrawRectangle(uint16_t xsta, uint16_t ysta, uint16_t xend, uint16_t yend)
     
584. *参数:xsta x起始坐标
     
585.       ysta Y起始坐标
     
586.       xend x结束坐标
     
587.       yend Y结束坐标
     8 G8 n* B1 g9 \* N( a% Z
588. *返回:无
     
589. *功能:在指定区域画矩形
     
590. *备注:
     
591. 
     
592. **/
     
593. void LCD_DrawRectangle(uint16_t xsta, uint16_t xend, uint16_t ysta,uint16_t yend, uint16_t color)
     , h! r5 z( \: o9 k; @3 ?  q+ q: J3 P
594. {
     
595. LCD_DrawLine(xsta, xend, ysta, ysta, color);
     8 j: v- I, I2 W/ D/ a) V
596. LCD_DrawLine(xsta, xsta, ysta, yend, color);
     ( d( O5 ]  I6 ], d5 f5 s; o
597. LCD_DrawLine(xsta, xend, yend, yend, color);
     
598. LCD_DrawLine(xend, xend, ysta, yend, color);
     9 C. I5 s0 ^& r" {2 p( Y
599. }
     3 _& P% c  p/ m1 i9 ^& V
600. /****************************************************************************
     
601. *名称:void LCD_DrawPicture(uint16_t StartX,uint16_t StartY,uint16_t EndX,uint16_t EndY,uint16_t *pic)
     
602. *功能:在指定座标范围显示一副图片
     
603. *入口参数:StartX     行起始坐标
     
604. *        EndX       行结束坐标
     1 U3 ~, Q! J5 V( m5 W, G
605. *        StartY     列起始坐标
       y7 I$ @* N' U! X5 h; S- C
606. *        EndY       列结束坐标
     
607.          pic        图片头指针
     
608. * 出口参数:无
     
609. * 说    明:图片取模格式为水平扫描，16位颜色模式
     * q* N! p0 v1 \
610. * 调用方法:ºLCD_DrawPicture(0,0,100,100,(uint16_t*)demo);
       Q$ h" P. e6 E1 C7 ~- o; J
611. ****************************************************************************/
     " v0 A8 e) V+ f4 \# r
612. void LCD_DrawPicture(uint16_t StartX,uint16_t Xend,uint16_t StartY,uint16_t Yend,uint8_t *pic)
     6 l" B2 g* a4 |
613. {
     4 E% j! b# h' r, x' p! e/ Q6 q
614. staticuint16_t i=0,j=0;
     * x) V" i; w1 d0 x
615. uint16_t *bitmap = (uint16_t *)pic;
     
616. 
     
617. for(j=0; j<Yend-StartY; j++)
     5 L( X% H1 Z7 t& n; s
618. {
     
619. for(i=0; i<Xend-StartX; i++)
     5 q. [. f0 r8 e; R5 i% T) P; E  O
620. LCD_DrawPoint(StartX+i, StartY+j, *bitmap++);
     
621. }
     
622. }
     : U8 ^0 T+ j3 K& t1 h5 d- s  ^
623. 
     ! A: G9 n( Y  b( t. b# C

复制代码

4 N( V  f7 M5 I2 |