SWPMI Exported Functions

Modules
	Initialization/de-initialization methods
	Initialization and Configuration functions.
	IO operation methods
	SWPMI Transmit/Receive functions.
	SWPMI IRQ handler and callbacks
	SWPMI IRQ handler.
	Peripheral Control methods
	SWPMI control functions.

Functions
HAL_StatusTypeDef	HAL_SWPMI_Init (SWPMI_HandleTypeDef *hswpmi)
	Initialize the SWPMI peripheral according to the specified parameters in the SWPMI_InitTypeDef. More...
HAL_StatusTypeDef	HAL_SWPMI_DeInit (SWPMI_HandleTypeDef *hswpmi)
	De-initialize the SWPMI peripheral. More...
void	HAL_SWPMI_MspInit (SWPMI_HandleTypeDef *hswpmi)
	Initialize the SWPMI MSP. More...
void	HAL_SWPMI_MspDeInit (SWPMI_HandleTypeDef *hswpmi)
	DeInitialize the SWPMI MSP. More...
HAL_StatusTypeDef	HAL_SWPMI_RegisterCallback (SWPMI_HandleTypeDef *hswpmi, HAL_SWPMI_CallbackIDTypeDef CallbackID, pSWPMI_CallbackTypeDef pCallback)
	Register a user SWPMI callback to be used instead of the weak predefined callback. More...
HAL_StatusTypeDef	HAL_SWPMI_UnRegisterCallback (SWPMI_HandleTypeDef *hswpmi, HAL_SWPMI_CallbackIDTypeDef CallbackID)
	Unregister a user SWPMI callback. SWPMI callback is redirected to the weak predefined callback. More...
HAL_StatusTypeDef	HAL_SWPMI_Transmit (SWPMI_HandleTypeDef *hswpmi, uint32_t *pData, uint16_t Size, uint32_t Timeout)
	Transmit an amount of data in blocking mode. More...
HAL_StatusTypeDef	HAL_SWPMI_Receive (SWPMI_HandleTypeDef *hswpmi, uint32_t *pData, uint16_t Size, uint32_t Timeout)
	Receive an amount of data in blocking mode. More...
HAL_StatusTypeDef	HAL_SWPMI_Transmit_IT (SWPMI_HandleTypeDef *hswpmi, uint32_t *pData, uint16_t Size)
	Transmit an amount of data in non-blocking mode with interrupt. More...
HAL_StatusTypeDef	HAL_SWPMI_Receive_IT (SWPMI_HandleTypeDef *hswpmi, uint32_t *pData, uint16_t Size)
	Receive an amount of data in non-blocking mode with interrupt. More...
HAL_StatusTypeDef	HAL_SWPMI_Transmit_DMA (SWPMI_HandleTypeDef *hswpmi, uint32_t *pData, uint16_t Size)
	Transmit an amount of data in non-blocking mode with DMA interrupt. More...
HAL_StatusTypeDef	HAL_SWPMI_Receive_DMA (SWPMI_HandleTypeDef *hswpmi, uint32_t *pData, uint16_t Size)
	Receive an amount of data in non-blocking mode with DMA interrupt. More...
HAL_StatusTypeDef	HAL_SWPMI_DMAStop (SWPMI_HandleTypeDef *hswpmi)
	Stop all DMA transfers. More...
HAL_StatusTypeDef	HAL_SWPMI_EnableLoopback (SWPMI_HandleTypeDef *hswpmi)
	Enable the Loopback mode. More...
HAL_StatusTypeDef	HAL_SWPMI_DisableLoopback (SWPMI_HandleTypeDef *hswpmi)
	Disable the Loopback mode. More...
void	HAL_SWPMI_IRQHandler (SWPMI_HandleTypeDef *hswpmi)
	Handle SWPMI interrupt request. More...
void	HAL_SWPMI_TxCpltCallback (SWPMI_HandleTypeDef *hswpmi)
	Tx Transfer completed callback. More...
void	HAL_SWPMI_TxHalfCpltCallback (SWPMI_HandleTypeDef *hswpmi)
	Tx Half Transfer completed callback. More...
void	HAL_SWPMI_RxCpltCallback (SWPMI_HandleTypeDef *hswpmi)
	Rx Transfer completed callback. More...
void	HAL_SWPMI_RxHalfCpltCallback (SWPMI_HandleTypeDef *hswpmi)
	Rx Half Transfer completed callback. More...
void	HAL_SWPMI_ErrorCallback (SWPMI_HandleTypeDef *hswpmi)
	SWPMI error callback. More...
HAL_SWPMI_StateTypeDef	HAL_SWPMI_GetState (SWPMI_HandleTypeDef *hswpmi)
	Return the SWPMI handle state. More...
uint32_t	HAL_SWPMI_GetError (SWPMI_HandleTypeDef *hswpmi)
	Return the SWPMI error code. More...

Detailed Description

Function Documentation

HAL_SWPMI_DeInit()

HAL_StatusTypeDef HAL_SWPMI_DeInit

(

SWPMI_HandleTypeDef *

hswpmi

)

De-initialize the SWPMI peripheral.

Parameters

hswpmi

SWPMI handle

Return values

HAL

status

Definition at line 328 of file stm32l4xx_hal_swpmi.c.

{
  HAL_StatusTypeDef status = HAL_OK;

  /* Check the SWPMI handle allocation */
  if(hswpmi == NULL)
  {
    status = HAL_ERROR;
  }
  else
  {
    /* Check the parameters */
    assert_param(IS_SWPMI_INSTANCE(hswpmi->Instance));

    hswpmi->State = HAL_SWPMI_STATE_BUSY;

    /* Disable SWPMI interface */
    CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);

    /* Disable Loopback mode */
    CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_LPBK);


    /* DeInit the low level hardware: GPIO, CLOCK, NVIC and DMA */
#if (USE_HAL_SWPMI_REGISTER_CALLBACKS == 1)
    if(hswpmi->MspDeInitCallback == NULL)
    {
      hswpmi->MspDeInitCallback = HAL_SWPMI_MspDeInit;
    }
    hswpmi->MspDeInitCallback(hswpmi);
#else
    HAL_SWPMI_MspDeInit(hswpmi);
#endif

    hswpmi->ErrorCode = HAL_SWPMI_ERROR_NONE;
    hswpmi->State = HAL_SWPMI_STATE_RESET;

    /* Release Lock */
    __HAL_UNLOCK(hswpmi);
  }

  return status;
}

