IRDA Private Functions

Functions
void	IRDA_InitCallbacksToDefault (IRDA_HandleTypeDef *hirda)
	Initialize the callbacks to their default values. More...
static HAL_StatusTypeDef	IRDA_SetConfig (IRDA_HandleTypeDef *hirda)
	Configure the IRDA peripheral. More...
static HAL_StatusTypeDef	IRDA_CheckIdleState (IRDA_HandleTypeDef *hirda)
	Check the IRDA Idle State. More...
static HAL_StatusTypeDef	IRDA_WaitOnFlagUntilTimeout (IRDA_HandleTypeDef *hirda, uint32_t Flag, FlagStatus Status, uint32_t Tickstart, uint32_t Timeout)
	Handle IRDA Communication Timeout. More...
static void	IRDA_EndTxTransfer (IRDA_HandleTypeDef *hirda)
	End ongoing Tx transfer on IRDA peripheral (following error detection or Transmit completion). More...
static void	IRDA_EndRxTransfer (IRDA_HandleTypeDef *hirda)
	End ongoing Rx transfer on UART peripheral (following error detection or Reception completion). More...
static void	IRDA_DMATransmitCplt (DMA_HandleTypeDef *hdma)
	DMA IRDA transmit process complete callback. More...
static void	IRDA_DMATransmitHalfCplt (DMA_HandleTypeDef *hdma)
	DMA IRDA transmit process half complete callback. More...
static void	IRDA_DMAReceiveCplt (DMA_HandleTypeDef *hdma)
	DMA IRDA receive process complete callback. More...
static void	IRDA_DMAReceiveHalfCplt (DMA_HandleTypeDef *hdma)
	DMA IRDA receive process half complete callback. More...
static void	IRDA_DMAError (DMA_HandleTypeDef *hdma)
	DMA IRDA communication error callback. More...
static void	IRDA_DMAAbortOnError (DMA_HandleTypeDef *hdma)
	DMA IRDA communication abort callback, when initiated by HAL services on Error (To be called at end of DMA Abort procedure following error occurrence). More...
static void	IRDA_DMATxAbortCallback (DMA_HandleTypeDef *hdma)
	DMA IRDA Tx communication abort callback, when initiated by user (To be called at end of DMA Tx Abort procedure following user abort request). More...
static void	IRDA_DMARxAbortCallback (DMA_HandleTypeDef *hdma)
	DMA IRDA Rx communication abort callback, when initiated by user (To be called at end of DMA Rx Abort procedure following user abort request). More...
static void	IRDA_DMATxOnlyAbortCallback (DMA_HandleTypeDef *hdma)
	DMA IRDA Tx communication abort callback, when initiated by user by a call to HAL_IRDA_AbortTransmit_IT API (Abort only Tx transfer) (This callback is executed at end of DMA Tx Abort procedure following user abort request, and leads to user Tx Abort Complete callback execution). More...
static void	IRDA_DMARxOnlyAbortCallback (DMA_HandleTypeDef *hdma)
	DMA IRDA Rx communication abort callback, when initiated by user by a call to HAL_IRDA_AbortReceive_IT API (Abort only Rx transfer) (This callback is executed at end of DMA Rx Abort procedure following user abort request, and leads to user Rx Abort Complete callback execution). More...
static void	IRDA_Transmit_IT (IRDA_HandleTypeDef *hirda)
	Send an amount of data in interrupt mode. More...
static void	IRDA_EndTransmit_IT (IRDA_HandleTypeDef *hirda)
	Wrap up transmission in non-blocking mode. More...
static void	IRDA_Receive_IT (IRDA_HandleTypeDef *hirda)
	Receive an amount of data in interrupt mode. More...

Detailed Description

Function Documentation

IRDA_CheckIdleState()

static HAL_StatusTypeDef IRDA_CheckIdleState ( IRDA_HandleTypeDef *  hirda )

static

Check the IRDA Idle State.

Parameters

hirda

Pointer to a IRDA_HandleTypeDef structure that contains the configuration information for the specified IRDA module.

Return values

HAL

status

Definition at line 2382 of file stm32l4xx_hal_irda.c.

