STM32L4xx_HAL_Driver  1.14.0
Functions
Peripheral Control functions
STM32L4xx_HAL_Driver » USARTEx » USARTEx Exported Functions

Extended Peripheral Control functions. More...

Functions

HAL_StatusTypeDef HAL_USARTEx_EnableSlaveMode (USART_HandleTypeDef *husart)
 Enable the SPI slave mode. More...
 
HAL_StatusTypeDef HAL_USARTEx_DisableSlaveMode (USART_HandleTypeDef *husart)
 Disable the SPI slave mode. More...
 
HAL_StatusTypeDef HAL_USARTEx_ConfigNSS (USART_HandleTypeDef *husart, uint32_t NSSConfig)
 Configure the Slave Select input pin (NSS). More...
 
HAL_StatusTypeDef HAL_USARTEx_EnableFifoMode (USART_HandleTypeDef *husart)
 Enable the FIFO mode. More...
 
HAL_StatusTypeDef HAL_USARTEx_DisableFifoMode (USART_HandleTypeDef *husart)
 Disable the FIFO mode. More...
 
HAL_StatusTypeDef HAL_USARTEx_SetTxFifoThreshold (USART_HandleTypeDef *husart, uint32_t Threshold)
 Set the TXFIFO threshold. More...
 
HAL_StatusTypeDef HAL_USARTEx_SetRxFifoThreshold (USART_HandleTypeDef *husart, uint32_t Threshold)
 Set the RXFIFO threshold. More...
 

Detailed Description

Extended Peripheral Control functions. 

 ===============================================================================
                      ##### Peripheral Control functions #####
 ===============================================================================
    [..] This section provides the following functions:
     (+) HAL_USARTEx_EnableSPISlaveMode() API enables the SPI slave mode
     (+) HAL_USARTEx_DisableSPISlaveMode() API disables the SPI slave mode
     (+) HAL_USARTEx_ConfigNSS API configures the Slave Select input pin (NSS)
     (+) HAL_USARTEx_EnableFifoMode() API enables the FIFO mode
     (+) HAL_USARTEx_DisableFifoMode() API disables the FIFO mode
     (+) HAL_USARTEx_SetTxFifoThreshold() API sets the TX FIFO threshold
     (+) HAL_USARTEx_SetRxFifoThreshold() API sets the RX FIFO threshold

Function Documentation

◆ HAL_USARTEx_ConfigNSS()

HAL_StatusTypeDef HAL_USARTEx_ConfigNSS ( USART_HandleTypeDef *  husart,
uint32_t  NSSConfig 
)

Configure the Slave Select input pin (NSS).

Note
Software NSS management: SPI slave will always be selected and NSS input pin will be ignored.
Hardware NSS management: the SPI slave selection depends on NSS input pin. The slave is selected when NSS is low and deselected when NSS is high.
Parameters
husartUSART handle.
NSSConfigNSS configuration. This parameter can be one of the following values:
  • USART_NSS_HARD
  • USART_NSS_SOFT
Return values
HALstatus

Definition at line 271 of file stm32l4xx_hal_usart_ex.c.

272 {
273  uint32_t tmpcr1;
274 
275  /* Check parameters */
276  assert_param(IS_UART_SPI_SLAVE_INSTANCE(husart->Instance));
277  assert_param(IS_USART_NSS(NSSConfig));
278 
279  /* Process Locked */
280  __HAL_LOCK(husart);
281 
282  husart->State = HAL_USART_STATE_BUSY;
283 
284  /* Save actual USART configuration */
285  tmpcr1 = READ_REG(husart->Instance->CR1);
286 
287  /* Disable USART */
288  __HAL_USART_DISABLE(husart);
289 
290  /* Program DIS_NSS bit in the USART_CR2 register */
291  MODIFY_REG(husart->Instance->CR2, USART_CR2_DIS_NSS, NSSConfig);
292 
293  /* Restore USART configuration */
294  WRITE_REG(husart->Instance->CR1, tmpcr1);
295 
296  husart->State = HAL_USART_STATE_READY;
297 
298  /* Process Unlocked */
299  __HAL_UNLOCK(husart);
300 
301  return HAL_OK;
302 }
__USART_HandleTypeDef::State
__IO HAL_USART_StateTypeDef State
Definition: stm32l4xx_hal_usart.h:166
__HAL_UNLOCK
__HAL_UNLOCK(hrtc)
__HAL_LOCK
__HAL_LOCK(hrtc)
HAL_OK
return HAL_OK
Definition: stm32l4xx_hal_rtc_ex.c:885
HAL_USART_STATE_READY
Definition: stm32l4xx_hal_usart.h:95
HAL_USART_STATE_BUSY
Definition: stm32l4xx_hal_usart.h:96
MODIFY_REG
MODIFY_REG(hrtc->Instance->CR, RTC_CR_WUCKSEL,(uint32_t) WakeUpClock)
__USART_HandleTypeDef::Instance
USART_TypeDef * Instance
Definition: stm32l4xx_hal_usart.h:122
assert_param
assert_param(IS_RTC_WAKEUP_CLOCK(WakeUpClock))

