【开源】无线调试器

二哲科技

1、介绍

目前很多单片机调试都是采用串口，而有些设备的调试接口不会暴露在外边，为此我设计了一款无线调试器，可以通过无线的方式监测设备信息数据。同时搭配了锂电池，实现真无线调试，锂电池没电的时候可以通过TypeC进行充电。

2、硬件准备
这次选用了4.3英寸迪文科技COF串口屏DMG80480F043_01W

设计了一块电路板，电路板上有ESP32-C3 WIFI芯片还有PCF8563时钟芯片，其中ESP32-C3和迪文屏采用串口通信，PCF8563和迪文屏采用IIC通信，电路原理图如下：

屏幕选择了一个白色的，所以电路板也设计了一个白色的。


3、界面设计
界面采用了科技风，让其更富有科技感，界面设计的AI工作如下：

接下来就是界面的设计，首先就是首页，有一个进入按钮。

接下来是调试界面，左上角是显示当前时间，右上角有一个进入WIFI设置的按钮，右边显示页数，还有显示时间戳，最下面是清除当前界面，左边部分就是显示调试信息，可以显示连接的设备情况。

WIFI信息部分，主要显示WIFI信息，有修改名字和密码的按钮。

点击修改WIFI名字，就可以进入WIFI名字修改界面，设计的是全字母+数字以及一些字符

修改WIFI密码类似，最多可以设计32位。

为了按钮显示效果好，还修改了设计了按下的界面，按键边缘发黑。


4、程序设计
程序分为Dwin和ESP32，Dwin主要是接收串口数据，然后显示出来，同时获取PCF8563时钟芯片的数据，主要代码如下：

1. /*协议
   
2. AA 03 31 32 33
   
3. AA为协议，添加显示内容
   
4. 03为后续内容长度
   
5. 31 32 33为内容
   
6. */
   
7. //u8 rec_data_g[40];
   
8. void esp32_analysis(u8 rec_data[])
   
9. {
   
10.     int i = 0;
    
11.     int pass = 0;
    
12.     u8 date_temp[256] = {0};
    
13. 
    
14.     if(rec_data[0] == 0xAA) //显示内容
    
15.     {
    
16.         if(display_time == 0)
    
17.         {
    
18.             memcpy(date_temp, &rec_data[2], rec_data[1]);
    
19.         }
    
20.         else
    
21.         {
    
22.             getTimeStr(date_temp);
    
23.             memcpy(&date_temp[10], &rec_data[2], rec_data[1]);
    
24.         }
    
25. 
    
26.         display_current_line += line_check(date_temp);
    
27.         if(display_current_line > 10)
    
28.         {
    
29.             display_current_line = 1;
    
30.             if(display_page_total < 10)
    
31.             {
    
32.                 if(display_page_current == display_page_total)
    
33.                 {
    
34.                     display_page_current++;
    
35.                 }
    
36.                 display_page_total++;
    
37.             }
    
38.             else
    
39.             {
    
40.                 for(i = 0;i < 9;i++)
    
41.                 {
    
42.                     memcpy(display_data[i], display_data[i+1], 512);
    
43.                 }
    
44.                 memset(display_data[9], 0, 512);
    
45.                 if(display_page_current != display_page_total)
    
46.                 {
    
47.                     if(display_page_current > 1)
    
48.                     {
    
49.                         display_page_current--;
    
50.                     }
    
51.                 }
    
52.             }
    
53.             display_page_str[0] = display_page_current / 10 + 0x30;
    
54.             display_page_str[1] = display_page_current % 10 + 0x30;
    
55.             display_page_str[3] = display_page_total / 10 + 0x30;
    
56.             display_page_str[4] = display_page_total % 10 + 0x30;
    
57.             write_dgus_vp(0x2120, display_page_str, 8);
    
58.         }
    
59.         memcpy(&display_data[display_page_total - 1][strlen(display_data[display_page_total - 1])], date_temp, strlen(date_temp));
    
60.         write_dgus_vp(0x3000, display_data[display_page_current - 1], strlen(display_data[display_page_current - 1]));
    
61.     }
    
62.     else if(rec_data[0] == 0xAB) //wifi名字和密码
    
63.     {
    
64.         memset(wifi_ssid, 0, 32);
    
65.         memset(wifi_pass, 0, 32);
    
66.         for(i = 0;i < rec_data[1];i++)
    
67.         {
    
68.             if(rec_data[i + 2] != ',')
    
69.             {
    
70.                 if(pass == 0)
    
71.                 {
    
72.                     wifi_ssid[strlen(wifi_ssid)] = rec_data[i + 2];
    
73.                 }
    
74.                 else
    
75.                 {
    
76.                     wifi_pass[strlen(wifi_pass)] = rec_data[i + 2];
    
77.                 }
    
78.             }
    
79.             else
    
80.             {
    
81.                 pass = 1;
    
82.             }
    
83.         }
    
84.         refresh_wifi_ssid();
    
85.         refresh_wifi_pass();
    
86.     }
    
87.     else if(rec_data[0] == 0xAC)
    
88.     {
    
89.         myTime.year = RTC_BinToBcd2((rec_data[4] - 0x30) * 10 + (rec_data[5] - 0x30));
    
90.         myTime.mon = RTC_BinToBcd2((rec_data[7] - 0x30) * 10 + (rec_data[8] - 0x30));
    
91.         myTime.day = RTC_BinToBcd2((rec_data[10] - 0x30) * 10 + (rec_data[11] - 0x30));
    
92.         myTime.hour = RTC_BinToBcd2((rec_data[13] - 0x30) * 10 + (rec_data[14] - 0x30));
    
93.         myTime.min = RTC_BinToBcd2((rec_data[16] - 0x30) * 10 + (rec_data[17] - 0x30));
    
94.         myTime.sec = RTC_BinToBcd2((rec_data[19] - 0x30) * 10 + (rec_data[20] - 0x30));
    
95.         SetRealTime(&myTime);
    
96.     }
    
97. }
    
