IO operation functions

IO operation functions. More...

Functions
HAL_StatusTypeDef	HAL_DCMI_Start_DMA (DCMI_HandleTypeDef *hdcmi, uint32_t DCMI_Mode, uint32_t pData, uint32_t Length)
	Enable DCMI capture in DMA mode. More...
HAL_StatusTypeDef	HAL_DCMI_Stop (DCMI_HandleTypeDef *hdcmi)
	Disable DCMI capture in DMA mode. More...
HAL_StatusTypeDef	HAL_DCMI_Suspend (DCMI_HandleTypeDef *hdcmi)
	Suspend DCMI capture. More...
HAL_StatusTypeDef	HAL_DCMI_Resume (DCMI_HandleTypeDef *hdcmi)
	Resume DCMI capture. More...
void	HAL_DCMI_ErrorCallback (DCMI_HandleTypeDef *hdcmi)
	Error DCMI callback. More...
void	HAL_DCMI_LineEventCallback (DCMI_HandleTypeDef *hdcmi)
	Line Event callback. More...
void	HAL_DCMI_FrameEventCallback (DCMI_HandleTypeDef *hdcmi)
	Frame Event callback. More...
void	HAL_DCMI_VsyncEventCallback (DCMI_HandleTypeDef *hdcmi)
	VSYNC Event callback. More...
void	HAL_DCMI_IRQHandler (DCMI_HandleTypeDef *hdcmi)
	Handle DCMI interrupt request. More...

Detailed Description

IO operation functions.

 ===============================================================================
                      #####  IO operation functions  #####
 ===============================================================================
    [..]  This section provides functions allowing to:
      (+) Configure destination address and data length,
          enable DCMI DMA request and DCMI capture.
      (+) Stop DCMI capture.
      (+) Handle DCMI interrupt request.

    [..]  A set of callbacks is provided:
        (+) HAL_DCMI_ErrorCallback()
        (+) HAL_DCMI_LineEventCallback()
        (+) HAL_DCMI_VsyncEventCallback()
        (+) HAL_DCMI_FrameEventCallback()

Function Documentation

HAL_DCMI_ErrorCallback()

__weak void HAL_DCMI_ErrorCallback

(

DCMI_HandleTypeDef *

hdcmi

)

Error DCMI callback.

Parameters

hdcmi

pointer to a DCMI_HandleTypeDef structure that contains the configuration information for DCMI.

Return values

None

Definition at line 813 of file stm32l4xx_hal_dcmi.c.

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

  /* NOTE : This function should not be modified; when the callback is needed,
            the HAL_DCMI_ErrorCallback() callback can be implemented in the user file.
   */
}

HAL_DCMI_FrameEventCallback()

__weak void HAL_DCMI_FrameEventCallback

(

DCMI_HandleTypeDef *

hdcmi

)

Frame Event callback.

Parameters

hdcmi

pointer to a DCMI_HandleTypeDef structure that contains the configuration information for DCMI.

Return values

None

Definition at line 861 of file stm32l4xx_hal_dcmi.c.

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

  /* NOTE : This function should not be modified; when the callback is needed,
            the HAL_DCMI_FrameEventCallback() callback can be implemented in the user file.
   */
}

HAL_DCMI_IRQHandler()

void HAL_DCMI_IRQHandler

(

DCMI_HandleTypeDef *

hdcmi

)

Handle DCMI interrupt request.

Parameters

hdcmi

pointer to a DCMI_HandleTypeDef structure that contains the configuration information for the DCMI.

Return values

None

Definition at line 714 of file stm32l4xx_hal_dcmi.c.