◆ HAL_USARTEx_DisableFifoMode()

HAL_StatusTypeDef HAL_USARTEx_DisableFifoMode ( USART_HandleTypeDef *  husart)

Disable the FIFO mode.

Parameters
husartUSART handle.
Return values
HALstatus

Definition at line 352 of file stm32l4xx_hal_usart_ex.c.

353 {
354  uint32_t tmpcr1;
355 
356  /* Check parameters */
357  assert_param(IS_UART_FIFO_INSTANCE(husart->Instance));
358 
359  /* Process Locked */
360  __HAL_LOCK(husart);
361 
362  husart->State = HAL_USART_STATE_BUSY;
363 
364  /* Save actual USART configuration */
365  tmpcr1 = READ_REG(husart->Instance->CR1);
366 
367  /* Disable USART */
368  __HAL_USART_DISABLE(husart);
369 
370  /* Enable FIFO mode */
371  CLEAR_BIT(tmpcr1, USART_CR1_FIFOEN);
372  husart->FifoMode = USART_FIFOMODE_DISABLE;
373 
374  /* Restore USART configuration */
375  WRITE_REG(husart->Instance->CR1, tmpcr1);
376 
377  husart->State = HAL_USART_STATE_READY;
378 
379  /* Process Unlocked */
380  __HAL_UNLOCK(husart);
381 
382  return HAL_OK;
383 }
__USART_HandleTypeDef::State
__IO HAL_USART_StateTypeDef State
Definition: stm32l4xx_hal_usart.h:166
__HAL_UNLOCK
__HAL_UNLOCK(hrtc)
CLEAR_BIT
CLEAR_BIT(hrtc->Instance->CR, RTC_CR_WUTE)
__HAL_LOCK
__HAL_LOCK(hrtc)
HAL_OK
return HAL_OK
Definition: stm32l4xx_hal_rtc_ex.c:885
HAL_USART_STATE_READY
Definition: stm32l4xx_hal_usart.h:95
HAL_USART_STATE_BUSY
Definition: stm32l4xx_hal_usart.h:96
__USART_HandleTypeDef::Instance
USART_TypeDef * Instance
Definition: stm32l4xx_hal_usart.h:122
__USART_HandleTypeDef::FifoMode
uint32_t FifoMode
Definition: stm32l4xx_hal_usart.h:152
assert_param
assert_param(IS_RTC_WAKEUP_CLOCK(WakeUpClock))

◆ HAL_USARTEx_DisableSlaveMode()

HAL_StatusTypeDef HAL_USARTEx_DisableSlaveMode ( USART_HandleTypeDef *  husart)

Disable the SPI slave mode.

Parameters
husartUSART handle.
Return values
HALstatus

Definition at line 223 of file stm32l4xx_hal_usart_ex.c.

224 {
225  uint32_t tmpcr1;
226 
227  /* Check parameters */
228  assert_param(IS_UART_SPI_SLAVE_INSTANCE(husart->Instance));
229 
230  /* Process Locked */
231  __HAL_LOCK(husart);
232 
233  husart->State = HAL_USART_STATE_BUSY;
234 
235  /* Save actual USART configuration */
236  tmpcr1 = READ_REG(husart->Instance->CR1);
237 
238  /* Disable USART */
239  __HAL_USART_DISABLE(husart);
240 
241  /* Disable SPI slave mode */
242  CLEAR_BIT(husart->Instance->CR2, USART_CR2_SLVEN);
243 
244  /* Restore USART configuration */
245  WRITE_REG(husart->Instance->CR1, tmpcr1);
246 
247  husart->SlaveMode = USART_SLAVEMODE_ENABLE;
248 
249  husart->State = HAL_USART_STATE_READY;
250 
251  /* Process Unlocked */
252  __HAL_UNLOCK(husart);
253 
254  return HAL_OK;
255 }
__USART_HandleTypeDef::State
__IO HAL_USART_StateTypeDef State
Definition: stm32l4xx_hal_usart.h:166
__HAL_UNLOCK
__HAL_UNLOCK(hrtc)
CLEAR_BIT
CLEAR_BIT(hrtc->Instance->CR, RTC_CR_WUTE)
__HAL_LOCK
__HAL_LOCK(hrtc)
HAL_OK
return HAL_OK
Definition: stm32l4xx_hal_rtc_ex.c:885
HAL_USART_STATE_READY
Definition: stm32l4xx_hal_usart.h:95
HAL_USART_STATE_BUSY
Definition: stm32l4xx_hal_usart.h:96
__USART_HandleTypeDef::Instance
USART_TypeDef * Instance
Definition: stm32l4xx_hal_usart.h:122
__USART_HandleTypeDef::SlaveMode
uint32_t SlaveMode
Definition: stm32l4xx_hal_usart.h:147
assert_param
assert_param(IS_RTC_WAKEUP_CLOCK(WakeUpClock))

