demos/stm32f429_disco/stm/stm32f4_spl/inc/stm32f4xx_hal_dcmi.h

   1 /**\r
   2   ******************************************************************************\r
   3   * @file    stm32f4xx_hal_dcmi.h\r
   4   * @author  MCD Application Team\r
   5   * @version V1.0.0\r
   6   * @date    18-February-2014\r
   7   * @brief   Header file of DCMI HAL module.\r
   8   ******************************************************************************\r
   9   * @attention\r
  10   *\r
  11   * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>\r
  12   *\r
  13   * Redistribution and use in source and binary forms, with or without modification,\r
  14   * are permitted provided that the following conditions are met:\r
  15   *   1. Redistributions of source code must retain the above copyright notice,\r
  16   *      this list of conditions and the following disclaimer.\r
  17   *   2. Redistributions in binary form must reproduce the above copyright notice,\r
  18   *      this list of conditions and the following disclaimer in the documentation\r
  19   *      and/or other materials provided with the distribution.\r
  20   *   3. Neither the name of STMicroelectronics nor the names of its contributors\r
  21   *      may be used to endorse or promote products derived from this software\r
  22   *      without specific prior written permission.\r
  23   *\r
  24   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"\r
  25   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
  26   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\r
  27   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\r
  28   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
  29   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\r
  30   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\r
  31   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\r
  32   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\r
  33   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
  34   *\r
  35   ******************************************************************************\r
  36   */ \r
  37 \r
  38 /* Define to prevent recursive inclusion -------------------------------------*/\r
  39 #ifndef __STM32F4xx_HAL_DCMI_H\r
  40 #define __STM32F4xx_HAL_DCMI_H\r
  41 \r
  42 #ifdef __cplusplus\r
  43  extern "C" {\r
  44 #endif\r
  45 \r
  46 #if defined(STM32F407xx) || defined(STM32F417xx) || defined(STM32F427xx) || defined(STM32F437xx) || defined(STM32F429xx) || defined(STM32F439xx)\r
  47 /* Includes ------------------------------------------------------------------*/\r
  48 #include "stm32f4xx_hal_def.h"\r
  49 \r
  50 \r
  51 /** @addtogroup STM32F4xx_HAL_Driver\r
  52   * @{\r
  53   */\r
  54 \r
  55 /** @addtogroup DCMI\r
  56   * @{\r
  57   */  \r
  58 \r
  59 /* Exported types ------------------------------------------------------------*/\r
  60 \r
  61 /** \r
  62   * @brief DCMI Error source  \r
  63   */ \r
  64 typedef enum\r
  65 { \r
  66   DCMI_ERROR_SYNC = 1,     /*!< Synchronisation error */\r
  67   DCMI_OVERRUN   = 2,      /*!< DCMI Overrun */\r
  68 \r
  69 }DCMI_ErrorTypeDef;   \r
  70 \r
  71 /** \r
  72   * @brief   DCMI Embedded Synchronisation CODE Init structure definition  \r
  73   */ \r
  74 typedef struct\r
  75 {\r
  76   uint8_t FrameStartCode; /*!< Specifies the code of the frame start delimiter. */\r
  77   uint8_t LineStartCode;  /*!< Specifies the code of the line start delimiter.  */\r
  78   uint8_t LineEndCode;    /*!< Specifies the code of the line end delimiter.    */\r
  79   uint8_t FrameEndCode;   /*!< Specifies the code of the frame end delimiter.   */\r
  80   \r
  81 }DCMI_CodesInitTypeDef;\r
  82 \r
  83 /** \r
  84   * @brief   DCMI Init structure definition  \r
  85   */ \r
  86 typedef struct\r
  87 {\r
  88   uint32_t  SynchroMode;                /*!< Specifies the Synchronization Mode: Hardware or Embedded.\r
  89                                              This parameter can be a value of @ref DCMI_Synchronization_Mode */\r
  90 \r
  91   uint32_t  PCKPolarity;                /*!< Specifies the Pixel clock polarity: Falling or Rising.\r
  92                                              This parameter can be a value of @ref DCMI_PIXCK_Polarity       */\r
  93 \r
  94   uint32_t  VSPolarity;                 /*!< Specifies the Vertical synchronization polarity: High or Low.\r
  95                                              This parameter can be a value of @ref DCMI_VSYNC_Polarity       */\r
  96 \r
  97   uint32_t  HSPolarity;                 /*!< Specifies the Horizontal synchronization polarity: High or Low.\r
  98                                              This parameter can be a value of @ref DCMI_HSYNC_Polarity       */\r
  99 \r
 100   uint32_t  CaptureRate;                /*!< Specifies the frequency of frame capture: All, 1/2 or 1/4.\r
 101                                              This parameter can be a value of @ref DCMI_Capture_Rate         */\r
 102 \r
 103   uint32_t  ExtendedDataMode;           /*!< Specifies the data width: 8-bit, 10-bit, 12-bit or 14-bit.\r
 104                                              This parameter can be a value of @ref DCMI_Extended_Data_Mode   */\r
 105   \r
 106   DCMI_CodesInitTypeDef SyncroCode;     /*!< Specifies the code of the frame start delimiter.                */\r
 107   \r
 108   uint32_t JPEGMode;                    /*!< Enable or Disable the JPEG mode.                                \r
 109                                              This parameter can be a value of @ref DCMI_MODE_JPEG            */  \r
 110   \r
 111 }DCMI_InitTypeDef;\r
 112 \r
 113 \r
 114 /** \r
 115   * @brief  HAL DCMI State structures definition  \r
 116   */ \r
 117 typedef enum\r
 118 {\r
 119   HAL_DCMI_STATE_RESET             = 0x00,  /*!< DCMI not yet initialized or disabled  */\r
 120   HAL_DCMI_STATE_READY             = 0x01,  /*!< DCMI initialized and ready for use    */\r
 121   HAL_DCMI_STATE_BUSY              = 0x02,  /*!< DCMI internal processing is ongoing   */\r
 122   HAL_DCMI_STATE_TIMEOUT           = 0x03,  /*!< DCMI timeout state                    */\r
 123   HAL_DCMI_STATE_ERROR             = 0x04   /*!< DCMI error state                      */\r
 124                                                                         \r
 125 }HAL_DCMI_StateTypeDef;\r
 126 \r
 127 /** \r
 128   * @brief  DCMI handle Structure definition  \r
 129   */   \r
 130 typedef struct\r
 131 {  \r
 132   DCMI_TypeDef                  *Instance;           /*!< DCMI Register base address   */\r
 133     \r
 134   DCMI_InitTypeDef              Init;                /*!< DCMI parameters              */\r
 135   \r
 136   HAL_LockTypeDef               Lock;                /*!< DCMI locking object          */\r
 137  \r
 138   __IO HAL_DCMI_StateTypeDef    State;               /*!< DCMI state                   */\r
 139   \r
 140   __IO uint32_t                 XferCount;           /*!< DMA transfer counter         */\r
 141   \r
 142   __IO uint32_t                 XferSize;            /*!< DMA transfer size            */\r
 143   \r
 144   uint32_t                      XferTransferNumber;  /*!< DMA transfer number          */  \r
 145 \r
 146   uint32_t                      pBuffPtr;            /*!< Pointer to DMA output buffer */    \r
 147   \r
 148   DMA_HandleTypeDef             *DMA_Handle;         /*!< Pointer to the DMA handler   */\r
 149 \r
 150   __IO uint32_t                 ErrorCode;           /*!< DCMI Error code              */  \r
 151   \r
 152 }DCMI_HandleTypeDef;    \r
 153 \r
 154 /* Exported constants --------------------------------------------------------*/\r
 155 \r
 156 /** @defgroup DCMI_Exported_Constants\r
 157   * @{\r
 158   */\r
 159 \r
 160 /** @defgroup DCMI_Error_Code\r
 161   * @{\r
 162   */\r
 163 #define HAL_DCMI_ERROR_NONE      ((uint32_t)0x00000000)    /*!< No error              */\r
 164 #define HAL_DCMI_ERROR_OVF       ((uint32_t)0x00000001)    /*!< Overflow error        */\r
 165 #define HAL_DCMI_ERROR_SYNC      ((uint32_t)0x00000002)    /*!< Synchronization error */   \r
 166 #define HAL_DCMI_ERROR_TIMEOUT   ((uint32_t)0x00000020)    /*!< Timeout error         */\r
 167 /**\r
 168   * @}\r
 169   */ \r
 170 \r
 171 /** @defgroup DCMI_Capture_Mode \r
 172   * @{\r
 173   */ \r
 174 #define DCMI_MODE_CONTINUOUS           ((uint32_t)0x00000000)  /*!< The received data are transferred continuously \r
 175                                                                     into the destination memory through the DMA             */\r
 176 #define DCMI_MODE_SNAPSHOT             ((uint32_t)DCMI_CR_CM)  /*!< Once activated, the interface waits for the start of \r
 177                                                                     frame and then transfers a single frame through the DMA */\r
 178 \r
 179 #define IS_DCMI_CAPTURE_MODE(MODE)(((MODE) == DCMI_MODE_CONTINUOUS) || \\r
 180                                    ((MODE) == DCMI_MODE_SNAPSHOT))\r
 181 /**\r
 182   * @}\r
 183   */ \r
 184 \r
 185 \r
 186 /** @defgroup DCMI_Synchronization_Mode\r
 187   * @{\r
 188   */ \r
 189 #define DCMI_SYNCHRO_HARDWARE        ((uint32_t)0x00000000)   /*!< Hardware synchronization data capture (frame/line start/stop)\r
 190                                                                    is synchronized with the HSYNC/VSYNC signals                  */\r
 191 #define DCMI_SYNCHRO_EMBEDDED        ((uint32_t)DCMI_CR_ESS)  /*!< Embedded synchronization data capture is synchronized with \r
 192                                                                    synchronization codes embedded in the data flow               */\r
 193                                                              \r
 194 #define IS_DCMI_SYNCHRO(MODE)(((MODE) == DCMI_SYNCHRO_HARDWARE) || \\r
 195                               ((MODE) == DCMI_SYNCHRO_EMBEDDED))\r
 196 /**\r
 197   * @}\r
 198   */ \r
 199 \r
 200 \r
 201 /** @defgroup DCMI_PIXCK_Polarity \r
 202   * @{\r
 203   */ \r
 204 #define DCMI_PCKPOLARITY_FALLING    ((uint32_t)0x00000000)      /*!< Pixel clock active on Falling edge */\r
 205 #define DCMI_PCKPOLARITY_RISING     ((uint32_t)DCMI_CR_PCKPOL)  /*!< Pixel clock active on Rising edge  */\r
 206 \r
 207 #define IS_DCMI_PCKPOLARITY(POLARITY)(((POLARITY) == DCMI_PCKPOLARITY_FALLING) || \\r
 208                                       ((POLARITY) == DCMI_PCKPOLARITY_RISING))\r
 209 /**\r
 210   * @}\r
 211   */ \r
 212 \r
 213 \r
 214 /** @defgroup DCMI_VSYNC_Polarity \r
 215   * @{\r
 216   */ \r
 217 #define DCMI_VSPOLARITY_LOW     ((uint32_t)0x00000000)     /*!< Vertical synchronization active Low  */\r
 218 #define DCMI_VSPOLARITY_HIGH    ((uint32_t)DCMI_CR_VSPOL)  /*!< Vertical synchronization active High */\r
 219 \r
 220 #define IS_DCMI_VSPOLARITY(POLARITY)(((POLARITY) == DCMI_VSPOLARITY_LOW) || \\r
 221                                      ((POLARITY) == DCMI_VSPOLARITY_HIGH))\r
 222 /**\r
 223   * @}\r
 224   */ \r
 225 \r
 226 \r
 227 /** @defgroup DCMI_HSYNC_Polarity \r
 228   * @{\r
 229   */ \r
 230 #define DCMI_HSPOLARITY_LOW     ((uint32_t)0x00000000)     /*!< Horizontal synchronization active Low  */\r
 231 #define DCMI_HSPOLARITY_HIGH    ((uint32_t)DCMI_CR_HSPOL)  /*!< Horizontal synchronization active High */\r
 232 \r
 233 #define IS_DCMI_HSPOLARITY(POLARITY)(((POLARITY) == DCMI_HSPOLARITY_LOW) || \\r
 234                                      ((POLARITY) == DCMI_HSPOLARITY_HIGH))\r
 235 /**\r
 236   * @}\r
 237   */ \r
 238 \r
 239 /** @defgroup DCMI_MODE_JPEG \r
 240   * @{\r
 241   */ \r
 242 #define DCMI_JPEG_DISABLE   ((uint32_t)0x00000000)    /*!< Mode JPEG Disabled  */\r
 243 #define DCMI_JPEG_ENABLE    ((uint32_t)DCMI_CR_JPEG)  /*!< Mode JPEG Enabled   */\r
 244 \r
 245 #define IS_DCMI_MODE_JPEG(JPEG_MODE)(((JPEG_MODE) == DCMI_JPEG_DISABLE) || \\r
 246                                      ((JPEG_MODE) == DCMI_JPEG_ENABLE))\r
 247 /**\r
 248   * @}\r
 249   */ \r
 250 \r
 251 /** @defgroup DCMI_Capture_Rate \r
 252   * @{\r
 253   */ \r
 254 #define DCMI_CR_ALL_FRAME            ((uint32_t)0x00000000)      /*!< All frames are captured        */\r
 255 #define DCMI_CR_ALTERNATE_2_FRAME    ((uint32_t)DCMI_CR_FCRC_0)  /*!< Every alternate frame captured */\r
 256 #define DCMI_CR_ALTERNATE_4_FRAME    ((uint32_t)DCMI_CR_FCRC_1)  /*!< One frame in 4 frames captured */\r
 257 \r
 258 #define IS_DCMI_CAPTURE_RATE(RATE) (((RATE) == DCMI_CR_ALL_FRAME)         || \\r
 259                                     ((RATE) == DCMI_CR_ALTERNATE_2_FRAME) || \\r
 260                                     ((RATE) == DCMI_CR_ALTERNATE_4_FRAME))\r
 261 /**\r
 262   * @}\r
 263   */ \r
 264 \r
 265 \r
 266 /** @defgroup DCMI_Extended_Data_Mode \r
 267   * @{\r
 268   */ \r
 269 #define DCMI_EXTEND_DATA_8B     ((uint32_t)0x00000000)                       /*!< Interface captures 8-bit data on every pixel clock  */\r
 270 #define DCMI_EXTEND_DATA_10B    ((uint32_t)DCMI_CR_EDM_0)                    /*!< Interface captures 10-bit data on every pixel clock */\r
 271 #define DCMI_EXTEND_DATA_12B    ((uint32_t)DCMI_CR_EDM_1)                    /*!< Interface captures 12-bit data on every pixel clock */\r
 272 #define DCMI_EXTEND_DATA_14B    ((uint32_t)(DCMI_CR_EDM_0 | DCMI_CR_EDM_1))  /*!< Interface captures 14-bit data on every pixel clock */\r
 273 \r
 274 #define IS_DCMI_EXTENDED_DATA(DATA)(((DATA) == DCMI_EXTEND_DATA_8B)  || \\r
 275                                     ((DATA) == DCMI_EXTEND_DATA_10B) || \\r
 276                                     ((DATA) == DCMI_EXTEND_DATA_12B) || \\r
 277                                     ((DATA) == DCMI_EXTEND_DATA_14B))\r
 278 /**\r
 279   * @}\r
 280   */ \r
 281 \r
 282 /** @defgroup DCMI_Window_Coordinate \r
 283   * @{\r
 284   */ \r
 285 #define DCMI_WINDOW_COORDINATE    ((uint32_t)0x3FFF)  /*!< Window coordinate */\r
 286 \r
 287 #define IS_DCMI_WINDOW_COORDINATE(COORDINATE) ((COORDINATE) <= DCMI_WINDOW_COORDINATE)\r
 288 /**\r
 289   * @}\r
 290   */\r
 291 \r
 292 /** @defgroup DCMI_Window_Height \r
 293   * @{\r
 294   */ \r
 295 #define DCMI_WINDOW_HEIGHT    ((uint32_t)0x1FFF)  /*!< Window Height */\r
 296 \r
 297 #define IS_DCMI_WINDOW_HEIGHT(HEIGHT) ((HEIGHT) <= DCMI_WINDOW_HEIGHT)\r
 298 /**\r
 299   * @}\r
 300   */ \r
 301 \r
 302 /** @defgroup DCMI_interrupt_sources \r
 303   * @{\r
 304   */ \r
 305 #define DCMI_IT_FRAME    ((uint32_t)DCMI_IER_FRAME_IE)\r
 306 #define DCMI_IT_OVF      ((uint32_t)DCMI_IER_OVF_IE)\r
 307 #define DCMI_IT_ERR      ((uint32_t)DCMI_IER_ERR_IE)\r
 308 #define DCMI_IT_VSYNC    ((uint32_t)DCMI_IER_VSYNC_IE)\r
 309 #define DCMI_IT_LINE     ((uint32_t)DCMI_IER_LINE_IE)\r
 310 \r
 311 #define IS_DCMI_CONFIG_IT(IT) ((((IT) & (uint16_t)0xFFE0) == 0x0000) && ((IT) != 0x0000))\r
 312 \r
 313 #define IS_DCMI_GET_IT(IT) (((IT) == DCMI_IT_FRAME) || \\r
 314                             ((IT) == DCMI_IT_OVF)   || \\r
 315                             ((IT) == DCMI_IT_ERR)   || \\r
 316                             ((IT) == DCMI_IT_VSYNC) || \\r
 317                             ((IT) == DCMI_IT_LINE))\r
 318 /**\r
 319   * @}\r
 320   */ \r
 321 \r
 322 /** @defgroup DCMI_Flags \r
 323   * @{\r
 324   */ \r
 325 /** \r
 326   * @brief   DCMI SR register  \r
 327   */ \r
 328 #define DCMI_FLAG_HSYNC     ((uint32_t)0x2001)\r
 329 #define DCMI_FLAG_VSYNC     ((uint32_t)0x2002)\r
 330 #define DCMI_FLAG_FNE       ((uint32_t)0x2004)\r
 331 /** \r
 332   * @brief   DCMI RISR register  \r
 333   */ \r
 334 #define DCMI_FLAG_FRAMERI    ((uint32_t)DCMI_RISR_FRAME_RIS)\r
 335 #define DCMI_FLAG_OVFRI      ((uint32_t)DCMI_RISR_OVF_RIS)\r
 336 #define DCMI_FLAG_ERRRI      ((uint32_t)DCMI_RISR_ERR_RIS)\r
 337 #define DCMI_FLAG_VSYNCRI    ((uint32_t)DCMI_RISR_VSYNC_RIS)\r
 338 #define DCMI_FLAG_LINERI     ((uint32_t)DCMI_RISR_LINE_RIS)\r
 339 /** \r
 340   * @brief   DCMI MISR register  \r
 341   */ \r
 342 #define DCMI_FLAG_FRAMEMI    ((uint32_t)0x1001)\r
 343 #define DCMI_FLAG_OVFMI      ((uint32_t)0x1002)\r
 344 #define DCMI_FLAG_ERRMI      ((uint32_t)0x1004)\r
 345 #define DCMI_FLAG_VSYNCMI    ((uint32_t)0x1008)\r
 346 #define DCMI_FLAG_LINEMI     ((uint32_t)0x1010)\r
 347 #define IS_DCMI_GET_FLAG(FLAG) (((FLAG) == DCMI_FLAG_HSYNC)   || \\r
 348                                 ((FLAG) == DCMI_FLAG_VSYNC)   || \\r
 349                                 ((FLAG) == DCMI_FLAG_FNE)     || \\r
 350                                 ((FLAG) == DCMI_FLAG_FRAMERI) || \\r
 351                                 ((FLAG) == DCMI_FLAG_OVFRI)   || \\r
 352                                 ((FLAG) == DCMI_FLAG_ERRRI)   || \\r
 353                                 ((FLAG) == DCMI_FLAG_VSYNCRI) || \\r
 354                                 ((FLAG) == DCMI_FLAG_LINERI)  || \\r
 355                                 ((FLAG) == DCMI_FLAG_FRAMEMI) || \\r
 356                                 ((FLAG) == DCMI_FLAG_OVFMI)   || \\r
 357                                 ((FLAG) == DCMI_FLAG_ERRMI)   || \\r
 358                                 ((FLAG) == DCMI_FLAG_VSYNCMI) || \\r
 359                                 ((FLAG) == DCMI_FLAG_LINEMI))\r
 360                                 \r
 361 #define IS_DCMI_CLEAR_FLAG(FLAG) ((((FLAG) & (uint32_t)0xFFE0) == 0x0000) && ((FLAG) != 0x0000))\r
 362 /**\r
 363   * @}\r
 364   */ \r
 365 \r
 366 /**\r
 367   * @}\r
 368   */\r
 369   \r
 370 /* Exported macro ------------------------------------------------------------*/\r
 371 /**\r
 372   * @brief  Enable the DCMI.\r
 373   * @param  __HANDLE__: DCMI handle\r
 374   * @retval None\r
 375   */\r
 376 #define __HAL_DCMI_ENABLE(__HANDLE__)    ((__HANDLE__)->Instance->CR |= DCMI_CR_ENABLE)\r
 377 \r
 378 /**\r
 379   * @brief  Disable the DCMI.\r
 380   * @param  __HANDLE__: DCMI handle\r
 381   * @retval None\r
 382   */\r
 383 #define __HAL_DCMI_DISABLE(__HANDLE__)   ((__HANDLE__)->Instance->CR &= ~(DCMI_CR_ENABLE))\r
 384 \r
 385 /* Interrupt & Flag management */\r
 386 /**\r
 387   * @brief  Get the DCMI pending flags.\r
 388   * @param  __HANDLE__: DCMI handle\r
 389   * @param  __FLAG__: Get the specified flag.\r
 390   *         This parameter can be any combination of the following values:\r
 391   *            @arg DCMI_FLAG_FRAMERI: Frame capture complete flag mask\r
 392   *            @arg DCMI_FLAG_OVFRI: Overflow flag mask\r
 393   *            @arg DCMI_FLAG_ERRRI: Synchronization error flag mask\r
 394   *            @arg DCMI_FLAG_VSYNCRI: VSYNC flag mask\r
 395   *            @arg DCMI_FLAG_LINERI: Line flag mask\r
 396   * @retval The state of FLAG.\r
 397   */\r
 398 #define __HAL_DCMI_GET_FLAG(__HANDLE__, __FLAG__)\\r
 399 ((((__FLAG__) & 0x3000) == 0x0)? ((__HANDLE__)->Instance->RISR & (__FLAG__)) :\\r
 400  (((__FLAG__) & 0x2000) == 0x0)? ((__HANDLE__)->Instance->MISR & (__FLAG__)) : ((__HANDLE__)->Instance->SR & (__FLAG__)))\r
 401 \r
 402 /**\r
 403   * @brief  Clear the DCMI pending flags.\r
 404   * @param  __HANDLE__: DCMI handle\r
 405   * @param  __FLAG__: specifies the flag to clear.\r
 406   *         This parameter can be any combination of the following values:\r
 407   *            @arg DCMI_FLAG_FRAMERI: Frame capture complete flag mask\r
 408   *            @arg DCMI_FLAG_OVFRI: Overflow flag mask\r
 409   *            @arg DCMI_FLAG_ERRRI: Synchronization error flag mask\r
 410   *            @arg DCMI_FLAG_VSYNCRI: VSYNC flag mask\r
 411   *            @arg DCMI_FLAG_LINERI: Line flag mask\r
 412   * @retval None\r
 413   */\r
 414 #define __HAL_DCMI_CLEAR_FLAG(__HANDLE__, __FLAG__) ((__HANDLE__)->Instance->ICR |= (__FLAG__))\r
 415 \r
 416 /**\r
 417   * @brief  Enable the specified DCMI interrupts.\r
 418   * @param  __HANDLE__:    DCMI handle\r
 419   * @param  __INTERRUPT__: specifies the DCMI interrupt sources to be enabled. \r
 420   *         This parameter can be any combination of the following values:\r
 421   *            @arg DCMI_IT_FRAME: Frame capture complete interrupt mask\r
 422   *            @arg DCMI_IT_OVF: Overflow interrupt mask\r
 423   *            @arg DCMI_IT_ERR: Synchronization error interrupt mask\r
 424   *            @arg DCMI_IT_VSYNC: VSYNC interrupt mask\r
 425   *            @arg DCMI_IT_LINE: Line interrupt mask\r
 426   * @retval None\r
 427   */\r
 428 #define __HAL_DCMI_ENABLE_IT(__HANDLE__, __INTERRUPT__) ((__HANDLE__)->Instance->IER |= (__INTERRUPT__))\r
 429 \r
 430 /**\r
 431   * @brief  Disable the specified DCMI interrupts.\r
 432   * @param  __HANDLE__: DCMI handle\r
 433   * @param  __INTERRUPT__: specifies the DCMI interrupt sources to be enabled. \r
 434   *         This parameter can be any combination of the following values:\r
 435   *            @arg DCMI_IT_FRAME: Frame capture complete interrupt mask\r
 436   *            @arg DCMI_IT_OVF: Overflow interrupt mask\r
 437   *            @arg DCMI_IT_ERR: Synchronization error interrupt mask\r
 438   *            @arg DCMI_IT_VSYNC: VSYNC interrupt mask\r
 439   *            @arg DCMI_IT_LINE: Line interrupt mask\r
 440   * @retval None\r
 441   */\r
 442 #define __HAL_DCMI_DISABLE_IT(__HANDLE__, __INTERRUPT__) ((__HANDLE__)->Instance->IER &= ~(__INTERRUPT__))\r
 443 \r
 444 /**\r
 445   * @brief  Check whether the specified DCMI interrupt has occurred or not.\r
 446   * @param  __HANDLE__: DCMI handle\r
 447   * @param  __INTERRUPT__: specifies the DCMI interrupt source to check.\r
 448   *         This parameter can be one of the following values:\r
 449   *            @arg DCMI_IT_FRAME: Frame capture complete interrupt mask\r
 450   *            @arg DCMI_IT_OVF: Overflow interrupt mask\r
 451   *            @arg DCMI_IT_ERR: Synchronization error interrupt mask\r
 452   *            @arg DCMI_IT_VSYNC: VSYNC interrupt mask\r
 453   *            @arg DCMI_IT_LINE: Line interrupt mask\r
 454   * @retval The state of INTERRUPT.\r
 455   */\r
 456 #define __HAL_DCMI_GET_IT_SOURCE(__HANDLE__, __INTERRUPT__) ((__HANDLE__)->Instance->MISR & (__INTERRUPT__))\r
 457     \r
 458 /* Exported functions --------------------------------------------------------*/  \r
 459 \r
 460 /* Initialization and de-initialization functions *******************************/\r
 461 HAL_StatusTypeDef HAL_DCMI_Init(DCMI_HandleTypeDef *hdcmi);\r
 462 HAL_StatusTypeDef HAL_DCMI_DeInit(DCMI_HandleTypeDef *hdcmi);\r
 463 void       HAL_DCMI_MspInit(DCMI_HandleTypeDef* hdcmi);\r
 464 void       HAL_DCMI_MspDeInit(DCMI_HandleTypeDef* hdcmi);\r
 465 \r
 466 /* IO operation functions *******************************************************/\r
 467 HAL_StatusTypeDef HAL_DCMI_Start_DMA(DCMI_HandleTypeDef* hdcmi, uint32_t DCMI_Mode, uint32_t pData, uint32_t Length);\r
 468 HAL_StatusTypeDef HAL_DCMI_Stop(DCMI_HandleTypeDef* hdcmi);\r
 469 void       HAL_DCMI_ErrorCallback(DCMI_HandleTypeDef *hdcmi);\r
 470 void       HAL_DCMI_LineEventCallback(DCMI_HandleTypeDef *hdcmi);\r
 471 void       HAL_DCMI_FrameEventCallback(DCMI_HandleTypeDef *hdcmi);\r
 472 void       HAL_DCMI_VsyncEventCallback(DCMI_HandleTypeDef *hdcmi);\r
 473 void              HAL_DCMI_IRQHandler(DCMI_HandleTypeDef *hdcmi);\r
 474 \r
 475 /* Peripheral Control functions *************************************************/\r
 476 HAL_StatusTypeDef     HAL_DCMI_ConfigCROP(DCMI_HandleTypeDef *hdcmi, uint32_t X0, uint32_t Y0, uint32_t XSize, uint32_t YSize);\r
 477 HAL_StatusTypeDef     HAL_DCMI_EnableCROP(DCMI_HandleTypeDef *hdcmi);\r
 478 HAL_StatusTypeDef     HAL_DCMI_DisableCROP(DCMI_HandleTypeDef *hdcmi);\r
 479 \r
 480 /* Peripheral State functions ***************************************************/\r
 481 HAL_DCMI_StateTypeDef HAL_DCMI_GetState(DCMI_HandleTypeDef *hdcmi);\r
 482 uint32_t              HAL_DCMI_GetError(DCMI_HandleTypeDef *hdcmi);\r
 483 \r
 484 #endif /* STM32F405xx || STM32F415xx || STM32F407xx || STM32F417xx || STM32F427xx || STM32F437xx || STM32F429xx || STM32F439xx */\r
 485 /**\r
 486   * @}\r
 487   */ \r
 488 \r
 489 /**\r
 490   * @}\r
 491   */ \r
 492 \r
 493 #ifdef __cplusplus\r
 494 }\r
 495 #endif\r
 496 \r
 497 #endif /* __STM32F4xx_HAL_DCMI_H */\r
 498 \r
 499 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/\r