HAL_SWPMI_DisableLoopback()

HAL_StatusTypeDef HAL_SWPMI_DisableLoopback

(

SWPMI_HandleTypeDef *

hswpmi

)

Disable the Loopback mode.

Parameters

hswpmi

SWPMI handle

Note

Loopback mode is to be used only for test purposes

Return values

HAL_OK

/ HAL_BUSY

Definition at line 1237 of file stm32l4xx_hal_swpmi.c.

{
  HAL_StatusTypeDef  status = HAL_OK;

  /* Process Locked */
  __HAL_LOCK(hswpmi);

  /* Make sure the SWPMI interface is not enabled to reset the loopback mode */
  CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);

  /* Reset Loopback */
  CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_LPBK);

  /* Re-enable SWPMI interface in normal mode */
  SET_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);

  /* Process Unlocked */
  __HAL_UNLOCK(hswpmi);

  return status;
}

HAL_SWPMI_DMAStop()

HAL_StatusTypeDef HAL_SWPMI_DMAStop

(

SWPMI_HandleTypeDef *

hswpmi

)

Stop all DMA transfers.

Parameters

hswpmi

SWPMI handle

Return values

HAL

status

Definition at line 1162 of file stm32l4xx_hal_swpmi.c.

{
  HAL_StatusTypeDef status = HAL_OK;

  /* Process Locked */
  __HAL_LOCK(hswpmi);

  /* Disable the SWPMI Tx/Rx DMA requests */
  CLEAR_BIT(hswpmi->Instance->CR, (SWPMI_CR_TXDMA | SWPMI_CR_RXDMA));

  /* Abort the SWPMI DMA tx channel */
  if(hswpmi->hdmatx != NULL)
  {
    if(HAL_DMA_Abort(hswpmi->hdmatx) != HAL_OK)
    {
      hswpmi->ErrorCode |= HAL_SWPMI_ERROR_DMA;
      status = HAL_ERROR;
    }
  }
  /* Abort the SWPMI DMA rx channel */
  if(hswpmi->hdmarx != NULL)
  {
    if(HAL_DMA_Abort(hswpmi->hdmarx) != HAL_OK)
    {
      hswpmi->ErrorCode |= HAL_SWPMI_ERROR_DMA;
      status = HAL_ERROR;
    }
  }

  /* Disable SWPMI interface */
  CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);

  hswpmi->State = HAL_SWPMI_STATE_READY;

  /* Process Unlocked */
  __HAL_UNLOCK(hswpmi);

  return status;
}

HAL_SWPMI_EnableLoopback()

HAL_StatusTypeDef HAL_SWPMI_EnableLoopback

(

SWPMI_HandleTypeDef *

hswpmi

)

Enable the Loopback mode.

Parameters

hswpmi

SWPMI handle

Note

Loopback mode is to be used only for test purposes

Return values

HAL_OK

/ HAL_BUSY

Definition at line 1209 of file stm32l4xx_hal_swpmi.c.

{
  HAL_StatusTypeDef  status = HAL_OK;

  /* Process Locked */
  __HAL_LOCK(hswpmi);

  /* Make sure the SWPMI interface is not enabled to set the loopback mode */
  CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);

  /* Set Loopback */
  SET_BIT(hswpmi->Instance->CR, SWPMI_CR_LPBK);

  /* Enable SWPMI interface in loopback mode */
  SET_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);

  /* Process Unlocked */
  __HAL_UNLOCK(hswpmi);

  return status;
}

HAL_SWPMI_ErrorCallback()

void HAL_SWPMI_ErrorCallback

(

SWPMI_HandleTypeDef *

hswpmi

)

SWPMI error callback.

Parameters

hswpmi

SWPMI handle

Return values

None

Definition at line 1514 of file stm32l4xx_hal_swpmi.c.

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

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

HAL_SWPMI_GetError()

uint32_t HAL_SWPMI_GetError

(

SWPMI_HandleTypeDef *

hswpmi

)

Return the SWPMI error code.

Parameters

hswpmi

: pointer to a SWPMI_HandleTypeDef structure that contains the configuration information for the specified SWPMI.

Return values

SWPMI

Error Code

Definition at line 1560 of file stm32l4xx_hal_swpmi.c.

{
  return hswpmi->ErrorCode;
}

HAL_SWPMI_GetState()

HAL_SWPMI_StateTypeDef HAL_SWPMI_GetState

(

SWPMI_HandleTypeDef *

hswpmi

)

Return the SWPMI handle state.

Parameters

hswpmi

SWPMI handle

Return values

HAL

state

Definition at line 1548 of file stm32l4xx_hal_swpmi.c.

{
  /* Return SWPMI handle state */
  return hswpmi->State;
}

HAL_SWPMI_Init()

HAL_StatusTypeDef HAL_SWPMI_Init

(

SWPMI_HandleTypeDef *

hswpmi

)

Initialize the SWPMI peripheral according to the specified parameters in the SWPMI_InitTypeDef.

Parameters

hswpmi

SWPMI handle

Return values

HAL

status

Definition at line 238 of file stm32l4xx_hal_swpmi.c.

