【开源】迪文串口屏与小凌派rk2206通信控制

dwin-hetingting

屏幕型号T5L DMG85480F050_01WTCZ02
1、迪文GUI设计，包含一个变量图标控制和2个text显示控件。注意中英文字库问题，字库可用DWIN DGUS软件的DGUS配置工具中的DGUS字库工具，生成0号字库，主要英文、数字和符号，中文字库用GBK编码制作字库。










2、迪文C51设计，串口2自定义处理小凌派rk2206的串口数据，并对显示控件进行控制。用keil开发C51单片机程序，主要main代码如下：

1. #include "sys.h"
   
2. #include "uart2.h"
   
3. #include "string.h"
   
4. 
   
5. #define FIRST_TXT    "手势结果：\0\0" //必须以两个字节的0x00或者两个字节的0xFF为文本结束标记
   
6. 
   
7. void main(void)
   
8. {   
   
9.         u16 len;
   
10.         s16 ges;
    
11.         u8  text_buf[32]={0};
    
12.         u16 ic_sta;//存储ICON值
    
13.         sys_init();//系统初始化
    
14.         
    
15.         sys_write_vp(0x2000,FIRST_TXT,sizeof(FIRST_TXT)/2+1);//给第一个文本显示控件设置文本内容
    
16.         
    
17.         uart2_init(115200);//初始化串口2
    
18.         
    
19.         while(1)
    
20.         {   
    
21.                 if(uart2_rx_sta&UART2_PACKET_OK)//接受到了串口数据包
    
22.                 {
    
23.                         len = uart2_rx_sta&UART2_PACKET_LEN;//得到串口数据包的长度,不包含"\r\n"或者'\n'结束符的长度
    
24.                         
    
25.                         ges = uart2_buf[0]+uart2_buf[1]*256;
    
26.                         switch(ges)
    
27.                         {
    
28.                                 case 1:
    
29.                                         ic_sta = 0;
    
30.                                         sys_write_vp(0x1000,(u8*)&ic_sta,1);
    
31.                                   sprintf(text_buf,"GES_UP:0x%x",ges);
    
32.                                 break;
    
33.                                 case 2:
    
34.                                         ic_sta = 1;
    
35.                                         sys_write_vp(0x1000,(u8*)&ic_sta,1);
    
36.                                   sprintf(text_buf,"GES_DOWN:0x%x",ges);
    
37.                                 break;
    
38.                                 case 4:
    
39.                                         ic_sta = 2;
    
40.                                         sys_write_vp(0x1000,(u8*)&ic_sta,1);
    
41.                                         sprintf(text_buf,"GES_LEFT:0x%x",ges);
    
42.                                 break;
    
43.                                 case 8:
    
44.                                         ic_sta = 3;
    
45.                                         sys_write_vp(0x1000,(u8*)&ic_sta,1);
    
46.                                   sprintf(text_buf,"GES_RIGHT:0x%x",ges);
    
47.                                 break;
    
48.                                 case 16:
    
49.                                         ic_sta = 4;
    
50.                                         sys_write_vp(0x1000,(u8*)&ic_sta,1);
    
51.                                   sprintf(text_buf,"GES_FORWARD:0x%x",ges);
    
52.                                 break;
    
53.                                 case 32:
    
54.                                         ic_sta = 5;
    
55.                                         sys_write_vp(0x1000,(u8*)&ic_sta,1);
    
56.                                   sprintf(text_buf,"GES_BACKWARD:0x%x",ges);
    
57.                                 break;
    
58.                                 case 64:
    
59.                                         ic_sta = 6;
    
60.                                         sys_write_vp(0x1000,(u8*)&ic_sta,1);
    
61.                                   sprintf(text_buf,"GES_CLOCKWISE:0x%x",ges);
    
62.                                 break;
    
63.                                 case 128:
    
64.                                         ic_sta = 7;
    
65.                                         sys_write_vp(0x1000,(u8*)&ic_sta,1);
    
66.                                   sprintf(text_buf,"GES_COUNT_CLOCKWISE:0x%x",ges);
    
67.                                 break;
    
68.                                 case 256:
    
69.                                         ic_sta = 8;
    
70.                                         sys_write_vp(0x1000,(u8*)&ic_sta,1);
    
71.                                   sprintf(text_buf,"GES_WAVE:0x%x",ges);
    
72.                                 break;
    
73.                                 default:
    
74.                                        
    
75.                                         break;
    
76.                         }
    
77.                         len = strlen(text_buf);
    
78.                         text_buf[len++] = 0;
    
79.                         text_buf[len++] = 0;
    
80.                         sys_write_vp(0x2064,text_buf,len/2+1);//同时把数据包显示到界面上
    
81.                         
    
82.                         uart2_rx_sta = 0;//清0代表处理掉了此串口包
    
83.                 }
    
84.         }
    
85. }
    
