【经验分享】STM32H7的LTDC应用之LCD电阻触摸和电容触摸

[复制链接]

STMCU小助手发布时间：2021-12-31 17:00

文章
文章封面:
文章简介:	LTDC驱动设计和相关问题在第51章有详细说明。

54.1 初学者重要提示
  LTDC驱动设计和相关问题在第51章有详细说明。
  电阻触摸支持2点和4点校准，而电容屏无需校准。
  电阻触摸校准解决的是触摸板的线性度问题，而飞点要另外处理，当前程序已经做了支持。总的来说，V7配套的电阻触摸方案已经比较成熟，可以放心用于项目。
54.2 电阻触摸和电容触摸相关知识
这部分知识点在第52章的2.2小节有详细说明，必看。

54.3 电阻屏硬件设计
电阻触摸STMPE811的原理图如下：

aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2NvbW1vbi8xMzc5MTA3LzIwMjAwMi8xMzc5MTA3LTIw.png

通过STMPE811的原理图要了解以下几点：

  I2C的两根通信线I2C_SCL和I2C_SDA的上拉电阻在V7的主板上。
  原理图右侧的GPIO-0到GPIO-7可以作为扩展IO使用，支持输入和输出。其中GPIO-4到GPIO-7用于电阻触摸校准（使用那个IO是可以配置的）。
  对于X-，X+，Y-和Y+，只要不是X和Y进行组合，其它组合方式可以随意接，配套的触摸校准算法都可以正常识别。

54.4 电容屏硬件设计
电容触摸主要有三种：FT5X06，GT911和GT811，其中GT811已经停产。下面是FT5X06和GT911触摸板效果（触摸板和触摸芯片是一体的）：

触摸芯片已经集成到柔性PCB上，且已经校准好。用户使用的话，直接通过I2C方式读取数据即可。下面是电容触摸板引出的引脚：

注意I2C_SDK和I2C_SCL的上拉电阻在V7主板上。