{
  uint32_t tickstart;

  /* Initialize the IRDA ErrorCode */
  hirda->ErrorCode = HAL_IRDA_ERROR_NONE;

  /* Init tickstart for timeout managment*/
  tickstart = HAL_GetTick();

  /* Check if the Transmitter is enabled */
  if ((hirda->Instance->CR1 & USART_CR1_TE) == USART_CR1_TE)
  {
    /* Wait until TEACK flag is set */
    if (IRDA_WaitOnFlagUntilTimeout(hirda, USART_ISR_TEACK, RESET, tickstart, IRDA_TEACK_REACK_TIMEOUT) != HAL_OK)
    {
      /* Timeout occurred */
      return HAL_TIMEOUT;
    }
  }
  /* Check if the Receiver is enabled */
  if ((hirda->Instance->CR1 & USART_CR1_RE) == USART_CR1_RE)
  {
    /* Wait until REACK flag is set */
    if (IRDA_WaitOnFlagUntilTimeout(hirda, USART_ISR_REACK, RESET, tickstart, IRDA_TEACK_REACK_TIMEOUT) != HAL_OK)
    {
      /* Timeout occurred */
      return HAL_TIMEOUT;
    }
  }

  /* Initialize the IRDA state*/
  hirda->gState  = HAL_IRDA_STATE_READY;
  hirda->RxState = HAL_IRDA_STATE_READY;

  /* Process Unlocked */
  __HAL_UNLOCK(hirda);

  return HAL_OK;
}

IRDA_DMAAbortOnError()

static void IRDA_DMAAbortOnError ( DMA_HandleTypeDef *  hdma )

static

DMA IRDA communication abort callback, when initiated by HAL services on Error (To be called at end of DMA Abort procedure following error occurrence).

Parameters

hdma	DMA handle.

Return values

None

Definition at line 2662 of file stm32l4xx_hal_irda.c.

{
  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)(hdma->Parent);
  hirda->RxXferCount = 0U;
  hirda->TxXferCount = 0U;

#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
  /* Call registered user error callback */
  hirda->ErrorCallback(hirda);
#else
  /* Call legacy weak user error callback */
  HAL_IRDA_ErrorCallback(hirda);
#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
}

IRDA_DMAError()

static void IRDA_DMAError ( DMA_HandleTypeDef *  hdma )

static

DMA IRDA communication error callback.

Parameters

hdma	Pointer to a DMA_HandleTypeDef structure that contains the configuration information for the specified DMA module.

Return values

None

Definition at line 2622 of file stm32l4xx_hal_irda.c.

{
  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)(hdma->Parent);

  /* Stop IRDA DMA Tx request if ongoing */
  if (hirda->gState == HAL_IRDA_STATE_BUSY_TX)
  {
    if (HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAT))
    {
      hirda->TxXferCount = 0U;
      IRDA_EndTxTransfer(hirda);
    }
  }

  /* Stop IRDA DMA Rx request if ongoing */
  if (hirda->RxState == HAL_IRDA_STATE_BUSY_RX)
  {
    if (HAL_IS_BIT_SET(hirda->Instance->CR3, USART_CR3_DMAR))
    {
      hirda->RxXferCount = 0U;
      IRDA_EndRxTransfer(hirda);
    }
  }

  hirda->ErrorCode |= HAL_IRDA_ERROR_DMA;
#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
  /* Call registered user error callback */
  hirda->ErrorCallback(hirda);
#else
  /* Call legacy weak user error callback */
  HAL_IRDA_ErrorCallback(hirda);
#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
}

IRDA_DMAReceiveCplt()

static void IRDA_DMAReceiveCplt ( DMA_HandleTypeDef *  hdma )

static

DMA IRDA receive process complete callback.

Parameters

hdma	Pointer to a DMA_HandleTypeDef structure that contains the configuration information for the specified DMA module.

Return values

None

Definition at line 2567 of file stm32l4xx_hal_irda.c.

{
  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)(hdma->Parent);

  /* DMA Normal mode */
  if (HAL_IS_BIT_CLR(hdma->Instance->CCR, DMA_CCR_CIRC))
  {
    hirda->RxXferCount = 0U;

    /* Disable PE and ERR (Frame error, noise error, overrun error) interrupts */
    CLEAR_BIT(hirda->Instance->CR1, USART_CR1_PEIE);
    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_EIE);

    /* Disable the DMA transfer for the receiver request by resetting the DMAR bit
       in the IRDA CR3 register */
    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAR);

    /* At end of Rx process, restore hirda->RxState to Ready */
    hirda->RxState = HAL_IRDA_STATE_READY;
  }