98. 
    
99. //发送wifi名字
    
100. void send_wifi_ssid(u8 wifi_temp[])
     
101. {
     
102.     u8 wifi_send[40] = {0xAA};
     
103. 
     
104.     wifi_send[1] = strlen(wifi_temp) + 1;
     
105.     wifi_send[2] = 0x01;
     
106.     memcpy(&wifi_send[3], wifi_temp, strlen(wifi_temp));
     
107. 
     
108.     Uatr_Send_Data(4, wifi_send, wifi_send[1] + 2);
     
109. }
     
110. 
     
111. //发送wifi密码
     
112. void send_wifi_pass(u8 wifi_temp[])
     
113. {
     
114.     u8 wifi_send[40] = {0xAA};
     
115. 
     
116.     wifi_send[1] = strlen(wifi_temp) + 1;
     
117.     wifi_send[2] = 0x02;
     
118.     memcpy(&wifi_send[3], wifi_temp, strlen(wifi_temp));
     
119. 
     
120.     Uatr_Send_Data(4, wifi_send, wifi_send[1] + 2);
     
121. }
     
122. 
     
123. 
     
124. 
     
125. void refresh_time()
     
126. {
     
127.     GetRealTime(&myTime);
     
128. 
     
129.     Write_Dgus(0x2100, 2);
     
130.     Write_Dgus(0x2102, 0);
     
131.     Write_Dgus(0x2104, myTime.year/16%10);
     
132.     Write_Dgus(0x2106, myTime.year%16);
     
133. 
     
134.     Write_Dgus(0x210A, RTC_Bcd2ToBin(myTime.mon)/10%10);
     
135.     Write_Dgus(0x210C, RTC_Bcd2ToBin(myTime.mon)%10);
     
136. 
     
137.     Write_Dgus(0x2110, RTC_Bcd2ToBin(myTime.day)/10%10);
     
138.     Write_Dgus(0x2112, RTC_Bcd2ToBin(myTime.day)%10);
     
139. 
     
140.     Write_Dgus(0x2114, RTC_Bcd2ToBin(myTime.hour)/10%10);
     
141.     Write_Dgus(0x2116, RTC_Bcd2ToBin(myTime.hour)%10);
     
142. 
     
143.     Write_Dgus(0x211A, RTC_Bcd2ToBin(myTime.min)/10%10);
     
144.     Write_Dgus(0x211C, RTC_Bcd2ToBin(myTime.min)%10);
     
145. 
     
146. }

