3 * All rights reserved.
\r
6 * SPDX-License-Identifier: BSD-3-Clause
\r
9 #include "fsl_common.h"
\r
10 #include "serial_manager.h"
\r
11 #include "serial_port_internal.h"
\r
13 #if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U))
\r
16 #include "serial_port_uart.h"
\r
18 /*******************************************************************************
\r
20 ******************************************************************************/
\r
22 #if (defined(DEBUG_CONSOLE_ASSERT_DISABLE) && (DEBUG_CONSOLE_ASSERT_DISABLE > 0U))
\r
28 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
29 #define SERIAL_PORT_UART_RECEIVE_DATA_LENGTH 1U
\r
31 typedef struct _serial_uart_send_state
\r
33 serial_manager_callback_t callback;
\r
34 void *callbackParam;
\r
37 volatile uint8_t busy;
\r
38 } serial_uart_send_state_t;
\r
40 typedef struct _serial_uart_recv_state
\r
42 serial_manager_callback_t callback;
\r
43 void *callbackParam;
\r
44 volatile uint8_t busy;
\r
45 uint8_t readBuffer[SERIAL_PORT_UART_RECEIVE_DATA_LENGTH];
\r
46 } serial_uart_recv_state_t;
\r
49 typedef struct _serial_uart_state
\r
51 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
52 serial_uart_send_state_t tx;
\r
53 serial_uart_recv_state_t rx;
\r
55 uint8_t usartHandleBuffer[HAL_UART_HANDLE_SIZE];
\r
56 } serial_uart_state_t;
\r
58 /*******************************************************************************
\r
60 ******************************************************************************/
\r
62 /*******************************************************************************
\r
64 ******************************************************************************/
\r
66 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
67 /* UART user callback */
\r
68 static void Serial_UartCallback(hal_uart_handle_t handle, hal_uart_status_t status, void *userData)
\r
70 serial_uart_state_t *serialUartHandle;
\r
71 serial_manager_callback_message_t msg;
\r
72 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
\r
73 hal_uart_transfer_t transfer;
\r
76 if (NULL == userData)
\r
81 serialUartHandle = (serial_uart_state_t *)userData;
\r
83 if ((hal_uart_status_t)kStatus_HAL_UartRxIdle == status)
\r
85 if ((NULL != serialUartHandle->rx.callback))
\r
87 msg.buffer = &serialUartHandle->rx.readBuffer[0];
\r
88 msg.length = sizeof(serialUartHandle->rx.readBuffer);
\r
89 serialUartHandle->rx.callback(serialUartHandle->rx.callbackParam, &msg, kStatus_SerialManager_Success);
\r
91 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
\r
92 transfer.data = &serialUartHandle->rx.readBuffer[0];
\r
93 transfer.dataSize = sizeof(serialUartHandle->rx.readBuffer);
\r
94 if (kStatus_HAL_UartSuccess ==
\r
95 HAL_UartTransferReceiveNonBlocking(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]), &transfer))
\r
97 if ((hal_uart_status_t)kStatus_HAL_UartSuccess ==
\r
98 HAL_UartReceiveNonBlocking(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]),
\r
99 &serialUartHandle->rx.readBuffer[0], sizeof(serialUartHandle->rx.readBuffer)))
\r
102 serialUartHandle->rx.busy = 1U;
\r
106 serialUartHandle->rx.busy = 0U;
\r
109 else if ((hal_uart_status_t)kStatus_HAL_UartTxIdle == status)
\r
111 if (0U != serialUartHandle->tx.busy)
\r
113 serialUartHandle->tx.busy = 0U;
\r
114 if ((NULL != serialUartHandle->tx.callback))
\r
116 msg.buffer = serialUartHandle->tx.buffer;
\r
117 msg.length = serialUartHandle->tx.length;
\r
118 serialUartHandle->tx.callback(serialUartHandle->tx.callbackParam, &msg, kStatus_SerialManager_Success);
\r
128 serial_manager_status_t Serial_UartInit(serial_handle_t serialHandle, void *serialConfig)
\r
130 serial_uart_state_t *serialUartHandle;
\r
131 serial_port_uart_config_t *uartConfig;
\r
132 hal_uart_config_t config;
\r
133 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
134 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
\r
135 hal_uart_transfer_t transfer;
\r
139 assert(serialConfig);
\r
140 assert(serialHandle);
\r
141 assert(SERIAL_PORT_UART_HANDLE_SIZE >= sizeof(serial_uart_state_t));
\r
143 uartConfig = (serial_port_uart_config_t *)serialConfig;
\r
144 serialUartHandle = (serial_uart_state_t *)serialHandle;
\r
146 config.baudRate_Bps = uartConfig->baudRate;
\r
147 config.parityMode = (hal_uart_parity_mode_t)uartConfig->parityMode;
\r
148 config.stopBitCount = (hal_uart_stop_bit_count_t)uartConfig->stopBitCount;
\r
149 config.enableRx = uartConfig->enableRx;
\r
150 config.enableTx = uartConfig->enableTx;
\r
151 config.srcClock_Hz = uartConfig->clockRate;
\r
152 config.instance = uartConfig->instance;
\r
154 if (kStatus_HAL_UartSuccess != HAL_UartInit(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]), &config))
\r
156 return kStatus_SerialManager_Error;
\r
159 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
161 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
\r
162 if (kStatus_HAL_UartSuccess !=
\r
163 HAL_UartTransferInstallCallback(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]),
\r
164 Serial_UartCallback, serialUartHandle))
\r
166 if (kStatus_HAL_UartSuccess != HAL_UartInstallCallback(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]),
\r
167 Serial_UartCallback, serialUartHandle))
\r
170 return kStatus_SerialManager_Error;
\r
173 if (0U != uartConfig->enableRx)
\r
175 serialUartHandle->rx.busy = 1U;
\r
176 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
\r
177 transfer.data = &serialUartHandle->rx.readBuffer[0];
\r
178 transfer.dataSize = sizeof(serialUartHandle->rx.readBuffer);
\r
179 if (kStatus_HAL_UartSuccess !=
\r
180 HAL_UartTransferReceiveNonBlocking(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]), &transfer))
\r
182 if (kStatus_HAL_UartSuccess !=
\r
183 HAL_UartReceiveNonBlocking(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]),
\r
184 &serialUartHandle->rx.readBuffer[0], sizeof(serialUartHandle->rx.readBuffer)))
\r
187 serialUartHandle->rx.busy = 0U;
\r
188 return kStatus_SerialManager_Error;
\r
193 return kStatus_SerialManager_Success;
\r
196 serial_manager_status_t Serial_UartDeinit(serial_handle_t serialHandle)
\r
198 serial_uart_state_t *serialUartHandle;
\r
200 assert(serialHandle);
\r
202 serialUartHandle = (serial_uart_state_t *)serialHandle;
\r
204 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
205 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
\r
206 (void)HAL_UartTransferAbortReceive(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));
\r
208 (void)HAL_UartAbortReceive(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));
\r
211 (void)HAL_UartDeinit(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));
\r
213 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
214 serialUartHandle->tx.busy = 0U;
\r
215 serialUartHandle->rx.busy = 0U;
\r
218 return kStatus_SerialManager_Success;
\r
221 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
223 serial_manager_status_t Serial_UartWrite(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length)
\r
225 serial_uart_state_t *serialUartHandle;
\r
226 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
\r
227 hal_uart_transfer_t transfer;
\r
230 assert(serialHandle);
\r
234 serialUartHandle = (serial_uart_state_t *)serialHandle;
\r
236 if (0U != serialUartHandle->tx.busy)
\r
238 return kStatus_SerialManager_Busy;
\r
240 serialUartHandle->tx.busy = 1U;
\r
242 serialUartHandle->tx.buffer = buffer;
\r
243 serialUartHandle->tx.length = length;
\r
245 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
\r
246 transfer.data = buffer;
\r
247 transfer.dataSize = length;
\r
248 if (kStatus_HAL_UartSuccess !=
\r
249 HAL_UartTransferSendNonBlocking(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]), &transfer))
\r
251 if (kStatus_HAL_UartSuccess !=
\r
252 HAL_UartSendNonBlocking(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]), buffer, length))
\r
255 serialUartHandle->tx.busy = 0U;
\r
256 return kStatus_SerialManager_Error;
\r
258 return kStatus_SerialManager_Success;
\r
263 serial_manager_status_t Serial_UartWrite(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length)
\r
265 serial_uart_state_t *serialUartHandle;
\r
267 assert(serialHandle);
\r
271 serialUartHandle = (serial_uart_state_t *)serialHandle;
\r
273 return (serial_manager_status_t)HAL_UartSendBlocking(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]),
\r
277 serial_manager_status_t Serial_UartRead(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length)
\r
279 serial_uart_state_t *serialUartHandle;
\r
281 assert(serialHandle);
\r
285 serialUartHandle = (serial_uart_state_t *)serialHandle;
\r
287 return (serial_manager_status_t)HAL_UartReceiveBlocking(
\r
288 ((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]), buffer, length);
\r
293 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
\r
294 serial_manager_status_t Serial_UartCancelWrite(serial_handle_t serialHandle)
\r
296 serial_uart_state_t *serialUartHandle;
\r
297 serial_manager_callback_message_t msg;
\r
299 uint8_t isBusy = 0U;
\r
301 assert(serialHandle);
\r
303 serialUartHandle = (serial_uart_state_t *)serialHandle;
\r
305 primask = DisableGlobalIRQ();
\r
306 isBusy = serialUartHandle->tx.busy;
\r
307 serialUartHandle->tx.busy = 0U;
\r
308 EnableGlobalIRQ(primask);
\r
310 #if (defined(HAL_UART_TRANSFER_MODE) && (HAL_UART_TRANSFER_MODE > 0U))
\r
311 (void)HAL_UartTransferAbortSend(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));
\r
313 (void)HAL_UartAbortSend(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));
\r
317 if ((NULL != serialUartHandle->tx.callback))
\r
319 msg.buffer = serialUartHandle->tx.buffer;
\r
320 msg.length = serialUartHandle->tx.length;
\r
321 serialUartHandle->tx.callback(serialUartHandle->tx.callbackParam, &msg, kStatus_SerialManager_Canceled);
\r
324 return kStatus_SerialManager_Success;
\r
327 serial_manager_status_t Serial_UartInstallTxCallback(serial_handle_t serialHandle,
\r
328 serial_manager_callback_t callback,
\r
329 void *callbackParam)
\r
331 serial_uart_state_t *serialUartHandle;
\r
333 assert(serialHandle);
\r
335 serialUartHandle = (serial_uart_state_t *)serialHandle;
\r
337 serialUartHandle->tx.callback = callback;
\r
338 serialUartHandle->tx.callbackParam = callbackParam;
\r
340 return kStatus_SerialManager_Success;
\r
343 serial_manager_status_t Serial_UartInstallRxCallback(serial_handle_t serialHandle,
\r
344 serial_manager_callback_t callback,
\r
345 void *callbackParam)
\r
347 serial_uart_state_t *serialUartHandle;
\r
349 assert(serialHandle);
\r
351 serialUartHandle = (serial_uart_state_t *)serialHandle;
\r
353 serialUartHandle->rx.callback = callback;
\r
354 serialUartHandle->rx.callbackParam = callbackParam;
\r
356 return kStatus_SerialManager_Success;
\r
359 void Serial_UartIsrFunction(serial_handle_t serialHandle)
\r
361 serial_uart_state_t *serialUartHandle;
\r
363 assert(serialHandle);
\r
365 serialUartHandle = (serial_uart_state_t *)serialHandle;
\r
367 HAL_UartIsrFunction(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0]));
\r
371 serial_manager_status_t Serial_UartEnterLowpower(serial_handle_t serialHandle)
\r
373 serial_uart_state_t *serialUartHandle;
\r
375 assert(serialHandle);
\r
377 serialUartHandle = (serial_uart_state_t *)serialHandle;
\r
379 if (kStatus_HAL_UartSuccess != HAL_UartEnterLowpower(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0])))
\r
381 return kStatus_SerialManager_Error;
\r
384 return kStatus_SerialManager_Success;
\r
387 serial_manager_status_t Serial_UartExitLowpower(serial_handle_t serialHandle)
\r
389 serial_uart_state_t *serialUartHandle;
\r
391 assert(serialHandle);
\r
393 serialUartHandle = (serial_uart_state_t *)serialHandle;
\r
395 if (kStatus_HAL_UartSuccess != HAL_UartExitLowpower(((hal_uart_handle_t)&serialUartHandle->usartHandleBuffer[0])))
\r
397 return kStatus_SerialManager_Error;
\r
400 return kStatus_SerialManager_Success;
\r