【已更新完毕】关于电阻触摸的4点校准和2点校准使用原理说明，适用于裸机和GUI

eric2013

2点触摸校准的实现
测试条件：
800*480分辨率显示屏，物理坐标值X轴范围0-799，Y轴0-479。
STMP811电阻触摸范围0 - 4095，其实就是一个差分ADC芯片。

实现思路：
点击了触摸板上的一点，会得到一个ADC采样值，含X轴和Y轴，那么如何将其转换为实际的物理坐标值?  实际上最简单的方法，建立一个比例关系即可：
采集的X轴ADC值乘以 799/4095，就是X物理坐标值。
采集的Y轴ADC值乘以 479/4095，就是Y物理坐标值。

考虑到触摸板的线性度差一点，坐标关系y = ax扩展为y = ax + b。

实现原理：
在左上角和右下角分别设置两个坐标点（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数值直接代入上面公式就可以得到校准后的物理坐标值。

eric2013

4点触摸校准实现，略复杂
实现原理：
在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数值再次代入这个方程就得到了最终的物理坐标。

eric2013

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: CalTwoPoint
   
4. *        功能说明: 根据2点直线方程，计算Y值
   
5. *        形    参:  2个点的坐标和x输入量
   
6. *        返 回 值: x对应的y值
   
7. *********************************************************************************************************
   
8. */
   
9. static int32_t CalTwoPoint(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t x)
   
10. {
    
11.         return y1 + ((int32_t)(y2 - y1) * (x - x1)) / (x2 - x1);
    
12. }
    
13. 
    
14. /*
    
15. *********************************************************************************************************
    
16. *        函 数 名: TOUCH_TransX
    
17. *        功能说明: 将触摸ADC值转换为像素坐标
    
18. *        形    参:  无
    
19. *        返 回 值: X 坐标值，允许负值
    
20. *********************************************************************************************************
    
21. */
    
22. static int16_t TOUCH_TransX(uint16_t _usAdcX, uint16_t _usAdcY)
    