复制代码

ESP32则是保存WIFI名称和密码，同时将WIFI的情况通过串口发送给Dwin屏，主要代码如下：

1. 
   
2. static void udp_server_task(void *pvParameters)
   
3. {
   
4.     char rx_buffer[120];
   
5.     char addr_str[120];
   
6.     int addr_family = (int)pvParameters;
   
7.     int ip_protocol = 0;
   
8.     struct sockaddr_in6 dest_addr;
   
9. 
   
10.     while (1) {
    
11. 
    
12.         if (addr_family == AF_INET) {
    
13.             struct sockaddr_in *dest_addr_ip4 = (struct sockaddr_in *)&dest_addr;
    
14.             dest_addr_ip4->sin_addr.s_addr = htonl(INADDR_ANY);
    
15.             dest_addr_ip4->sin_family = AF_INET;
    
16.             dest_addr_ip4->sin_port = htons(BROADCAST_PORT);
    
17.             ip_protocol = IPPROTO_IP;
    
18.         } else if (addr_family == AF_INET6) {
    
19.             bzero(&dest_addr.sin6_addr.un, sizeof(dest_addr.sin6_addr.un));
    
20.             dest_addr.sin6_family = AF_INET6;
    
21.             dest_addr.sin6_port = htons(BROADCAST_PORT);
    
22.             ip_protocol = IPPROTO_IPV6;
    
23.         }
    
24. 
    
25.         int sock = socket(addr_family, SOCK_DGRAM, ip_protocol);
    
26.         if (sock < 0) {
    
27.             ESP_LOGE(TAG, "Unable to create socket: errno %d", errno);
    
28.             break;
    
29.         }
    
30.         ESP_LOGI(TAG, "Socket created");
    
31. 
    
32. #if defined(CONFIG_LWIP_NETBUF_RECVINFO) && !defined(CONFIG_EXAMPLE_IPV6)
    
33.         int enable = 1;
    
34.         lwip_setsockopt(sock, IPPROTO_IP, IP_PKTINFO, &enable, sizeof(enable));
    
35. #endif
    
36. 
    
37. #if defined(CONFIG_EXAMPLE_IPV4) && defined(CONFIG_EXAMPLE_IPV6)
    
38.         if (addr_family == AF_INET6) {
    
39.             // Note that by default IPV6 binds to both protocols, it is must be disabled
    
40.             // if both protocols used at the same time (used in CI)
    
41.             int opt = 1;
    
42.             setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    
43.             setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &opt, sizeof(opt));
    
44.         }
    
45. #endif
    
46.         // Set timeout
    
47.         struct timeval timeout;
    
48.         timeout.tv_sec = 10;
    
49.         timeout.tv_usec = 0;
    
50.         setsockopt (sock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof timeout);
    
51. 
    
52.         int err = bind(sock, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
    
53.         if (err < 0) {
    
54.             ESP_LOGE(TAG, "Socket unable to bind: errno %d", errno);
    
55.         }
    
56.         ESP_LOGI(TAG, "Socket bound, port %d", BROADCAST_PORT);
    
57. 
    
58.         struct sockaddr_storage source_addr; // Large enough for both IPv4 or IPv6
    
59.         socklen_t socklen = sizeof(source_addr);
    
60. 
    
61. #if defined(CONFIG_LWIP_NETBUF_RECVINFO) && !defined(CONFIG_EXAMPLE_IPV6)
    
62.         struct iovec iov;
    
63.         struct msghdr msg;
    
64.         struct cmsghdr *cmsgtmp;
    
65.         u8_t cmsg_buf[CMSG_SPACE(sizeof(struct in_pktinfo))];
    
66. 
    
67.         iov.iov_base = rx_buffer;
    
68.         iov.iov_len = sizeof(rx_buffer);
    
69.         msg.msg_control = cmsg_buf;
    
70.         msg.msg_controllen = sizeof(cmsg_buf);
    
71.         msg.msg_flags = 0;
    
72.         msg.msg_iov = &iov;
    
73.         msg.msg_iovlen = 1;
    
74.         msg.msg_name = (struct sockaddr *)&source_addr;
    
75.         msg.msg_namelen = socklen;
    
76. #endif
    
77. 
    
78.         while (1) {
    
79.             ESP_LOGI(TAG, "Waiting for data");
    
80. #if defined(CONFIG_LWIP_NETBUF_RECVINFO) && !defined(CONFIG_EXAMPLE_IPV6)
    
81.             int len = recvmsg(sock, &msg, 0);
    
82. #else
    
83.             int len = recvfrom(sock, rx_buffer, sizeof(rx_buffer) - 1, 0, (struct sockaddr *)&source_addr, &socklen);
    
84. #endif
    
85.             // Error occurred during receiving
    
86.             if (len < 0) {
    
87.                 ESP_LOGE(TAG, "recvfrom failed: errno %d", errno);
    
88.                 break;
    
89.             }
    
90.             // Data received
    
91.             else {
    
92.                 // Get the sender's ip address as string
    
93.                 if (source_addr.ss_family == PF_INET) {
    
94.                     inet_ntoa_r(((struct sockaddr_in *)&source_addr)->sin_addr, addr_str, sizeof(addr_str) - 1);
    
95. #if defined(CONFIG_LWIP_NETBUF_RECVINFO) && !defined(CONFIG_EXAMPLE_IPV6)
    
96.                     for ( cmsgtmp = CMSG_FIRSTHDR(&msg); cmsgtmp != NULL; cmsgtmp = CMSG_NXTHDR(&msg, cmsgtmp) ) {
    
97.                         if ( cmsgtmp->cmsg_level == IPPROTO_IP && cmsgtmp->cmsg_type == IP_PKTINFO ) {
    
98.                             struct in_pktinfo *pktinfo;
    
99.                             pktinfo = (struct in_pktinfo*)CMSG_DATA(cmsgtmp);
    
100.                             ESP_LOGI(TAG, "dest ip: %s", inet_ntoa(pktinfo->ipi_addr));
     
101.                         }
     
102.                     }
     
103. #endif
     
104.                 } else if (source_addr.ss_family == PF_INET6) {
     
105.                     inet6_ntoa_r(((struct sockaddr_in6 *)&source_addr)->sin6_addr, addr_str, sizeof(addr_str) - 1);
     
106.                 }
     
107. 
     
108.                 rx_buffer[len] = 0; // Null-terminate whatever we received and treat like a string...
     
109.                 ESP_LOGI(TAG, "Received %d bytes from %s:", len, addr_str);
     
110.                 ESP_LOGI(TAG, "%s", rx_buffer);
     
111.                 char send_data[256] = {0};
     
112.                 sprintf(send_data, "[R]%s:%s\r\n", addr_str, rx_buffer);
     
113.                 ESP_LOGI(TAG, "send_data: %s", send_data);
     
114.                 dwin_screen_display(send_data, strlen(send_data));
     
115.                 if(rx_buffer[0] == 't' && rx_buffer[1] == 'i' && rx_buffer[2] == 'm' && rx_buffer[3] == 'e' && rx_buffer[4] == ':' )
     
116.                 {
     
117.                     dwin_screen_datetime(&rx_buffer[5], 19);
     
118.                 }
     
119. 
     
120.                 // int err = sendto(sock, rx_buffer, len, 0, (struct sockaddr *)&source_addr, sizeof(source_addr));
     
121.                 // if (err < 0) {
     
122.                 //     ESP_LOGE(TAG, "Error occurred during sending: errno %d", errno);
     
123.                 //     break;
     
124.                 // }
     
125.             }
     
126.         }
     
127. 
     
128.         if (sock != -1) {
     
129.             ESP_LOGE(TAG, "Shutting down socket and restarting...");
     
130.             shutdown(sock, 0);
     
131.             close(sock);
     
132.         }
     
133.     }
     
134.     vTaskDelete(NULL);
     
135. }
     