{
  HAL_StatusTypeDef status = HAL_OK;
  __IO uint32_t wait_loop_index = 0U;

  /* Check the SWPMI handle allocation */
  if(hswpmi == NULL)
  {
    status = HAL_ERROR;
  }
  else
  {
    /* Check the parameters */
    assert_param(IS_SWPMI_VOLTAGE_CLASS(hswpmi->Init.VoltageClass));
    assert_param(IS_SWPMI_BITRATE_VALUE(hswpmi->Init.BitRate));
    assert_param(IS_SWPMI_TX_BUFFERING_MODE(hswpmi->Init.TxBufferingMode));
    assert_param(IS_SWPMI_RX_BUFFERING_MODE(hswpmi->Init.RxBufferingMode));

    if(hswpmi->State == HAL_SWPMI_STATE_RESET)
    {
      /* Allocate lock resource and initialize it */
      hswpmi->Lock = HAL_UNLOCKED;

#if (USE_HAL_SWPMI_REGISTER_CALLBACKS == 1)
      /* Reset callback pointers to the weak predefined callbacks */
      hswpmi->RxCpltCallback     = HAL_SWPMI_RxCpltCallback;
      hswpmi->RxHalfCpltCallback = HAL_SWPMI_RxHalfCpltCallback;
      hswpmi->TxCpltCallback     = HAL_SWPMI_TxCpltCallback;
      hswpmi->TxHalfCpltCallback = HAL_SWPMI_TxHalfCpltCallback;
      hswpmi->ErrorCallback      = HAL_SWPMI_ErrorCallback;

      /* Init the low level hardware : GPIO, CLOCK, NVIC and DMA */
      if(hswpmi->MspInitCallback == NULL)
      {
        hswpmi->MspInitCallback = HAL_SWPMI_MspInit;
      }
      hswpmi->MspInitCallback(hswpmi);
#else
      /* Init the low level hardware : GPIO, CLOCK, NVIC and DMA */
      HAL_SWPMI_MspInit(hswpmi);
#endif
    }

    hswpmi->State = HAL_SWPMI_STATE_BUSY;

    /* Disable SWPMI interface */
    CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);

    /* Clear all SWPMI interface flags */
    WRITE_REG(hswpmi->Instance->ICR, 0x019F);

    /* Apply Voltage class selection */
    MODIFY_REG(hswpmi->Instance->OR, SWPMI_OR_CLASS, hswpmi->Init.VoltageClass);

    /* If Voltage class B, apply 300 µs delay */
    if(hswpmi->Init.VoltageClass == SWPMI_VOLTAGE_CLASS_B)
    {
      /* Insure 300 µs wait to insure SWPMI_IO output not higher than 1.8V */
      /* Wait loop initialization and execution                            */
      /* Note: Variable divided by 4 to compensate partially CPU processing cycles. */
      wait_loop_index = (300U * (SystemCoreClock / (1000000U * 4U))) + 150U;
      while(wait_loop_index != 0U)
      {
        wait_loop_index--;
      }
    }

    /* Configure the BRR register (Bitrate) */
    WRITE_REG(hswpmi->Instance->BRR, hswpmi->Init.BitRate);

    /* Apply SWPMI CR configuration */
    MODIFY_REG(hswpmi->Instance->CR, \
               SWPMI_CR_RXDMA | SWPMI_CR_TXDMA  | SWPMI_CR_RXMODE | SWPMI_CR_TXMODE, \
               hswpmi->Init.TxBufferingMode | hswpmi->Init.RxBufferingMode);

    hswpmi->ErrorCode = HAL_SWPMI_ERROR_NONE;
    hswpmi->State = HAL_SWPMI_STATE_READY;

    /* Enable SWPMI peripheral */
    SET_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
  }

  return status;
}

HAL_SWPMI_IRQHandler()

void HAL_SWPMI_IRQHandler

(

SWPMI_HandleTypeDef *

hswpmi

)

Handle SWPMI interrupt request.

Parameters

hswpmi

SWPMI handle

Return values

None

Definition at line 1282 of file stm32l4xx_hal_swpmi.c.

{
  uint32_t regisr = READ_REG(hswpmi->Instance->ISR);
  uint32_t regier = READ_REG(hswpmi->Instance->IER);
  uint32_t errcode = HAL_SWPMI_ERROR_NONE;

  /* SWPMI CRC error interrupt occurred --------------------------------------*/
  if(((regisr & SWPMI_FLAG_RXBERF) != 0U) && ((regier & SWPMI_IT_RXBERIE) != 0U))
  {
    /* Disable Receive CRC interrupt */
    CLEAR_BIT(hswpmi->Instance->IER, SWPMI_IT_RXBERIE | SWPMI_IT_RXBFIE);
    /* Clear Receive CRC and Receive buffer full flag */
    WRITE_REG(hswpmi->Instance->ICR, SWPMI_FLAG_RXBERF | SWPMI_FLAG_RXBFF);

    errcode |= HAL_SWPMI_ERROR_CRC;
  }

  /* SWPMI Over-Run interrupt occurred -----------------------------------------*/
  if(((regisr & SWPMI_FLAG_RXOVRF) != 0U) && ((regier & SWPMI_IT_RXOVRIE) != 0U))
  {
    /* Disable Receive overrun interrupt */
    CLEAR_BIT(hswpmi->Instance->IER, SWPMI_IT_RXOVRIE);
    /* Clear Receive overrun flag */
    WRITE_REG(hswpmi->Instance->ICR, SWPMI_FLAG_RXOVRF);

    errcode |= HAL_SWPMI_ERROR_OVR;
  }

  /* SWPMI Under-Run interrupt occurred -----------------------------------------*/
  if(((regisr & SWPMI_FLAG_TXUNRF) != 0U) && ((regier & SWPMI_IT_TXUNRIE) != 0U))
  {
    /* Disable Transmit under run interrupt */
    CLEAR_BIT(hswpmi->Instance->IER, SWPMI_IT_TXUNRIE);
    /* Clear Transmit under run flag */
    WRITE_REG(hswpmi->Instance->ICR, SWPMI_FLAG_TXUNRF);

    errcode |= HAL_SWPMI_ERROR_UDR;
  }

   /* Call SWPMI Error Call back function if needed --------------------------*/
  if(errcode != HAL_SWPMI_ERROR_NONE)
  {
    hswpmi->ErrorCode |= errcode;

    if((errcode & HAL_SWPMI_ERROR_UDR) != 0U)
    {
      /* Check TXDMA transfer to abort */
      if(HAL_IS_BIT_SET(hswpmi->Instance->CR, SWPMI_CR_TXDMA))
      {
        /* Disable DMA TX at SWPMI level */
        CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_TXDMA);

        /* Abort the USART DMA Tx channel */
        if(hswpmi->hdmatx != NULL)
        {
          /* Set the SWPMI Tx DMA Abort callback :
             will lead to call HAL_SWPMI_ErrorCallback() at end of DMA abort procedure */
          hswpmi->hdmatx->XferAbortCallback = SWPMI_DMAAbortOnError;
          /* Abort DMA TX */
          if(HAL_DMA_Abort_IT(hswpmi->hdmatx) != HAL_OK)
          {
            /* Call Directly hswpmi->hdmatx->XferAbortCallback function in case of error */
            hswpmi->hdmatx->XferAbortCallback(hswpmi->hdmatx);
          }
        }
        else
        {
          /* Set the SWPMI state ready to be able to start again the process */
          hswpmi->State = HAL_SWPMI_STATE_READY;

#if (USE_HAL_SWPMI_REGISTER_CALLBACKS == 1)
          hswpmi->ErrorCallback(hswpmi);
#else
          HAL_SWPMI_ErrorCallback(hswpmi);
#endif
        }
      }
      else
      {
        /* Set the SWPMI state ready to be able to start again the process */
        hswpmi->State = HAL_SWPMI_STATE_READY;

#if (USE_HAL_SWPMI_REGISTER_CALLBACKS == 1)
        hswpmi->ErrorCallback(hswpmi);
#else
        HAL_SWPMI_ErrorCallback(hswpmi);
#endif
      }
    }
    else
    {
      /* Check RXDMA transfer to abort */
      if(HAL_IS_BIT_SET(hswpmi->Instance->CR, SWPMI_CR_RXDMA))
      {
        /* Disable DMA RX at SWPMI level */
        CLEAR_BIT(hswpmi->Instance->CR, SWPMI_CR_RXDMA);

        /* Abort the USART DMA Rx channel */
        if(hswpmi->hdmarx != NULL)
        {
          /* Set the SWPMI Rx DMA Abort callback :
             will lead to call HAL_SWPMI_ErrorCallback() at end of DMA abort procedure */
          hswpmi->hdmarx->XferAbortCallback = SWPMI_DMAAbortOnError;
          /* Abort DMA RX */
          if(HAL_DMA_Abort_IT(hswpmi->hdmarx) != HAL_OK)
          {
            /* Call Directly hswpmi->hdmarx->XferAbortCallback function in case of error */
            hswpmi->hdmarx->XferAbortCallback(hswpmi->hdmarx);
          }
        }
        else
        {
          /* Set the SWPMI state ready to be able to start again the process */
          hswpmi->State = HAL_SWPMI_STATE_READY;

#if (USE_HAL_SWPMI_REGISTER_CALLBACKS == 1)
          hswpmi->ErrorCallback(hswpmi);
#else
          HAL_SWPMI_ErrorCallback(hswpmi);
#endif
        }
      }
      else
      {
        /* Set the SWPMI state ready to be able to start again the process */
        hswpmi->State = HAL_SWPMI_STATE_READY;

#if (USE_HAL_SWPMI_REGISTER_CALLBACKS == 1)
        hswpmi->ErrorCallback(hswpmi);
#else
        HAL_SWPMI_ErrorCallback(hswpmi);
#endif
      }
    }
  }

  /* SWPMI in mode Receiver ---------------------------------------------------*/
  if(((regisr & SWPMI_FLAG_RXNE) != 0U) && ((regier & SWPMI_IT_RIE)  != 0U))
  {
    SWPMI_Receive_IT(hswpmi);
  }

  /* SWPMI in mode Transmitter ------------------------------------------------*/
  if(((regisr & SWPMI_FLAG_TXE) != 0U) && ((regier & SWPMI_IT_TIE) != 0U))
  {
    SWPMI_Transmit_IT(hswpmi);
  }

  /* SWPMI in mode Transmitter (Transmit buffer empty) ------------------------*/
  if(((regisr & SWPMI_FLAG_TXBEF) != 0U) && ((regier & SWPMI_IT_TXBEIE) != 0U))
  {
    SWPMI_EndTransmit_IT(hswpmi);
  }

  /* SWPMI in mode Receiver (Receive buffer full) -----------------------------*/
  if(((regisr & SWPMI_FLAG_RXBFF) != 0U) && ((regier & SWPMI_IT_RXBFIE) != 0U))
  {
    SWPMI_EndReceive_IT(hswpmi);
  }

  /* Both Transmission and reception complete ---------------------------------*/
  if(((regisr & SWPMI_FLAG_TCF) != 0U) && ((regier & SWPMI_IT_TCIE) != 0U))
  {
    SWPMI_EndTransmitReceive_IT(hswpmi);
  }
}

