#ifndef __SERIAL_MANAGER_H__\r
#define __SERIAL_MANAGER_H__\r
\r
+/*!\r
+ * @addtogroup serialmanager\r
+ * @{\r
+ */\r
+\r
/*******************************************************************************\r
* Definitions\r
******************************************************************************/\r
#ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING\r
-#define SERIAL_MANAGER_NON_BLOCKING_MODE \\r
- (1U) /* Enable or disable serial manager non-blocking mode (1 - enable, 0 - disable) */\r
+/*! @brief Enable or disable serial manager non-blocking mode (1 - enable, 0 - disable) */\r
+#define SERIAL_MANAGER_NON_BLOCKING_MODE (1U)\r
#else\r
#ifndef SERIAL_MANAGER_NON_BLOCKING_MODE\r
-#define SERIAL_MANAGER_NON_BLOCKING_MODE \\r
- (0U) /* Enable or disable serial manager non-blocking mode (1 - enable, 0 - disable) */\r
+#define SERIAL_MANAGER_NON_BLOCKING_MODE (0U)\r
#endif\r
#endif\r
\r
+/*! @brief Enable or disable uart port (1 - enable, 0 - disable) */\r
#ifndef SERIAL_PORT_TYPE_UART\r
-#define SERIAL_PORT_TYPE_UART (1U) /* Enable or disable uart port (1 - enable, 0 - disable) */\r
+#define SERIAL_PORT_TYPE_UART (0U)\r
#endif\r
\r
+/*! @brief Enable or disable USB CDC port (1 - enable, 0 - disable) */\r
#ifndef SERIAL_PORT_TYPE_USBCDC\r
-#define SERIAL_PORT_TYPE_USBCDC (0U) /* Enable or disable USB CDC port (1 - enable, 0 - disable) */\r
+#define SERIAL_PORT_TYPE_USBCDC (0U)\r
#endif\r
\r
+/*! @brief Enable or disable SWO port (1 - enable, 0 - disable) */\r
#ifndef SERIAL_PORT_TYPE_SWO\r
-#define SERIAL_PORT_TYPE_SWO (0U) /* Enable or disable SWO port (1 - enable, 0 - disable) */\r
+#define SERIAL_PORT_TYPE_SWO (0U)\r
+#endif\r
+\r
+/*! @brief Enable or disable USB CDC virtual port (1 - enable, 0 - disable) */\r
+#ifndef SERIAL_PORT_TYPE_USBCDC_VIRTUAL\r
+#define SERIAL_PORT_TYPE_USBCDC_VIRTUAL (0U)\r
#endif\r
\r
+/*! @brief Set serial manager write handle size */\r
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
#define SERIAL_MANAGER_WRITE_HANDLE_SIZE (44U)\r
#define SERIAL_MANAGER_READ_HANDLE_SIZE (44U)\r
#include "serial_port_swo.h"\r
#endif\r
\r
+#if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
+\r
+#if !(defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
+#error The serial manager blocking mode cannot be supported for USB CDC.\r
+#endif\r
+\r
+#include "serial_port_usb_virtual.h"\r
+#endif\r
+\r
#define SERIAL_MANAGER_HANDLE_SIZE_TEMP 0U\r
#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))\r
\r
\r
#endif\r
\r
-/* SERIAL_PORT_UART_HANDLE_SIZE/SERIAL_PORT_USB_CDC_HANDLE_SIZE + serial manager dedicated size */\r
+#if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U))\r
+\r
+#if (SERIAL_PORT_USB_VIRTUAL_HANDLE_SIZE > SERIAL_MANAGER_HANDLE_SIZE_TEMP)\r
+#undef SERIAL_MANAGER_HANDLE_SIZE_TEMP\r
+#define SERIAL_MANAGER_HANDLE_SIZE_TEMP SERIAL_PORT_USB_VIRTUAL_HANDLE_SIZE\r
+#endif\r
+\r
+#endif\r
+\r
+/*! @brief SERIAL_PORT_UART_HANDLE_SIZE/SERIAL_PORT_USB_CDC_HANDLE_SIZE + serial manager dedicated size */\r
#if ((defined(SERIAL_MANAGER_HANDLE_SIZE_TEMP) && (SERIAL_MANAGER_HANDLE_SIZE_TEMP > 0U)))\r
#else\r
-#error SERIAL_PORT_TYPE_UART, SERIAL_PORT_TYPE_USBCDC and SERIAL_PORT_TYPE_SWO should not be cleared at same time.\r
+#error SERIAL_PORT_TYPE_UART, SERIAL_PORT_TYPE_USBCDC, SERIAL_PORT_TYPE_SWO and SERIAL_PORT_TYPE_USBCDC_VIRTUAL should not be cleared at same time.\r
#endif\r
\r
#if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))\r
typedef void *serial_write_handle_t;\r
typedef void *serial_read_handle_t;\r
\r
+/*! @brief serial port type*/\r
typedef enum _serial_port_type\r
{\r
- kSerialPort_Uart = 1U, /*!< Serial port UART */\r
- kSerialPort_UsbCdc, /*!< Serial port USB CDC */\r
- kSerialPort_Swo, /*!< Serial port SWO */\r
+ kSerialPort_Uart = 1U, /*!< Serial port UART */\r
+ kSerialPort_UsbCdc, /*!< Serial port USB CDC */\r
+ kSerialPort_Swo, /*!< Serial port SWO */\r
+ kSerialPort_UsbCdcVirtual, /*!< Serial port USB CDC Virtual */\r
} serial_port_type_t;\r
\r
+/*! @brief serial manager config structure*/\r
typedef struct _serial_manager_config\r
{\r
uint8_t *ringBuffer; /*!< Ring buffer address, it is used to buffer data received by the hardware.\r
void *portConfig; /*!< Serial port configuration */\r
} serial_manager_config_t;\r
\r
+/*! @brief serial manager error code*/\r
typedef enum _serial_manager_status\r
{\r
- kStatus_SerialManager_Success = kStatus_Success, /*!< Success */\r
- kStatus_SerialManager_Error = MAKE_STATUS(kStatusGroup_SERIALMANAGER, 1), /*!< Failed */\r
- kStatus_SerialManager_Busy = MAKE_STATUS(kStatusGroup_SERIALMANAGER, 2), /*!< Busy */\r
- kStatus_SerialManager_Notify = MAKE_STATUS(kStatusGroup_SERIALMANAGER, 3), /*!< Ring buffer is not empty */\r
+ kStatus_SerialManager_Success = kStatus_Success, /*!< Success */\r
+ kStatus_SerialManager_Error = MAKE_STATUS(kStatusGroup_SERIALMANAGER, 1), /*!< Failed */\r
+ kStatus_SerialManager_Busy = MAKE_STATUS(kStatusGroup_SERIALMANAGER, 2), /*!< Busy */\r
+ kStatus_SerialManager_Notify = MAKE_STATUS(kStatusGroup_SERIALMANAGER, 3), /*!< Ring buffer is not empty */\r
kStatus_SerialManager_Canceled =\r
MAKE_STATUS(kStatusGroup_SERIALMANAGER, 4), /*!< the non-blocking request is canceled */\r
kStatus_SerialManager_HandleConflict = MAKE_STATUS(kStatusGroup_SERIALMANAGER, 5), /*!< The handle is opened */\r
/*!\r
* @brief Initializes a serial manager module with the serial manager handle and the user configuration structure.\r
*\r
- * This function configures the serial manager module with user-defined settings. The user can configure the\r
+ * This function configures the Serial Manager module with user-defined settings. The user can configure the\r
* configuration\r
* structure. The parameter serialHandle is a pointer to point to a memory space of size #SERIAL_MANAGER_HANDLE_SIZE\r
* allocated by the caller.\r
- * The serial manager module supports two types serial port, uart (includes UART, USART, LPSCI, LPUART, etc) and USB\r
+ * The Serial Manager module supports two types of serial port, UART (includes UART, USART, LPSCI, LPUART, etc) and USB\r
* CDC.\r
* Please refer to #serial_port_type_t for serial port setting. These two types can be set by using\r
* #serial_manager_config_t.\r
*\r
- * Example below shows how to use this API to configure the serial manager.\r
+ * Example below shows how to use this API to configure the Serial Manager.\r
* For UART,\r
* @code\r
* #define SERIAL_MANAGER_RING_BUFFER_SIZE (256U)\r
- * static uint8_t s_serialHandleBuffer[SERIAL_MANAGER_HANDLE_SIZE];\r
- * static serial_handle_t s_serialHandle = &s_serialHandleBuffer[0];\r
+ * static uint32_t s_serialHandleBuffer[((SERIAL_MANAGER_HANDLE_SIZE + sizeof(uint32_t) - 1) / sizeof(uitn32_t))];\r
+ * static serial_handle_t s_serialHandle = (serial_handle_t)&s_serialHandleBuffer[0];\r
* static uint8_t s_ringBuffer[SERIAL_MANAGER_RING_BUFFER_SIZE];\r
*\r
* serial_manager_config_t config;\r
* For USB CDC,\r
* @code\r
* #define SERIAL_MANAGER_RING_BUFFER_SIZE (256U)\r
- * static uint8_t s_serialHandleBuffer[SERIAL_MANAGER_HANDLE_SIZE];\r
- * static serial_handle_t s_serialHandle = &s_serialHandleBuffer[0];\r
+ * static uint32_t s_serialHandleBuffer[((SERIAL_MANAGER_HANDLE_SIZE + sizeof(uint32_t) - 1) / sizeof(uitn32_t))];\r
+ * static serial_handle_t s_serialHandle = (serial_handle_t)&s_serialHandleBuffer[0];\r
* static uint8_t s_ringBuffer[SERIAL_MANAGER_RING_BUFFER_SIZE];\r
*\r
* serial_manager_config_t config;\r
* @endcode\r
*\r
* @param serialHandle Pointer to point to a memory space of size #SERIAL_MANAGER_HANDLE_SIZE allocated by the caller.\r
+ * The handle should be 4 byte aligned, because unaligned access does not support on some devices.\r
* @param config Pointer to user-defined configuration structure.\r
* @retval kStatus_SerialManager_Error An error occurred.\r
- * @retval kStatus_SerialManager_Success The serial manager module initialization succeed.\r
+ * @retval kStatus_SerialManager_Success The Serial Manager module initialization succeed.\r
*/\r
serial_manager_status_t SerialManager_Init(serial_handle_t serialHandle, serial_manager_config_t *config);\r
\r
* is needed for a task.\r
*\r
* @param serialHandle The serial manager module handle pointer.\r
+ * The handle should be 4 byte aligned, because unaligned access does not support on some devices.\r
* @param writeHandle The serial manager module writing handle pointer.\r
+ * The handle should be 4 byte aligned, because unaligned access does not support on some devices.\r
* @retval kStatus_SerialManager_Error An error occurred.\r
* @retval kStatus_SerialManager_HandleConflict The writing handle was opened.\r
* @retval kStatus_SerialManager_Success The writing handle is opened.\r
* Example below shows how to use this API to write data.\r
* For task 1,\r
* @code\r
- * static uint8_t s_serialWriteHandleBuffer1[SERIAL_MANAGER_WRITE_HANDLE_SIZE];\r
- * static serial_write_handle_t s_serialWriteHandle1 = &s_serialWriteHandleBuffer1[0];\r
- * static uint8_t s_nonBlockingWelcome1[] = "This is non-blocking writing log for task1!\r\n";\r
- * SerialManager_OpenWriteHandle(serialHandle, s_serialWriteHandle1);\r
+ * static uint32_t s_serialWriteHandleBuffer1[((SERIAL_MANAGER_WRITE_HANDLE_SIZE + sizeof(uint32_t) - 1) /\r
+ * sizeof(uitn32_t))]; static serial_write_handle_t s_serialWriteHandle1 =\r
+ * (serial_write_handle_t)&s_serialWriteHandleBuffer1[0]; static uint8_t s_nonBlockingWelcome1[] = "This is non-blocking\r
+ * writing log for task1!\r\n"; SerialManager_OpenWriteHandle(serialHandle, s_serialWriteHandle1);\r
* SerialManager_InstallTxCallback(s_serialWriteHandle1, Task1_SerialManagerTxCallback, s_serialWriteHandle1);\r
* SerialManager_WriteNonBlocking(s_serialWriteHandle1, s_nonBlockingWelcome1, sizeof(s_nonBlockingWelcome1) - 1);\r
* @endcode\r
* For task 2,\r
* @code\r
- * static uint8_t s_serialWriteHandleBuffer2[SERIAL_MANAGER_WRITE_HANDLE_SIZE];\r
- * static serial_write_handle_t s_serialWriteHandle2 = &s_serialWriteHandleBuffer2[0];\r
- * static uint8_t s_nonBlockingWelcome2[] = "This is non-blocking writing log for task2!\r\n";\r
- * SerialManager_OpenWriteHandle(serialHandle, s_serialWriteHandle2);\r
+ * static uint32_t s_serialWriteHandleBuffer2[((SERIAL_MANAGER_WRITE_HANDLE_SIZE + sizeof(uint32_t) - 1) /\r
+ * sizeof(uitn32_t))]; static serial_write_handle_t s_serialWriteHandle2 =\r
+ * (serial_write_handle_t)&s_serialWriteHandleBuffer2[0]; static uint8_t s_nonBlockingWelcome2[] = "This is non-blocking\r
+ * writing log for task2!\r\n"; SerialManager_OpenWriteHandle(serialHandle, s_serialWriteHandle2);\r
* SerialManager_InstallTxCallback(s_serialWriteHandle2, Task2_SerialManagerTxCallback, s_serialWriteHandle2);\r
* SerialManager_WriteNonBlocking(s_serialWriteHandle2, s_nonBlockingWelcome2, sizeof(s_nonBlockingWelcome2) - 1);\r
* @endcode\r
*\r
* This function Opens a reading handle for the serial manager module. The reading handle can not be\r
* opened multiple at the same time. The error code kStatus_SerialManager_Busy would be returned when\r
- * the previous reading handle is not closed. And There can only one buffer for receiving for the\r
+ * the previous reading handle is not closed. And There can only be one buffer for receiving for the\r
* reading handle at the same time.\r
*\r
* @param serialHandle The serial manager module handle pointer.\r
+ * The handle should be 4 byte aligned, because unaligned access does not support on some devices.\r
* @param readHandle The serial manager module reading handle pointer.\r
+ * The handle should be 4 byte aligned, because unaligned access does not support on some devices.\r
* @retval kStatus_SerialManager_Error An error occurred.\r
* @retval kStatus_SerialManager_Success The reading handle is opened.\r
* @retval kStatus_SerialManager_Busy Previous reading handle is not closed.\r
*\r
* Example below shows how to use this API to read data.\r
* @code\r
- * static uint8_t s_serialReadHandleBuffer[SERIAL_MANAGER_READ_HANDLE_SIZE];\r
- * static serial_read_handle_t s_serialReadHandle = &s_serialReadHandleBuffer[0];\r
- * SerialManager_OpenReadHandle(serialHandle, s_serialReadHandle);\r
+ * static uint32_t s_serialReadHandleBuffer[((SERIAL_MANAGER_READ_HANDLE_SIZE + sizeof(uint32_t) - 1) /\r
+ * sizeof(uitn32_t))]; static serial_read_handle_t s_serialReadHandle =\r
+ * (serial_read_handle_t)&s_serialReadHandleBuffer[0]; SerialManager_OpenReadHandle(serialHandle, s_serialReadHandle);\r
* static uint8_t s_nonBlockingBuffer[64];\r
* SerialManager_InstallRxCallback(s_serialReadHandle, APP_SerialManagerRxCallback, s_serialReadHandle);\r
* SerialManager_ReadNonBlocking(s_serialReadHandle, s_nonBlockingBuffer, sizeof(s_nonBlockingBuffer));\r
#if defined(__cplusplus)\r
}\r
#endif\r
-\r
+/*! @} */\r
#endif /* __SERIAL_MANAGER_H__ */\r
projects / freertos / blobdiff