新版CMSIS-DAP V2.0.1增加了一个DAP 硬件UART的玩法，类似SWO引脚的另一种方式

eric2013

CMSIS V5.8.0软件包下个月应该就正式发布了，当前Github上已经更新，估计还有些待整理。

https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DAP/Firmware

在DAP协议上增加了个串口通信

eric2013

1. /*
   
2. * Copyright (c) 2021 ARM Limited. All rights reserved.
   
3. *
   
4. * SPDX-License-Identifier: Apache-2.0
   
5. *
   
6. * Licensed under the Apache License, Version 2.0 (the License); you may
   
7. * not use this file except in compliance with the License.
   
8. * You may obtain a copy of the License at
   
9. *
   
10. * www.apache.org/licenses/LICENSE-2.0
    
11. *
    
12. * Unless required by applicable law or agreed to in writing, software
    
13. * distributed under the License is distributed on an AS IS BASIS, WITHOUT
    
14. * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    
15. * See the License for the specific language governing permissions and
    
16. * limitations under the License.
    
17. *
    
18. * ----------------------------------------------------------------------
    
19. *
    
20. * $Date:        1. March 2021
    
21. * $Revision:    V1.0.0
    
22. *
    
23. * Project:      CMSIS-DAP Source
    
24. * Title:        UART.c CMSIS-DAP UART
    
25. *
    
26. *---------------------------------------------------------------------------*/
    
27. 
    
28. #include "DAP_config.h"
    
29. #include "DAP.h"
    
30. 
    
31. #if (DAP_UART != 0)
    
32. 
    
33. #ifdef DAP_FW_V1
    
34. #error "UART Communication Port not supported in DAP V1!"
    
35. #endif
    
36. 
    
37. #include "Driver_USART.h"
    
38. 
    
39. #include "cmsis_os2.h"
    
40. #include <string.h>
    
41. 
    
42. #define UART_TX_BUF_SIZE    1024U   /* Uart Tx Buffer (must be 2^n) */
    
43. #define UART_RX_BUF_SIZE    1024U   /* Uart Rx Buffer (must be 2^n) */
    
44. #define UART_RX_BLOCK_SIZE    32U   /* Uart Rx Block Size (must be 2^n) */
    
45. #define UART_MAX_XFER_NUM    509U
    
46. 
    
47. // USART Driver
    
48. #define _USART_Driver_(n)  Driver_USART##n
    
49. #define  USART_Driver_(n) _USART_Driver_(n)
    
50. extern ARM_DRIVER_USART    USART_Driver_(DAP_UART_DRIVER);
    
51. #define pUSART           (&USART_Driver_(DAP_UART_DRIVER))
    
52. 
    
53. // UART Configuration
    
54. static uint8_t  UartTransport = DAP_UART_TRANSPORT_USB_COM_PORT;
    
55. static uint8_t  UartControl   = 0U;
    
56. static uint32_t UartBaudrate  = 115200U;
    
57. 
    
58. // UART TX Buffer
    
59. static uint8_t UartTxBuf[UART_TX_BUF_SIZE];
    
60. static volatile uint32_t UartTxIndexI = 0U;
    
61. static volatile uint32_t UartTxIndexO = 0U;
    
62. 
    
63. // UART RX Buffer
    
64. static uint8_t UartRxBuf[UART_RX_BUF_SIZE];
    
65. static volatile uint32_t UartRxIndexI = 0U;
    
66. static volatile uint32_t UartRxIndexO = 0U;
    
67. 
    
68. // Uart Errors
    
69. static volatile uint8_t UartRxDataLost   = 0U;
    
70. static volatile uint8_t UartFramingError = 0U;
    
71. static volatile uint8_t UartParityError  = 0U;
    
72. 
    
73. // UART Transmit
    
74. static uint32_t UartTxNum = 0U;
    
75. 
    
76. // Function prototypes
    
77. static uint32_t UART_Start   (void);
    
78. static uint32_t UART_Stop    (void);
    
79. static void     UART_Send    (void);
    
80. static void     UART_Receive (void);
    
81. 
    
82. 
    
83. // USART Driver Callback function
    
84. //   event: event mask
    