#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
  /* Call registered Rx complete callback */
  hirda->RxCpltCallback(hirda);
#else
  /* Call legacy weak Rx complete callback */
  HAL_IRDA_RxCpltCallback(hirda);
#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
}

IRDA_DMAReceiveHalfCplt()

static void IRDA_DMAReceiveHalfCplt ( DMA_HandleTypeDef *  hdma )

static

DMA IRDA receive process half complete callback.

Parameters

hdma	Pointer to a DMA_HandleTypeDef structure that contains the configuration information for the specified DMA module.

Return values

None

Definition at line 2603 of file stm32l4xx_hal_irda.c.

{
  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)(hdma->Parent);

#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
  /*Call registered Rx Half complete callback*/
  hirda->RxHalfCpltCallback(hirda);
#else
  /* Call legacy weak Rx Half complete callback */
  HAL_IRDA_RxHalfCpltCallback(hirda);
#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
}

IRDA_DMARxAbortCallback()

static void IRDA_DMARxAbortCallback ( DMA_HandleTypeDef *  hdma )

static

DMA IRDA Rx communication abort callback, when initiated by user (To be called at end of DMA Rx Abort procedure following user abort request).

Note

When this callback is executed, User Abort complete call back is called only if no Abort still ongoing for Tx DMA Handle.

Parameters

hdma	DMA handle.

Return values

None

Definition at line 2733 of file stm32l4xx_hal_irda.c.

{
  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)(hdma->Parent);

  hirda->hdmarx->XferAbortCallback = NULL;

  /* Check if an Abort process is still ongoing */
  if (hirda->hdmatx != NULL)
  {
    if (hirda->hdmatx->XferAbortCallback != NULL)
    {
      return;
    }
  }

  /* No Abort process still ongoing : All DMA channels are aborted, call user Abort Complete callback */
  hirda->TxXferCount = 0U;
  hirda->RxXferCount = 0U;

  /* Reset errorCode */
  hirda->ErrorCode = HAL_IRDA_ERROR_NONE;

  /* Clear the Error flags in the ICR register */
  __HAL_IRDA_CLEAR_FLAG(hirda, IRDA_CLEAR_OREF | IRDA_CLEAR_NEF | IRDA_CLEAR_PEF | IRDA_CLEAR_FEF);

  /* Restore hirda->gState and hirda->RxState to Ready */
  hirda->gState  = HAL_IRDA_STATE_READY;
  hirda->RxState = HAL_IRDA_STATE_READY;

  /* Call user Abort complete callback */
#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
  /* Call registered Abort complete callback */
  hirda->AbortCpltCallback(hirda);
#else
  /* Call legacy weak Abort complete callback */
  HAL_IRDA_AbortCpltCallback(hirda);
#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
}

IRDA_DMARxOnlyAbortCallback()

static void IRDA_DMARxOnlyAbortCallback ( DMA_HandleTypeDef *  hdma )

static

DMA IRDA Rx communication abort callback, when initiated by user by a call to HAL_IRDA_AbortReceive_IT API (Abort only Rx transfer) (This callback is executed at end of DMA Rx Abort procedure following user abort request, and leads to user Rx Abort Complete callback execution).

Parameters

hdma	DMA handle.

Return values

None

Definition at line 2808 of file stm32l4xx_hal_irda.c.

{
  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)((DMA_HandleTypeDef *)hdma)->Parent;

  hirda->RxXferCount = 0U;

  /* Clear the Error flags in the ICR register */
  __HAL_IRDA_CLEAR_FLAG(hirda, IRDA_CLEAR_OREF | IRDA_CLEAR_NEF | IRDA_CLEAR_PEF | IRDA_CLEAR_FEF);

  /* Restore hirda->RxState to Ready */
  hirda->RxState = HAL_IRDA_STATE_READY;

  /* Call user Abort complete callback */
#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
  /* Call registered Abort Receive Complete Callback */
  hirda->AbortReceiveCpltCallback(hirda);
#else
  /* Call legacy weak Abort Receive Complete Callback */
  HAL_IRDA_AbortReceiveCpltCallback(hirda);