86. 
    

复制代码

完整代码附件上传。KEIL工程我加入了直接生成T5L51.bin文件功能，大家可以打开工程查看。目标文件修改需要修改bat文件。
3、小凌派rk2206手势控制传感器结果，由串口发送给迪文串口屏的串口2.小凌派跑的是鸿蒙系统，没有的可以使用其他对接开发板即可，也可用另一51单片机串口发送控制，用按键即可，都可以。手里正好有这个板子。

1. /*
   
2. * Copyright (c) 2022 FuZhou Lockzhiner Electronic Co., Ltd. All rights reserved.
   
3. * Licensed under the Apache License, Version 2.0 (the "License");
   
4. * you may not use this file except in compliance with the License.
   
5. * You may obtain a copy of the License at
   
6. *
   
7. *     http://www.apache.org/licenses/LICENSE-2.0
   
8. *
   
9. * Unless required by applicable law or agreed to in writing, software
   
10. * distributed under the License is distributed on an "AS IS" BASIS,
    
11. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    
12. * See the License for the specific language governing permissions and
    
13. * limitations under the License.
    
14. */
    
15. #include <stdio.h>
    
16. #include "los_task.h"
    
17. #include "ohos_init.h"
    
18. #include "lz_hardware.h"
    
19. #include "e53_gesture_sensor.h"
    
20. 
    
21. /* E53模块中
    
22. * UART0_RX_M0 -> GPIO0_B6
    
23. * UART0_TX_M0 -> GPIO0_B7
    
24. */
    
25. #define UART_ID                 0
    
26. 
    
27. unsigned short getCRC16(unsigned char *ptr,unsigned char len)
    
28. {
    
29.                 unsigned char i;
    
30.                 unsigned short crc = 0xFFFF;
    
31.                
    
32.                 if(ptr==0)
    
33.                 {
    
34.                                 return 0;
    
35.                 }
    
36.                 if(len==0)
    
37.                 {
    
38.                         len = 1;
    
39.                 }
    
40.                 //if(len<=255)
    
41.                 {
    
42.                                 while(len--)
    
43.                                 {
    
44.                                                 crc ^= *ptr;
    
45.                                                 for(i=0; i<8; i++)
    
46.                                                 {
    
47.                                                         if(crc&1)
    
48.                                                         {
    
49.                                                                 crc >>= 1;
    
50.                                                                 crc ^= 0xA001;
    
51.                                                         }
    
52.                                                         else
    
53.                                                                 crc >>= 1;
    
54.                                                 }
    
55.                                                 ptr++;
    
56.                                 }
    
57.                 }
    
58.                 return(crc);
    
59. }
    
60. void uart0_init(void)
    
61. {
    
62.     unsigned int ret;
    
63.     UartAttribute attr;
    
64.    
    
65.     LzUartDeinit(UART_ID);
    
66.    
    
67.     attr.baudRate = 115200;
    
68.     attr.dataBits = UART_DATA_BIT_8;
    
69.     attr.pad = FLOW_CTRL_NONE;
    
70.     attr.parity = UART_PARITY_NONE;
    
71.     attr.rxBlock = UART_BLOCK_STATE_NONE_BLOCK;
    
72.     attr.stopBits = UART_STOP_BIT_1;
    
73.     attr.txBlock = UART_BLOCK_STATE_NONE_BLOCK;
    
74.    
    
75.     PinctrlSet(GPIO0_PB6, MUX_FUNC2, PULL_KEEP, DRIVE_LEVEL2);
    
76.     PinctrlSet(GPIO0_PB7, MUX_FUNC2, PULL_KEEP, DRIVE_LEVEL2);
    
77.    
    
78.     ret = LzUartInit(UART_ID, &attr);
    
79.     if (ret != LZ_HARDWARE_SUCCESS)
    
80.     {
    
81.         printf("%s, %d: LzUartInit(%d) failed!\n", __FILE__, __LINE__, ret);
    
82.         return;
    
83.     }
    
84.    
    
85.     return;
    
86. }
    
87. void e53_gs_process(void *arg)
    