85. static void USART_Callback (uint32_t event) {
    
86.   if (event &  ARM_USART_EVENT_SEND_COMPLETE) {
    
87.     UartTxIndexO += UartTxNum;
    
88.     UART_Send();
    
89.   }
    
90.   if (event &  ARM_USART_EVENT_RECEIVE_COMPLETE) {
    
91.     UartRxIndexI += UART_RX_BLOCK_SIZE;
    
92.     UART_Receive();
    
93.   }
    
94.   if (event &  ARM_USART_EVENT_RX_OVERFLOW) {
    
95.     UartRxDataLost = 1U;
    
96.   }
    
97.   if (event &  ARM_USART_EVENT_RX_FRAMING_ERROR) {
    
98.     UartFramingError = 1U;
    
99.   }
    
100.   if (event &  ARM_USART_EVENT_RX_PARITY_ERROR) {
     
101.     UartParityError = 1U;
     
102.   }
     
103. }
     
104. 
     
105. // Start UART
     
106. //   return: 1 - Success, 0 - Error
     
107. static uint32_t UART_Start (void) {
     
108.   int32_t status;
     
109.   uint32_t ret;
     
110. 
     
111.   UartTxNum = 0U;
     
112. 
     
113.   UartTxIndexI = 0U;
     
114.   UartTxIndexO = 0U;
     
115.   UartRxIndexI = 0U;
     
116.   UartRxIndexO = 0U;
     
117. 
     
118.   status = pUSART->Initialize(USART_Callback);
     
119. 
     
120.   if (status == ARM_DRIVER_OK) {
     
121.     status = pUSART->PowerControl(ARM_POWER_FULL);
     
122.   }
     
123. 
     
124.   if (status == ARM_DRIVER_OK) {
     
125.     status = pUSART->Control (UartControl |
     
126.                               ARM_USART_MODE_ASYNCHRONOUS |
     
127.                               ARM_USART_FLOW_CONTROL_NONE,
     
128.                               UartBaudrate);
     
129.   }
     
130. 
     
131.   if (status == ARM_DRIVER_OK) {
     
132.     UART_Receive();
     
133.     pUSART->Control (ARM_USART_CONTROL_TX, 1);
     
134.     pUSART->Control (ARM_USART_CONTROL_RX, 1);
     
135.   }
     
136. 
     
137.   if (status != ARM_DRIVER_OK) {
     
138.     pUSART->PowerControl(ARM_POWER_OFF);
     
139.     pUSART->Uninitialize();
     
140.   }
     
141. 
     
142.   if (status == ARM_DRIVER_OK) {
     
143.     ret = 1U;
     
144.   } else {
     
145.     ret = 0U;
     
146.   }
     
147. 
     
148.   return (ret);
     
149. }
     
150. 
     
151. // Stop UART
     
152. //   return: 1 - Success, 0 - Error
     
153. static uint32_t UART_Stop (void) {
     
154.   UartTxIndexI = 0U;
     
155.   UartTxIndexO = 0U;
     
156.   UartRxIndexI = 0U;
     
157.   UartRxIndexO = 0U;
     
158. 
     
159.   pUSART->Control(ARM_USART_ABORT_RECEIVE, 0U);
     
160.   pUSART->Control(ARM_USART_ABORT_SEND, 0U);
     
161.   pUSART->PowerControl(ARM_POWER_OFF);
     
162.   pUSART->Uninitialize();
     
163. 
     
164.   return (1U);
     
165. }
     
166. 
     
167. // Send available data to target via UART
     
168. static void UART_Send (void) {
     
169.   uint32_t count;
     
170.   uint32_t index;
     
171. 
     
172.   count = UartTxIndexI - UartTxIndexO;
     
173.   index = UartTxIndexO & (UART_TX_BUF_SIZE - 1);
     
174. 
     
175.   if (count != 0U) {
     
176.     if ((index + count) < UART_TX_BUF_SIZE) {
     
177.       UartTxNum = count;
     
178.     } else {
     
179.       UartTxNum = UART_TX_BUF_SIZE - index;
     
180.     }
     
181.     pUSART->Send(&UartTxBuf[index], UartTxNum);
     
182.   }
     
183. }
     
184. 
     
185. // Receive data from target via UART
     
186. static void UART_Receive (void) {
     
187.   uint16_t num;
     
188.   uint32_t count;
     
189.   uint32_t index;
     
190. 
     
191.   count = UartRxIndexI - UartRxIndexO;
     
192.   index = UartRxIndexI & (UART_RX_BUF_SIZE - 1);
     
193.   num   =  UART_RX_BLOCK_SIZE;
     
194. 
     
195.   if ((UART_RX_BUF_SIZE - count) >= num) {
     
196.     pUSART->Receive(&UartRxBuf[index], num);
     
197.   }
     
198. }
     
199. 
     
200. // Process UART Transport command and prepare response
     
201. //   request:  pointer to request data
     
202. //   response: pointer to response data
     
203. //   return:   number of bytes in response (lower 16 bits)
     