#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
}

IRDA_DMATransmitCplt()

static void IRDA_DMATransmitCplt ( DMA_HandleTypeDef *  hdma )

static

DMA IRDA transmit process complete callback.

Parameters

hdma	Pointer to a DMA_HandleTypeDef structure that contains the configuration information for the specified DMA module.

Return values

None

Definition at line 2512 of file stm32l4xx_hal_irda.c.

{
  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)(hdma->Parent);

  /* DMA Normal mode */
  if (HAL_IS_BIT_CLR(hdma->Instance->CCR, DMA_CCR_CIRC))
  {
    hirda->TxXferCount = 0U;

    /* Disable the DMA transfer for transmit request by resetting the DMAT bit
       in the IRDA CR3 register */
    CLEAR_BIT(hirda->Instance->CR3, USART_CR3_DMAT);

    /* Enable the IRDA Transmit Complete Interrupt */
    SET_BIT(hirda->Instance->CR1, USART_CR1_TCIE);
  }
  /* DMA Circular mode */
  else
  {
#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
    /* Call registered Tx complete callback */
    hirda->TxCpltCallback(hirda);
#else
    /* Call legacy weak Tx complete callback */
    HAL_IRDA_TxCpltCallback(hirda);
#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
  }

}

IRDA_DMATransmitHalfCplt()

static void IRDA_DMATransmitHalfCplt ( DMA_HandleTypeDef *  hdma )

static

DMA IRDA transmit process half complete callback.

Parameters

hdma	Pointer to a DMA_HandleTypeDef structure that contains the configuration information for the specified DMA module.

Return values

None

Definition at line 2548 of file stm32l4xx_hal_irda.c.

{
  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)(hdma->Parent);

#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
  /* Call registered Tx Half complete callback */
  hirda->TxHalfCpltCallback(hirda);
#else
  /* Call legacy weak Tx complete callback */
  HAL_IRDA_TxHalfCpltCallback(hirda);
#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
}

IRDA_DMATxAbortCallback()

static void IRDA_DMATxAbortCallback ( DMA_HandleTypeDef *  hdma )

static

DMA IRDA Tx communication abort callback, when initiated by user (To be called at end of DMA Tx Abort procedure following user abort request).

Note

When this callback is executed, User Abort complete call back is called only if no Abort still ongoing for Rx DMA Handle.

Parameters

hdma	DMA handle.

Return values

None

Definition at line 2685 of file stm32l4xx_hal_irda.c.

{
  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)(hdma->Parent);

  hirda->hdmatx->XferAbortCallback = NULL;

  /* Check if an Abort process is still ongoing */
  if (hirda->hdmarx != NULL)
  {
    if (hirda->hdmarx->XferAbortCallback != NULL)
    {
      return;
    }
  }

  /* No Abort process still ongoing : All DMA channels are aborted, call user Abort Complete callback */
  hirda->TxXferCount = 0U;
  hirda->RxXferCount = 0U;

  /* Reset errorCode */
  hirda->ErrorCode = HAL_IRDA_ERROR_NONE;

  /* Clear the Error flags in the ICR register */
  __HAL_IRDA_CLEAR_FLAG(hirda, IRDA_CLEAR_OREF | IRDA_CLEAR_NEF | IRDA_CLEAR_PEF | IRDA_CLEAR_FEF);

  /* Restore hirda->gState and hirda->RxState to Ready */
  hirda->gState  = HAL_IRDA_STATE_READY;
  hirda->RxState = HAL_IRDA_STATE_READY;

  /* Call user Abort complete callback */
#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
  /* Call registered Abort complete callback */
  hirda->AbortCpltCallback(hirda);
#else
  /* Call legacy weak Abort complete callback */
  HAL_IRDA_AbortCpltCallback(hirda);
#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
}

IRDA_DMATxOnlyAbortCallback()

static void IRDA_DMATxOnlyAbortCallback ( DMA_HandleTypeDef *  hdma )

static

DMA IRDA Tx communication abort callback, when initiated by user by a call to HAL_IRDA_AbortTransmit_IT API (Abort only Tx transfer) (This callback is executed at end of DMA Tx Abort procedure following user abort request, and leads to user Tx Abort Complete callback execution).

Parameters

