Initialization and de-initialization functions

Initialization and Configuration functions. More...

Functions
HAL_StatusTypeDef	HAL_IRDA_Init (IRDA_HandleTypeDef *hirda)
	Initialize the IRDA mode according to the specified parameters in the IRDA_InitTypeDef and initialize the associated handle. More...
HAL_StatusTypeDef	HAL_IRDA_DeInit (IRDA_HandleTypeDef *hirda)
	DeInitialize the IRDA peripheral. More...
void	HAL_IRDA_MspInit (IRDA_HandleTypeDef *hirda)
	Initialize the IRDA MSP. More...
void	HAL_IRDA_MspDeInit (IRDA_HandleTypeDef *hirda)
	DeInitialize the IRDA MSP. More...
HAL_StatusTypeDef	HAL_IRDA_RegisterCallback (IRDA_HandleTypeDef *hirda, HAL_IRDA_CallbackIDTypeDef CallbackID, pIRDA_CallbackTypeDef pCallback)
	Register a User IRDA Callback To be used instead of the weak predefined callback. More...
HAL_StatusTypeDef	HAL_IRDA_UnRegisterCallback (IRDA_HandleTypeDef *hirda, HAL_IRDA_CallbackIDTypeDef CallbackID)
	Unregister an IRDA callback IRDA callback is redirected to the weak predefined callback. More...

Detailed Description

Initialization and Configuration functions.

  ==============================================================================
              ##### Initialization and Configuration functions #####
  ==============================================================================
  [..]
  This subsection provides a set of functions allowing to initialize the USARTx
  in asynchronous IRDA mode.
  (+) For the asynchronous mode only these parameters can be configured:
      (++) Baud Rate
      (++) Word Length
      (++) Parity: If the parity is enabled, then the MSB bit of the data written
           in the data register is transmitted but is changed by the parity bit.
      (++) Power mode
      (++) Prescaler setting
      (++) Receiver/transmitter modes

  [..]
  The HAL_IRDA_Init() API follows the USART asynchronous configuration procedures
  (details for the procedures are available in reference manual).

Depending on the frame length defined by the M1 and M0 bits (7-bit, 8-bit or 9-bit), the possible IRDA frame formats are listed in the following table.

Table 1. IRDA frame format. +--------------------------------------------------------------------—+ | M1 bit | M0 bit | PCE bit | IRDA frame | |------—|------—|--------—|------------------------------------—| | 0 | 0 | 0 | | SB | 8 bit data | STB | | |------—|------—|--------—|------------------------------------—| | 0 | 0 | 1 | | SB | 7 bit data | PB | STB | | |------—|------—|--------—|------------------------------------—| | 0 | 1 | 0 | | SB | 9 bit data | STB | | |------—|------—|--------—|------------------------------------—| | 0 | 1 | 1 | | SB | 8 bit data | PB | STB | | |------—|------—|--------—|------------------------------------—| | 1 | 0 | 0 | | SB | 7 bit data | STB | | |------—|------—|--------—|------------------------------------—| | 1 | 0 | 1 | | SB | 6 bit data | PB | STB | | +--------------------------------------------------------------------—+

Function Documentation

HAL_IRDA_DeInit()

HAL_StatusTypeDef HAL_IRDA_DeInit

(

IRDA_HandleTypeDef *

hirda

)

DeInitialize 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 401 of file stm32l4xx_hal_irda.c.

{
  /* Check the IRDA handle allocation */
  if (hirda == NULL)
  {
    return HAL_ERROR;
  }

  /* Check the USART/UART associated to the IRDA handle */
  assert_param(IS_IRDA_INSTANCE(hirda->Instance));

  hirda->gState = HAL_IRDA_STATE_BUSY;

  /* DeInit the low level hardware */
#if USE_HAL_IRDA_REGISTER_CALLBACKS == 1
  if (hirda->MspDeInitCallback == NULL)
  {
    hirda->MspDeInitCallback = HAL_IRDA_MspDeInit;
  }
  /* DeInit the low level hardware */
  hirda->MspDeInitCallback(hirda);
#else
  HAL_IRDA_MspDeInit(hirda);
#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
  /* Disable the Peripheral */
  __HAL_IRDA_DISABLE(hirda);

  hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
  hirda->gState    = HAL_IRDA_STATE_RESET;
  hirda->RxState   = HAL_IRDA_STATE_RESET;

  /* Process Unlock */
  __HAL_UNLOCK(hirda);

  return HAL_OK;
}