204. //             number of bytes in request (upper 16 bits)
     
205. uint32_t UART_Transport (const uint8_t *request, uint8_t *response) {
     
206.   uint8_t  transport;
     
207.   uint32_t result = 0U;
     
208. 
     
209.   transport = *request;
     
210.   switch (transport) {
     
211.     case DAP_UART_TRANSPORT_USB_COM_PORT:
     
212. #if (DAP_UART_USB_COM_PORT != 0U)
     
213.       if (UartTransport == DAP_UART_TRANSPORT_DAP_COMMAND) {
     
214.         result = UART_Stop();
     
215.         USB_COM_PORT_Activate(1U);
     
216.       } else {
     
217.         result = 1U;
     
218.       }
     
219.       UartTransport = transport;
     
220. #endif
     
221.       break;
     
222.     case DAP_UART_TRANSPORT_DAP_COMMAND:
     
223.       if (UartTransport != DAP_UART_TRANSPORT_DAP_COMMAND) {
     
224. #if (DAP_UART_USB_COM_PORT != 0U)
     
225.         USB_COM_PORT_Activate(0U);
     
226. #endif
     
227.         result = UART_Start();
     
228.       } else {
     
229.         result = 1U;
     
230.       }
     
231.       UartTransport = transport;
     
232.       break;
     
233.     default:
     
234.       result = 0U;
     
235.       break;
     
236.   }
     
237. 
     
238.   if (result != 0U) {
     
239.     *response = DAP_OK;
     
240.   } else {
     
241.     *response = DAP_ERROR;
     
242.   }
     
243. 
     
244.   return ((1U << 16) | 1U);
     
245. }
     
246. 
     
247. // Process UART Configure command and prepare response
     
248. //   request:  pointer to request data
     
249. //   response: pointer to response data
     
250. //   return:   number of bytes in response (lower 16 bits)
     
251. //             number of bytes in request (upper 16 bits)
     
252. uint32_t UART_Configure (const uint8_t *request, uint8_t *response) {
     
253.   uint8_t  control, status;
     
254.   uint32_t baudrate;
     
255.   int32_t  result;
     
256. 
     
257.   status   = 0U;
     
258.   control  = *request;
     
259.   baudrate = (uint32_t)(*(request+1) <<  0) |
     
260.              (uint32_t)(*(request+2) <<  8) |
     
261.              (uint32_t)(*(request+3) << 16) |
     
262.              (uint32_t)(*(request+4) << 24);
     
263. 
     
264.   if (UartTransport == DAP_UART_TRANSPORT_DAP_COMMAND) {
     
265.     result = pUSART->Control (control |
     
266.                               ARM_USART_MODE_ASYNCHRONOUS |
     
267.                               ARM_USART_FLOW_CONTROL_NONE,
     
268.                               baudrate);
     
269.     switch (result) {
     
270.       case ARM_USART_ERROR_BAUDRATE:
     
271.         status = 0U;
     
272.         baudrate = 0U;
     
273.         break;
     
274.       case ARM_USART_ERROR_DATA_BITS:
     
275.         status = (1U << 0);
     
276.         break;
     
277.       case ARM_USART_ERROR_STOP_BITS:
     
278.         status = (1U << 1);
     
279.         break;
     
280.       case ARM_USART_ERROR_PARITY:
     
281.         status = (1U << 2);
     
282.         break;
     
283.     }
     
284.   }
     
285. 
     
286.   if ((status == 0U) && (baudrate != 0U)) {
     
287.     UartControl = control;
     
288.     UartBaudrate = baudrate;
     
289.   }
     
290. 
     
291.   *response++ = status;
     
292.   *response++ = (uint8_t)(baudrate >>  0);
     
293.   *response++ = (uint8_t)(baudrate >>  8);
     
294.   *response++ = (uint8_t)(baudrate >> 16);
     
295.   *response   = (uint8_t)(baudrate >> 24);
     
296. 
     
297.   return ((5U << 16) | 5U);
     
298. }
     
299. 
     
300. // Process UART Transfer command and prepare response
     
301. //   request:  pointer to request data
     
302. //   response: pointer to response data
     
303. //   return:   number of bytes in response (lower 16 bits)
     
304. //             number of bytes in request (upper 16 bits)
     