hdma	DMA handle.

Return values

None

Definition at line 2781 of file stm32l4xx_hal_irda.c.

{
  IRDA_HandleTypeDef *hirda = (IRDA_HandleTypeDef *)(hdma->Parent);

  hirda->TxXferCount = 0U;

  /* Restore hirda->gState to Ready */
  hirda->gState = HAL_IRDA_STATE_READY;

  /* Call user Abort complete callback */
#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
  /* Call registered Abort Transmit Complete Callback */
  hirda->AbortTransmitCpltCallback(hirda);
#else
  /* Call legacy weak Abort Transmit Complete Callback */
  HAL_IRDA_AbortTransmitCpltCallback(hirda);
#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
}

IRDA_EndRxTransfer()

static void IRDA_EndRxTransfer ( IRDA_HandleTypeDef *  hirda )

static

End ongoing Rx transfer on UART peripheral (following error detection or Reception completion).

Parameters

hirda

Pointer to a IRDA_HandleTypeDef structure that contains the configuration information for the specified IRDA module.

Return values

None

Definition at line 2491 of file stm32l4xx_hal_irda.c.

{
  /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
#if defined(USART_CR1_FIFOEN)
  CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_RXNEIE_RXFNEIE | USART_CR1_PEIE));
#else
  CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));
#endif /* USART_CR1_FIFOEN */
  CLEAR_BIT(hirda->Instance->CR3, USART_CR3_EIE);

  /* At end of Rx process, restore hirda->RxState to Ready */
  hirda->RxState = HAL_IRDA_STATE_READY;
}

IRDA_EndTransmit_IT()

static void IRDA_EndTransmit_IT ( IRDA_HandleTypeDef *  hirda )

static

Wrap up transmission in non-blocking mode.

Parameters

hirda

Pointer to a IRDA_HandleTypeDef structure that contains the configuration information for the specified IRDA module.

Return values

None

Definition at line 2881 of file stm32l4xx_hal_irda.c.

{
  /* Disable the IRDA Transmit Complete Interrupt */
  CLEAR_BIT(hirda->Instance->CR1, USART_CR1_TCIE);

  /* Tx process is ended, restore hirda->gState to Ready */
  hirda->gState = HAL_IRDA_STATE_READY;

#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
  /* Call registered Tx complete callback */
  hirda->TxCpltCallback(hirda);
#else
  /* Call legacy weak Tx complete callback */
  HAL_IRDA_TxCpltCallback(hirda);
#endif /* USE_HAL_IRDA_REGISTER_CALLBACK */
}

IRDA_EndTxTransfer()

static void IRDA_EndTxTransfer ( IRDA_HandleTypeDef *  hirda )

static

End ongoing Tx transfer on IRDA peripheral (following error detection or Transmit completion).

Parameters

hirda

Pointer to a IRDA_HandleTypeDef structure that contains the configuration information for the specified IRDA module.

Return values

None

Definition at line 2471 of file stm32l4xx_hal_irda.c.

{
  /* Disable TXEIE and TCIE interrupts */
#if defined(USART_CR1_FIFOEN)
  CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_TXEIE_TXFNFIE | USART_CR1_TCIE));
#else
  CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_TXEIE | USART_CR1_TCIE));
#endif /* USART_CR1_FIFOEN */

  /* At end of Tx process, restore hirda->gState to Ready */
  hirda->gState = HAL_IRDA_STATE_READY;
}

IRDA_InitCallbacksToDefault()

void IRDA_InitCallbacksToDefault

(

IRDA_HandleTypeDef *

hirda

)

Initialize the callbacks to their default values.

Parameters

hirda

IRDA handle.

Return values

none

Definition at line 2255 of file stm32l4xx_hal_irda.c.