136. 
     
137. // Mount path for the partition
     
138. const char *base_path = "/spiflash";
     
139. 
     
140. // Handle of the wear levelling library instance
     
141. static wl_handle_t s_wl_handle = WL_INVALID_HANDLE;
     
142. 
     
143. void wifi_write_flash()
     
144. {
     
145.     char write_data[65] = {0};
     
146.     ESP_LOGI(TAG, "Opening file write");
     
147.     FILE *f;
     
148.    
     
149.     f = fopen(device_filename, "wb");
     
150.     if (f == NULL) {
     
151.         ESP_LOGE(TAG, "Failed to open file for writing");
     
152.         return;
     
153.     }
     
154. 
     
155.     sprintf(write_data, "%s,%s", wifi_ssid, wifi_pass);
     
156. 
     
157.     fprintf(f, write_data);
     
158.     fclose(f);
     
159. }
     
160. 
     
161. void app_main(void)
     
162. {
     
163.     //Initialize NVS
     
164.     esp_err_t ret = nvs_flash_init();
     
165.     if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
     
166.       ESP_ERROR_CHECK(nvs_flash_erase());
     
167.       ret = nvs_flash_init();
     
168.     }
     
169.     ESP_ERROR_CHECK(ret);
     
170. 
     
171.     vTaskDelay(1000 / portTICK_PERIOD_MS);     //100ms
     
