: ~$ C0 L" [# o! L+ {) ~

一、常见显示器类型介绍

6 r+ D; r; [6 K# B! S: g) s

显示器属于输出设备，它是一种将特定电子信息输出到屏幕上再反射到人眼的显示工具。常见显示器有三类：CRT显示器、LCD液晶显示器和LED点阵显示器。

CRT显示器：CRT显示器是靠电子束激发屏幕内表面的荧光粉来显示图像的，由于荧光粉被点亮后很快会熄灭，所以电子枪必须循环地不断激发这些点。

LCD显示器：液晶显示器，简称 LCD(Liquid Crystal Display)，相对于上一代 CRT显示器，LCD 显示器具有功耗低、体积小、承载的信息量大及不伤眼的优点，因而它成为了现在的主流电子显示设备，其中包括电视、电脑显示器、手机屏幕及各种嵌入式设备的显示器。

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

LED显示器：LED点阵彩色显示器的单个像素点内包含红绿蓝三色LED灯，通过控制红绿蓝颜色的强度进行混色，实现全彩颜色输出，多个像素点构成一个屏幕。由于每个像素点都是LED灯自发光的，所以在户外白天也显示得非常清晰，但由于LED灯体积较大，导致屏幕的像素密度低，所以它一般只适合用于广场上的巨型显示器。相对来说，单色的LED点阵显示器应用得更广泛，如公交车上的信息展示牌、店广告牌等。

; y) ?6 \% y  q/ \

, p( z9 m* |  j, S4 i5 T9 v0 l

OLED显示器：新一代的OLED显示器与LED点阵彩色显示器的原理类似，但由于它采用的像素单元是“有机发光二极管”(Organic Light Emitting Diode)，所以像素密度比普通LED点阵显示器高得多。OLED显示器具有不需要背光源、对比度高、轻薄、视角广及响应速度快等优点。待到生产工艺更加成熟时，必将取代现在液晶显示器的地位。

2 x& ]( B' G$ K# ^

二、显示器的基本参数

) i% w  R, M7 x! w: e4 Z# C

像素：是组成图像的最基本单元要素，显示器的像素指它成像最小的点，即前面讲解液晶原理中提到的一个显示单元。

( }3 d9 y! s! ~' T

分辨率： 一些嵌入式设备的显示器常常以“行像素值x列像素值”表示屏幕的分辨率。如分辨率800x480表示该显示器的每一行有800个像素点，每一列有480个像素点，也可理解为有800列，480行。

8 b" I5 P  C- ~. }% `$ [( z% U

" U% T0 N% h. h: s! [% m

色彩深度：指显示器的每个像素点能表示多少种颜色，一般用“位”(bit)来表示。如单色屏的每个像素点能表示亮或灭两种状态(即实际上能显示2种颜色)，用1个数据位就可以表示像素点的所有状态，所以它的色彩深度为1bit，其它常见的显示屏色深为16bit、24bit。

显示器尺寸：显示器的大小一般以英寸表示，如5英寸、21英寸、24英寸等，这个长度是指屏幕对角线的长度，通过显示器的对角线长度及长宽比可确定显示器的实际长宽尺寸

) E6 Y' L" V! N+ Y) T

显存：液晶屏中的每个像素点都是数据，在实际应用中需要把每个像素点的数据缓存起来，再传输给液晶屏，一般会使用 SRAM 或 SDRAM 性质的存储器，而这些专门用于存储显示数据的存储器，则被称为显存。显存一般至少要能存储液晶屏的一帧显示数据。

( l% v5 Y$ {) d4 N* q

如分辨率为 800x480 的 液 晶 屏  使 用 RGB888 格 式 显 示 ， 它 的 一 帧 显 示 数 据 大 小 为 ：3（字节）x800x480=1152000 字 节 ；若 使 用 RGB565 格 式 显 示 ， 一 帧 显 示 数 据 大 小 为 ：2（字节）x800x480=768000 字节。

一般来说，外置的液晶控制器会自带显存，而像 STM32F429等集成液晶控制器的芯片可使用内部 SRAM或外扩 SDRAM用于显存空间

! P% Z) k# N3 g. d8 S8 `6 o