{
  /* Init the IRDA Callback settings */
  hirda->TxHalfCpltCallback        = HAL_IRDA_TxHalfCpltCallback;        /* Legacy weak TxHalfCpltCallback        */
  hirda->TxCpltCallback            = HAL_IRDA_TxCpltCallback;            /* Legacy weak TxCpltCallback            */
  hirda->RxHalfCpltCallback        = HAL_IRDA_RxHalfCpltCallback;        /* Legacy weak RxHalfCpltCallback        */
  hirda->RxCpltCallback            = HAL_IRDA_RxCpltCallback;            /* Legacy weak RxCpltCallback            */
  hirda->ErrorCallback             = HAL_IRDA_ErrorCallback;             /* Legacy weak ErrorCallback             */
  hirda->AbortCpltCallback         = HAL_IRDA_AbortCpltCallback;         /* Legacy weak AbortCpltCallback         */
  hirda->AbortTransmitCpltCallback = HAL_IRDA_AbortTransmitCpltCallback; /* Legacy weak AbortTransmitCpltCallback */
  hirda->AbortReceiveCpltCallback  = HAL_IRDA_AbortReceiveCpltCallback;  /* Legacy weak AbortReceiveCpltCallback  */

}

IRDA_Receive_IT()

static void IRDA_Receive_IT ( IRDA_HandleTypeDef *  hirda )

static

Receive an amount of data in interrupt mode.

Note

Function is called under interruption only, once interruptions have been enabled by HAL_IRDA_Receive_IT()

Parameters

hirda

Pointer to a IRDA_HandleTypeDef structure that contains the configuration information for the specified IRDA module.

Return values

None

Definition at line 2906 of file stm32l4xx_hal_irda.c.

{
  uint16_t *tmp;
  uint16_t  uhMask = hirda->Mask;
  uint16_t  uhdata;

  /* Check that a Rx process is ongoing */
  if (hirda->RxState == HAL_IRDA_STATE_BUSY_RX)
  {
    uhdata = (uint16_t) READ_REG(hirda->Instance->RDR);
    if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE))
    {
      tmp = (uint16_t *) hirda->pRxBuffPtr; /* Derogation R.11.3 */
      *tmp = (uint16_t)(uhdata & uhMask);
      hirda->pRxBuffPtr  += 2U;
    }
    else
    {
      *hirda->pRxBuffPtr = (uint8_t)(uhdata & (uint8_t)uhMask);
      hirda->pRxBuffPtr++;
    }

    hirda->RxXferCount--;
    if (hirda->RxXferCount == 0U)
    {
      /* Disable the IRDA Parity Error Interrupt and RXNE interrupt */
#if defined(USART_CR1_FIFOEN)
      CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_RXNEIE_RXFNEIE | USART_CR1_PEIE));
#else
      CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));
#endif /* USART_CR1_FIFOEN */

      /* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */
      CLEAR_BIT(hirda->Instance->CR3, USART_CR3_EIE);

      /* Rx process is completed, restore hirda->RxState to Ready */
      hirda->RxState = HAL_IRDA_STATE_READY;

#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
      /* Call registered Rx complete callback */
      hirda->RxCpltCallback(hirda);
#else
      /* Call legacy weak Rx complete callback */
      HAL_IRDA_RxCpltCallback(hirda);
#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
    }
  }
  else
  {
    /* Clear RXNE interrupt flag */
    __HAL_IRDA_SEND_REQ(hirda, IRDA_RXDATA_FLUSH_REQUEST);
  }
}

IRDA_SetConfig()

static HAL_StatusTypeDef IRDA_SetConfig ( IRDA_HandleTypeDef *  hirda )

static

Configure the IRDA peripheral.

Parameters

hirda

Pointer to a IRDA_HandleTypeDef structure that contains the configuration information for the specified IRDA module.

Return values

HAL

status

Definition at line 2276 of file stm32l4xx_hal_irda.c.