172. 
     
173.     dwin_init();
     
174. 
     
175.     vTaskDelay(2000 / portTICK_PERIOD_MS);     //100ms
     
176. 
     
177.     ESP_LOGI(TAG, "Mounting FAT filesystem");
     
178.     // To mount device we need name of device partition, define base_path
     
179.     // and allow format partition in case if it is new one and was not formatted before
     
180.     const esp_vfs_fat_mount_config_t mount_config = {
     
181.             .max_files = 4,
     
182.             .format_if_mount_failed = false,
     
183.             .allocation_unit_size = CONFIG_WL_SECTOR_SIZE
     
184.     };
     
185.     esp_err_t err;
     
186.     if (EXAMPLE_FATFS_MODE_READ_ONLY){
     
187.         err = esp_vfs_fat_spiflash_mount_ro(base_path, "storage", &mount_config);
     
188.     } else {
     
189.         err = esp_vfs_fat_spiflash_mount_rw_wl(base_path, "storage", &mount_config, &s_wl_handle);
     
190.     }
     
191. 
     
192.     if (err != ESP_OK) {
     
193.         ESP_LOGE(TAG, "Failed to mount FATFS (%s)", esp_err_to_name(err));
     
194.         return;
     
195.     }
     
196. 
     
197.     char line[128];
     
198.    
     
199.     ESP_LOGI(TAG, "Opening file write");
     
200. 
     
201.     // Open file for reading
     
202.     ESP_LOGI(TAG, "Reading file read");
     
203.     FILE *f;
     
204.     f = fopen(device_filename, "rb");
     
205.     if (f != NULL) {
     
206.         // ESP_LOGE(TAG, "Failed to open file for reading");
     
207.         fgets(line, sizeof(line), f);
     
208.         fclose(f);
     
209.         // strip newline
     
210.         char *pos = strchr(line, '\n');
     
211.         if (pos) {
     
212.             *pos = '\0';
     
213.         }
     
214.         ESP_LOGI(TAG, "Read from file: '%s'", line);
     
215. 
     
216.         int split_cnt = 0;
     
217.         while(line[split_cnt] != ',')
     
218.         {
     
219.             split_cnt++;
     
220.         }
     
221. 
     
222.         memcpy(wifi_ssid, line, split_cnt);
     
223.         memcpy(wifi_pass, &line[split_cnt + 1], strlen(line) - split_cnt);
     
224. 
     
225.         dwin_screen_wifi(line, strlen(line));   //给屏幕发送WIFI
     
226.         // dwin_screen_wifi(line, strlen(line));   //给屏幕发送WIFI
     
227.         // dwin_screen_wifi(line, strlen(line));   //给屏幕发送WIFI
     
228. 
     
229.         wifi_ssid[split_cnt] = '\0';
     
230.         wifi_pass[strlen(line) - split_cnt] = '\0';
     
231.     }
     
232.    
     
233.     wifi_init_softap();
     
234.    
     
235. 
     
236.     xTaskCreate(udp_server_task, "udp_server", 4096, (void*)AF_INET, 5, NULL);
     
237.     xTaskCreate(softap_check_ip_task, "softap_check_ip", 4096, (void*)AF_INET, 5, NULL);
     
238. 
     
239. }
     

复制代码

演示视频：