1 /*
2 * Copyright 2018-2024 NXP
3 * All rights reserved.
4 *
5 *
6 * SPDX-License-Identifier: BSD-3-Clause
7 */
8
9 #ifndef __SERIAL_MANAGER_H__
10 #define __SERIAL_MANAGER_H__
11
12 #include "fsl_common.h"
13
14 /*!
15 * @addtogroup serialmanager
16 * @{
17 */
18
19 /*******************************************************************************
20 * Definitions
21 ******************************************************************************/
22 /*! @brief Enable or disable serial manager non-blocking mode (1 - enable, 0 - disable) */
23 #ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING
24 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE == 0U))
25 #error When SERIAL_MANAGER_NON_BLOCKING_MODE=0, DEBUG_CONSOLE_TRANSFER_NON_BLOCKING can not be set.
26 #else
27 #define SERIAL_MANAGER_NON_BLOCKING_MODE (1U)
28 #endif
29 #else
30 #ifndef SERIAL_MANAGER_NON_BLOCKING_MODE
31 #define SERIAL_MANAGER_NON_BLOCKING_MODE (0U)
32 #endif
33 #endif
34
35 /*! @brief Enable or ring buffer flow control (1 - enable, 0 - disable) */
36 #ifndef SERIAL_MANAGER_RING_BUFFER_FLOWCONTROL
37 #define SERIAL_MANAGER_RING_BUFFER_FLOWCONTROL (0U)
38 #endif
39
40 /*! @brief Enable or disable uart port (1 - enable, 0 - disable) */
41 #ifndef SERIAL_PORT_TYPE_UART
42 #define SERIAL_PORT_TYPE_UART (0U)
43 #endif
44
45 /*! @brief Enable or disable uart dma port (1 - enable, 0 - disable) */
46 #ifndef SERIAL_PORT_TYPE_UART_DMA
47 #define SERIAL_PORT_TYPE_UART_DMA (0U)
48 #endif
49 /*! @brief Enable or disable USB CDC port (1 - enable, 0 - disable) */
50 #ifndef SERIAL_PORT_TYPE_USBCDC
51 #define SERIAL_PORT_TYPE_USBCDC (0U)
52 #endif
53
54 /*! @brief Enable or disable SWO port (1 - enable, 0 - disable) */
55 #ifndef SERIAL_PORT_TYPE_SWO
56 #define SERIAL_PORT_TYPE_SWO (0U)
57 #endif
58
59 /*! @brief Enable or disable USB CDC virtual port (1 - enable, 0 - disable) */
60 #ifndef SERIAL_PORT_TYPE_VIRTUAL
61 #define SERIAL_PORT_TYPE_VIRTUAL (0U)
62 #endif
63
64 /*! @brief Enable or disable rPMSG port (1 - enable, 0 - disable) */
65 #ifndef SERIAL_PORT_TYPE_RPMSG
66 #define SERIAL_PORT_TYPE_RPMSG (0U)
67 #endif
68
69 /*! @brief Enable or disable SPI Master port (1 - enable, 0 - disable) */
70 #ifndef SERIAL_PORT_TYPE_SPI_MASTER
71 #define SERIAL_PORT_TYPE_SPI_MASTER (0U)
72 #endif
73
74 /*! @brief Enable or disable SPI Slave port (1 - enable, 0 - disable) */
75 #ifndef SERIAL_PORT_TYPE_SPI_SLAVE
76 #define SERIAL_PORT_TYPE_SPI_SLAVE (0U)
77 #endif
78
79 /*! @brief Enable or disable BLE WU port (1 - enable, 0 - disable) */
80 #ifndef SERIAL_PORT_TYPE_BLE_WU
81 #define SERIAL_PORT_TYPE_BLE_WU (0U)
82 #endif
83
84 #if (defined(SERIAL_PORT_TYPE_SPI_SLAVE) && (SERIAL_PORT_TYPE_SPI_SLAVE == 1U))
85 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE == 0U))
86 #warning When SERIAL_PORT_TYPE_SPI_SLAVE=1, SERIAL_MANAGER_NON_BLOCKING_MODE should be set.
87 #undef SERIAL_MANAGER_NON_BLOCKING_MODE
88 #define SERIAL_MANAGER_NON_BLOCKING_MODE (1U)
89 #endif
90 #endif
91
92 /*! @brief Set the default delay time in ms used by SerialManager_WriteTimeDelay(). */
93 #ifndef SERIAL_MANAGER_WRITE_TIME_DELAY_DEFAULT_VALUE
94 #define SERIAL_MANAGER_WRITE_TIME_DELAY_DEFAULT_VALUE (1U)
95 #endif
96
97 /*! @brief Set the default delay time in ms used by SerialManager_ReadTimeDelay(). */
98 #ifndef SERIAL_MANAGER_READ_TIME_DELAY_DEFAULT_VALUE
99 #define SERIAL_MANAGER_READ_TIME_DELAY_DEFAULT_VALUE (1U)
100 #endif
101
102 /*! @brief Enable or disable SerialManager_Task() handle RX data available notify */
103 #ifndef SERIAL_MANAGER_TASK_HANDLE_RX_AVAILABLE_NOTIFY
104 #define SERIAL_MANAGER_TASK_HANDLE_RX_AVAILABLE_NOTIFY (0U)
105 #endif
106 #if (defined(SERIAL_MANAGER_TASK_HANDLE_RX_AVAILABLE_NOTIFY) && (SERIAL_MANAGER_TASK_HANDLE_RX_AVAILABLE_NOTIFY > 0U))
107 #ifndef OSA_USED
108 #error When SERIAL_MANAGER_TASK_HANDLE_RX_AVAILABLE_NOTIFY=1, OSA_USED must be set.
109 #endif
110 #endif
111
112 /*! @brief Set serial manager write handle size */
113 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
114 #define SERIAL_MANAGER_WRITE_HANDLE_SIZE (UINTPTR_SIZE * 11U)
115 #define SERIAL_MANAGER_READ_HANDLE_SIZE (UINTPTR_SIZE * 11U)
116 #define SERIAL_MANAGER_WRITE_BLOCK_HANDLE_SIZE (UINTPTR_SIZE)
117 #define SERIAL_MANAGER_READ_BLOCK_HANDLE_SIZE (UINTPTR_SIZE)
118 #else
119 #define SERIAL_MANAGER_WRITE_HANDLE_SIZE (UINTPTR_SIZE)
120 #define SERIAL_MANAGER_READ_HANDLE_SIZE (UINTPTR_SIZE)
121 #define SERIAL_MANAGER_WRITE_BLOCK_HANDLE_SIZE (UINTPTR_SIZE)
122 #define SERIAL_MANAGER_READ_BLOCK_HANDLE_SIZE (UINTPTR_SIZE)
123 #endif
124
125 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
126 #include "fsl_component_serial_port_uart.h"
127 #endif
128
129 #if (defined(SERIAL_PORT_TYPE_UART_DMA) && (SERIAL_PORT_TYPE_UART_DMA > 0U))
130 #include "fsl_component_serial_port_uart.h"
131 #endif
132 #if (defined(SERIAL_PORT_TYPE_RPMSG) && (SERIAL_PORT_TYPE_RPMSG > 0U))
133 #include "fsl_component_serial_port_rpmsg.h"
134 #endif
135
136 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
137
138 #if !(defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
139 #error The serial manager blocking mode cannot be supported for USB CDC.
140 #endif
141
142 #include "fsl_component_serial_port_usb.h"
143 #endif
144
145 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
146 #include "fsl_component_serial_port_swo.h"
147 #endif
148
149 #if (defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U))
150 #include "fsl_component_serial_port_spi.h"
151 #endif
152 #if (defined(SERIAL_PORT_TYPE_SPI_SLAVE) && (SERIAL_PORT_TYPE_SPI_SLAVE > 0U))
153 #include "fsl_component_serial_port_spi.h"
154 #endif
155 #if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
156
157 #if !(defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
158 #error The serial manager blocking mode cannot be supported for USB CDC.
159 #endif
160
161 #include "fsl_component_serial_port_virtual.h"
162 #endif
163 #if (defined(SERIAL_PORT_TYPE_BLE_WU) && (SERIAL_PORT_TYPE_BLE_WU > 0U))
164
165 #if !(defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
166 #error The serial manager blocking mode cannot be supported for BLE WU.
167 #endif /* SERIAL_MANAGER_NON_BLOCKING_MODE */
168
169 #include "fsl_component_serial_port_ble_wu.h"
170 #endif /* SERIAL_PORT_TYPE_BLE_WU */
171
172 #define SERIAL_MANAGER_HANDLE_SIZE_TEMP 0U
173 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
174
175 #if (SERIAL_PORT_UART_HANDLE_SIZE > SERIAL_MANAGER_HANDLE_SIZE_TEMP)
176 #undef SERIAL_MANAGER_HANDLE_SIZE_TEMP
177 #define SERIAL_MANAGER_HANDLE_SIZE_TEMP SERIAL_PORT_UART_HANDLE_SIZE
178 #endif
179 #endif
180
181 #if (defined(SERIAL_PORT_TYPE_UART_DMA) && (SERIAL_PORT_TYPE_UART_DMA > 0U))
182 #if (SERIAL_PORT_UART_DMA_HANDLE_SIZE > SERIAL_MANAGER_HANDLE_SIZE_TEMP)
183 #undef SERIAL_MANAGER_HANDLE_SIZE_TEMP
184 #define SERIAL_MANAGER_HANDLE_SIZE_TEMP SERIAL_PORT_UART_DMA_HANDLE_SIZE
185 #endif
186 #endif
187
188 #if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U))
189
190 #if (SERIAL_PORT_USB_CDC_HANDLE_SIZE > SERIAL_MANAGER_HANDLE_SIZE_TEMP)
191 #undef SERIAL_MANAGER_HANDLE_SIZE_TEMP
192 #define SERIAL_MANAGER_HANDLE_SIZE_TEMP SERIAL_PORT_USB_CDC_HANDLE_SIZE
193 #endif
194
195 #endif
196
197 #if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U))
198
199 #if (SERIAL_PORT_SWO_HANDLE_SIZE > SERIAL_MANAGER_HANDLE_SIZE_TEMP)
200 #undef SERIAL_MANAGER_HANDLE_SIZE_TEMP
201 #define SERIAL_MANAGER_HANDLE_SIZE_TEMP SERIAL_PORT_SWO_HANDLE_SIZE
202 #endif
203
204 #endif
205
206 #if (defined(SERIAL_PORT_TYPE_SPI_MASTER) && (SERIAL_PORT_TYPE_SPI_MASTER > 0U))
207 #if (SERIAL_PORT_SPI_MASTER_HANDLE_SIZE > SERIAL_MANAGER_HANDLE_SIZE_TEMP)
208 #undef SERIAL_MANAGER_HANDLE_SIZE_TEMP
209 #define SERIAL_MANAGER_HANDLE_SIZE_TEMP SERIAL_PORT_SPI_MASTER_HANDLE_SIZE
210 #endif
211 #endif
212
213 #if (defined(SERIAL_PORT_TYPE_SPI_SLAVE) && (SERIAL_PORT_TYPE_SPI_SLAVE > 0U))
214 #if (SERIAL_PORT_SPI_SLAVE_HANDLE_SIZE > SERIAL_MANAGER_HANDLE_SIZE_TEMP)
215 #undef SERIAL_MANAGER_HANDLE_SIZE_TEMP
216 #define SERIAL_MANAGER_HANDLE_SIZE_TEMP SERIAL_PORT_SPI_SLAVE_HANDLE_SIZE
217 #endif
218 #endif
219
220 #if (defined(SERIAL_PORT_TYPE_VIRTUAL) && (SERIAL_PORT_TYPE_VIRTUAL > 0U))
221
222 #if (SERIAL_PORT_VIRTUAL_HANDLE_SIZE > SERIAL_MANAGER_HANDLE_SIZE_TEMP)
223 #undef SERIAL_MANAGER_HANDLE_SIZE_TEMP
224 #define SERIAL_MANAGER_HANDLE_SIZE_TEMP SERIAL_PORT_VIRTUAL_HANDLE_SIZE
225 #endif
226
227 #endif
228
229 #if (defined(SERIAL_PORT_TYPE_RPMSG) && (SERIAL_PORT_TYPE_RPMSG > 0U))
230
231 #if (SERIAL_PORT_RPMSG_HANDLE_SIZE > SERIAL_MANAGER_HANDLE_SIZE_TEMP)
232 #undef SERIAL_MANAGER_HANDLE_SIZE_TEMP
233 #define SERIAL_MANAGER_HANDLE_SIZE_TEMP SERIAL_PORT_RPMSG_HANDLE_SIZE
234
235 #endif
236
237 #endif
238
239 #if (defined(SERIAL_PORT_TYPE_BLE_WU) && (SERIAL_PORT_TYPE_BLE_WU > 0U))
240
241 #if (SERIAL_PORT_BLE_WU_HANDLE_SIZE > SERIAL_MANAGER_HANDLE_SIZE_TEMP)
242 #undef SERIAL_MANAGER_HANDLE_SIZE_TEMP
243 #define SERIAL_MANAGER_HANDLE_SIZE_TEMP SERIAL_PORT_BLE_WU_HANDLE_SIZE
244 #endif
245
246 #endif
247
248 /*! @brief SERIAL_PORT_UART_HANDLE_SIZE/SERIAL_PORT_USB_CDC_HANDLE_SIZE + serial manager dedicated size */
249 #if ((defined(SERIAL_MANAGER_HANDLE_SIZE_TEMP) && (SERIAL_MANAGER_HANDLE_SIZE_TEMP > 0U)))
250 #else
251 #error SERIAL_PORT_TYPE_UART, SERIAL_PORT_TYPE_USBCDC, SERIAL_PORT_TYPE_SWO, SERIAL_PORT_TYPE_VIRTUAL, and SERIAL_PORT_TYPE_BLE_WU should not be cleared at same time.
252 #endif
253
254 /*! @brief Macro to determine whether use common task. */
255 #ifndef SERIAL_MANAGER_USE_COMMON_TASK
256 #define SERIAL_MANAGER_USE_COMMON_TASK (0U)
257 #endif
258
259 #if defined(OSA_USED)
260 #if (defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U))
261 #include "fsl_component_common_task.h"
262 #endif
263 /*! @brief Enable or disable SerialManager_Task() handle TX to prevent recursive calling */
264 #ifndef SERIAL_MANAGER_TASK_HANDLE_TX
265 #define SERIAL_MANAGER_TASK_HANDLE_TX (1U)
266 #endif
267 #endif
268
269 #if (defined(SERIAL_MANAGER_TASK_HANDLE_TX) && (SERIAL_MANAGER_TASK_HANDLE_TX > 0U))
270 #ifndef OSA_USED
271 #error When SERIAL_MANAGER_TASK_HANDLE_TX=1, OSA_USED must be set.
272 #endif
273 #endif
274
275 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
276 #if (defined(OSA_USED) && !(defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U)))
277 #include "fsl_os_abstraction.h"
278 #endif
279 #endif
280
281 /*! @brief Definition of serial manager handle size. */
282 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
283 #if (defined(OSA_USED) && !(defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U)))
284 #define SERIAL_MANAGER_HANDLE_SIZE \
285 (SERIAL_MANAGER_HANDLE_SIZE_TEMP + UINTPTR_SIZE * 31U + OSA_TASK_HANDLE_SIZE + OSA_EVENT_HANDLE_SIZE)
286 #else /*defined(OSA_USED)*/
287 #define SERIAL_MANAGER_HANDLE_SIZE (SERIAL_MANAGER_HANDLE_SIZE_TEMP + UINTPTR_SIZE * 31U)
288 #endif /*defined(OSA_USED)*/
289 #define SERIAL_MANAGER_BLOCK_HANDLE_SIZE (SERIAL_MANAGER_HANDLE_SIZE_TEMP + UINTPTR_SIZE * 4U)
290 #else
291 #define SERIAL_MANAGER_HANDLE_SIZE (SERIAL_MANAGER_HANDLE_SIZE_TEMP + UINTPTR_SIZE * 3U)
292 #define SERIAL_MANAGER_BLOCK_HANDLE_SIZE (SERIAL_MANAGER_HANDLE_SIZE_TEMP + UINTPTR_SIZE * 3U)
293 #endif
294
295 /*!
296 * @brief Defines the serial manager handle
297 *
298 * This macro is used to define a 4 byte aligned serial manager handle.
299 * Then use "(serial_handle_t)name" to get the serial manager handle.
300 *
301 * The macro should be global and could be optional. You could also define serial manager handle by yourself.
302 *
303 * This is an example,
304 * @code
305 * SERIAL_MANAGER_HANDLE_DEFINE(serialManagerHandle);
306 * @endcode
307 *
308 * @param name The name string of the serial manager handle.
309 */
310 #define SERIAL_MANAGER_HANDLE_DEFINE(name) \
311 uint32_t name[((SERIAL_MANAGER_HANDLE_SIZE + sizeof(uint32_t) - 1U) / sizeof(uint32_t))]
312 #define SERIAL_MANAGER_BLOCK_HANDLE_DEFINE(name) \
313 uint32_t name[((SERIAL_MANAGER_BLOCK_HANDLE_SIZE + sizeof(uint32_t) - 1U) / sizeof(uint32_t))]
314 /*!
315 * @brief Defines the serial manager write handle
316 *
317 * This macro is used to define a 4 byte aligned serial manager write handle.
318 * Then use "(serial_write_handle_t)name" to get the serial manager write handle.
319 *
320 * The macro should be global and could be optional. You could also define serial manager write handle by yourself.
321 *
322 * This is an example,
323 * @code
324 * SERIAL_MANAGER_WRITE_HANDLE_DEFINE(serialManagerwriteHandle);
325 * @endcode
326 *
327 * @param name The name string of the serial manager write handle.
328 */
329 #define SERIAL_MANAGER_WRITE_HANDLE_DEFINE(name) \
330 uint32_t name[((SERIAL_MANAGER_WRITE_HANDLE_SIZE + sizeof(uint32_t) - 1U) / sizeof(uint32_t))]
331 #define SERIAL_MANAGER_WRITE_BLOCK_HANDLE_DEFINE(name) \
332 uint32_t name[((SERIAL_MANAGER_WRITE_BLOCK_HANDLE_SIZE + sizeof(uint32_t) - 1U) / sizeof(uint32_t))]
333 /*!
334 * @brief Defines the serial manager read handle
335 *
336 * This macro is used to define a 4 byte aligned serial manager read handle.
337 * Then use "(serial_read_handle_t)name" to get the serial manager read handle.
338 *
339 * The macro should be global and could be optional. You could also define serial manager read handle by yourself.
340 *
341 * This is an example,
342 * @code
343 * SERIAL_MANAGER_READ_HANDLE_DEFINE(serialManagerReadHandle);
344 * @endcode
345 *
346 * @param name The name string of the serial manager read handle.
347 */
348 #define SERIAL_MANAGER_READ_HANDLE_DEFINE(name) \
349 uint32_t name[((SERIAL_MANAGER_READ_HANDLE_SIZE + sizeof(uint32_t) - 1U) / sizeof(uint32_t))]
350 #define SERIAL_MANAGER_READ_BLOCK_HANDLE_DEFINE(name) \
351 uint32_t name[((SERIAL_MANAGER_READ_BLOCK_HANDLE_SIZE + sizeof(uint32_t) - 1U) / sizeof(uint32_t))]
352
353 /*! @brief Macro to set serial manager task priority. */
354 #ifndef SERIAL_MANAGER_TASK_PRIORITY
355 #define SERIAL_MANAGER_TASK_PRIORITY (2U)
356 #endif
357
358 /*! @brief Macro to set serial manager task stack size. */
359 #ifndef SERIAL_MANAGER_TASK_STACK_SIZE
360 #define SERIAL_MANAGER_TASK_STACK_SIZE (1000U)
361 #endif
362
363 /*! @brief The handle of the serial manager module */
364 typedef void *serial_handle_t;
365
366 /*! @brief The write handle of the serial manager module */
367 typedef void *serial_write_handle_t;
368
369 /*! @brief The read handle of the serial manager module */
370 typedef void *serial_read_handle_t;
371
372 #ifndef _SERIAL_PORT_T_
373 #define _SERIAL_PORT_T_
374 /*! @brief serial port type*/
375 typedef enum _serial_port_type
376 {
377 kSerialPort_None = 0U, /*!< Serial port is none */
378 kSerialPort_Uart = 1U, /*!< Serial port UART */
379 kSerialPort_UsbCdc, /*!< Serial port USB CDC */
380 kSerialPort_Swo, /*!< Serial port SWO */
381 kSerialPort_Virtual, /*!< Serial port Virtual */
382 kSerialPort_Rpmsg, /*!< Serial port RPMSG */
383 kSerialPort_UartDma, /*!< Serial port UART DMA*/
384 kSerialPort_SpiMaster, /*!< Serial port SPIMASTER*/
385 kSerialPort_SpiSlave, /*!< Serial port SPISLAVE*/
386 kSerialPort_BleWu, /*!< Serial port BLE WU */
387 } serial_port_type_t;
388 #endif
389
390 /*! @brief serial manager type*/
391 typedef enum _serial_manager_type
392 {
393 kSerialManager_NonBlocking = 0x0U, /*!< None blocking handle*/
394 kSerialManager_Blocking = 0x8F41U, /*!< Blocking handle*/
395 } serial_manager_type_t;
396 /*! @brief serial manager config structure*/
397 typedef struct _serial_manager_config
398 {
399 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
400 uint8_t *ringBuffer; /*!< Ring buffer address, it is used to buffer data received by the hardware.
401 Besides, the memory space cannot be free during the lifetime of the serial
402 manager module. */
403 uint32_t ringBufferSize; /*!< The size of the ring buffer */
404 #if (defined(OSA_USED) && !(defined(SERIAL_MANAGER_USE_COMMON_TASK) && (SERIAL_MANAGER_USE_COMMON_TASK > 0U)))
405 osa_task_def_t *serialTaskConfig; /*!< Serial manager task configuration, can be defined the serial manager
406 task configuration for this instance, if serialTaskConfig is NULL, will use the
407 default serial manager configure provided by serial manger module.*/
408 #endif
409 #endif
410 serial_port_type_t type; /*!< Serial port type */
411 serial_manager_type_t blockType; /*!< Serial manager port type */
412 void *portConfig; /*!< Serial port configuration */
413 } serial_manager_config_t;
414
415 /*! @brief serial manager error code*/
416 typedef enum _serial_manager_status
417 {
418 kStatus_SerialManager_Success = kStatus_Success, /*!< Success */
419 kStatus_SerialManager_Error = MAKE_STATUS(kStatusGroup_SERIALMANAGER, 1), /*!< Failed */
420 kStatus_SerialManager_Busy = MAKE_STATUS(kStatusGroup_SERIALMANAGER, 2), /*!< Busy */
421 kStatus_SerialManager_Notify = MAKE_STATUS(kStatusGroup_SERIALMANAGER, 3), /*!< Ring buffer is not empty */
422 kStatus_SerialManager_Canceled =
423 MAKE_STATUS(kStatusGroup_SERIALMANAGER, 4), /*!< the non-blocking request is canceled */
424 kStatus_SerialManager_HandleConflict = MAKE_STATUS(kStatusGroup_SERIALMANAGER, 5), /*!< The handle is opened */
425 kStatus_SerialManager_RingBufferOverflow =
426 MAKE_STATUS(kStatusGroup_SERIALMANAGER, 6), /*!< The ring buffer is overflowed */
427 kStatus_SerialManager_NotConnected = MAKE_STATUS(kStatusGroup_SERIALMANAGER, 7), /*!< The host is not connected */
428 } serial_manager_status_t;
429
430 /*! @brief Callback message structure */
431 typedef struct _serial_manager_callback_message
432 {
433 uint8_t *buffer; /*!< Transferred buffer */
434 uint32_t length; /*!< Transferred data length */
435 } serial_manager_callback_message_t;
436
437 /*! @brief serial manager callback function */
438 typedef void (*serial_manager_callback_t)(void *callbackParam,
439 serial_manager_callback_message_t *message,
440 serial_manager_status_t status);
441
442 /*! @brief serial manager Lowpower Critical callback function */
443 typedef int32_t (*serial_manager_lowpower_critical_callback_t)(int32_t power_mode);
444 typedef struct _serial_manager_lowpower_critical_CBs_t
445 {
446 serial_manager_lowpower_critical_callback_t serialEnterLowpowerCriticalFunc;
447 serial_manager_lowpower_critical_callback_t serialExitLowpowerCriticalFunc;
448 } serial_manager_lowpower_critical_CBs_t;
449 /*******************************************************************************
450 * API
451 ******************************************************************************/
452
453 #if defined(__cplusplus)
454 extern "C" {
455 #endif /* _cplusplus */
456
457 /*!
458 * @brief Initializes a serial manager module with the serial manager handle and the user configuration structure.
459 *
460 * This function configures the Serial Manager module with user-defined settings.
461 * The user can configure the configuration structure.
462 * The parameter serialHandle is a pointer to point to a memory space of size #SERIAL_MANAGER_HANDLE_SIZE
463 * allocated by the caller.
464 * The Serial Manager module supports three types of serial port, UART (includes UART, USART, LPSCI, LPUART, etc), USB
465 * CDC and swo.
466 * Please refer to #serial_port_type_t for serial port setting.
467 * These three types can be set by using #serial_manager_config_t.
468 *
469 * Example below shows how to use this API to configure the Serial Manager.
470 * For UART,
471 * @code
472 * #define SERIAL_MANAGER_RING_BUFFER_SIZE (256U)
473 * static SERIAL_MANAGER_HANDLE_DEFINE(s_serialHandle);
474 * static uint8_t s_ringBuffer[SERIAL_MANAGER_RING_BUFFER_SIZE];
475 *
476 * serial_manager_config_t config;
477 * serial_port_uart_config_t uartConfig;
478 * config.type = kSerialPort_Uart;
479 * config.ringBuffer = &s_ringBuffer[0];
480 * config.ringBufferSize = SERIAL_MANAGER_RING_BUFFER_SIZE;
481 * uartConfig.instance = 0;
482 * uartConfig.clockRate = 24000000;
483 * uartConfig.baudRate = 115200;
484 * uartConfig.parityMode = kSerialManager_UartParityDisabled;
485 * uartConfig.stopBitCount = kSerialManager_UartOneStopBit;
486 * uartConfig.enableRx = 1;
487 * uartConfig.enableTx = 1;
488 * uartConfig.enableRxRTS = 0;
489 * uartConfig.enableTxCTS = 0;
490 * config.portConfig = &uartConfig;
491 * SerialManager_Init((serial_handle_t)s_serialHandle, &config);
492 * @endcode
493 * For USB CDC,
494 * @code
495 * #define SERIAL_MANAGER_RING_BUFFER_SIZE (256U)
496 * static SERIAL_MANAGER_HANDLE_DEFINE(s_serialHandle);
497 * static uint8_t s_ringBuffer[SERIAL_MANAGER_RING_BUFFER_SIZE];
498 *
499 * serial_manager_config_t config;
500 * serial_port_usb_cdc_config_t usbCdcConfig;
501 * config.type = kSerialPort_UsbCdc;
502 * config.ringBuffer = &s_ringBuffer[0];
503 * config.ringBufferSize = SERIAL_MANAGER_RING_BUFFER_SIZE;
504 * usbCdcConfig.controllerIndex = kSerialManager_UsbControllerKhci0;
505 * config.portConfig = &usbCdcConfig;
506 * SerialManager_Init((serial_handle_t)s_serialHandle, &config);
507 * @endcode
508 *
509 * Example below shows how to use this API to configure the Serial Manager task configuration.
510 * For example if user need do specfical configuration(s_os_thread_def_serialmanager)for the
511 * serial mananger task,
512 * @code
513 * #define SERIAL_MANAGER_RING_BUFFER_SIZE (256U)
514 * static SERIAL_MANAGER_HANDLE_DEFINE(s_serialHandle);
515 * static uint8_t s_ringBuffer[SERIAL_MANAGER_RING_BUFFER_SIZE];
516 * const osa_task_def_t s_os_thread_def_serialmanager = {
517 * .tpriority = 4,
518 * .instances = 1,
519 * .stacksize = 2048,
520 * };
521 * serial_manager_config_t config;
522 * serial_port_uart_config_t uartConfig;
523 * config.type = kSerialPort_Uart;
524 * config.ringBuffer = &s_ringBuffer[0];
525 * config.ringBufferSize = SERIAL_MANAGER_RING_BUFFER_SIZE;
526 * config.serialTaskConfig = (osa_task_def_t *)&s_os_thread_def_serialmanager,
527 * uartConfig.instance = 0;
528 * uartConfig.clockRate = 24000000;
529 * uartConfig.baudRate = 115200;
530 * uartConfig.parityMode = kSerialManager_UartParityDisabled;
531 * uartConfig.stopBitCount = kSerialManager_UartOneStopBit;
532 * uartConfig.enableRx = 1;
533 * uartConfig.enableTx = 1;
534 * uartConfig.enableRxRTS = 0;
535 * uartConfig.enableTxCTS = 0;
536 * config.portConfig = &uartConfig;
537 * SerialManager_Init((serial_handle_t)s_serialHandle, &config);
538 * @endcode
539 * @param serialHandle Pointer to point to a memory space of size #SERIAL_MANAGER_HANDLE_SIZE allocated by the caller.
540 * The handle should be 4 byte aligned, because unaligned access doesn't be supported on some devices.
541 * You can define the handle in the following two ways:
542 * #SERIAL_MANAGER_HANDLE_DEFINE(serialHandle);
543 * or
544 * uint32_t serialHandle[((SERIAL_MANAGER_HANDLE_SIZE + sizeof(uint32_t) - 1U) / sizeof(uint32_t))];
545 * @param serialConfig Pointer to user-defined configuration structure.
546 * @retval kStatus_SerialManager_Error An error occurred.
547 * @retval kStatus_SerialManager_Success The Serial Manager module initialization succeed.
548 */
549 serial_manager_status_t SerialManager_Init(serial_handle_t serialHandle, const serial_manager_config_t *serialConfig);
550
551 /*!
552 * @brief De-initializes the serial manager module instance.
553 *
554 * This function de-initializes the serial manager module instance. If the opened writing or
555 * reading handle is not closed, the function will return kStatus_SerialManager_Busy.
556 *
557 * @param serialHandle The serial manager module handle pointer.
558 * @retval kStatus_SerialManager_Success The serial manager de-initialization succeed.
559 * @retval kStatus_SerialManager_Busy Opened reading or writing handle is not closed.
560 */
561 serial_manager_status_t SerialManager_Deinit(serial_handle_t serialHandle);
562
563 /*!
564 * @brief Opens a writing handle for the serial manager module.
565 *
566 * This function Opens a writing handle for the serial manager module. If the serial manager needs to
567 * be used in different tasks, the task should open a dedicated write handle for itself by calling
568 * #SerialManager_OpenWriteHandle. Since there can only one buffer for transmission for the writing
569 * handle at the same time, multiple writing handles need to be opened when the multiple transmission
570 * is needed for a task.
571 *
572 * @param serialHandle The serial manager module handle pointer.
573 * The handle should be 4 byte aligned, because unaligned access doesn't be supported on some devices.
574 * @param writeHandle The serial manager module writing handle pointer.
575 * The handle should be 4 byte aligned, because unaligned access doesn't be supported on some devices.
576 * You can define the handle in the following two ways:
577 * #SERIAL_MANAGER_WRITE_HANDLE_DEFINE(writeHandle);
578 * or
579 * uint32_t writeHandle[((SERIAL_MANAGER_WRITE_HANDLE_SIZE + sizeof(uint32_t) - 1U) / sizeof(uint32_t))];
580 * @retval kStatus_SerialManager_Error An error occurred.
581 * @retval kStatus_SerialManager_HandleConflict The writing handle was opened.
582 * @retval kStatus_SerialManager_Success The writing handle is opened.
583 *
584 * Example below shows how to use this API to write data.
585 * For task 1,
586 * @code
587 * static SERIAL_MANAGER_WRITE_HANDLE_DEFINE(s_serialWriteHandle1);
588 * static uint8_t s_nonBlockingWelcome1[] = "This is non-blocking writing log for task1!\r\n";
589 * SerialManager_OpenWriteHandle((serial_handle_t)serialHandle, (serial_write_handle_t)s_serialWriteHandle1);
590 * SerialManager_InstallTxCallback((serial_write_handle_t)s_serialWriteHandle1,
591 * Task1_SerialManagerTxCallback,
592 * s_serialWriteHandle1);
593 * SerialManager_WriteNonBlocking((serial_write_handle_t)s_serialWriteHandle1,
594 * s_nonBlockingWelcome1,
595 * sizeof(s_nonBlockingWelcome1) - 1U);
596 * @endcode
597 * For task 2,
598 * @code
599 * static SERIAL_MANAGER_WRITE_HANDLE_DEFINE(s_serialWriteHandle2);
600 * static uint8_t s_nonBlockingWelcome2[] = "This is non-blocking writing log for task2!\r\n";
601 * SerialManager_OpenWriteHandle((serial_handle_t)serialHandle, (serial_write_handle_t)s_serialWriteHandle2);
602 * SerialManager_InstallTxCallback((serial_write_handle_t)s_serialWriteHandle2,
603 * Task2_SerialManagerTxCallback,
604 * s_serialWriteHandle2);
605 * SerialManager_WriteNonBlocking((serial_write_handle_t)s_serialWriteHandle2,
606 * s_nonBlockingWelcome2,
607 * sizeof(s_nonBlockingWelcome2) - 1U);
608 * @endcode
609 */
610 serial_manager_status_t SerialManager_OpenWriteHandle(serial_handle_t serialHandle, serial_write_handle_t writeHandle);
611
612 /*!
613 * @brief Closes a writing handle for the serial manager module.
614 *
615 * This function Closes a writing handle for the serial manager module.
616 *
617 * @param writeHandle The serial manager module writing handle pointer.
618 * @retval kStatus_SerialManager_Success The writing handle is closed.
619 */
620 serial_manager_status_t SerialManager_CloseWriteHandle(serial_write_handle_t writeHandle);
621
622 /*!
623 * @brief Opens a reading handle for the serial manager module.
624 *
625 * This function Opens a reading handle for the serial manager module. The reading handle can not be
626 * opened multiple at the same time. The error code kStatus_SerialManager_Busy would be returned when
627 * the previous reading handle is not closed. And there can only be one buffer for receiving for the
628 * reading handle at the same time.
629 *
630 * @param serialHandle The serial manager module handle pointer.
631 * The handle should be 4 byte aligned, because unaligned access doesn't be supported on some devices.
632 * @param readHandle The serial manager module reading handle pointer.
633 * The handle should be 4 byte aligned, because unaligned access doesn't be supported on some devices.
634 * You can define the handle in the following two ways:
635 * #SERIAL_MANAGER_READ_HANDLE_DEFINE(readHandle);
636 * or
637 * uint32_t readHandle[((SERIAL_MANAGER_READ_HANDLE_SIZE + sizeof(uint32_t) - 1U) / sizeof(uint32_t))];
638 * @retval kStatus_SerialManager_Error An error occurred.
639 * @retval kStatus_SerialManager_Success The reading handle is opened.
640 * @retval kStatus_SerialManager_Busy Previous reading handle is not closed.
641 *
642 * Example below shows how to use this API to read data.
643 * @code
644 * static SERIAL_MANAGER_READ_HANDLE_DEFINE(s_serialReadHandle);
645 * SerialManager_OpenReadHandle((serial_handle_t)serialHandle, (serial_read_handle_t)s_serialReadHandle);
646 * static uint8_t s_nonBlockingBuffer[64];
647 * SerialManager_InstallRxCallback((serial_read_handle_t)s_serialReadHandle,
648 * APP_SerialManagerRxCallback,
649 * s_serialReadHandle);
650 * SerialManager_ReadNonBlocking((serial_read_handle_t)s_serialReadHandle,
651 * s_nonBlockingBuffer,
652 * sizeof(s_nonBlockingBuffer));
653 * @endcode
654 */
655 serial_manager_status_t SerialManager_OpenReadHandle(serial_handle_t serialHandle, serial_read_handle_t readHandle);
656
657 /*!
658 * @brief Closes a reading for the serial manager module.
659 *
660 * This function Closes a reading for the serial manager module.
661 *
662 * @param readHandle The serial manager module reading handle pointer.
663 * @retval kStatus_SerialManager_Success The reading handle is closed.
664 */
665 serial_manager_status_t SerialManager_CloseReadHandle(serial_read_handle_t readHandle);
666
667 /*!
668 * @brief Transmits data with the blocking mode.
669 *
670 * This is a blocking function, which polls the sending queue, waits for the sending queue to be empty.
671 * This function sends data using an interrupt method. The interrupt of the hardware could not be disabled.
672 * And There can only one buffer for transmission for the writing handle at the same time.
673 *
674 * @note The function #SerialManager_WriteBlocking and the function SerialManager_WriteNonBlocking
675 * cannot be used at the same time.
676 * And, the function SerialManager_CancelWriting cannot be used to abort the transmission of this function.
677 *
678 * @param writeHandle The serial manager module handle pointer.
679 * @param buffer Start address of the data to write.
680 * @param length Length of the data to write.
681 * @retval kStatus_SerialManager_Success Successfully sent all data.
682 * @retval kStatus_SerialManager_Busy Previous transmission still not finished; data not all sent yet.
683 * @retval kStatus_SerialManager_Error An error occurred.
684 */
685 serial_manager_status_t SerialManager_WriteBlocking(serial_write_handle_t writeHandle,
686 uint8_t *buffer,
687 uint32_t length);
688
689 /*!
690 * @brief Reads data with the blocking mode.
691 *
692 * This is a blocking function, which polls the receiving buffer, waits for the receiving buffer to be full.
693 * This function receives data using an interrupt method. The interrupt of the hardware could not be disabled.
694 * And There can only one buffer for receiving for the reading handle at the same time.
695 *
696 * @note The function #SerialManager_ReadBlocking and the function SerialManager_ReadNonBlocking
697 * cannot be used at the same time.
698 * And, the function SerialManager_CancelReading cannot be used to abort the transmission of this function.
699 *
700 * @param readHandle The serial manager module handle pointer.
701 * @param buffer Start address of the data to store the received data.
702 * @param length The length of the data to be received.
703 * @retval kStatus_SerialManager_Success Successfully received all data.
704 * @retval kStatus_SerialManager_Busy Previous transmission still not finished; data not all received yet.
705 * @retval kStatus_SerialManager_Error An error occurred.
706 */
707 serial_manager_status_t SerialManager_ReadBlocking(serial_read_handle_t readHandle, uint8_t *buffer, uint32_t length);
708
709 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
710 /*!
711 * @brief Transmits data with the non-blocking mode.
712 *
713 * This is a non-blocking function, which returns directly without waiting for all data to be sent.
714 * When all data is sent, the module notifies the upper layer through a TX callback function and passes
715 * the status parameter @ref kStatus_SerialManager_Success.
716 * This function sends data using an interrupt method. The interrupt of the hardware could not be disabled.
717 * And There can only one buffer for transmission for the writing handle at the same time.
718 *
719 * @note The function #SerialManager_WriteBlocking and the function #SerialManager_WriteNonBlocking
720 * cannot be used at the same time. And, the TX callback is mandatory before the function could be used.
721 *
722 * @param writeHandle The serial manager module handle pointer.
723 * @param buffer Start address of the data to write.
724 * @param length Length of the data to write.
725 * @retval kStatus_SerialManager_Success Successfully sent all data.
726 * @retval kStatus_SerialManager_Busy Previous transmission still not finished; data not all sent yet.
727 * @retval kStatus_SerialManager_Error An error occurred.
728 */
729 serial_manager_status_t SerialManager_WriteNonBlocking(serial_write_handle_t writeHandle,
730 uint8_t *buffer,
731 uint32_t length);
732
733 /*!
734 * @brief Reads data with the non-blocking mode.
735 *
736 * This is a non-blocking function, which returns directly without waiting for all data to be received.
737 * When all data is received, the module driver notifies the upper layer
738 * through a RX callback function and passes the status parameter @ref kStatus_SerialManager_Success.
739 * This function receives data using an interrupt method. The interrupt of the hardware could not be disabled.
740 * And There can only one buffer for receiving for the reading handle at the same time.
741 *
742 * @note The function #SerialManager_ReadBlocking and the function #SerialManager_ReadNonBlocking
743 * cannot be used at the same time. And, the RX callback is mandatory before the function could be used.
744 *
745 * @param readHandle The serial manager module handle pointer.
746 * @param buffer Start address of the data to store the received data.
747 * @param length The length of the data to be received.
748 * @retval kStatus_SerialManager_Success Successfully received all data.
749 * @retval kStatus_SerialManager_Busy Previous transmission still not finished; data not all received yet.
750 * @retval kStatus_SerialManager_Error An error occurred.
751 */
752 serial_manager_status_t SerialManager_ReadNonBlocking(serial_read_handle_t readHandle,
753 uint8_t *buffer,
754 uint32_t length);
755
756 /*!
757 * @brief Tries to read data.
758 *
759 * The function tries to read data from internal ring buffer. If the ring buffer is not empty, the data will be
760 * copied from ring buffer to up layer buffer. The copied length is the minimum of the ring buffer and up layer length.
761 * After the data is copied, the actual data length is passed by the parameter length.
762 * And There can only one buffer for receiving for the reading handle at the same time.
763 *
764 * @param readHandle The serial manager module handle pointer.
765 * @param buffer Start address of the data to store the received data.
766 * @param length The length of the data to be received.
767 * @param receivedLength Length received from the ring buffer directly.
768 * @retval kStatus_SerialManager_Success Successfully received all data.
769 * @retval kStatus_SerialManager_Busy Previous transmission still not finished; data not all received yet.
770 * @retval kStatus_SerialManager_Error An error occurred.
771 */
772 serial_manager_status_t SerialManager_TryRead(serial_read_handle_t readHandle,
773 uint8_t *buffer,
774 uint32_t length,
775 uint32_t *receivedLength);
776
777 /*!
778 * @brief Cancels unfinished send transmission.
779 *
780 * The function cancels unfinished send transmission. When the transfer is canceled, the module notifies the upper layer
781 * through a TX callback function and passes the status parameter @ref kStatus_SerialManager_Canceled.
782 *
783 * @note The function #SerialManager_CancelWriting cannot be used to abort the transmission of
784 * the function #SerialManager_WriteBlocking.
785 *
786 * @param writeHandle The serial manager module handle pointer.
787 * @retval kStatus_SerialManager_Success Get successfully abort the sending.
788 * @retval kStatus_SerialManager_Error An error occurred.
789 */
790 serial_manager_status_t SerialManager_CancelWriting(serial_write_handle_t writeHandle);
791
792 /*!
793 * @brief Cancels unfinished receive transmission.
794 *
795 * The function cancels unfinished receive transmission. When the transfer is canceled, the module notifies the upper
796 * layer
797 * through a RX callback function and passes the status parameter @ref kStatus_SerialManager_Canceled.
798 *
799 * @note The function #SerialManager_CancelReading cannot be used to abort the transmission of
800 * the function #SerialManager_ReadBlocking.
801 *
802 * @param readHandle The serial manager module handle pointer.
803 * @retval kStatus_SerialManager_Success Get successfully abort the receiving.
804 * @retval kStatus_SerialManager_Error An error occurred.
805 */
806 serial_manager_status_t SerialManager_CancelReading(serial_read_handle_t readHandle);
807
808 /*!
809 * @brief Installs a TX callback and callback parameter.
810 *
811 * This function is used to install the TX callback and callback parameter for the serial manager module.
812 * When any status of TX transmission changed, the driver will notify the upper layer by the installed callback
813 * function. And the status is also passed as status parameter when the callback is called.
814 *
815 * @param writeHandle The serial manager module handle pointer.
816 * @param callback The callback function.
817 * @param callbackParam The parameter of the callback function.
818 * @retval kStatus_SerialManager_Success Successfully install the callback.
819 */
820 serial_manager_status_t SerialManager_InstallTxCallback(serial_write_handle_t writeHandle,
821 serial_manager_callback_t callback,
822 void *callbackParam);
823
824 /*!
825 * @brief Installs a RX callback and callback parameter.
826 *
827 * This function is used to install the RX callback and callback parameter for the serial manager module.
828 * When any status of RX transmission changed, the driver will notify the upper layer by the installed callback
829 * function. And the status is also passed as status parameter when the callback is called.
830 *
831 * @param readHandle The serial manager module handle pointer.
832 * @param callback The callback function.
833 * @param callbackParam The parameter of the callback function.
834 * @retval kStatus_SerialManager_Success Successfully install the callback.
835 */
836 serial_manager_status_t SerialManager_InstallRxCallback(serial_read_handle_t readHandle,
837 serial_manager_callback_t callback,
838 void *callbackParam);
839
840 /*!
841 * @brief Check if need polling ISR.
842 *
843 * This function is used to check if need polling ISR.
844 *
845 * @retval TRUE if need polling.
846 */
SerialManager_needPollingIsr(void)847 static inline bool SerialManager_needPollingIsr(void)
848 {
849 #if (defined(__DSC__) && defined(__CW__))
850 return !(isIRQAllowed());
851 #elif defined(CPSR_M_Msk)
852 return (0x13 == (__get_CPSR() & CPSR_M_Msk));
853 #elif defined(DAIF_I_BIT)
854 return (__get_DAIF() & DAIF_I_BIT);
855 #elif defined(__XCC__)
856 return (xthal_get_interrupt() & xthal_get_intenable());
857 #else
858 return (0U != __get_IPSR());
859 #endif
860 }
861 #endif
862
863 /*!
864 * @brief Prepares to enter low power consumption.
865 *
866 * This function is used to prepare to enter low power consumption.
867 *
868 * @param serialHandle The serial manager module handle pointer.
869 * @retval kStatus_SerialManager_Success Successful operation.
870 */
871 serial_manager_status_t SerialManager_EnterLowpower(serial_handle_t serialHandle);
872
873 /*!
874 * @brief Restores from low power consumption.
875 *
876 * This function is used to restore from low power consumption.
877 *
878 * @param serialHandle The serial manager module handle pointer.
879 * @retval kStatus_SerialManager_Success Successful operation.
880 */
881 serial_manager_status_t SerialManager_ExitLowpower(serial_handle_t serialHandle);
882
883 /*!
884 * @brief This function performs initialization of the callbacks structure used to disable lowpower
885 * when serial manager is active.
886 *
887 *
888 * @param pfCallback Pointer to the function structure used to allow/disable lowpower.
889 *
890 */
891 void SerialManager_SetLowpowerCriticalCb(const serial_manager_lowpower_critical_CBs_t *pfCallback);
892
893 #if defined(__cplusplus)
894 }
895 #endif
896 /*! @} */
897 #endif /* __SERIAL_MANAGER_H__ */
898