{
  uint32_t tmpreg;
  IRDA_ClockSourceTypeDef clocksource;
  HAL_StatusTypeDef ret = HAL_OK;
#if defined(USART_PRESC_PRESCALER)
  const uint16_t IRDAPrescTable[12] = {1U, 2U, 4U, 6U, 8U, 10U, 12U, 16U, 32U, 64U, 128U, 256U};
#endif /* USART_PRESC_PRESCALER */

  /* Check the communication parameters */
  assert_param(IS_IRDA_BAUDRATE(hirda->Init.BaudRate));
  assert_param(IS_IRDA_WORD_LENGTH(hirda->Init.WordLength));
  assert_param(IS_IRDA_PARITY(hirda->Init.Parity));
  assert_param(IS_IRDA_TX_RX_MODE(hirda->Init.Mode));
  assert_param(IS_IRDA_PRESCALER(hirda->Init.Prescaler));
  assert_param(IS_IRDA_POWERMODE(hirda->Init.PowerMode));
#if defined(USART_PRESC_PRESCALER)
  assert_param(IS_IRDA_CLOCKPRESCALER(hirda->Init.ClockPrescaler));
#endif /* USART_PRESC_PRESCALER */

  /*-------------------------- USART CR1 Configuration -----------------------*/
  /* Configure the IRDA Word Length, Parity and transfer Mode:
     Set the M bits according to hirda->Init.WordLength value
     Set PCE and PS bits according to hirda->Init.Parity value
     Set TE and RE bits according to hirda->Init.Mode value */
  tmpreg = (uint32_t)hirda->Init.WordLength | hirda->Init.Parity | hirda->Init.Mode ;

  MODIFY_REG(hirda->Instance->CR1, IRDA_CR1_FIELDS, tmpreg);

  /*-------------------------- USART CR3 Configuration -----------------------*/
  MODIFY_REG(hirda->Instance->CR3, USART_CR3_IRLP, hirda->Init.PowerMode);

#if defined(USART_PRESC_PRESCALER)
  /*--------------------- USART clock PRESC Configuration ----------------*/
  /* Configure
  * - IRDA Clock Prescaler: set PRESCALER according to hirda->Init.ClockPrescaler value */
  MODIFY_REG(hirda->Instance->PRESC, USART_PRESC_PRESCALER, hirda->Init.ClockPrescaler);
#endif /* USART_PRESC_PRESCALER */

  /*-------------------------- USART GTPR Configuration ----------------------*/
  MODIFY_REG(hirda->Instance->GTPR, (uint16_t)USART_GTPR_PSC, (uint16_t)hirda->Init.Prescaler);

  /*-------------------------- USART BRR Configuration -----------------------*/
  IRDA_GETCLOCKSOURCE(hirda, clocksource);
  tmpreg =   0U;
  switch (clocksource)
  {
    case IRDA_CLOCKSOURCE_PCLK1:
#if defined(USART_PRESC_PRESCALER)
      tmpreg = (uint16_t)(IRDA_DIV_SAMPLING16(HAL_RCC_GetPCLK1Freq(), hirda->Init.BaudRate, hirda->Init.ClockPrescaler));
#else
      tmpreg = (uint16_t)(IRDA_DIV_SAMPLING16(HAL_RCC_GetPCLK1Freq(), hirda->Init.BaudRate));
#endif /* USART_PRESC_PRESCALER */
      break;
    case IRDA_CLOCKSOURCE_PCLK2:
#if defined(USART_PRESC_PRESCALER)
      tmpreg = (uint16_t)(IRDA_DIV_SAMPLING16(HAL_RCC_GetPCLK2Freq(), hirda->Init.BaudRate, hirda->Init.ClockPrescaler));
#else
      tmpreg = (uint16_t)(IRDA_DIV_SAMPLING16(HAL_RCC_GetPCLK2Freq(), hirda->Init.BaudRate));
#endif /* USART_PRESC_PRESCALER */
      break;
    case IRDA_CLOCKSOURCE_HSI:
#if defined(USART_PRESC_PRESCALER)
      tmpreg = (uint16_t)(IRDA_DIV_SAMPLING16(HSI_VALUE, hirda->Init.BaudRate, hirda->Init.ClockPrescaler));
#else
      tmpreg = (uint16_t)(IRDA_DIV_SAMPLING16(HSI_VALUE, hirda->Init.BaudRate));
#endif /* USART_PRESC_PRESCALER */
      break;
    case IRDA_CLOCKSOURCE_SYSCLK:
#if defined(USART_PRESC_PRESCALER)
      tmpreg = (uint16_t)(IRDA_DIV_SAMPLING16(HAL_RCC_GetSysClockFreq(), hirda->Init.BaudRate, hirda->Init.ClockPrescaler));
#else
      tmpreg = (uint16_t)(IRDA_DIV_SAMPLING16(HAL_RCC_GetSysClockFreq(), hirda->Init.BaudRate));
#endif /* USART_PRESC_PRESCALER */
      break;
    case IRDA_CLOCKSOURCE_LSE:
#if defined(USART_PRESC_PRESCALER)
      tmpreg = (uint16_t)(IRDA_DIV_SAMPLING16((uint32_t)LSE_VALUE, hirda->Init.BaudRate, hirda->Init.ClockPrescaler));
#else
      tmpreg = (uint16_t)(IRDA_DIV_SAMPLING16((uint32_t)LSE_VALUE, hirda->Init.BaudRate));
#endif /* USART_PRESC_PRESCALER */
      break;
    default:
      ret = HAL_ERROR;
      break;
  }

  /* USARTDIV must be greater than or equal to 0d16 */
  if ((tmpreg >= USART_BRR_MIN) && (tmpreg <= USART_BRR_MAX))
  {
    hirda->Instance->BRR = tmpreg;
  }
  else
  {
    ret = HAL_ERROR;
  }

  return ret;
}