HAL_SWPMI_MspDeInit()

void HAL_SWPMI_MspDeInit

(

SWPMI_HandleTypeDef *

hswpmi

)

DeInitialize the SWPMI MSP.

Parameters

hswpmi

SWPMI handle

Return values

None

Definition at line 392 of file stm32l4xx_hal_swpmi.c.

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

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

HAL_SWPMI_MspInit()

void HAL_SWPMI_MspInit

(

SWPMI_HandleTypeDef *

hswpmi

)

Initialize the SWPMI MSP.

Parameters

hswpmi

SWPMI handle

Return values

None

Definition at line 377 of file stm32l4xx_hal_swpmi.c.

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

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

HAL_SWPMI_Receive()

HAL_StatusTypeDef HAL_SWPMI_Receive	(	SWPMI_HandleTypeDef *	hswpmi,
		uint32_t *	pData,
		uint16_t	Size,
		uint32_t	Timeout
	)

Receive an amount of data in blocking mode.

Parameters

hswpmi	pointer to a SWPMI_HandleTypeDef structure that contains the configuration information for SWPMI module.
pData	Pointer to data buffer
Size	Amount of data to be received
Timeout	Timeout duration

Return values

HAL

status

Definition at line 757 of file stm32l4xx_hal_swpmi.c.

{
  uint32_t tickstart = HAL_GetTick();
  HAL_StatusTypeDef status = HAL_OK;
  HAL_SWPMI_StateTypeDef tmp_state;
  uint32_t *ptmp_data;
  uint32_t tmp_size;

  if((pData == NULL ) || (Size == 0U))
  {
    status = HAL_ERROR;
  }
  else
  {
    /* Process Locked */
    __HAL_LOCK(hswpmi);

    tmp_state = hswpmi->State;
    if((tmp_state == HAL_SWPMI_STATE_READY) || (tmp_state == HAL_SWPMI_STATE_BUSY_TX))
    {
      /* Check if a non-blocking transmit process is ongoing or not */
      if(tmp_state == HAL_SWPMI_STATE_READY)
      {
        hswpmi->State = HAL_SWPMI_STATE_BUSY_RX;

        /* Disable any receiver interrupts */
        CLEAR_BIT(hswpmi->Instance->IER, SWPMI_IT_SRIE | SWPMI_IT_RIE | SWPMI_IT_RXBERIE | SWPMI_IT_RXOVRIE | SWPMI_IT_RXBFIE);

        /* Enable SWPMI peripheral if not */
        SET_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
      }
      else
      {
        hswpmi->State = HAL_SWPMI_STATE_BUSY_TX_RX;
      }

      ptmp_data = pData;
      tmp_size = Size;
      do
      {
        /* Wait the RXNE to read data */
        if(HAL_IS_BIT_SET(hswpmi->Instance->ISR, SWPMI_FLAG_RXNE))
        {
          *ptmp_data = hswpmi->Instance->RDR;
          ptmp_data++;
          tmp_size--;
        }
        else
        {
          /* Check for the Timeout */
          if(Timeout != HAL_MAX_DELAY)
          {
            if(((HAL_GetTick() - tickstart) > Timeout) || (Timeout == 0U))
            {
              status = HAL_TIMEOUT;
              break;
            }
          }
        }
      } while(tmp_size != 0U);

      if(status == HAL_OK)
      {
        if(HAL_IS_BIT_SET(hswpmi->Instance->ISR, SWPMI_FLAG_RXBFF))
        {
          /* Clear RXBFF at end of reception */
          WRITE_REG(hswpmi->Instance->ICR, SWPMI_FLAG_RXBFF);
        }

        /* Check if a non-blocking transmit Process is ongoing or not */
        if(hswpmi->State == HAL_SWPMI_STATE_BUSY_TX_RX)
        {
          hswpmi->State = HAL_SWPMI_STATE_BUSY_TX;
        }
        else
        {
          hswpmi->State = HAL_SWPMI_STATE_READY;
        }
      }
    }
    else
    {
      status = HAL_BUSY;
    }
  }

  if((status != HAL_OK) && (status != HAL_BUSY))
  {
    hswpmi->State = HAL_SWPMI_STATE_READY;
  }
  /* Process Unlocked */
  __HAL_UNLOCK(hswpmi);

  return status;
}