◆ HAL_USARTEx_EnableFifoMode()

HAL_StatusTypeDef HAL_USARTEx_EnableFifoMode ( USART_HandleTypeDef *  husart)

Enable the FIFO mode.

Parameters
husartUSART handle.
Return values
HALstatus

Definition at line 311 of file stm32l4xx_hal_usart_ex.c.

312 {
313  uint32_t tmpcr1;
314 
315  /* Check parameters */
316  assert_param(IS_UART_FIFO_INSTANCE(husart->Instance));
317 
318  /* Process Locked */
319  __HAL_LOCK(husart);
320 
321  husart->State = HAL_USART_STATE_BUSY;
322 
323  /* Save actual USART configuration */
324  tmpcr1 = READ_REG(husart->Instance->CR1);
325 
326  /* Disable USART */
327  __HAL_USART_DISABLE(husart);
328 
329  /* Enable FIFO mode */
330  SET_BIT(tmpcr1, USART_CR1_FIFOEN);
331  husart->FifoMode = USART_FIFOMODE_ENABLE;
332 
333  /* Restore USART configuration */
334  WRITE_REG(husart->Instance->CR1, tmpcr1);
335 
336  /* Determine the number of data to process during RX/TX ISR execution */
337  USARTEx_SetNbDataToProcess(husart);
338 
339  husart->State = HAL_USART_STATE_READY;
340 
341  /* Process Unlocked */
342  __HAL_UNLOCK(husart);
343 
344  return HAL_OK;
345 }
__USART_HandleTypeDef::State
__IO HAL_USART_StateTypeDef State
Definition: stm32l4xx_hal_usart.h:166
USARTEx_SetNbDataToProcess
static void USARTEx_SetNbDataToProcess(USART_HandleTypeDef *husart)
Calculate the number of data to process in RX/TX ISR.
Definition: stm32l4xx_hal_usart_ex.c:504
__HAL_UNLOCK
__HAL_UNLOCK(hrtc)
__HAL_LOCK
__HAL_LOCK(hrtc)
HAL_OK
return HAL_OK
Definition: stm32l4xx_hal_rtc_ex.c:885
HAL_USART_STATE_READY
Definition: stm32l4xx_hal_usart.h:95
HAL_USART_STATE_BUSY
Definition: stm32l4xx_hal_usart.h:96
__USART_HandleTypeDef::Instance
USART_TypeDef * Instance
Definition: stm32l4xx_hal_usart.h:122
__USART_HandleTypeDef::FifoMode
uint32_t FifoMode
Definition: stm32l4xx_hal_usart.h:152
assert_param
assert_param(IS_RTC_WAKEUP_CLOCK(WakeUpClock))

◆ HAL_USARTEx_EnableSlaveMode()

HAL_StatusTypeDef HAL_USARTEx_EnableSlaveMode ( USART_HandleTypeDef *  husart)

Enable the SPI slave mode.

Note
When the USART operates in SPI slave mode, it handles data flow using the serial interface clock derived from the external SCLK signal provided by the external master SPI device.
In SPI slave mode, the USART must be enabled before starting the master communications (or between frames while the clock is stable). Otherwise, if the USART slave is enabled while the master is in the middle of a frame, it will become desynchronized with the master.
The data register of the slave needs to be ready before the first edge of the communication clock or before the end of the ongoing communication, otherwise the SPI slave will transmit zeros.
Parameters
husartUSART handle.
Return values
HALstatus

Definition at line 175 of file stm32l4xx_hal_usart_ex.c.