HAL_IRDA_Init()

HAL_StatusTypeDef HAL_IRDA_Init

(

IRDA_HandleTypeDef *

hirda

)

Initialize the IRDA mode according to the specified parameters in the IRDA_InitTypeDef and initialize the associated handle.

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 336 of file stm32l4xx_hal_irda.c.

{
  /* Check the IRDA handle allocation */
  if (hirda == NULL)
  {
    return HAL_ERROR;
  }

  /* Check the USART/UART associated to the IRDA handle */
  assert_param(IS_IRDA_INSTANCE(hirda->Instance));

  if (hirda->gState == HAL_IRDA_STATE_RESET)
  {
    /* Allocate lock resource and initialize it */
    hirda->Lock = HAL_UNLOCKED;

#if USE_HAL_IRDA_REGISTER_CALLBACKS == 1
    IRDA_InitCallbacksToDefault(hirda);

    if (hirda->MspInitCallback == NULL)
    {
      hirda->MspInitCallback = HAL_IRDA_MspInit;
    }

    /* Init the low level hardware */
    hirda->MspInitCallback(hirda);
#else
    /* Init the low level hardware : GPIO, CLOCK */
    HAL_IRDA_MspInit(hirda);
#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
  }

  hirda->gState = HAL_IRDA_STATE_BUSY;

  /* Disable the Peripheral to update the configuration registers */
  __HAL_IRDA_DISABLE(hirda);

  /* Set the IRDA Communication parameters */
  if (IRDA_SetConfig(hirda) == HAL_ERROR)
  {
    return HAL_ERROR;
  }

  /* In IRDA mode, the following bits must be kept cleared:
  - LINEN, STOP and CLKEN bits in the USART_CR2 register,
  - SCEN and HDSEL bits in the USART_CR3 register.*/
  CLEAR_BIT(hirda->Instance->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN | USART_CR2_STOP));
  CLEAR_BIT(hirda->Instance->CR3, (USART_CR3_SCEN | USART_CR3_HDSEL));

  /* set the UART/USART in IRDA mode */
  hirda->Instance->CR3 |= USART_CR3_IREN;

  /* Enable the Peripheral */
  __HAL_IRDA_ENABLE(hirda);

  /* TEACK and/or REACK to check before moving hirda->gState and hirda->RxState to Ready */
  return (IRDA_CheckIdleState(hirda));
}

HAL_IRDA_MspDeInit()

__weak void HAL_IRDA_MspDeInit

(

IRDA_HandleTypeDef *

hirda

)

DeInitialize the IRDA MSP.

Parameters

hirda

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

Return values

None

Definition at line 460 of file stm32l4xx_hal_irda.c.

{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(hirda);

  /* NOTE: This function should not be modified, when the callback is needed,
           the HAL_IRDA_MspDeInit can be implemented in the user file
   */
}

HAL_IRDA_MspInit()

__weak void HAL_IRDA_MspInit

(

IRDA_HandleTypeDef *

hirda

)

Initialize the IRDA MSP.

Parameters

hirda

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

Return values

None

Definition at line 444 of file stm32l4xx_hal_irda.c.

{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(hirda);

  /* NOTE: This function should not be modified, when the callback is needed,
           the HAL_IRDA_MspInit can be implemented in the user file
   */
}

HAL_IRDA_RegisterCallback()

HAL_StatusTypeDef HAL_IRDA_RegisterCallback	(	IRDA_HandleTypeDef *	hirda,
		HAL_IRDA_CallbackIDTypeDef	CallbackID,
		pIRDA_CallbackTypeDef	pCallback
	)

Register a User IRDA Callback To be used instead of the weak predefined callback.

Parameters

hirda	irda handle
CallbackID	ID of the callback to be registered This parameter can be one of the following values: HAL_IRDA_TX_HALFCOMPLETE_CB_ID Tx Half Complete Callback ID HAL_IRDA_TX_COMPLETE_CB_ID Tx Complete Callback ID HAL_IRDA_RX_HALFCOMPLETE_CB_ID Rx Half Complete Callback ID HAL_IRDA_RX_COMPLETE_CB_ID Rx Complete Callback ID HAL_IRDA_ERROR_CB_ID Error Callback ID HAL_IRDA_ABORT_COMPLETE_CB_ID Abort Complete Callback ID HAL_IRDA_ABORT_TRANSMIT_COMPLETE_CB_ID Abort Transmit Complete Callback ID HAL_IRDA_ABORT_RECEIVE_COMPLETE_CB_ID Abort Receive Complete Callback ID HAL_IRDA_MSPINIT_CB_ID MspInit Callback ID HAL_IRDA_MSPDEINIT_CB_ID MspDeInit Callback ID
pCallback	pointer to the Callback function