HAL_SWPMI_Receive_DMA()

HAL_StatusTypeDef HAL_SWPMI_Receive_DMA	(	SWPMI_HandleTypeDef *	hswpmi,
		uint32_t *	pData,
		uint16_t	Size
	)

Receive an amount of data in non-blocking mode with DMA interrupt.

Parameters

hswpmi	SWPMI handle
pData	Pointer to data buffer
Size	Amount of data to be received

Return values

HAL

status

Definition at line 1078 of file stm32l4xx_hal_swpmi.c.

{
  HAL_StatusTypeDef status = HAL_OK;
  HAL_SWPMI_StateTypeDef tmp_state;

  if((pData == NULL ) || (Size == 0U))
  {
    status =  HAL_ERROR;
  }
  else
  {
    /* Process Locked */
    __HAL_LOCK(hswpmi);

    tmp_state = hswpmi->State;
    if((tmp_state == HAL_SWPMI_STATE_READY) || (tmp_state == HAL_SWPMI_STATE_BUSY_TX))
    {
      /* Update handle */
      hswpmi->pRxBuffPtr = pData;
      hswpmi->RxXferSize = Size;
      hswpmi->ErrorCode = HAL_SWPMI_ERROR_NONE;

      /* Check if a transmit process is ongoing or not */
      if(tmp_state == HAL_SWPMI_STATE_READY)
      {
        hswpmi->State = HAL_SWPMI_STATE_BUSY_RX;

        /* Enable SWPMI peripheral if not */
        SET_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
      }
      else
      {
        hswpmi->State = HAL_SWPMI_STATE_BUSY_TX_RX;
      }

      /* Set the SWPMI DMA transfer complete callback */
      hswpmi->hdmarx->XferCpltCallback = SWPMI_DMAReceiveCplt;

      /* Set the SWPMI DMA Half transfer complete callback */
      hswpmi->hdmarx->XferHalfCpltCallback = SWPMI_DMARxHalfCplt;

      /* Set the DMA error callback */
      hswpmi->hdmarx->XferErrorCallback = SWPMI_DMAError;

      /* Enable the DMA request */
      if(HAL_DMA_Start_IT(hswpmi->hdmarx, (uint32_t)&hswpmi->Instance->RDR, (uint32_t)hswpmi->pRxBuffPtr, Size) != HAL_OK)
      {
        hswpmi->State = tmp_state;    /* Back to previous state */
        hswpmi->ErrorCode = HAL_SWPMI_ERROR_DMA;
        status = HAL_ERROR;

        /* Process Unlocked */
        __HAL_UNLOCK(hswpmi);
      }
      else
      {
        /* Process Unlocked */
        __HAL_UNLOCK(hswpmi);

        /* Enable the SWPMI receive CRC Error and receive overrun interrupts */
        __HAL_SWPMI_ENABLE_IT(hswpmi, SWPMI_IT_RXBERIE | SWPMI_IT_RXOVRIE);

        /* Enable the DMA transfer for the receiver request by setting the RXDMA bit
           in the SWPMI CR register */
        SET_BIT(hswpmi->Instance->CR, SWPMI_CR_RXDMA);
      }
    }
    else
    {
      status = HAL_BUSY;

      /* Process Unlocked */
      __HAL_UNLOCK(hswpmi);
    }
  }

  return status;
}

HAL_SWPMI_Receive_IT()

HAL_StatusTypeDef HAL_SWPMI_Receive_IT	(	SWPMI_HandleTypeDef *	hswpmi,
		uint32_t *	pData,
		uint16_t	Size
	)

Receive an amount of data in non-blocking mode with interrupt.

Parameters

hswpmi	SWPMI handle
pData	Pointer to data buffer
Size	Amount of data to be received

Return values

HAL

status

Definition at line 928 of file stm32l4xx_hal_swpmi.c.

{
  HAL_StatusTypeDef status = HAL_OK;
  HAL_SWPMI_StateTypeDef tmp_state;

  if((pData == NULL ) || (Size == 0U))
  {
    status =  HAL_ERROR;
  }
  else
  {
    /* Process Locked */
    __HAL_LOCK(hswpmi);

    tmp_state = hswpmi->State;
    if((tmp_state == HAL_SWPMI_STATE_READY) || (tmp_state == HAL_SWPMI_STATE_BUSY_TX))
    {
      /* Update handle */
      hswpmi->pRxBuffPtr = pData;
      hswpmi->RxXferSize = Size;
      hswpmi->RxXferCount = Size;
      hswpmi->ErrorCode = HAL_SWPMI_ERROR_NONE;

      /* Check if a transmit process is ongoing or not */
      if(tmp_state == HAL_SWPMI_STATE_READY)
      {
        hswpmi->State = HAL_SWPMI_STATE_BUSY_RX;

        /* Enable SWPMI peripheral if not */
        SET_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
      }
      else
      {
        hswpmi->State = HAL_SWPMI_STATE_BUSY_TX_RX;
      }

      /* Process Unlocked */
      __HAL_UNLOCK(hswpmi);

      /* Enable the SWPMI slave resume */
      /* Enable the SWPMI Data Register not empty Interrupt, receive CRC Error, receive overrun and RxBuf Interrupt */
      /*  Enable the SWPMI Transmit/Reception completion   */
      __HAL_SWPMI_ENABLE_IT(hswpmi, SWPMI_IT_RIE | SWPMI_IT_RXBERIE | SWPMI_IT_RXOVRIE | SWPMI_IT_RXBFIE);
    }
    else
    {
      status = HAL_BUSY;

      /* Process Unlocked */
      __HAL_UNLOCK(hswpmi);
    }
  }

  return status;
}