23. {
    
24.         if (g_tTPParam.CalibPointCount == 2)
    
25.         {
    
26.                 uint16_t x;
    
27.                 int32_t y;
    
28. 
    
29.                 if (g_tTPParam.XYChange == 0)
    
30.                 {
    
31.                         x = _usAdcX;
    
32.                         if (x == 0)
    
33.                         {
    
34.                                 y = 0;
    
35.                         }
    
36.                         else
    
37.                         {
    
38.                                 //y = CalTwoPoint(g_tTPParam.usAdcX1, TP_X1, g_tTPParam.usAdcX2, TP_X2, x);
    
39.                                 y = CalTwoPoint(g_tTPParam.usAdcX1, g_tTPParam.usLcdX1, g_tTPParam.usAdcX2, g_tTPParam.usLcdX2, x);
    
40.                         }
    
41.                 }
    
42.                 else
    
43.                 {
    
44.                         x = _usAdcY;
    
45.                         if (x == 0)
    
46.                         {
    
47.                                 y = 0;
    
48.                         }
    
49.                         else
    
50.                         {
    
51.                                 //y = CalTwoPoint(g_tTPParam.usAdcY1, TP_X1, g_tTPParam.usAdcY2, TP_X2, x);
    
52.                                 y = CalTwoPoint(g_tTPParam.usAdcY1, g_tTPParam.usLcdX1, g_tTPParam.usAdcY2, g_tTPParam.usLcdX2, x);
    
53.                         }
    
54.                 }
    
55.                 return y;
    
56.         }
    
57.         else        /* 4点校准 */
    
58.         {
    
59.                 uint16_t x, x1, x2;
    
60.                 int32_t y;
    
61. 
    
62.                 if (g_tTPParam.XYChange == 0)        /* X Y 坐标不交换 */
    
63.                 {
    
64.                         x = _usAdcX;
    
65. 
    
66.                         /* 根据 Y ADC 实时计算直线方程的参考点x1, x2
    
67.                                 if  _usAdcY = usAdcY1 then  取点 = (AdcX1, TP_X1, AdcX4, TP_X4, _usAdcY)
    
68.                                 if  _usAdcY = usAdcY2 then  取点 = (AdcX3, TP_X3, AdcX2, TP_X2, _usAdcY)
    
69. 
    
70.                                 其中 TP_X1 = TP_X3;  TP_X4 = TP_X1 , 这是程序设定的校准位置的像素坐标, 是固定的。
    
71.                                 我们仅需要动态计算对第1个和第3个参数。同样采用2点直线方程计算。
    
72.                         */
    
73.                         x1 = CalTwoPoint(g_tTPParam.usAdcY1, g_tTPParam.usAdcX1, g_tTPParam.usAdcY2,  g_tTPParam.usAdcX3, _usAdcY);
    
74.                         x2 = CalTwoPoint(g_tTPParam.usAdcY1, g_tTPParam.usAdcX4, g_tTPParam.usAdcY2,  g_tTPParam.usAdcX2, _usAdcY);
    
75.                 }
    
76.                 else                                                /* X Y 坐标交换 */
    
77.                 {
    
78.                         x = _usAdcY;
    
79. 
    
80.                         /* 根据 X ADC 实时计算直线方程的参考点x1, x2
    
81.                                 if  _usAdcX = usAdcX1 then  取点 = (AdcY1, TP_X1, AdcY4, TP_X4, _usAdcX)
    
82.                                 if  _usAdcX = usAdcX2 then  取点 = (AdcY3, TP_X3, AdcY2, TP_X2, _usAdcX)
    
83. 
    
84.                                 其中 TP_X1 = TP_X3;  TP_X4 = TP_X1 , 这是程序设定的校准位置的像素坐标, 是固定的。
    
85.                                 我们仅需要动态计算对第1个和第3个参数。同样采用2点直线方程计算。
    
86.                         */
    
87.                         x1 = CalTwoPoint(g_tTPParam.usAdcX1, g_tTPParam.usAdcY1, g_tTPParam.usAdcX2,  g_tTPParam.usAdcY3, _usAdcX);
    
88.                         x2 = CalTwoPoint(g_tTPParam.usAdcX1, g_tTPParam.usAdcY4, g_tTPParam.usAdcX2,  g_tTPParam.usAdcY2, _usAdcX);
    
89.                 }
    
90. 
    
91.                 if (x == 0)
    
92.                 {
    
93.                         y = 0;
    
94.                 }
    
95.                 else
    
96.                 {
    
97.                         /* 根据2点直线方程，计算坐标 */
    
98.                         //y = CalTwoPoint(x1, TP_X1, x2, TP_X2, x);
    
99.                         y = CalTwoPoint(x1, g_tTPParam.usLcdX1, x2, g_tTPParam.usLcdX2, x);
    
100.                 }
     
101.                 return y;
     
102.         }
     
103. }
     
104. 
     
105. /*
     
106. *********************************************************************************************************
     
107. *        函 数 名: TOUCH_TransY
     
108. *        功能说明: 将触摸ADC值转换为像素坐标
     
109. *        形    参:  无
     
110. *        返 回 值: Y 坐标值，允许负值
     
111. *********************************************************************************************************
     
112. */
     
113. static int16_t TOUCH_TransY(uint16_t _usAdcX, uint16_t _usAdcY)
     
