|
38
|
1 /**
|
|
|
2 ******************************************************************************
|
|
|
3 * @file stm32f4xx_hal_usart.c
|
|
|
4 * @author MCD Application Team
|
|
|
5 * @version V1.2.0
|
|
|
6 * @date 26-December-2014
|
|
|
7 * @brief USART HAL module driver.
|
|
|
8 * This file provides firmware functions to manage the following
|
|
|
9 * functionalities of the Universal Synchronous Asynchronous Receiver Transmitter (USART) peripheral:
|
|
|
10 * + Initialization and de-initialization functions
|
|
|
11 * + IO operation functions
|
|
|
12 * + Peripheral Control functions
|
|
|
13 @verbatim
|
|
|
14 ==============================================================================
|
|
|
15 ##### How to use this driver #####
|
|
|
16 ==============================================================================
|
|
|
17 [..]
|
|
|
18 The USART HAL driver can be used as follows:
|
|
|
19
|
|
|
20 (#) Declare a USART_HandleTypeDef handle structure.
|
|
|
21 (#) Initialize the USART low level resources by implementing the HAL_USART_MspInit () API:
|
|
|
22 (##) Enable the USARTx interface clock.
|
|
|
23 (##) USART pins configuration:
|
|
|
24 (+++) Enable the clock for the USART GPIOs.
|
|
|
25 (+++) Configure these USART pins as alternate function pull-up.
|
|
|
26 (##) NVIC configuration if you need to use interrupt process (HAL_USART_Transmit_IT(),
|
|
|
27 HAL_USART_Receive_IT() and HAL_USART_TransmitReceive_IT() APIs):
|
|
|
28 (+++) Configure the USARTx interrupt priority.
|
|
|
29 (+++) Enable the NVIC USART IRQ handle.
|
|
|
30 (##) DMA Configuration if you need to use DMA process (HAL_USART_Transmit_DMA()
|
|
|
31 HAL_USART_Receive_IT() and HAL_USART_TransmitReceive_IT() APIs):
|
|
|
32 (+++) Declare a DMA handle structure for the Tx/Rx stream.
|
|
|
33 (+++) Enable the DMAx interface clock.
|
|
|
34 (+++) Configure the declared DMA handle structure with the required Tx/Rx parameters.
|
|
|
35 (+++) Configure the DMA Tx/Rx Stream.
|
|
|
36 (+++) Associate the initialized DMA handle to the USART DMA Tx/Rx handle.
|
|
|
37 (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx/Rx Stream.
|
|
|
38
|
|
|
39 (#) Program the Baud Rate, Word Length, Stop Bit, Parity, Hardware
|
|
|
40 flow control and Mode(Receiver/Transmitter) in the husart Init structure.
|
|
|
41
|
|
|
42 (#) Initialize the USART registers by calling the HAL_USART_Init() API:
|
|
|
43 (++) These APIs configures also the low level Hardware GPIO, CLOCK, CORTEX...etc)
|
|
|
44 by calling the customized HAL_USART_MspInit(&husart) API.
|
|
|
45
|
|
|
46 -@@- The specific USART interrupts (Transmission complete interrupt,
|
|
|
47 RXNE interrupt and Error Interrupts) will be managed using the macros
|
|
|
48 __HAL_USART_ENABLE_IT() and __HAL_USART_DISABLE_IT() inside the transmit and receive process.
|
|
|
49
|
|
|
50 (#) Three operation modes are available within this driver :
|
|
|
51
|
|
|
52 *** Polling mode IO operation ***
|
|
|
53 =================================
|
|
|
54 [..]
|
|
|
55 (+) Send an amount of data in blocking mode using HAL_USART_Transmit()
|
|
|
56 (+) Receive an amount of data in blocking mode using HAL_USART_Receive()
|
|
|
57
|
|
|
58 *** Interrupt mode IO operation ***
|
|
|
59 ===================================
|
|
|
60 [..]
|
|
|
61 (+) Send an amount of data in non blocking mode using HAL_USART_Transmit_IT()
|
|
|
62 (+) At transmission end of transfer HAL_USART_TxHalfCpltCallback is executed and user can
|
|
|
63 add his own code by customization of function pointer HAL_USART_TxCpltCallback
|
|
|
64 (+) Receive an amount of data in non blocking mode using HAL_USART_Receive_IT()
|
|
|
65 (+) At reception end of transfer HAL_USART_RxCpltCallback is executed and user can
|
|
|
66 add his own code by customization of function pointer HAL_UART_RxCpltCallback
|
|
|
67 (+) In case of transfer Error, HAL_USART_ErrorCallback() function is executed and user can
|
|
|
68 add his own code by customization of function pointer HAL_USART_ErrorCallback
|
|
|
69
|
|
|
70 *** DMA mode IO operation ***
|
|
|
71 ==============================
|
|
|
72 [..]
|
|
|
73 (+) Send an amount of data in non blocking mode (DMA) using HAL_USART_Transmit_DMA()
|
|
|
74 (+) At transmission end of half transfer HAL_USART_TxHalfCpltCallback is executed and user can
|
|
|
75 add his own code by customization of function pointer HAL_USART_TxHalfCpltCallback
|
|
|
76 (+) At transmission end of transfer HAL_USART_TxCpltCallback is executed and user can
|
|
|
77 add his own code by customization of function pointer HAL_USART_TxCpltCallback
|
|
|
78 (+) Receive an amount of data in non blocking mode (DMA) using HAL_USART_Receive_DMA()
|
|
|
79 (+) At reception end of half transfer HAL_USART_RxHalfCpltCallback is executed and user can
|
|
|
80 add his own code by customization of function pointer HAL_USART_RxHalfCpltCallback
|
|
|
81 (+) At reception end of transfer HAL_USART_RxCpltCallback is executed and user can
|
|
|
82 add his own code by customization of function pointer HAL_USART_RxCpltCallback
|
|
|
83 (+) In case of transfer Error, HAL_USART_ErrorCallback() function is executed and user can
|
|
|
84 add his own code by customization of function pointer HAL_USART_ErrorCallback
|
|
|
85 (+) Pause the DMA Transfer using HAL_USART_DMAPause()
|
|
|
86 (+) Resume the DMA Transfer using HAL_USART_DMAResume()
|
|
|
87 (+) Stop the DMA Transfer using HAL_USART_DMAStop()
|
|
|
88
|
|
|
89 *** USART HAL driver macros list ***
|
|
|
90 =============================================
|
|
|
91 [..]
|
|
|
92 Below the list of most used macros in USART HAL driver.
|
|
|
93
|
|
|
94 (+) __HAL_USART_ENABLE: Enable the USART peripheral
|
|
|
95 (+) __HAL_USART_DISABLE: Disable the USART peripheral
|
|
|
96 (+) __HAL_USART_GET_FLAG : Check whether the specified USART flag is set or not
|
|
|
97 (+) __HAL_USART_CLEAR_FLAG : Clear the specified USART pending flag
|
|
|
98 (+) __HAL_USART_ENABLE_IT: Enable the specified USART interrupt
|
|
|
99 (+) __HAL_USART_DISABLE_IT: Disable the specified USART interrupt
|
|
|
100
|
|
|
101 [..]
|
|
|
102 (@) You can refer to the USART HAL driver header file for more useful macros
|
|
|
103
|
|
|
104 @endverbatim
|
|
|
105 ******************************************************************************
|
|
|
106 * @attention
|
|
|
107 *
|
|
|
108 * <h2><center>© COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
|
|
|
109 *
|
|
|
110 * Redistribution and use in source and binary forms, with or without modification,
|
|
|
111 * are permitted provided that the following conditions are met:
|
|
|
112 * 1. Redistributions of source code must retain the above copyright notice,
|
|
|
113 * this list of conditions and the following disclaimer.
|
|
|
114 * 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
|
115 * this list of conditions and the following disclaimer in the documentation
|
|
|
116 * and/or other materials provided with the distribution.
|
|
|
117 * 3. Neither the name of STMicroelectronics nor the names of its contributors
|
|
|
118 * may be used to endorse or promote products derived from this software
|
|
|
119 * without specific prior written permission.
|
|
|
120 *
|
|
|
121 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
|
122 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
123 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
|
124 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
|
|
125 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
126 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
|
127 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
|
128 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
|
129 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
130 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
131 *
|
|
|
132 ******************************************************************************
|
|
|
133 */
|
|
|
134
|
|
|
135 /* Includes ------------------------------------------------------------------*/
|
|
|
136 #include "stm32f4xx_hal.h"
|
|
|
137
|
|
|
138 /** @addtogroup STM32F4xx_HAL_Driver
|
|
|
139 * @{
|
|
|
140 */
|
|
|
141
|
|
|
142 /** @defgroup USART USART
|
|
|
143 * @brief HAL USART Synchronous module driver
|
|
|
144 * @{
|
|
|
145 */
|
|
|
146 #ifdef HAL_USART_MODULE_ENABLED
|
|
|
147 /* Private typedef -----------------------------------------------------------*/
|
|
|
148 /* Private define ------------------------------------------------------------*/
|
|
|
149 /** @addtogroup USART_Private_Constants
|
|
|
150 * @{
|
|
|
151 */
|
|
|
152 #define DUMMY_DATA 0xFFFF
|
|
|
153 #define USART_TIMEOUT_VALUE 22000
|
|
|
154 /**
|
|
|
155 * @}
|
|
|
156 */
|
|
|
157 /* Private macro -------------------------------------------------------------*/
|
|
|
158 /* Private variables ---------------------------------------------------------*/
|
|
|
159 /* Private function prototypes -----------------------------------------------*/
|
|
|
160 /* Private functions ---------------------------------------------------------*/
|
|
|
161 /** @addtogroup USART_Private_Functions
|
|
|
162 * @{
|
|
|
163 */
|
|
|
164 static HAL_StatusTypeDef USART_Transmit_IT(USART_HandleTypeDef *husart);
|
|
|
165 static HAL_StatusTypeDef USART_EndTransmit_IT(USART_HandleTypeDef *husart);
|
|
|
166 static HAL_StatusTypeDef USART_Receive_IT(USART_HandleTypeDef *husart);
|
|
|
167 static HAL_StatusTypeDef USART_TransmitReceive_IT(USART_HandleTypeDef *husart);
|
|
|
168 static void USART_SetConfig (USART_HandleTypeDef *husart);
|
|
|
169 static void USART_DMATransmitCplt(DMA_HandleTypeDef *hdma);
|
|
|
170 static void USART_DMATxHalfCplt(DMA_HandleTypeDef *hdma);
|
|
|
171 static void USART_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
|
|
|
172 static void USART_DMARxHalfCplt(DMA_HandleTypeDef *hdma);
|
|
|
173 static void USART_DMAError(DMA_HandleTypeDef *hdma);
|
|
|
174 static HAL_StatusTypeDef USART_WaitOnFlagUntilTimeout(USART_HandleTypeDef *husart, uint32_t Flag, FlagStatus Status, uint32_t Timeout);
|
|
|
175 /**
|
|
|
176 * @}
|
|
|
177 */
|
|
|
178
|
|
|
179 /* Exported functions --------------------------------------------------------*/
|
|
|
180 /** @defgroup USART_Exported_Functions USART Exported Functions
|
|
|
181 * @{
|
|
|
182 */
|
|
|
183
|
|
|
184 /** @defgroup USART_Exported_Functions_Group1 USART Initialization and de-initialization functions
|
|
|
185 * @brief Initialization and Configuration functions
|
|
|
186 *
|
|
|
187 @verbatim
|
|
|
188 ==============================================================================
|
|
|
189 ##### Initialization and Configuration functions #####
|
|
|
190 ==============================================================================
|
|
|
191 [..]
|
|
|
192 This subsection provides a set of functions allowing to initialize the USART
|
|
|
193 in asynchronous and in synchronous modes.
|
|
|
194 (+) For the asynchronous mode only these parameters can be configured:
|
|
|
195 (++) Baud Rate
|
|
|
196 (++) Word Length
|
|
|
197 (++) Stop Bit
|
|
|
198 (++) Parity: If the parity is enabled, then the MSB bit of the data written
|
|
|
199 in the data register is transmitted but is changed by the parity bit.
|
|
|
200 Depending on the frame length defined by the M bit (8-bits or 9-bits),
|
|
|
201 please refer to Reference manual for possible USART frame formats.
|
|
|
202 (++) USART polarity
|
|
|
203 (++) USART phase
|
|
|
204 (++) USART LastBit
|
|
|
205 (++) Receiver/transmitter modes
|
|
|
206
|
|
|
207 [..]
|
|
|
208 The HAL_USART_Init() function follows the USART synchronous configuration
|
|
|
209 procedure (details for the procedure are available in reference manual (RM0329)).
|
|
|
210
|
|
|
211 @endverbatim
|
|
|
212 * @{
|
|
|
213 */
|
|
|
214
|
|
|
215 /**
|
|
|
216 * @brief Initializes the USART mode according to the specified
|
|
|
217 * parameters in the USART_InitTypeDef and create the associated handle.
|
|
|
218 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
219 * the configuration information for the specified USART module.
|
|
|
220 * @retval HAL status
|
|
|
221 */
|
|
|
222 HAL_StatusTypeDef HAL_USART_Init(USART_HandleTypeDef *husart)
|
|
|
223 {
|
|
|
224 /* Check the USART handle allocation */
|
|
|
225 if(husart == NULL)
|
|
|
226 {
|
|
|
227 return HAL_ERROR;
|
|
|
228 }
|
|
|
229
|
|
|
230 /* Check the parameters */
|
|
|
231 assert_param(IS_USART_INSTANCE(husart->Instance));
|
|
|
232
|
|
|
233 if(husart->State == HAL_USART_STATE_RESET)
|
|
|
234 {
|
|
|
235 /* Init the low level hardware */
|
|
|
236 HAL_USART_MspInit(husart);
|
|
|
237 }
|
|
|
238
|
|
|
239 husart->State = HAL_USART_STATE_BUSY;
|
|
|
240
|
|
|
241 /* Set the USART Communication parameters */
|
|
|
242 USART_SetConfig(husart);
|
|
|
243
|
|
|
244 /* In USART mode, the following bits must be kept cleared:
|
|
|
245 - LINEN bit in the USART_CR2 register
|
|
|
246 - HDSEL, SCEN and IREN bits in the USART_CR3 register */
|
|
|
247 husart->Instance->CR2 &= ~USART_CR2_LINEN;
|
|
|
248 husart->Instance->CR3 &= ~(USART_CR3_IREN | USART_CR3_SCEN | USART_CR3_HDSEL);
|
|
|
249
|
|
|
250 /* Enable the Peripheral */
|
|
|
251 __HAL_USART_ENABLE(husart);
|
|
|
252
|
|
|
253 /* Initialize the USART state */
|
|
|
254 husart->ErrorCode = HAL_USART_ERROR_NONE;
|
|
|
255 husart->State= HAL_USART_STATE_READY;
|
|
|
256
|
|
|
257 return HAL_OK;
|
|
|
258 }
|
|
|
259
|
|
|
260 /**
|
|
|
261 * @brief DeInitializes the USART peripheral.
|
|
|
262 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
263 * the configuration information for the specified USART module.
|
|
|
264 * @retval HAL status
|
|
|
265 */
|
|
|
266 HAL_StatusTypeDef HAL_USART_DeInit(USART_HandleTypeDef *husart)
|
|
|
267 {
|
|
|
268 /* Check the USART handle allocation */
|
|
|
269 if(husart == NULL)
|
|
|
270 {
|
|
|
271 return HAL_ERROR;
|
|
|
272 }
|
|
|
273
|
|
|
274 /* Check the parameters */
|
|
|
275 assert_param(IS_USART_INSTANCE(husart->Instance));
|
|
|
276
|
|
|
277 husart->State = HAL_USART_STATE_BUSY;
|
|
|
278
|
|
|
279 /* Disable the Peripheral */
|
|
|
280 __HAL_USART_DISABLE(husart);
|
|
|
281
|
|
|
282 /* DeInit the low level hardware */
|
|
|
283 HAL_USART_MspDeInit(husart);
|
|
|
284
|
|
|
285 husart->ErrorCode = HAL_USART_ERROR_NONE;
|
|
|
286 husart->State = HAL_USART_STATE_RESET;
|
|
|
287
|
|
|
288 /* Release Lock */
|
|
|
289 __HAL_UNLOCK(husart);
|
|
|
290
|
|
|
291 return HAL_OK;
|
|
|
292 }
|
|
|
293
|
|
|
294 /**
|
|
|
295 * @brief USART MSP Init.
|
|
|
296 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
297 * the configuration information for the specified USART module.
|
|
|
298 * @retval None
|
|
|
299 */
|
|
|
300 __weak void HAL_USART_MspInit(USART_HandleTypeDef *husart)
|
|
|
301 {
|
|
|
302 /* NOTE: This function Should not be modified, when the callback is needed,
|
|
|
303 the HAL_USART_MspInit could be implemented in the user file
|
|
|
304 */
|
|
|
305 }
|
|
|
306
|
|
|
307 /**
|
|
|
308 * @brief USART MSP DeInit.
|
|
|
309 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
310 * the configuration information for the specified USART module.
|
|
|
311 * @retval None
|
|
|
312 */
|
|
|
313 __weak void HAL_USART_MspDeInit(USART_HandleTypeDef *husart)
|
|
|
314 {
|
|
|
315 /* NOTE: This function Should not be modified, when the callback is needed,
|
|
|
316 the HAL_USART_MspDeInit could be implemented in the user file
|
|
|
317 */
|
|
|
318 }
|
|
|
319
|
|
|
320 /**
|
|
|
321 * @}
|
|
|
322 */
|
|
|
323
|
|
|
324 /** @defgroup USART_Exported_Functions_Group2 IO operation functions
|
|
|
325 * @brief USART Transmit and Receive functions
|
|
|
326 *
|
|
|
327 @verbatim
|
|
|
328 ==============================================================================
|
|
|
329 ##### IO operation functions #####
|
|
|
330 ==============================================================================
|
|
|
331 [..]
|
|
|
332 This subsection provides a set of functions allowing to manage the USART synchronous
|
|
|
333 data transfers.
|
|
|
334
|
|
|
335 [..]
|
|
|
336 The USART supports master mode only: it cannot receive or send data related to an input
|
|
|
337 clock (SCLK is always an output).
|
|
|
338
|
|
|
339 (#) There are two modes of transfer:
|
|
|
340 (++) Blocking mode: The communication is performed in polling mode.
|
|
|
341 The HAL status of all data processing is returned by the same function
|
|
|
342 after finishing transfer.
|
|
|
343 (++) No-Blocking mode: The communication is performed using Interrupts
|
|
|
344 or DMA, These API's return the HAL status.
|
|
|
345 The end of the data processing will be indicated through the
|
|
|
346 dedicated USART IRQ when using Interrupt mode or the DMA IRQ when
|
|
|
347 using DMA mode.
|
|
|
348 The HAL_USART_TxCpltCallback(), HAL_USART_RxCpltCallback() and HAL_USART_TxRxCpltCallback()
|
|
|
349 user callbacks
|
|
|
350 will be executed respectively at the end of the transmit or Receive process
|
|
|
351 The HAL_USART_ErrorCallback() user callback will be executed when a communication
|
|
|
352 error is detected
|
|
|
353
|
|
|
354 (#) Blocking mode APIs are :
|
|
|
355 (++) HAL_USART_Transmit() in simplex mode
|
|
|
356 (++) HAL_USART_Receive() in full duplex receive only
|
|
|
357 (++) HAL_USART_TransmitReceive() in full duplex mode
|
|
|
358
|
|
|
359 (#) Non Blocking mode APIs with Interrupt are :
|
|
|
360 (++) HAL_USART_Transmit_IT()in simplex mode
|
|
|
361 (++) HAL_USART_Receive_IT() in full duplex receive only
|
|
|
362 (++) HAL_USART_TransmitReceive_IT() in full duplex mode
|
|
|
363 (++) HAL_USART_IRQHandler()
|
|
|
364
|
|
|
365 (#) Non Blocking mode functions with DMA are :
|
|
|
366 (++) HAL_USART_Transmit_DMA()in simplex mode
|
|
|
367 (++) HAL_USART_Receive_DMA() in full duplex receive only
|
|
|
368 (++) HAL_USART_TransmitReceie_DMA() in full duplex mode
|
|
|
369 (++) HAL_USART_DMAPause()
|
|
|
370 (++) HAL_USART_DMAResume()
|
|
|
371 (++) HAL_USART_DMAStop()
|
|
|
372
|
|
|
373 (#) A set of Transfer Complete Callbacks are provided in non Blocking mode:
|
|
|
374 (++) HAL_USART_TxHalfCpltCallback()
|
|
|
375 (++) HAL_USART_TxCpltCallback()
|
|
|
376 (++) HAL_USART_RxHalfCpltCallback()
|
|
|
377 (++) HAL_USART_RxCpltCallback()
|
|
|
378 (++) HAL_USART_ErrorCallback()
|
|
|
379 (++) HAL_USART_TxRxCpltCallback()
|
|
|
380
|
|
|
381 @endverbatim
|
|
|
382 * @{
|
|
|
383 */
|
|
|
384
|
|
|
385 /**
|
|
|
386 * @brief Simplex Send an amount of data in blocking mode.
|
|
|
387 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
388 * the configuration information for the specified USART module.
|
|
|
389 * @param pTxData: Pointer to data buffer
|
|
|
390 * @param Size: Amount of data to be sent
|
|
|
391 * @param Timeout: Timeout duration
|
|
|
392 * @retval HAL status
|
|
|
393 */
|
|
|
394 HAL_StatusTypeDef HAL_USART_Transmit(USART_HandleTypeDef *husart, uint8_t *pTxData, uint16_t Size, uint32_t Timeout)
|
|
|
395 {
|
|
|
396 uint16_t* tmp;
|
|
|
397
|
|
|
398 if(husart->State == HAL_USART_STATE_READY)
|
|
|
399 {
|
|
|
400 if((pTxData == NULL) || (Size == 0))
|
|
|
401 {
|
|
|
402 return HAL_ERROR;
|
|
|
403 }
|
|
|
404
|
|
|
405 /* Process Locked */
|
|
|
406 __HAL_LOCK(husart);
|
|
|
407
|
|
|
408 husart->ErrorCode = HAL_USART_ERROR_NONE;
|
|
|
409 husart->State = HAL_USART_STATE_BUSY_TX;
|
|
|
410
|
|
|
411 husart->TxXferSize = Size;
|
|
|
412 husart->TxXferCount = Size;
|
|
|
413 while(husart->TxXferCount > 0)
|
|
|
414 {
|
|
|
415 husart->TxXferCount--;
|
|
|
416 if(husart->Init.WordLength == USART_WORDLENGTH_9B)
|
|
|
417 {
|
|
|
418 /* Wait for TC flag in order to write data in DR */
|
|
|
419 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, Timeout) != HAL_OK)
|
|
|
420 {
|
|
|
421 return HAL_TIMEOUT;
|
|
|
422 }
|
|
|
423 tmp = (uint16_t*) pTxData;
|
|
|
424 husart->Instance->DR = (*tmp & (uint16_t)0x01FF);
|
|
|
425 if(husart->Init.Parity == USART_PARITY_NONE)
|
|
|
426 {
|
|
|
427 pTxData += 2;
|
|
|
428 }
|
|
|
429 else
|
|
|
430 {
|
|
|
431 pTxData += 1;
|
|
|
432 }
|
|
|
433 }
|
|
|
434 else
|
|
|
435 {
|
|
|
436 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, Timeout) != HAL_OK)
|
|
|
437 {
|
|
|
438 return HAL_TIMEOUT;
|
|
|
439 }
|
|
|
440 husart->Instance->DR = (*pTxData++ & (uint8_t)0xFF);
|
|
|
441 }
|
|
|
442 }
|
|
|
443
|
|
|
444 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TC, RESET, Timeout) != HAL_OK)
|
|
|
445 {
|
|
|
446 return HAL_TIMEOUT;
|
|
|
447 }
|
|
|
448
|
|
|
449 husart->State = HAL_USART_STATE_READY;
|
|
|
450
|
|
|
451 /* Process Unlocked */
|
|
|
452 __HAL_UNLOCK(husart);
|
|
|
453
|
|
|
454 return HAL_OK;
|
|
|
455 }
|
|
|
456 else
|
|
|
457 {
|
|
|
458 return HAL_BUSY;
|
|
|
459 }
|
|
|
460 }
|
|
|
461
|
|
|
462 /**
|
|
|
463 * @brief Full-Duplex Receive an amount of data in blocking mode.
|
|
|
464 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
465 * the configuration information for the specified USART module.
|
|
|
466 * @param pRxData: Pointer to data buffer
|
|
|
467 * @param Size: Amount of data to be received
|
|
|
468 * @param Timeout: Timeout duration
|
|
|
469 * @retval HAL status
|
|
|
470 */
|
|
|
471 HAL_StatusTypeDef HAL_USART_Receive(USART_HandleTypeDef *husart, uint8_t *pRxData, uint16_t Size, uint32_t Timeout)
|
|
|
472 {
|
|
|
473 uint16_t* tmp;
|
|
|
474
|
|
|
475 if(husart->State == HAL_USART_STATE_READY)
|
|
|
476 {
|
|
|
477 if((pRxData == NULL) || (Size == 0))
|
|
|
478 {
|
|
|
479 return HAL_ERROR;
|
|
|
480 }
|
|
|
481 /* Process Locked */
|
|
|
482 __HAL_LOCK(husart);
|
|
|
483
|
|
|
484 husart->ErrorCode = HAL_USART_ERROR_NONE;
|
|
|
485 husart->State = HAL_USART_STATE_BUSY_RX;
|
|
|
486
|
|
|
487 husart->RxXferSize = Size;
|
|
|
488 husart->RxXferCount = Size;
|
|
|
489 /* Check the remain data to be received */
|
|
|
490 while(husart->RxXferCount > 0)
|
|
|
491 {
|
|
|
492 husart->RxXferCount--;
|
|
|
493 if(husart->Init.WordLength == USART_WORDLENGTH_9B)
|
|
|
494 {
|
|
|
495 /* Wait until TXE flag is set to send dummy byte in order to generate the clock for the slave to send data */
|
|
|
496 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, Timeout) != HAL_OK)
|
|
|
497 {
|
|
|
498 return HAL_TIMEOUT;
|
|
|
499 }
|
|
|
500 /* Send dummy byte in order to generate clock */
|
|
|
501 husart->Instance->DR = (DUMMY_DATA & (uint16_t)0x01FF);
|
|
|
502
|
|
|
503 /* Wait for RXNE Flag */
|
|
|
504 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_RXNE, RESET, Timeout) != HAL_OK)
|
|
|
505 {
|
|
|
506 return HAL_TIMEOUT;
|
|
|
507 }
|
|
|
508 tmp = (uint16_t*) pRxData ;
|
|
|
509 if(husart->Init.Parity == USART_PARITY_NONE)
|
|
|
510 {
|
|
|
511 *tmp = (uint16_t)(husart->Instance->DR & (uint16_t)0x01FF);
|
|
|
512 pRxData +=2;
|
|
|
513 }
|
|
|
514 else
|
|
|
515 {
|
|
|
516 *tmp = (uint16_t)(husart->Instance->DR & (uint16_t)0x00FF);
|
|
|
517 pRxData +=1;
|
|
|
518 }
|
|
|
519 }
|
|
|
520 else
|
|
|
521 {
|
|
|
522 /* Wait until TXE flag is set to send dummy byte in order to generate the clock for the slave to send data */
|
|
|
523 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, Timeout) != HAL_OK)
|
|
|
524 {
|
|
|
525 return HAL_TIMEOUT;
|
|
|
526 }
|
|
|
527
|
|
|
528 /* Send Dummy Byte in order to generate clock */
|
|
|
529 husart->Instance->DR = (DUMMY_DATA & (uint16_t)0x00FF);
|
|
|
530
|
|
|
531 /* Wait until RXNE flag is set to receive the byte */
|
|
|
532 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_RXNE, RESET, Timeout) != HAL_OK)
|
|
|
533 {
|
|
|
534 return HAL_TIMEOUT;
|
|
|
535 }
|
|
|
536 if(husart->Init.Parity == USART_PARITY_NONE)
|
|
|
537 {
|
|
|
538 /* Receive data */
|
|
|
539 *pRxData++ = (uint8_t)(husart->Instance->DR & (uint8_t)0x00FF);
|
|
|
540 }
|
|
|
541 else
|
|
|
542 {
|
|
|
543 /* Receive data */
|
|
|
544 *pRxData++ = (uint8_t)(husart->Instance->DR & (uint8_t)0x007F);
|
|
|
545 }
|
|
|
546
|
|
|
547 }
|
|
|
548 }
|
|
|
549
|
|
|
550 husart->State = HAL_USART_STATE_READY;
|
|
|
551
|
|
|
552 /* Process Unlocked */
|
|
|
553 __HAL_UNLOCK(husart);
|
|
|
554
|
|
|
555 return HAL_OK;
|
|
|
556 }
|
|
|
557 else
|
|
|
558 {
|
|
|
559 return HAL_BUSY;
|
|
|
560 }
|
|
|
561 }
|
|
|
562
|
|
|
563 /**
|
|
|
564 * @brief Full-Duplex Send receive an amount of data in full-duplex mode (blocking mode).
|
|
|
565 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
566 * the configuration information for the specified USART module.
|
|
|
567 * @param pTxData: Pointer to data transmitted buffer
|
|
|
568 * @param pRxData: Pointer to data received buffer
|
|
|
569 * @param Size: Amount of data to be sent
|
|
|
570 * @param Timeout: Timeout duration
|
|
|
571 * @retval HAL status
|
|
|
572 */
|
|
|
573 HAL_StatusTypeDef HAL_USART_TransmitReceive(USART_HandleTypeDef *husart, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size, uint32_t Timeout)
|
|
|
574 {
|
|
|
575 uint16_t* tmp;
|
|
|
576
|
|
|
577 if(husart->State == HAL_USART_STATE_READY)
|
|
|
578 {
|
|
|
579 if((pTxData == NULL) || (pRxData == NULL) || (Size == 0))
|
|
|
580 {
|
|
|
581 return HAL_ERROR;
|
|
|
582 }
|
|
|
583 /* Process Locked */
|
|
|
584 __HAL_LOCK(husart);
|
|
|
585
|
|
|
586 husart->ErrorCode = HAL_USART_ERROR_NONE;
|
|
|
587 husart->State = HAL_USART_STATE_BUSY_RX;
|
|
|
588
|
|
|
589 husart->RxXferSize = Size;
|
|
|
590 husart->TxXferSize = Size;
|
|
|
591 husart->TxXferCount = Size;
|
|
|
592 husart->RxXferCount = Size;
|
|
|
593
|
|
|
594 /* Check the remain data to be received */
|
|
|
595 while(husart->TxXferCount > 0)
|
|
|
596 {
|
|
|
597 husart->TxXferCount--;
|
|
|
598 husart->RxXferCount--;
|
|
|
599 if(husart->Init.WordLength == USART_WORDLENGTH_9B)
|
|
|
600 {
|
|
|
601 /* Wait for TC flag in order to write data in DR */
|
|
|
602 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, Timeout) != HAL_OK)
|
|
|
603 {
|
|
|
604 return HAL_TIMEOUT;
|
|
|
605 }
|
|
|
606 tmp = (uint16_t*) pTxData;
|
|
|
607 husart->Instance->DR = (*tmp & (uint16_t)0x01FF);
|
|
|
608 if(husart->Init.Parity == USART_PARITY_NONE)
|
|
|
609 {
|
|
|
610 pTxData += 2;
|
|
|
611 }
|
|
|
612 else
|
|
|
613 {
|
|
|
614 pTxData += 1;
|
|
|
615 }
|
|
|
616
|
|
|
617 /* Wait for RXNE Flag */
|
|
|
618 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_RXNE, RESET, Timeout) != HAL_OK)
|
|
|
619 {
|
|
|
620 return HAL_TIMEOUT;
|
|
|
621 }
|
|
|
622 tmp = (uint16_t*) pRxData ;
|
|
|
623 if(husart->Init.Parity == USART_PARITY_NONE)
|
|
|
624 {
|
|
|
625 *tmp = (uint16_t)(husart->Instance->DR & (uint16_t)0x01FF);
|
|
|
626 pRxData += 2;
|
|
|
627 }
|
|
|
628 else
|
|
|
629 {
|
|
|
630 *tmp = (uint16_t)(husart->Instance->DR & (uint16_t)0x00FF);
|
|
|
631 pRxData += 1;
|
|
|
632 }
|
|
|
633 }
|
|
|
634 else
|
|
|
635 {
|
|
|
636 /* Wait for TC flag in order to write data in DR */
|
|
|
637 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, Timeout) != HAL_OK)
|
|
|
638 {
|
|
|
639 return HAL_TIMEOUT;
|
|
|
640 }
|
|
|
641 husart->Instance->DR = (*pTxData++ & (uint8_t)0x00FF);
|
|
|
642
|
|
|
643 /* Wait for RXNE Flag */
|
|
|
644 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_RXNE, RESET, Timeout) != HAL_OK)
|
|
|
645 {
|
|
|
646 return HAL_TIMEOUT;
|
|
|
647 }
|
|
|
648 if(husart->Init.Parity == USART_PARITY_NONE)
|
|
|
649 {
|
|
|
650 /* Receive data */
|
|
|
651 *pRxData++ = (uint8_t)(husart->Instance->DR & (uint8_t)0x00FF);
|
|
|
652 }
|
|
|
653 else
|
|
|
654 {
|
|
|
655 /* Receive data */
|
|
|
656 *pRxData++ = (uint8_t)(husart->Instance->DR & (uint8_t)0x007F);
|
|
|
657 }
|
|
|
658 }
|
|
|
659 }
|
|
|
660
|
|
|
661 husart->State = HAL_USART_STATE_READY;
|
|
|
662
|
|
|
663 /* Process Unlocked */
|
|
|
664 __HAL_UNLOCK(husart);
|
|
|
665
|
|
|
666 return HAL_OK;
|
|
|
667 }
|
|
|
668 else
|
|
|
669 {
|
|
|
670 return HAL_BUSY;
|
|
|
671 }
|
|
|
672 }
|
|
|
673
|
|
|
674 /**
|
|
|
675 * @brief Simplex Send an amount of data in non-blocking mode.
|
|
|
676 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
677 * the configuration information for the specified USART module.
|
|
|
678 * @param pTxData: Pointer to data buffer
|
|
|
679 * @param Size: Amount of data to be sent
|
|
|
680 * @retval HAL status
|
|
|
681 * @note The USART errors are not managed to avoid the overrun error.
|
|
|
682 */
|
|
|
683 HAL_StatusTypeDef HAL_USART_Transmit_IT(USART_HandleTypeDef *husart, uint8_t *pTxData, uint16_t Size)
|
|
|
684 {
|
|
|
685 if(husart->State == HAL_USART_STATE_READY)
|
|
|
686 {
|
|
|
687 if((pTxData == NULL) || (Size == 0))
|
|
|
688 {
|
|
|
689 return HAL_ERROR;
|
|
|
690 }
|
|
|
691
|
|
|
692 /* Process Locked */
|
|
|
693 __HAL_LOCK(husart);
|
|
|
694
|
|
|
695 husart->pTxBuffPtr = pTxData;
|
|
|
696 husart->TxXferSize = Size;
|
|
|
697 husart->TxXferCount = Size;
|
|
|
698
|
|
|
699 husart->ErrorCode = HAL_USART_ERROR_NONE;
|
|
|
700 husart->State = HAL_USART_STATE_BUSY_TX;
|
|
|
701
|
|
|
702 /* The USART Error Interrupts: (Frame error, Noise error, Overrun error)
|
|
|
703 are not managed by the USART transmit process to avoid the overrun interrupt
|
|
|
704 when the USART mode is configured for transmit and receive "USART_MODE_TX_RX"
|
|
|
705 to benefit for the frame error and noise interrupts the USART mode should be
|
|
|
706 configured only for transmit "USART_MODE_TX"
|
|
|
707 The __HAL_USART_ENABLE_IT(husart, USART_IT_ERR) can be used to enable the Frame error,
|
|
|
708 Noise error interrupt */
|
|
|
709
|
|
|
710 /* Process Unlocked */
|
|
|
711 __HAL_UNLOCK(husart);
|
|
|
712
|
|
|
713 /* Enable the USART Transmit Data Register Empty Interrupt */
|
|
|
714 __HAL_USART_ENABLE_IT(husart, USART_IT_TXE);
|
|
|
715
|
|
|
716 return HAL_OK;
|
|
|
717 }
|
|
|
718 else
|
|
|
719 {
|
|
|
720 return HAL_BUSY;
|
|
|
721 }
|
|
|
722 }
|
|
|
723
|
|
|
724 /**
|
|
|
725 * @brief Simplex Receive an amount of data in non-blocking mode.
|
|
|
726 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
727 * the configuration information for the specified USART module.
|
|
|
728 * @param pRxData: Pointer to data buffer
|
|
|
729 * @param Size: Amount of data to be received
|
|
|
730 * @retval HAL status
|
|
|
731 */
|
|
|
732 HAL_StatusTypeDef HAL_USART_Receive_IT(USART_HandleTypeDef *husart, uint8_t *pRxData, uint16_t Size)
|
|
|
733 {
|
|
|
734 if(husart->State == HAL_USART_STATE_READY)
|
|
|
735 {
|
|
|
736 if((pRxData == NULL) || (Size == 0))
|
|
|
737 {
|
|
|
738 return HAL_ERROR;
|
|
|
739 }
|
|
|
740 /* Process Locked */
|
|
|
741 __HAL_LOCK(husart);
|
|
|
742
|
|
|
743 husart->pRxBuffPtr = pRxData;
|
|
|
744 husart->RxXferSize = Size;
|
|
|
745 husart->RxXferCount = Size;
|
|
|
746
|
|
|
747 husart->ErrorCode = HAL_USART_ERROR_NONE;
|
|
|
748 husart->State = HAL_USART_STATE_BUSY_RX;
|
|
|
749
|
|
|
750 /* Process Unlocked */
|
|
|
751 __HAL_UNLOCK(husart);
|
|
|
752
|
|
|
753 /* Enable the USART Data Register not empty Interrupt */
|
|
|
754 __HAL_USART_ENABLE_IT(husart, USART_IT_RXNE);
|
|
|
755
|
|
|
756 /* Enable the USART Parity Error Interrupt */
|
|
|
757 __HAL_USART_ENABLE_IT(husart, USART_IT_PE);
|
|
|
758
|
|
|
759 /* Enable the USART Error Interrupt: (Frame error, noise error, overrun error) */
|
|
|
760 __HAL_USART_ENABLE_IT(husart, USART_IT_ERR);
|
|
|
761
|
|
|
762 /* Send dummy byte in order to generate the clock for the slave to send data */
|
|
|
763 husart->Instance->DR = (DUMMY_DATA & (uint16_t)0x01FF);
|
|
|
764
|
|
|
765 return HAL_OK;
|
|
|
766 }
|
|
|
767 else
|
|
|
768 {
|
|
|
769 return HAL_BUSY;
|
|
|
770 }
|
|
|
771 }
|
|
|
772
|
|
|
773 /**
|
|
|
774 * @brief Full-Duplex Send receive an amount of data in full-duplex mode (non-blocking).
|
|
|
775 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
776 * the configuration information for the specified USART module.
|
|
|
777 * @param pTxData: Pointer to data transmitted buffer
|
|
|
778 * @param pRxData: Pointer to data received buffer
|
|
|
779 * @param Size: Amount of data to be received
|
|
|
780 * @retval HAL status
|
|
|
781 */
|
|
|
782 HAL_StatusTypeDef HAL_USART_TransmitReceive_IT(USART_HandleTypeDef *husart, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size)
|
|
|
783 {
|
|
|
784 if(husart->State == HAL_USART_STATE_READY)
|
|
|
785 {
|
|
|
786 if((pTxData == NULL) || (pRxData == NULL) || (Size == 0))
|
|
|
787 {
|
|
|
788 return HAL_ERROR;
|
|
|
789 }
|
|
|
790 /* Process Locked */
|
|
|
791 __HAL_LOCK(husart);
|
|
|
792
|
|
|
793 husart->pRxBuffPtr = pRxData;
|
|
|
794 husart->RxXferSize = Size;
|
|
|
795 husart->RxXferCount = Size;
|
|
|
796 husart->pTxBuffPtr = pTxData;
|
|
|
797 husart->TxXferSize = Size;
|
|
|
798 husart->TxXferCount = Size;
|
|
|
799
|
|
|
800 husart->ErrorCode = HAL_USART_ERROR_NONE;
|
|
|
801 husart->State = HAL_USART_STATE_BUSY_TX_RX;
|
|
|
802
|
|
|
803 /* Process Unlocked */
|
|
|
804 __HAL_UNLOCK(husart);
|
|
|
805
|
|
|
806 /* Enable the USART Data Register not empty Interrupt */
|
|
|
807 __HAL_USART_ENABLE_IT(husart, USART_IT_RXNE);
|
|
|
808
|
|
|
809 /* Enable the USART Parity Error Interrupt */
|
|
|
810 __HAL_USART_ENABLE_IT(husart, USART_IT_PE);
|
|
|
811
|
|
|
812 /* Enable the USART Error Interrupt: (Frame error, noise error, overrun error) */
|
|
|
813 __HAL_USART_ENABLE_IT(husart, USART_IT_ERR);
|
|
|
814
|
|
|
815 /* Enable the USART Transmit Data Register Empty Interrupt */
|
|
|
816 __HAL_USART_ENABLE_IT(husart, USART_IT_TXE);
|
|
|
817
|
|
|
818 return HAL_OK;
|
|
|
819 }
|
|
|
820 else
|
|
|
821 {
|
|
|
822 return HAL_BUSY;
|
|
|
823 }
|
|
|
824 }
|
|
|
825
|
|
|
826 /**
|
|
|
827 * @brief Simplex Send an amount of data in non-blocking mode.
|
|
|
828 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
829 * the configuration information for the specified USART module.
|
|
|
830 * @param pTxData: Pointer to data buffer
|
|
|
831 * @param Size: Amount of data to be sent
|
|
|
832 * @retval HAL status
|
|
|
833 */
|
|
|
834 HAL_StatusTypeDef HAL_USART_Transmit_DMA(USART_HandleTypeDef *husart, uint8_t *pTxData, uint16_t Size)
|
|
|
835 {
|
|
|
836 uint32_t *tmp;
|
|
|
837
|
|
|
838 if(husart->State == HAL_USART_STATE_READY)
|
|
|
839 {
|
|
|
840 if((pTxData == NULL) || (Size == 0))
|
|
|
841 {
|
|
|
842 return HAL_ERROR;
|
|
|
843 }
|
|
|
844 /* Process Locked */
|
|
|
845 __HAL_LOCK(husart);
|
|
|
846
|
|
|
847 husart->pTxBuffPtr = pTxData;
|
|
|
848 husart->TxXferSize = Size;
|
|
|
849 husart->TxXferCount = Size;
|
|
|
850
|
|
|
851 husart->ErrorCode = HAL_USART_ERROR_NONE;
|
|
|
852 husart->State = HAL_USART_STATE_BUSY_TX;
|
|
|
853
|
|
|
854 /* Set the USART DMA transfer complete callback */
|
|
|
855 husart->hdmatx->XferCpltCallback = USART_DMATransmitCplt;
|
|
|
856
|
|
|
857 /* Set the USART DMA Half transfer complete callback */
|
|
|
858 husart->hdmatx->XferHalfCpltCallback = USART_DMATxHalfCplt;
|
|
|
859
|
|
|
860 /* Set the DMA error callback */
|
|
|
861 husart->hdmatx->XferErrorCallback = USART_DMAError;
|
|
|
862
|
|
|
863 /* Enable the USART transmit DMA Stream */
|
|
|
864 tmp = (uint32_t*)&pTxData;
|
|
|
865 HAL_DMA_Start_IT(husart->hdmatx, *(uint32_t*)tmp, (uint32_t)&husart->Instance->DR, Size);
|
|
|
866
|
|
|
867 /* Clear the TC flag in the SR register by writing 0 to it */
|
|
|
868 __HAL_USART_CLEAR_FLAG(husart, USART_FLAG_TC);
|
|
|
869
|
|
|
870 /* Enable the DMA transfer for transmit request by setting the DMAT bit
|
|
|
871 in the USART CR3 register */
|
|
|
872 husart->Instance->CR3 |= USART_CR3_DMAT;
|
|
|
873
|
|
|
874 /* Process Unlocked */
|
|
|
875 __HAL_UNLOCK(husart);
|
|
|
876
|
|
|
877 return HAL_OK;
|
|
|
878 }
|
|
|
879 else
|
|
|
880 {
|
|
|
881 return HAL_BUSY;
|
|
|
882 }
|
|
|
883 }
|
|
|
884
|
|
|
885 /**
|
|
|
886 * @brief Full-Duplex Receive an amount of data in non-blocking mode.
|
|
|
887 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
888 * the configuration information for the specified USART module.
|
|
|
889 * @param pRxData: Pointer to data buffer
|
|
|
890 * @param Size: Amount of data to be received
|
|
|
891 * @retval HAL status
|
|
|
892 * @note The USART DMA transmit stream must be configured in order to generate the clock for the slave.
|
|
|
893 * @note When the USART parity is enabled (PCE = 1) the data received contain the parity bit.
|
|
|
894 */
|
|
|
895 HAL_StatusTypeDef HAL_USART_Receive_DMA(USART_HandleTypeDef *husart, uint8_t *pRxData, uint16_t Size)
|
|
|
896 {
|
|
|
897 uint32_t *tmp;
|
|
|
898
|
|
|
899 if(husart->State == HAL_USART_STATE_READY)
|
|
|
900 {
|
|
|
901 if((pRxData == NULL) || (Size == 0))
|
|
|
902 {
|
|
|
903 return HAL_ERROR;
|
|
|
904 }
|
|
|
905
|
|
|
906 /* Process Locked */
|
|
|
907 __HAL_LOCK(husart);
|
|
|
908
|
|
|
909 husart->pRxBuffPtr = pRxData;
|
|
|
910 husart->RxXferSize = Size;
|
|
|
911 husart->pTxBuffPtr = pRxData;
|
|
|
912 husart->TxXferSize = Size;
|
|
|
913
|
|
|
914 husart->ErrorCode = HAL_USART_ERROR_NONE;
|
|
|
915 husart->State = HAL_USART_STATE_BUSY_RX;
|
|
|
916
|
|
|
917 /* Set the USART DMA Rx transfer complete callback */
|
|
|
918 husart->hdmarx->XferCpltCallback = USART_DMAReceiveCplt;
|
|
|
919
|
|
|
920 /* Set the USART DMA Half transfer complete callback */
|
|
|
921 husart->hdmarx->XferHalfCpltCallback = USART_DMARxHalfCplt;
|
|
|
922
|
|
|
923 /* Set the USART DMA Rx transfer error callback */
|
|
|
924 husart->hdmarx->XferErrorCallback = USART_DMAError;
|
|
|
925
|
|
|
926 /* Enable the USART receive DMA Stream */
|
|
|
927 tmp = (uint32_t*)&pRxData;
|
|
|
928 HAL_DMA_Start_IT(husart->hdmarx, (uint32_t)&husart->Instance->DR, *(uint32_t*)tmp, Size);
|
|
|
929
|
|
|
930 /* Enable the USART transmit DMA Stream: the transmit stream is used in order
|
|
|
931 to generate in the non-blocking mode the clock to the slave device,
|
|
|
932 this mode isn't a simplex receive mode but a full-duplex receive one */
|
|
|
933 HAL_DMA_Start_IT(husart->hdmatx, *(uint32_t*)tmp, (uint32_t)&husart->Instance->DR, Size);
|
|
|
934
|
|
|
935 /* Clear the Overrun flag just before enabling the DMA Rx request: mandatory for the second transfer
|
|
|
936 when using the USART in circular mode */
|
|
|
937 __HAL_USART_CLEAR_OREFLAG(husart);
|
|
|
938
|
|
|
939 /* Enable the DMA transfer for the receiver request by setting the DMAR bit
|
|
|
940 in the USART CR3 register */
|
|
|
941 husart->Instance->CR3 |= USART_CR3_DMAR;
|
|
|
942
|
|
|
943 /* Enable the DMA transfer for transmit request by setting the DMAT bit
|
|
|
944 in the USART CR3 register */
|
|
|
945 husart->Instance->CR3 |= USART_CR3_DMAT;
|
|
|
946
|
|
|
947 /* Process Unlocked */
|
|
|
948 __HAL_UNLOCK(husart);
|
|
|
949
|
|
|
950 return HAL_OK;
|
|
|
951 }
|
|
|
952 else
|
|
|
953 {
|
|
|
954 return HAL_BUSY;
|
|
|
955 }
|
|
|
956 }
|
|
|
957
|
|
|
958 /**
|
|
|
959 * @brief Full-Duplex Transmit Receive an amount of data in non-blocking mode.
|
|
|
960 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
961 * the configuration information for the specified USART module.
|
|
|
962 * @param pTxData: Pointer to data transmitted buffer
|
|
|
963 * @param pRxData: Pointer to data received buffer
|
|
|
964 * @param Size: Amount of data to be received
|
|
|
965 * @note When the USART parity is enabled (PCE = 1) the data received contain the parity bit.
|
|
|
966 * @retval HAL status
|
|
|
967 */
|
|
|
968 HAL_StatusTypeDef HAL_USART_TransmitReceive_DMA(USART_HandleTypeDef *husart, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size)
|
|
|
969 {
|
|
|
970 uint32_t *tmp;
|
|
|
971
|
|
|
972 if(husart->State == HAL_USART_STATE_READY)
|
|
|
973 {
|
|
|
974 if((pTxData == NULL) || (pRxData == NULL) || (Size == 0))
|
|
|
975 {
|
|
|
976 return HAL_ERROR;
|
|
|
977 }
|
|
|
978 /* Process Locked */
|
|
|
979 __HAL_LOCK(husart);
|
|
|
980
|
|
|
981 husart->pRxBuffPtr = pRxData;
|
|
|
982 husart->RxXferSize = Size;
|
|
|
983 husart->pTxBuffPtr = pTxData;
|
|
|
984 husart->TxXferSize = Size;
|
|
|
985
|
|
|
986 husart->ErrorCode = HAL_USART_ERROR_NONE;
|
|
|
987 husart->State = HAL_USART_STATE_BUSY_TX_RX;
|
|
|
988
|
|
|
989 /* Set the USART DMA Rx transfer complete callback */
|
|
|
990 husart->hdmarx->XferCpltCallback = USART_DMAReceiveCplt;
|
|
|
991
|
|
|
992 /* Set the USART DMA Half transfer complete callback */
|
|
|
993 husart->hdmarx->XferHalfCpltCallback = USART_DMARxHalfCplt;
|
|
|
994
|
|
|
995 /* Set the USART DMA Tx transfer complete callback */
|
|
|
996 husart->hdmatx->XferCpltCallback = USART_DMATransmitCplt;
|
|
|
997
|
|
|
998 /* Set the USART DMA Half transfer complete callback */
|
|
|
999 husart->hdmatx->XferHalfCpltCallback = USART_DMATxHalfCplt;
|
|
|
1000
|
|
|
1001 /* Set the USART DMA Tx transfer error callback */
|
|
|
1002 husart->hdmatx->XferErrorCallback = USART_DMAError;
|
|
|
1003
|
|
|
1004 /* Set the USART DMA Rx transfer error callback */
|
|
|
1005 husart->hdmarx->XferErrorCallback = USART_DMAError;
|
|
|
1006
|
|
|
1007 /* Enable the USART receive DMA Stream */
|
|
|
1008 tmp = (uint32_t*)&pRxData;
|
|
|
1009 HAL_DMA_Start_IT(husart->hdmarx, (uint32_t)&husart->Instance->DR, *(uint32_t*)tmp, Size);
|
|
|
1010
|
|
|
1011 /* Enable the USART transmit DMA Stream */
|
|
|
1012 tmp = (uint32_t*)&pTxData;
|
|
|
1013 HAL_DMA_Start_IT(husart->hdmatx, *(uint32_t*)tmp, (uint32_t)&husart->Instance->DR, Size);
|
|
|
1014
|
|
|
1015 /* Clear the TC flag in the SR register by writing 0 to it */
|
|
|
1016 __HAL_USART_CLEAR_FLAG(husart, USART_FLAG_TC);
|
|
|
1017
|
|
|
1018 /* Clear the Overrun flag: mandatory for the second transfer in circular mode */
|
|
|
1019 __HAL_USART_CLEAR_OREFLAG(husart);
|
|
|
1020
|
|
|
1021 /* Enable the DMA transfer for the receiver request by setting the DMAR bit
|
|
|
1022 in the USART CR3 register */
|
|
|
1023 husart->Instance->CR3 |= USART_CR3_DMAR;
|
|
|
1024
|
|
|
1025 /* Enable the DMA transfer for transmit request by setting the DMAT bit
|
|
|
1026 in the USART CR3 register */
|
|
|
1027 husart->Instance->CR3 |= USART_CR3_DMAT;
|
|
|
1028
|
|
|
1029 /* Process Unlocked */
|
|
|
1030 __HAL_UNLOCK(husart);
|
|
|
1031
|
|
|
1032 return HAL_OK;
|
|
|
1033 }
|
|
|
1034 else
|
|
|
1035 {
|
|
|
1036 return HAL_BUSY;
|
|
|
1037 }
|
|
|
1038 }
|
|
|
1039
|
|
|
1040 /**
|
|
|
1041 * @brief Pauses the DMA Transfer.
|
|
|
1042 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
1043 * the configuration information for the specified USART module.
|
|
|
1044 * @retval HAL status
|
|
|
1045 */
|
|
|
1046 HAL_StatusTypeDef HAL_USART_DMAPause(USART_HandleTypeDef *husart)
|
|
|
1047 {
|
|
|
1048 /* Process Locked */
|
|
|
1049 __HAL_LOCK(husart);
|
|
|
1050
|
|
|
1051 /* Disable the USART DMA Tx request */
|
|
|
1052 husart->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAT);
|
|
|
1053
|
|
|
1054 /* Process Unlocked */
|
|
|
1055 __HAL_UNLOCK(husart);
|
|
|
1056
|
|
|
1057 return HAL_OK;
|
|
|
1058 }
|
|
|
1059
|
|
|
1060 /**
|
|
|
1061 * @brief Resumes the DMA Transfer.
|
|
|
1062 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
1063 * the configuration information for the specified USART module.
|
|
|
1064 * @retval HAL status
|
|
|
1065 */
|
|
|
1066 HAL_StatusTypeDef HAL_USART_DMAResume(USART_HandleTypeDef *husart)
|
|
|
1067 {
|
|
|
1068 /* Process Locked */
|
|
|
1069 __HAL_LOCK(husart);
|
|
|
1070
|
|
|
1071 /* Enable the USART DMA Tx request */
|
|
|
1072 husart->Instance->CR3 |= USART_CR3_DMAT;
|
|
|
1073
|
|
|
1074 /* Process Unlocked */
|
|
|
1075 __HAL_UNLOCK(husart);
|
|
|
1076
|
|
|
1077 return HAL_OK;
|
|
|
1078 }
|
|
|
1079
|
|
|
1080 /**
|
|
|
1081 * @brief Stops the DMA Transfer.
|
|
|
1082 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
1083 * the configuration information for the specified USART module.
|
|
|
1084 * @retval HAL status
|
|
|
1085 */
|
|
|
1086 HAL_StatusTypeDef HAL_USART_DMAStop(USART_HandleTypeDef *husart)
|
|
|
1087 {
|
|
|
1088 /* The Lock is not implemented on this API to allow the user application
|
|
|
1089 to call the HAL USART API under callbacks HAL_USART_TxCpltCallback() / HAL_USART_RxCpltCallback():
|
|
|
1090 when calling HAL_DMA_Abort() API the DMA TX/RX Transfer complete interrupt is generated
|
|
|
1091 and the correspond call back is executed HAL_USART_TxCpltCallback() / HAL_USART_RxCpltCallback()
|
|
|
1092 */
|
|
|
1093
|
|
|
1094 /* Abort the USART DMA Tx Stream */
|
|
|
1095 if(husart->hdmatx != NULL)
|
|
|
1096 {
|
|
|
1097 HAL_DMA_Abort(husart->hdmatx);
|
|
|
1098 }
|
|
|
1099 /* Abort the USART DMA Rx Stream */
|
|
|
1100 if(husart->hdmarx != NULL)
|
|
|
1101 {
|
|
|
1102 HAL_DMA_Abort(husart->hdmarx);
|
|
|
1103 }
|
|
|
1104
|
|
|
1105 /* Disable the USART Tx/Rx DMA requests */
|
|
|
1106 husart->Instance->CR3 &= ~USART_CR3_DMAT;
|
|
|
1107 husart->Instance->CR3 &= ~USART_CR3_DMAR;
|
|
|
1108
|
|
|
1109 husart->State = HAL_USART_STATE_READY;
|
|
|
1110
|
|
|
1111 return HAL_OK;
|
|
|
1112 }
|
|
|
1113
|
|
|
1114 /**
|
|
|
1115 * @brief This function handles USART interrupt request.
|
|
|
1116 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
1117 * the configuration information for the specified USART module.
|
|
|
1118 * @retval None
|
|
|
1119 */
|
|
|
1120 void HAL_USART_IRQHandler(USART_HandleTypeDef *husart)
|
|
|
1121 {
|
|
|
1122 uint32_t tmp1 = 0, tmp2 = 0;
|
|
|
1123
|
|
|
1124 tmp1 = __HAL_USART_GET_FLAG(husart, USART_FLAG_PE);
|
|
|
1125 tmp2 = __HAL_USART_GET_IT_SOURCE(husart, USART_IT_PE);
|
|
|
1126 /* USART parity error interrupt occurred -----------------------------------*/
|
|
|
1127 if((tmp1 != RESET) && (tmp2 != RESET))
|
|
|
1128 {
|
|
|
1129 __HAL_USART_CLEAR_PEFLAG(husart);
|
|
|
1130 husart->ErrorCode |= HAL_USART_ERROR_PE;
|
|
|
1131 }
|
|
|
1132
|
|
|
1133 tmp1 = __HAL_USART_GET_FLAG(husart, USART_FLAG_FE);
|
|
|
1134 tmp2 = __HAL_USART_GET_IT_SOURCE(husart, USART_IT_ERR);
|
|
|
1135 /* USART frame error interrupt occurred ------------------------------------*/
|
|
|
1136 if((tmp1 != RESET) && (tmp2 != RESET))
|
|
|
1137 {
|
|
|
1138 __HAL_USART_CLEAR_FEFLAG(husart);
|
|
|
1139 husart->ErrorCode |= HAL_USART_ERROR_FE;
|
|
|
1140 }
|
|
|
1141
|
|
|
1142 tmp1 = __HAL_USART_GET_FLAG(husart, USART_FLAG_NE);
|
|
|
1143 tmp2 = __HAL_USART_GET_IT_SOURCE(husart, USART_IT_ERR);
|
|
|
1144 /* USART noise error interrupt occurred ------------------------------------*/
|
|
|
1145 if((tmp1 != RESET) && (tmp2 != RESET))
|
|
|
1146 {
|
|
|
1147 __HAL_USART_CLEAR_NEFLAG(husart);
|
|
|
1148 husart->ErrorCode |= HAL_USART_ERROR_NE;
|
|
|
1149 }
|
|
|
1150
|
|
|
1151 tmp1 = __HAL_USART_GET_FLAG(husart, USART_FLAG_ORE);
|
|
|
1152 tmp2 = __HAL_USART_GET_IT_SOURCE(husart, USART_IT_ERR);
|
|
|
1153 /* USART Over-Run interrupt occurred ---------------------------------------*/
|
|
|
1154 if((tmp1 != RESET) && (tmp2 != RESET))
|
|
|
1155 {
|
|
|
1156 __HAL_USART_CLEAR_OREFLAG(husart);
|
|
|
1157 husart->ErrorCode |= HAL_USART_ERROR_ORE;
|
|
|
1158 }
|
|
|
1159
|
|
|
1160 if(husart->ErrorCode != HAL_USART_ERROR_NONE)
|
|
|
1161 {
|
|
|
1162 /* Set the USART state ready to be able to start again the process */
|
|
|
1163 husart->State = HAL_USART_STATE_READY;
|
|
|
1164
|
|
|
1165 HAL_USART_ErrorCallback(husart);
|
|
|
1166 }
|
|
|
1167
|
|
|
1168 tmp1 = __HAL_USART_GET_FLAG(husart, USART_FLAG_RXNE);
|
|
|
1169 tmp2 = __HAL_USART_GET_IT_SOURCE(husart, USART_IT_RXNE);
|
|
|
1170 /* USART in mode Receiver --------------------------------------------------*/
|
|
|
1171 if((tmp1 != RESET) && (tmp2 != RESET))
|
|
|
1172 {
|
|
|
1173 if(husart->State == HAL_USART_STATE_BUSY_RX)
|
|
|
1174 {
|
|
|
1175 USART_Receive_IT(husart);
|
|
|
1176 }
|
|
|
1177 else
|
|
|
1178 {
|
|
|
1179 USART_TransmitReceive_IT(husart);
|
|
|
1180 }
|
|
|
1181 }
|
|
|
1182
|
|
|
1183 tmp1 = __HAL_USART_GET_FLAG(husart, USART_FLAG_TXE);
|
|
|
1184 tmp2 = __HAL_USART_GET_IT_SOURCE(husart, USART_IT_TXE);
|
|
|
1185 /* USART in mode Transmitter -----------------------------------------------*/
|
|
|
1186 if((tmp1 != RESET) && (tmp2 != RESET))
|
|
|
1187 {
|
|
|
1188 if(husart->State == HAL_USART_STATE_BUSY_TX)
|
|
|
1189 {
|
|
|
1190 USART_Transmit_IT(husart);
|
|
|
1191 }
|
|
|
1192 else
|
|
|
1193 {
|
|
|
1194 USART_TransmitReceive_IT(husart);
|
|
|
1195 }
|
|
|
1196 }
|
|
|
1197
|
|
|
1198 tmp1 = __HAL_USART_GET_FLAG(husart, USART_FLAG_TC);
|
|
|
1199 tmp2 = __HAL_USART_GET_IT_SOURCE(husart, USART_IT_TC);
|
|
|
1200 /* USART in mode Transmitter (transmission end) ----------------------------*/
|
|
|
1201 if((tmp1 != RESET) && (tmp2 != RESET))
|
|
|
1202 {
|
|
|
1203 USART_EndTransmit_IT(husart);
|
|
|
1204 }
|
|
|
1205 }
|
|
|
1206
|
|
|
1207 /**
|
|
|
1208 * @brief Tx Transfer completed callbacks.
|
|
|
1209 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
1210 * the configuration information for the specified USART module.
|
|
|
1211 * @retval None
|
|
|
1212 */
|
|
|
1213 __weak void HAL_USART_TxCpltCallback(USART_HandleTypeDef *husart)
|
|
|
1214 {
|
|
|
1215 /* NOTE: This function Should not be modified, when the callback is needed,
|
|
|
1216 the HAL_USART_TxCpltCallback could be implemented in the user file
|
|
|
1217 */
|
|
|
1218 }
|
|
|
1219
|
|
|
1220 /**
|
|
|
1221 * @brief Tx Half Transfer completed callbacks.
|
|
|
1222 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
1223 * the configuration information for the specified USART module.
|
|
|
1224 * @retval None
|
|
|
1225 */
|
|
|
1226 __weak void HAL_USART_TxHalfCpltCallback(USART_HandleTypeDef *husart)
|
|
|
1227 {
|
|
|
1228 /* NOTE: This function Should not be modified, when the callback is needed,
|
|
|
1229 the HAL_USART_TxCpltCallback could be implemented in the user file
|
|
|
1230 */
|
|
|
1231 }
|
|
|
1232
|
|
|
1233 /**
|
|
|
1234 * @brief Rx Transfer completed callbacks.
|
|
|
1235 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
1236 * the configuration information for the specified USART module.
|
|
|
1237 * @retval None
|
|
|
1238 */
|
|
|
1239 __weak void HAL_USART_RxCpltCallback(USART_HandleTypeDef *husart)
|
|
|
1240 {
|
|
|
1241 /* NOTE: This function Should not be modified, when the callback is needed,
|
|
|
1242 the HAL_USART_TxCpltCallback could be implemented in the user file
|
|
|
1243 */
|
|
|
1244 }
|
|
|
1245
|
|
|
1246 /**
|
|
|
1247 * @brief Rx Half Transfer completed callbacks.
|
|
|
1248 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
1249 * the configuration information for the specified USART module.
|
|
|
1250 * @retval None
|
|
|
1251 */
|
|
|
1252 __weak void HAL_USART_RxHalfCpltCallback(USART_HandleTypeDef *husart)
|
|
|
1253 {
|
|
|
1254 /* NOTE: This function Should not be modified, when the callback is needed,
|
|
|
1255 the HAL_USART_TxCpltCallback could be implemented in the user file
|
|
|
1256 */
|
|
|
1257 }
|
|
|
1258
|
|
|
1259 /**
|
|
|
1260 * @brief Tx/Rx Transfers completed callback for the non-blocking process.
|
|
|
1261 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
1262 * the configuration information for the specified USART module.
|
|
|
1263 * @retval None
|
|
|
1264 */
|
|
|
1265 __weak void HAL_USART_TxRxCpltCallback(USART_HandleTypeDef *husart)
|
|
|
1266 {
|
|
|
1267 /* NOTE: This function Should not be modified, when the callback is needed,
|
|
|
1268 the HAL_USART_TxCpltCallback could be implemented in the user file
|
|
|
1269 */
|
|
|
1270 }
|
|
|
1271
|
|
|
1272 /**
|
|
|
1273 * @brief USART error callbacks.
|
|
|
1274 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
1275 * the configuration information for the specified USART module.
|
|
|
1276 * @retval None
|
|
|
1277 */
|
|
|
1278 __weak void HAL_USART_ErrorCallback(USART_HandleTypeDef *husart)
|
|
|
1279 {
|
|
|
1280 /* NOTE: This function Should not be modified, when the callback is needed,
|
|
|
1281 the HAL_USART_ErrorCallback could be implemented in the user file
|
|
|
1282 */
|
|
|
1283 }
|
|
|
1284
|
|
|
1285 /**
|
|
|
1286 * @}
|
|
|
1287 */
|
|
|
1288
|
|
|
1289 /** @defgroup USART_Exported_Functions_Group3 Peripheral State and Errors functions
|
|
|
1290 * @brief USART State and Errors functions
|
|
|
1291 *
|
|
|
1292 @verbatim
|
|
|
1293 ==============================================================================
|
|
|
1294 ##### Peripheral State and Errors functions #####
|
|
|
1295 ==============================================================================
|
|
|
1296 [..]
|
|
|
1297 This subsection provides a set of functions allowing to return the State of
|
|
|
1298 USART communication
|
|
|
1299 process, return Peripheral Errors occurred during communication process
|
|
|
1300 (+) HAL_USART_GetState() API can be helpful to check in run-time the state
|
|
|
1301 of the USART peripheral.
|
|
|
1302 (+) HAL_USART_GetError() check in run-time errors that could be occurred during
|
|
|
1303 communication.
|
|
|
1304 @endverbatim
|
|
|
1305 * @{
|
|
|
1306 */
|
|
|
1307
|
|
|
1308 /**
|
|
|
1309 * @brief Returns the USART state.
|
|
|
1310 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
1311 * the configuration information for the specified USART module.
|
|
|
1312 * @retval HAL state
|
|
|
1313 */
|
|
|
1314 HAL_USART_StateTypeDef HAL_USART_GetState(USART_HandleTypeDef *husart)
|
|
|
1315 {
|
|
|
1316 return husart->State;
|
|
|
1317 }
|
|
|
1318
|
|
|
1319 /**
|
|
|
1320 * @brief Return the USART error code
|
|
|
1321 * @param husart : pointer to a USART_HandleTypeDef structure that contains
|
|
|
1322 * the configuration information for the specified USART.
|
|
|
1323 * @retval USART Error Code
|
|
|
1324 */
|
|
|
1325 uint32_t HAL_USART_GetError(USART_HandleTypeDef *husart)
|
|
|
1326 {
|
|
|
1327 return husart->ErrorCode;
|
|
|
1328 }
|
|
|
1329
|
|
|
1330 /**
|
|
|
1331 * @}
|
|
|
1332 */
|
|
|
1333
|
|
|
1334
|
|
|
1335 /**
|
|
|
1336 * @brief DMA USART transmit process complete callback.
|
|
|
1337 * @param hdma: DMA handle
|
|
|
1338 * @retval None
|
|
|
1339 */
|
|
|
1340 static void USART_DMATransmitCplt(DMA_HandleTypeDef *hdma)
|
|
|
1341 {
|
|
|
1342 USART_HandleTypeDef* husart = ( USART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
|
|
|
1343 /* DMA Normal mode */
|
|
|
1344 if((hdma->Instance->CR & DMA_SxCR_CIRC) == 0)
|
|
|
1345 {
|
|
|
1346 husart->TxXferCount = 0;
|
|
|
1347 if(husart->State == HAL_USART_STATE_BUSY_TX)
|
|
|
1348 {
|
|
|
1349 /* Disable the DMA transfer for transmit request by resetting the DMAT bit
|
|
|
1350 in the USART CR3 register */
|
|
|
1351 CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAT);
|
|
|
1352
|
|
|
1353 /* Enable the USART Transmit Complete Interrupt */
|
|
|
1354 __HAL_USART_ENABLE_IT(husart, USART_IT_TC);
|
|
|
1355 }
|
|
|
1356 }
|
|
|
1357 /* DMA Circular mode */
|
|
|
1358 else
|
|
|
1359 {
|
|
|
1360 if(husart->State == HAL_USART_STATE_BUSY_TX)
|
|
|
1361 {
|
|
|
1362 HAL_USART_TxCpltCallback(husart);
|
|
|
1363 }
|
|
|
1364 }
|
|
|
1365 }
|
|
|
1366
|
|
|
1367 /**
|
|
|
1368 * @brief DMA USART transmit process half complete callback
|
|
|
1369 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
|
|
|
1370 * the configuration information for the specified DMA module.
|
|
|
1371 * @retval None
|
|
|
1372 */
|
|
|
1373 static void USART_DMATxHalfCplt(DMA_HandleTypeDef *hdma)
|
|
|
1374 {
|
|
|
1375 USART_HandleTypeDef* husart = (USART_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
|
|
|
1376
|
|
|
1377 HAL_USART_TxHalfCpltCallback(husart);
|
|
|
1378 }
|
|
|
1379
|
|
|
1380 /**
|
|
|
1381 * @brief DMA USART receive process complete callback.
|
|
|
1382 * @param hdma: DMA handle
|
|
|
1383 * @retval None
|
|
|
1384 */
|
|
|
1385 static void USART_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
|
|
|
1386 {
|
|
|
1387 USART_HandleTypeDef* husart = ( USART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
|
|
|
1388 /* DMA Normal mode */
|
|
|
1389 if((hdma->Instance->CR & DMA_SxCR_CIRC) == 0)
|
|
|
1390 {
|
|
|
1391 husart->RxXferCount = 0;
|
|
|
1392 if(husart->State == HAL_USART_STATE_BUSY_RX)
|
|
|
1393 {
|
|
|
1394 /* Disable the DMA transfer for the Transmit/receiver requests by setting the DMAT/DMAR bit
|
|
|
1395 in the USART CR3 register */
|
|
|
1396 husart->Instance->CR3 &= ~(USART_CR3_DMAR);
|
|
|
1397
|
|
|
1398 husart->State= HAL_USART_STATE_READY;
|
|
|
1399 HAL_USART_RxCpltCallback(husart);
|
|
|
1400 }
|
|
|
1401 /* The USART state is HAL_USART_STATE_BUSY_TX_RX */
|
|
|
1402 else
|
|
|
1403 {
|
|
|
1404 /* Disable the DMA transfer for the Transmit/receiver requests by setting the DMAT/DMAR bit
|
|
|
1405 in the USART CR3 register */
|
|
|
1406 husart->Instance->CR3 &= ~(USART_CR3_DMAR);
|
|
|
1407 husart->Instance->CR3 &= ~(USART_CR3_DMAT);
|
|
|
1408
|
|
|
1409 husart->State= HAL_USART_STATE_READY;
|
|
|
1410 HAL_USART_TxRxCpltCallback(husart);
|
|
|
1411 }
|
|
|
1412 }
|
|
|
1413 /* DMA circular mode */
|
|
|
1414 else
|
|
|
1415 {
|
|
|
1416 if(husart->State == HAL_USART_STATE_BUSY_RX)
|
|
|
1417 {
|
|
|
1418 HAL_USART_RxCpltCallback(husart);
|
|
|
1419 }
|
|
|
1420 /* The USART state is HAL_USART_STATE_BUSY_TX_RX */
|
|
|
1421 else
|
|
|
1422 {
|
|
|
1423 HAL_USART_TxRxCpltCallback(husart);
|
|
|
1424 }
|
|
|
1425 }
|
|
|
1426 }
|
|
|
1427
|
|
|
1428 /**
|
|
|
1429 * @brief DMA USART receive process half complete callback
|
|
|
1430 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
|
|
|
1431 * the configuration information for the specified DMA module.
|
|
|
1432 * @retval None
|
|
|
1433 */
|
|
|
1434 static void USART_DMARxHalfCplt(DMA_HandleTypeDef *hdma)
|
|
|
1435 {
|
|
|
1436 USART_HandleTypeDef* husart = (USART_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
|
|
|
1437
|
|
|
1438 HAL_USART_RxHalfCpltCallback(husart);
|
|
|
1439 }
|
|
|
1440
|
|
|
1441 /**
|
|
|
1442 * @brief DMA USART communication error callback.
|
|
|
1443 * @param hdma: DMA handle
|
|
|
1444 * @retval None
|
|
|
1445 */
|
|
|
1446 static void USART_DMAError(DMA_HandleTypeDef *hdma)
|
|
|
1447 {
|
|
|
1448 USART_HandleTypeDef* husart = ( USART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
|
|
|
1449
|
|
|
1450 husart->RxXferCount = 0;
|
|
|
1451 husart->TxXferCount = 0;
|
|
|
1452 husart->ErrorCode |= HAL_USART_ERROR_DMA;
|
|
|
1453 husart->State= HAL_USART_STATE_READY;
|
|
|
1454
|
|
|
1455 HAL_USART_ErrorCallback(husart);
|
|
|
1456 }
|
|
|
1457
|
|
|
1458 /**
|
|
|
1459 * @brief This function handles USART Communication Timeout.
|
|
|
1460 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
1461 * the configuration information for the specified USART module.
|
|
|
1462 * @param Flag: specifies the USART flag to check.
|
|
|
1463 * @param Status: The new Flag status (SET or RESET).
|
|
|
1464 * @param Timeout: Timeout duration
|
|
|
1465 * @retval HAL status
|
|
|
1466 */
|
|
|
1467 static HAL_StatusTypeDef USART_WaitOnFlagUntilTimeout(USART_HandleTypeDef *husart, uint32_t Flag, FlagStatus Status, uint32_t Timeout)
|
|
|
1468 {
|
|
|
1469 uint32_t tickstart = 0;
|
|
|
1470
|
|
|
1471 /* Get tick */
|
|
|
1472 tickstart = HAL_GetTick();
|
|
|
1473
|
|
|
1474 /* Wait until flag is set */
|
|
|
1475 if(Status == RESET)
|
|
|
1476 {
|
|
|
1477 while(__HAL_USART_GET_FLAG(husart, Flag) == RESET)
|
|
|
1478 {
|
|
|
1479 /* Check for the Timeout */
|
|
|
1480 if(Timeout != HAL_MAX_DELAY)
|
|
|
1481 {
|
|
|
1482 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
|
|
|
1483 {
|
|
|
1484 /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
|
|
|
1485 __HAL_USART_DISABLE_IT(husart, USART_IT_TXE);
|
|
|
1486 __HAL_USART_DISABLE_IT(husart, USART_IT_RXNE);
|
|
|
1487 __HAL_USART_DISABLE_IT(husart, USART_IT_PE);
|
|
|
1488 __HAL_USART_DISABLE_IT(husart, USART_IT_ERR);
|
|
|
1489
|
|
|
1490 husart->State= HAL_USART_STATE_READY;
|
|
|
1491
|
|
|
1492 /* Process Unlocked */
|
|
|
1493 __HAL_UNLOCK(husart);
|
|
|
1494
|
|
|
1495 return HAL_TIMEOUT;
|
|
|
1496 }
|
|
|
1497 }
|
|
|
1498 }
|
|
|
1499 }
|
|
|
1500 else
|
|
|
1501 {
|
|
|
1502 while(__HAL_USART_GET_FLAG(husart, Flag) != RESET)
|
|
|
1503 {
|
|
|
1504 /* Check for the Timeout */
|
|
|
1505 if(Timeout != HAL_MAX_DELAY)
|
|
|
1506 {
|
|
|
1507 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
|
|
|
1508 {
|
|
|
1509 /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
|
|
|
1510 __HAL_USART_DISABLE_IT(husart, USART_IT_TXE);
|
|
|
1511 __HAL_USART_DISABLE_IT(husart, USART_IT_RXNE);
|
|
|
1512 __HAL_USART_DISABLE_IT(husart, USART_IT_PE);
|
|
|
1513 __HAL_USART_DISABLE_IT(husart, USART_IT_ERR);
|
|
|
1514
|
|
|
1515 husart->State= HAL_USART_STATE_READY;
|
|
|
1516
|
|
|
1517 /* Process Unlocked */
|
|
|
1518 __HAL_UNLOCK(husart);
|
|
|
1519
|
|
|
1520 return HAL_TIMEOUT;
|
|
|
1521 }
|
|
|
1522 }
|
|
|
1523 }
|
|
|
1524 }
|
|
|
1525 return HAL_OK;
|
|
|
1526 }
|
|
|
1527
|
|
|
1528
|
|
|
1529 /**
|
|
|
1530 * @brief Simplex Send an amount of data in non-blocking mode.
|
|
|
1531 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
1532 * the configuration information for the specified USART module.
|
|
|
1533 * @retval HAL status
|
|
|
1534 * @note The USART errors are not managed to avoid the overrun error.
|
|
|
1535 */
|
|
|
1536 static HAL_StatusTypeDef USART_Transmit_IT(USART_HandleTypeDef *husart)
|
|
|
1537 {
|
|
|
1538 uint16_t* tmp;
|
|
|
1539
|
|
|
1540 if(husart->State == HAL_USART_STATE_BUSY_TX)
|
|
|
1541 {
|
|
|
1542 if(husart->Init.WordLength == USART_WORDLENGTH_9B)
|
|
|
1543 {
|
|
|
1544 tmp = (uint16_t*) husart->pTxBuffPtr;
|
|
|
1545 husart->Instance->DR = (uint16_t)(*tmp & (uint16_t)0x01FF);
|
|
|
1546 if(husart->Init.Parity == USART_PARITY_NONE)
|
|
|
1547 {
|
|
|
1548 husart->pTxBuffPtr += 2;
|
|
|
1549 }
|
|
|
1550 else
|
|
|
1551 {
|
|
|
1552 husart->pTxBuffPtr += 1;
|
|
|
1553 }
|
|
|
1554 }
|
|
|
1555 else
|
|
|
1556 {
|
|
|
1557 husart->Instance->DR = (uint8_t)(*husart->pTxBuffPtr++ & (uint8_t)0x00FF);
|
|
|
1558 }
|
|
|
1559
|
|
|
1560 if(--husart->TxXferCount == 0)
|
|
|
1561 {
|
|
|
1562 /* Disable the USART Transmit data register empty Interrupt */
|
|
|
1563 __HAL_USART_DISABLE_IT(husart, USART_IT_TXE);
|
|
|
1564
|
|
|
1565 /* Enable the USART Transmit Complete Interrupt */
|
|
|
1566 __HAL_USART_ENABLE_IT(husart, USART_IT_TC);
|
|
|
1567 }
|
|
|
1568 return HAL_OK;
|
|
|
1569 }
|
|
|
1570 else
|
|
|
1571 {
|
|
|
1572 return HAL_BUSY;
|
|
|
1573 }
|
|
|
1574 }
|
|
|
1575
|
|
|
1576 /**
|
|
|
1577 * @brief Wraps up transmission in non blocking mode.
|
|
|
1578 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
1579 * the configuration information for the specified USART module.
|
|
|
1580 * @retval HAL status
|
|
|
1581 */
|
|
|
1582 static HAL_StatusTypeDef USART_EndTransmit_IT(USART_HandleTypeDef *husart)
|
|
|
1583 {
|
|
|
1584 /* Disable the USART Transmit Complete Interrupt */
|
|
|
1585 __HAL_USART_DISABLE_IT(husart, USART_IT_TC);
|
|
|
1586
|
|
|
1587 /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) */
|
|
|
1588 __HAL_USART_DISABLE_IT(husart, USART_IT_ERR);
|
|
|
1589
|
|
|
1590 husart->State = HAL_USART_STATE_READY;
|
|
|
1591
|
|
|
1592 HAL_USART_TxCpltCallback(husart);
|
|
|
1593
|
|
|
1594 return HAL_OK;
|
|
|
1595 }
|
|
|
1596
|
|
|
1597 /**
|
|
|
1598 * @brief Simplex Receive an amount of data in non-blocking mode.
|
|
|
1599 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
1600 * the configuration information for the specified USART module.
|
|
|
1601 * @retval HAL status
|
|
|
1602 */
|
|
|
1603 static HAL_StatusTypeDef USART_Receive_IT(USART_HandleTypeDef *husart)
|
|
|
1604 {
|
|
|
1605 uint16_t* tmp;
|
|
|
1606 if(husart->State == HAL_USART_STATE_BUSY_RX)
|
|
|
1607 {
|
|
|
1608 if(husart->Init.WordLength == USART_WORDLENGTH_9B)
|
|
|
1609 {
|
|
|
1610 tmp = (uint16_t*) husart->pRxBuffPtr;
|
|
|
1611 if(husart->Init.Parity == USART_PARITY_NONE)
|
|
|
1612 {
|
|
|
1613 *tmp = (uint16_t)(husart->Instance->DR & (uint16_t)0x01FF);
|
|
|
1614 husart->pRxBuffPtr += 2;
|
|
|
1615 }
|
|
|
1616 else
|
|
|
1617 {
|
|
|
1618 *tmp = (uint16_t)(husart->Instance->DR & (uint16_t)0x00FF);
|
|
|
1619 husart->pRxBuffPtr += 1;
|
|
|
1620 }
|
|
|
1621 if(--husart->RxXferCount != 0x00)
|
|
|
1622 {
|
|
|
1623 /* Send dummy byte in order to generate the clock for the slave to send the next data */
|
|
|
1624 husart->Instance->DR = (DUMMY_DATA & (uint16_t)0x01FF);
|
|
|
1625 }
|
|
|
1626 }
|
|
|
1627 else
|
|
|
1628 {
|
|
|
1629 if(husart->Init.Parity == USART_PARITY_NONE)
|
|
|
1630 {
|
|
|
1631 *husart->pRxBuffPtr++ = (uint8_t)(husart->Instance->DR & (uint8_t)0x00FF);
|
|
|
1632 }
|
|
|
1633 else
|
|
|
1634 {
|
|
|
1635 *husart->pRxBuffPtr++ = (uint8_t)(husart->Instance->DR & (uint8_t)0x007F);
|
|
|
1636 }
|
|
|
1637
|
|
|
1638 if(--husart->RxXferCount != 0x00)
|
|
|
1639 {
|
|
|
1640 /* Send dummy byte in order to generate the clock for the slave to send the next data */
|
|
|
1641 husart->Instance->DR = (DUMMY_DATA & (uint16_t)0x00FF);
|
|
|
1642 }
|
|
|
1643 }
|
|
|
1644
|
|
|
1645 if(husart->RxXferCount == 0)
|
|
|
1646 {
|
|
|
1647 /* Disable the USART RXNE Interrupt */
|
|
|
1648 __HAL_USART_DISABLE_IT(husart, USART_IT_RXNE);
|
|
|
1649
|
|
|
1650 /* Disable the USART Parity Error Interrupt */
|
|
|
1651 __HAL_USART_DISABLE_IT(husart, USART_IT_PE);
|
|
|
1652
|
|
|
1653 /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) */
|
|
|
1654 __HAL_USART_DISABLE_IT(husart, USART_IT_ERR);
|
|
|
1655
|
|
|
1656 husart->State = HAL_USART_STATE_READY;
|
|
|
1657 HAL_USART_RxCpltCallback(husart);
|
|
|
1658
|
|
|
1659 return HAL_OK;
|
|
|
1660 }
|
|
|
1661 return HAL_OK;
|
|
|
1662 }
|
|
|
1663 else
|
|
|
1664 {
|
|
|
1665 return HAL_BUSY;
|
|
|
1666 }
|
|
|
1667 }
|
|
|
1668
|
|
|
1669 /**
|
|
|
1670 * @brief Full-Duplex Send receive an amount of data in full-duplex mode (non-blocking).
|
|
|
1671 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
1672 * the configuration information for the specified USART module.
|
|
|
1673 * @retval HAL status
|
|
|
1674 */
|
|
|
1675 static HAL_StatusTypeDef USART_TransmitReceive_IT(USART_HandleTypeDef *husart)
|
|
|
1676 {
|
|
|
1677 uint16_t* tmp;
|
|
|
1678
|
|
|
1679 if(husart->State == HAL_USART_STATE_BUSY_TX_RX)
|
|
|
1680 {
|
|
|
1681 if(husart->TxXferCount != 0x00)
|
|
|
1682 {
|
|
|
1683 if(__HAL_USART_GET_FLAG(husart, USART_FLAG_TXE) != RESET)
|
|
|
1684 {
|
|
|
1685 if(husart->Init.WordLength == USART_WORDLENGTH_9B)
|
|
|
1686 {
|
|
|
1687 tmp = (uint16_t*) husart->pTxBuffPtr;
|
|
|
1688 husart->Instance->DR = (uint16_t)(*tmp & (uint16_t)0x01FF);
|
|
|
1689 if(husart->Init.Parity == USART_PARITY_NONE)
|
|
|
1690 {
|
|
|
1691 husart->pTxBuffPtr += 2;
|
|
|
1692 }
|
|
|
1693 else
|
|
|
1694 {
|
|
|
1695 husart->pTxBuffPtr += 1;
|
|
|
1696 }
|
|
|
1697 }
|
|
|
1698 else
|
|
|
1699 {
|
|
|
1700 husart->Instance->DR = (uint8_t)(*husart->pTxBuffPtr++ & (uint8_t)0x00FF);
|
|
|
1701 }
|
|
|
1702 husart->TxXferCount--;
|
|
|
1703
|
|
|
1704 /* Check the latest data transmitted */
|
|
|
1705 if(husart->TxXferCount == 0)
|
|
|
1706 {
|
|
|
1707 __HAL_USART_DISABLE_IT(husart, USART_IT_TXE);
|
|
|
1708 }
|
|
|
1709 }
|
|
|
1710 }
|
|
|
1711
|
|
|
1712 if(husart->RxXferCount != 0x00)
|
|
|
1713 {
|
|
|
1714 if(__HAL_USART_GET_FLAG(husart, USART_FLAG_RXNE) != RESET)
|
|
|
1715 {
|
|
|
1716 if(husart->Init.WordLength == USART_WORDLENGTH_9B)
|
|
|
1717 {
|
|
|
1718 tmp = (uint16_t*) husart->pRxBuffPtr;
|
|
|
1719 if(husart->Init.Parity == USART_PARITY_NONE)
|
|
|
1720 {
|
|
|
1721 *tmp = (uint16_t)(husart->Instance->DR & (uint16_t)0x01FF);
|
|
|
1722 husart->pRxBuffPtr += 2;
|
|
|
1723 }
|
|
|
1724 else
|
|
|
1725 {
|
|
|
1726 *tmp = (uint16_t)(husart->Instance->DR & (uint16_t)0x00FF);
|
|
|
1727 husart->pRxBuffPtr += 1;
|
|
|
1728 }
|
|
|
1729 }
|
|
|
1730 else
|
|
|
1731 {
|
|
|
1732 if(husart->Init.Parity == USART_PARITY_NONE)
|
|
|
1733 {
|
|
|
1734 *husart->pRxBuffPtr++ = (uint8_t)(husart->Instance->DR & (uint8_t)0x00FF);
|
|
|
1735 }
|
|
|
1736 else
|
|
|
1737 {
|
|
|
1738 *husart->pRxBuffPtr++ = (uint8_t)(husart->Instance->DR & (uint8_t)0x007F);
|
|
|
1739 }
|
|
|
1740 }
|
|
|
1741 husart->RxXferCount--;
|
|
|
1742 }
|
|
|
1743 }
|
|
|
1744
|
|
|
1745 /* Check the latest data received */
|
|
|
1746 if(husart->RxXferCount == 0)
|
|
|
1747 {
|
|
|
1748 __HAL_USART_DISABLE_IT(husart, USART_IT_RXNE);
|
|
|
1749
|
|
|
1750 /* Disable the USART Parity Error Interrupt */
|
|
|
1751 __HAL_USART_DISABLE_IT(husart, USART_IT_PE);
|
|
|
1752
|
|
|
1753 /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) */
|
|
|
1754 __HAL_USART_DISABLE_IT(husart, USART_IT_ERR);
|
|
|
1755
|
|
|
1756 husart->State = HAL_USART_STATE_READY;
|
|
|
1757
|
|
|
1758 HAL_USART_TxRxCpltCallback(husart);
|
|
|
1759
|
|
|
1760 return HAL_OK;
|
|
|
1761 }
|
|
|
1762
|
|
|
1763 return HAL_OK;
|
|
|
1764 }
|
|
|
1765 else
|
|
|
1766 {
|
|
|
1767 return HAL_BUSY;
|
|
|
1768 }
|
|
|
1769 }
|
|
|
1770
|
|
|
1771 /**
|
|
|
1772 * @brief Configures the USART peripheral.
|
|
|
1773 * @param husart: pointer to a USART_HandleTypeDef structure that contains
|
|
|
1774 * the configuration information for the specified USART module.
|
|
|
1775 * @retval None
|
|
|
1776 */
|
|
|
1777 static void USART_SetConfig(USART_HandleTypeDef *husart)
|
|
|
1778 {
|
|
|
1779 uint32_t tmpreg = 0x00;
|
|
|
1780
|
|
|
1781 /* Check the parameters */
|
|
|
1782 assert_param(IS_USART_INSTANCE(husart->Instance));
|
|
|
1783 assert_param(IS_USART_POLARITY(husart->Init.CLKPolarity));
|
|
|
1784 assert_param(IS_USART_PHASE(husart->Init.CLKPhase));
|
|
|
1785 assert_param(IS_USART_LASTBIT(husart->Init.CLKLastBit));
|
|
|
1786 assert_param(IS_USART_BAUDRATE(husart->Init.BaudRate));
|
|
|
1787 assert_param(IS_USART_WORD_LENGTH(husart->Init.WordLength));
|
|
|
1788 assert_param(IS_USART_STOPBITS(husart->Init.StopBits));
|
|
|
1789 assert_param(IS_USART_PARITY(husart->Init.Parity));
|
|
|
1790 assert_param(IS_USART_MODE(husart->Init.Mode));
|
|
|
1791
|
|
|
1792 /* The LBCL, CPOL and CPHA bits have to be selected when both the transmitter and the
|
|
|
1793 receiver are disabled (TE=RE=0) to ensure that the clock pulses function correctly. */
|
|
|
1794 husart->Instance->CR1 &= (uint32_t)~((uint32_t)(USART_CR1_TE | USART_CR1_RE));
|
|
|
1795
|
|
|
1796 /*---------------------------- USART CR2 Configuration ---------------------*/
|
|
|
1797 tmpreg = husart->Instance->CR2;
|
|
|
1798 /* Clear CLKEN, CPOL, CPHA and LBCL bits */
|
|
|
1799 tmpreg &= (uint32_t)~((uint32_t)(USART_CR2_CPHA | USART_CR2_CPOL | USART_CR2_CLKEN | USART_CR2_LBCL | USART_CR2_STOP));
|
|
|
1800 /* Configure the USART Clock, CPOL, CPHA and LastBit -----------------------*/
|
|
|
1801 /* Set CPOL bit according to husart->Init.CLKPolarity value */
|
|
|
1802 /* Set CPHA bit according to husart->Init.CLKPhase value */
|
|
|
1803 /* Set LBCL bit according to husart->Init.CLKLastBit value */
|
|
|
1804 /* Set Stop Bits: Set STOP[13:12] bits according to husart->Init.StopBits value */
|
|
|
1805 tmpreg |= (uint32_t)(USART_CLOCK_ENABLE| husart->Init.CLKPolarity |
|
|
|
1806 husart->Init.CLKPhase| husart->Init.CLKLastBit | husart->Init.StopBits);
|
|
|
1807 /* Write to USART CR2 */
|
|
|
1808 husart->Instance->CR2 = (uint32_t)tmpreg;
|
|
|
1809
|
|
|
1810 /*-------------------------- USART CR1 Configuration -----------------------*/
|
|
|
1811 tmpreg = husart->Instance->CR1;
|
|
|
1812
|
|
|
1813 /* Clear M, PCE, PS, TE, RE and OVER8 bits */
|
|
|
1814 tmpreg &= (uint32_t)~((uint32_t)(USART_CR1_M | USART_CR1_PCE | USART_CR1_PS | USART_CR1_TE | \
|
|
|
1815 USART_CR1_RE | USART_CR1_OVER8));
|
|
|
1816
|
|
|
1817 /* Configure the USART Word Length, Parity and mode:
|
|
|
1818 Set the M bits according to husart->Init.WordLength value
|
|
|
1819 Set PCE and PS bits according to husart->Init.Parity value
|
|
|
1820 Set TE and RE bits according to husart->Init.Mode value
|
|
|
1821 Force OVER8 bit to 1 in order to reach the max USART frequencies */
|
|
|
1822 tmpreg |= (uint32_t)husart->Init.WordLength | husart->Init.Parity | husart->Init.Mode | USART_CR1_OVER8;
|
|
|
1823
|
|
|
1824 /* Write to USART CR1 */
|
|
|
1825 husart->Instance->CR1 = (uint32_t)tmpreg;
|
|
|
1826
|
|
|
1827 /*-------------------------- USART CR3 Configuration -----------------------*/
|
|
|
1828 /* Clear CTSE and RTSE bits */
|
|
|
1829 husart->Instance->CR3 &= (uint32_t)~((uint32_t)(USART_CR3_RTSE | USART_CR3_CTSE));
|
|
|
1830
|
|
|
1831 /*-------------------------- USART BRR Configuration -----------------------*/
|
|
|
1832 if((husart->Instance == USART1) || (husart->Instance == USART6))
|
|
|
1833 {
|
|
|
1834 husart->Instance->BRR = USART_BRR(HAL_RCC_GetPCLK2Freq(), husart->Init.BaudRate);
|
|
|
1835 }
|
|
|
1836 else
|
|
|
1837 {
|
|
|
1838 husart->Instance->BRR = USART_BRR(HAL_RCC_GetPCLK1Freq(), husart->Init.BaudRate);
|
|
|
1839 }
|
|
|
1840 }
|
|
|
1841
|
|
|
1842 /**
|
|
|
1843 * @}
|
|
|
1844 */
|
|
|
1845
|
|
|
1846 #endif /* HAL_USART_MODULE_ENABLED */
|
|
|
1847 /**
|
|
|
1848 * @}
|
|
|
1849 */
|
|
|
1850
|
|
|
1851 /**
|
|
|
1852 * @}
|
|
|
1853 */
|
|
|
1854
|
|
|
1855 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
|