三、TFT-LCD控制框图

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

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

0 [/ S& s8 j: ^' B7 l5 L; S' r

四、TFT-LCD控制原理

$ ?$ B- _0 q! `" P2 X7 P2 v; x; q

TFT-LCD结构：完整的显示屏由液晶显示面板、电容触摸面板以及 PCB底板构成

( O8 Y1 C2 {: u8 }& X5 d# e! A

1.液晶显示面板：用于显示图像，文字的彩色显示设备

2.触摸面板：触摸面板带有触摸控制芯片，该芯片处理触摸信号并通过引出的信号线与外部器件通讯，触摸面板中间是透明的，它贴在液晶面板上面，一起构成屏幕的主体

8 j- ]1 h& k' L5 G1 S

3.PCB 底板：PCB 底板上可能会带有“液晶控制器芯片”因为控制液晶面板需要比较多的资源，所以大部分低级微控制器都不能直接控制液晶面板，需要额外配套一个专用液晶控制器来处理显示过程，外部微控制器只要把它希望显示的数据直接交给液晶控制器即可。而不带液晶控制器的PCB底板，只有小部分的电源管理电路，液晶面板的信号线与外部微控制器相连，直接控制。

5 g9 g1 B8 x0 p) y2 K9 s7 B

5 a: W8 l, x2 V" G: `0 p1 G

五、RGB-LCD控制原理

2 I+ }, d5 G6 Q: M

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

7 a0 X1 a; X  ~7 K4 P

