Mercurial > public > ostc4
comparison Common/Drivers/STM32F4xx_HAL_DRIVER_v120/Src/stm32f4xx_hal_dcmi.c @ 38:5f11787b4f42
include in ostc4 repository
author | heinrichsweikamp |
---|---|
date | Sat, 28 Apr 2018 11:52:34 +0200 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
37:ccc45c0e1ea2 | 38:5f11787b4f42 |
---|---|
1 /** | |
2 ****************************************************************************** | |
3 * @file stm32f4xx_hal_dcmi.c | |
4 * @author MCD Application Team | |
5 * @version V1.2.0 | |
6 * @date 26-December-2014 | |
7 * @brief DCMI HAL module driver | |
8 * This file provides firmware functions to manage the following | |
9 * functionalities of the Digital Camera Interface (DCMI) peripheral: | |
10 * + Initialization and de-initialization functions | |
11 * + IO operation functions | |
12 * + Peripheral Control functions | |
13 * + Peripheral State and Error functions | |
14 * | |
15 @verbatim | |
16 ============================================================================== | |
17 ##### How to use this driver ##### | |
18 ============================================================================== | |
19 [..] | |
20 The sequence below describes how to use this driver to capture image | |
21 from a camera module connected to the DCMI Interface. | |
22 This sequence does not take into account the configuration of the | |
23 camera module, which should be made before to configure and enable | |
24 the DCMI to capture images. | |
25 | |
26 (#) Program the required configuration through following parameters: | |
27 horizontal and vertical polarity, pixel clock polarity, Capture Rate, | |
28 Synchronization Mode, code of the frame delimiter and data width | |
29 using HAL_DCMI_Init() function. | |
30 | |
31 (#) Configure the DMA2_Stream1 channel1 to transfer Data from DCMI DR | |
32 register to the destination memory buffer. | |
33 | |
34 (#) Program the required configuration through following parameters: | |
35 DCMI mode, destination memory Buffer address and the data length | |
36 and enable capture using HAL_DCMI_Start_DMA() function. | |
37 | |
38 (#) Optionally, configure and Enable the CROP feature to select a rectangular | |
39 window from the received image using HAL_DCMI_ConfigCrop() | |
40 and HAL_DCMI_EnableCROP() functions | |
41 | |
42 (#) The capture can be stopped using HAL_DCMI_Stop() function. | |
43 | |
44 (#) To control DCMI state you can use the function HAL_DCMI_GetState(). | |
45 | |
46 *** DCMI HAL driver macros list *** | |
47 ============================================= | |
48 [..] | |
49 Below the list of most used macros in DCMI HAL driver. | |
50 | |
51 (+) __HAL_DCMI_ENABLE: Enable the DCMI peripheral. | |
52 (+) __HAL_DCMI_DISABLE: Disable the DCMI peripheral. | |
53 (+) __HAL_DCMI_GET_FLAG: Get the DCMI pending flags. | |
54 (+) __HAL_DCMI_CLEAR_FLAG: Clear the DCMI pending flags. | |
55 (+) __HAL_DCMI_ENABLE_IT: Enable the specified DCMI interrupts. | |
56 (+) __HAL_DCMI_DISABLE_IT: Disable the specified DCMI interrupts. | |
57 (+) __HAL_DCMI_GET_IT_SOURCE: Check whether the specified DCMI interrupt has occurred or not. | |
58 | |
59 [..] | |
60 (@) You can refer to the DCMI HAL driver header file for more useful macros | |
61 | |
62 @endverbatim | |
63 ****************************************************************************** | |
64 * @attention | |
65 * | |
66 * <h2><center>© COPYRIGHT(c) 2014 STMicroelectronics</center></h2> | |
67 * | |
68 * Redistribution and use in source and binary forms, with or without modification, | |
69 * are permitted provided that the following conditions are met: | |
70 * 1. Redistributions of source code must retain the above copyright notice, | |
71 * this list of conditions and the following disclaimer. | |
72 * 2. Redistributions in binary form must reproduce the above copyright notice, | |
73 * this list of conditions and the following disclaimer in the documentation | |
74 * and/or other materials provided with the distribution. | |
75 * 3. Neither the name of STMicroelectronics nor the names of its contributors | |
76 * may be used to endorse or promote products derived from this software | |
77 * without specific prior written permission. | |
78 * | |
79 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
80 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
81 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |
82 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE | |
83 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
84 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR | |
85 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER | |
86 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, | |
87 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
88 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
89 * | |
90 ****************************************************************************** | |
91 */ | |
92 | |
93 /* Includes ------------------------------------------------------------------*/ | |
94 #include "stm32f4xx_hal.h" | |
95 | |
96 /** @addtogroup STM32F4xx_HAL_Driver | |
97 * @{ | |
98 */ | |
99 /** @defgroup DCMI DCMI | |
100 * @brief DCMI HAL module driver | |
101 * @{ | |
102 */ | |
103 | |
104 #ifdef HAL_DCMI_MODULE_ENABLED | |
105 | |
106 #if defined(STM32F407xx) || defined(STM32F417xx) || defined(STM32F427xx) || defined(STM32F437xx) || defined(STM32F429xx) || defined(STM32F439xx) | |
107 /* Private typedef -----------------------------------------------------------*/ | |
108 /* Private define ------------------------------------------------------------*/ | |
109 #define HAL_TIMEOUT_DCMI_STOP ((uint32_t)1000) /* 1s */ | |
110 /* Private macro -------------------------------------------------------------*/ | |
111 /* Private variables ---------------------------------------------------------*/ | |
112 /* Private function prototypes -----------------------------------------------*/ | |
113 static void DCMI_DMAConvCplt(DMA_HandleTypeDef *hdma); | |
114 static void DCMI_DMAError(DMA_HandleTypeDef *hdma); | |
115 | |
116 /* Exported functions --------------------------------------------------------*/ | |
117 | |
118 /** @defgroup DCMI_Exported_Functions DCMI Exported Functions | |
119 * @{ | |
120 */ | |
121 | |
122 /** @defgroup DCMI_Exported_Functions_Group1 Initialization and Configuration functions | |
123 * @brief Initialization and Configuration functions | |
124 * | |
125 @verbatim | |
126 =============================================================================== | |
127 ##### Initialization and Configuration functions ##### | |
128 =============================================================================== | |
129 [..] This section provides functions allowing to: | |
130 (+) Initialize and configure the DCMI | |
131 (+) De-initialize the DCMI | |
132 | |
133 @endverbatim | |
134 * @{ | |
135 */ | |
136 | |
137 /** | |
138 * @brief Initializes the DCMI according to the specified | |
139 * parameters in the DCMI_InitTypeDef and create the associated handle. | |
140 * @param hdcmi: pointer to a DCMI_HandleTypeDef structure that contains | |
141 * the configuration information for DCMI. | |
142 * @retval HAL status | |
143 */ | |
144 HAL_StatusTypeDef HAL_DCMI_Init(DCMI_HandleTypeDef *hdcmi) | |
145 { | |
146 /* Check the DCMI peripheral state */ | |
147 if(hdcmi == NULL) | |
148 { | |
149 return HAL_ERROR; | |
150 } | |
151 | |
152 /* Check function parameters */ | |
153 assert_param(IS_DCMI_ALL_INSTANCE(hdcmi->Instance)); | |
154 assert_param(IS_DCMI_PCKPOLARITY(hdcmi->Init.PCKPolarity)); | |
155 assert_param(IS_DCMI_VSPOLARITY(hdcmi->Init.VSPolarity)); | |
156 assert_param(IS_DCMI_HSPOLARITY(hdcmi->Init.HSPolarity)); | |
157 assert_param(IS_DCMI_SYNCHRO(hdcmi->Init.SynchroMode)); | |
158 assert_param(IS_DCMI_CAPTURE_RATE(hdcmi->Init.CaptureRate)); | |
159 assert_param(IS_DCMI_EXTENDED_DATA(hdcmi->Init.ExtendedDataMode)); | |
160 assert_param(IS_DCMI_MODE_JPEG(hdcmi->Init.JPEGMode)); | |
161 | |
162 if(hdcmi->State == HAL_DCMI_STATE_RESET) | |
163 { | |
164 /* Init the low level hardware */ | |
165 HAL_DCMI_MspInit(hdcmi); | |
166 } | |
167 | |
168 /* Change the DCMI state */ | |
169 hdcmi->State = HAL_DCMI_STATE_BUSY; | |
170 /* Configures the HS, VS, DE and PC polarity */ | |
171 hdcmi->Instance->CR &= ~(DCMI_CR_PCKPOL | DCMI_CR_HSPOL | DCMI_CR_VSPOL | DCMI_CR_EDM_0 | | |
172 DCMI_CR_EDM_1 | DCMI_CR_FCRC_0 | DCMI_CR_FCRC_1 | DCMI_CR_JPEG | | |
173 DCMI_CR_ESS); | |
174 hdcmi->Instance->CR |= (uint32_t)(hdcmi->Init.SynchroMode | hdcmi->Init.CaptureRate | \ | |
175 hdcmi->Init.VSPolarity | hdcmi->Init.HSPolarity | \ | |
176 hdcmi->Init.PCKPolarity | hdcmi->Init.ExtendedDataMode | \ | |
177 hdcmi->Init.JPEGMode); | |
178 | |
179 if(hdcmi->Init.SynchroMode == DCMI_SYNCHRO_EMBEDDED) | |
180 { | |
181 DCMI->ESCR = (((uint32_t)hdcmi->Init.SyncroCode.FrameStartCode) | | |
182 ((uint32_t)hdcmi->Init.SyncroCode.LineStartCode << 8)| | |
183 ((uint32_t)hdcmi->Init.SyncroCode.LineEndCode << 16) | | |
184 ((uint32_t)hdcmi->Init.SyncroCode.FrameEndCode << 24)); | |
185 | |
186 } | |
187 | |
188 /* Enable the Line interrupt */ | |
189 __HAL_DCMI_ENABLE_IT(hdcmi, DCMI_IT_LINE); | |
190 | |
191 /* Enable the VSYNC interrupt */ | |
192 __HAL_DCMI_ENABLE_IT(hdcmi, DCMI_IT_VSYNC); | |
193 | |
194 /* Enable the Frame capture complete interrupt */ | |
195 __HAL_DCMI_ENABLE_IT(hdcmi, DCMI_IT_FRAME); | |
196 | |
197 /* Enable the Synchronization error interrupt */ | |
198 __HAL_DCMI_ENABLE_IT(hdcmi, DCMI_IT_ERR); | |
199 | |
200 /* Enable the Overflow interrupt */ | |
201 __HAL_DCMI_ENABLE_IT(hdcmi, DCMI_IT_OVF); | |
202 | |
203 /* Enable DCMI by setting DCMIEN bit */ | |
204 __HAL_DCMI_ENABLE(hdcmi); | |
205 | |
206 /* Update error code */ | |
207 hdcmi->ErrorCode = HAL_DCMI_ERROR_NONE; | |
208 | |
209 /* Initialize the DCMI state*/ | |
210 hdcmi->State = HAL_DCMI_STATE_READY; | |
211 | |
212 return HAL_OK; | |
213 } | |
214 | |
215 /** | |
216 * @brief Deinitializes the DCMI peripheral registers to their default reset | |
217 * values. | |
218 * @param hdcmi: pointer to a DCMI_HandleTypeDef structure that contains | |
219 * the configuration information for DCMI. | |
220 * @retval HAL status | |
221 */ | |
222 | |
223 HAL_StatusTypeDef HAL_DCMI_DeInit(DCMI_HandleTypeDef *hdcmi) | |
224 { | |
225 /* DeInit the low level hardware */ | |
226 HAL_DCMI_MspDeInit(hdcmi); | |
227 | |
228 /* Update error code */ | |
229 hdcmi->ErrorCode = HAL_DCMI_ERROR_NONE; | |
230 | |
231 /* Initialize the DCMI state*/ | |
232 hdcmi->State = HAL_DCMI_STATE_RESET; | |
233 | |
234 /* Release Lock */ | |
235 __HAL_UNLOCK(hdcmi); | |
236 | |
237 return HAL_OK; | |
238 } | |
239 | |
240 /** | |
241 * @brief Initializes the DCMI MSP. | |
242 * @param hdcmi: pointer to a DCMI_HandleTypeDef structure that contains | |
243 * the configuration information for DCMI. | |
244 * @retval None | |
245 */ | |
246 __weak void HAL_DCMI_MspInit(DCMI_HandleTypeDef* hdcmi) | |
247 { | |
248 /* NOTE : This function Should not be modified, when the callback is needed, | |
249 the HAL_DCMI_MspInit could be implemented in the user file | |
250 */ | |
251 } | |
252 | |
253 /** | |
254 * @brief DeInitializes the DCMI MSP. | |
255 * @param hdcmi: pointer to a DCMI_HandleTypeDef structure that contains | |
256 * the configuration information for DCMI. | |
257 * @retval None | |
258 */ | |
259 __weak void HAL_DCMI_MspDeInit(DCMI_HandleTypeDef* hdcmi) | |
260 { | |
261 /* NOTE : This function Should not be modified, when the callback is needed, | |
262 the HAL_DCMI_MspDeInit could be implemented in the user file | |
263 */ | |
264 } | |
265 | |
266 /** | |
267 * @} | |
268 */ | |
269 /** @defgroup DCMI_Exported_Functions_Group2 IO operation functions | |
270 * @brief IO operation functions | |
271 * | |
272 @verbatim | |
273 =============================================================================== | |
274 ##### IO operation functions ##### | |
275 =============================================================================== | |
276 [..] This section provides functions allowing to: | |
277 (+) Configure destination address and data length and | |
278 Enables DCMI DMA request and enables DCMI capture | |
279 (+) Stop the DCMI capture. | |
280 (+) Handles DCMI interrupt request. | |
281 | |
282 @endverbatim | |
283 * @{ | |
284 */ | |
285 | |
286 /** | |
287 * @brief Enables DCMI DMA request and enables DCMI capture | |
288 * @param hdcmi: pointer to a DCMI_HandleTypeDef structure that contains | |
289 * the configuration information for DCMI. | |
290 * @param DCMI_Mode: DCMI capture mode snapshot or continuous grab. | |
291 * @param pData: The destination memory Buffer address (LCD Frame buffer). | |
292 * @param Length: The length of capture to be transferred. | |
293 * @retval HAL status | |
294 */ | |
295 HAL_StatusTypeDef HAL_DCMI_Start_DMA(DCMI_HandleTypeDef* hdcmi, uint32_t DCMI_Mode, uint32_t pData, uint32_t Length) | |
296 { | |
297 /* Initialize the second memory address */ | |
298 uint32_t SecondMemAddress = 0; | |
299 | |
300 /* Check function parameters */ | |
301 assert_param(IS_DCMI_CAPTURE_MODE(DCMI_Mode)); | |
302 | |
303 /* Process Locked */ | |
304 __HAL_LOCK(hdcmi); | |
305 | |
306 /* Lock the DCMI peripheral state */ | |
307 hdcmi->State = HAL_DCMI_STATE_BUSY; | |
308 | |
309 /* Check the parameters */ | |
310 assert_param(IS_DCMI_CAPTURE_MODE(DCMI_Mode)); | |
311 | |
312 /* Configure the DCMI Mode */ | |
313 hdcmi->Instance->CR &= ~(DCMI_CR_CM); | |
314 hdcmi->Instance->CR |= (uint32_t)(DCMI_Mode); | |
315 | |
316 /* Set the DMA memory0 conversion complete callback */ | |
317 hdcmi->DMA_Handle->XferCpltCallback = DCMI_DMAConvCplt; | |
318 | |
319 /* Set the DMA error callback */ | |
320 hdcmi->DMA_Handle->XferErrorCallback = DCMI_DMAError; | |
321 | |
322 if(Length <= 0xFFFF) | |
323 { | |
324 /* Enable the DMA Stream */ | |
325 HAL_DMA_Start_IT(hdcmi->DMA_Handle, (uint32_t)&hdcmi->Instance->DR, (uint32_t)pData, Length); | |
326 } | |
327 else /* DCMI_DOUBLE_BUFFER Mode */ | |
328 { | |
329 /* Set the DMA memory1 conversion complete callback */ | |
330 hdcmi->DMA_Handle->XferM1CpltCallback = DCMI_DMAConvCplt; | |
331 | |
332 /* Initialize transfer parameters */ | |
333 hdcmi->XferCount = 1; | |
334 hdcmi->XferSize = Length; | |
335 hdcmi->pBuffPtr = pData; | |
336 | |
337 /* Get the number of buffer */ | |
338 while(hdcmi->XferSize > 0xFFFF) | |
339 { | |
340 hdcmi->XferSize = (hdcmi->XferSize/2); | |
341 hdcmi->XferCount = hdcmi->XferCount*2; | |
342 } | |
343 | |
344 /* Update DCMI counter and transfer number*/ | |
345 hdcmi->XferCount = (hdcmi->XferCount - 2); | |
346 hdcmi->XferTransferNumber = hdcmi->XferCount; | |
347 | |
348 /* Update second memory address */ | |
349 SecondMemAddress = (uint32_t)(pData + (4*hdcmi->XferSize)); | |
350 | |
351 /* Start DMA multi buffer transfer */ | |
352 HAL_DMAEx_MultiBufferStart_IT(hdcmi->DMA_Handle, (uint32_t)&hdcmi->Instance->DR, (uint32_t)pData, SecondMemAddress, hdcmi->XferSize); | |
353 } | |
354 | |
355 /* Enable Capture */ | |
356 DCMI->CR |= DCMI_CR_CAPTURE; | |
357 | |
358 /* Return function status */ | |
359 return HAL_OK; | |
360 } | |
361 | |
362 /** | |
363 * @brief Disable DCMI DMA request and Disable DCMI capture | |
364 * @param hdcmi: pointer to a DCMI_HandleTypeDef structure that contains | |
365 * the configuration information for DCMI. | |
366 * @retval HAL status | |
367 */ | |
368 HAL_StatusTypeDef HAL_DCMI_Stop(DCMI_HandleTypeDef* hdcmi) | |
369 { | |
370 uint32_t tickstart = 0; | |
371 | |
372 /* Lock the DCMI peripheral state */ | |
373 hdcmi->State = HAL_DCMI_STATE_BUSY; | |
374 | |
375 __HAL_DCMI_DISABLE(hdcmi); | |
376 | |
377 /* Disable Capture */ | |
378 DCMI->CR &= ~(DCMI_CR_CAPTURE); | |
379 | |
380 /* Get tick */ | |
381 tickstart = HAL_GetTick(); | |
382 | |
383 /* Check if the DCMI capture effectively disabled */ | |
384 while((hdcmi->Instance->CR & DCMI_CR_CAPTURE) != 0) | |
385 { | |
386 if((HAL_GetTick() - tickstart ) > HAL_TIMEOUT_DCMI_STOP) | |
387 { | |
388 /* Process Unlocked */ | |
389 __HAL_UNLOCK(hdcmi); | |
390 | |
391 /* Update error code */ | |
392 hdcmi->ErrorCode |= HAL_DCMI_ERROR_TIMEOUT; | |
393 | |
394 /* Change DCMI state */ | |
395 hdcmi->State = HAL_DCMI_STATE_TIMEOUT; | |
396 | |
397 return HAL_TIMEOUT; | |
398 } | |
399 } | |
400 | |
401 /* Disable the DMA */ | |
402 HAL_DMA_Abort(hdcmi->DMA_Handle); | |
403 | |
404 /* Update error code */ | |
405 hdcmi->ErrorCode |= HAL_DCMI_ERROR_NONE; | |
406 | |
407 /* Change DCMI state */ | |
408 hdcmi->State = HAL_DCMI_STATE_READY; | |
409 | |
410 /* Process Unlocked */ | |
411 __HAL_UNLOCK(hdcmi); | |
412 | |
413 /* Return function status */ | |
414 return HAL_OK; | |
415 } | |
416 | |
417 /** | |
418 * @brief Handles DCMI interrupt request. | |
419 * @param hdcmi: pointer to a DCMI_HandleTypeDef structure that contains | |
420 * the configuration information for the DCMI. | |
421 * @retval None | |
422 */ | |
423 void HAL_DCMI_IRQHandler(DCMI_HandleTypeDef *hdcmi) | |
424 { | |
425 /* Synchronization error interrupt management *******************************/ | |
426 if(__HAL_DCMI_GET_FLAG(hdcmi, DCMI_FLAG_ERRRI) != RESET) | |
427 { | |
428 if(__HAL_DCMI_GET_IT_SOURCE(hdcmi, DCMI_IT_ERR) != RESET) | |
429 { | |
430 /* Disable the Synchronization error interrupt */ | |
431 __HAL_DCMI_DISABLE_IT(hdcmi, DCMI_IT_ERR); | |
432 | |
433 /* Clear the Synchronization error flag */ | |
434 __HAL_DCMI_CLEAR_FLAG(hdcmi, DCMI_FLAG_ERRRI); | |
435 | |
436 /* Update error code */ | |
437 hdcmi->ErrorCode |= HAL_DCMI_ERROR_SYNC; | |
438 | |
439 /* Change DCMI state */ | |
440 hdcmi->State = HAL_DCMI_STATE_ERROR; | |
441 | |
442 /* Process Unlocked */ | |
443 __HAL_UNLOCK(hdcmi); | |
444 | |
445 /* Abort the DMA Transfer */ | |
446 HAL_DMA_Abort(hdcmi->DMA_Handle); | |
447 | |
448 /* Synchronization error Callback */ | |
449 HAL_DCMI_ErrorCallback(hdcmi); | |
450 } | |
451 } | |
452 /* Overflow interrupt management ********************************************/ | |
453 if(__HAL_DCMI_GET_FLAG(hdcmi, DCMI_FLAG_OVFRI) != RESET) | |
454 { | |
455 if(__HAL_DCMI_GET_IT_SOURCE(hdcmi, DCMI_IT_OVF) != RESET) | |
456 { | |
457 /* Disable the Overflow interrupt */ | |
458 __HAL_DCMI_DISABLE_IT(hdcmi, DCMI_IT_OVF); | |
459 | |
460 /* Clear the Overflow flag */ | |
461 __HAL_DCMI_CLEAR_FLAG(hdcmi, DCMI_FLAG_OVFRI); | |
462 | |
463 /* Update error code */ | |
464 hdcmi->ErrorCode |= HAL_DCMI_ERROR_OVF; | |
465 | |
466 /* Change DCMI state */ | |
467 hdcmi->State = HAL_DCMI_STATE_ERROR; | |
468 | |
469 /* Process Unlocked */ | |
470 __HAL_UNLOCK(hdcmi); | |
471 | |
472 /* Abort the DMA Transfer */ | |
473 HAL_DMA_Abort(hdcmi->DMA_Handle); | |
474 | |
475 /* Overflow Callback */ | |
476 HAL_DCMI_ErrorCallback(hdcmi); | |
477 } | |
478 } | |
479 /* Line Interrupt management ************************************************/ | |
480 if(__HAL_DCMI_GET_FLAG(hdcmi, DCMI_FLAG_LINERI) != RESET) | |
481 { | |
482 if(__HAL_DCMI_GET_IT_SOURCE(hdcmi, DCMI_IT_LINE) != RESET) | |
483 { | |
484 /* Clear the Line interrupt flag */ | |
485 __HAL_DCMI_CLEAR_FLAG(hdcmi, DCMI_FLAG_LINERI); | |
486 | |
487 /* Process Unlocked */ | |
488 __HAL_UNLOCK(hdcmi); | |
489 | |
490 /* Line interrupt Callback */ | |
491 HAL_DCMI_LineEventCallback(hdcmi); | |
492 } | |
493 } | |
494 /* VSYNC interrupt management ***********************************************/ | |
495 if(__HAL_DCMI_GET_FLAG(hdcmi, DCMI_FLAG_VSYNCRI) != RESET) | |
496 { | |
497 if(__HAL_DCMI_GET_IT_SOURCE(hdcmi, DCMI_IT_VSYNC) != RESET) | |
498 { | |
499 /* Disable the VSYNC interrupt */ | |
500 __HAL_DCMI_DISABLE_IT(hdcmi, DCMI_IT_VSYNC); | |
501 | |
502 /* Clear the VSYNC flag */ | |
503 __HAL_DCMI_CLEAR_FLAG(hdcmi, DCMI_FLAG_VSYNCRI); | |
504 | |
505 /* Process Unlocked */ | |
506 __HAL_UNLOCK(hdcmi); | |
507 | |
508 /* VSYNC Callback */ | |
509 HAL_DCMI_VsyncEventCallback(hdcmi); | |
510 } | |
511 } | |
512 /* End of Frame interrupt management ****************************************/ | |
513 if(__HAL_DCMI_GET_FLAG(hdcmi, DCMI_FLAG_FRAMERI) != RESET) | |
514 { | |
515 if(__HAL_DCMI_GET_IT_SOURCE(hdcmi, DCMI_IT_FRAME) != RESET) | |
516 { | |
517 /* Disable the End of Frame interrupt */ | |
518 __HAL_DCMI_DISABLE_IT(hdcmi, DCMI_IT_FRAME); | |
519 | |
520 /* Clear the End of Frame flag */ | |
521 __HAL_DCMI_CLEAR_FLAG(hdcmi, DCMI_FLAG_FRAMERI); | |
522 | |
523 /* Process Unlocked */ | |
524 __HAL_UNLOCK(hdcmi); | |
525 | |
526 /* End of Frame Callback */ | |
527 HAL_DCMI_FrameEventCallback(hdcmi); | |
528 } | |
529 } | |
530 } | |
531 | |
532 /** | |
533 * @brief Error DCMI callback. | |
534 * @param hdcmi: pointer to a DCMI_HandleTypeDef structure that contains | |
535 * the configuration information for DCMI. | |
536 * @retval None | |
537 */ | |
538 __weak void HAL_DCMI_ErrorCallback(DCMI_HandleTypeDef *hdcmi) | |
539 { | |
540 /* NOTE : This function Should not be modified, when the callback is needed, | |
541 the HAL_DCMI_ErrorCallback could be implemented in the user file | |
542 */ | |
543 } | |
544 | |
545 /** | |
546 * @brief Line Event callback. | |
547 * @param hdcmi: pointer to a DCMI_HandleTypeDef structure that contains | |
548 * the configuration information for DCMI. | |
549 * @retval None | |
550 */ | |
551 __weak void HAL_DCMI_LineEventCallback(DCMI_HandleTypeDef *hdcmi) | |
552 { | |
553 /* NOTE : This function Should not be modified, when the callback is needed, | |
554 the HAL_DCMI_LineEventCallback could be implemented in the user file | |
555 */ | |
556 } | |
557 | |
558 /** | |
559 * @brief VSYNC Event callback. | |
560 * @param hdcmi: pointer to a DCMI_HandleTypeDef structure that contains | |
561 * the configuration information for DCMI. | |
562 * @retval None | |
563 */ | |
564 __weak void HAL_DCMI_VsyncEventCallback(DCMI_HandleTypeDef *hdcmi) | |
565 { | |
566 /* NOTE : This function Should not be modified, when the callback is needed, | |
567 the HAL_DCMI_VsyncEventCallback could be implemented in the user file | |
568 */ | |
569 } | |
570 | |
571 /** | |
572 * @brief Frame Event callback. | |
573 * @param hdcmi: pointer to a DCMI_HandleTypeDef structure that contains | |
574 * the configuration information for DCMI. | |
575 * @retval None | |
576 */ | |
577 __weak void HAL_DCMI_FrameEventCallback(DCMI_HandleTypeDef *hdcmi) | |
578 { | |
579 /* NOTE : This function Should not be modified, when the callback is needed, | |
580 the HAL_DCMI_FrameEventCallback could be implemented in the user file | |
581 */ | |
582 } | |
583 | |
584 /** | |
585 * @} | |
586 */ | |
587 | |
588 /** @defgroup DCMI_Exported_Functions_Group3 Peripheral Control functions | |
589 * @brief Peripheral Control functions | |
590 * | |
591 @verbatim | |
592 =============================================================================== | |
593 ##### Peripheral Control functions ##### | |
594 =============================================================================== | |
595 [..] This section provides functions allowing to: | |
596 (+) Configure the CROP feature. | |
597 (+) Enable/Disable the CROP feature. | |
598 | |
599 @endverbatim | |
600 * @{ | |
601 */ | |
602 | |
603 /** | |
604 * @brief Configure the DCMI CROP coordinate. | |
605 * @param hdcmi: pointer to a DCMI_HandleTypeDef structure that contains | |
606 * the configuration information for DCMI. | |
607 * @param YSize: DCMI Line number | |
608 * @param XSize: DCMI Pixel per line | |
609 * @param X0: DCMI window X offset | |
610 * @param Y0: DCMI window Y offset | |
611 * @retval HAL status | |
612 */ | |
613 HAL_StatusTypeDef HAL_DCMI_ConfigCROP(DCMI_HandleTypeDef *hdcmi, uint32_t X0, uint32_t Y0, uint32_t XSize, uint32_t YSize) | |
614 { | |
615 /* Process Locked */ | |
616 __HAL_LOCK(hdcmi); | |
617 | |
618 /* Lock the DCMI peripheral state */ | |
619 hdcmi->State = HAL_DCMI_STATE_BUSY; | |
620 | |
621 /* Check the parameters */ | |
622 assert_param(IS_DCMI_WINDOW_COORDINATE(X0)); | |
623 assert_param(IS_DCMI_WINDOW_COORDINATE(YSize)); | |
624 assert_param(IS_DCMI_WINDOW_COORDINATE(XSize)); | |
625 assert_param(IS_DCMI_WINDOW_HEIGHT(Y0)); | |
626 | |
627 /* Configure CROP */ | |
628 DCMI->CWSIZER = (XSize | (YSize << 16)); | |
629 DCMI->CWSTRTR = (X0 | (Y0 << 16)); | |
630 | |
631 /* Initialize the DCMI state*/ | |
632 hdcmi->State = HAL_DCMI_STATE_READY; | |
633 | |
634 /* Process Unlocked */ | |
635 __HAL_UNLOCK(hdcmi); | |
636 | |
637 return HAL_OK; | |
638 } | |
639 | |
640 /** | |
641 * @brief Disable the Crop feature. | |
642 * @param hdcmi: pointer to a DCMI_HandleTypeDef structure that contains | |
643 * the configuration information for DCMI. | |
644 * @retval HAL status | |
645 */ | |
646 HAL_StatusTypeDef HAL_DCMI_DisableCROP(DCMI_HandleTypeDef *hdcmi) | |
647 { | |
648 /* Process Locked */ | |
649 __HAL_LOCK(hdcmi); | |
650 | |
651 /* Lock the DCMI peripheral state */ | |
652 hdcmi->State = HAL_DCMI_STATE_BUSY; | |
653 | |
654 /* Disable DCMI Crop feature */ | |
655 DCMI->CR &= ~(uint32_t)DCMI_CR_CROP; | |
656 | |
657 /* Change the DCMI state*/ | |
658 hdcmi->State = HAL_DCMI_STATE_READY; | |
659 | |
660 /* Process Unlocked */ | |
661 __HAL_UNLOCK(hdcmi); | |
662 | |
663 return HAL_OK; | |
664 } | |
665 | |
666 /** | |
667 * @brief Enable the Crop feature. | |
668 * @param hdcmi: pointer to a DCMI_HandleTypeDef structure that contains | |
669 * the configuration information for DCMI. | |
670 * @retval HAL status | |
671 */ | |
672 HAL_StatusTypeDef HAL_DCMI_EnableCROP(DCMI_HandleTypeDef *hdcmi) | |
673 { | |
674 /* Process Locked */ | |
675 __HAL_LOCK(hdcmi); | |
676 | |
677 /* Lock the DCMI peripheral state */ | |
678 hdcmi->State = HAL_DCMI_STATE_BUSY; | |
679 | |
680 /* Enable DCMI Crop feature */ | |
681 DCMI->CR |= (uint32_t)DCMI_CR_CROP; | |
682 | |
683 /* Change the DCMI state*/ | |
684 hdcmi->State = HAL_DCMI_STATE_READY; | |
685 | |
686 /* Process Unlocked */ | |
687 __HAL_UNLOCK(hdcmi); | |
688 | |
689 return HAL_OK; | |
690 } | |
691 | |
692 /** | |
693 * @} | |
694 */ | |
695 | |
696 /** @defgroup DCMI_Exported_Functions_Group4 Peripheral State functions | |
697 * @brief Peripheral State functions | |
698 * | |
699 @verbatim | |
700 =============================================================================== | |
701 ##### Peripheral State and Errors functions ##### | |
702 =============================================================================== | |
703 [..] | |
704 This subsection provides functions allowing to | |
705 (+) Check the DCMI state. | |
706 (+) Get the specific DCMI error flag. | |
707 | |
708 @endverbatim | |
709 * @{ | |
710 */ | |
711 | |
712 /** | |
713 * @brief Return the DCMI state | |
714 * @param hdcmi: pointer to a DCMI_HandleTypeDef structure that contains | |
715 * the configuration information for DCMI. | |
716 * @retval HAL state | |
717 */ | |
718 HAL_DCMI_StateTypeDef HAL_DCMI_GetState(DCMI_HandleTypeDef *hdcmi) | |
719 { | |
720 return hdcmi->State; | |
721 } | |
722 | |
723 /** | |
724 * @brief Return the DCMI error code | |
725 * @param hdcmi : pointer to a DCMI_HandleTypeDef structure that contains | |
726 * the configuration information for DCMI. | |
727 * @retval DCMI Error Code | |
728 */ | |
729 uint32_t HAL_DCMI_GetError(DCMI_HandleTypeDef *hdcmi) | |
730 { | |
731 return hdcmi->ErrorCode; | |
732 } | |
733 | |
734 /** | |
735 * @} | |
736 */ | |
737 /* Private functions ---------------------------------------------------------*/ | |
738 /** @defgroup DCMI_Private_Functions DCMI Private Functions | |
739 * @{ | |
740 */ | |
741 | |
742 /** | |
743 * @brief DMA conversion complete callback. | |
744 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains | |
745 * the configuration information for the specified DMA module. | |
746 * @retval None | |
747 */ | |
748 static void DCMI_DMAConvCplt(DMA_HandleTypeDef *hdma) | |
749 { | |
750 uint32_t tmp = 0; | |
751 | |
752 DCMI_HandleTypeDef* hdcmi = ( DCMI_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent; | |
753 hdcmi->State= HAL_DCMI_STATE_READY; | |
754 | |
755 if(hdcmi->XferCount != 0) | |
756 { | |
757 /* Update memory 0 address location */ | |
758 tmp = ((hdcmi->DMA_Handle->Instance->CR) & DMA_SxCR_CT); | |
759 if(((hdcmi->XferCount % 2) == 0) && (tmp != 0)) | |
760 { | |
761 tmp = hdcmi->DMA_Handle->Instance->M0AR; | |
762 HAL_DMAEx_ChangeMemory(hdcmi->DMA_Handle, (tmp + (8*hdcmi->XferSize)), MEMORY0); | |
763 hdcmi->XferCount--; | |
764 } | |
765 /* Update memory 1 address location */ | |
766 else if((hdcmi->DMA_Handle->Instance->CR & DMA_SxCR_CT) == 0) | |
767 { | |
768 tmp = hdcmi->DMA_Handle->Instance->M1AR; | |
769 HAL_DMAEx_ChangeMemory(hdcmi->DMA_Handle, (tmp + (8*hdcmi->XferSize)), MEMORY1); | |
770 hdcmi->XferCount--; | |
771 } | |
772 } | |
773 /* Update memory 0 address location */ | |
774 else if((hdcmi->DMA_Handle->Instance->CR & DMA_SxCR_CT) != 0) | |
775 { | |
776 hdcmi->DMA_Handle->Instance->M0AR = hdcmi->pBuffPtr; | |
777 } | |
778 /* Update memory 1 address location */ | |
779 else if((hdcmi->DMA_Handle->Instance->CR & DMA_SxCR_CT) == 0) | |
780 { | |
781 tmp = hdcmi->pBuffPtr; | |
782 hdcmi->DMA_Handle->Instance->M1AR = (tmp + (4*hdcmi->XferSize)); | |
783 hdcmi->XferCount = hdcmi->XferTransferNumber; | |
784 } | |
785 | |
786 if(__HAL_DCMI_GET_FLAG(hdcmi, DCMI_FLAG_FRAMERI) != RESET) | |
787 { | |
788 /* Process Unlocked */ | |
789 __HAL_UNLOCK(hdcmi); | |
790 | |
791 /* FRAME Callback */ | |
792 HAL_DCMI_FrameEventCallback(hdcmi); | |
793 } | |
794 } | |
795 | |
796 /** | |
797 * @brief DMA error callback | |
798 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains | |
799 * the configuration information for the specified DMA module. | |
800 * @retval None | |
801 */ | |
802 static void DCMI_DMAError(DMA_HandleTypeDef *hdma) | |
803 { | |
804 DCMI_HandleTypeDef* hdcmi = ( DCMI_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent; | |
805 hdcmi->State= HAL_DCMI_STATE_READY; | |
806 HAL_DCMI_ErrorCallback(hdcmi); | |
807 } | |
808 | |
809 /** | |
810 * @} | |
811 */ | |
812 | |
813 /** | |
814 * @} | |
815 */ | |
816 #endif /* STM32F405xx || STM32F415xx || STM32F407xx || STM32F417xx || STM32F427xx || STM32F437xx || STM32F429xx || STM32F439xx */ | |
817 #endif /* HAL_DCMI_MODULE_ENABLED */ | |
818 /** | |
819 * @} | |
820 */ | |
821 | |
822 /** | |
823 * @} | |
824 */ | |
825 | |
826 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ |