【HAL库每天一例】第056例：LCD-触摸画笔

haohao663

【HAL库每天一例】系列例程从今天开始持续更新。。。。。
我们将坚持每天至少发布一个基于YS-F1Pro开发板的HAL库例程，
该系列例程将带领大家从零开始使用HAL库，后面会持续添加模块应用例程。
同样的，我们还程序发布基于HAL库的指导文档和视频教程，欢迎持续关注，并提出改进意见。
例程下载：
资料包括程序、相关说明资料以及软件使用截图
链接：https://pan.baidu.com/s/1i574oPv
密码：r3s3
（硬石YS-F1Pro开发板HAL库例程持续更新\1. 软件设计之基本裸机例程(HAL库版本)\YSF1_HAL-056. LCD-触摸画笔）
/**
  ******************************************************************************
  *                           硬石YS-F1Pro开发板例程功能说明
  *
  *  例程名称: YSF1_HAL-056. LCD-触摸画笔
  *   
  ******************************************************************************
  * 说明：
  * 本例程配套硬石stm32开发板YS-F1Pro使用。
  *
  * 淘宝：
  * 论坛：硬石电子社区
  * 版权归硬石嵌入式开发团队所有，请勿商用。
  ******************************************************************************
  */

【1】例程简介
  电阻式触摸屏是一种传感器，它将矩形区域中触摸点(X,Y)的物理位置转换为代表X坐标和
Y坐标的电压。
  电阻式触摸屏是一种传感器，基本上是薄膜加上玻璃的结构，薄膜和玻璃相邻的一面上均
涂有ITO（纳米铟锡金属氧化物）涂层，ITO具有很好的导电性和透明性。当触摸操作时，薄
膜下层的ITO会接触到玻璃上层的ITO，经由感应器传出相应的电信号，经过转换电路送到处
理器，通过运算转化为屏幕上的X、Y值，而完成点选的动作，并呈现在屏幕上。
  四线触摸屏包含两个阻性层。其中一层在屏幕的左右边缘各有一条垂直总线，另一层在屏
幕的底部和顶部各有一条水平总线。
  本例程实现触摸屏数据读取并实现校准算法。
/******************* (C) COPYRIGHT 2015-2020 硬石嵌入式开发团队 *****END OF FILE****/














bsp_touch.c文件内容

1. /**
   
2.   ******************************************************************************
   
3.   * 文件名程: bsp_touch.c
   
4.   * 作    者: 硬石嵌入式开发团队
   
5.   * 版    本: V1.0
   
6.   * 编写日期: 2015-10-04
   
7.   * 功    能: 电阻触摸底层驱动函数
   
8.   ******************************************************************************
   
9.   * 说明：
   
10.   * 本例程配套硬石stm32开发板YS-F1Pro使用。
    
11.   *
    
12.   * 淘宝：
    
13.   * 论坛：http://www.ing10bbs.com
    
14.   * 版权归硬石嵌入式开发团队所有，请勿商用。
    
15.   ******************************************************************************
    
16.   */
    
17. /* 包含头文件 ----------------------------------------------------------------*/
    
18. #include "lcd/bsp_lcd.h"
    
19. #include "usart/bsp_debug_usart.h"
    
20. #include "spiflash/bsp_spiflash.h"
    
21. #include "touch/bsp_touch.h"
    
22. #include <stdio.h>
    
23. #include <string.h>
    
24. 
    
25. /* 私有类型定义 --------------------------------------------------------------*/
    
26. /* 私有宏定义 ----------------------------------------------------------------*/
    
27. 
    
28. /* 私有变量 ------------------------------------------------------------------*/
    
29. XPT2046_Calibration cal_value={0};
    
30. 
    
31. /* 扩展变量 ------------------------------------------------------------------*/
    
32. /* 私有函数原形 --------------------------------------------------------------*/
    
33. /* 函数体 --------------------------------------------------------------------*/
    
34. /**
    
35.   * 函数功能: 电阻触摸相关GPIO初始化
    
36.   * 输入参数: 无
    
37.   * 返 回 值: 无
    
38.   * 说    明：无
    
39.   */
    
40. void Touch_Init_GPIO(void)
    
41. {
    
42.   GPIO_InitTypeDef GPIO_InitStruct;
    
43. 
    
44.   /* 开启GPIO时钟 */
    
45.   XPT2046_EXTI_GPIO_CLK_ENABLE();
    
46.   XPT2046_SPI_GPIO_CLK_ENABLE();
    
47. 
    
48.   /* 模拟SPI GPIO初始化 */
    
49.   GPIO_InitStruct.Pin = XPT2046_SPI_CLK_PIN|XPT2046_SPI_MOSI_PIN|XPT2046_SPI_CS_PIN;
    
50.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    
51.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_MEDIUM;
    
52.   HAL_GPIO_Init(XPT2046_SPI_PORT, &GPIO_InitStruct);
    
53. 
    
54. 
    
55.   GPIO_InitStruct.Pin  = XPT2046_SPI_MISO_PIN;
    
56.   GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    
57.   GPIO_InitStruct.Pull = GPIO_PULLUP;
    
58.   HAL_GPIO_Init(XPT2046_SPI_PORT, &GPIO_InitStruct);
    
59.   
    
60.   GPIO_InitStruct.Pin = XPT2046_EXTI_PIN;
    
61.   HAL_GPIO_Init(XPT2046_EXTI_PORT, &GPIO_InitStruct);
    
62.    
    
63.   /* 拉低片选，选择XPT2046 */
    
64.   XPT2046_CS_LOW();
    
65. }
    
66. 
    
67. /**
    
68.   * 函数功能: us 级别延时，不是很精确
    
69.   * 输入参数: cnt：延时时间
    
70.   * 返 回 值: 无
    
71.   * 说    明：无
    
72.   */
    
73. static void XPT2046_DelayUS ( __IO uint32_t ulCount )
    
74. {
    
75.         uint32_t i;
    
76.         for ( i = 0; i < ulCount; i ++ )
    
77.         {
    
78.                 uint8_t uc = 12;     //设置值为12，大约延1微秒               
    
79.                 while ( uc -- );     //延1微秒        
    
80.         }        
    
81. }
    
82. 
    
83. /**
    
84.   * 函数功能: 写命令
    
85.   * 输入参数: CHX         0x90         //通道Y+的选择控制字
    
86.   *           CHY   0xd0        //通道X+的选择控制字
    
87.   * 返 回 值: 无
    
88.   * 说    明：无
    
89.   */
    
90. static void XPT2046_WriteCMD(uint8_t ucCmd)
    
91. {
    
92.         uint8_t i;
    
93.   
    
94.         XPT2046_MOSI_LOW();        
    
95.         XPT2046_CLK_LOW();
    
96. 
    
97.         for ( i = 0; i < 8; i ++ )
    
98.         {
    
99.                 ( ( ucCmd >> ( 7 - i ) ) & 0x01 ) ? XPT2046_MOSI_HIGH() : XPT2046_MOSI_LOW();               
    
100.           XPT2046_DelayUS ( 5 );               
     
101.                 XPT2046_CLK_HIGH();
     
102.           XPT2046_DelayUS ( 5 );
     
103.                 XPT2046_CLK_LOW();
     
104.         }        
     
105. }
     
106. 
     
107. /**
     
108.   * 函数功能: 读数据
     
109.   * 输入参数: 无
     
110.   * 返 回 值: short：读到的数据
     
111.   * 说    明：无
     
112.   */
     
113. static uint16_t XPT2046_ReadCMD ( void )
     
114. {
     
115.         uint8_t i;
     
116.         uint16_t usBuf=0, usTemp;
     
117. 
     
118.         XPT2046_MOSI_LOW();
     
119.         XPT2046_CLK_HIGH();
     
120.         for ( i=0;i<12;i++ )
     
121.         {
     
122.                 XPT2046_CLK_LOW();        
     
123.                 usTemp = XPT2046_MISO_READ();               
     
124.                 usBuf |= usTemp << ( 11 - i );        
     
125.                 XPT2046_CLK_HIGH();               
     
126.         }        
     
127.         return usBuf;
     
128. }
     
129. 
     
130. /**
     
131.   * 函数功能: 选择一个模拟通道，启动ADC，并返回ADC采样结果
     
132.   * 输入参数: _ucCh = 0x90 表示Y通道；
     
133.   *                   0xd0 表示X通道
     
134.   * 返 回 值: 无
     
135.   * 说    明：无
     
136.   */
     
137. uint16_t XPT2046_ReadAdc(uint8_t _ucCh)
     
138. {
     
139.   XPT2046_WriteCMD(_ucCh);
     
140.         return         XPT2046_ReadCMD();
     
141. }
     
142. 
     
143. /**
     
144.   * 函数功能: 校正触摸时画十字专用
     
145.   * 输入参数: x：十字中点x轴
     
146.   *           y：十字中点y轴
     
147.   * 返 回 值: 无
     
148.   * 说    明：无
     
149.   */
     
150. void LCD_DrawCross(uint16_t x,uint16_t y)
     
151. {
     
152.   LCD_DrawLine(x-10,y,x+10,y,RED);
     
153.   LCD_DrawLine(x,y-10,x,y+10,RED);
     
154. }
     
155. 
     
156. /**
     
157.   * 函数功能: 读取TP x y 的AD值(12bit，最大是4096)
     
158.   * 输入参数: x：读到AD值
     
159.   *           y：读到AD值
     
160.   * 返 回 值: 无
     
161.   * 说    明：无
     
162.   */
     
163. void XPT2046_ReadAdc_XY(int16_t *sX_Ad,int16_t *sY_Ad)  
     
164. {
     
165.         int16_t sX_Ad_Temp, sY_Ad_Temp;         
     
166.         
     
167.         sX_Ad_Temp = XPT2046_ReadAdc(XPT2046_CHANNEL_X);
     
168.         XPT2046_DelayUS(10);
     
169.         sY_Ad_Temp = XPT2046_ReadAdc(XPT2046_CHANNEL_Y);                 
     
170.         * sY_Ad = sX_Ad_Temp;
     
171.         * sX_Ad = sY_Ad_Temp;        
     
172. }
     
173. 
     
174. /**
     
175.   * 函数功能: 得到简单滤波之后的X Y
     
176.   * 输入参数: pTouch_AD_x：保存测量X+对应的AD值
     
177.   *           pTouch_AD_y：保存测量Y+对应的AD值
     
178.   *           wait：松开等待使能
     
179.   *            参数 1：使能等待松开
     
180.   *                 0：无需等待松开
     
181.   * 返 回 值: 无
     
182.   * 说    明：画板应用实例专用,不是很精准，但是速度比较快
     
183.   */
     
184. static uint8_t XPT2046_ReadAdc_Smooth_XY(int32_t *pTouch_AD_x,int32_t *pTouch_AD_y,uint8_t wait)
     
185. {
     
186.         uint8_t ucCount = 0, i;
     
187.         int16_t sAD_X, sAD_Y;
     
188.         int16_t sBufferArray[2][10]={{0},{0}};  //坐标X和Y进行多次采样        
     
189.         int32_t lX_Min, lX_Max, lY_Min, lY_Max;
     
190.   
     
191.   while(ucCount<10)
     
192.   {
     
193.     if(XPT2046_EXTI_Read() == XPT2046_EXTI_ActiveLevel)
     
194.     {
     
195.       XPT2046_ReadAdc_XY(&sAD_X,&sAD_Y);      
     
196.       sBufferArray[0][ucCount]=sAD_X;  
     
197.       sBufferArray[1][ucCount]=sAD_Y;
     
198.       ucCount ++;     
     
199.     }
     
200.     else if(wait==0)
     
201.       break;
     
202.   }
     
203.   
     
204.   while(wait)
     
205.   {
     
206.     if(XPT2046_EXTI_Read() != XPT2046_EXTI_ActiveLevel)break;
     
207.   }
     
208.   
     
209.         if(ucCount==10)
     
210.   {
     
211.     lX_Max=lX_Min=sBufferArray[0][0];
     
212.     lY_Max=lY_Min=sBufferArray[1][0];      
     
213.     for(i=1;i<10;i++)
     
214.     {
     
215.       if(sBufferArray[0][i]<lX_Min)
     
216.         lX_Min=sBufferArray[0][i];
     
217.       else if(sBufferArray[0][i]>lX_Max)
     
218.         lX_Max=sBufferArray[0][i];
     
219.     }
     
220.     for(i=1;i<10;i++)
     
221.     {
     
222.       if(sBufferArray[1][i]<lY_Min)
     
223.         lY_Min=sBufferArray[1][i];                        
     
224.       else if(sBufferArray[1][i]>lY_Max)
     
225.         lY_Max=sBufferArray[1][i];
     
226.     }               
     
227.    
     
228.     /*去除最小值和最大值之后求平均值*/
     
229.     *pTouch_AD_x=(sBufferArray[0][0]+sBufferArray[0][1]+sBufferArray[0][2]+sBufferArray[0][3]+sBufferArray[0][4]+
     
230.                sBufferArray[0][5]+sBufferArray[0][6]+sBufferArray[0][7]+sBufferArray[0][8]+sBufferArray[0][9]-lX_Min-lX_Max)>>3;
     
231.     *pTouch_AD_y=(sBufferArray[1][0]+sBufferArray[1][1]+sBufferArray[1][2]+sBufferArray[1][3]+sBufferArray[1][4]+
     
232.                sBufferArray[1][5]+sBufferArray[1][6]+sBufferArray[1][7]+sBufferArray[1][8]+sBufferArray[1][9]-lX_Min-lX_Max)>>3;
     
233.     return 0;
     
234.   }
     
235.   *pTouch_AD_x=-1;
     
236.   *pTouch_AD_y=-1;
     
237.   return 1;
     
238. }
     
239. 
     
240. /**
     
241.   * 函数功能: 电阻屏校准算法实现
     
242.   * 输入参数: XPT2046_Calibration结构体指针
     
243.   * 返 回 值: 0：计算成功，1：无法计算
     
244.   * 说    明：无
     
245.   */
     
246. static uint8_t perform_calibration(XPT2046_Calibration *cal)
     
247. {
     
248.         int j;
     
249.         float n, x, y, x2, y2, xy, z, zx, zy;
     
250.         float det, a, b, c, e, f, i;
     
251.         float scaling = 65536.0;
     
252. 
     
253. // Get sums for matrix
     
254.         n = x = y = x2 = y2 = xy = 0;
     
255.         for(j=0;j<5;j++) {
     
256.                 n += 1.0;
     
257.                 x += (float)cal->touch_x[j];
     
258.                 y += (float)cal->touch_y[j];
     
259.                 x2 += (float)(cal->touch_x[j]*cal->touch_x[j]);
     
260.                 y2 += (float)(cal->touch_y[j]*cal->touch_y[j]);
     
261.                 xy += (float)(cal->touch_x[j]*cal->touch_y[j]);
     
262.         }
     
263. 
     
264. // Get determinant of matrix -- check if determinant is too small
     
265.         det = n*(x2*y2 - xy*xy) + x*(xy*y - x*y2) + y*(x*xy - y*x2);
     
266.         if(det < 0.1 && det > -0.1) {
     
267. //                printf("ts_calibrate: determinant is too small -- %f\n\r",det);
     
268.                 return 1;
     
269.         }
     
270. 
     
271. // Get elements of inverse matrix
     
272.         a = (x2*y2 - xy*xy)/det;
     
273.         b = (xy*y - x*y2)/det;
     
274.         c = (x*xy - y*x2)/det;
     
275.         e = (n*y2 - y*y)/det;
     
276.         f = (x*y - n*xy)/det;
     
277.         i = (n*x2 - x*x)/det;
     
278. 
     
279. // Get sums for x calibration
     
280.         z = zx = zy = 0;
     
281.         for(j=0;j<5;j++) {
     
282.                 z += (float)cal->lcd_x[j];
     
283.                 zx += (float)(cal->lcd_x[j]*cal->touch_x[j]);
     
284.                 zy += (float)(cal->lcd_x[j]*cal->touch_y[j]);
     
285.         }
     
286. 
     
287. // Now multiply out to get the calibration for framebuffer x coord
     
288.         cal->adjust[0] = (int32_t)((a*z + b*zx + c*zy)*(scaling));
     
289.         cal->adjust[1] = (int32_t)((b*z + e*zx + f*zy)*(scaling));
     
290.         cal->adjust[2] = (int32_t)((c*z + f*zx + i*zy)*(scaling));
     
291. 
     
292. //        printf("%f %f %f\n\r",(a*z + b*zx + c*zy),
     
293. //                                (b*z + e*zx + f*zy),
     
294. //                                (c*z + f*zx + i*zy));
     
295. 
     
296. // Get sums for y calibration
     
297.         z = zx = zy = 0;
     
298.         for(j=0;j<5;j++) {
     
299.                 z += (float)cal->lcd_y[j];
     
300.                 zx += (float)(cal->lcd_y[j]*cal->touch_x[j]);
     
301.                 zy += (float)(cal->lcd_y[j]*cal->touch_y[j]);
     
302.         }
     
303. 
     
304. // Now multiply out to get the calibration for framebuffer y coord
     
305.         cal->adjust[3] = (int32_t)((a*z + b*zx + c*zy)*(scaling));
     
306.         cal->adjust[4] = (int32_t)((b*z + e*zx + f*zy)*(scaling));
     
307.         cal->adjust[5] = (int32_t)((c*z + f*zx + i*zy)*(scaling));
     
308. 
     
309. //        printf("%f %f %f\n\r",(a*z + b*zx + c*zy),
     
310. //                                (b*z + e*zx + f*zy),
     
311. //                                (c*z + f*zx + i*zy));
     
312. 
     
313. // If we got here, we're OK, so assign scaling to a[6] and return
     
314.         cal->adjust[6] = (int32_t)scaling;
     
315.         return 0;
     
316. }
     
317. 
     
318. /**
     
319.   * 函数功能: 触摸屏校正函数
     
320.   * 输入参数: 无
     
321.   * 返 回 值: 0：校正成功
     
322.   *           1：校正失败
     
323.   * 说    明：无
     
324.   */
     
325. uint8_t XPT2046_Touch_Calibrate(void)
     
326. {  
     
327.   uint8_t i;  
     
328. 
     
329.   uint16_t usTest_x=0,usTest_y=0;  
     
330.   
     
331.   /* 设定“十”字交叉点的坐标 */
     
332.   cal_value.lcd_x[0]=20;
     
333.   cal_value.lcd_y[0]=20;
     
334.   
     
335.   cal_value.lcd_x[1]=20;
     
336.   cal_value.lcd_y[1]=LCD_DEFAULT_HEIGTH-20;
     
337.   
     
338.   cal_value.lcd_x[2]=LCD_DEFAULT_WIDTH-20;
     
339.   cal_value.lcd_y[2]=cal_value.lcd_y[1];
     
340.   
     
341.   cal_value.lcd_x[3]=cal_value.lcd_x[2];
     
342.   cal_value.lcd_y[3]=cal_value.lcd_y[0];        
     
343.   
     
344.   cal_value.lcd_x[4]=LCD_DEFAULT_WIDTH/2;
     
345.   cal_value.lcd_y[4]=LCD_DEFAULT_HEIGTH/2;        
     
346.   
     
347.   for(i=0; i<5; i++)
     
348.   {        
     
349.     LCD_Clear(0, 0,LCD_DEFAULT_WIDTH, LCD_DEFAULT_HEIGTH, BACKGROUND);        
     
350.     LCD_DispString_EN(50,120,"Touch Calibrate...",BACKGROUND,BLUE,USB_FONT_24);                 
     
351.     LCD_DispChar_EN(150, 80, i+'1',BACKGROUND,RED,USB_FONT_24);
     
352. 
     
353.     /* 适当的延时很有必要 */        
     
354.     XPT2046_DelayUS(200000);   
     
355.     LCD_DrawCross(cal_value.lcd_x[i],cal_value.lcd_y[i]); //显示校正用的“十”字   
     
356.     XPT2046_ReadAdc_Smooth_XY(&cal_value.touch_x[i],&cal_value.touch_y[i],1);
     
357.   }
     
358.   
     
359.   if(perform_calibration(&cal_value)==1)
     
360.   {
     
361. //                printf("Calibration failed.\n\r");
     
362.     return 1;
     
363.         }
     
364. 
     
365.   /* 用原始参数计算出 原始参数与坐标的转换系数。 */
     
366.   for(i=0; i<2; i++)
     
367.   {   
     
368.     int xtemp,ytemp,usGap_x,usGap_y;      
     
369.     xtemp=cal_value.touch_x[2*i];
     
370.     ytemp=cal_value.touch_y[2*i];
     
371. //    printf("before Calibration x=(%d)-> %d y=(%d)-> %d\n\r",cal_value.lcd_x[2*i],xtemp,cal_value.lcd_y[2*i],ytemp);
     
372.    
     
373.                 usTest_x=(int)((cal_value.adjust[0]+cal_value.adjust[1]*xtemp+cal_value.adjust[2]*ytemp)/cal_value.adjust[6]);
     
374.                 usTest_y=(int)((cal_value.adjust[3]+cal_value.adjust[4]*xtemp+cal_value.adjust[5]*ytemp)/cal_value.adjust[6]);
     
375. //          printf("after Calibration x = %d y=%d\n\r",usTest_x,usTest_y);
     
376.    
     
377.     usGap_x=(usTest_x>cal_value.lcd_x[2*i])?(usTest_x-cal_value.lcd_x[2*i]):(cal_value.lcd_x[2*i]-usTest_x);   //实际X坐标与计算坐标的绝对差
     
378.     usGap_y=(usTest_y>cal_value.lcd_y[2*i])?(usTest_y-cal_value.lcd_y[2*i]):(cal_value.lcd_y[2*i]-usTest_y);   //实际Y坐标与计算坐标的绝对差
     
379.   
     
380.     if((usGap_x>10)||(usGap_y>10))
     
381.     {
     
382.       LCD_Clear(0, 0,LCD_DEFAULT_WIDTH, LCD_DEFAULT_HEIGTH, BACKGROUND);   
     
383.       LCD_DispString_EN(80,100,"Calibrate fail",BACKGROUND,RED,USB_FONT_24);
     
384.       LCD_DispString_EN(110,130,"try again",BACKGROUND,RED,USB_FONT_16);
     
385.       XPT2046_DelayUS(1000000);   
     
386.       return 1;   
     
387.     }      
     
388.   }
     
389.   
     
390.   cal_value.cal_flag = 0xAA55;
     
391.   SPI_FLASH_SectorErase(XPT2046_SPIFLASH_ADDR);
     
392.   SPI_FLASH_BufferWrite((uint8_t *)&cal_value,XPT2046_SPIFLASH_ADDR, sizeof(XPT2046_Calibration));
     
393.   
     
394.   LCD_Clear(0, 0,LCD_DEFAULT_WIDTH, LCD_DEFAULT_HEIGTH, BACKGROUND);
     
395.   LCD_DispString_EN(50,100,"Calibrate Succed",BACKGROUND,BLUE,USB_FONT_24);
     
396.   XPT2046_DelayUS(1000000);
     
397.   LCD_Clear(0, 0,LCD_DEFAULT_WIDTH, LCD_DEFAULT_HEIGTH, BACKGROUND);
     
398.   return 0;   
     
399. }
     