{
  uint32_t misflags = READ_REG(hdcmi->Instance->MISR);

  /* Synchronization error interrupt management *******************************/
  if ((misflags & DCMI_MIS_ERR_MIS) != 0x0U)
  {
    /* Clear the Synchronization error flag */
    __HAL_DCMI_CLEAR_FLAG(hdcmi, DCMI_FLAG_ERRRI);

    /* Update error code */
    hdcmi->ErrorCode |= HAL_DCMI_ERROR_SYNC;
  }

  /* Overflow interrupt management ********************************************/
  if ((misflags & DCMI_MIS_OVR_MIS) != 0x0U)
  {
    /* Clear the Overflow flag */
    __HAL_DCMI_CLEAR_FLAG(hdcmi, DCMI_FLAG_OVRRI);

    /* Update error code */
    hdcmi->ErrorCode |= HAL_DCMI_ERROR_OVR;
  }

  if (hdcmi->ErrorCode != HAL_DCMI_ERROR_NONE)
  {
    /* Change DCMI state */
    hdcmi->State = HAL_DCMI_STATE_READY;

    /* Set the overflow callback */
    hdcmi->DMA_Handle->XferAbortCallback = DCMI_DMAError;

    /* Abort the DMA Transfer */
    if (HAL_DMA_Abort_IT(hdcmi->DMA_Handle) != HAL_OK)
    {
      DCMI_DMAError(hdcmi->DMA_Handle);
    }
  }

  /* Line Interrupt management ************************************************/
  if ((misflags & DCMI_MIS_LINE_MIS) != 0x0U)
  {
    /* Clear the Line interrupt flag */
    __HAL_DCMI_CLEAR_FLAG(hdcmi, DCMI_FLAG_LINERI);

    /* Line interrupt Event Callback */
#if (USE_HAL_DCMI_REGISTER_CALLBACKS == 1)
    /*Call registered DCMI line event callback*/
    hdcmi->LineEventCallback(hdcmi);
#else
    HAL_DCMI_LineEventCallback(hdcmi);
#endif /* USE_HAL_DCMI_REGISTER_CALLBACKS */
  }

  /* VSYNC interrupt management ***********************************************/
  if ((misflags & DCMI_MIS_VSYNC_MIS) != 0x0U)
  {
    /* Clear the VSYNC flag */
    __HAL_DCMI_CLEAR_FLAG(hdcmi, DCMI_FLAG_VSYNCRI);

    /* VSYNC Event Callback */
#if (USE_HAL_DCMI_REGISTER_CALLBACKS == 1)
    /*Call registered DCMI vsync event callback*/
    hdcmi->VsyncEventCallback(hdcmi);
#else
    HAL_DCMI_VsyncEventCallback(hdcmi);
#endif /* USE_HAL_DCMI_REGISTER_CALLBACKS */
  }

  /* End of Frame interrupt management ****************************************/
  if ((misflags & DCMI_MIS_FRAME_MIS) != 0x0U)
  {
    /* Disable the Line interrupt when using snapshot mode */
    if ((hdcmi->Instance->CR & DCMI_CR_CM) == DCMI_MODE_SNAPSHOT)
    {
      __HAL_DCMI_DISABLE_IT(hdcmi, DCMI_IT_LINE|DCMI_IT_VSYNC|DCMI_IT_ERR|DCMI_IT_OVR);
      /* Change the DCMI state */
      hdcmi->State = HAL_DCMI_STATE_READY;
    }

    /* Clear the End of Frame flag */
    __HAL_DCMI_CLEAR_FLAG(hdcmi, DCMI_FLAG_FRAMERI);

    /* Frame Event Callback */
#if (USE_HAL_DCMI_REGISTER_CALLBACKS == 1)
    /*Call registered DCMI frame event callback*/
    hdcmi->FrameEventCallback(hdcmi);
#else
    HAL_DCMI_FrameEventCallback(hdcmi);
#endif /* USE_HAL_DCMI_REGISTER_CALLBACKS */
  }
}

HAL_DCMI_LineEventCallback()

__weak void HAL_DCMI_LineEventCallback

(

DCMI_HandleTypeDef *

hdcmi

)

Line Event callback.

Parameters

hdcmi

pointer to a DCMI_HandleTypeDef structure that contains the configuration information for DCMI.

Return values

None

Definition at line 829 of file stm32l4xx_hal_dcmi.c.

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

  /* NOTE : This function should not be modified; when the callback is needed,
            the HAL_DCMI_LineEventCallback() callback can be implemented in the user file.
   */
}

HAL_DCMI_Resume()

HAL_StatusTypeDef HAL_DCMI_Resume

(

DCMI_HandleTypeDef *

hdcmi

)

Resume DCMI capture.

Parameters

hdcmi

pointer to a DCMI_HandleTypeDef structure that contains the configuration information for DCMI.

Return values

HAL

status

Definition at line 688 of file stm32l4xx_hal_dcmi.c.

{
  /* Process locked */
  __HAL_LOCK(hdcmi);

  if(hdcmi->State == HAL_DCMI_STATE_SUSPENDED)
  {
    /* Change DCMI state */
    hdcmi->State = HAL_DCMI_STATE_BUSY;

    /* Enable Capture */
    SET_BIT(hdcmi->Instance->CR, DCMI_CR_CAPTURE);
  }

  /* Process Unlocked */
  __HAL_UNLOCK(hdcmi);

  return HAL_OK;
}

HAL_DCMI_Start_DMA()

HAL_StatusTypeDef HAL_DCMI_Start_DMA	(	DCMI_HandleTypeDef *	hdcmi,
		uint32_t	DCMI_Mode,
		uint32_t	pData,
		uint32_t	Length
	)

Enable DCMI capture in DMA mode.

Parameters