305. uint32_t UART_Transfer (const uint8_t *request, uint8_t *response) {
     
306.   uint16_t status = 0U;
     
307.   uint32_t count, index;
     
308.   uint32_t tx_num, rx_num, num;
     
309.   uint8_t * data;
     
310. 
     
311.   if (UartTransport != DAP_UART_TRANSPORT_DAP_COMMAND) {
     
312.     return (0U);
     
313.   }
     
314. 
     
315.   // TX Data
     
316.   tx_num = ((uint16_t)(*(request+0) <<  0)  |
     
317.             (uint16_t)(*(request+1) <<  8));
     
318.   data = (uint8_t *)((uint32_t)request) + 2;
     
319. 
     
320.   if (tx_num > UART_MAX_XFER_NUM) {
     
321.     tx_num = UART_MAX_XFER_NUM;
     
322.   }
     
323. 
     
324.   count = UartTxIndexI - UartTxIndexO;
     
325.   index = UartTxIndexI & (UART_TX_BUF_SIZE - 1);
     
326. 
     
327.   if ((UART_TX_BUF_SIZE - count) >= tx_num) {
     
328.     if ((index + tx_num) < UART_TX_BUF_SIZE) {
     
329.       memcpy(&UartTxBuf[index], data, tx_num);
     
330.     } else {
     
331.       num = UART_TX_BUF_SIZE - index;
     
332.       memcpy(&UartTxBuf[index], data, num);
     
333.       memcpy(&UartTxBuf[0], data + num, tx_num - num);
     
334.     }
     
335.     UartTxIndexI += tx_num;
     
336. 
     
337.     if (pUSART->GetStatus().tx_busy == 0U) {
     
338.       UART_Send();
     
339.     }
     
340.   } else {
     
341.     // Tx Data lost
     
342.     status |= DAP_UART_TRANSFER_TX_DATA_LOST;
     
343.   }
     
344.   if ((UART_TX_BUF_SIZE - count) < UART_MAX_XFER_NUM) {
     
345.     // Can't accept next full TX packet
     
346.     status |= DAP_UART_TRANSFER_TX_BUSY;
     
347.   }
     
348. 
     
349.   // RX Data
     
350.   rx_num  = UartRxIndexI - UartRxIndexO;
     
351.   rx_num += pUSART->GetRxCount();
     
352.   data = response + 2;
     
353.   index = UartRxIndexO & (UART_RX_BUF_SIZE - 1);
     
354. 
     
355.   if (rx_num > UART_MAX_XFER_NUM) {
     
356.     rx_num = UART_MAX_XFER_NUM;
     
357.   }
     
358.   if ((index + rx_num) < UART_RX_BUF_SIZE) {
     
359.     memcpy(data, &UartRxBuf[index], rx_num);
     
360.   } else {
     
361.     num = UART_RX_BUF_SIZE - index;
     
362.     memcpy(data, &UartRxBuf[index], num);
     
363.     memcpy(data + num, &UartRxBuf[0], rx_num - num);
     
364.   }
     
365.   UartRxIndexO += rx_num;
     
366. 
     
367.   if (pUSART->GetStatus().rx_busy == 0U) {
     
368.     UART_Receive();
     
369.   }
     
370. 
     
371.   if (UartRxDataLost == 1U) {
     
372.     UartRxDataLost = 0U;
     
373.     status |= DAP_UART_TRANSFER_RX_DATA_LOST;
     
374.   }
     
375.   if (UartFramingError == 1U) {
     
376.     UartFramingError = 0U;
     
377.     status |= DAP_UART_TRANSFER_FRAMING_ERROR;
     
378.   }
     
379.   if (UartParityError == 1U) {
     
380.     UartParityError = 0U;
     
381.     status |= DAP_UART_TRANSFER_PARITY_ERROR;
     
382.   }
     
383. 
     
384.   status |= rx_num;
     
385. 
     
386.   *response++ = (uint8_t)(status >> 0);
     
387.   *response++ = (uint8_t)(status >> 8);
     
388. 
     
389.   return (((2U + tx_num) << 16) | (2U + rx_num));
     
390. }
     
391. 
     
392. #endif /* DAP_UART */

复制代码

ou513

H7-TOOL可以添加这个功能啊，调试和串口同时还是很方便的

eric2013

ou513 发表于 2021-5-27 20:34
H7-TOOL可以添加这个功能啊，调试和串口同时还是很方便的

现在的TOOL就支持，DAPLINK调试和HID高速虚拟串口同时使用。

byccc

预感MDK要发布新版了，这个功能应该要配合MDK新调试组件一起用，像ITM, EVENT RECORDER的方式

eric2013

byccc 发表于 2021-5-28 08:07
预感MDK要发布新版了，这个功能应该要配合MDK新调试组件一起用，像ITM, EVENT RECORDER的方式

下个月新的CMSIS软件包要发布，MDK应该也快了