Return values

HAL

status

Definition at line 490 of file stm32l4xx_hal_irda.c.

{
  HAL_StatusTypeDef status = HAL_OK;

  if (pCallback == NULL)
  {
    /* Update the error code */
    hirda->ErrorCode |= HAL_IRDA_ERROR_INVALID_CALLBACK;

    return HAL_ERROR;
  }
  /* Process locked */
  __HAL_LOCK(hirda);

  if (hirda->gState == HAL_IRDA_STATE_READY)
  {
    switch (CallbackID)
    {
      case HAL_IRDA_TX_HALFCOMPLETE_CB_ID :
        hirda->TxHalfCpltCallback = pCallback;
        break;

      case HAL_IRDA_TX_COMPLETE_CB_ID :
        hirda->TxCpltCallback = pCallback;
        break;

      case HAL_IRDA_RX_HALFCOMPLETE_CB_ID :
        hirda->RxHalfCpltCallback = pCallback;
        break;

      case HAL_IRDA_RX_COMPLETE_CB_ID :
        hirda->RxCpltCallback = pCallback;
        break;

      case HAL_IRDA_ERROR_CB_ID :
        hirda->ErrorCallback = pCallback;
        break;

      case HAL_IRDA_ABORT_COMPLETE_CB_ID :
        hirda->AbortCpltCallback = pCallback;
        break;

      case HAL_IRDA_ABORT_TRANSMIT_COMPLETE_CB_ID :
        hirda->AbortTransmitCpltCallback = pCallback;
        break;

      case HAL_IRDA_ABORT_RECEIVE_COMPLETE_CB_ID :
        hirda->AbortReceiveCpltCallback = pCallback;
        break;

      case HAL_IRDA_MSPINIT_CB_ID :
        hirda->MspInitCallback = pCallback;
        break;

      case HAL_IRDA_MSPDEINIT_CB_ID :
        hirda->MspDeInitCallback = pCallback;
        break;

      default :
        /* Update the error code */
        hirda->ErrorCode |= HAL_IRDA_ERROR_INVALID_CALLBACK;

        /* Return error status */
        status =  HAL_ERROR;
        break;
    }
  }
  else if (hirda->gState == HAL_IRDA_STATE_RESET)
  {
    switch (CallbackID)
    {
      case HAL_IRDA_MSPINIT_CB_ID :
        hirda->MspInitCallback = pCallback;
        break;

      case HAL_IRDA_MSPDEINIT_CB_ID :
        hirda->MspDeInitCallback = pCallback;
        break;

      default :
        /* Update the error code */
        hirda->ErrorCode |= HAL_IRDA_ERROR_INVALID_CALLBACK;

        /* Return error status */
        status =  HAL_ERROR;
        break;
    }
  }
  else
  {
    /* Update the error code */
    hirda->ErrorCode |= HAL_IRDA_ERROR_INVALID_CALLBACK;

    /* Return error status */
    status =  HAL_ERROR;
  }

  /* Release Lock */
  __HAL_UNLOCK(hirda);

  return status;
}

HAL_IRDA_UnRegisterCallback()

HAL_StatusTypeDef HAL_IRDA_UnRegisterCallback	(	IRDA_HandleTypeDef *	hirda,
		HAL_IRDA_CallbackIDTypeDef	CallbackID
	)

Unregister an IRDA callback IRDA callback is redirected to the weak predefined callback.

Parameters

hirda

irda handle

CallbackID