hdcmi	Pointer to a DCMI_HandleTypeDef structure that contains the configuration information for DCMI.
DCMI_Mode	DCMI capture mode snapshot or continuous grab.
pData	The destination memory buffer address.
Length	The length of capture to be transferred (in 32-bit words).

Note

In case of length larger than 65535 (0xFFFF is the DMA maximum transfer length), the API uses the end of the destination buffer as a work area: HAL_DCMI_Start_DMA() initiates a circular DMA transfer from DCMI DR to the ad-hoc work buffer and each half and complete transfer interrupt triggers a copy from the work buffer to the final destination pData thru a second DMA channel.

Following HAL_DCMI_Init() call, all interruptions are enabled (line end, frame end, overrun, VSYNC and embedded synchronization error interrupts). User can disable unwanted interrupts thru __HAL_DCMI_DISABLE_IT() macro before invoking HAL_DCMI_Start_DMA().

For length less than 0xFFFF (DMA maximum transfer length) and in snapshot mode, frame interrupt is disabled before DMA transfer. FRAME capture flag is checked in DCMI_DMAXferCplt callback at the end of the DMA transfer. If flag is set, HAL_DCMI_FrameEventCallback() API is called.

Return values

HAL

status

Definition at line 467 of file stm32l4xx_hal_dcmi.c.

{
  uint32_t circular_copy_length;

  /* Check capture parameter */
  assert_param(IS_DCMI_CAPTURE_MODE(DCMI_Mode));

  /* Process Locked */
  __HAL_LOCK(hdcmi);

  /* Lock the DCMI peripheral state */
  hdcmi->State = HAL_DCMI_STATE_BUSY;

  /* Configure the DCMI Mode and enable the DCMI IP at the same time */
  MODIFY_REG(hdcmi->Instance->CR, (DCMI_CR_CM|DCMI_CR_ENABLE), (DCMI_Mode|DCMI_CR_ENABLE));

  /* Set the DMA conversion complete callback */
  hdcmi->DMA_Handle->XferCpltCallback = DCMI_DMAXferCplt;

  /* Set the DMA error callback */
  hdcmi->DMA_Handle->XferErrorCallback = DCMI_DMAError;

  /* Set the dma abort callback */
  hdcmi->DMA_Handle->XferAbortCallback = NULL;

  if(Length <= 0xFFFFU)
  {
    hdcmi->XferCount = 0; /* Mark as direct transfer from DCMI_DR register to final destination buffer */

    /* Enable the DMA channel */
    if (HAL_DMA_Start_IT(hdcmi->DMA_Handle, (uint32_t)&hdcmi->Instance->DR, (uint32_t)pData, Length) != HAL_OK)
    {
      /* Update error code */
      hdcmi->ErrorCode |= HAL_DCMI_ERROR_DMA;

      /* Set state back to Ready */
      hdcmi->State = HAL_DCMI_STATE_READY;

      /* Process Unlocked */
      __HAL_UNLOCK(hdcmi);

       return HAL_ERROR;
    }
  }
  else /* Capture length is longer than DMA maximum transfer size */
  {
     /* Set DMA in circular mode */
    hdcmi->DMA_Handle->Init.Mode = DMA_CIRCULAR;

    /* Set the DMA half transfer complete callback */
    hdcmi->DMA_Handle->XferHalfCpltCallback = DCMI_DMAHalfXferCplt;

    /* Initialize transfer parameters */
    hdcmi->XferSize = Length;  /* Store the complete transfer length in DCMI handle */
    hdcmi->pBuffPtr = pData;   /* Final destination buffer pointer */

    circular_copy_length = DCMI_TransferSize(Length);

    /* Check if issue in intermediate length computation */
    if (circular_copy_length == 0U)
    {
      /* Set state back to Ready */
      hdcmi->State = HAL_DCMI_STATE_READY;

      /* Process Unlocked */
      __HAL_UNLOCK(hdcmi);

       return HAL_ERROR;
    }

    /* Store the number of half - intermediate buffer copies needed */
    hdcmi->XferCount = 2U * ((Length / circular_copy_length) - 1U);
    /* Store the half-buffer copy length */
    hdcmi->HalfCopyLength = circular_copy_length / 2U;

    /* DCMI DR samples in circular mode will be copied
       at the end of the final buffer.
       Now compute the circular buffer start address. */
    /* Start by pointing at the final buffer */
    hdcmi->pCircularBuffer = pData;
    /* Update pCircularBuffer in "moving" at the end of the final
       buffer, don't forger to convert in bytes to compute exact address */
    hdcmi->pCircularBuffer +=  4U * (((Length / circular_copy_length) - 1U) * circular_copy_length);

    /* Initiate the circular DMA transfer from DCMI IP to final buffer end */
    if ( HAL_DMA_Start_IT(hdcmi->DMA_Handle, (uint32_t)&hdcmi->Instance->DR, (uint32_t)hdcmi->pCircularBuffer, circular_copy_length) != HAL_OK)
    {
      /* Update error code */
      hdcmi->ErrorCode |= HAL_DCMI_ERROR_DMA;

      /* Set state back to Ready */
      hdcmi->State = HAL_DCMI_STATE_READY;

      /* Process Unlocked */
      __HAL_UNLOCK(hdcmi);

       return HAL_ERROR;
    }
  }

  /* Enable Capture */
  SET_BIT(hdcmi->Instance->CR, DCMI_CR_CAPTURE);

  /* Release Lock */
  __HAL_UNLOCK(hdcmi);

  /* Return function status */
  return HAL_OK;
}