IRDA_Transmit_IT()

static void IRDA_Transmit_IT ( IRDA_HandleTypeDef *  hirda )

static

Send an amount of data in interrupt mode.

Note

Function is called under interruption only, once interruptions have been enabled by HAL_IRDA_Transmit_IT().

Parameters

hirda

Pointer to a IRDA_HandleTypeDef structure that contains the configuration information for the specified IRDA module.

Return values

None

Definition at line 2838 of file stm32l4xx_hal_irda.c.

{
  uint16_t *tmp;

  /* Check that a Tx process is ongoing */
  if (hirda->gState == HAL_IRDA_STATE_BUSY_TX)
  {
    if (hirda->TxXferCount == 0U)
    {
      /* Disable the IRDA Transmit Data Register Empty Interrupt */
#if defined(USART_CR1_FIFOEN)
      CLEAR_BIT(hirda->Instance->CR1, USART_CR1_TXEIE_TXFNFIE);
#else
      CLEAR_BIT(hirda->Instance->CR1, USART_CR1_TXEIE);
#endif /* USART_CR1_FIFOEN */

      /* Enable the IRDA Transmit Complete Interrupt */
      SET_BIT(hirda->Instance->CR1, USART_CR1_TCIE);
    }
    else
    {
      if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE))
      {
        tmp = (uint16_t *) hirda->pTxBuffPtr; /* Derogation R.11.3 */
        hirda->Instance->TDR = (uint16_t)(*tmp & 0x01FFU);
        hirda->pTxBuffPtr += 2U;
      }
      else
      {
        hirda->Instance->TDR = (uint8_t)(*hirda->pTxBuffPtr & 0xFFU);
        hirda->pTxBuffPtr++;
      }
      hirda->TxXferCount--;
    }
  }
}

IRDA_WaitOnFlagUntilTimeout()

static HAL_StatusTypeDef IRDA_WaitOnFlagUntilTimeout ( IRDA_HandleTypeDef *  hirda, uint32_t  Flag, FlagStatus  Status, uint32_t  Tickstart, uint32_t  Timeout  )

static

Handle IRDA Communication Timeout.

Parameters

hirda	Pointer to a IRDA_HandleTypeDef structure that contains the configuration information for the specified IRDA module.
Flag	Specifies the IRDA flag to check.
Status	Flag status (SET or RESET)
Tickstart	Tick start value
Timeout	Timeout duration

Return values

HAL

status

Definition at line 2433 of file stm32l4xx_hal_irda.c.

{
  /* Wait until flag is set */
  while ((__HAL_IRDA_GET_FLAG(hirda, Flag) ? SET : RESET) == Status)
  {
    /* Check for the Timeout */
    if (Timeout != HAL_MAX_DELAY)
    {
      if (((HAL_GetTick() - Tickstart) > Timeout) || (Timeout == 0U))
      {
        /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
#if defined(USART_CR1_FIFOEN)
        CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_RXNEIE_RXFNEIE | USART_CR1_PEIE | USART_CR1_TXEIE_TXFNFIE));
#else
        CLEAR_BIT(hirda->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE));
#endif /* USART_CR1_FIFOEN */
        CLEAR_BIT(hirda->Instance->CR3, USART_CR3_EIE);

        hirda->gState  = HAL_IRDA_STATE_READY;
        hirda->RxState = HAL_IRDA_STATE_READY;

        /* Process Unlocked */
        __HAL_UNLOCK(hirda);
        return HAL_TIMEOUT;
      }
    }
  }
  return HAL_OK;
}