ID of the callback to be unregistered This parameter can be one of the following values: HAL_IRDA_TX_HALFCOMPLETE_CB_ID Tx Half Complete Callback ID HAL_IRDA_TX_COMPLETE_CB_ID Tx Complete Callback ID HAL_IRDA_RX_HALFCOMPLETE_CB_ID Rx Half Complete Callback ID HAL_IRDA_RX_COMPLETE_CB_ID Rx Complete Callback ID HAL_IRDA_ERROR_CB_ID Error Callback ID HAL_IRDA_ABORT_COMPLETE_CB_ID Abort Complete Callback ID HAL_IRDA_ABORT_TRANSMIT_COMPLETE_CB_ID Abort Transmit Complete Callback ID HAL_IRDA_ABORT_RECEIVE_COMPLETE_CB_ID Abort Receive Complete Callback ID HAL_IRDA_MSPINIT_CB_ID MspInit Callback ID HAL_IRDA_MSPDEINIT_CB_ID MspDeInit Callback ID

Return values

HAL

status

Definition at line 612 of file stm32l4xx_hal_irda.c.

{
  HAL_StatusTypeDef status = HAL_OK;

  /* Process locked */
  __HAL_LOCK(hirda);

  if (HAL_IRDA_STATE_READY == hirda->gState)
  {
    switch (CallbackID)
    {
      case HAL_IRDA_TX_HALFCOMPLETE_CB_ID :
        hirda->TxHalfCpltCallback = HAL_IRDA_TxHalfCpltCallback;               /* Legacy weak  TxHalfCpltCallback       */
        break;

      case HAL_IRDA_TX_COMPLETE_CB_ID :
        hirda->TxCpltCallback = HAL_IRDA_TxCpltCallback;                       /* Legacy weak TxCpltCallback            */
        break;

      case HAL_IRDA_RX_HALFCOMPLETE_CB_ID :
        hirda->RxHalfCpltCallback = HAL_IRDA_RxHalfCpltCallback;               /* Legacy weak RxHalfCpltCallback        */
        break;

      case HAL_IRDA_RX_COMPLETE_CB_ID :
        hirda->RxCpltCallback = HAL_IRDA_RxCpltCallback;                       /* Legacy weak RxCpltCallback            */
        break;

      case HAL_IRDA_ERROR_CB_ID :
        hirda->ErrorCallback = HAL_IRDA_ErrorCallback;                         /* Legacy weak ErrorCallback             */
        break;

      case HAL_IRDA_ABORT_COMPLETE_CB_ID :
        hirda->AbortCpltCallback = HAL_IRDA_AbortCpltCallback;                 /* Legacy weak AbortCpltCallback         */
        break;

      case HAL_IRDA_ABORT_TRANSMIT_COMPLETE_CB_ID :
        hirda->AbortTransmitCpltCallback = HAL_IRDA_AbortTransmitCpltCallback; /* Legacy weak AbortTransmitCpltCallback */
        break;

      case HAL_IRDA_ABORT_RECEIVE_COMPLETE_CB_ID :
        hirda->AbortReceiveCpltCallback = HAL_IRDA_AbortReceiveCpltCallback;   /* Legacy weak AbortReceiveCpltCallback  */
        break;

      case HAL_IRDA_MSPINIT_CB_ID :
        hirda->MspInitCallback = HAL_IRDA_MspInit;                             /* Legacy weak MspInitCallback           */
        break;

      case HAL_IRDA_MSPDEINIT_CB_ID :
        hirda->MspDeInitCallback = HAL_IRDA_MspDeInit;                         /* Legacy weak MspDeInitCallback         */
        break;

      default :
        /* Update the error code */
        hirda->ErrorCode |= HAL_IRDA_ERROR_INVALID_CALLBACK;

        /* Return error status */
        status =  HAL_ERROR;
        break;
    }
  }
  else if (HAL_IRDA_STATE_RESET == hirda->gState)
  {
    switch (CallbackID)
    {
      case HAL_IRDA_MSPINIT_CB_ID :
        hirda->MspInitCallback = HAL_IRDA_MspInit;
        break;

      case HAL_IRDA_MSPDEINIT_CB_ID :
        hirda->MspDeInitCallback = HAL_IRDA_MspDeInit;
        break;

      default :
        /* Update the error code */
        hirda->ErrorCode |= HAL_IRDA_ERROR_INVALID_CALLBACK;

        /* Return error status */
        status =  HAL_ERROR;
        break;
    }
  }
  else
  {
    /* Update the error code */
    hirda->ErrorCode |= HAL_IRDA_ERROR_INVALID_CALLBACK;

    /* Return error status */
    status =  HAL_ERROR;
  }

  /* Release Lock */
  __HAL_UNLOCK(hirda);

  return status;
}