400. 
     
401. /**
     
402.   * 函数功能: 获取 XPT2046 触摸点（校准后）的坐标
     
403.   * 输入参数: pLCD_x：校准后x的坐标
     
404.   *           pLCD_y：校准后y的坐标
     
405.   * 返 回 值: 无
     
406.   * 说    明：无
     
407.   */
     
408. void XPT2046_Get_TouchedPoint(uint16_t *pLCD_x,uint16_t *pLCD_y)
     
409. {
     
410.   int xtemp,ytemp;
     
411.   
     
412.   if(XPT2046_ReadAdc_Smooth_XY(&xtemp,&ytemp,0)==0)
     
413.   {
     
414.     *pLCD_x=(uint16_t)((cal_value.adjust[0]+cal_value.adjust[1]*xtemp+cal_value.adjust[2]*ytemp)/cal_value.adjust[6]);
     
415.     *pLCD_y=(uint16_t)((cal_value.adjust[3]+cal_value.adjust[4]*xtemp+cal_value.adjust[5]*ytemp)/cal_value.adjust[6]);
     
416.   }
     
417.   else
     
418.   {
     
419.     *pLCD_x=0xFFFF;
     
420.     *pLCD_y=0xFFFF;
     
421.   }
     
422.   
     
423. }
     
424. 
     
425. /**
     
426.   * 函数功能: 在LCD指定位置画一个大点(包含9个小点)
     
427.   * 输入参数: x：x坐标
     
428.   *           y：y坐标
     
429.   *           usColor：点的颜色
     
430.   * 返 回 值: 无
     
431.   * 说    明：无
     
432.   */
     
433. void Palette_draw_point(uint16_t x, uint16_t y,uint16_t usColor)
     
434. {  
     
435.   LCD_SetPointPixel ( x-1, y-1, usColor );
     
436.   LCD_SetPointPixel (   x, y-1, usColor );
     
437.   LCD_SetPointPixel ( x+1, y-1, usColor );
     
438.   LCD_SetPointPixel ( x-1,   y, usColor );  
     
439.   LCD_SetPointPixel (   x,   y, usColor );  
     
440.   LCD_SetPointPixel ( x+1,   y, usColor );
     
441.   LCD_SetPointPixel ( x-1, y+1, usColor );  
     
442.   LCD_SetPointPixel (   x, y+1, usColor );  
     
443.   LCD_SetPointPixel ( x+1, y+1, usColor );
     
444. }
     
445. /******************* (C) COPYRIGHT 2015-2020 硬石嵌入式开发团队 *****END OF FILE****/
     

复制代码

eefishing

辛苦了，网友你也是真拼