114. {
     
115.         if (g_tTPParam.CalibPointCount == 2)        /* 2点校准 */
     
116.         {
     
117.                 int32_t x;
     
118.                 int32_t y;
     
119. 
     
120.                 if (g_tTPParam.XYChange == 0)
     
121.                 {
     
122.                         x = _usAdcY;
     
123.                         if (x == 0)
     
124.                         {
     
125.                                 y = 0;
     
126.                         }
     
127.                         else
     
128.                         {
     
129.                                 //y = CalTwoPoint(g_tTPParam.usAdcY1, TP_Y1, g_tTPParam.usAdcY2, TP_Y2, x);
     
130.                                 y = CalTwoPoint(g_tTPParam.usAdcY1, g_tTPParam.usLcdY1, g_tTPParam.usAdcY2, g_tTPParam.usLcdY2, x);
     
131.                         }
     
132.                 }
     
133.                 else
     
134.                 {
     
135.                         x = _usAdcX;
     
136.                         if (x == 0)
     
137.                         {
     
138.                                 y = 0;
     
139.                         }
     
140.                         else
     
141.                         {
     
142.                                 //y = CalTwoPoint(g_tTPParam.usAdcX1, TP_Y1, g_tTPParam.usAdcX2, TP_Y2, x);
     
143.                                 y = CalTwoPoint(g_tTPParam.usAdcX1, g_tTPParam.usAdcY1, g_tTPParam.usAdcX2, g_tTPParam.usLcdY2, x);
     
144.                         }
     
145.                 }
     
146.                 return y;
     
147.         }
     
148.         else /* 4点校准 */
     
149.         {
     
150.                 int32_t x, x1, x2;
     
151.                 int32_t y;
     
152. 
     
153.                 if (g_tTPParam.XYChange == 0)        /* X Y 坐标不交换 */
     
154.                 {
     
155.                         x = _usAdcY;
     
156. 
     
157.                         /* 根据 X ADC 实时计算直线方程的参考点x1, x2
     
158.                                 if  _usAdcX = usAdcX1 then  取点 = (AdcY1, TP_Y1, AdcY3, TP_Y3, _usAdcX)
     
159.                                 if  _usAdcX = usAdcX2 then  取点 = (AdcY4, TP_Y4, AdcY2, TP_Y2, _usAdcX)
     
160. 
     
161.                                 其中 TP_Y1 = TP_Y4;  TP_Y3 = TP_Y2 , 这是程序设定的校准位置的像素坐标, 是固定的。
     
162.                                 我们仅需要动态计算对第1个和第3个参数。同样采用2点直线方程计算。
     
163.                         */
     
164.                         x1 = CalTwoPoint(g_tTPParam.usAdcX1, g_tTPParam.usAdcY1, g_tTPParam.usAdcX2,  g_tTPParam.usAdcY4, _usAdcX);
     
165.                         x2 = CalTwoPoint(g_tTPParam.usAdcX1, g_tTPParam.usAdcY3, g_tTPParam.usAdcX2,  g_tTPParam.usAdcY2, _usAdcX);
     
166.                 }
     
167.                 else                                                /* X Y 坐标交换 */
     
168.                 {
     
169.                         x = _usAdcX;
     
170. 
     
171.                         /* 根据 X ADC 实时计算直线方程的参考点x1, x2
     
172.                                 if  _usAdcY = usAdcY1 then  取点 = (AdcX1, TP_Y1, AdcX3, TP_Y3, _usAdcY)
     
173.                                 if  _usAdcY = usAdcY2 then  取点 = (AdcX4, TP_Y4, AdcX2, TP_Y2, _usAdcY)
     
174. 
     
175.                                 其中 TP_Y1 = TP_Y3;  TP_Y4 = TP_Y2 , 这是程序设定的校准位置的像素坐标, 是固定的。
     
176.                                 我们仅需要动态计算对第1个和第3个参数。同样采用2点直线方程计算。
     
177.                         */
     
178.                         x1 = CalTwoPoint(g_tTPParam.usAdcY1, g_tTPParam.usAdcX1, g_tTPParam.usAdcY2,  g_tTPParam.usAdcX4, _usAdcY);
     
179.                         x2 = CalTwoPoint(g_tTPParam.usAdcY1, g_tTPParam.usAdcX3, g_tTPParam.usAdcY2,  g_tTPParam.usAdcX2, _usAdcY);
     
180.                 }
     
181. 
     
182.                 if (x == 0)
     
183.                 {
     
184.                         y = 0;
     
185.                 }
     
186.                 else
     
187.                 {
     
188.                         /* 根据2点直线方程，计算坐标 */
     
189.                         //y = CalTwoPoint(x1, TP_Y1, x2, TP_Y2, x);
     
190.                         y = CalTwoPoint(x1, g_tTPParam.usLcdY1, x2, g_tTPParam.usLcdY2, x);
     
191.                 }
     
192.                 return y;
     
193.         }
     
194. }

复制代码

xieyang__

采集的X轴ADC值乘以 799/4095，就是X物理坐标值。 采集的X轴ADC值乘以 479/4095，就是X物理坐标值。这个是笔误吧？

eric2013

xieyang__ 发表于 2019-4-15 21:55
采集的X轴ADC值乘以 799/4095，就是X物理坐标值。 采集的X轴ADC值乘以 479/4095，就是X物理坐标值。这个是 ...

写错了，已经更正，谢谢指出