176 {
177  uint32_t tmpcr1;
178 
179  /* Check parameters */
180  assert_param(IS_UART_SPI_SLAVE_INSTANCE(husart->Instance));
181 
182  /* Process Locked */
183  __HAL_LOCK(husart);
184 
185  husart->State = HAL_USART_STATE_BUSY;
186 
187  /* Save actual USART configuration */
188  tmpcr1 = READ_REG(husart->Instance->CR1);
189 
190  /* Disable USART */
191  __HAL_USART_DISABLE(husart);
192 
193  /* In SPI slave mode mode, the following bits must be kept cleared:
194  - LINEN and CLKEN bit in the USART_CR2 register
195  - HDSEL, SCEN and IREN bits in the USART_CR3 register.*/
196  CLEAR_BIT(husart->Instance->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN));
197  CLEAR_BIT(husart->Instance->CR3, (USART_CR3_SCEN | USART_CR3_HDSEL | USART_CR3_IREN));
198 
199  /* Enable SPI slave mode */
200  SET_BIT(husart->Instance->CR2, USART_CR2_SLVEN);
201 
202  /* Restore USART configuration */
203  WRITE_REG(husart->Instance->CR1, tmpcr1);
204 
205  husart->SlaveMode = USART_SLAVEMODE_ENABLE;
206 
207  husart->State = HAL_USART_STATE_READY;
208 
209  /* Enable USART */
210  __HAL_USART_ENABLE(husart);
211 
212  /* Process Unlocked */
213  __HAL_UNLOCK(husart);
214 
215  return HAL_OK;
216 }
__USART_HandleTypeDef::State
__IO HAL_USART_StateTypeDef State
Definition: stm32l4xx_hal_usart.h:166
__HAL_UNLOCK
__HAL_UNLOCK(hrtc)
CLEAR_BIT
CLEAR_BIT(hrtc->Instance->CR, RTC_CR_WUTE)
__HAL_LOCK
__HAL_LOCK(hrtc)
HAL_OK
return HAL_OK
Definition: stm32l4xx_hal_rtc_ex.c:885
HAL_USART_STATE_READY
Definition: stm32l4xx_hal_usart.h:95
HAL_USART_STATE_BUSY
Definition: stm32l4xx_hal_usart.h:96
__USART_HandleTypeDef::Instance
USART_TypeDef * Instance
Definition: stm32l4xx_hal_usart.h:122
__USART_HandleTypeDef::SlaveMode
uint32_t SlaveMode
Definition: stm32l4xx_hal_usart.h:147
assert_param
assert_param(IS_RTC_WAKEUP_CLOCK(WakeUpClock))

◆ HAL_USARTEx_SetRxFifoThreshold()

HAL_StatusTypeDef HAL_USARTEx_SetRxFifoThreshold ( USART_HandleTypeDef *  husart,
uint32_t  Threshold 
)

Set the RXFIFO threshold.

Parameters
husartUSART handle.
ThresholdRX FIFO threshold value This parameter can be one of the following values:
  • USART_RXFIFO_THRESHOLD_1_8
  • USART_RXFIFO_THRESHOLD_1_4
  • USART_RXFIFO_THRESHOLD_1_2
  • USART_RXFIFO_THRESHOLD_3_4
  • USART_RXFIFO_THRESHOLD_7_8
  • USART_RXFIFO_THRESHOLD_8_8
Return values
HALstatus

Definition at line 447 of file stm32l4xx_hal_usart_ex.c.