88. {
    
89.     unsigned int ret = 0;
    
90.                 unsigned int i=0;
    
91.     unsigned short flag = 0;
    
92.                 unsigned short rc = 0;
    
93.     unsigned char tubiao[16] = {0};
    
94.                 unsigned char tubiao_str[48] = {0};
    
95.    
    
96.     e53_gs_init();
    
97.     uart0_init();
    
98.    
    
99.                  ret = LzUartWrite(UART_ID, tubiao, 4);
    
100.     if (ret != LZ_HARDWARE_SUCCESS)
     
101.     {
     
102.         printf("%s, %d: LzUartInit(%d) failed!\n", __FILE__, __LINE__, ret);
     
103.         return;
     
104.     }
     
105.    
     
106.     while (1)
     
107.     {
     
108.         ret = e53_gs_get_gesture_state(&flag);
     
109.         if (ret != 0)
     
110.         {
     
111.             printf("Get Gesture Statu: 0x%x\n", flag);
     
112.             if (flag & GES_UP)
     
113.             {
     
114.                 printf("\tUp\n");
     
115.             }
     
116.             if (flag & GES_DOWM)
     
117.             {
     
118.                 printf("\tDown\n");
     
119.             }
     
120.             if (flag & GES_LEFT)
     
121.             {
     
122.                 printf("\tLeft\n");
     
123.             }
     
124.             if (flag & GES_RIGHT)
     
125.             {
     
126.                 printf("\tRight\n");
     
127.             }
     
128.             if (flag & GES_FORWARD)
     
129.             {
     
130.                 printf("\tForward\n");
     
131.             }
     
132.             if (flag & GES_BACKWARD)
     
133.             {
     
134.                 printf("\tBackward\n");
     
135.             }
     
136.             if (flag & GES_CLOCKWISE)
     
137.             {
     
138.                 printf("\tClockwise\n");
     
139.             }
     
140.             if (flag & GES_COUNT_CLOCKWISE)
     
141.             {
     
142.                 printf("\tCount Clockwise\n");
     
143.             }
     
144.             if (flag & GES_WAVE)
     
145.             {
     
146.                 printf("\tWave\n");
     
147.             }
     
148.             
     
149.             e53_gs_led_up_set((flag & GES_UP) ? (1) : (0));
     
150.             e53_gs_led_down_set((flag & GES_DOWM) ? (1) : (0));
     
151.             e53_gs_led_left_set((flag & GES_LEFT) ? (1) : (0));
     
152.             e53_gs_led_right_set((flag & GES_RIGHT) ? (1) : (0));
     
153.             e53_gs_led_forward_set((flag & GES_FORWARD) ? (1) : (0));
     
154.             e53_gs_led_backward_set((flag & GES_BACKWARD) ? (1) : (0));
     
155.             e53_gs_led_cw_set((flag & GES_CLOCKWISE) ? (1) : (0));
     
156.             e53_gs_led_ccw_set((flag & GES_COUNT_CLOCKWISE) ? (1) : (0));
     
157.             e53_gs_led_wave_set((flag & GES_WAVE) ? (1) : (0));
     
158.             
     
159.             tubiao[0] = flag;
     
160.             tubiao[1] = (flag&0xff00)>>8;
     
161.             tubiao[2] = '\r';
     
162.             tubiao[3] = '\n';
     
163.                                                 printf("tubiao：\n");
     
164.                                                 for(i=0;i<4;i++) {
     
165.                                                         sprintf(tubiao_str+i*3, "%02X ", tubiao[i] & 0xFF);
     
166.                                                 }
     
167.                                                 printf("DOWN HEX: %s", tubiao_str);
     
168.                                                 printf("\n");
     
169.             ret = LzUartWrite(UART_ID, tubiao, 4);
     
170.             if (ret != LZ_HARDWARE_SUCCESS)
     
171.             {
     
172.                 printf("%s, %d: LzUartInit(%d) failed!\n", __FILE__, __LINE__, ret);
     
173.                 return;
     
174.             }
     
175.         }
     
176.         else
     
177.         {
     
178.             /* 如果没有数据，则多等待 */
     
179.             LOS_Msleep(100);
     
180.         }
     
181.     }
     
182. }
     
183. 
     
184. void e53_gs_example()
     
185. {
     
186.     unsigned int thread_id;
     
187.     TSK_INIT_PARAM_S task = {0};
     
188.     unsigned int ret = LOS_OK;
     
189. 
     
190.     task.pfnTaskEntry = (TSK_ENTRY_FUNC)e53_gs_process;
     
191.     task.uwStackSize = 2048;
     
192.     task.pcName = "e53 getsture sensor process";
     
193.     task.usTaskPrio = 24;
     
194.     ret = LOS_TaskCreate(&thread_id, &task);
     
195.     if (ret != LOS_OK)
     
196.     {
     
197.         printf("Falied to create Task_One ret:0x%x\n", ret);
     
198.         return;
     
199.     }
     
200. }
     
201. 
     
202. APP_FEATURE_INIT(e53_gs_example);
     

复制代码

代码附件可见