HAL_SWPMI_RegisterCallback()

HAL_StatusTypeDef HAL_SWPMI_RegisterCallback	(	SWPMI_HandleTypeDef *	hswpmi,
		HAL_SWPMI_CallbackIDTypeDef	CallbackID,
		pSWPMI_CallbackTypeDef	pCallback
	)

Register a user SWPMI callback to be used instead of the weak predefined callback.

Parameters

hswpmi	SWPMI handle.
CallbackID	ID of the callback to be registered. This parameter can be one of the following values: HAL_SWPMI_RX_COMPLETE_CB_ID receive complete callback ID. HAL_SWPMI_RX_HALFCOMPLETE_CB_ID receive half complete callback ID. HAL_SWPMI_TX_COMPLETE_CB_ID transmit complete callback ID. HAL_SWPMI_TX_HALFCOMPLETE_CB_ID transmit half complete callback ID. HAL_SWPMI_ERROR_CB_ID error callback ID. HAL_SWPMI_MSPINIT_CB_ID MSP init callback ID. HAL_SWPMI_MSPDEINIT_CB_ID MSP de-init callback ID.
pCallback	pointer to the callback function.

Return values

HAL

status.

Definition at line 419 of file stm32l4xx_hal_swpmi.c.

{
  HAL_StatusTypeDef status = HAL_OK;

  if(pCallback == NULL)
  {
    /* update the error code */
    hswpmi->ErrorCode |= HAL_SWPMI_ERROR_INVALID_CALLBACK;
    /* update return status */
    status = HAL_ERROR;
  }
  else
  {
    if(hswpmi->State == HAL_SWPMI_STATE_READY)
    {
      switch (CallbackID)
      {
      case HAL_SWPMI_RX_COMPLETE_CB_ID :
        hswpmi->RxCpltCallback = pCallback;
        break;
      case HAL_SWPMI_RX_HALFCOMPLETE_CB_ID :
        hswpmi->RxHalfCpltCallback = pCallback;
        break;
      case HAL_SWPMI_TX_COMPLETE_CB_ID :
        hswpmi->TxCpltCallback = pCallback;
        break;
      case HAL_SWPMI_TX_HALFCOMPLETE_CB_ID :
        hswpmi->TxHalfCpltCallback = pCallback;
        break;
      case HAL_SWPMI_ERROR_CB_ID :
        hswpmi->ErrorCallback = pCallback;
        break;
      case HAL_SWPMI_MSPINIT_CB_ID :
        hswpmi->MspInitCallback = pCallback;
        break;
      case HAL_SWPMI_MSPDEINIT_CB_ID :
        hswpmi->MspDeInitCallback = pCallback;
        break;
      default :
        /* update the error code */
        hswpmi->ErrorCode |= HAL_SWPMI_ERROR_INVALID_CALLBACK;
        /* update return status */
        status = HAL_ERROR;
        break;
      }
    }
    else if(hswpmi->State == HAL_SWPMI_STATE_RESET)
    {
      switch (CallbackID)
      {
      case HAL_SWPMI_MSPINIT_CB_ID :
        hswpmi->MspInitCallback = pCallback;
        break;
      case HAL_SWPMI_MSPDEINIT_CB_ID :
        hswpmi->MspDeInitCallback = pCallback;
        break;
      default :
        /* update the error code */
        hswpmi->ErrorCode |= HAL_SWPMI_ERROR_INVALID_CALLBACK;
        /* update return status */
        status = HAL_ERROR;
        break;
      }
    }
    else
    {
      /* update the error code */
      hswpmi->ErrorCode |= HAL_SWPMI_ERROR_INVALID_CALLBACK;
      /* update return status */
      status = HAL_ERROR;
    }
  }
  return status;
}

HAL_SWPMI_RxCpltCallback()

void HAL_SWPMI_RxCpltCallback

(

SWPMI_HandleTypeDef *

hswpmi

)

Rx Transfer completed callback.

Parameters

hswpmi

SWPMI handle

Return values

None

Definition at line 1484 of file stm32l4xx_hal_swpmi.c.

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

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

HAL_SWPMI_RxHalfCpltCallback()

void HAL_SWPMI_RxHalfCpltCallback

(

SWPMI_HandleTypeDef *

hswpmi

)

Rx Half Transfer completed callback.

Parameters

hswpmi

SWPMI handle

Return values

None

Definition at line 1499 of file stm32l4xx_hal_swpmi.c.

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

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

HAL_SWPMI_Transmit()

HAL_StatusTypeDef HAL_SWPMI_Transmit	(	SWPMI_HandleTypeDef *	hswpmi,
		uint32_t *	pData,
		uint16_t	Size,
		uint32_t	Timeout
	)

Transmit an amount of data in blocking mode.

Parameters

hswpmi	pointer to a SWPMI_HandleTypeDef structure that contains the configuration information for SWPMI module.
pData	Pointer to data buffer
Size	Amount of data to be sent
Timeout	Timeout duration

Return values

HAL

status

Definition at line 646 of file stm32l4xx_hal_swpmi.c.