HAL_DCMI_Stop()

HAL_StatusTypeDef HAL_DCMI_Stop

(

DCMI_HandleTypeDef *

hdcmi

)

Disable DCMI capture in DMA mode.

Parameters

hdcmi

pointer to a DCMI_HandleTypeDef structure that contains the configuration information for DCMI.

Return values

HAL

status

Definition at line 583 of file stm32l4xx_hal_dcmi.c.

{
  uint32_t tickstart;
  HAL_StatusTypeDef status = HAL_OK;

  /* Process locked */
  __HAL_LOCK(hdcmi);

  /* Lock the DCMI peripheral state */
  hdcmi->State = HAL_DCMI_STATE_BUSY;

  /* Disable Capture */
  CLEAR_BIT(hdcmi->Instance->CR, DCMI_CR_CAPTURE);

  /* Get tick */
  tickstart = HAL_GetTick();

  /* Check if the DCMI capture is effectively disabled */
  while((hdcmi->Instance->CR & DCMI_CR_CAPTURE) != 0U)
  {
    if((HAL_GetTick() - tickstart ) > DCMI_TIMEOUT_STOP)
    {
      /* Update error code */
      hdcmi->ErrorCode |= HAL_DCMI_ERROR_TIMEOUT;

      status = HAL_TIMEOUT;
      break;
    }
  }

  /* Disable the DMA */
  if (HAL_DMA_Abort(hdcmi->DMA_Handle) != HAL_OK)
  {
    DCMI_DMAError(hdcmi->DMA_Handle);
  }

  /* Disable DCMI IP */
  __HAL_DCMI_DISABLE(hdcmi);

  /* Change DCMI state */
  hdcmi->State = HAL_DCMI_STATE_READY;

  /* Process Unlocked */
  __HAL_UNLOCK(hdcmi);

  /* Return function status */
  return status;
}

HAL_DCMI_Suspend()

HAL_StatusTypeDef HAL_DCMI_Suspend

(

DCMI_HandleTypeDef *

hdcmi

)

Suspend DCMI capture.

Parameters

hdcmi

pointer to a DCMI_HandleTypeDef structure that contains the configuration information for DCMI.

Return values

HAL

status

Definition at line 638 of file stm32l4xx_hal_dcmi.c.

{
  uint32_t tickstart;

  /* Process locked */
  __HAL_LOCK(hdcmi);

  if(hdcmi->State == HAL_DCMI_STATE_BUSY)
  {
    /* Change DCMI state */
    hdcmi->State = HAL_DCMI_STATE_SUSPENDED;

    /* Disable Capture */
    CLEAR_BIT(hdcmi->Instance->CR, DCMI_CR_CAPTURE);

    /* Get tick */
    tickstart = HAL_GetTick();

    /* Check if the DCMI capture is effectively disabled */
    while((hdcmi->Instance->CR & DCMI_CR_CAPTURE) != 0U)
    {
      if((HAL_GetTick() - tickstart ) > DCMI_TIMEOUT_STOP)
      {
        /* Update error code */
        hdcmi->ErrorCode |= HAL_DCMI_ERROR_TIMEOUT;

        /* Change DCMI state */
        hdcmi->State = HAL_DCMI_STATE_READY;

        /* Process Unlocked */
        __HAL_UNLOCK(hdcmi);

        return HAL_TIMEOUT;
      }
    }
  }

  /* Process Unlocked */
  __HAL_UNLOCK(hdcmi);

  /* Return function status */
  return HAL_OK;
}

HAL_DCMI_VsyncEventCallback()

__weak void HAL_DCMI_VsyncEventCallback

(

DCMI_HandleTypeDef *

hdcmi

)

VSYNC Event callback.

Parameters

hdcmi

pointer to a DCMI_HandleTypeDef structure that contains the configuration information for DCMI.

Return values

None

Definition at line 845 of file stm32l4xx_hal_dcmi.c.

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

  /* NOTE : This function should not be modified; when the callback is needed,
            the HAL_DCMI_VsyncEventCallback() callback can be implemented in the user file.
   */
}