; A7 K- i0 {0 v0 ~. x* Q$ ?+ U54.5 电阻触摸驱动设计
下面将电阻触摸程序设计中的相关问题逐一为大家做个说明。

54.5.1 STMPE811的驱动实现
电阻触摸要比电容触摸麻烦很多，因为电阻触摸要做校准，还要做滤波，否则采集回来的触摸值会抖动或者出现飞点，出现这种情况的主要原因是电阻触摸板的线性度不够好。开发板电阻屏使用的触摸芯片是STMPE811，这个芯片其实就是12位分辨率的ADC，用来采集电阻触摸板的X轴ADC值和Y轴ADC值，然后按照一定的线性关系将ADC值转换为实际的坐标值。其中这个线性关系是通过触摸校准建立起来的，每次采集的X轴和Y轴ADC就可以代入这个线性关系，从而获得实际的坐标值。

总的来说，STMPE811的驱动不难实现，可以结合STMPE811的数据手册：http://bbs.armfly.com/read.php?tid=23306 研究开发板提供的驱动配置。配置好后仅需要提供读取的X轴，Y轴的ADC值以及触摸按下状态（判断STMPE811的中断输出引脚就可以了，如果有触摸，这个引脚输出低电平，反之，输出高电平。通过判断这个引脚就可以选择是否读取X轴，Y轴的ADC值，避免不必要的操作）。这些函数在bsp_ts_stmpe811.c文件实现。而触摸值滤波，触摸扫描和触摸校准是在bsp_touch.c文件里面实现。

下面是清除触摸中断标志函数和X轴，Y轴的ADC值读取函数，这些函数被bsp_touch.c文件所调用，而函数TOUCH_PenInt是在bsp_touch.c文件，这里也贴出来。

1. /*. G% R( z$ y' u& n
2. ****************************************************************************************************** g. K% `- `! A% H4 p [3 ?3 D
3. * 函数名: TOUCH_PenInt
/ w+ D+ W5 R" i8 z* C3 V1 Y. H
4. * 功能说明: 判断触摸按下
5 F- l' T4 E2 @& c5 g2 b
5. * 形参: 无; c+ z+ {5 `( q A8 p
6. * 返回值: 0表示无触笔按下，1表示有触笔按下
, ]- G5 {* G& N5 m, `
7. ******************************************************************************************************
: ^6 k, ?$ T2 K6 b9 h
8. */
+ c1 @. V$ {; K. v" g( L+ U' Y
9. uint8_t TOUCH_PenInt(void)
" y2 G6 y5 I; N
10. {3 l+ |% }1 U5 O9 h0 U& l9 R Z2 E8 i8 I# V
11. if ((TP_INT_GPIO_PORT->IDR & TP_INT_PIN) == 0)
8 H5 p$ s- D0 s. q' p( R5 e( U
12. {
+ p8 m% l7 u- Z$ B; D
13. return 1;
3 z$ V! a i C
14. }
2 V& W) X( l& s5 q/ x% T2 |
15. return 0;5 g; h: k9 h& q( u. r. U
16. }
# H/ z7 K+ W7 q3 b" {+ f
17.
3 G. F, Q+ S0 O& O' Q
18. /*
W+ Q+ ~2 A* S4 }& y0 t
19. ******************************************************************************************************
) A1 e! d7 E3 f% g4 O4 A5 F1 w
20. * 函数名: STMPE811_ClearInt) f* w4 a' Y0 O# V
21. * 功能说明: 清楚触笔中断
% b$ B" c) c9 r8 k
22. * 形参: 无
9 `8 Q. B1 p9 v" P
23. * 返回值: 无: e' M8 u8 O7 E; M3 e2 D
24. ******************************************************************************************************2 H8 o: C3 H5 m
25. */; t/ w+ @) p. l. Y$ E
26. void STMPE811_ClearInt(void)
/ X5 j, p4 g* w2 G
27. {
* o3 [, m2 p$ b. d; L: D
28. STMPE811_WriteReg1(REG811_INT_STA, 0xFF);
6 q5 \, F L" @+ Y4 L
29. }4 f8 ?4 D+ t; _! @( r
30.
+ }, j6 G. o" H2 V
31. /*
" J7 X9 \) i D4 F! t( P) m' z% i
32. ******************************************************************************************************$ V0 W2 b: v3 O9 a1 I. y
33. * 函数名: STMPE811_ReadX
2 g8 [; d2 a# G: _/ i# V: q
34. * 功能说明: 读取X坐标adc! e! c3 Q; E! _/ ?* \4 Y
35. * 形参: 无$ M- k/ {' Q" O4 ^5 b4 m
36. * 返回值: X坐标值adc& H* g' O: t- y9 q$ r, e* m6 e# l
37. ******************************************************************************************************6 D% ?+ V P# y; {
38. */, R- {/ W2 q6 N" R
39. uint16_t STMPE811_ReadX(void)! U$ {. @3 d( S" }
40. {' W: r9 S) N \% q
41. /* 按照 XY 读取模式，连续读取3字节数据，然后分解出X,Y
0 l8 D. a0 W% ~* T6 C9 u/ ?
42. | byte0 | byte1 | byte2 | 2 [: Y- f% o4 {8 A
43. | X[11:4], | X[3:0],Y[11:8] | Y[7:0] |
' f6 [, }% m6 {1 \& R
44. */# x H) L% M8 v6 m' L
45. uint8_t buf[3];
( C0 V# F9 k9 E- b
46. ( Q N9 V% B: Z; p2 F
47. #if 0
; ?- e0 @: b" V7 a% \
48. STMPE811_ReadBytes(buf, REG811_TSC_DATA1, 3);
0 j g( I H# u r" A1 N$ c
49. 7 f6 o3 k% _$ l2 n3 {2 v: W' w5 F
50. s_AdcX = ((uint16_t)buf[0] << 4) | (buf[1] >> 4);
# W* J8 b# K4 ]/ l+ Q
51. s_AdcY = ((uint16_t)(buf[1] & 0xF) << 8) | buf[2]; ) ]( f) C: A: H
52. #else
0 b. a1 W9 y- W5 G3 G
53. if (STMPE811_ReadReg1(REG811_TSC_CTRL) & 0x80). Z- }8 r5 F7 r3 v( }
54. {
7 _; p9 w3 G X$ T" C4 c: a
55. STMPE811_ReadBytes(buf, REG811_TSC_DATA1, 3);
0 P1 O% t g# k+ I. u
56. k1 O _* {, E6 Y/ I
57. s_AdcX = ((uint16_t)buf[0] << 4) | (buf[1] >> 4);
) {9 |* C+ M! G7 b; r7 A7 P
58. s_AdcY = ((uint16_t)(buf[1] & 0xF) << 8) | buf[2];4 b0 ~$ V2 b* @5 O" B$ F- j a- o
59.
" y5 B# W5 B0 j' e r- t0 P
60. #if 0
- a, @7 P# e$ ^5 M2 O" ^3 S% C5 h
61. /* for debug */1 |2 r2 P& r2 S$ i7 @: j# K
62. {# B- ^3 F0 |- p" |( R# W
63. static int32_t s_t1 = 0;
`" h" ]" r; O2 M- K; c- J
64. int32_t tt;
6 B; c7 N$ Z; Z- ?- O: f
65. h# o* |5 Q8 e& h$ ^3 O
66. tt = bsp_GetRunTime();; U/ d) O) X0 X1 \6 f0 P4 X; s" t) h
67. if (tt - s_t1 > 1000)
1 P& n" c: S( C" j! i: `* O* G5 o
68. {
9 C* f. c6 {* `# ]* U
69. printf("\r\n");1 p' z# W6 ~# |$ F. s! R! B% x
70. s_t1 = tt;0 S+ l9 c; s6 B4 G4 G3 C( y: }2 X
71. }4 w) h* ~) }, n- j9 S) }0 u% O
72. printf("(%7d) %5d %5d\r\n", tt, s_AdcX, s_AdcY);/ Q8 }$ }1 x* s' P2 r
73. }
5 |( D+ |5 t1 s; S+ e6 A. h
74. #endif
* q1 Q- p" K" v8 D6 Z+ I( b& Q3 t" |
75. }. k5 W* o: R: \* j4 l: @% m, _
76. else6 t+ g- P" Y0 ^
77. {
& Q9 i( s& J0 q: R* q
78. s_AdcX = 0;& v) J/ N5 q9 P! I$ r' M p
79. s_AdcY = 0;5 I1 X8 R8 t* T- A5 V1 d: Y
80. }9 z3 b+ t& z9 B
81. #endif
9 _+ y( _ ^/ u* I9 b) }* s
82.
3 o6 l+ x9 p2 O% r) ~2 s1 z
83. return s_AdcX;# b0 N$ `7 p r& k/ v
84. }; K' L0 H. X( X" W& Q9 S. x
85.
8 E. V( U3 B: F" |: f9 g+ [
86. /*
% D9 ?8 q; x) P2 x# W! _
87. ******************************************************************************************************
6 r# G4 k# U7 n
88. * 函数名: STMPE811_ReadX
$ b) r6 Q2 b, A7 G4 ~3 v8 Y
89. * 功能说明: 读取Y坐标adc
. F6 v% i" P' s- p- A" a
90. * 形参: 无6 P5 x2 R$ P4 Y/ B6 k) a
91. * 返回值: Y坐标值adc$ m0 c4 J+ f6 x8 a) W/ L
92. ******************************************************************************************************# f1 A, |6 t0 A; q
93. */5 @3 \$ G2 r3 h1 w
94. uint16_t STMPE811_ReadY(void)6 f, _* z0 k# g
95. {
* x! [7 k2 r2 v1 C- I
96. return s_AdcY;
' l7 t5 N a" e3 K$ v3 ]
97. }

复制代码

下面将程序设计中的关键地方做个阐释：

  第9-16行，通过判断STMPE811的中断输出引脚的高低电平来判断触摸板是否被按下，如果有触摸，这个引脚输出低电平，反之，输出高电平。通过判断这个引脚就可以选择是否读取X轴，Y轴的ADC值，避免不必要的操作。
  第26-29行，清除触摸中断标志，检测到触摸屏未被按下时，要做清除。
  第39-84行，读取X轴ADC数值。
  第94-97行，读取Y轴ADC数值。

54.5.2       电阻触摸扫描函数TOUCH_Scan
接下来再来看bsp_touch.c文件中STMPE811触摸扫描函数TOUCH_Scan的实现：

1. /*
6 q& d' Q: i3 w f$ s4 R4 V4 P" c! [
2. ******************************************************************************************************
+ H" X. t; Y$ R- D8 S
3. * 函数名: TOUCH_Scan3 @, O" Z% J f& g! D6 |
4. * 功能说明: 触摸板事件检测程序。该函数被周期性调用，每ms调用1次. 见 bsp_Timer.c+ q: h: E& i5 f, M+ S) c
5. * 形参: 无' f7 k* l+ P% ~) _0 c
6. * 返回值: 无9 O7 e3 M2 e% |( e4 N
7. ******************************************************************************************************
3 Q1 P! u* i) @$ x' O( J
8. */
. N+ V4 T W2 Z% j6 O7 {
9. void TOUCH_Scan(void)7 o5 a% B5 H: M7 Q; j
10. {
/ C; ^+ Z7 N* M' Q
11. uint16_t usAdcX;
5 F$ F$ `3 h& a* ~; v8 u$ \- _
12. uint16_t usAdcY;
0 X6 O% m( V3 s
13. static uint16_t s_usXBuf[SAMPLE_COUNT];
! R+ x4 K+ F P* s6 A* h; K$ \
14. static uint16_t s_usYBuf[SAMPLE_COUNT];
+ X) D/ n6 ] y# C/ a$ J' m
15. static uint8_t s_ucPos = 0;
6 C, g( f7 |0 Y+ {+ [& y8 |
16. static uint8_t s_count = 0; |5 k/ E# V; D6 Z6 I
17. static uint8_t s_down = 0;
+ I$ p2 r A8 L9 X! v
18. static uint16_t s_usSaveAdcX, s_usSaveAdcY; /* 用于触笔抬起事件，保存按下和移动的最后采样值 */8 m# l& L% s" ?4 j, Z
19. static uint8_t s_ms = 0;0 o2 T) c' ^1 ~
20.
# W, q, Z% L5 {2 r' ?' p! K6 j, O
21. if (g_GT811.Enable == 1), h) o" _ Y5 G0 `
22. {
: W5 s$ m6 T7 r* e' P
23. GT811_Timer1ms(); /* 电容触摸屏程序计数器 */! X% G: x1 m/ U
24. return;
6 k2 r+ M2 h1 V \* S# s9 y
25. }
# S: ~7 t$ _/ s) A3 j/ c
26.
; Q1 F2 {2 b9 Q$ _8 u% m
27. if (g_GT911.Enable == 1)
* a' x5 D# z/ G: t! H1 u' Z
28. {9 p5 |! \3 K. O$ {( q
29. GT911_Timer1ms(); /* 电容触摸屏程序计数器 */
) B, U Y$ H* L) a" c
30. return;
1 v# Q. @" ]: o1 X9 [
31. } 1 o4 ?( }; }" o/ B5 Z# N7 f( S
32.
' E( G7 X- b+ ?
33. if (g_tFT5X06.Enable == 1)
0 X8 s% `& T: v8 @( y9 H: k
34. {
5 t9 d( g) t6 C. g% J' \
35. FT5X06_Timer1ms(); /* 电容触摸屏程序计数器 */. {1 n/ r. g% e
36. return;/ k; ~4 h7 P9 _6 b$ |9 ?
37. }
/ I! |: l& F: w
38. . G0 Z8 ~4 Y G, S6 I
39. /* 下面用于电阻触摸 */
- e b+ T9 R& d0 I% A- c a
40.
9 l) q7 R. l( w/ o- h
41. if (g_tTP.Enable == 0) 7 k8 {2 k4 A5 g3 K5 F
42. {
& d+ J5 P$ A' X4 \# D8 c8 f
43. return;
5 @ N% ?. v0 E) Q V
44. }6 _* n' m' v: W# {6 x9 q
45. % Z7 c" F) I0 I
46. if (++s_ms >= 2)2 J- P1 ?* q6 `, j
47. {
0 G4 Y& O% h6 ]/ X6 R; F, ~. ?
48. return;- J# f- N( x2 c' Q
49. }
( v: v1 o# @4 l6 B0 n8 v
50.
% {+ i8 Y' `+ o1 U
51. /* 2ms进入一次 */
( N5 X* `/ T7 f- y. g
52. s_ms = 0;
1 R5 y) D/ J$ X5 l7 v1 s. y
53.
0 {3 e6 I/ f- ` T q% K: d+ n- b
54. /* 触笔中断发生 */2 |$ c* w- p3 M2 \/ S
55. if (TOUCH_PenInt())
# e$ j- _& F5 ~& u2 X
56. {( ^6 N8 n/ R4 L4 B7 z9 Y- ]: P
57. /* 获得原始的ADC值，未滤波 */4 v7 Q* L4 g$ [7 C1 C
58. usAdcX = STMPE811_ReadX();, f% @5 ?$ f3 u) F
59. usAdcY = STMPE811_ReadY();3 V( h% _, {9 X8 l
60. / o; f5 p: \8 u2 P" F
61. if (TOUCH_PressValid(usAdcX, usAdcY))2 _$ |6 O; ?# E& i& u+ _# Q0 R
62. {, z- l. u4 {" z! j% Z3 q
63. /* 按压30ms之后才开始采集数据 */1 N& x% ?+ e& p) q
64. if (s_count >= DOWN_VALID / 2)
' d( T/ }0 {, n# s
65. {: P0 G! O# `2 i0 r8 Z
66. s_usXBuf[s_ucPos] = usAdcX;2 d. K) [* m) A3 T% O. \( b% |& ~2 j
67. s_usYBuf[s_ucPos] = usAdcY;
' Y6 Z7 j8 k6 L% I( M
68. + @& @ x0 ?4 C. d6 o0 f% X6 C; ~
69. /* 采集20ms数据进行滤波 */
4 E' R3 A4 j; r/ O+ t
70. if (++s_ucPos >= SAMPLE_COUNT / 2)% N. D( c3 @* ^9 y' v! f
71. {
1 p' X) @+ F8 }* t0 G
72. s_ucPos = 0;6 G) e( k8 y' H# R. w& X/ y
73. " `- W9 E3 g8 |: N
74. /* 对ADC采样值进行软件滤波 */
( }3 {8 ~9 l* f8 u
75. g_tTP.usAdcNowX = TOUCH_DataFilter(s_usXBuf, SAMPLE_COUNT / 2);
2 g1 G- s3 A) |# E" Y
76. g_tTP.usAdcNowY = TOUCH_DataFilter(s_usYBuf, SAMPLE_COUNT / 2);
; s& A5 q' V, G @' r: F
77. * T5 q: H$ c1 P, r6 w( h
78. if (s_down == 0)7 y/ C, c/ c- t' s5 H
79. {- O3 X$ H9 J1 M+ a7 S) K' q
80. s_down = 1;0 E& U) ] g( C1 Z
81. /* 触摸按下事件 */
, }+ N0 G: o5 Y9 t1 Q
82. TOUCH_PutKey(TOUCH_DOWN, g_tTP.usAdcNowX, g_tTP.usAdcNowY);
: s, z' C: H4 F% b- H$ ~8 z" N
83. : |9 _) g" O3 ^* V3 ^( y% G0 V
84. s_usSaveAdcX = g_tTP.usAdcNowX;
1 d7 H" E, q- O6 A' _* M
85. s_usSaveAdcY = g_tTP.usAdcNowY;
# i0 ~: T0 w* m m! v6 m3 K, h
86. }
( N! z# w2 A1 `7 y6 V
87. else$ i- ~- R$ {3 b: t% O3 L
88. {6 w+ f, X3 c' F8 ?% D
89. if (TOUCH_MoveValid(s_usSaveAdcX, s_usSaveAdcY, g_tTP.usAdcNowX, g_tTP.usAdcNowY))
" N" P" z8 I# l: a6 x
90. {
: [, W0 O5 P& \1 C: C
91. /* 触摸移动事件 */
2 z; o, G3 n( i1 L
92. TOUCH_PutKey(TOUCH_MOVE, g_tTP.usAdcNowX, g_tTP.usAdcNowY);* Y& }' X5 c6 X/ P$ q7 y
93.
* m* C2 I* p5 [2 d+ r1 \
94. s_usSaveAdcX = g_tTP.usAdcNowX;5 Y5 h* T; m: D/ K* v
95. s_usSaveAdcY = g_tTP.usAdcNowY;
N2 k) _+ p% i+ x6 B
96. }
' O- P- ]! D9 z0 u; v3 Q
97. else! d9 L3 t, ^0 A4 w- |! p$ [9 \" [% {
98. {
( K, k% u; C+ m, P+ O) O4 P
99. g_tTP.usAdcNowX = 0; /* for debug stop */- w. ?% [( M9 ] _7 F( P3 W
100. }
3 r% E) N L, o/ U& K
101. }
; Y* C1 |$ t# g* w R! s8 R# C
102. }8 n" a% o4 x& H+ |% k6 ]
103. }
7 N3 Q u2 v* I& j5 D
104. else
1 L% }" V/ M0 u6 V% W8 |
105. {( c' v: Y% u' B( g4 p
106. s_count++;9 [4 h6 a! B- M( B. x8 Z* s
107. }
8 h1 o. T4 v# [- }! O6 e
108. }5 H- S% k, z2 Z6 T j c
109. else
% o% Y. ?- v0 {9 x- x2 g5 b
110. {
+ u; @- g5 l; N( D: @9 v" |+ \; A
111. if (s_count > 0)/ d! `, P. |4 L% r" f8 T" _
112. {& v/ e X6 C7 o$ |. j( v+ @
113. if (--s_count == 0)
) [. \& ~# W7 t3 d& r
114. {0 Z/ n# S9 Y3 s9 L5 {1 Y
115. /* 触摸释放事件 */8 c2 K0 K- h, N/ |' p; L
116. //TOUCH_PutKey(TOUCH_RELEASE, g_tTP.usAdcNowX, g_tTP.usAdcNowY);- m! Z5 ^: x' e! P
117. TOUCH_PutKey(TOUCH_RELEASE, s_usSaveAdcX, s_usSaveAdcY);
7 `) S* B( u! E9 j4 l6 y' x9 O
118.
0 U" F8 C0 X( b0 n/ i& d
119. g_tTP.usAdcNowX = 0;$ T. `/ \: }9 w4 G j
120. g_tTP.usAdcNowY = 0;& e: m$ N6 s6 K" C) M; e& g* C
121. , L1 B- [ {$ m
122. s_count = 0;
- M! M; U8 i, e# E7 u
123. s_down = 0;
+ C1 R2 L( k. d
124.
8 w- q1 S( ?1 o
125. STMPE811_ClearInt(); /* 清触笔中断标志 */
! z, X' H/ Q1 a- q1 f
126. }! A' \) D. e8 h8 s
127. }
i5 P3 J$ ] p
128. s_ucPos = 0;
7 k: ~1 r8 _/ b& J& ~+ }9 d: m- ?
129. }, P6 K! d$ O; U: c- Y
130. }% `& \. U. K. b* h$ a
131. }, L9 j6 R9 K; ~ @
& T v2 m4 L) S

复制代码

下面将程序设计中的关键地方做个阐释：

  第9行，此函数要每1ms被调用一次。
  第21-37行，用于GT811，GT911和FT5X06的程序计数器。
  第46-52行，设置每2ms进行一次STMPE811检测。
  第55行，这个就是本章前面小节说的利用STMPE811的中断输出引脚的高低电平来判断触摸板是否被按下。
  第58-59行，读取X轴ADC数值和Y轴ADC数值。
  第61行，通过函数TOUCH_PressValid检测刚刚读取的X轴，Y轴数值是否在有效的范围内。
函数TOUCH_PressValid的具体实现如下，其中全局变量g_tTP.usMaxAdc = 4095，因为电阻触摸芯片STMPE811是12位ADC，最大触摸值就是2^12 – 1 = 4095。

/* 有效ADC值的判断门限. 太接近ADC临界值的坐标认为无效 */; S5 t& C+ \! l1 F- o
#define ADC_VALID_OFFSET 20 T) y0 i0 u( i; _* m, ?
* q3 E" [" f$ T4 T# c7 K. z
/*
& ^" v' z- \3 W- ]
*********************************************************************************************************
* 函数名: TOUCH_PressValid- D, Z {6 p, t1 x7 S& G
* 功能说明: 判断按压是否有效，根据X, Y的ADC值进行大致判断
5 g9 o$ G& l ~, l+ z4 L8 J
* 形参: 无 H6 l' G$ l$ q
* 返回值: 1 表示有效； 0 表示无效
6 O5 u8 W: o( D, b
*********************************************************************************************************
0 v* L5 a( t; E" ~4 I
*/
( q" f* X K* H% N
static uint8_t TOUCH_PressValid(uint16_t _usX, uint16_t _usY)- j! |3 z8 L5 i2 v$ |# Z% x; M
{; A. N& b. p k- r+ Y/ Y+ C
if ((_usX <= ADC_VALID_OFFSET) || (_usY <= ADC_VALID_OFFSET)
# [/ k/ Z) m/ U* X- d
|| (_usX >= g_tTP.usMaxAdc - ADC_VALID_OFFSET)
6 w" E! \& k5 y: Y$ }& g
|| (_usY >= g_tTP.usMaxAdc - ADC_VALID_OFFSET))6 g, { Q$ S* E' d- V, N4 }
{8 d) D. A& t7 d& g% w; M8 i) G0 c
return 0;4 ]) ]! ]* T) W: a: C
}
- F, i, l9 }) U) @
else9 L" n9 y2 P2 ?, @9 }6 J/ m( K/ _
{2 m; x( O' J1 |( g- k0 V7 r* u# D
return 1;) n# y% L3 I# M% _- L2 `( X
}* F$ K. L9 k2 d" h* ^& [0 r
}

复制代码

  第64行，DOWN_VALID的宏定义是
#define DOWN_VALID          30

由于是每2ms进行一次检测，这里就表示延迟30ms后进行触摸数据采集。延迟30ms是为了消除触摸抖动。

  第70行，SAMPLE_COUNT 的宏定义是
#define SAMPLE_COUNT 20

由于是每2ms进行一次检测，这里就表示采集够10组数据，即20ms后进行下一步操作。

  第75-76行，对X轴和Y轴的ADC数值都进行软件滤波。软件滤波函数TOUCH_DataFilter的实现方法是对10组数值由小到大进行排序，对第3个，第4个和第5个数值求和，然后求平均，将平均值作为最终的ADC数值。
  第78-86行，变量标识s_down = 0表示触摸之前是未按下状态，在此条件里面设置s_down = 1表示触摸已经按下，并通过函数TOUCH_TransX（这个函数比较关键，是通过触摸校准函数得到的一个线性关系）将当前的X轴和Y轴ADC数值转换成实际的坐标值，然后调用函数TOUCH_PutKey将当前的坐标信息存储到FIFO里面。
  第89-100行设置变量标识s_down = 1后会进入此条件里面，在这个条件里面通过函数TOUCH_MoveValid判断当前是否是有效的移动，如果是，就继续调用函数TOUCH_PutKey将当前的坐标信息存储到FIFO里面，如果不是，就设置全局变量g_tTP.usAdcNowX = 0。
  第111-128行，如果通过STMPE811的中断输出引脚检测到触摸未按下，然后判断变量s_count是否大于0，如果大于0的话，做减减运算，算是做了一个松手延迟，防止抖动。减到0的时候，将触摸未按下或者说触摸释放消息通过函数TOUCH_PutKey存储到FIFO里面。

# t4 S; P/ Z/ n& P, X& ]. p- I54.5.3       电阻屏触摸校准原理（2点）
由于不同电阻触摸板的线性度参差不齐，不能直接采用比例关系将电阻触摸芯片STMPE811的返回

值转换成实际的坐标。比如我们操作的显示屏分辨率是800*480，电阻触摸芯片采用STMPE811（12位ADC，触摸值范围0-4095），获得当前的触摸值是（1024, 2048），按照比例关系转换成坐标值就是(1024*800/4096，2048*800/4096)，即（200，400）。采用这种方法效果不好，容易出现点击不准确的问题。

鉴于此原因，需要通过触摸校准在ADC数值和显示屏分辨率之间建立一个新的线性关系，简单的说就是由比例关系y = ax升级为y = ax + b。如果有了新的触摸ADC数值，代入这个线性关系里面就可以得到当前实际的坐标值，触摸校准的作用就在这里了。

具体实现原理图如下：

在左上角和右下角分别设置两个坐标点（LcdX0,  LcdY0）和（LcdX1,  LcdY1），然后让用户去点击，会得到两组ADC数值（AdcX0，AdcY0）和（AdcX1,  AdcY1）。

根据这四个坐标点，可以建立两组方程，一个X轴的，一个Y轴。

  将数值（AdcX0， LcdX0）和（AdcX1,  LcdX1）代入方程y = ax + b得到X轴方程：
y = （x - AdcX0）*（LcdX1 - LcdX0）/(AdcX1 - AdcX0) + LcdX0

  将数值（AdcY0， LcdY0）和（AdcY1,  LcdY1）代入方程y = ax + b得到Y轴方程
y = （x - AdcY0）*（LcdY1 - LcdY0）/(AdcY1 - AdcX0) + LcdY0

后面采集到的ADC数值直接代入上面公式就可以得到校准后的物理坐标值（实际的分辨率坐标）。
. `, [0 S0 P( b) Y2 R. Q8 t9 W) s
54.5.4       电阻屏触摸校准原理（4点）
4点触摸校准实现，略复杂，实现原理如下（如果理解起来麻烦的话，会用就行，一般情况下2点校准就行）：

在LCD的左上角，右上角，左下角和右下角分别标坐标点（LcdX1,  LcdY1），（LcdX4, LcdY4），（LcdX3,  LcdY3）和（LcdX2, LcdY2）。然后让用户去点击，会得到四组ADC数值（AdcX1, AdcY1），（AdcX4,  AdcY4），（AdcX3, AdcY3）和（AdcX2, AdcY2）。

计算X轴：

将数值（AdcX1，AdcY1）和（AdcX2, AdcY2）代入方程y = ax + b得到一组方程
y = （x - AdcX1）*（AdcY2- AdcY1）/(AdcX2- AdcX1) + AdcY1

这里将AdcX2用AdcX3替换，那么坐标方程就变为
y = （x - AdcX1）*（AdcY2- AdcY1）/(AdcX3- AdcX1) + AdcY1。

同理，将AdcX1用AdcX4替换，那么坐标方程就变为
y = （x - AdcX4）*（AdcY2- AdcY1）/(AdcX3- AdcX4) + AdcY1

那么将采集的X值代入上面两个方程会得到两个数值，假设数值是x1和x2。

再将(x1,  LcdX1)）和（x2,  LcdX2）代入方程y = ax + b得到一组方程
y = （x - x1）*（LcdX2- LcdX1）/(x2- x1) + LcdX1

将采集的X轴ADC数值再次代入这个方程就得到了最终的物理坐标（实际的分辨率坐标）。

计算Y轴：

将数值（AdcX1， AdcY1）和（AdcX2,  AdcY2）代入方程y = ax + b得到一组方程
y = （x - AdcX1）*（AdcY2- AdcY1）/(AdcX2- AdcX1) + AdcY1

这里将AdcY2用AdcY4替换，那么坐标方程就变为
y = （x - AdcX1）*（AdcY4- AdcY1）/(AdcX2- AdcX1) + AdcY1

同理，将AdcX1用AdcX3替换，那么坐标方程就变为
y = （x - AdcX3）*（AdcY2- AdcY1）/(AdcX2- AdcX3) + AdcY1

那么将采集的X值代入上面两个方程会得到两个数值，假设数值是x1和x2。

再将(x1, LcdY1)）和（x2,  LcdY2）代入方程y = ax + b得到一组方程
y = （x - x1）*（LcdY2- LcdY1）/(x2- x1) + LcdY1

将采集的Y轴ADC数值再次代入这个方程就得到了最终的物理坐标（实际的分辨率坐标）。
3 W/ w* ]% Y+ ]1 [: ]6 A! j
54.5.5       电阻屏触摸校准的实现
对2点和4点触摸校准原理有所了解后，再看代码部分就比较好理解了：

1. /*
: [3 A# S4 c4 Y5 t, D
2. ******************************************************************************************************1 P, P; W* G8 X- |2 G8 Z( P
3. * 函数名: TOUCH_Calibration
/ B; ^2 t8 o. Y3 q
4. * 功能说明: 触摸屏校准
! n5 H5 \7 b+ [
5. * 形参: _PointCount : 校准点数，2 或 4.
: [1 c G: m/ v- w9 C, x% D
6. * 返回值: 无
0 b S! p; ^" g/ \
7. ******************************************************************************************************
4 p7 c* x8 v$ P5 G
8. */
U) j4 J! H: w" M' G( \/ c
9. void TOUCH_Calibration(uint8_t _PointCount)
G6 N Z, ?4 E; I2 l
10. {' n/ g3 q1 a) d% ]" {: F4 q
11. uint16_t usAdcX;
! y7 I6 N' ]: P- I: W& l
12. uint16_t usAdcY;
& _0 R/ I0 o P# I) X2 G4 @9 e
13. uint8_t usCount;- S2 Z2 M$ L7 w$ p* h; y5 e6 [
14. uint8_t I;
6 q* y* V3 \! A' n6 w
15. uint32_t n;9 X$ L6 p" O1 n6 k( R
16. & {, V2 ]4 j) X" C" V" t
17. /* 校准点数，2点或4点 */
, L; y3 o/ l# E& N
18. if (_PointCount == 4)
; J! f# i& N% g1 [
19. {
' k2 I. \; q( y
20. g_tTPParam.CalibPointCount = 4;: E0 ^ `& c5 K) b/ {
21. }
$ t/ n) j8 S/ |& [) g8 ~3 m$ ?; g
22. else
+ u. C0 V! ?( H3 o
23. {9 H; F7 n/ w G" ^( h" P e
24. g_tTPParam.CalibPointCount = 2;+ X7 a7 Y3 x2 S5 \9 [- q9 o0 c5 [
25. } ; `2 H: G! d7 g2 ` B7 Q
26.
& ?- n1 v4 P+ o. G8 d3 g
27. TOUCH_CelarFIFO(); /* 清除无效的触摸事件 */
* L5 J! Z7 z7 y
28. ! y/ b7 \0 j1 S# c; l' ]
29. for (I = 0; I < g_tTPParam.CalibPointCount; i++)- X1 h+ R4 M% f
30. {+ z8 N5 `$ l: j+ J
31. TOUCH_DispPoint(i); /* 显示校准点 */( \& j( Q N' h) r' }
32.
: R7 x- t+ ^8 K1 a K
33. TOUCH_WaitRelease(); /* 等待触笔释放 */% W! e4 {$ A" P
34. ( \( m7 W4 {3 c
35. usCount = 0;5 C3 X" `7 j. M9 o0 C& v- l) u1 L
36. for (n = 0; n < 500; n++); P3 e/ X1 a8 O3 h4 y* {
37. {
7 `0 m/ A1 r% C6 T, _: d; [
38. usAdcX = TOUCH_ReadAdcX();
. V) P; T1 z, X1 \
39. usAdcY = TOUCH_ReadAdcY();; R8 t3 @+ B! y1 P z
40. ^$ U3 X: I+ C- G" `) p' N1 T
41. if (TOUCH_PressValid(usAdcX, usAdcY))* @; w6 k4 b1 g$ G# _& r; `
42. {
/ m0 E$ U' n, W) `8 J# c
43. if (++usCount > 5)
, O" z0 B/ L: ?+ Y, O8 |
44. {
) g! e: n w; e: b4 i
45. /* 按压有效, 保存校准点ADC采样值 */
' K! r; V% D% S3 G5 p6 J* f
46. if (I == 0)
' f; P' H8 V! @, C% B3 S5 A. m7 z3 R/ S
47. {, k: E5 D6 B* {; K A
48. g_tTPParam.usAdcX1 = usAdcX;
6 l8 f9 O3 ]5 D. i0 S+ U" p/ t* _
49. g_tTPParam.usAdcY1 = usAdcY;2 @6 x# s6 Q; p' \6 c
50. }
& u! L% M( j6 s ?7 W- f
51. else if (I == 1)* f' u) t1 x" k
52. {
. o |/ E8 a- S2 ^8 W: t
53. g_tTPParam.usAdcX2 = usAdcX;# x& C5 U% B/ z; j3 o1 y7 ]
54. g_tTPParam.usAdcY2 = usAdcY;
+ Y0 C( S* r) i5 \
55. }
8 c! G" t7 w, S8 v7 B5 p3 V
56. else if (I == 2)
4 D% Q" m8 k; F O* ?' P; h
57. {( c1 G4 P" T. m) q5 C
58. g_tTPParam.usAdcX3 = usAdcX;
" x9 I/ I* C- r! x) q) @" I) c& @
59. g_tTPParam.usAdcY3 = usAdcY;
, O# N% C* W: y- G" y0 q' ^
60. }
V. `( h1 n- a2 l9 ?8 z& \. @! e+ T
61. else5 ]2 H. H I/ g1 x& S' v
62. {
( K5 E. s" u' Z% ]7 K) p
63. g_tTPParam.usAdcX4 = usAdcX;
) E8 Y' I/ x& @( ~
64. g_tTPParam.usAdcY4 = usAdcY;
! p2 S! \5 _% C0 F
65. }: N" r4 i; Q2 D v" i+ z
66. break;
?/ W% ]: Z& V; U
67. }0 V& c4 l" y, y
68. }. E8 n9 _: V/ h0 U+ g Z# o
69. else m- |2 X7 k u1 F% \* }; @- {
70. {; c6 H$ Z f# o- g: d
71. usCount = 0;: ?2 X" ^. J) i' O- _9 Q
72. }
* g% Y% H, a, j" E) f
73. bsp_DelayMS(10);: b# p# e; D/ r `- E3 O, s
74. }
' q+ u" N, p) s7 Q8 o5 B% g+ L
75. if (n == 500), Z8 j L2 y- a5 n/ y' b, Y
76. {1 c4 P D5 C" G4 L* c/ }1 _& o8 _( s
77. return;/ s& r. L( U3 ]! d
78. }; N! Y5 X: P0 {: H. |1 z
79. }# {3 d+ |* {: P2 T
80.
# _# r7 W3 ~% s" z! Y( l
81. TOUCH_WaitRelease(); /* 等待触笔释放 */
6 b- p% V0 {/ Q d/ j
82. / v* \6 p4 E( y& U- Z' U6 i
83. /* 识别触摸的 X, Y 和显示面板的 X，Y 是否需要交换 */
, e% z; ~, B! V+ Z4 S1 a# \
84. g_tTPParam.XYChange = 0; /* 1表示X Y需要交换 */
) @1 [/ {0 q' I! b
85. if (LCD_GetHeight() < LCD_GetWidth())
+ a; _' \" W C/ F' d# N( O
86. {5 C& x. `% {3 |& ~) ~
87. if (TOUCH_Abs(g_tTPParam.usAdcX1 – g_tTPParam.usAdcX2) < P G; H# C0 i" Y
88. TOUCH_Abs(g_tTPParam.usAdcY1 – g_tTPParam.usAdcY2))% S; ]- p3 F! o5 ]
89. {
5 s/ o* @2 G" ]2 _) x
90. g_tTPParam.XYChange = 1;
1 C0 Q. R* q: @' r
91. }2 X2 F2 Y" w3 N7 `
92. }
2 Y& @& u y0 W q) Y
93. else
6 M- b G. {, ^2 }. \
94. {. Q# s0 t5 Y4 p/ u' |
95. if (TOUCH_Abs(g_tTPParam.usAdcX1 – g_tTPParam.usAdcX2) > ) E2 t+ D9 Y, g1 c1 ]% @
96. TOUCH_Abs(g_tTPParam.usAdcY1 – g_tTPParam.usAdcY2))) ?! T2 G! C& \, T" n: _
97. {6 |% Z2 K" ~9 W
98. g_tTPParam.XYChange = 1;
p9 r1 B: a+ n, i+ i! z# S
99. }
- k. t+ [) [6 i
100. }
3 e6 n( Z& q: x- |/ J) {; O
101.
A% B( R8 I4 e6 v- _
102. g_tTPParam.usLcdX1 = TP_X1;
8 m& W3 Z/ o4 g5 N* s
103. g_tTPParam.usLcdY1 = TP_Y1;" U+ @( B4 |8 t- a' i
104. g_tTPParam.usLcdX2 = TP_X2;: `. ~% a: B3 a9 p, t
105. g_tTPParam.usLcdY2 = TP_Y2;* z# F s5 z9 I# z8 t. j3 [
106. g_tTPParam.usLcdX3 = TP_X3;
: H7 ?/ g- B) ~5 E+ r* z4 v/ |
107. g_tTPParam.usLcdY3 = TP_Y3;2 e% y V. ~( y
108. g_tTPParam.usLcdX4 = TP_X4;% N0 U4 h2 S/ L
109. g_tTPParam.usLcdY4 = TP_Y4;
7 k- t7 @' P( E! T. a! J/ J- Y
110.
- N9 {7 b8 r1 s% D0 w3 W( M% D
111. /* 在最后一步，将校准参数保存入Flash 或者EEPROM */
3 c+ ? o; K* F4 \9 m, {7 s' I
112. TOUCH_SaveParam();; _/ s9 J8 y" X6 k L. t' C
113. }

复制代码

下面将程序设置中的关键地方做个阐释：

  第18-25行，用于标记是4点触摸校准还是2点触摸校准。
  第31行，显示触摸校准点，2点触摸校准的话，显示左上角和右下角的校准点位置。4点触摸校准的话，显示左上角，右上角，左下角和右下角的校准点位置。
  第33行，用于等待触摸笔释放，当校准完毕1个点后，等待释放时使用。
  第35-79行，读取500次X轴和Y轴的ADC数值，每10ms读取1次，每个触摸点的最大读取时间就是5秒。如果5秒内还没有触摸就会进入到第77行直接退出触摸校准。
第41行检测到有按下的话，会连续读取5次，确保已经按下了，然后标记本次按下得到的ADC数值。根据执行的是4点触摸校准还是2点触摸校准，这个操作会执行4次或者2次。

  第84-100行，这里涉及到一个知识点，即X轴镜像，Y轴镜像和XY交换的处理办法
  第112行，将校准后的参数存储到EEPROM里面，下次开发板上电可以直接从EEPROM里面读取校准参数。

54.5.6       电阻屏触摸ADC值转物理坐标
电阻屏触摸ADC值转物理坐标的公式就是由前面5.4和5.6小节而来。

1. /*( a7 ~6 [+ Y6 j' H+ X8 J% W4 L
2. ******************************************************************************************************
& E: Y0 O' Y8 k. Y! C- Q" q& v
3. * 函数名: CalTwoPoint1 F9 Z* D1 y2 ]* W7 U$ C% R: a: ?, P% |
4. * 功能说明: 根据2点直线方程，计算Y值- ]; A9 D; |, V
5. * 形参: 2个点的坐标和x输入量
+ z% H3 _. l1 \5 d7 ]
6. * 返回值: x对应的y值
' n& Z% w* I) u/ s
7. ******************************************************************************************************% Y, K7 C, S5 h% K; D2 t( e
8. */
$ E) _+ M1 o' h- H# J
9. static int32_t CalTwoPoint(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t x)1 O! W$ ?7 d4 @0 q2 r
10. {5 [; d% w! \( J5 U
11. return y1 + ((int32_t)(y2 - y1) * (x - x1)) / (x2 - x1);0 Y/ S+ @! A% `1 U7 ]% c
12. }
. k5 [1 W/ z5 ?( `* `4 ?4 j+ V' r
13.
+ {. Y# C/ Y( Y; `- x# K" \- O% i
14. /*
" H4 s+ z! a' `5 s
15. ******************************************************************************************************/ R2 I( C7 s; j
16. * 函数名: TOUCH_TransX
6 s+ u8 U+ N$ b% z
17. * 功能说明: 将触摸ADC值转换为像素坐标2 J2 S4 A4 s* @8 n! L( E
18. * 形参: 无
! ?6 n- F" a) I! V: \
19. * 返回值: X 坐标值，允许负值
8 j+ d+ l* s, |+ ~9 u/ j
20. ******************************************************************************************************7 O$ ]* V V9 G* f4 D4 t
21. */% p3 @. g" r) J+ D$ @% f
22. static int16_t TOUCH_TransX(uint16_t _usAdcX, uint16_t _usAdcY)
, A/ k- A0 x4 |& W( n& n
23. {
8 p1 C- L! ^4 ^
24. if (g_tTPParam.CalibPointCount == 2)# R" S8 S. \% ^2 y9 E9 H3 Z
25. {7 W) V9 j4 K8 ^" `, Q2 ~# Q
26. uint16_t x;
1 }( _. @6 [+ N9 [6 T: C
27. int32_t y;
: P0 C5 e& R& y+ d' @4 ~
28. " x6 A4 j( _- _+ x6 K
29. if (g_tTPParam.XYChange == 0)$ T# p% }7 d {9 G w+ U
30. {
9 G' g" @* \5 ?% k# _# q# a# Z
31. x = _usAdcX;
- r5 g0 { R3 ?
32. if (x == 0)6 O/ O5 C' j7 ?' [% W1 l' x
33. {! M+ A3 `1 o% U0 Z+ f
34. y = 0;9 J V4 z: m6 ^
35. }1 D, R9 S B( a7 R' i
36. else
% w' C* o& C5 |* `
37. {
3 R# d! M3 @: R& X. } k% ~: x
38. //y = CalTwoPoint(g_tTPParam.usAdcX1, TP_X1, g_tTPParam.usAdcX2, TP_X2, x);" \! M4 P3 Z* t
39. y = CalTwoPoint(g_tTPParam.usAdcX1, g_tTPParam.usLcdX1, g_tTPParam.usAdcX2,! W$ @9 h2 {" P$ E G! P
40. g_tTPParam.usLcdX2, x);
7 w3 \. w, w6 [. N& K
41. }
}. H: o0 w+ B! a7 f0 y8 t
42. }
: p) }. e# i7 ^. C, L
43. else7 O$ D0 K* p/ k4 p; V
44. {
- N C+ ^ D- z/ p1 K
45. x = _usAdcY;
3 Y% s) h5 i, t* E7 o& {
46. if (x == 0)
6 y4 ? @ `3 n+ I
47. {* w$ S& ~( s9 q) I1 H6 {
48. y = 0;
49. }& m% t3 x. W$ Q( n' ?
50. else
' r) t# F$ h# d. v
51. {
- h0 }3 G3 A7 ^ X3 l6 |8 @) [
52. //y = CalTwoPoint(g_tTPParam.usAdcY1, TP_X1, g_tTPParam.usAdcY2, TP_X2, x);
) [) v' r7 W$ W9 J* H5 R
53. y = CalTwoPoint(g_tTPParam.usAdcY1, g_tTPParam.usLcdX1, g_tTPParam.usAdcY2,
1 A2 ^3 ?0 l8 [3 v; ^9 s2 J
54. g_tTPParam.usLcdX2, x);# G8 J0 e7 \* U
55. }
7 v2 A1 A8 H" B5 `+ i: E- V* s/ j0 S
56. }
& K* o! S2 [( @& y `+ j
57. return y;
$ u+ O% A3 @; x9 z0 r1 r
58. }
' ]$ Z1 P% w( k) {- f" S2 F
59. else /* 4点校准 */
/ |0 Z" i" U- T/ u
60. {5 ?, b2 y# j8 f( R5 o5 j
61. uint16_t x, x1, x2;
4 I) _$ O$ ^5 y! k# O0 W
62. int32_t y;
3 y0 A# |% @, B3 U( l t
63.
% q+ R+ O# } I0 {2 h* r" Z2 b
64. if (g_tTPParam.XYChange == 0) /* X Y 坐标不交换 */ |( G2 d* S. [7 b- S3 |$ @
65. {, L! V+ q2 B1 T/ R
66. x = _usAdcX;
' w; e! {2 Y- b; R+ y/ H) K
67.
/ R/ E5 W+ O& g9 a- W1 @0 S
68. /* 根据 Y ADC 实时计算直线方程的参考点x1, x22 \& X/ }+ C5 Q
69. if _usAdcY = usAdcY1 then 取点 = (AdcX1, TP_X1, AdcX4, TP_X4, _usAdcY)/ Q* h+ x( ]- W8 l J/ h$ k7 M
70. if _usAdcY = usAdcY2 then 取点 = (AdcX3, TP_X3, AdcX2, TP_X2, _usAdcY)
. C7 i, \6 M' e+ O
71. 0 `* j: v- ~6 y! b c a
72. 其中 TP_X1 = TP_X3; TP_X4 = TP_X1 , 这是程序设定的校准位置的像素坐标, 是固定的。6 t% h; e# J) q/ P' P- U
73. 我们仅需要动态计算对第1个和第3个参数。同样采用2点直线方程计算。7 @4 n- P) I, B) y2 ~$ @
74. */
) L- J/ g% B: s5 W9 x0 q; V0 |* d
75. x1 = CalTwoPoint(g_tTPParam.usAdcY1, g_tTPParam.usAdcX1, g_tTPParam.usAdcY2,
8 Z: N/ m1 w& }
76. g_tTPParam.usAdcX3, _usAdcY);
1 R: {- K- V( h5 O; i
77. x2 = CalTwoPoint(g_tTPParam.usAdcY1, g_tTPParam.usAdcX4, g_tTPParam.usAdcY2,
4 N% y- K6 _, Z7 d7 L1 F+ A& r. k
78. g_tTPParam.usAdcX2, _usAdcY);
* V1 h/ F" l- {% \$ q" t8 t
79. }! f6 f& U. H ^; n
80. else /* X Y 坐标交换 */
; |" d9 I, x" y, M* f! x
81. {/ h2 E5 G. W | U
82. x = _usAdcY;
4 U9 D# v, Z) t2 [+ U
83.
" @* ^5 B" X) O! j q6 _1 H
84. /* 根据 X ADC 实时计算直线方程的参考点x1, x2
# q2 E" u H! v$ S: F- @
85. if _usAdcX = usAdcX1 then 取点 = (AdcY1, TP_X1, AdcY4, TP_X4, _usAdcX): j4 Y7 l/ ~* S5 W, T
86. if _usAdcX = usAdcX2 then 取点 = (AdcY3, TP_X3, AdcY2, TP_X2, _usAdcX)
W* q% {" `5 u J- E
87.
/ A6 ^* D4 j5 F( r8 U- T
88. 其中 TP_X1 = TP_X3; TP_X4 = TP_X1 , 这是程序设定的校准位置的像素坐标, 是固定的。
8 p- l, B. @. S2 K9 E, v8 K8 d
89. 我们仅需要动态计算对第1个和第3个参数。同样采用2点直线方程计算。
) _9 k' Z' L- y5 @. q" e
90. */+ t; c7 A4 f, t
91. x1 = CalTwoPoint(g_tTPParam.usAdcX1, g_tTPParam.usAdcY1, g_tTPParam.usAdcX2,
! D6 V0 J* {! R* h
92. g_tTPParam.usAdcY3, _usAdcX);
3 a9 |, [9 }2 Y9 w7 E% F( \' `
93. x2 = CalTwoPoint(g_tTPParam.usAdcX1, g_tTPParam.usAdcY4, g_tTPParam.usAdcX2,
4 E; L5 M$ p" i. V7 R) Q
94. g_tTPParam.usAdcY2, _usAdcX);
4 z" B# O. ~; m* O7 k: H: A
95. }
, R! U3 Z5 o6 }' [9 K" R7 b- m
96. ' }9 x- O1 n6 M" U2 x+ q
97. if (x == 0)
9 t3 h- T8 ?7 q5 |8 r& R' c# H
98. {/ e/ W) o' o/ t
99. y = 0;) X8 S8 ?4 W1 |8 ^$ ^
100. }9 w( ^& b( |" W& A4 C7 s8 L f8 y+ b
101. else
! g# _5 S) b3 h# w L' H# B v
102. {
7 l6 _0 T& r8 D2 B
103. /* 根据2点直线方程，计算坐标 */
! V- v9 A- _' @
104. //y = CalTwoPoint(x1, TP_X1, x2, TP_X2, x);
+ t5 L$ o' z& r
105. y = CalTwoPoint(x1, g_tTPParam.usLcdX1, x2, g_tTPParam.usLcdX2, x);" ^+ l) L/ d9 }* a. y+ c
106. }
3 ]: u2 k5 y- f( H* g
107. return y;+ E( E! d( S2 p5 q$ `: D8 m
108. }. g& Q, r8 \+ W3 U' D B5 _, m
109. }
) j1 l% {. k% K8 f2 n/ b" g
110.
; l( g9 G5 D+ y8 m0 |0 v1 u
111. /*0 s. G0 O; ~8 V- N( V
112. ******************************************************************************************************# L8 V* d9 L9 d6 b0 C
113. * 函数名: TOUCH_TransY
( @9 e1 _6 c9 F( a! F
114. * 功能说明: 将触摸ADC值转换为像素坐标
6 J0 @0 [( o5 O
115. * 形参: 无
& R! ]+ P% r6 f% |
116. * 返回值: Y 坐标值，允许负值
& U$ v3 n6 b }0 G8 N0 _* F
117. ******************************************************************************************************
3 ?, w! e! k1 o3 K5 z$ L/ z, C: P
118. */7 K# a3 c; s3 ~ Q& ?1 E
119. static int16_t TOUCH_TransY(uint16_t _usAdcX, uint16_t _usAdcY)# ^) I+ _+ I+ ~+ f S3 t
120. {& ~% G2 D0 a8 b* K2 S
121. if (g_tTPParam.CalibPointCount == 2) /* 2点校准 *// @5 v2 S8 |' x. L( O
122. {
123. /* 类似函数TOUCH_TransX，省略未贴出 */
) P3 I$ B5 c- q8 \" Q
124. }$ z0 C0 x1 b% W! r: S6 H& [! B
125. else /* 4点校准 */
5 b4 s, Q, g( e, E- h: I
126. {0 V" G6 z7 E6 R
127. /* 类似函数TOUCH_TransX，省略未贴出 */
8 q$ G' [/ ?9 l! C4 ^4 _
128. }
4 f. ~8 W8 H* }) g( l9 b4 l$ Q
129. } W/ L) R( j- l- ]. s1 i5 q( ^

复制代码

下面将程序设计中几个关键地方做个阐释：

第9-12行，y =ax+b类型的直线方程，根据前四个参数输入的两个坐标点可以确定一条直线，然后输入第5个参数x，可以得到此坐标点对应的y值。
第22行，函数TOUCH_TransX的作用是将X轴采集的ADC值转换为物理坐标值。
第24-58行，用于处理2点触摸校准，对应的公式就是本章5.4小节的内容。
第59-108行，用于处理4点触摸校准，对应的公式就是本章5.5小节的内容。
第119-129行，函数TOUCH_TransY的作用是将Y轴采集的ADC值转换为物理坐标值。

54.5.7 电阻触摸的使用方法
电阻触摸的使用主要分为三步：

第1步，使能触摸，在bsp.c文件的函数bsp_Init里面实现。

/*
" m/ I: S* J' l5 C4 ^& I2 s h. T
*********************************************************************************************************
# c/ s- x" [2 u* F% \" }
* 函数名: bsp_Init* Z+ c- Q# _& ~! s, {# K3 P
* 功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次/ C: k. _, q! x+ L* d9 T
* 形参：无
0 A/ O* g. E% i8 U8 y, n v, p6 d
* 返回值: 无
* ^6 k$ k: i; i7 Z
*********************************************************************************************************7 @) [5 |; d$ y
*/
( d! g& I) u; Y/ R% O: e; S$ A
void bsp_Init(void)
4 i, O5 Z" \1 g/ u4 w
{% ?, A0 D: ~# _! X
/* 省略未写 */2 M9 D6 H2 \& s) X/ c+ [$ l
w, ?8 ?0 |+ ^1 g% \/ F+ T
bsp_InitI2C(); /* 初始化I2C总线 */( [: J# g/ n4 y: G `7 ^
TOUCH_InitHard(); /* 初始化触摸芯片，LCD面板型号的检查也在此函数，所以要在函数LCD_InitHard前调用 */ 6 l7 t" [1 B4 y, i( l
LCD_InitHard(); /* 初始化LCD */
[+ V( _' T- x3 Z
}

复制代码

第2步，每毫秒调用1次触摸扫描。

/*0 f+ n2 `5 b' f. ^% j2 ^
*********************************************************************************************************
: H$ F [; p: l
* 函数名: bsp_RunPer1ms s' G$ k5 ?% A8 o" }
* 功能说明: 该函数每隔1ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些需要周期性处理
" j: {1 a$ ?0 c$ _
* 的事务可以放在此函数。比如：触摸坐标扫描。: J. {* D3 ^. H# {9 v7 q3 e1 D
* 形参: 无0 s( [5 s* {; d5 ]% r7 e
* 返回值: 无
% }4 S% m5 b: h# T9 v
*********************************************************************************************************
. z1 I3 Y9 c* b6 d4 T% G$ x
*/9 J4 w- @9 N) J9 l( o/ c/ G' H" y! I
void bsp_RunPer1ms(void)
$ c7 n/ C' G* F; p1 [2 U3 O5 @
{
0 B& c. {8 P( p2 U. n; O
TOUCH_Scan(); /* 触摸屏 */
" J: |& {; b, K! E: B
}
7 ~, A* I; U8 Q" R+ t( ^* T

复制代码

第3步，用户程序里面采用下面的框架进行触摸消息处理。
TOUCH_DOWN表示按下消息。

TOUCH_MOVE表示触摸移动消息。

TOUCH_RELEASE表示触摸释放消息。

根据这几个消息，用户可以在程序里面判断当前获取的物理坐标值是否在设置的区域内来执行触摸操作。

int16_t tpX, tpY;
1 o. A6 L5 g, y* W. Z/ H, ^
uint8_t ucTouch; /* 触摸事件 */. z$ d% T6 P5 y$ W
7 k2 o8 v7 p/ `# Y
ucTouch = TOUCH_GetKey(&tpX, &tpY); /* 读取触摸事件 */
' _* i5 _+ L" T. B; }# j, S
if (ucTouch != TOUCH_NONE)7 T0 r( D8 b8 g! }6 i
{
- a1 m+ i3 E- L
switch (ucTouch)
# v$ E. X( ]2 i2 q
{: Z' @. T7 H- P
case TOUCH_DOWN: /* 触笔按下事件 */
7 P$ z/ Z/ A! i; P m
) E& R9 z( K$ r
/* 在触笔所在位置显示一个小圈 *// L Z( w/ j0 u5 G2 ~. i+ `. N. X: [# D
if ((tpX > 0) && (tpY > 0))
# V7 D% {$ k9 B& f3 B
{
( H9 [2 t) O3 G/ y- _" _& d! M
y" o/ q; ~( B p* ?& z
}
! r$ m. X1 J* k! R0 _( M9 i
break;
: `' B9 H0 C$ R0 @' H4 S
. M8 V* b) a4 `$ L, F% O
case TOUCH_MOVE: /* 触笔移动事件 */: K* l* I, j. V1 y
/* 实时刷新触摸ADC采样值和转换后的坐标 */
- _9 B$ X% ?8 Z: A- I8 k
{+ t, I/ d& i+ k9 d9 `+ z& N7 J* [
/* 在触笔所在位置显示一个小圈 */
+ S- b: p% \; Z3 k2 c8 F
if ((tpX > 0) && (tpY > 0))+ h; b$ ^: m. t! V, _/ S
{
H. e1 ?- s* e' S
. P1 c1 T0 q* z) x% r. r% I
}: \8 n* l# t# j2 p2 e: h( b
}/ \. q3 R+ y5 u" e
break;2 }7 ^ B: |: J1 G+ A, ]8 k
$ q% j6 {; R7 _. Z
case TOUCH_RELEASE: /* 触笔释放事件 *// u2 B" W* c# b2 J% V% [
/* 在触笔所在位置显示一个小圈 */8 b9 c3 C1 S4 r) y/ W- k( d4 r
if ((tpX > 0) && (tpY > 0))( s. T5 ^# U) @5 d0 R4 j: {
{
9 a7 n/ d) _8 Q5 A% Y: ?/ v
' i. W- @/ w5 F% o& u7 E1 o/ m M
}
3 v0 X) b4 v X/ R" T* d
break;
9 U }0 ]8 Y, q" U, S
}" W7 d$ @1 `5 j0 W# Q' n7 N
}

复制代码

54.6 电容触摸驱动设计
电容触摸相比电阻触摸就要简单很多了，因为电容触摸不需要做触摸校准，而且用的是触摸板和触摸芯片一体的，也不需要做寄存器初始化配置，上电后直接读取参数即可。

由于GT811已经停产，这里重点把GT911和FT5X06做个说明。

54.6.1 电容屏触摸IC---FT5X06
电容触摸IC是支持多点触摸的，FT5X06支持多达10点触摸同时按下，并提供了I2C和SPI两种

通信接口方式，开发板使用的是I2C通信接口。

注意，这个芯片返回的就是实际的坐标值，比如显示屏的分辨率是800*480，那么返回的就是在这个分辨率范围内的实际坐标，然后通过函数TOUCH_PutKey将FT5X06读出的实际坐标值存储到FIFO中即可，具体实现代码如下：

1. /*( `& y5 \. s. ^0 I& t1 w5 Z8 d, O
2. ******************************************************************************************************
1 ]$ q0 d0 z0 ~0 K9 F0 {5 S _* _
3. * 函数名: FT5X06_Scan* {& ~9 }! S7 e1 k+ D
4. * 功能说明: 读取触摸数据。读取全部的数据。放在主程序 bsp_Idle()中执行0 c' a+ A" }* m3 c: u1 F
5. * 形参: 无2 n5 s. O. E3 `' @% H
6. * 返回值: 无' W7 z3 t& @6 D
7. ******************************************************************************************************
% F, S4 m! d! G; e# ?# V
8. */
$ D: Z6 V8 G# Y2 i
9. void FT5X06_Scan(void)
: H$ d8 K9 x) [( B, {2 ^1 Q# Z
10. {
4 }9 W! A7 N% v1 w+ ?
11. uint8_t buf[CFG_POINT_READ_BUF];
0 U. M$ V" v3 v6 _! B& r# U* ~
12. uint8_t i;
A5 Z9 N# g+ G8 {" c
13. static uint8_t s_tp_down = 0;
) z+ Y4 ?$ p: E/ @ p0 g) ]2 a
14. uint16_t x, y;7 M1 @) G# v0 @0 H3 E+ |
15. static uint16_t x_save, y_save;
: ~2 r3 ?& q* b. A5 g) _0 Z
16. static uint8_t s_count = 0;
3 n: z. ^! k9 R. P9 B* [/ O6 d
17. # M. p8 u4 q9 A) ?& t2 G
18. if (g_tFT5X06.Enable == 0)
& Y9 c6 v' j$ m" w# d' w& t
19. {' y w: F$ K8 F
20. return;
M+ `7 b" i. K- n, w7 x' m9 I
21. }
]) X, P" T4 v- K; N
22. ) Y& B/ s+ x/ r3 W: O& N) S
23. /* 10ms 执行一次 */6 {. @8 c. {% O8 B; s. c1 p% K( L
24. if (g_tFT5X06.TimerCount < 10)1 C) j4 ]/ l4 k
25. {
9 [9 X2 P- r# w8 x% B0 a) T1 O
26. return;
/ O! ^+ z$ Z& G5 p- d
27. }
) m4 E) P. J* `
28. ; B, Y3 r. x. K A! |9 H" C( w
29. g_tFT5X06.TimerCount = 0;, F. f) o' _$ _2 o# Z: I+ ^" E
30. & o& s- ]4 s9 |( L; l
31. #if 1 /* 方案1: 检测INT引脚电平. */* l% X8 x0 q, V
32. if (TOUCH_PenInt() == 0)
( E7 F+ w0 _( F! Q3 O
33. {
! T! h# N2 |. h0 e$ {
34. #else /* 方案2：不用INT引脚，读状态寄存器 */ , _5 a5 B" n& x% B
35. FT5X06_ReadReg(2, buf, 1); ( m+ B2 F+ B b* R
36. if ((buf[0] & 0x07) == 0)7 |+ D$ U1 D) x1 v3 r: o
37. {
" A' I8 Z7 y& \6 h6 o' _$ B
38. #endif 7 J! P, \! b) z7 f0 R: U
39. /* 持续按下时，INT电平是脉冲信号。每隔18ms出现1个宽度4ms的高电平。 */
" i8 [, D: N4 c
40. if (s_tp_down == 1)" R; G# k Q% _" Q2 Q$ R
41. {5 a1 C. G5 R, M" K' a. ?
42. if (++s_count > 2)2 B% b) {. m$ s) Q
43. {* @+ `& M/ _/ h4 ?' d- F/ h
44. s_count = 0;
: F( P0 F3 }0 n5 `0 B1 J
45. s_tp_down = 0;% |$ r9 B/ o' x4 x
46. TOUCH_PutKey(TOUCH_RELEASE, x_save, y_save);
' J6 M; ?2 g' k3 c
47. }
5 ~, a' @5 [* k
48. }1 c6 h9 m. q/ S3 }/ y' N+ |3 a3 J
49. return;/ c' O6 Y# s/ k6 o! W8 D& N
50. }- G1 F, k/ g7 b( O
51. s_count = 0; Y$ t! |8 c, Q0 n
52.
5 J$ w8 a) v3 L7 X
53. /* 有触摸，读取完整的数据 */
n/ r& e; n! A
54. FT5X06_ReadReg(0, buf, CFG_POINT_READ_BUF);# @; D w# c( L8 x& o! z5 w8 T
55.
& i# K% J; Q3 n, i% c
56. g_tFT5X06.Count = buf[2] & 0x07;
9 s5 i4 K! l" u0 k: p4 [
57. if (g_tFT5X06.Count > FT5X06_TOUCH_POINTS)
- p7 u" T& U! Q+ A( i
58. {
6 g3 R" ^8 t0 `2 ?# K/ l' c" @
59. g_tFT5X06.Count = FT5X06_TOUCH_POINTS;
K1 \1 J% |- Q* z' A" u! D
60. }
! l, ^+ T/ S' R4 i0 n7 a+ P" Q. H
61.
; }# ^/ D$ g+ R ~5 Z
62. g_tFT5X06.Count = 0;' z% G3 s- r- g3 o6 Q- z: x' `
63. for (i = 0; i < FT5X06_TOUCH_POINTS; i++)8 v; F/ ] S0 ?' U6 v5 h+ k6 `
64. {+ q: n9 r+ }$ P2 r& K0 k8 k
65. uint8_t pointid;0 G% ^& J# i: ]
66.
7 d Y( R. m# h( _( b8 _, `
67. pointid = (buf[5 + 6*i]) >> 4;
6 i6 D. B' @% f% z* r" E
68. if (pointid >= 0x0f)1 w! s3 `# x2 ~
69. {
' Q. h, w& S$ `3 A
70. break;4 H& l. {7 L/ _7 k4 [/ F
71. }! r/ ~$ I, J6 |9 ?
72. else
3 [' o# i# a' Q% s( l
73. {
2 m- p3 A* Q' }7 v5 l
74. g_tFT5X06.Count++;
" q* [7 }; U$ X& i# c
75. g_tFT5X06.X = (int16_t)(buf[3 + 6*i] & 0x0F)<<8 | (int16_t)buf[4 + 6*i];
* T6 g6 c3 l$ l- ^* L+ v# A+ p) a
76. g_tFT5X06.Y = (int16_t)(buf[5 + 6*i] & 0x0F)<<8 | (int16_t)buf[6 + 6*i];. j6 l; O. K3 [) F w
77. g_tFT5X06.Event = buf[0x3 + 6*i] >> 6;9 c! Z+ _# o0 l
78. g_tFT5X06.id = (buf[5 + 6*i])>>4;& k2 Q% }, z1 v2 Z/ c9 M; T
79. }. [4 A7 |* `" Z7 Q6 M
80. }1 N$ V6 }& @5 ]
81.
: h" n1 z, ]& |5 {. G
82. /* 检测按下 */' {8 `2 r. k8 I6 n E
83. {
84. if (g_tFT5X06.ChipID == 0x55) /* 4.3寸 480 * 272 */" @, g4 }: f% f9 Y- u
85. {0 o4 s9 N; t' v
86. x = g_tFT5X06.Y[0];
' t$ f9 p& S5 s7 H) |3 y; g* N
87. y = g_tFT5X06.X[0]; 5 X+ X' o# t' R
88. + u5 h# I1 v. G! a( X: Y" ]
89. /* 判断值域 */
3 g' c% u6 G% w
90. if (x > 479); P+ M! b6 [5 M0 R7 e# [# z6 R( L# @
91. {
/ G7 O( L8 [, I) c
92. x = 479;! c }" i4 y1 u0 ]
93. }! X1 x* N/ L6 e/ w
94.
( X3 m$ V& p! o. w t% {
95. if (y > 271)
' `4 j! F7 j- l9 ~$ }
96. {
1 U }7 U1 `& D% m& ?# K G
97. y = 271;
( ^. F, s; N+ r5 T4 t3 p7 d6 y: q
98. }
" D/ G' e, X1 S/ G4 f1 }8 P* w7 m
99. }+ u% J2 `5 o s- `
100. else if (g_tFT5X06.ChipID == 0x0A) /* 5.0寸 800 * 480 */ ^) U7 x' O& M4 \: {, m. ?$ h4 I' n
101. {) I, U# n) ^- ~# v* B5 W
102. x = g_tFT5X06.X[0];. P9 t4 Z; T& L Z9 O9 W( [' g
103. y = g_tFT5X06.Y[0];
9 B" J/ z- ] T! s4 e J* R3 F
104.
" \# R$ t1 @0 q
105. /* 判断值域 */% b1 x4 h% Q* C A+ \8 v2 J8 G
106. if (x > 799)* \( C' r" l8 r
107. {
" i- W" n( z. i5 `4 ~
108. x = 799;/ q' F5 V# Q& K
109. } 7 A, f0 }- P9 p6 r
110. if (y > 479)
; _$ R3 z1 s. g0 W, a. N- U
111. {! |- e! Z: M# a; z4 r$ Z2 x
112. y = 479;
" k! `# l) n' p1 L' s. p
113. } : @# J4 ]- h/ n
114. }
3 [+ G$ z1 J6 N0 `
115. else /* id == 0x06 表示7寸电容屏（FT芯片） */7 K" d! R! o! n6 w$ N
116. {
% j, Y, h9 e: H) Q) J7 N
117. x = g_tFT5X06.X[0];
- T$ s' h5 m/ ~: ]1 X$ ^
118. y = g_tFT5X06.Y[0];
^7 j& [' a M
119. # o; Z& f2 ^* F( C
120. /* 判断值域 */
* L% ^, Q7 [8 U) \/ W# m% q9 W$ T
121. if (x > 799)
7 m2 @- \# M' n8 K
122. {
# C$ s$ l" z3 @0 |$ {. B! ]' y5 _
123. x = 799;+ G$ `; T! A+ c: C) f8 y
124. } % x, }6 Y% A9 V/ J: L4 K
125. if (y > 479)+ a) o, ^. R1 B( @6 m* Y2 n) q
126. {
' @6 L1 Y6 k0 I; J. `( K9 S* Y, W
127. y = 479;
0 s) N- Z- E7 k, w9 Q/ a9 n" X
128. }
3 T$ m9 i% C2 u0 T8 K5 F' m) w8 r& e* P
129. }4 `) K, `% I( d9 a4 B/ p. E0 J
130. }% u* B+ s+ S% N8 G% U' B+ j
131.
' S* z4 E: X5 z. P7 A
132. if (s_tp_down == 0)
8 q0 O9 ^7 C1 j! c
133. {: a+ @) ^7 Y) Z" p$ W2 B5 }. q
134. s_tp_down = 1;0 d, w; }7 P1 h
135.
0 j; A. ?% h' G |
136. TOUCH_PutKey(TOUCH_DOWN, x, y);
- f+ z% N8 S1 O3 J g& {' M
137. }
8 N" P8 i1 ]" |2 f
138. else
* [0 R$ D, g. s5 V4 j, K2 a9 }
139. {
! `+ |1 q% i9 V; T, j, C
140. TOUCH_PutKey(TOUCH_MOVE, x, y);
# F' V: L6 ^4 H
141. }
7 S; D- t2 g! v% `5 M. \. O
142. x_save = x; /* 保存坐标，用于释放事件 *// E$ V% \# p! Y
143. y_save = y;9 G4 o$ I5 }% D
144. / e8 I3 f) M7 M
145. #if 0
4 n1 S( V6 f* z
146. for (i = 0; i < CFG_POINT_READ_BUF; i++)
' x7 w( i+ z) Y! U0 X
147. {/ H7 B8 i5 J' v. b
148. printf("%02X ", buf);
: o# t* t+ z8 H: j# {
149. }
+ \7 n6 D& q1 u$ I6 f+ [- C
150. printf("\r\n");5 P& |, F, r0 n$ ~* m' }' b
151. #endif
$ p5 s/ V8 X2 F2 ^( W5 \
152. 5 H7 i; P |9 e3 L: U* p; E
153. #if 0 /* 打印5个坐标点数据 */
E, _) `# q# c. s9 c4 E4 x- r( d% h
154. printf("(%5d,%5d,%3d,%3d) ", g_tFT5X06.X[0], g_tFT5X06.Y[0], g_tFT5X06.Event[0],
$ N3 e5 M! E: C6 X1 V! F' C' Z4 {0 s
155. g_tFT5X06.id[0]);
+ c6 }9 H# I. D" k! |4 |3 ?+ ]
156. printf("(%5d,%5d,%3d,%3d) ", g_tFT5X06.X[1], g_tFT5X06.Y[1], g_tFT5X06.Event[1],( W! e0 I9 q V1 v5 v
157. g_tFT5X06.id[1]);
1 V7 A) ^7 |8 L$ E$ Z% U# l% ^* m
158. printf("(%5d,%5d,%3d,%3d) ", g_tFT5X06.X[2], g_tFT5X06.Y[2], g_tFT5X06.Event[2],9 Z# @) x* K* Z Z
159. g_tFT5X06.id[2]);
8 S+ Y4 Z# h, e' m9 f5 L$ j
160. printf("(%5d,%5d,%3d,%3d) ", g_tFT5X06.X[3], g_tFT5X06.Y[3], g_tFT5X06.Event[3],
2 T M/ v- M( f/ M( k
161. g_tFT5X06.id[3]);+ @: e0 T5 K" E, u5 ?0 w3 q! L* E, [
162. printf("(%5d,%5d,%3d,%3d) ", g_tFT5X06.X[4], g_tFT5X06.Y[4], g_tFT5X06.Event[4],
& R) m/ N" W1 t0 u5 E: [/ n) w
163. g_tFT5X06.id[4]);/ I; `: B" i. w# i) n
164. printf("\r\n");2 _; v7 s# I. r B! ~8 g
165. #endif : p" J K/ l# F- y* m' ^6 P C
166. }

复制代码

. B6 I& [- L" A0 F1 Y9 J下面将程序设计中几个关键地方做个阐释：: \2 s& I0 ^8 S5 I* E+ L' q
6 r/ a0 P" }5 K" Z# Q
  第32行，通过判断FT5X06的中断输出引脚的高低电平来判断触摸板是否被按下，如果有触摸，这个引脚输出低电平，反之，输出高电平。通过判断这个引脚可以避免不必要的操作。
) I5 l3 S6 T; k& {/ ^+ p  r) \# i  第35-36行，从寄存器2读取一个数据，判断是否有触摸数据，这种方式就没有直接判断中断引脚方便。
8 D3 r1 E' O  c1 E( N8 ~* P  第40-50行，如果没有触摸数据，而且变量标志s_tp_down = 1（此变量等于1表示之前处于触摸按下或者移动状态，如果等于0表示之前处于未被触摸状态），那么此时要通过函数TOUCH_PutKey存储松手消息，这一步比较重要，切不可省略。如果变量标志s_tp_down = 0，直接退出即可。另外，特别注意一点，这里是通过s_count变量连续记录到两次松手消息才执行。
9 [5 i5 h4 v+ m! E1 @3 p' ~  第50-80行，如果有触摸，将所有触摸值全部记录下来（由于支持多点触摸，会有多个触摸值）。
7 n+ @& j! T% I2 h/ u- S- y  第83-130行，根据不同的分辨率的显示屏，做值域范围处理，防止超出范围。
: v1 ~7 E$ o2 q6 n) O  第132-137行，如果变量s_tp_down = 0表示之前处于未被触摸状态，这里设置此变量为1，并通过函数TOUCH_PutKey存储按下消息和当前的坐标值。
2 f2 P* O& x" i9 v  第138-141行，如果变量不等于0（其实这里也就是1）表示之前处于按下状态，此时触摸处于移动状态，这里不用重复设置此变量了，但通过函数TOUCH_PutKey存储按下消息和当前的坐标值。
8 A3 ?8 b/ N" h  第153-165行，这里预留的条件编译主要是方便调试阶段使用。
% C2 q9 a  O' a" C
54.6.2       电容屏触摸IC---GT9111 T( a4 X0 ^- Y( C
GT911支持多达5点触摸同时按下，并提供了I2C通信接口方式。! x/ f; M1 j+ v/ p
7 h9 u, H0 G+ e1 D0 U
GT911的使用基本跟FT5X06是一样（注意，芯片GT911返回的就是实际的坐标值，比如显示屏的分辨率是800*480，那么返回的就是在这个分辨率范围内的实际坐标，跟FT5X06也是一样的），具体实现代码如下（这里没有使用多点触摸功能，仅存了一个触摸值，一般情况下已经够用）：
) i# K/ t' o+ ]+ }& U: A3 H
  J" U/ U# d3 `6 `

1. /*
% R8 h. s" b( _( b
2. ******************************************************************************************************
9 ^$ i- v% G& I8 ?; T* p7 w
3. * 函数名: GT911_Scan6 L. z% ]; S9 b% U/ f
4. * 功能说明: 读取GT911触摸数据。读取全部的数据，需要 720us左右。放在 bsp_Idle()中执行
1 c( C: d$ a7 q4 W- ?$ v4 @$ i& Q
5. * 形参: 无% l5 M; a5 I2 N- l$ c1 B$ H7 Z
6. * 返回值: 无
' f: Q9 K& K7 ^1 T# d1 q
7. ******************************************************************************************************+ ~. ?6 W/ K5 y; Q
8. */. e6 X; K, o0 e3 j; C- N1 ?, ?
9. void GT911_Scan(void)% S8 B- o. B& ]5 u
10. {! x4 A! A7 @ V0 @. M4 u- T
11. uint8_t buf[48];
( i# G3 e; J! G6 A+ I
12. static uint8_t s_tp_down = 0;- K" E# L* o( w8 Q# z0 k* O" I
13. uint16_t x, y;8 c0 `5 H. v0 l) {1 Y9 e
14. static uint16_t x_save, y_save;
5 P9 w0 p) N1 o! U6 ?
15. uint8_t clear_flag = 0;: G, E; }, }8 V; i# v2 t9 A
16. static uint8_t s_count = 0; " [" k' C. j- ~9 x- x
17. 9 @; k; J5 X) T' E
18. if (g_GT911.Enable == 0)/ {4 M; h: s ^# U2 ?) v* W# b3 i* C
19. {( g+ }# H }: c; Y) c" R
20. return;3 m3 {8 z& |* N* m, W d
21. }
$ I1 L+ k9 p& t" B, q% |
22.
v) o) C( N# e0 e; J
23. /* 10ms 执行一次 */$ n' D/ N1 c' x
24. if (g_GT911.TimerCount < 10)
" W4 U, E6 G$ s
25. {
8 e8 _. N+ ^4 k# d. x# \( e
26. return;5 K9 \/ B. j0 p& Z
27. }6 {& m. p3 q' M8 w9 H: X
28.
7 a5 ^4 g) B# k: h+ t3 t0 x+ _
29. g_GT911.TimerCount = 0;
0 T" V. j- a9 {- R# H& Q
30. 5 N0 I, L% f9 G, i Y$ a6 f
31. #if 1 /* 方案1: 检测INT引脚电平. */' U2 R5 ^7 \) {/ _8 Q; \0 B$ U- K
32. if (TOUCH_PenInt() == 0)1 `' k1 u1 Z& r" l
33. { ( G8 ?2 m3 D4 y/ H; p4 m7 @5 d
34. #else /* 方案2：不用INT引脚，读状态寄存器 */
$ v8 x% W, N' J6 Z
35. GT911_ReadReg(GT911_READ_XY_REG, buf, 1);
+ X9 d/ T7 M3 ]
36. if (buf[0] == 0)
" g8 i4 a, M. ?* }) s5 U
37. {
' e8 H( W: d% P ~7 G" z* A
38. #endif . C6 M3 \- ^3 J8 w
39. if (s_tp_down == 1)
1 A! F6 f7 d5 c' Y7 `1 \
40. {' p- u, b6 j5 w$ U9 n
41. if (++s_count > 1)
5 Y% v: Y6 g# X2 V/ m
42. {
0 s0 L( m7 @' D4 l' {/ S9 H
43. s_count = 0;
' l( x* U& L" R9 q7 g
44. s_tp_down = 0;
, B$ D/ A' _3 O7 w( I5 `
45. TOUCH_PutKey(TOUCH_RELEASE, x_save, y_save);
. l- K: p- G! K6 Y* N1 z
46. }! n S2 X: w& B# f2 |( @! u2 n
47. }& O% ]3 ~" j! C5 S: \; W5 b
48. return;
( g$ n: K6 _, q. q
49. }
( ?; z/ L2 V6 ~4 G0 \: M
50. s_count = 0; ; b% x7 s/ }8 }. q: z# A8 F; g' O
51.
U$ ~, y0 `; L
52. #if 1 /* 一般应用只读1点 */4 v: U# N2 E5 F; N& f8 W- R2 h; J
53. GT911_ReadReg(GT911_READ_XY_REG, buf, 8);
/ t- K4 k Z; m2 L; c9 e
54. #else /* 读5个触摸点 */. W T4 ]8 V( Q6 G: A! k8 @5 z8 L' d
55. GT911_ReadReg(GT911_READ_XY_REG, buf, 40);7 S1 i7 z# g d4 J3 S
56. #endif. B1 Z# y6 E4 x
57. * Y2 C$ t6 B) o3 |( E% |0 u# i
58. GT911_WriteReg(GT911_READ_XY_REG, &clear_flag, 1); /* 读完坐标后必须写0清除 */ S' E- o: s; n I, ~
59. 5 L# [2 ~$ I! I/ @1 E, M
60. /*
0 ^. }7 T5 K4 c; o' v. Q9 a2 _
61. 0x814E R/W Bufferstatus Large_Detect number of touch points
7 U* l* L( j- N6 I
62. Bit7: Buffer status，1表示坐标（或按键）已经准备好，主控可以读取；0表示未就绪，数据无效。; {+ H8 A6 n8 S- o
63. 当主控读取完坐标后，必须通过I2C将此标志（或整个字节）写为0。
! R" o; ^, g @! c; ?/ `. U
64. Bit4: HaveKey, 1表示有按键，0表示无按键（已经松键）。% h" ~! l( Q; K! ?
65. Bit3~0: Number of touch points, 屏上的坐标点个数
/ |: u2 i4 i5 a4 m, t' w1 I% ~
66. * T/ r, x, I4 T: ~
67. 0x814F R Point1 track id & e2 j8 ^. C% R- L" ~0 [
68. 0x8150 R Point1Xl 触摸点 1，X 坐标低 8 位 ( w& l7 }1 }' C9 S" R" l ^
69. 0x8151 R Point1Xh 触摸点 1，X 坐标高 8 位 1 z3 J b8 c" ^: s
70. 0x8152 R Point1Yl 触摸点 1，Y 坐标低 8 位
4 c3 M' |( Y% c) T9 y( A6 Q
71. 0x8153 R Point1Yh 触摸点 1，Y 坐标高 8 位 , O3 @3 ~/ N$ c5 M& e
72. 0x8154 R Point1 触摸点 1，触摸面积低 8 位
0 g* o4 E: x1 e. n4 x" `' ]
73. 0x8155 R Point1 触摸点 1，触摸面积高 8 位 ( i+ r" V. f; W
74. 0x8156 ----, p5 _* K+ O$ ]4 K9 \! S( s
75.
0 Z# O) O& C6 j7 f
76. 0x8157 R Point2 track id
/ ^1 S8 c* C; U, j/ F! o
77. 0x8158 R Point2Xl 触摸点 2，X 坐标低 8 位
3 t3 b0 k2 c/ h6 A
78. 0x8159 R Point2Xh 触摸点 2，X 坐标高 8 位 5 \: S y p. \0 N" b( P7 X: n
79. 0x815A R Point2Yl 触摸点 2，Y 坐标低 8 位 7 |9 ]" `+ l% v* {2 O
80. 0x815B R Point2Yh 触摸点 2，Y 坐标高 8 位
, E; I9 A( M, M. n/ e" m) t4 o
81. 0x815C R Point2 触摸点 2，触摸面积低 8 位 : \. `" H/ k5 B7 h- X
82. 0x815D R Point2 触摸点 2，触摸面积高 8 位
6 o6 H4 p9 L0 M& j
83. 0x815E ----
- i2 g: m' s D. N1 `2 {( q
84.
/ b, }. X, ~. k$ ^. C3 x
85. 0x815F R Point3 track id
1 b. l8 y* p+ H: @
86. 0x8160 R Point3Xl 触摸点 3，X 坐标低 8 位
) R% d k5 g9 ]7 M |; E
87. 0x8161 R Point3Xh 触摸点 3，X 坐标高 8 位
* Q8 ^7 j8 n- V, l
88. 0x8162 R Point3Yl 触摸点 3，Y 坐标低 8 位
# g6 g; Q0 W( O( {
89. 0x8163 R Point3Yh 触摸点 3，Y 坐标高 8 位
$ F( Z I/ j4 e6 X6 s* l
90. 0x8164 R Point3 触摸点 3，触摸面积低 8 位 1 X: `7 G0 f5 Q
91. 0x8165 R Point3 触摸点 3，触摸面积高 8 位 ! v# z9 t! s7 Q) L% F0 W( }: n( l
92. 0x8166 ----
$ G, L* |2 i) l2 {( U0 }7 D
93.
- S6 O G1 y# A1 _
94. 0x8167 R Point4 track id
5 m' d/ e) y/ }8 w' j1 X- |, `/ t
95. 0x8168 R Point4Xl 触摸点 4，X 坐标低 8 位 4 Y, n- ~+ I4 Q
96. 0x8169 R Point4Xh 触摸点 4，X 坐标高 8 位
2 R* [2 P0 V$ \) c$ ~3 J
97. 0x816A R Point4Yl 触摸点 4，Y 坐标低 8 位 * g; F: {$ @. L8 k: a& b
98. 0x816B R Point4Yh 触摸点 4，Y 坐标高 8 位
' B9 {/ X, P- X/ {" A
99. 0x816C R Point4 触摸点 4，触摸面积低 8 位 , B. |# k7 n3 i
100. 0x816D R Point4 触摸点 4，触摸面积高 8 位 9 {, s A% d/ A. U( N; F
101. 0x816E ----
% q: N$ _1 N2 y6 O2 I$ f3 h7 o- K6 _" s
102.
e' N8 V: J# O8 |2 Q
103. 0x816F R Point5 track id 2 A- B ^ V0 n' q4 e7 ^6 @' x
104. 0x8170 R Point5Xl 触摸点 5，X 坐标低 8 位 7 U- F* k# \. v' w R& m% P" M. ]9 ]
105. 0x8171 R Point5Xh 触摸点 5，X 坐标高 8 位 & ?7 D- d5 A# N$ K$ T, C: r
106. 0x8172 R Point5Yl 触摸点 5，Y 坐标低 8 位
; }) f& P& B2 x+ Q; e
107. 0x8173 R Point5Yh 触摸点 5，Y 坐标高 8 位 & v! v( v- p( |, X4 A/ @7 a _
108. 0x8174 R Point5 触摸点 5，触摸面积低 8 位 7 f' L9 M8 W1 [ X2 {& ?0 s
109. 0x8175 R Point5 触摸点 5，触摸面积高 8 位
( U; L6 a. w Z
110. 0x8176 --9 P4 `+ t; B8 [5 E9 j0 b( N
111.
' X9 ^8 p4 j6 z4 h5 p6 R, L. J
112. */' y3 s R3 P% [* \
113. g_GT911.TouchpointFlag = buf[0];5 Y) r: y0 i4 ]! Q. q
114. g_GT911.Touchkeystate = buf[1];
Y- C3 {; G* n/ {, B& m$ o8 ]
115.
$ v% X+ z) f( L( ~; N
116. g_GT911.X0 = ((uint16_t)buf[3] << 8) + buf[2];; }. \ W5 d+ h( |
117. g_GT911.Y0 = ((uint16_t)buf[5] << 8) + buf[4];$ }1 S3 _/ \. Q& r
118. g_GT911.P0 = ((uint16_t)buf[7] << 8) + buf[6];& H- i. Q0 }3 G# m
119. 1 `$ R# ~6 _- w
120. #if 0 /* 其余4点一般不用 */. M7 a+ h* ?( h* I8 h
121. g_GT911.X1 = ((uint16_t)buf[9] << 8) + buf[10];
% j9 E# O/ K" {* k P3 F
122. g_GT911.Y1 = ((uint16_t)buf[11] << 8) + buf[12];" ]/ l6 j! B; x" X7 m% q
123. g_GT911.P1 = ((uint16_t)buf[13] << 8) + buf[14];, P' y& O/ c/ q
124.
; Z; ~! Z3 G# H+ K& j
125. g_GT911.X2 = ((uint16_t)buf[17] << 8) + buf[16];8 v3 w; t1 {+ F/ I, c% f7 x( _9 F" e
126. g_GT911.Y2 = ((uint16_t)buf[19] << 8) + buf[18];) @ |/ G$ `: W( x, v
127. g_GT911.P2 = ((uint16_t)buf[21] << 8) + buf[20];/ X6 b2 R* P- B5 G+ X8 f
128.
/ U$ y1 m" ^$ }+ Z5 Y* {9 F0 X
129. g_GT911.X3 = ((uint16_t)buf[24] << 8) + buf[23];$ Y* f; t) h; |& `! @
130. g_GT911.Y3 = ((uint16_t)buf[26] << 8) + buf[25];* g+ X H& i5 _- J& \4 ?; @" P
131. g_GT911.P3 = ((uint16_t)buf[28] << 8) + buf[27];
7 b' ~2 ]& {& O8 d% X. x' r
132. 8 N$ u j3 C& P, ~
133. g_GT911.X4 = ((uint16_t)buf[31] << 8) + buf[30];4 ~8 R: q' Q, N7 C+ ^
134. g_GT911.Y4 = ((uint16_t)buf[33] << 8) + buf[32];! t F3 x" w$ @$ p6 e6 I
135. g_GT911.P4 = ((uint16_t)buf[35] << 8) + buf[34];
( E3 f& ]. R; h% h
136. #endif, X6 |5 s- Z' b
137.
: W- ^( f$ H+ y' P& X, l) W
138. /* 检测按下 */" Z: m7 F& I" P& }, p5 s
139. {) O, Y. }$ R1 i' v6 |' H, E
140. /* 坐标转换 :
+ X8 B6 D) L: T8 P; H- U3 k
141. 电容触摸板左下角是 (0，0); 右上角是 (479，799)
+ U0 z1 o- ]; I* j2 R0 l( b- }
142. 需要转到LCD的像素坐标 (左上角是 (0，0), 右下角是 (799，479). x+ ?' z2 o. R# ]. p% V
143. */: o* R* M, E" U1 P2 [$ F/ t
144. {
/ `9 u* E: P0 S; l
145. x = g_GT911.X0;% Q; b7 V6 Y& l4 n% E! }& j6 r- o
146. y = g_GT911.Y0;
+ V& [3 {/ k- O7 A6 u2 I
147. & E- i4 i6 r0 A! ], a7 A
148. if (x > 799)& \" e3 P7 _; t- [) ~) H* _3 E
149. {
: e0 R S' C* P2 a
150. x = 799;& w2 w, p1 j! h/ s
151. }, s0 I: k' U: u5 v1 o' A* q
152. 3 `; m5 z/ S, F
153. if (y > 479)5 Y/ Y; q" t! S( [& b+ d
154. {
7 g" T: \# v) \1 Y/ i
155. y = 479;
# B8 z" R7 G& i0 z
156. }
7 ]4 @3 h+ y" p
157. }
: E. n; @9 v, H
158. }
) T y; t z8 f5 }1 {+ H5 R; X; ^
159. : g( ~2 f8 [( r w% i: v0 @* h
160. if (s_tp_down == 0)" I1 i) }& E0 `3 i* c" M
161. {# @( ?0 }1 S& t! f) h
162. s_tp_down = 1;9 X+ `; M x x8 ?6 {# T
163. # M$ l- B8 ` s; V. @! \
164. TOUCH_PutKey(TOUCH_DOWN, x, y);
* W1 T# a5 V3 h
165. }
0 ~* `7 [5 s7 a. @& I5 o: b2 `
166. else
, A# Z" F& z0 I" r4 X
167. {, d0 [0 ^1 f8 U- T, ~
168. TOUCH_PutKey(TOUCH_MOVE, x, y);7 J2 F- t. M! S2 R
169. }; f: {: ?, r! E. \0 ^0 h+ X
170. x_save = x; /* 保存坐标，用于释放事件 */
% C' }1 `" D" z5 I) }4 [, g( ?
171. y_save = y;& E- F0 q# W7 a3 @+ T
172. 3 ?) p! j% E) B8 }! F6 E) H( Q( H j
173. #if 00 e! R/ `) ~1 Y. S1 b2 V) P
174. {
9 J( T0 W# Q8 e! F3 w
175. uint8_t i;
5 w9 N) `# K5 }0 j' ]8 z) d% z y
176. z) o Z3 J# c% Y
177. for (i = 0; i < 34; i++)
- `: z0 B. I# l
178. {/ b8 E/ W4 y, r5 K1 T6 ?
179. printf("%02X ", buf);
% J- g. a1 P" y2 w% o1 s
180. }
% w* V% h% o V
181. printf("\r\n");' ]: ?& ]* m! {' `
182. 9 I( F# k N& y1 Q& G3 t
183. printf("(%5d,%5d,%3d) ", g_GT911.X0, g_GT911.Y0, g_GT911.P0);+ [) d8 C" Y# k+ O1 V, l8 l
184. printf("(%5d,%5d,%3d) ", g_GT911.X1, g_GT911.Y1, g_GT911.P1);
% M) l; Y% r1 L$ |" l, L1 V' [
185. printf("(%5d,%5d,%3d) ", g_GT911.X2, g_GT911.Y2, g_GT911.P2);1 b( M# D5 B! ]) d) w/ d. l) h: q
186. printf("(%5d,%5d,%3d) ", g_GT911.X3, g_GT911.Y3, g_GT911.P3);
$ H7 ^- Z& t" ]( }) R9 M/ d, l
187. printf("(%5d,%5d,%3d) ", x, y, g_GT911.P4);
6 ^5 L1 L$ G: J3 {: q
188. printf("\r\n");) P' E/ `) s; T# e
189. }
( a& W2 p9 J* b9 {- }: |7 R
190. #endif 4 ~$ B! z- w$ ~" V& Z% ]& J
191. }

复制代码

9 E5 R* U- ~: u7 b2 j' p
下面将程序设计中几个关键地方做个阐释：5 c+ |& e4 z- e: x( H

1 J/ N6 W1 M. G  第18-21行，使能标志，在文件bsp_touch.c文件里面有一个函数bsp_DetectLcdType专门检测不同的触摸IC，如果是GT911的话，变量g_tFT5X06.Enable会被置1。
0 z5 f( f' J0 J+ i8 h6 N  第24-27行，表示函数GT911_Scan每10ms执行1次。( X& a, p" K$ z% ^& q
  第32行，通过判断GT911的中断输出引脚的高低电平来判断触摸板是否被按下，如果有触摸，这个引脚输出低电平，反之，输出高电平。通过判断这个引脚可以避免不必要的操作。$ k* J0 f6 ~1 D3 ^7 P- J1 h
  第35-36行，从寄存器2读取一个数据，判断是否有触摸数据，这种方式就没有直接判断中断引脚方便。% i6 g( T# O& W4 n7 _* N
  第39-49行，如果没有触摸数据，而且变量标志s_tp_down = 1（此变量等于1表示之前处于触摸按下或者移动状态，如果等于0表示之前处于未被触摸状态），那么此时要通过函数TOUCH_PutKey存储松手消息，这一步比较重要，切不可省略。如果变量标志s_tp_down = 0，直接退出即可。另外，特别注意一点，这里是通过s_count变量连续记录到两次松手消息才执行。0 R9 Q( x7 f% N; U6 g& j
  第52-136行，仅读取一组。这里没有使用多点触摸功能，仅存了一个触摸值，一般情况下已经够用。9 m' p' Q3 G$ x4 I# K( D7 A7 }' r+ c
  第138-158行，对读取的值域范围处理，防止超出范围。
2 d. ]8 G4 L6 h- _, w) w# y) Y  第160-165行，如果变量s_tp_down = 0表示之前处于未被触摸状态，这里设置此变量为1，并通过函数TOUCH_PutKey存储按下消息和当前的坐标值。
, s6 N7 ]" W6 J. f6 T  第166-169行，如果变量不等于0（其实这里也就是1）表示之前处于按下状态，此时触摸处于移动状态，这里不用重复设置此变量了，但通过函数TOUCH_PutKey存储按下消息和当前的坐标值。9 U; }4 Q, H5 F7 d$ O
  第173-190行，这里预留的条件编译主要是方便调试阶段使用。

. u9 V# t0 z- n8 k, l4 `* Q54.6.3 电容触摸的使用方法* K/ h/ X' U1 {  I( t
电容触摸的使用主要分为三步：) \0 E( @2 @1 x; v8 q" i8 e

) R7 H3 f4 y9 k, A2 C: Y  第1步，使能触摸，在bsp.c文件的函数bsp_Init里面实现。
8 [$ E2 @8 Z3 g" J" Y

/*8 D+ w( S3 E' k; b O3 C
*********************************************************************************************************
3 O/ ]8 t& z& W/ P- C3 A; e4 p
* 函数名: bsp_Init1 [$ B7 h# G2 j5 {; t4 S
* 功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
6 `& v2 W& e. Z# K
* 形参：无
4 L8 w: h+ h( S& m7 b. l
* 返回值: 无; y/ M; j9 Z2 O- h9 {: b
*********************************************************************************************************3 q. N- o( d% N0 n
*/
. W7 ~. G7 e2 d, t' r7 F
void bsp_Init(void)
2 \9 Y5 }- t" N0 F; D
{
l+ k& W4 S9 ^" Y. z, s
/* 省略未写 */; x1 T' i2 n. G# W
$ ]6 }/ |/ a5 O* X: B
bsp_InitI2C(); /* 初始化I2C总线 */; G) [! I# |$ L; t. s
TOUCH_InitHard(); /* 初始化触摸芯片，LCD面板型号的检查也在此函数，所以要在函数LCD_InitHard前调用 */
# f7 I4 w. J1 N2 G
LCD_InitHard(); /* 初始化LCD */
9 \" P9 o3 i0 T- r4 [
}

复制代码

$ L4 V7 t8 S8 _0 E6 }- ~' W 第2步，每毫秒调用1次触摸扫描。对于电容屏来说，这个函数主要提供了一个计数器功能。并且需要用户在主任务里面一直调用函数bsp_Idle，这个函数主要实现电容触摸屏扫描。
% l8 M& M R3 p3 B7 p, {0 x

/*
Y- t0 O D2 t
*********************************************************************************************************7 a+ Q, ]+ w4 p" N) O, [
* 函数名: bsp_RunPer1ms
5 u* K K: U* V0 U+ A
* 功能说明: 该函数每隔1ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些需要周期性处理
1 j9 z; h o! G1 `
* 的事务可以放在此函数。比如：触摸坐标扫描。" b" F3 Q1 V% M7 u) A; L
* 形参: 无
; a# [ @% k4 A7 V" @+ A
* 返回值: 无
. O$ n4 p1 g/ M* S! p0 v
*********************************************************************************************************
*/
* s, x7 ?; Z- f6 p/ Q
void bsp_RunPer1ms(void)
) S# D7 q0 o8 U/ L* b3 f7 }7 P1 R
{
9 l0 C4 K3 q, T; q
TOUCH_Scan(); /* 触摸屏 */
" q; n9 K' E- |7 t$ L3 ?
}& J0 s6 |( K H
6 X) d: A/ k o0 J! H
/*6 U% ? s$ d) M- s0 [# t
*********************************************************************************************************& h" b. z8 z- g* l& |, M
* 函数名: bsp_Idle
" ?+ P9 D& D8 }. W
* 功能说明: 空闲时执行的函数。一般主程序在for和while循环程序体中需要插入 CPU_IDLE() 宏来调用本函数。
: R8 Y. K( k8 J, a- ` y
* 本函数缺省为空操作。用户可以添加喂狗、设置CPU进入休眠模式的功能。. g0 l- {( x7 x* E4 l/ ^
* 形参: 无& v- k1 A/ o# n2 O; {% h* q# W
* 返回值: 无
) m& h# a4 T" J- B& y
*********************************************************************************************************: L- S! o1 F+ F* z+ i
*/' \& \$ R* H* l, k$ G0 s
void bsp_Idle(void)4 d7 @' y% \6 Q
{
& D+ h6 g1 Z9 p& T
/* --- 喂狗 */6 X# X2 x, E: l1 w/ {) u
$ v( L4 J4 B5 x9 C5 n* D0 s1 M# C
/* --- 让CPU进入休眠，由Systick定时中断唤醒或者其他中断唤醒 */' q1 t* {) m/ X& ^# f5 ?
: T+ F; L3 ^) U1 z
/* 例如 emWin 图形库，可以插入图形库需要的轮询函数 */% C, T- H* b6 H, R; k" K4 j0 v3 E
//GUI_Exec();# \( _; }) W0 @! |) a
+ H9 `( T$ u" g, O5 L
/* 例如 uIP 协议，可以插入uip轮询函数 */
! ~" D$ z9 C6 ?8 D1 o3 u
TOUCH_CapScan();
4 W; r5 d, q/ L0 m$ q: S0 S
}

复制代码

- [& ^" U# t* D  第3步，用户程序里面采用下面的框架进行触摸消息处理。
/ C2 o  a: V$ b3 |0 MTOUCH_DOWN表示按下消息。0 T. E  t5 K) ?$ p4 R/ ?+ q$ Y
: e. E+ y+ I. h; `6 V9 b$ c! m
TOUCH_MOVE表示触摸移动消息。
0 b/ f2 L1 C  N( \3 M2 q6 n8 P
* G7 U$ ?, z* {' g9 S" mTOUCH_RELEASE表示触摸释放消息。
+ ~) c7 o. ^3 @0 D5 C9 ~1 l
根据这几个消息，用户可以在程序里面判断当前获取的物理坐标值是否在设置的区域内来执行触摸操作。
, B+ x; W& ~0 V- H% U2 {: ~2 i5 y( k( u- c

int16_t tpX, tpY;
. c5 X3 h0 w' f6 D
uint8_t ucTouch; /* 触摸事件 */
8 ]% h5 s* p& d; d8 w$ h
" ]- N7 ~& n% O( k7 P o( t- C
ucTouch = TOUCH_GetKey(&tpX, &tpY); /* 读取触摸事件 */
1 c) K0 k4 d/ t& B/ }6 C& ^
if (ucTouch != TOUCH_NONE)6 \& w6 L0 V+ b; f: l7 |
{
4 y2 A: K% \* V% R) Z
switch (ucTouch)
, q6 [+ A3 v7 K& m6 H8 j
{) j+ @( g/ p( M3 Z( `7 u
case TOUCH_DOWN: /* 触笔按下事件 */! X6 `, Y; S: c ?& r1 G
* y0 |" n$ K X, d# P7 ?! q! e) d
/* 在触笔所在位置显示一个小圈 */! V1 c) A! P) O: `) ~$ w6 ]
if ((tpX > 0) && (tpY > 0))+ ?$ r: ~& [. ^, e8 G8 m
{% h5 f- ]3 n/ s G; z' r
7 {" I8 `$ p" e! i3 q4 L
}
" D. B S* d% A, b
break;; v- B) J/ j1 a3 Y; f9 V
; F S% M+ q/ U8 U
case TOUCH_MOVE: /* 触笔移动事件 */
& }) K% P5 H+ c/ Q: S. [
/* 实时刷新触摸ADC采样值和转换后的坐标 */& P1 N. J) {2 j! X. J) X- x
{
( |1 ?( ~( D0 x( V9 N( k Q
/* 在触笔所在位置显示一个小圈 */! b' j7 k8 G( i: M
if ((tpX > 0) && (tpY > 0))1 O5 l6 |0 z. E! s0 P
{
3 H: w! }8 k1 ?8 x; I' p
( |7 Q& v* l& f* p$ Y9 ?
}1 z8 K- c4 p9 ]5 {2 w2 G; _
}
: T9 d7 V" _8 G' M8 x7 g
break;
, b2 v' a K/ q% V' J7 U
& U9 H( ^/ l b2 F. o+ l; f
case TOUCH_RELEASE: /* 触笔释放事件 */
: D* `9 s: \' g, M4 W7 h% ]
/* 在触笔所在位置显示一个小圈 */
$ D' x; W( j# H
if ((tpX > 0) && (tpY > 0))
, y* B$ \. C" N1 I, y
{# Z# z, q5 p1 [2 G4 `
' ]: }9 J, L% D1 M/ o" k5 n9 a4 a
}
; l7 C- p! b0 i9 H
break;
! } T% y% y& p0 C
}
9 y- r& U. f6 ? ?& W+ u+ T) R
}
, d+ M. ~' @# Z2 G5 B6 ~4 F
9 ~9 I5 C# L# M7 r6 Z& C- E6 \

复制代码

54.7 不同触摸IC的识别0 q& N5 X B/ |1 F9 `
由于V7开发板要做不同显示屏的自适应，所以关联了多个文件。自适应方法也比较简单，因为触摸芯片GT911，GT811，FT5X06和STMPE811都是I2C接口，通过I2C地址就区分开了，具体代码如下：3 a5 e6 K. S# J& e! L; \: Z

& q6 z; |+ y% x: f

1. /*
1 ]/ n6 i6 I* d$ O6 I5 i
2. ******************************************************************************************************
$ K/ ?- J5 R2 M
3. * 函数名: bsp_DetectLcdType1 C/ v8 f+ W. @% k1 I1 r! l
4. * 功能说明: 通过I2C触摸芯片，识别LCD模组类型。结果存放在全局变量 g_LcdType 和 g_TouchType
/ k1 D, @* O4 Y
5. * 形参: 无
W" d( Z! D8 K( o. C% Y5 N
6. * 返回值: 无
- A: E. E1 h2 p5 Z6 j* x
7. ******************************************************************************************************
, T R8 v, y; _1 }
8. */
) \7 V- p( k1 @; ^1 A
9. void bsp_DetectLcdType(void)
7 _% M" k) r9 S$ f
10. {0 L* @9 A/ g. M" }: {6 E& O$ e# z& y
11. uint8_t i;" b" X" I l; ?0 E7 T0 A" G
12. ' q8 Z! }0 s: A8 h# v
13. g_TouchType = 0xFF;& H5 O, F9 \2 w' P1 R; g' V
14. g_LcdType = 0xFF;
5 Y4 S+ U4 Y {" j: `0 [5 K
15. 1 v# M4 A a: i' \$ t% b- L" L6 B
16. bsp_DelayUS(5000);
% x4 a8 z' n' c
17.
2 o+ S7 `, v) o- E0 V+ L7 r
18. touch_printf("正在识别触摸屏型号\r\n");
. P7 s6 b* [$ Z4 o# C% X
19. 6 ^$ o0 Z8 y9 R6 |8 c# p4 P
20. /* 50ms，等待GT811复位就绪，才能探测GT811芯片 ID */3 k2 s6 Q! e# @" E. \, P
21. for (i = 0; i < 5; i++)4 B% S K) [& o* N( H
22. { 8 t2 L* V" ?2 d: P1 _* @
23. /*9 g: H; v+ K; t2 |
24. GT811电容触摸板和GT911的I2C地址相同! O" q: ~- d T- B5 v
25. 一般就 0x28 、 0xBA 两种。& c/ R# q8 l7 K: s$ l, R
26. 通过读取触摸IC的芯片ID来识别。
9 E$ W# J4 v- r9 \1 e7 ]
27. */* T. R0 J8 ?$ A c; z8 W
28. if (i2c_CheckDevice(0x28) == 0)
' x/ `7 ~( z! l
29. {5 R) _/ j' @) F6 ?! Q; f. d
30. uint32_t id;; {' @7 D% Z8 D
31.
0 L t2 F( k6 s3 I# t* _ w
32. bsp_DelayUS(500);
$ {4 |8 t4 F' Z7 P- \
33. g_GT911.i2c_addr = 0x28;
# K! Y1 L# ^! B
34. id = GT911_ReadID(); 2 k, m2 g3 W5 |* F+ O' A
35. if (id == 0x00313139)# j1 N4 i, o3 u7 t& @/ e: Q
36. {
7 f' u: h) p$ B7 r0 w; W
37. g_GT911.i2c_addr = 0x28;
' _6 K) f" s: K- S$ p* g- x' {
38. g_TouchType = CT_GT911;& s" E+ c# w, Y0 X, k) N7 _
39. g_LcdType = LCD_70_800X480;
! S. B- z1 E- z+ j$ I2 L9 Y* u
40. touch_printf("检测到7.0寸电容触摸屏GT911(0x28) 800x480\r\n");: p' p- O& j$ E( [
41. }) o9 Q! Z* E h% W
42. else /* GT811 */) g, u/ N: F' }
43. {( ]- `0 ^: M6 D8 E) ^) b t
44. g_GT811.i2c_addr = 0x28;2 l$ r/ g9 J+ `* h8 N' p0 f
45. g_TouchType = CT_GT811;
& o$ _0 _+ |- T3 W% y$ Q+ \
46. g_LcdType = LCD_70_800X480;
9 R! X9 p$ i! t d9 S0 O" I- A$ }
47. touch_printf("检测到7.0寸电容触摸屏GT811(0x28) 800x480\r\n");
8 h! D _$ e& a' ?1 Z
48. }! m7 l: ?' f2 Z6 F6 h/ r
49. break;
; n" \! v& s- S! f
50. }9 B, J" t" j% v1 ]7 i
51.
\: t' @ g- C. g0 g) ?, r3 a
52. if (i2c_CheckDevice(0xBA) == 0)
% k* B7 I) R5 O! t
53. {% R6 p7 T0 F7 A
54. uint32_t id;
) h* Z. s; z- u( v# y U# Q* T
55.
2 E* m- f# A. I3 N2 [% u( Z
56. bsp_DelayUS(500);5 `2 q2 w# ]" T7 M
57. g_GT911.i2c_addr = 0xBA;
5 T1 w: }9 U* ]& O }7 @6 S
58. id = GT911_ReadID(); : A2 k, v$ B# G& z$ x$ b
59. if (id == 0x00313139)
% Y! |+ l! U5 W$ x8 L
60. { T1 H) G' [, X. u3 M* R% a$ M+ @
61. g_GT911.i2c_addr = 0xBA;$ f. e, B) J" h# i
62. g_TouchType = CT_GT911;& |3 x- b; h; h) B0 z
63. g_LcdType = LCD_70_800X480;
64. touch_printf("检测到7.0寸电容触摸屏GT911(0xBA) 800x480\r\n");5 B! c: n: V* o7 T4 {
65. }: G2 a. w3 e7 x5 K+ v' r
66. else /* GT811 */
+ s: A6 s6 [; ?. n- _- q
67. {
4 W2 q* E4 Z; }0 H- g1 Z7 j" `
68. g_GT811.i2c_addr = 0xBA;
# x1 n, ?5 [9 a
69. g_TouchType = CT_GT811;+ }. @* W4 N2 D% y8 B! V
70. g_LcdType = LCD_70_800X480; ) p% h; e( Q$ E& G5 d
71. touch_printf("检测到7.0寸电容触摸屏GT811(0xBA) 800x480\r\n");
! e: g6 U+ l) f& @8 `
72. }
$ I: Z4 l9 [3 i& v6 C1 {" l" f
73. break;: w8 d5 s8 \1 C9 J- S# S' M
74. } - X/ W- S6 F) R5 @, s5 x
75.
0 i; @$ ]! F5 a8 b" w& {: w2 V
76. /* FT系列电容触摸: 4.3寸id = 0x55 5.0寸id = 0x0A 7.0寸id = 0x06 */
1 z$ W! g& B; ^9 ]
77. if (i2c_CheckDevice(FT5X06_I2C_ADDR) == 0)
" l3 R7 U5 T- `* w& g$ ^
78. {: y& f2 e: q7 Q2 g7 s+ w5 D
79. uint8_t id;
: ]: p6 u: n$ O
80. ! b. S" f9 a+ k j+ p% {$ Y
81. bsp_DelayUS(50000); /* 延迟50ms */
K0 m# Q% j1 W) w% P6 y
82. id = FT5X06_ReadID();
& D8 e2 o2 t. I l. ^
83. if (id == 0x55)4 @ q) |% D) R; ^1 Z8 v
84. {
3 D$ W8 K( ^8 H, X# _
85. g_TouchType = CT_FT5X06;
e0 y" N0 C4 |, E
86. g_LcdType = LCD_43_480X272;
S9 B" M6 r# J! p; d) w: T
87. touch_printf("检测到4.3寸电容触摸屏\r\n");
9 i! E0 }; K; \7 s) J. D" c
88. }
4 X6 H8 c( ^( N2 w8 v G) C5 D
89. else if (id == 0x0A)9 Z, T! D0 I/ y* Z5 x2 r
90. {
; g- `, v' C+ Y$ D8 e/ f$ @: n: n
91. g_TouchType = CT_FT5X06;
4 W! ^- ^5 v) ?, j9 P! @3 M
92. g_LcdType = LCD_50_800X480; 5 G8 R4 _8 W6 c7 ?4 T- R4 H
93. touch_printf("检测到5.0寸电容触摸屏\r\n");
% p! |2 T9 s2 q+ c) F4 i# m
94. }+ g! g" P5 p3 D% T
95. else /* id == 0x06 表示7寸电容屏（FT芯片） */! e1 [* f7 p& P) y8 G! o
96. {
! H9 v; w7 a6 b- Z
97. g_TouchType = CT_FT5X06;' l1 E4 F0 M2 z& B; J9 r
98. g_LcdType = LCD_70_800X480; # \( H& ]3 ` U3 r4 {- Y
99. touch_printf("检测到7.0寸电容触摸屏FT\r\n");
- W; U4 H: A9 a3 A; I
100. }/ p+ w8 M. x7 p* ]
101. break;9 t% V7 v% E0 Q' z$ J6 Q# T9 A* ^
102. }
6 D a( c9 n& U) o3 w2 }
103.
7 {6 N& ~& y2 w ]
104. /* 电阻触摸板 */ 5 a& ~3 O0 K" O! b1 m, B
105. if (i2c_CheckDevice(STMPE811_I2C_ADDRESS) == 0)
" |% J6 `( C9 ]# h# B7 l a
106. {
. U7 ?& x0 Y P' c
107. /*
) p0 v" x2 \( ?
108. 0 = 4.3寸屏（480X272）
8 }2 [0 A& }5 B) z6 |3 u! Q
109. 1 = 5.0寸屏（480X272）( A9 |% v e- G- G: d( W$ q
110. 2 = 5.0寸屏（800X480）
& ?0 n" O* G, |; U; n
111. 3 = 7.0寸屏（800X480）/ S2 }' m: T8 ]2 [
112. 4 = 7.0寸屏（1024X600）
0 Q- S! m3 d) I( @# H
113. 5 = 3.5寸屏（480X320） + K4 a! m. U! p+ B
114. */
8 g! `. O* Z7 d: y# x3 j* f1 Z, Y
115. uint8_t id; ' ]6 p# Q- I4 a7 }+ B+ r
116.
$ b: m9 H5 U4 S- z4 r* v! v
117. g_TouchType = CT_STMPE811; /* 触摸类型 */
$ R. c0 K8 \: O7 |# |( s5 ]
118.
; L3 J" [! c# U$ S& P4 J/ ]' l0 x/ k: G
119. STMPE811_InitHard(); /* 必须先配置才能读取ID */ B$ z0 T5 \8 Q2 G4 g: R
120.
+ H! n2 X: p' N C
121. id = STMPE811_ReadIO(); /* 识别LCD硬件类型 */
# d; a6 b+ o% P
122. $ ~4 ]9 @8 K) f
123. touch_printf("检测到电阻触摸屏, id = %d\r\n", id);6 S7 C, F7 C! [- n; i
124. switch (id)
- x j1 F$ k6 V: L. j
125. {' r- N6 M" I1 g1 ?0 W8 q
126. case 0:- n1 _# G, v0 w" i* j
127. g_LcdType = LCD_43_480X272;! z0 R6 |% ?" Y: _$ h
128. break;; j5 k7 J* |! ^" O& P6 w7 p4 Q# L
129. 7 ^1 g; `* S: j' W3 F1 F
130. case 1:
# J6 [# \1 i4 \& b5 Z) d- _
131. g_LcdType = LCD_50_480X272;8 F! X; H1 @5 v9 R( o; H" p
132. break;
& U, ^+ [/ x8 T) B( w' P! X
133. / e9 S8 t# @- R5 J; M7 }- \
134. case 2:' R! M' z3 e7 z* B4 T/ M
135. g_LcdType = LCD_50_800X480;! Y e8 W0 K% x' x' c1 e+ l- g' i
136. break;
; ?1 K" |2 y1 U7 J
137.
6 u6 P! U- J) ^! ~, N% }$ q2 i
138. case 3:+ T3 c$ x! X1 a9 r8 T1 ?8 ]
139. g_LcdType = LCD_70_800X480;7 |2 ?0 X# ]- J+ T! e. B
140. break;
K- j% A2 i% p* q) n
141.
0 x3 b# V- @' E& \ n7 L
142. case 4:2 I# u' i+ U U) b, ~. T
143. g_LcdType = LCD_70_1024X600;
% Q, }. z. m: S" L8 X! L; b7 W( `. Q" ~
144. break;
4 v- O1 \# n1 @, M
145. / m+ c0 h$ {% j& _, K: K
146. case 5:
1 n4 [* @- L' k# q8 H
147. g_LcdType = LCD_35_480X320;
148. break; : x4 r8 W/ k0 \
149.
6 ]5 S+ t% ~. p
150. default:
9 ] `! O9 K _
151. g_LcdType = LCD_35_480X320;
- C. H7 \# ], J& j- r
152. break;: O1 p# V( K8 N) `, V" b* Z
153. }
1 F; q r$ Y7 r3 y8 c- P
154. break; 7 N0 K0 t. ~- w) t$ M
155. } 5 K! D4 P$ I( H- z9 m
156. ( m. `; O+ F2 k$ @: t7 f# v) O
157. bsp_DelayMS(10);
0 ?0 E$ a0 ^( Z, T0 [
158. }
9 K, Z0 _% y1 B1 J
159. ; p1 H& [/ ]0 }4 i; P1 |8 x
160. if (i == 5)
" S4 U: [$ f. H( e
161. {
' v) A% i! l2 j& I" z7 n
162. touch_printf("未识别出显示模块\r\n");
1 u2 L0 ?! q, ^* W) o
163. }' ^4 C3 R" [% {! Z% S& D+ H, U) i
164. }

复制代码

( p$ s- [. C+ J+ V( C' b9 |下面将程序设计中几个关键地方做个阐释：
# L- W2 i6 N7 F6 U0 V( U. |; u7 `! Z0 L3 N
  第21行，上电后，这几款传感器一定要延迟一段时间才可以正常读取ID，所以这里做了一个for循环做检测。
& Q/ x9 \, [. b; F6 k" q  第28-74行，GT811电容触摸板和GT911的I2C地址相同，一般就0x28和0xBA两种。程序里面对这两个地址都做了检测，然后通过ID区分是GT811还是GT911。1 s4 m, R; {0 ~. M( b
  第77-102行，FT5X06电容触摸板检测，通过ID区分不同分辨率。+ @; \# s; a4 J! {' `6 B/ Y8 ]) Z
  第105-158行，STMPE811电阻触摸屏检测，通过函数STMPE811_ReadIO返回的IO状态可以识别3.5寸480*320分辨率显示屏，4.3寸480*272分辨率显示屏，5寸480*272和800*480分辨率显示屏以及7寸800*480和1024*600分辨率显示屏。
  第160-163行，用于调试。

54.8 LCD触摸移植和使用
LCD驱动的移植与第51章51.7小节相同，这里重点说下触摸部分的移植。

通过前面的讲解，移植触摸驱动到自己的板子上，最简单的办法是将开发板上与触摸相关的文件全部移植过来，然后在这些文件的基础上进行修改。下面分两种情况进行说明：

  电容屏触摸的移植比较简单，如果用户用的触摸IC跟开发板一样，直接拿来用即可，如果不一样，需要先将触摸IC的驱动实现，然后按照开发板提供的GT811、GT911和FT5X06的触摸扫描函数，照葫芦画瓢实现一个即可。
  电阻屏的移植稍麻烦些，如果用户用的触摸IC跟开发板一样，直接拿来用即可，如果不一样，需要先将触摸IC的驱动实现，然后仿照TOUCH_STMPE811.c文件提供触摸按下状态函数，X轴，Y轴的ADC数值读取函数和清除触摸中断标志函数。最后用重新实现的这几个函数替换bsp_touch.c文件中的原函数即可。另外要注意一点，这种方式实现后，虽然触摸校准依然可以使用，但是开发板的触摸校准参数保存在EEPROM中，用户可以根据自己的实际情况选择存储介质。

当然，如果大家不想用开发板实现的方案，想自己重新实现一个，也是没问题的。

54.9 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：

  第1阶段，上电启动阶段：

这部分在第14章进行了详细说明。

  第2阶段，进入main函数：

  第1步，硬件初始化，主要是MPU，Cache，HAL库，系统时钟，滴答定时器，LED，串口，LCD，SDRAM等。
  第2步，LCD应用程序设计部分。通过按键执行功能，同时LCD界面做了一个简单的画板功能。

2 d1 ~* h- K- O4 G: H+ l  \; m54.10       实验例程说明（MDK）
配套例子：

V7-034_LCD的电阻触摸和电容触摸（电阻触摸支持2点和4点校准）

实验目的：

学习LCD的电阻触摸和电容触摸。

实验内容：

电容屏无需校准，电阻屏需要校准。
LCD界面实现了一个简单的画板功能，方便检测触摸是否准确。
启动1个200ms的自动重装定时器，让LED2每200ms翻转一次。

LCD界面显示效果如下：

上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1

程序设计：

系统栈大小分配：

RAM空间用的DTCM：

硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：

/*: |1 K/ G0 X; j
*********************************************************************************************************
2 J. j( R! c( z) X$ I2 Q
* 函数名: bsp_Init9 ~9 J4 a9 S+ p2 J2 A4 m% f& S7 {
* 功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
2 j! K1 z! ~* N8 B: h
* 形参：无7 f# s4 D# z8 N4 T! R
* 返回值: 无
% q+ Q) C# e) j. t3 J+ `* b
*********************************************************************************************************. I' G+ w8 h1 @
*/
/ k+ O1 w4 W& ~4 l. J
void bsp_Init(void)
{. Q# X/ _2 l+ h
/* 配置MPU */
: A. D# K% A4 Z: O
MPU_Config();
, e5 e3 o: \* ]% T. a
: O4 v9 z8 D* f- E9 P
/* 使能L1 Cache */
5 x7 R0 a& [' f9 c7 j1 d6 F. c
CPU_CACHE_Enable();
( W& y7 m+ U K5 P$ H" W8 L8 _
& p0 ?# u; X/ p& ]4 {
/* * E# E# ~! c& }/ Q- k% ]
STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
, N5 f Z$ F/ C, Y- y$ L5 D$ l
- 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
% y8 z, } J# m! @: y7 h. _% ?* b
- 设置NVIV优先级分组为4。
2 [ D! k7 U0 F8 `; a8 I, k$ b
*/) n0 {6 B; m4 _% v4 c" p4 `0 i
HAL_Init();% z3 [- O0 P. b
0 v2 v% b4 H& X; c7 J
/* & d: k% L0 n+ u! H5 K
配置系统时钟到400MHz% H& K2 F2 f& t" W
- 切换使用HSE。
* }5 B% L" Y# N; d- E9 e) C
- 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。, z! E5 R/ _, N) q5 p4 Z; U' J
*// S% f5 |! D6 o# e- r
SystemClock_Config();
) a6 {) R( ^' K. c! G+ g
% L _% T% `- {" r1 p
/* 4 S+ z. B. g5 \, ^8 y8 t- |
Event Recorder：
4 ~% p- e3 e- c" F
- 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
$ w) u) z6 ?2 F9 G9 H
- 默认不开启，如果要使能此选项，务必看V7开发板用户手册第8章) Z' ~0 z. M8 B- ^1 R$ ?/ y( }
*/
+ g1 f9 E/ W; a2 [9 [; i- B
#if Enable_EventRecorder == 1
3 A( b! t& T( Z! C" ^' ^4 B% z
/* 初始化EventRecorder并开启 */
! R+ S( L, \7 e# |+ i4 E
EventRecorderInitialize(EventRecordAll, 1U);. z8 v5 y1 b, I- Y4 i$ X
EventRecorderStart();; q$ {7 ~! X* Z7 M) q8 \
#endif& {6 t( f! }9 f
& x0 S# ^5 Y8 {# C' X3 ]# ]+ R
bsp_InitKey(); /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */( F( ~4 q5 R3 z' v/ K
bsp_InitTimer(); /* 初始化滴答定时器 */: m9 f* G" M& y) S5 o6 r" k
bsp_InitUart(); /* 初始化串口 */
+ M# r/ w4 C, ]- }4 R9 m
bsp_InitExtIO(); /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */
T6 x4 ?: T* h0 L" |* g* C9 _$ e- j
bsp_InitLed(); /* 初始化LED */ {' I* M" f6 Q* ]- i3 g
+ v$ D+ M, r0 A5 q9 N! T. o7 F
bsp_InitI2C(); /* 初始化I2C总线 */
. f8 j) S. o8 Y1 F. Z
TOUCH_InitHard(); /* 初始化触摸芯片，LCD面板型号的检查也在此函数，所以要在函数LCD_InitHard前调用 */ + f1 A. u; A, X' T4 Y1 M
LCD_InitHard(); /* 初始化LCD */6 ?! M2 Y$ N+ e9 l5 f/ d
}, ~. b% o5 M/ y

复制代码

MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM），FMC的扩展IO区和SDRAM。由于SDRAM要用于LCD的显存，方便起见，直接将其配置为WT模式。

/*
; H8 m5 b; t/ \' Q
*********************************************************************************************************
0 v* ]8 K, s7 G" M2 g1 b$ ?2 J
* 函数名: MPU_Config
$ \- a& K$ A* {' s
* 功能说明: 配置MPU, K& S E5 T) E6 k2 L, j
* 形参: 无
1 |% a& Q* G: l
* 返回值: 无# U# h9 m7 v) t, c0 r8 j2 z
*********************************************************************************************************
5 c# }! r6 X) R4 L0 |
*/
& c! K/ r* F' ^5 I
static void MPU_Config( void )
0 _& O. i; A: y Q. T
{
5 z( e5 y4 Q6 t) V. s; s
MPU_Region_InitTypeDef MPU_InitStruct;7 w# E# q& O0 V1 O- `! Q# [3 B: v
. I1 R4 x+ e: t6 R8 u3 |9 K
/* 禁止 MPU */
$ k3 t) G& n) @+ @2 b
HAL_MPU_Disable();
- p1 `$ m: f' q8 i: ^" }6 M
`+ {* Q/ }# x+ N- o: u% C% }7 S
/* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
9 m; j, B3 K! Z- p
MPU_InitStruct.Enable = MPU_REGION_ENABLE;' ~- q" q/ t; [: `1 N- J7 d1 s3 o
MPU_InitStruct.BaseAddress = 0x24000000;
9 D' I5 i5 ~6 \4 w: k0 C; ~
MPU_InitStruct.Size = MPU_REGION_SIZE_512KB;
# k# K O; r# C
MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
4 F' b5 p3 t. U5 E; h- `
MPU_InitStruct.IsBufferable = MPU_ACCESS_BUFFERABLE;. m4 m: ?; L/ F) P' g$ d0 M. Q
MPU_InitStruct.IsCacheable = MPU_ACCESS_CACHEABLE;! x6 b9 }7 [7 M8 {
MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;- Y7 G" j' G J1 T" k1 c' h
MPU_InitStruct.Number = MPU_REGION_NUMBER0;/ v3 d; z O5 F4 F5 M. F5 A. ]
MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL1;8 H6 }) {& m4 U2 Q
MPU_InitStruct.SubRegionDisable = 0x00;
5 s5 y3 u% K o7 D% @
MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;
- Q3 ]" @( u: T' Q, N) E0 Q1 Z9 J5 Y
1 W" R/ a; q4 U/ i
HAL_MPU_ConfigRegion(&MPU_InitStruct);
$ ]' l3 O- G7 D" U
- R5 M$ F+ E4 {" H$ U
# C7 y$ O+ r- s8 _7 L( e4 e
/* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */, c! L, n% w5 w3 }+ P2 x
MPU_InitStruct.Enable = MPU_REGION_ENABLE;, X) T" n) u+ h! q+ H
MPU_InitStruct.BaseAddress = 0x60000000;
+ \' W) g6 c ~& p8 c& g% I
MPU_InitStruct.Size = ARM_MPU_REGION_SIZE_64KB; % J- c4 Y3 U! s( w5 z
MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;4 B& t1 ?* ~. \1 ?1 a N
MPU_InitStruct.IsBufferable = MPU_ACCESS_BUFFERABLE;
- w( }9 f+ a8 j2 ]/ A. r8 V' I
MPU_InitStruct.IsCacheable = MPU_ACCESS_NOT_CACHEABLE;
. h0 `# s1 ]: t0 w. j
MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;" U+ `1 e \) Y4 H, T- G9 J
MPU_InitStruct.Number = MPU_REGION_NUMBER1;4 g% x# N/ s# P# r1 o- a' |, [5 X* O
MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;
5 _/ ~" ]8 R7 E( Y6 [& f
MPU_InitStruct.SubRegionDisable = 0x00;
+ T$ I/ l5 a0 ?1 d
MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;
/ I4 g8 @) p4 c. U
+ G1 b6 t/ n: N& J" \1 F& L
HAL_MPU_ConfigRegion(&MPU_InitStruct);1 `$ [' n$ l d0 p( @% e. @
. M4 O U1 H8 y* @. R
/* 配置SDRAM的MPU属性为Write through, read allocate，no write allocate */
7 T# P. m9 X7 T" j* i/ ^7 m4 z
MPU_InitStruct.Enable = MPU_REGION_ENABLE;& B- P5 }8 L: C6 Q" S) `- B- S+ Y
MPU_InitStruct.BaseAddress = 0xC0000000;
) y/ h1 e; F; N* V5 C# F
MPU_InitStruct.Size = MPU_REGION_SIZE_32MB;
) u& }; I- j* O5 A* i
MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
$ X: J6 {; C9 K2 y/ {2 k, g; y
MPU_InitStruct.IsBufferable = MPU_ACCESS_NOT_BUFFERABLE;5 O: M3 b7 `' D" a0 G* Q: m
MPU_InitStruct.IsCacheable = MPU_ACCESS_CACHEABLE;6 D0 Y2 g+ c+ {/ Z8 o+ [7 }4 u
MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
1 I/ B0 X0 M3 w+ z ]
MPU_InitStruct.Number = MPU_REGION_NUMBER2;
$ T- L8 M0 d$ s2 h" `" M1 g- j! m
MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;( F2 Z. B; a1 L8 O
MPU_InitStruct.SubRegionDisable = 0x00;
4 q! H) s; t I, `% n g; W, g
MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;' j, X" `! C4 a7 d; @0 b
# \/ b5 O2 E" L0 `5 G
HAL_MPU_ConfigRegion(&MPU_InitStruct);
# g5 D% S; l9 z3 m! J8 F- U
( A' }. A8 y9 U( s
/*使能 MPU */
* D0 s4 H d+ ~" g$ p7 L h& m* w
HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
( R" P6 S/ R. b4 B2 X# J: ^
}
+ R5 `! @* Q" s2 J8 ^- x6 B
! s. a& n* @7 J, U) R
/*6 J( `4 I' c; v) K
*********************************************************************************************************3 {% ?+ \6 Y( T- Q1 z: o
* 函数名: CPU_CACHE_Enable4 m3 n/ F* u: V3 u" F
* 功能说明: 使能L1 Cache
" j# r! U0 Y2 I" K% R7 p( {
* 形参: 无/ l8 t3 X' k7 n. W
* 返回值: 无5 Q. \( o+ ?; `: k* X1 b! M' ]
********************************************************************************************************* y+ h0 ]9 P+ M) a
*/
3 V$ F7 b- k( s
static void CPU_CACHE_Enable(void)1 b9 s7 n4 i7 c C! R
{
8 a. m2 k# u5 }; U$ M6 @6 D" a
/* 使能 I-Cache */1 k6 n6 C" l, _
SCB_EnableICache();
, l5 c5 _- E8 x4 A, }2 o! y# T$ Z
7 \* J b! S; S( A7 ]2 Y9 k
/* 使能 D-Cache */6 F' m. w ^# E* i
SCB_EnableDCache();
' M8 p6 H2 l8 F$ e/ t5 q- ^5 g- Y
}

复制代码

  主功能：

主程序实现如下操作：

  LCD界面实现了一个简单的画板功能，方便检测触摸是否准确。
  启动1个200ms的自动重装定时器，让LED2每200ms翻转一次。
  摇杆上键，增加LCD背景光亮度。
  摇杆下键，降低LCD背景光亮度。
  摇杆左键，电阻触摸屏校准。
  摇杆OK键，清屏。

/*" J, R7 f0 P* [: Q$ q/ Q
*********************************************************************************************************
$ }# R. F: g5 e o& U1 N: X
* 函数名: main
, p$ o- s) a1 @* D3 y) C
* 功能说明: c程序入口0 E8 _6 w, t1 O" [
* 形参: 无! f' ^" P0 A: w$ k$ [4 N( {
* 返回值: 错误代码(无需处理)
8 ]/ r# J( L4 c9 g& k' v, I
*********************************************************************************************************
" \- M$ R3 Y9 q1 V: x q9 F
*/
, L' C- J- D, J
int main(void)
8 R- D& x* w% Y+ Y9 w u& `
{
& B$ @ i0 k/ T9 Y9 `% f
uint16_t ucBright; /* 背光亮度(0-255) */
2 I( h9 t5 @3 x4 P! }9 Z6 T7 `8 a
uint8_t ucKeyCode; /* 按键代码 */
4 b3 b; I! ]- m2 g5 Q
uint8_t fRefresh; /* 刷屏请求标志,1表示需要刷新 */# S9 u# f# V# h/ m, E$ K
FONT_T tFont; /* 定义一个字体结构体变量，用于设置字体参数 */ Z) x" Z2 T7 j. C4 M! [( Y# Q
char buf[64];/ M& e: I, K5 R k
uint16_t usAdcX, usAdcY;3 J0 I+ e1 O) R) z
int16_t tpX, tpY;
( V9 p& W" K: j; p, s: O
uint8_t ucTouch; /* 触摸事件 *// e( k6 P6 [' S+ q. w6 r6 X
; j4 l- z1 Q2 t# _
6 n$ B C! F3 a+ x7 w1 q. w
/* 设置字体参数 */9 p' w+ s) \' _. b$ [) i8 I" E# {
{
* a* T! H, [" t7 I: |
tFont.FontCode = FC_ST_16; /* 字体代码 16点阵 */
9 T: Q4 t) u7 s- m8 P: h
tFont.FrontColor = CL_WHITE; /* 字体颜色 */: C( N5 q, X: L3 I8 H
tFont.BackColor = CL_BLUE; /* 文字背景颜色 */
8 x2 @ D/ q# E, Q
tFont.Space = 0; /* 文字间距，单位 = 像素 */
6 {4 ]' J/ P0 P9 B" e p
}
: z ?% ~% e2 k( b% |+ h/ T
! _$ }, P h! a& J
bsp_Init(); /* 硬件初始化 */
4 E+ u0 P0 a' u/ W; P: D1 j( E
PrintfLogo(); /* 打印例程名称和版本等信息 */- q# k J' v8 A) z
PrintfHelp(); /* 打印操作提示 */* ]) u; S! ?6 G2 A# V/ S
( Y& Y9 O' N( u; Q9 _
/* 延迟200ms再点亮背光，避免瞬间高亮 */
+ q, A6 y1 M+ @ w5 t8 c
bsp_DelayMS(200); 3 C! v( s* \7 n3 z( Q1 _
! l; u, f' m" g
DispFirstPage(); /* 显示第1页 */
7 M5 h& j. K* h, |: t# Z, {3 l! B3 M
% p+ Y: S, v# Z2 t
/* 界面整体显示完毕后，再打开背光，设置为缺省亮度 */! z6 h. o$ y) g P2 n/ H& Y
bsp_DelayMS(100); 0 A1 o1 `) V+ j/ r/ n$ x, f
ucBright = BRIGHT_DEFAULT;
: D% y; G5 w, h. s6 w4 W
LCD_SetBackLight(ucBright);
2 q y: I0 w) p7 L) ~
$ W# e( o- T# M7 ?) b& x4 H
bsp_StartAutoTimer(0, 200); /* 启动1个200ms的自动重装的定时器，软件定时器0 */" K, K9 B9 p% m( s/ B$ B
7 \7 ^3 U0 o7 o: @6 B
/* 进入主程序循环体 */$ K2 I0 t; \: v' ^' q. Z* \: ~
fRefresh = 1;
/ h0 ~ Y' \$ ~) H6 {
while (1)
$ u' \* h. q0 @- L$ b+ S. w" d! Q3 q2 J
{
2 T* v; [2 V- e7 x- n. T8 g, W
bsp_Idle();
" J% G4 ~$ w9 K+ n9 K
4 P$ Y# S( A0 J' F
/* 判断软件定时器0是否超时 */1 k0 F2 d, @* \' w; n( i
if(bsp_CheckTimer(0))
$ h; ?5 i# e9 R: m* T! P# l& t
{6 V9 h b1 F1 q& y9 h$ W1 | E
/* 每隔200ms 进来一次 */
) q4 o2 ~5 M& `, j$ g: {
bsp_LedToggle(2);
: J" ^' L6 L, x8 d
}
* D, r! h1 o3 r8 z# `6 l
Y3 A1 F9 ?9 ?! O0 Z1 g
if (fRefresh)
p9 ~% y9 G& E6 q2 w) L% @6 Q" l# E
{* }) m# J! y2 l) y
fRefresh = 0;
% F. ?- X& L% T {1 H
5 ~8 k* s4 w+ r' p$ y* m) Z
/* 实时刷新触摸ADC采样值和转换后的坐标 */! }9 m6 L+ d* Y* k& r- n5 {
{
6 W7 {9 G& e, M) h+ M) @% M
5 C. ?! I9 g) R- @7 p- a$ x3 C
/* 读取并显示当前X轴和Y轴的ADC采样值 */
" o8 X1 w5 g( _- C
usAdcX = TOUCH_ReadAdcX();
_( t7 K3 U4 M a5 U
usAdcY = TOUCH_ReadAdcY();
$ ?5 l* a9 q5 z) i, L4 x7 v! e
sprintf(buf, "触摸ADC值 X = %4d, Y = %4d ", usAdcX, usAdcY);, D0 Y9 ~' F& ]& Z/ O P, @
LCD_DispStr(5, 40, buf, &tFont);! H1 _# @8 Z p
( G: h8 O. y5 P7 t, O
/* 读取并显示当前触摸坐标 */" N/ i% @* s) U) o4 _ R
tpX = TOUCH_GetX();
) j) ~0 V3 P" {
tpY = TOUCH_GetY();# p) {; S' q# z' [: k+ v+ s
sprintf(buf, "触摸坐标 X = %4d, Y = %4d ", tpX, tpY);, b7 R K6 u, B, ?5 b7 k: d: P
LCD_DispStr(5, 60, buf, &tFont);( U# t& u/ n0 J5 e3 I
) m# |5 ~. Z' W/ g/ A; r1 h
/* 在触笔所在位置显示一个小圈 */
; ?8 H9 y8 a% ^
if ((tpX > 0) && (tpY > 0))& m5 t, F$ C4 d* L! v4 R+ j! u0 k
{$ d5 E; @# U: X" `$ U
LCD_DrawCircle(tpX, tpY, 2, CL_YELLOW);. I" y) D$ s# Z! y0 g1 ^; w
}
& Z$ V. r8 e! N# S% c9 Z
}: C$ X% d6 p6 n- Y+ x8 l" P6 t$ l
0 B9 U7 w2 V& A/ I4 D
/* 在屏幕边沿绘制2个矩形框(用于检测面板边缘像素是否正常) */
( X1 S+ [- K) }3 E# {6 w
LCD_DrawRect(0, 0, LCD_GetHeight(), LCD_GetWidth(), CL_WHITE);
4 f6 c0 w3 l2 y. G: k. ~$ N! R. ^
LCD_DrawRect(2, 2, LCD_GetHeight() - 4, LCD_GetWidth() - 4, CL_YELLOW); T! @1 ^" G1 j
8 l- C: }! {* X
/* 显示背光值 */) L5 y3 l* ]0 c7 _# {: e0 b
sprintf(buf, "当前背光亮度: %3d", ucBright);
8 _2 p9 L8 O k
LCD_DispStr(5, 80, buf, &tFont);/ \/ L; u7 \8 M, B' X- A
}
" Y+ F5 M5 h' c
7 t V4 p6 B" ^$ i5 K" u9 [
ucTouch = TOUCH_GetKey(&tpX, &tpY); /* 读取触摸事件 */7 N6 A+ X) S" o( M {$ f, ~
if (ucTouch != TOUCH_NONE)
4 P9 |- v5 \0 G% D( J6 j9 g
{
5 o1 y' F8 R @# n; M
switch (ucTouch)
& m5 L. C( H# S
{
! i4 o9 n2 w; @5 y$ E2 O
case TOUCH_DOWN: /* 触笔按下事件 */
! ^. `3 [0 a' s G! g. \6 a
4 q4 ~/ C5 r: \/ ?" o0 x) z. G
/* 在触笔所在位置显示一个小圈 */
2 H; x6 }0 T, w9 j& L
if ((tpX > 0) && (tpY > 0))% j U: M' p1 L" N# T' [
{; Q/ K* R3 G' S: |
LCD_DrawCircle(tpX, tpY, 3, CL_RED);. n Y: j# v/ H) ]
}2 j: f1 _) B4 G1 M8 n
break;
g2 a# o: e) J4 t5 l$ w7 [5 ~$ o
4 ?/ Z% r0 K( ~ ~# l
case TOUCH_MOVE: /* 触笔移动事件 */
4 X) n/ _ m8 v% p8 s. z
/* 实时刷新触摸ADC采样值和转换后的坐标 */% z3 I P" f" P5 n) q
{
/ `5 E; Q( K$ w
/* 读取并显示当前X轴和Y轴的ADC采样值 */# G& E3 h+ w& D$ K
usAdcX = TOUCH_ReadAdcX();
# O9 V3 s: V; T- u9 X
usAdcY = TOUCH_ReadAdcY();
# Z/ {: A, \* W) P
sprintf(buf, "触摸ADC值 X = %4d, Y = %4d ", usAdcX, usAdcY);. \ y, ~5 V' U) }0 P! J
LCD_DispStr(5, 40, buf, &tFont);
& D! I* m' A5 g* B0 }) z+ g
% Z: I( q5 G/ ~/ U! ^& \
/* 读取并显示当前触摸坐标 */
; `5 ^7 Y( x8 E1 Q' ~( e4 B3 ^
//tpX = TOUCH_GetX();4 C) ]! m+ @' s* R
//tpY = TOUCH_GetY();8 F# m$ l: B5 }% k- ?
sprintf(buf, "触摸坐标 X = %4d, Y = %4d ", tpX, tpY);' L( x E. Q: M: W x
LCD_DispStr(5, 60, buf, &tFont);& b7 B& I+ F8 K# r
/ Y& \/ L. n6 L( S1 g
/* 在触笔所在位置显示一个小圈 */
/ r3 q: T/ }4 n2 g: O% S8 [3 R
if ((tpX > 0) && (tpY > 0)) X" i" T% \' c
{
) T4 |( Z5 f5 E" |+ o" D
LCD_DrawCircle(tpX, tpY, 2, CL_YELLOW);
8 _: L! a# ^2 n; O+ N( E
}
4 H+ c J1 X" d. ~) ^, r& ?, W3 ^- ^
}0 W: |$ c; I* ^% l/ J/ R, p# T- H
break;/ j. q6 N5 U4 s% k
1 ~, O$ D% z/ q& ]
case TOUCH_RELEASE: /* 触笔释放事件 */
5 m/ J9 U$ @: V/ m C. g
/* 在触笔所在位置显示一个小圈 */) u: x9 `$ \; _ u: z4 \" D
if ((tpX > 0) && (tpY > 0))
; M1 z& L- z [& l) |! _% }5 M
{2 C, T( `* H! ~/ M1 x1 T
LCD_DrawCircle(tpX, tpY, 4, CL_WHITE);, [5 C. ^. `/ v8 C8 L6 }
}
b% } |% `4 @# h1 }8 X
break;. _* A% V: u9 H! b! d9 y
}: l8 N- {4 ^' d4 L9 ~! Z
}
$ U2 ?) q! _' V" _ t: }9 c
: x# }0 {* R' L: o2 e6 w0 J
ucKeyCode = bsp_GetKey(); /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
* t9 {0 I! \2 D, H' S$ {3 Q# B
if (ucKeyCode != KEY_NONE)3 C$ T" B |: D! \, j
{4 Q- [% }, `! N& q J) o* o
/* 有键按下 */( U) D4 J k; h& y3 P4 r6 f2 e! F1 W: _
switch (ucKeyCode)
# ?/ ]+ B' I+ C
{
# S0 H+ s g% n! v0 q6 g2 ?) Q
case JOY_DOWN_L: /* 摇杆LEFT键按下, 2点触摸校准 */
9 M& F2 u9 ]4 G& ~3 ^
TOUCH_Calibration(2);
: o3 k, {' Q1 l& Q V* {9 Q
DispFirstPage();
) c$ K- |% ], u- n/ D
fRefresh = 1; /* 请求刷新LCD */- _3 e) X" K' q$ W2 P6 b
break;
' W! L# b; j) ^* L
2 j! Q( x- m, K; X( u7 L1 v
case JOY_DOWN_OK: /* 摇杆OK键，清屏 */5 d1 M5 q L. o/ t9 R' A
DispFirstPage(); # i9 B6 w9 n. D4 P. ?( W* g* X3 Z6 b! D4 _
fRefresh = 1; /* 请求刷新LCD */
\6 s, |2 k! o) d/ r( k W
break;
: Q; S7 b% `. X8 {, g1 C* P: u2 Y
$ r) c3 j4 h6 b0 w3 H! }
case JOY_DOWN_U: /* 摇杆UP键按下 */
* \* b- |8 P) Q/ I
ucBright += BRIGHT_STEP;8 K5 M/ I; Z" w* B6 U( }
if (ucBright > BRIGHT_MAX)3 L8 l. n, I+ f% V+ p
{
9 M" w# H7 N& D" ]- \# k3 X' s* O
ucBright = BRIGHT_MAX;3 [) N1 _! x% c
}
, i1 S) e0 b% P/ j6 S( R' L
LCD_SetBackLight(ucBright);9 [7 L2 S9 G& o
fRefresh = 1; /* 请求刷新LCD */
* s: n: W. b( H/ {" B
break;& V8 ]" h; k! g5 w
5 |0 d* d. y! k9 L! j' @: u3 _
case JOY_DOWN_D: /* 摇杆DOWN键按下 */; W8 R) W4 c% O: [* m2 ^
if (ucBright < BRIGHT_STEP)
- R8 {0 T; B* |' C
{
5 y. l5 ]4 D6 g4 j p" P6 h; ?
ucBright = 0;
" e+ X! U9 Y* V" w. k
}
- ~2 R6 T' t" i" X
else
' b+ K: B. H n% B
{
. S3 o$ r K- s" B. T+ |
ucBright -= BRIGHT_STEP;
* s+ B p+ G7 ^! \
}
; }" H$ u; u/ `7 s$ f
LCD_SetBackLight(ucBright);6 S. S4 h b" } _
fRefresh = 1; /* 请求刷新LCD */
% l% q. S1 a8 t$ ~
break;5 ^$ R# @9 N* v7 y
/ @- |, e6 t+ g$ }8 g% N
default:
7 V5 \ x8 A* V) W; v
break;! e7 j; z4 `( G" g5 s( k6 T$ q" [
}
/ D, b8 ^ K$ j$ ^
}6 Z2 Q! c+ L! U
}4 H6 i) o/ _! {
}
8 i B* z8 F: w3 z4 u+ b

复制代码

LCD主界面显示内容如下:

/*
$ L) V9 X: W1 I6 V# |* R
*********************************************************************************************************
a3 C2 c" G9 c& H( z' k# n
* 函数名: DispFirstPage
# D, c& F9 H# K' ]) }* J- w. m
* 功能说明: 显示操作提示9 T! w o9 i1 v; q/ `$ d1 B: o6 m( R$ i
* 形参：无
# K2 z2 l! v/ W, Z* S: Z
* 返回值: 无
3 F m' c1 k4 X( D* A, ]
*********************************************************************************************************' O! @% ^( x* n5 N% Q2 [
*/
1 u& L& O" G* w1 N$ m, t
static void DispFirstPage(void)
& X D/ e' \9 t" w% x D) d3 n, ?
{
5 y W2 U8 {7 [/ _$ G, ~
FONT_T tFont; /* 定义一个字体结构体变量，用于设置字体参数 */! j4 s- v4 @7 Y* R
uint16_t y; /* Y坐标 */. L3 M1 M. @& I' c9 X' M& e0 w
uint16_t usLineCap; /* 行高 */
6 X* m! {: D& i! c
char buf[50]; X1 S% f0 G2 ~1 {/ a; E+ C; M, |
7 w- p; O, g+ Y0 [5 x
LCD_ClrScr(CL_BLUE); /* 清屏，背景蓝色 */6 q0 s% h2 i7 a3 A8 f' l0 h. d# c
5 S. D9 L- [# _5 t) K$ g
8 ~1 I! Z4 M/ T3 Z5 d" g& A; d
/* 设置字体属性 */
# O: ~$ `. y2 F+ K
tFont.FontCode = FC_ST_16; /* 字体选择宋体16点阵，高16x宽15) */3 O5 c4 s+ h( z% h1 G. s4 j5 s
tFont.FrontColor = CL_WHITE; /* 字体颜色设置为白色 */6 D' c* s2 s% K3 z8 z
tFont.BackColor = CL_MASK; /* 文字背景颜色，透明 */
4 A9 {0 }% u/ w& b( A0 W4 q5 B c2 E
tFont.Space = 0; /* 字符水平间距, 单位 = 像素 */. f4 V3 |* {; {8 {& P e
% d" h0 u4 N' g" N2 ^' i
y = 4;7 D$ P; K- P2 T$ ^: c
usLineCap = 18; /* 行间距 */" \6 I" ^1 T. b& ]2 {& w
LCD_DispStr(5, y, "安富莱STM32-V7开发板 <a href="http://www.armfly.com" target="_blank">www.armfly.com</a>", &tFont);
: Y+ }9 o0 b& ?: a, P! ^. ~+ a
y += usLineCap;
' X$ W4 F/ Z) V: v* \9 X5 C. I
LCD_DispStr(5, y, "电阻屏和电容屏实验，电容屏无需校准，电阻需要校准", &tFont);+ W8 `% C4 T" b* ~
/ P- ~* C% } p6 |7 W& }* J+ q. x
y += 5 * usLineCap;
% `3 Q, V& D; h, N
LCD_DispStr(30, y, "操作提示:", &tFont);
( I9 J' V' J% s4 ~ x
) k9 R0 ~2 A5 \" a( y& z
y += usLineCap;- B0 @. z4 P! r5 O* B5 S
LCD_DispStr(50, y, "摇杆上键 = 增加背光亮度", &tFont);4 `0 J. l: T4 P( L. Y3 l
# m! @! A% O3 _+ `# f6 j- l
y += usLineCap;
* z7 Z% Q1 [2 L+ V: f6 e9 c
LCD_DispStr(50, y, "摇杆下键 = 降低背光亮度", &tFont);
4 D1 w& e" `/ T3 B8 M7 D
" b( D* v# \. I; O8 ^
y += usLineCap;; u1 t; j% P6 {+ R' |) e) d5 T
LCD_DispStr(50, y, "摇杆左键 = 电阻屏触摸校准", &tFont);+ O& {/ W! i; d2 j+ {; g
# Q7 q7 \$ U1 d3 R5 y( a* W. ]) G; Z |
y += usLineCap;% s' C% c# R3 q& o3 M' I' u
LCD_DispStr(50, y, "摇杆OK键 = 清屏", &tFont);) Y- I0 k9 C. z' z
( e O$ b0 C3 a3 i9 [
y += 2 * usLineCap;
0 G. Q# M& a( e4 a
& ~2 V( _8 a( I, s0 ~1 b; P
7 w3 r. H' [7 d% H2 J* ]+ {! G6 U
/* 显示TFT控制器型号和屏幕分辨率 */
! H! }/ B7 ? ~# X, r6 y% n
//LCD_GetChipDescribe(buf); /* 读取TFT驱动芯片型号 */
& n3 i2 [0 |; ~" D# n
if (g_TouchType == CT_GT811)
6 V2 E0 w! B7 T$ R/ a( B( _# z1 a! O
{ : r- E* Y! _$ |9 F2 l( b
strcpy(buf, "STM32H743 + GT811");2 D; ]9 V8 [8 M6 q4 W! ~
}
. y' s* T- `* D+ H" J' |. Y
else if (g_TouchType == CT_GT911)
+ F5 {/ S! ^4 g" V
{
" n0 _0 D. l) P( C7 Y+ \! G
strcpy(buf, "STM32H743 + GT911");, e5 o! L0 H6 v- G) E7 d
}
5 z, [! M3 Y# Y4 f
else if (g_TouchType == CT_FT5X06)6 a k4 o& N% H. q% C
{
( A$ }- k Z! u% a! Z: i9 z8 B: J6 X
strcpy(buf, "STM32H743 + FT5X06"); h+ [9 `7 {$ d0 f: u2 ?: @
}
$ u( W3 l, Y# `- _# ^
else if (g_TouchType == CT_STMPE811)$ H' p, i/ T' W: |
{
* T, W. j2 R, {& x5 S8 d# N$ @
strcpy(buf, "STM32H743 + STMPE811");
4 a5 q @4 |. r- d* k
}6 O. m e& b0 {" k
else
8 F$ u: v; C: i+ k( D
{ $ G: b1 i* p/ S z: [
strcpy(buf, "STM32H743 + NoTouch"); ) p) E) Q. ^. I$ K3 b0 i
}
+ F* r9 r/ _* Y7 x) n3 C7 ]" G
sprintf(&buf[strlen(buf)], " %d x %d", LCD_GetWidth(), LCD_GetHeight());
; G( T j4 e* t2 A
LCD_DispStr(5, y, (char *)buf, &tFont);. j1 _9 K$ G4 \# C/ |
}
0 R8 K% G4 n+ s: l0 v

复制代码

) v3 D4 ~# i% b% L( j: f: Y
54.11 实验例程说明（IAR）
配套例子：

V7-034_LCD的电阻触摸和电容触摸（电阻触摸支持2点和4点校准）

实验目的：

学习LCD的电阻触摸和电容触摸。

实验内容：

电容屏无需校准，电阻屏需要校准。
LCD界面实现了一个简单的画板功能，方便检测触摸是否准确。
启动1个200ms的自动重装定时器，让LED2每200ms翻转一次。

LCD界面显示效果如下：

上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1

程序设计：

系统栈大小分配：

RAM空间用的DTCM：

硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：

/*
: B1 k0 p+ s! C2 a3 G+ Z' U5 X
*********************************************************************************************************5 T) ~- L$ \4 ?' }; s1 J Y
* 函数名: bsp_Init. x/ h" y* M, t
* 功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次# d" D* b- D6 Q' y F( j6 o' ~ R
* 形参：无# t% }) L2 @) D8 X# P7 S8 }
* 返回值: 无
) J) ] I9 W" q8 s+ `5 ^
*********************************************************************************************************# c( @7 r6 [- `/ @
*/
3 i5 n& \! b; ]9 z0 E
void bsp_Init(void)
7 c8 [% z8 u( [
{
! {5 g& g! S- e1 h4 T
/* 配置MPU */8 R2 U& R( S: I9 K8 P0 a- r0 {1 U* u
MPU_Config();3 ~9 s, y9 Q% c3 r/ B0 T2 C
8 p' r: A v3 @/ C
/* 使能L1 Cache */+ m9 r% | X$ X, g1 S
CPU_CACHE_Enable();
& Y- i$ G% {: |* m! b8 e$ F
, l5 n: M5 V8 r3 b+ w0 Z6 g5 d
/* ' a9 G& s+ W) G5 B
STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
( j+ q1 h* e; `% x U$ E }8 u0 t
- 调用函数HAL_InitTick，初始化滴答时钟中断1ms。$ ]. d# W8 y3 d2 H0 w4 Q5 F( K+ W
- 设置NVIV优先级分组为4。# Y; y l7 I+ d1 z. O+ Y Y# T8 D$ T
*/! R e' \7 [! J3 T9 v
HAL_Init();
& |) p# l6 v" R" e/ w- G
3 k) v: z* h9 Q* F) y
/* 8 C( y! I+ ?/ O* z
配置系统时钟到400MHz4 C; E! [. _; i! B, I6 ~6 b
- 切换使用HSE。( G% b* r9 N+ t) w: [$ o
- 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。+ S) F. x" b, N5 u5 L" m) i+ k
*/
6 E5 l5 Q d O
SystemClock_Config();5 u* u9 d' G/ Y
( ~& }( f8 r" ], L
/* # i' v: R6 q# P1 z
Event Recorder：7 \6 W! P( D2 ?4 N" I0 P
- 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。( j$ a) z8 \6 u& Q) u# s
- 默认不开启，如果要使能此选项，务必看V7开发板用户手册第8章, b, q e/ M* q' | ?
*/
1 c$ E5 I6 Q+ m. D/ k& v/ u l
#if Enable_EventRecorder == 1 " \/ S& X7 ^. `+ f3 t5 K) _
/* 初始化EventRecorder并开启 */( A* R6 J3 ~" ]2 _( f
EventRecorderInitialize(EventRecordAll, 1U);/ V. q+ R6 T5 c
EventRecorderStart();
$ U0 T9 v @3 M$ s! f# Z1 F
#endif
7 r$ y& |3 H+ ^" ~' T. o3 |, r
; ]- a8 e% h7 C) y( I; t" |
bsp_InitKey(); /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */! @6 @& e! `; h$ l; j
bsp_InitTimer(); /* 初始化滴答定时器 */
7 a1 i ^9 T$ T* Q. b! g1 e2 a, K
bsp_InitUart(); /* 初始化串口 */- e1 @/ C$ [1 U+ j3 D
bsp_InitExtIO(); /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */
' q! G* e9 E( M& W+ e5 s5 n
bsp_InitLed(); /* 初始化LED */ . }5 u! X( i: w" r& \0 X
3 k* _) A, ]3 E# j8 {
bsp_InitI2C(); /* 初始化I2C总线 */; w" l7 ~8 W: |* `1 U! ?: o4 }% ^
TOUCH_InitHard(); /* 初始化触摸芯片，LCD面板型号的检查也在此函数，所以要在函数LCD_InitHard前调用 */ 2 p' \! }* y/ _% F1 d' w4 g I
LCD_InitHard(); /* 初始化LCD */
' F2 p+ ^4 w! h/ {
}
* c8 x# d& Y+ s2 j8 q9 h0 Q8 |
2 p) F# M+ X9 _" T: ~9 n# |

复制代码

/*
2 N# V# j/ u4 d
*********************************************************************************************************
; Z( @1 V# w! l, Y
* 函数名: MPU_Config5 \3 ^% l0 }3 x: H
* 功能说明: 配置MPU
6 Z/ n# A7 v( f
* 形参: 无
6 G) @! ?6 b+ w$ Q0 r2 Q
* 返回值: 无
9 f! M4 y2 l& M/ h; C8 D
*********************************************************************************************************
( p0 y5 Q0 h8 V! `. f2 V' S
*/8 X' t7 E' O1 }, |# N) ?' Z
static void MPU_Config( void )+ a2 ^1 q' h$ s2 h: T; L
{ C! _5 @' K) `: U8 L2 i3 I
MPU_Region_InitTypeDef MPU_InitStruct;- ~ j9 Q/ ]1 N) @0 T9 ] Z
4 A/ |1 y9 }6 J" M9 w* E5 @" h
/* 禁止 MPU */: ^9 m0 A! F8 v! R/ \$ @
HAL_MPU_Disable();
! V; p6 f0 I. ^* _
1 w+ X. M4 O/ ]3 T2 Y
/* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
3 }2 K$ Q0 k6 S3 n& |6 O$ }9 h* ?' |
MPU_InitStruct.Enable = MPU_REGION_ENABLE;
6 M7 W$ G: @ @8 C
MPU_InitStruct.BaseAddress = 0x24000000;/ P8 t- W- r( \# n5 X4 T. c/ L
MPU_InitStruct.Size = MPU_REGION_SIZE_512KB;
# _% {* g B1 b0 Q+ H F
MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;0 L1 {3 q: x5 n- _! s" T1 \+ J5 b
MPU_InitStruct.IsBufferable = MPU_ACCESS_BUFFERABLE;1 c: u; K0 O4 z$ p/ z% L' }
MPU_InitStruct.IsCacheable = MPU_ACCESS_CACHEABLE;
2 P, O, O% v! q1 K3 g9 {9 S
MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
; m: O) m; N: n) C
MPU_InitStruct.Number = MPU_REGION_NUMBER0;( s6 s s+ Z+ I2 C3 ^- N
MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL1;
$ j x7 i5 g3 y# \) p
MPU_InitStruct.SubRegionDisable = 0x00;
& U7 y$ r* F; U R# C
MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;
: D% @$ C. t. P% E4 ~1 `
4 P3 C- D6 o2 u3 L; _( W
HAL_MPU_ConfigRegion(&MPU_InitStruct);
$ a" M) d, ^4 D1 W& \4 a
W* o& o* }5 L( O F5 M
" i0 g: A- Z7 ]
/* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */4 F) m1 z% g+ g: |
MPU_InitStruct.Enable = MPU_REGION_ENABLE;
9 j8 o$ `# P9 V& P! M3 Y/ G! t
MPU_InitStruct.BaseAddress = 0x60000000;1 x! _/ j: d, j+ k/ q# n6 n
MPU_InitStruct.Size = ARM_MPU_REGION_SIZE_64KB; ' m/ w; j% S3 C3 Y. e: u; _( V
MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
' E. @, f5 g! z0 N# `" j5 H
MPU_InitStruct.IsBufferable = MPU_ACCESS_BUFFERABLE;
) _# W1 [: s* a- q+ N
MPU_InitStruct.IsCacheable = MPU_ACCESS_NOT_CACHEABLE; - f8 X _. L4 C* n& Q
MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
& E& }) |7 }7 @3 y
MPU_InitStruct.Number = MPU_REGION_NUMBER1;
& ]8 h" @# o) x- z: ?
MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;% j# r6 L3 ?8 x* T8 @! F
MPU_InitStruct.SubRegionDisable = 0x00;
2 V6 K- ? A$ y' Y. A+ Y
MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;
' G, H) Z X5 m* z" i3 K% C" y
' P3 R5 @& u9 x9 G) L* E
HAL_MPU_ConfigRegion(&MPU_InitStruct);; L& d% x+ A: k% X
P# ^+ ^+ b G( d) G6 k; i5 Q' Y
/* 配置SDRAM的MPU属性为Write through, read allocate，no write allocate */
5 ?3 {1 c8 A& I. x# U* L: Y1 v
MPU_InitStruct.Enable = MPU_REGION_ENABLE;
* s; h/ X3 |0 g5 \: h
MPU_InitStruct.BaseAddress = 0xC0000000;. _8 G9 @5 G# a4 K1 o& M
MPU_InitStruct.Size = MPU_REGION_SIZE_32MB;
; n. n4 V3 L6 v) e+ d
MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;. f4 q# h0 o0 S# Y! C `/ [
MPU_InitStruct.IsBufferable = MPU_ACCESS_NOT_BUFFERABLE;3 ?* ]6 I( s7 ?, L0 I2 W
MPU_InitStruct.IsCacheable = MPU_ACCESS_CACHEABLE;" R+ S5 }9 U# v& E8 c2 `% \
MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;5 J; S9 _( @3 |( }6 c9 Y
MPU_InitStruct.Number = MPU_REGION_NUMBER2;
, n8 t- ~5 F; M R
MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;) O3 k( ^9 Z+ |4 u8 Q
MPU_InitStruct.SubRegionDisable = 0x00;
& }) U+ q h, w- E$ [, r8 d
MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;
8 ^. ]% D) T2 X* q. v
4 ?7 g1 W' \, A- y& ]$ r, E6 r
HAL_MPU_ConfigRegion(&MPU_InitStruct);
. K# u% E8 L+ W: D* A/ S
1 H8 y0 G3 i5 z$ ^+ p# H+ h
/*使能 MPU */
3 n1 n5 {( M ?. u9 j G
HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
! Y* D4 \$ B. E; p3 ~1 w$ d* t
}$ k% v2 b6 x2 Q4 \) p8 F [ X8 T
, n. d! R5 ]* F, ~* l8 ]
/*$ t, e! {( l4 V; J- K; c- W
*********************************************************************************************************: B# Y/ _6 c+ M. r
* 函数名: CPU_CACHE_Enable
6 E6 O6 |7 b( b7 N/ v# e
* 功能说明: 使能L1 Cache
- p' u- z* q% C7 o, y: i' E
* 形参: 无
+ I, S& u8 X$ u! L3 t: q! p; Y
* 返回值: 无+ W* Z0 Q X$ W8 C) z1 U" p: q
*********************************************************************************************************: a$ q8 f" H6 ]
*/8 r- H# v9 K# h. I
static void CPU_CACHE_Enable(void)9 {* m- S% z6 X3 L3 o
{# ~$ z( n$ W2 l: B+ k8 t( m
/* 使能 I-Cache */3 G! i/ K8 n% K# D" `# g
SCB_EnableICache();) B4 O( u( H7 ~: Y: ?! J: \
* H; x, P; U/ u
/* 使能 D-Cache */
/ V1 E1 ?6 G& W) E! ~
SCB_EnableDCache();# y1 E( C% \) U7 u) A9 j$ R! Q
}# ?/ q/ r- m: l6 k; R& f! Y. f4 a

复制代码

/*( V. y5 C7 L3 p% d8 i# \ V
*********************************************************************************************************
4 h# o; j, p# S9 `0 i& D8 n
* 函数名: main2 v7 E3 m) v* `, C( Y
* 功能说明: c程序入口
5 L" ?7 Q6 _4 |. V4 i8 s
* 形参: 无
( c( ], R$ g' y+ [6 O5 z
* 返回值: 错误代码(无需处理)
8 @3 H0 ~4 a+ E
*********************************************************************************************************
+ C" {+ Z7 b3 ^' A# P* [! O) u' P
*// L7 x* \5 ~. M( {9 m* c! o9 S+ I y
int main(void)* s* O' U* _; E7 G
{* j' |/ l8 C; z, l1 r
uint16_t ucBright; /* 背光亮度(0-255) */
W* v- g( g3 D p
uint8_t ucKeyCode; /* 按键代码 */% P; G$ l- x; V# v0 S! \7 F
uint8_t fRefresh; /* 刷屏请求标志,1表示需要刷新 */
9 A8 E" P4 A) g4 _+ U' j; x% z e
FONT_T tFont; /* 定义一个字体结构体变量，用于设置字体参数 */. i* W: A3 X9 z3 |: F
char buf[64];
" T: u- s3 U( f. ^& y5 \1 u
uint16_t usAdcX, usAdcY;
- t/ `( f' ] b4 J# C( m6 r
int16_t tpX, tpY;* ~9 ~; C% N1 E
uint8_t ucTouch; /* 触摸事件 */
& N$ H) {+ O. f# m" Z- `2 t
* `- H0 N' e# u: B/ R" q& V
0 x1 V7 R+ V% }0 B; q R- ~: E+ A
/* 设置字体参数 */8 {6 _: z9 M* N( n' q* k0 g9 X
{
tFont.FontCode = FC_ST_16; /* 字体代码 16点阵 */8 O7 P) T8 |! w9 l) {8 L0 u4 W% I5 @
tFont.FrontColor = CL_WHITE; /* 字体颜色 */2 T4 }5 [4 S6 U: n8 V5 K
tFont.BackColor = CL_BLUE; /* 文字背景颜色 */; J& P) {1 }1 ~
tFont.Space = 0; /* 文字间距，单位 = 像素 */! \& f) q: f9 U
}
3 g Y& {; j" U6 E
( @4 K7 M# n0 q( B5 D- @5 s
bsp_Init(); /* 硬件初始化 */
/ [: r2 Y+ t' {' h( ?
PrintfLogo(); /* 打印例程名称和版本等信息 */
- L6 h2 ]2 O* X5 m0 V6 E7 s% E8 d
PrintfHelp(); /* 打印操作提示 */& Q$ r* t* x- a/ c2 }
# }: X( j: N: _4 z
/* 延迟200ms再点亮背光，避免瞬间高亮 */7 R2 t8 \9 h' c0 J! @
bsp_DelayMS(200); % R, B# Z# H# q: t2 g
9 D# J% h( z+ o" W8 {2 R, U( f/ A
DispFirstPage(); /* 显示第1页 */ h! b4 X" @& E
: L* X! j- P3 n7 w: A# [1 U
/* 界面整体显示完毕后，再打开背光，设置为缺省亮度 */
4 b- t/ M% S3 [" X
bsp_DelayMS(100); 8 g) h3 `' v1 {
ucBright = BRIGHT_DEFAULT;4 o7 G U% e. o" [% j% e( s
LCD_SetBackLight(ucBright);
A: n" e. M. g! e$ ~, R' ?
% d" y7 N U0 c
bsp_StartAutoTimer(0, 200); /* 启动1个200ms的自动重装的定时器，软件定时器0 */4 s) v9 ]- m2 R
$ ?; z6 t) |. `! U
/* 进入主程序循环体 */
9 _. R! E7 E3 G# W: G: A
fRefresh = 1; ; K3 Z* C4 x* ?: h8 h: E% V
while (1)8 X* _7 y) ?' {# l$ @
{
# J/ h) B5 C) c+ x% s
bsp_Idle();2 {2 C1 \% y3 O i5 t1 B
9 ], }& J1 o, X6 f
/* 判断软件定时器0是否超时 */3 S1 J, l) [3 p! z4 [9 r+ F
if(bsp_CheckTimer(0))1 u* H) N' y; A$ d5 \" v
{4 e# S& `( O( u9 }" T
/* 每隔200ms 进来一次 */ d! s% }; c& J* A$ N/ |
bsp_LedToggle(2);
i5 \/ \% u/ q# J7 l; G
}
$ d5 J5 b$ l9 D# f
$ I( Y% D! m! r7 Z) \5 X1 y
if (fRefresh); {' ~2 z- A; a' i
{7 x5 n/ E' P7 G6 g8 V
fRefresh = 0;
, J; r- N9 m7 m/ B/ }7 t
. K4 p* J" T( b) O
/* 实时刷新触摸ADC采样值和转换后的坐标 */
) l4 `2 ]' A- r
{2 u3 m2 s/ D" V& H; b1 o1 a* d4 D
9 a) g' P, V) a1 ^
/* 读取并显示当前X轴和Y轴的ADC采样值 */( d3 B5 H) y0 X+ ?
usAdcX = TOUCH_ReadAdcX();$ j+ z8 n( B8 k O0 H
usAdcY = TOUCH_ReadAdcY();
% E2 \: z) Y5 F5 ~
sprintf(buf, "触摸ADC值 X = %4d, Y = %4d ", usAdcX, usAdcY);& p R9 ~! B& R* M8 u2 Y& L
LCD_DispStr(5, 40, buf, &tFont);' J9 o) w. o6 D/ i
% i B N% ?/ O' I# l
/* 读取并显示当前触摸坐标 */' K8 ^! s& @# J2 V P& O/ K
tpX = TOUCH_GetX();* l/ {) R6 O7 j; \* y, x1 O
tpY = TOUCH_GetY();# C! H b! \1 h1 {- \
sprintf(buf, "触摸坐标 X = %4d, Y = %4d ", tpX, tpY);
/ v) `# k; K% e: B; B1 C3 ?: t
LCD_DispStr(5, 60, buf, &tFont);
9 D8 i5 m* C3 z& L8 x: i' F$ n
* d" l _! v' M! Y8 b! I
/* 在触笔所在位置显示一个小圈 */
+ ^) y" L' d3 X' f
if ((tpX > 0) && (tpY > 0))
1 N, B8 `! J9 \; C& I7 J
{9 I/ Q+ @2 k8 V# I5 f' ~ c/ j
LCD_DrawCircle(tpX, tpY, 2, CL_YELLOW);! D" x. V. A$ @7 L
}
3 w' y9 [- D7 v: p# x; Y2 r* |7 Q
}$ D) |/ l5 q; ?, w
7 G) W) r: F+ K5 U
/* 在屏幕边沿绘制2个矩形框(用于检测面板边缘像素是否正常) */5 x7 B& Q4 f. z; M. `# @. y5 u
LCD_DrawRect(0, 0, LCD_GetHeight(), LCD_GetWidth(), CL_WHITE);( J3 ~+ t8 @5 L5 \
LCD_DrawRect(2, 2, LCD_GetHeight() - 4, LCD_GetWidth() - 4, CL_YELLOW);
8 }( h1 A' Z V7 ?: o6 ^
4 r/ T/ R% b h z
/* 显示背光值 */1 h9 Z1 X+ D4 ~7 Z- L4 j
sprintf(buf, "当前背光亮度: %3d", ucBright);
8 c1 p, f, x3 v6 U; v
LCD_DispStr(5, 80, buf, &tFont);7 h1 j, s$ m& p4 n( o
}) F+ q2 P# d3 o2 j
) v) { P% T3 S2 Z0 P
ucTouch = TOUCH_GetKey(&tpX, &tpY); /* 读取触摸事件 */4 j: }: `1 w+ _
if (ucTouch != TOUCH_NONE)
2 G h- _1 B4 _$ O/ O9 C( G9 N9 |
{
$ C# B; f1 ?6 p" M
switch (ucTouch)
. I. \! \6 y% b$ @. c6 `1 q! K$ ^0 ?
{& {' j9 M6 V, K; p
case TOUCH_DOWN: /* 触笔按下事件 */
: [! r/ D: Z& U l% C3 Z) e/ W9 _
; }) Y0 M6 y; H) n' b* h) N' Y
/* 在触笔所在位置显示一个小圈 */" m/ ?7 I( z8 ~; n3 I7 f
if ((tpX > 0) && (tpY > 0))
, W" i. a' J; u u" o
{
q( R* Q9 s2 w6 l
LCD_DrawCircle(tpX, tpY, 3, CL_RED); |: s8 B8 D1 V8 i# u2 ^% @, C! S
}
6 }# k4 | _) V
break;# f; o& k* B) V! x0 o( o& f
: ^8 C: H g& ?8 n2 p% c4 y9 B
case TOUCH_MOVE: /* 触笔移动事件 */
+ q4 k4 c$ i2 q) x3 w8 t
/* 实时刷新触摸ADC采样值和转换后的坐标 */6 f1 I. ~2 h2 k5 o/ t
{
) J. n* _ S4 s
/* 读取并显示当前X轴和Y轴的ADC采样值 */% {' D0 B8 [7 E5 ]
usAdcX = TOUCH_ReadAdcX();: Q8 M& C' a# x" x3 j2 t7 f" w
usAdcY = TOUCH_ReadAdcY();- g5 B6 y8 D6 P
sprintf(buf, "触摸ADC值 X = %4d, Y = %4d ", usAdcX, usAdcY);
3 A# ]6 q! U; ~5 V$ C
LCD_DispStr(5, 40, buf, &tFont);
7 G9 R# h% y3 u- e; I
7 i8 T0 l' L9 K/ S7 |9 X: g: G; B
/* 读取并显示当前触摸坐标 */+ }0 v/ _' z& l3 ? z- X
//tpX = TOUCH_GetX();
, I5 S, U9 i! T6 Y6 ^6 A
//tpY = TOUCH_GetY();' \- P7 o; l4 g1 z Y
sprintf(buf, "触摸坐标 X = %4d, Y = %4d ", tpX, tpY);
$ ]+ k8 @: [3 a' ]9 l4 ^' r
LCD_DispStr(5, 60, buf, &tFont);9 z) M' O* s1 f3 K8 @- w
% g. H" U& T% V/ J3 G1 D) G; T( R7 f
/* 在触笔所在位置显示一个小圈 */
& O; y. { r9 u' C& f
if ((tpX > 0) && (tpY > 0))
5 X- F' ?2 N# a: L3 }
{9 h! y& ] T" D
LCD_DrawCircle(tpX, tpY, 2, CL_YELLOW);7 D* ]$ L. [0 g$ n
}
1 k/ X3 I/ J' }- v- Y5 j
}2 d/ \3 e" v! G0 J8 D f4 }
break;0 u: h# J- m# e
. |7 p R0 n/ m+ C. i+ ?$ G
case TOUCH_RELEASE: /* 触笔释放事件 */
$ E4 E7 J) [3 X- [' s1 g6 W
/* 在触笔所在位置显示一个小圈 */; T) p4 _* |# q3 W& l- r
if ((tpX > 0) && (tpY > 0))+ v% B# Y9 }# q( @5 p0 S, K0 N
{. K* Y/ s, D0 ]& s0 w
LCD_DrawCircle(tpX, tpY, 4, CL_WHITE);& q/ G* F, L2 C, m4 @! S
}: A+ M1 E$ }% _: M8 t0 O
break;: i6 @8 ~3 _4 m7 ]) d
}
5 H0 a" q1 U0 D7 g
}
% O! I% E% h' A/ _- ~
7 c' Q( J) @5 P! U
ucKeyCode = bsp_GetKey(); /* 读取键值, 无键按下时返回 KEY_NONE = 0 */- T: g( ] j7 p7 |8 o3 O
if (ucKeyCode != KEY_NONE)
6 d" N# s, g5 z5 d) e) v
{6 U8 x; ]# G+ @* @
/* 有键按下 */4 ?. s) Y# N; M a9 A
switch (ucKeyCode)
$ ^' E1 g5 i. z' @
{
3 b" K! W% u# j1 P
case JOY_DOWN_L: /* 摇杆LEFT键按下, 2点触摸校准 */% ], K4 L! m: \ |$ c9 j: I
TOUCH_Calibration(2);9 p" E( x) Z2 ]6 j8 i) m+ }- k
DispFirstPage(); : B V0 [* M# ?! @) S
fRefresh = 1; /* 请求刷新LCD */# _$ y% |! K' h7 w
break;: b0 c( w. l6 w4 d$ M
?3 i( j& l6 u# x
case JOY_DOWN_OK: /* 摇杆OK键，清屏 */ T/ ^9 G, X$ j' \5 g
DispFirstPage(); " N, }( |2 U( Y' `
fRefresh = 1; /* 请求刷新LCD */
; h3 g( g4 s0 P+ _ n+ `
break;
A; z; p, O9 v. K8 @
4 G' |1 U- ~1 W* n a0 {6 Q
case JOY_DOWN_U: /* 摇杆UP键按下 */
4 q; f8 S8 b3 D m
ucBright += BRIGHT_STEP;
8 [4 w/ Z! F. k P6 J0 {
if (ucBright > BRIGHT_MAX)0 E$ K% F4 t D' m3 x
{
( a+ m6 P$ c. R3 U1 \
ucBright = BRIGHT_MAX;
6 |8 g& H3 n" H: ^6 M$ E( K
}
5 c6 b& |: R! f- g; W; _2 i6 v: o
LCD_SetBackLight(ucBright);" Y+ M+ W3 a- J# y8 o$ L
fRefresh = 1; /* 请求刷新LCD */
7 c3 _1 _, d( R0 Z2 y
break;
3 ?7 V& {$ ]( m8 O9 x" w4 Y' l
: e4 W: e$ x5 }* f7 B/ c% P" U- [
case JOY_DOWN_D: /* 摇杆DOWN键按下 */
, D$ H( C+ N) j* K
if (ucBright < BRIGHT_STEP)6 @+ M: t: L' p3 ]1 D, @+ F
{) g3 Z& r4 P6 t X, p8 L
ucBright = 0;
: B$ ]1 h/ G' Z+ `# f- r: W
}7 c" U* l; N5 `+ _1 B
else
! K; s" b, |+ C+ c2 [# @
{
0 S& ~2 W8 A. A, \- r" [: B5 I0 q
ucBright -= BRIGHT_STEP;
a6 h: z7 V% Y9 B& @+ D
}# x8 a- s4 a2 Y4 P1 m3 D! Q( u% @( U
LCD_SetBackLight(ucBright);
. L( z' `4 B# F5 k
fRefresh = 1; /* 请求刷新LCD */1 e& o; Y% a8 H; W( p
break;
& ^$ H8 v6 Z0 Y( ^, `; T) ^
4 D: w8 W( M* x* C3 I* `
default:
3 l) [7 X8 V- p% @6 L" F6 Q
break;
( |# k- k/ W, j) v
}! b* g3 X5 P' t9 F# b' _% [- c
}5 W& t! w: V7 G
}5 k/ D6 g) e5 {* H
}
& Q4 J9 `5 a% w9 ]) S8 S

复制代码

LCD主界面显示内容如下:

/*
7 N/ b9 [4 d* i3 l5 O
*********************************************************************************************************( @& x* a# C7 {
* 函数名: DispFirstPage% A- }# x+ i! u) k/ l* R y5 K
* 功能说明: 显示操作提示
3 X+ R8 b7 {4 y3 @* b, k
* 形参：无) i) U/ { @, r/ n8 F& v
* 返回值: 无
4 c1 k. D" N6 Z
*********************************************************************************************************
7 Q! R$ D: D; F1 w$ ^
*/
* E5 x' z7 Z8 W3 @
static void DispFirstPage(void)
( m4 E1 r( |( c/ |
{, `. q. U& C. J+ Q5 I: J8 g# R+ ^. {
FONT_T tFont; /* 定义一个字体结构体变量，用于设置字体参数 */
( X$ o$ j; u* Q" R# n
uint16_t y; /* Y坐标 */
- o- ^' x5 N/ g2 q" u" H
uint16_t usLineCap; /* 行高 *// j6 q. t! z' J- M/ \' p9 g
char buf[50];
0 v' e" ^& e# t5 u8 G9 o
9 ~ Q$ n% _; d' m/ F) n
LCD_ClrScr(CL_BLUE); /* 清屏，背景蓝色 */
! e8 `+ e R p. E
2 u/ z ~7 D3 P: G2 E4 D( u, q
$ _0 \2 ~1 o% q( ]2 ?
/* 设置字体属性 */. r4 I" o$ |$ ` h! s+ f
tFont.FontCode = FC_ST_16; /* 字体选择宋体16点阵，高16x宽15) */
5 Y+ U! ]; m; \/ l# P( e9 A
tFont.FrontColor = CL_WHITE; /* 字体颜色设置为白色 */0 `+ [9 R* B! l- ?7 B2 X
tFont.BackColor = CL_MASK; /* 文字背景颜色，透明 */
% z2 M p" z, K6 T) u1 X
tFont.Space = 0; /* 字符水平间距, 单位 = 像素 */
8 q7 g3 U' R7 h
! K9 g; e; L+ J' A$ {7 }
y = 4;# ^4 s, y2 g: Q. E
usLineCap = 18; /* 行间距 */
5 t1 E8 W, m7 _
LCD_DispStr(5, y, "安富莱STM32-V7开发板 <a href="http://www.armfly.com" target="_blank">www.armfly.com</a>", &tFont);+ ^+ M$ {4 f% v2 E4 ~, k0 h0 X
y += usLineCap;
* R+ Q; \8 _% P1 n8 J4 l
LCD_DispStr(5, y, "电阻屏和电容屏实验，电容屏无需校准，电阻需要校准", &tFont);# \5 @. @2 y" v
( j( D; v$ Q0 h) ~9 S1 V; X. U
y += 5 * usLineCap;% ~. W1 \$ W b( c7 ~ L( h
LCD_DispStr(30, y, "操作提示:", &tFont);
4 r3 N2 l$ }) v, \
4 Z4 e$ A' \( y! x3 T4 q8 w8 i" @
y += usLineCap;! D1 D) S& V% o. D* w1 f
LCD_DispStr(50, y, "摇杆上键 = 增加背光亮度", &tFont);5 w Z9 J( P F: ~$ J
* F( |* M0 `+ N5 o
y += usLineCap;
) n3 H5 K* b; K/ o% e
LCD_DispStr(50, y, "摇杆下键 = 降低背光亮度", &tFont);6 A0 W9 g& E! L$ Z6 s* n
1 B& _6 ~! a& f0 B/ I+ ^
y += usLineCap;# X) j: \! I% o% n3 N1 i3 {6 g1 O
LCD_DispStr(50, y, "摇杆左键 = 电阻屏触摸校准", &tFont);& l& u- J* J) e$ \
5 E8 K- c; _7 H2 R
y += usLineCap;- F: |0 i6 l' l0 U" A, v
LCD_DispStr(50, y, "摇杆OK键 = 清屏", &tFont);
3 I# k/ x, M, i9 K) ?4 i7 G
" \! f$ Y( ]- h( Y) z9 A
y += 2 * usLineCap; $ ^/ a, X7 b0 D- r# e( V
2 f8 t6 n w3 P4 {- o
P8 n& }. U/ k' k+ P
/* 显示TFT控制器型号和屏幕分辨率 */
- x8 e2 S" d1 Y h* `& m! Q+ }$ G
//LCD_GetChipDescribe(buf); /* 读取TFT驱动芯片型号 */7 J( F2 v w( v4 I6 X0 e$ l4 z
if (g_TouchType == CT_GT811)7 A( q8 o2 L5 a+ W7 J7 P2 ^1 E
{ , S3 b, T! ^5 m) L5 P; e
strcpy(buf, "STM32H743 + GT811");3 ?$ ]$ F7 J3 j2 `0 B
}
6 k1 }5 m# F5 }& m
else if (g_TouchType == CT_GT911)" N% w9 b8 j7 |0 z
{
( s& a4 m2 h3 N" G& C. F- L- o% d
strcpy(buf, "STM32H743 + GT911");) k$ {: c# ` s6 m0 a1 |
}
5 a W: P/ U' g. p/ t# y$ P
else if (g_TouchType == CT_FT5X06): P* {8 x, [5 T' w# u3 u
{$ y* P/ K4 k z' D: e
strcpy(buf, "STM32H743 + FT5X06");! b1 N% `0 w* z2 i! Q
}1 m" K# E: w7 w+ |4 q& s" o7 Q# b
else if (g_TouchType == CT_STMPE811)2 w7 M- a! a+ X8 K
{6 A) A7 l4 f# i+ E7 F- r: g% e U5 ^
strcpy(buf, "STM32H743 + STMPE811");
5 o/ l" w% j# t' ^- y3 d! |" a$ Y
}7 _0 N$ `$ J! U, M4 O
else; Q, M# S: Q' b8 \& x8 y( r
{
. j/ q/ U) W4 W; b
strcpy(buf, "STM32H743 + NoTouch"); 9 Z7 W9 o+ |% [# k
} + F) x; r6 g: f5 Y! l
sprintf(&buf[strlen(buf)], " %d x %d", LCD_GetWidth(), LCD_GetHeight());# \, P9 x6 c* l/ r; n$ N, o7 D7 y
LCD_DispStr(5, y, (char *)buf, &tFont);! M/ {8 L% F2 R5 _" V; F w8 }' v: ]
}7 G8 `' j, g! c; N$ {