{
  uint32_t tickstart = HAL_GetTick();
  HAL_StatusTypeDef status = HAL_OK;
  HAL_SWPMI_StateTypeDef tmp_state;
  uint32_t *ptmp_data;
  uint32_t tmp_size;

  if((pData == NULL ) || (Size == 0U))
  {
    status = HAL_ERROR;
  }
  else
  {
    /* Process Locked */
    __HAL_LOCK(hswpmi);

    tmp_state = hswpmi->State;
    if((tmp_state == HAL_SWPMI_STATE_READY) || (tmp_state == HAL_SWPMI_STATE_BUSY_RX))
    {
      /* Check if a non-blocking receive process is ongoing or not */
      if(tmp_state == HAL_SWPMI_STATE_READY)
      {
        hswpmi->State = HAL_SWPMI_STATE_BUSY_TX;

        /* Disable any transmitter interrupts */
        __HAL_SWPMI_DISABLE_IT(hswpmi, SWPMI_IT_TCIE | SWPMI_IT_TIE | SWPMI_IT_TXUNRIE | SWPMI_IT_TXBEIE);

        /* Disable any transmitter flags */
        __HAL_SWPMI_CLEAR_FLAG(hswpmi, SWPMI_FLAG_TXBEF | SWPMI_FLAG_TXUNRF | SWPMI_FLAG_TCF);

        /* Enable SWPMI peripheral if not */
        SET_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
      }
      else
      {
        hswpmi->State = HAL_SWPMI_STATE_BUSY_TX_RX;
      }

      ptmp_data = pData;
      tmp_size = Size;
      do
      {
        /* Wait the TXE to write data */
        if(HAL_IS_BIT_SET(hswpmi->Instance->ISR, SWPMI_FLAG_TXE))
        {
          hswpmi->Instance->TDR = *ptmp_data;
          ptmp_data++;
          tmp_size--;
        }
        else
        {
          /* Check for the Timeout */
          if(Timeout != HAL_MAX_DELAY)
          {
            if(((HAL_GetTick() - tickstart) > Timeout) || (Timeout == 0U))
            {
              status = HAL_TIMEOUT;
              break;
            }
          }
        }
      } while(tmp_size != 0U);

      /* Wait on TXBEF flag to be able to start a second transfer */
      if(SWPMI_WaitOnFlagSetUntilTimeout(hswpmi, SWPMI_FLAG_TXBEF, tickstart, Timeout) != HAL_OK)
      {
        /* Timeout occurred */
        hswpmi->ErrorCode |= HAL_SWPMI_ERROR_TXBEF_TIMEOUT;

        status = HAL_TIMEOUT;
      }

      if(status == HAL_OK)
      {
        /* Check if a non-blocking receive Process is ongoing or not */
        if(hswpmi->State == HAL_SWPMI_STATE_BUSY_TX_RX)
        {
          hswpmi->State = HAL_SWPMI_STATE_BUSY_RX;
        }
        else
        {
          hswpmi->State = HAL_SWPMI_STATE_READY;
        }
      }
    }
    else
    {
      status = HAL_BUSY;
    }
  }

  if((status != HAL_OK) && (status != HAL_BUSY))
  {
    hswpmi->State = HAL_SWPMI_STATE_READY;
  }
  /* Process Unlocked */
  __HAL_UNLOCK(hswpmi);

  return status;
}

HAL_SWPMI_Transmit_DMA()

HAL_StatusTypeDef HAL_SWPMI_Transmit_DMA	(	SWPMI_HandleTypeDef *	hswpmi,
		uint32_t *	pData,
		uint16_t	Size
	)

Transmit an amount of data in non-blocking mode with DMA interrupt.

Parameters

hswpmi	SWPMI handle
pData	Pointer to data buffer
Size	Amount of data to be sent

Return values

HAL

status

Definition at line 991 of file stm32l4xx_hal_swpmi.c.

{
  HAL_StatusTypeDef status = HAL_OK;
  HAL_SWPMI_StateTypeDef tmp_state;

  if((pData == NULL ) || (Size == 0U))
  {
    status =  HAL_ERROR;
  }
  else
  {
    /* Process Locked */
    __HAL_LOCK(hswpmi);

    tmp_state = hswpmi->State;
    if((tmp_state == HAL_SWPMI_STATE_READY) || (tmp_state == HAL_SWPMI_STATE_BUSY_RX))
    {
      /* Update handle */
      hswpmi->pTxBuffPtr = pData;
      hswpmi->TxXferSize = Size;
      hswpmi->TxXferCount = Size;
      hswpmi->ErrorCode = HAL_SWPMI_ERROR_NONE;

      /* Check if a receive process is ongoing or not */
      if(tmp_state == HAL_SWPMI_STATE_READY)
      {
        hswpmi->State = HAL_SWPMI_STATE_BUSY_TX;

        /* Enable SWPMI peripheral if not */
        SET_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
      }
      else
      {
        hswpmi->State = HAL_SWPMI_STATE_BUSY_TX_RX;
      }

      /* Set the SWPMI DMA transfer complete callback */
      hswpmi->hdmatx->XferCpltCallback = SWPMI_DMATransmitCplt;

      /* Set the SWPMI DMA Half transfer complete callback */
      hswpmi->hdmatx->XferHalfCpltCallback = SWPMI_DMATxHalfCplt;

      /* Set the DMA error callback */
      hswpmi->hdmatx->XferErrorCallback = SWPMI_DMAError;

      /* Enable the SWPMI transmit DMA channel */
      if(HAL_DMA_Start_IT(hswpmi->hdmatx, (uint32_t)hswpmi->pTxBuffPtr, (uint32_t)&hswpmi->Instance->TDR, Size) != HAL_OK)
      {
        hswpmi->State = tmp_state;    /* Back to previous state */
        hswpmi->ErrorCode = HAL_SWPMI_ERROR_DMA;
        status = HAL_ERROR;

        /* Process Unlocked */
        __HAL_UNLOCK(hswpmi);
      }
      else
      {
        /* Process Unlocked */
        __HAL_UNLOCK(hswpmi);

        /* Enable the SWPMI transmit underrun error */
        __HAL_SWPMI_ENABLE_IT(hswpmi, SWPMI_IT_TXUNRIE);

        /* Enable the DMA transfer for transmit request by setting the TXDMA bit
           in the SWPMI CR register */
        SET_BIT(hswpmi->Instance->CR, SWPMI_CR_TXDMA);
      }
    }
    else
    {
      status = HAL_BUSY;

      /* Process Unlocked */
      __HAL_UNLOCK(hswpmi);
    }
  }

  return status;
}

HAL_SWPMI_Transmit_IT()

HAL_StatusTypeDef HAL_SWPMI_Transmit_IT	(	SWPMI_HandleTypeDef *	hswpmi,
		uint32_t *	pData,
		uint16_t	Size
	)

Transmit an amount of data in non-blocking mode with interrupt.

Parameters

hswpmi	pointer to a SWPMI_HandleTypeDef structure that contains the configuration information for SWPMI module.
pData	Pointer to data buffer
Size	Amount of data to be sent

Return values

HAL

status