448 {
449  uint32_t tmpcr1;
450 
451  /* Check the parameters */
452  assert_param(IS_UART_FIFO_INSTANCE(husart->Instance));
453  assert_param(IS_USART_RXFIFO_THRESHOLD(Threshold));
454 
455  /* Process Locked */
456  __HAL_LOCK(husart);
457 
458  husart->State = HAL_USART_STATE_BUSY;
459 
460  /* Save actual USART configuration */
461  tmpcr1 = READ_REG(husart->Instance->CR1);
462 
463  /* Disable USART */
464  __HAL_USART_DISABLE(husart);
465 
466  /* Update RX threshold configuration */
467  MODIFY_REG(husart->Instance->CR3, USART_CR3_RXFTCFG, Threshold);
468 
469  /* Determine the number of data to process during RX/TX ISR execution */
470  USARTEx_SetNbDataToProcess(husart);
471 
472  /* Restore USART configuration */
473  WRITE_REG(husart->Instance->CR1, tmpcr1);
474 
475  husart->State = HAL_USART_STATE_READY;
476 
477  /* Process Unlocked */
478  __HAL_UNLOCK(husart);
479 
480  return HAL_OK;
481 }
__USART_HandleTypeDef::State
__IO HAL_USART_StateTypeDef State
Definition: stm32l4xx_hal_usart.h:166
USARTEx_SetNbDataToProcess
static void USARTEx_SetNbDataToProcess(USART_HandleTypeDef *husart)
Calculate the number of data to process in RX/TX ISR.
Definition: stm32l4xx_hal_usart_ex.c:504
__HAL_UNLOCK
__HAL_UNLOCK(hrtc)
__HAL_LOCK
__HAL_LOCK(hrtc)
HAL_OK
return HAL_OK
Definition: stm32l4xx_hal_rtc_ex.c:885
HAL_USART_STATE_READY
Definition: stm32l4xx_hal_usart.h:95
HAL_USART_STATE_BUSY
Definition: stm32l4xx_hal_usart.h:96
MODIFY_REG
MODIFY_REG(hrtc->Instance->CR, RTC_CR_WUCKSEL,(uint32_t) WakeUpClock)
__USART_HandleTypeDef::Instance
USART_TypeDef * Instance
Definition: stm32l4xx_hal_usart.h:122
assert_param
assert_param(IS_RTC_WAKEUP_CLOCK(WakeUpClock))

◆ HAL_USARTEx_SetTxFifoThreshold()

HAL_StatusTypeDef HAL_USARTEx_SetTxFifoThreshold ( USART_HandleTypeDef *  husart,
uint32_t  Threshold 
)

Set the TXFIFO threshold.

Parameters
husartUSART handle.
ThresholdTX FIFO threshold value This parameter can be one of the following values:
  • USART_TXFIFO_THRESHOLD_1_8
  • USART_TXFIFO_THRESHOLD_1_4
  • USART_TXFIFO_THRESHOLD_1_2
  • USART_TXFIFO_THRESHOLD_3_4
  • USART_TXFIFO_THRESHOLD_7_8
  • USART_TXFIFO_THRESHOLD_8_8
Return values
HALstatus

Definition at line 398 of file stm32l4xx_hal_usart_ex.c.

399 {
400  uint32_t tmpcr1;
401 
402  /* Check parameters */
403  assert_param(IS_UART_FIFO_INSTANCE(husart->Instance));
404  assert_param(IS_USART_TXFIFO_THRESHOLD(Threshold));
405 
406  /* Process Locked */
407  __HAL_LOCK(husart);
408 
409  husart->State = HAL_USART_STATE_BUSY;
410 
411  /* Save actual USART configuration */
412  tmpcr1 = READ_REG(husart->Instance->CR1);
413 
414  /* Disable USART */
415  __HAL_USART_DISABLE(husart);
416 
417  /* Update TX threshold configuration */
418  MODIFY_REG(husart->Instance->CR3, USART_CR3_TXFTCFG, Threshold);
419 
420  /* Determine the number of data to process during RX/TX ISR execution */
421  USARTEx_SetNbDataToProcess(husart);
422 
423  /* Restore USART configuration */
424  WRITE_REG(husart->Instance->CR1, tmpcr1);
425 
426  husart->State = HAL_USART_STATE_READY;
427 
428  /* Process Unlocked */
429  __HAL_UNLOCK(husart);
430 
431  return HAL_OK;
432 }
__USART_HandleTypeDef::State
__IO HAL_USART_StateTypeDef State
Definition: stm32l4xx_hal_usart.h:166
USARTEx_SetNbDataToProcess
static void USARTEx_SetNbDataToProcess(USART_HandleTypeDef *husart)
Calculate the number of data to process in RX/TX ISR.
Definition: stm32l4xx_hal_usart_ex.c:504
__HAL_UNLOCK
__HAL_UNLOCK(hrtc)
__HAL_LOCK
__HAL_LOCK(hrtc)
HAL_OK
return HAL_OK
Definition: stm32l4xx_hal_rtc_ex.c:885
HAL_USART_STATE_READY
Definition: stm32l4xx_hal_usart.h:95
HAL_USART_STATE_BUSY
Definition: stm32l4xx_hal_usart.h:96
MODIFY_REG
MODIFY_REG(hrtc->Instance->CR, RTC_CR_WUCKSEL,(uint32_t) WakeUpClock)
__USART_HandleTypeDef::Instance
USART_TypeDef * Instance
Definition: stm32l4xx_hal_usart.h:122
assert_param
assert_param(IS_RTC_WAKEUP_CLOCK(WakeUpClock))