+ [/ o+ P  D4 X$ ?/ D& T9 R

同步时钟信号CLK：液晶屏与外部使用同步通讯方式，以CLK信号作为同步时钟，在同步时钟的驱动下，每个时钟传输一个像素点数据。

! p. Q- D! r' Q$ v8 k

水平同步信号HSYNC：水平同步信号HSYNC(Horizontal Sync)用于表示液晶屏一行像素数据的传输结束，每传输完成液晶屏的一行像素数据时，HSYNC会发生电平跳变，如分辨率为800x480的显示屏(800列，480行)，传输一帧的图像HSYNC的电平会跳变480次。

垂直同步信号VSYNC：垂直同步信号VSYNC(Vertical Sync)用于表示液晶屏一帧像素数据的传输结束，每传输完成一帧像素数据时，VSYNC会发生电平跳变。其中“帧”是图像的单位，一幅图像称为一帧，在液晶屏中，一帧指一个完整屏液晶像素点。人们常常用“帧/秒”来表示液晶屏的刷新特性，即液晶屏每秒可以显示多少帧图像，如液晶屏以60帧/秒的速率运行时，VSYNC每秒钟电平会跳变60次。

数据使能信号DE：数据使能信号DE(Data Enable)用于表示数据的有效性，当DE信号线为高电平时，RGB信号线表示的数据有效。

: U& b0 _. H( j5 i' O

LCD数据传输时序

一个VSYNC（即一帧）包含若干个HSYNC（即若干行），而一个HSYNC包含若干个像素点（一个24位数据）

  @7 }/ c$ s! Q4 w& |' Y* F

. F! I' l& q2 r% d' E

液晶屏显示的图像可看作一个矩形，液晶屏有一个显示指针，它指向将要显示的像素。显示指针的扫描方向方向从左到右、从上到下，一个像素点一个像素点地描绘图形。这些像素点的数据通过RGB数据线传输至液晶屏，它们在同步时钟CLK的驱动下一个一个地传输到液晶屏中，交给显示指针，传输完成一行时，水平同步信号HSYNC电平跳变一次，而传输完一帧时VSYNC电平跳变一次。

9 H0 m9 o7 |7 \( _% u1 a' f( U2 S3 V

液晶显示指针在行与行之间，帧与帧之间切换时需要延时，而且HSYNC及VSYNC信号本身也有宽度，这些时间参数说明见下表：

5 z) q3 Y; A& B" B# {# m6 o3 y

六、SSD1963液晶控制器

液晶驱动芯片或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电器连线图如下：

5 ?/ T, c* u! J# l2 u% j

8080时序-写数据/命令

1. 
   
2. //用GPIO管脚模拟8080时序
   
3. 
   
4. void LCD_WR_Byte(uint8_t dat, uint8_t cmd)
   
5. {
   
6.   LCD_Data_Out(dat);        //放入数据  
   
7. if(cmd)  
   $ S& o. I9 G. h
8.       LCD_DC_Set();        //传命令      
   ' F. d7 n# q3 Y0 q
9. else
   7 n- p" _( y9 v$ }* E% m  c" b
10.       LCD_DC_Clr();       //传数据
    
11. 
    
12. LCD_CS_Clr();           //拉低片选
    
13. LCD_WR_Clr();           //写使能
    2 T$ y6 e. e: H% _; R/ v9 l3 D  h
14. LCD_WR_Set();           //WR产生上升沿，数据锁存  
    
15. LCD_CS_Set();           //取消片选  
    6 f! Y9 S' L7 u) P
16. LCD_DC_Set();           //复位DC信号线   
    5 |, w; k: a% p( r. u1 {
17. }

复制代码

注：STM32通过8080接口与SSD1963 芯片进行通讯，实现对液晶屏的控制。通讯的内容主要包括命令和显存数据，显存数据即各个像素点的RGB565内容；命令是指对SSD1963的控制指令，MCU 可通过8080接口发送命令编码控制 SSD1963的工作方式，例如复位指令、设置光标指令、睡眠。

FSMC模拟8080时序

, s& ~7 I* [- I  t$ ]

重要的时序参数如下：时间相对长一点，也不能过大，否则屏幕刷新时间就会变成长，视觉上表现卡顿。

对于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。

; o" N/ s- K. B7 k( I1 C* r$ |

' T* P- y6 m+ o

可以看到显示器在传输过程中并没有高低字节控制的选项（在读写SRAM的过程中，使用掩码信号LB#与UB#指示要访问目标地址的高、低字节部分），也就是说液晶控制器（显存）与MCU之间一次就要传输16位数据。

在实际控制时，以上地址计算方式还不完整，根据《STM32 参考手册》对 FSMC 访问NOR FLASH （LCD读写数据的方式与NOR FLASN几乎是一样的，都是16位，但是FSMC 访问NOR FLASH具有高低字节控制选项）的说明STM32 内部访问地址时使用的是内部 HADDR 总线， HADDR[25:0] 包含外部存储器地址。由于 HADDR 为字节地址（一次传输8位），而存储器按字寻址，所以根据存储器数据宽度不同，实际向存储器发送的地址也将有所不同，如下表所示。

6 a9 f0 P  P3 V8 D

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

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

5 ?, G( ?& W- A

0x6C000000    低电平表示命令         

0x6C000002    高电平表示数据

: N& ?% k) p% p  H4 a

0 \( H' Z- s3 F" y3 ?

LCD 测试

步骤：

1.配置RCC

( x/ h2 l1 z0 k

2.配置FSMC

2 ]0 M5 K  I" T' V, {

根据上图进行时序大小的设定，图中单位是ns，（读者需根据不同发开发设备进行调试，没有固定值）

  S" n7 @" @$ u

3.编程

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

复制代码

/ O4 g% c6 v- x

转载自： 骆驼听海

如有侵权请联系删除

不错不错，对lcd显示的很感兴趣

非常基础但是非常重要的知识，感谢分享，

介绍非常的详细，适合入门学习

确实不错很详细