Definition at line 861 of file stm32l4xx_hal_swpmi.c.

{
  HAL_StatusTypeDef status = HAL_OK;
  HAL_SWPMI_StateTypeDef tmp_state;

  if((pData == NULL ) || (Size == 0U))
  {
    status =  HAL_ERROR;
  }
  else
  {
    /* Process Locked */
    __HAL_LOCK(hswpmi);

    tmp_state = hswpmi->State;
    if((tmp_state == HAL_SWPMI_STATE_READY) || (tmp_state == HAL_SWPMI_STATE_BUSY_RX))
    {
      /* Update handle */
      hswpmi->pTxBuffPtr = pData;
      hswpmi->TxXferSize = Size;
      hswpmi->TxXferCount = Size;
      hswpmi->ErrorCode = HAL_SWPMI_ERROR_NONE;

      /* Check if a receive process is ongoing or not */
      if(tmp_state == HAL_SWPMI_STATE_READY)
      {
        hswpmi->State = HAL_SWPMI_STATE_BUSY_TX;

        /* Enable SWPMI peripheral if not */
        SET_BIT(hswpmi->Instance->CR, SWPMI_CR_SWPACT);
      }
      else
      {
        hswpmi->State = HAL_SWPMI_STATE_BUSY_TX_RX;
      }

      /* Enable the SWPMI transmit underrun error */
      __HAL_SWPMI_ENABLE_IT(hswpmi, SWPMI_IT_TXUNRIE);

      /* Process Unlocked */
      __HAL_UNLOCK(hswpmi);

      /* Enable the SWPMI interrupts:      */
      /* - Transmit data register empty    */
      /* - Transmit buffer empty           */
      /* - Transmit/Reception completion   */
      __HAL_SWPMI_ENABLE_IT(hswpmi, SWPMI_IT_TIE | SWPMI_IT_TXBEIE | SWPMI_IT_TCIE);
    }
    else
    {
      status =  HAL_BUSY;

      /* Process Unlocked */
      __HAL_UNLOCK(hswpmi);
    }
  }

  return status;
}

HAL_SWPMI_TxCpltCallback()

void HAL_SWPMI_TxCpltCallback

(

SWPMI_HandleTypeDef *

hswpmi

)

Tx Transfer completed callback.

Parameters

hswpmi

SWPMI handle

Return values

None

Definition at line 1454 of file stm32l4xx_hal_swpmi.c.

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

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

HAL_SWPMI_TxHalfCpltCallback()

void HAL_SWPMI_TxHalfCpltCallback

(

SWPMI_HandleTypeDef *

hswpmi

)

Tx Half Transfer completed callback.

Parameters

hswpmi

SWPMI handle

Return values

None

Definition at line 1469 of file stm32l4xx_hal_swpmi.c.

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

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

HAL_SWPMI_UnRegisterCallback()

HAL_StatusTypeDef HAL_SWPMI_UnRegisterCallback	(	SWPMI_HandleTypeDef *	hswpmi,
		HAL_SWPMI_CallbackIDTypeDef	CallbackID
	)

Unregister a user SWPMI callback. SWPMI callback is redirected to the weak predefined callback.

Parameters

hswpmi

SWPMI handle.

CallbackID

ID of the callback to be unregistered. This parameter can be one of the following values: HAL_SWPMI_RX_COMPLETE_CB_ID receive complete callback ID. HAL_SWPMI_RX_HALFCOMPLETE_CB_ID receive half complete callback ID. HAL_SWPMI_TX_COMPLETE_CB_ID transmit complete callback ID. HAL_SWPMI_TX_HALFCOMPLETE_CB_ID transmit half complete callback ID. HAL_SWPMI_ERROR_CB_ID error callback ID. HAL_SWPMI_MSPINIT_CB_ID MSP init callback ID. HAL_SWPMI_MSPDEINIT_CB_ID MSP de-init callback ID.

Return values

HAL

status.

Definition at line 511 of file stm32l4xx_hal_swpmi.c.

{
  HAL_StatusTypeDef status = HAL_OK;

  if(hswpmi->State == HAL_SWPMI_STATE_READY)
  {
    switch (CallbackID)
    {
    case HAL_SWPMI_RX_COMPLETE_CB_ID :
      hswpmi->RxCpltCallback = HAL_SWPMI_RxCpltCallback;
      break;
    case HAL_SWPMI_RX_HALFCOMPLETE_CB_ID :
      hswpmi->RxHalfCpltCallback = HAL_SWPMI_RxHalfCpltCallback;
      break;
    case HAL_SWPMI_TX_COMPLETE_CB_ID :
      hswpmi->TxCpltCallback = HAL_SWPMI_TxCpltCallback;
      break;
    case HAL_SWPMI_TX_HALFCOMPLETE_CB_ID :
      hswpmi->TxHalfCpltCallback = HAL_SWPMI_TxHalfCpltCallback;
      break;
    case HAL_SWPMI_ERROR_CB_ID :
      hswpmi->ErrorCallback = HAL_SWPMI_ErrorCallback;
      break;
    case HAL_SWPMI_MSPINIT_CB_ID :
      hswpmi->MspInitCallback = HAL_SWPMI_MspInit;
      break;
    case HAL_SWPMI_MSPDEINIT_CB_ID :
      hswpmi->MspDeInitCallback = HAL_SWPMI_MspDeInit;
      break;
    default :
      /* update the error code */
      hswpmi->ErrorCode |= HAL_SWPMI_ERROR_INVALID_CALLBACK;
      /* update return status */
      status = HAL_ERROR;
      break;
    }
  }
  else if(hswpmi->State == HAL_SWPMI_STATE_RESET)
  {
    switch (CallbackID)
    {
    case HAL_SWPMI_MSPINIT_CB_ID :
      hswpmi->MspInitCallback = HAL_SWPMI_MspInit;
      break;
    case HAL_SWPMI_MSPDEINIT_CB_ID :
      hswpmi->MspDeInitCallback = HAL_SWPMI_MspDeInit;
      break;
    default :
      /* update the error code */
      hswpmi->ErrorCode |= HAL_SWPMI_ERROR_INVALID_CALLBACK;
      /* update return status */
      status = HAL_ERROR;
      break;
    }
  }
  else
  {
    /* update the error code */
    hswpmi->ErrorCode |= HAL_SWPMI_ERROR_INVALID_CALLBACK;
    /* update return status */
    status = HAL_ERROR;
  }
  return status;
}