|
38
|
1 /**
|
|
|
2 ******************************************************************************
|
|
|
3 * @file stm32f4xx_hal_ltdc.c
|
|
|
4 * @author MCD Application Team
|
|
|
5 * @version V1.2.0
|
|
|
6 * @date 26-December-2014
|
|
|
7 * @brief LTDC HAL module driver.
|
|
|
8 * This file provides firmware functions to manage the following
|
|
|
9 * functionalities of the LTDC peripheral:
|
|
|
10 * + Initialization and de-initialization functions
|
|
|
11 * + IO operation functions
|
|
|
12 * + Peripheral Control functions
|
|
|
13 * + Peripheral State and Errors functions
|
|
|
14 *
|
|
|
15 @verbatim
|
|
|
16 ==============================================================================
|
|
|
17 ##### How to use this driver #####
|
|
|
18 ==============================================================================
|
|
|
19 [..]
|
|
|
20 (#) Program the required configuration through the following parameters:
|
|
|
21 the LTDC timing, the horizontal and vertical polarity,
|
|
|
22 the pixel clock polarity, Data Enable polarity and the LTDC background color value
|
|
|
23 using HAL_LTDC_Init() function
|
|
|
24
|
|
|
25 (#) Program the required configuration through the following parameters:
|
|
|
26 the pixel format, the blending factors, input alpha value, the window size
|
|
|
27 and the image size using HAL_LTDC_ConfigLayer() function for foreground
|
|
|
28 or/and background layer.
|
|
|
29
|
|
|
30 (#) Optionally, configure and enable the CLUT using HAL_LTDC_ConfigCLUT() and
|
|
|
31 HAL_LTDC_EnableCLUT functions.
|
|
|
32
|
|
|
33 (#) Optionally, enable the Dither using HAL_LTDC_EnableDither().
|
|
|
34
|
|
|
35 (#) Optionally, configure and enable the Color keying using HAL_LTDC_ConfigColorKeying()
|
|
|
36 and HAL_LTDC_EnableColorKeying functions.
|
|
|
37
|
|
|
38 (#) Optionally, configure LineInterrupt using HAL_LTDC_ProgramLineEvent()
|
|
|
39 function
|
|
|
40
|
|
|
41 (#) If needed, reconfigure and change the pixel format value, the alpha value
|
|
|
42 value, the window size, the window position and the layer start address
|
|
|
43 for foreground or/and background layer using respectively the following
|
|
|
44 functions: HAL_LTDC_SetPixelFormat(), HAL_LTDC_SetAlpha(), HAL_LTDC_SetWindowSize(),
|
|
|
45 HAL_LTDC_SetWindowPosition(), HAL_LTDC_SetAddress.
|
|
|
46
|
|
|
47 (#) To control LTDC state you can use the following function: HAL_LTDC_GetState()
|
|
|
48
|
|
|
49 *** LTDC HAL driver macros list ***
|
|
|
50 =============================================
|
|
|
51 [..]
|
|
|
52 Below the list of most used macros in LTDC HAL driver.
|
|
|
53
|
|
|
54 (+) __HAL_LTDC_ENABLE: Enable the LTDC.
|
|
|
55 (+) __HAL_LTDC_DISABLE: Disable the LTDC.
|
|
|
56 (+) __HAL_LTDC_LAYER_ENABLE: Enable the LTDC Layer.
|
|
|
57 (+) __HAL_LTDC_LAYER_DISABLE: Disable the LTDC Layer.
|
|
|
58 (+) __HAL_LTDC_RELOAD_CONFIG: Reload Layer Configuration.
|
|
|
59 (+) __HAL_LTDC_GET_FLAG: Get the LTDC pending flags.
|
|
|
60 (+) __HAL_LTDC_CLEAR_FLAG: Clear the LTDC pending flags.
|
|
|
61 (+) __HAL_LTDC_ENABLE_IT: Enable the specified LTDC interrupts.
|
|
|
62 (+) __HAL_LTDC_DISABLE_IT: Disable the specified LTDC interrupts.
|
|
|
63 (+) __HAL_LTDC_GET_IT_SOURCE: Check whether the specified LTDC interrupt has occurred or not.
|
|
|
64
|
|
|
65 [..]
|
|
|
66 (@) You can refer to the LTDC HAL driver header file for more useful macros
|
|
|
67
|
|
|
68 @endverbatim
|
|
|
69 ******************************************************************************
|
|
|
70 * @attention
|
|
|
71 *
|
|
|
72 * <h2><center>© COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
|
|
|
73 *
|
|
|
74 * Redistribution and use in source and binary forms, with or without modification,
|
|
|
75 * are permitted provided that the following conditions are met:
|
|
|
76 * 1. Redistributions of source code must retain the above copyright notice,
|
|
|
77 * this list of conditions and the following disclaimer.
|
|
|
78 * 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
|
79 * this list of conditions and the following disclaimer in the documentation
|
|
|
80 * and/or other materials provided with the distribution.
|
|
|
81 * 3. Neither the name of STMicroelectronics nor the names of its contributors
|
|
|
82 * may be used to endorse or promote products derived from this software
|
|
|
83 * without specific prior written permission.
|
|
|
84 *
|
|
|
85 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
|
86 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
87 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
|
88 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
|
|
89 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
90 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
|
91 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
|
92 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
|
93 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
94 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
95 *
|
|
|
96 ******************************************************************************
|
|
|
97 */
|
|
|
98
|
|
|
99 /* Includes ------------------------------------------------------------------*/
|
|
|
100 #include "stm32f4xx_hal.h"
|
|
|
101
|
|
|
102 /** @addtogroup STM32F4xx_HAL_Driver
|
|
|
103 * @{
|
|
|
104 */
|
|
|
105 /** @defgroup LTDC LTDC
|
|
|
106 * @brief LTDC HAL module driver
|
|
|
107 * @{
|
|
|
108 */
|
|
|
109
|
|
|
110 #ifdef HAL_LTDC_MODULE_ENABLED
|
|
|
111
|
|
|
112 #if defined(STM32F429xx) || defined(STM32F439xx)
|
|
|
113
|
|
|
114 /* Private typedef -----------------------------------------------------------*/
|
|
|
115 /* Private define ------------------------------------------------------------*/
|
|
|
116 /* Private macro -------------------------------------------------------------*/
|
|
|
117 /* Private variables ---------------------------------------------------------*/
|
|
|
118 /* Private function prototypes -----------------------------------------------*/
|
|
|
119 static void LTDC_SetConfig(LTDC_HandleTypeDef *hltdc, LTDC_LayerCfgTypeDef *pLayerCfg, uint32_t LayerIdx);
|
|
|
120 /* Private functions ---------------------------------------------------------*/
|
|
|
121
|
|
|
122 /** @defgroup LTDC_Exported_Functions LTDC Exported Functions
|
|
|
123 * @{
|
|
|
124 */
|
|
|
125
|
|
|
126 /** @defgroup LTDC_Exported_Functions_Group1 Initialization and Configuration functions
|
|
|
127 * @brief Initialization and Configuration functions
|
|
|
128 *
|
|
|
129 @verbatim
|
|
|
130 ===============================================================================
|
|
|
131 ##### Initialization and Configuration functions #####
|
|
|
132 ===============================================================================
|
|
|
133 [..] This section provides functions allowing to:
|
|
|
134 (+) Initialize and configure the LTDC
|
|
|
135 (+) De-initialize the LTDC
|
|
|
136
|
|
|
137 @endverbatim
|
|
|
138 * @{
|
|
|
139 */
|
|
|
140
|
|
|
141 /**
|
|
|
142 * @brief Initializes the LTDC according to the specified
|
|
|
143 * parameters in the LTDC_InitTypeDef and create the associated handle.
|
|
|
144 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
|
|
|
145 * the configuration information for the LTDC.
|
|
|
146 * @retval HAL status
|
|
|
147 */
|
|
|
148 HAL_StatusTypeDef HAL_LTDC_Init(LTDC_HandleTypeDef *hltdc)
|
|
|
149 {
|
|
|
150 uint32_t tmp = 0, tmp1 = 0;
|
|
|
151
|
|
|
152 /* Check the LTDC peripheral state */
|
|
|
153 if(hltdc == NULL)
|
|
|
154 {
|
|
|
155 return HAL_ERROR;
|
|
|
156 }
|
|
|
157
|
|
|
158 /* Check function parameters */
|
|
|
159 assert_param(IS_LTDC_ALL_INSTANCE(hltdc->Instance));
|
|
|
160 assert_param(IS_LTDC_HSYNC(hltdc->Init.HorizontalSync));
|
|
|
161 assert_param(IS_LTDC_VSYNC(hltdc->Init.VerticalSync));
|
|
|
162 assert_param(IS_LTDC_AHBP(hltdc->Init.AccumulatedHBP));
|
|
|
163 assert_param(IS_LTDC_AVBP(hltdc->Init.AccumulatedVBP));
|
|
|
164 assert_param(IS_LTDC_AAH(hltdc->Init.AccumulatedActiveH));
|
|
|
165 assert_param(IS_LTDC_AAW(hltdc->Init.AccumulatedActiveW));
|
|
|
166 assert_param(IS_LTDC_TOTALH(hltdc->Init.TotalHeigh));
|
|
|
167 assert_param(IS_LTDC_TOTALW(hltdc->Init.TotalWidth));
|
|
|
168 assert_param(IS_LTDC_HSPOL(hltdc->Init.HSPolarity));
|
|
|
169 assert_param(IS_LTDC_VSPOL(hltdc->Init.VSPolarity));
|
|
|
170 assert_param(IS_LTDC_DEPOL(hltdc->Init.DEPolarity));
|
|
|
171 assert_param(IS_LTDC_PCPOL(hltdc->Init.PCPolarity));
|
|
|
172
|
|
|
173 if(hltdc->State == HAL_LTDC_STATE_RESET)
|
|
|
174 {
|
|
|
175 /* Init the low level hardware */
|
|
|
176 HAL_LTDC_MspInit(hltdc);
|
|
|
177 }
|
|
|
178
|
|
|
179 /* Change LTDC peripheral state */
|
|
|
180 hltdc->State = HAL_LTDC_STATE_BUSY;
|
|
|
181
|
|
|
182 /* Configures the HS, VS, DE and PC polarity */
|
|
|
183 hltdc->Instance->GCR &= ~(LTDC_GCR_HSPOL | LTDC_GCR_VSPOL | LTDC_GCR_DEPOL | LTDC_GCR_PCPOL);
|
|
|
184 hltdc->Instance->GCR |= (uint32_t)(hltdc->Init.HSPolarity | hltdc->Init.VSPolarity | \
|
|
|
185 hltdc->Init.DEPolarity | hltdc->Init.PCPolarity);
|
|
|
186
|
|
|
187 /* Sets Synchronization size */
|
|
|
188 hltdc->Instance->SSCR &= ~(LTDC_SSCR_VSH | LTDC_SSCR_HSW);
|
|
|
189 tmp = (hltdc->Init.HorizontalSync << 16);
|
|
|
190 hltdc->Instance->SSCR |= (tmp | hltdc->Init.VerticalSync);
|
|
|
191
|
|
|
192 /* Sets Accumulated Back porch */
|
|
|
193 hltdc->Instance->BPCR &= ~(LTDC_BPCR_AVBP | LTDC_BPCR_AHBP);
|
|
|
194 tmp = (hltdc->Init.AccumulatedHBP << 16);
|
|
|
195 hltdc->Instance->BPCR |= (tmp | hltdc->Init.AccumulatedVBP);
|
|
|
196
|
|
|
197 /* Sets Accumulated Active Width */
|
|
|
198 hltdc->Instance->AWCR &= ~(LTDC_AWCR_AAH | LTDC_AWCR_AAW);
|
|
|
199 tmp = (hltdc->Init.AccumulatedActiveW << 16);
|
|
|
200 hltdc->Instance->AWCR |= (tmp | hltdc->Init.AccumulatedActiveH);
|
|
|
201
|
|
|
202 /* Sets Total Width */
|
|
|
203 hltdc->Instance->TWCR &= ~(LTDC_TWCR_TOTALH | LTDC_TWCR_TOTALW);
|
|
|
204 tmp = (hltdc->Init.TotalWidth << 16);
|
|
|
205 hltdc->Instance->TWCR |= (tmp | hltdc->Init.TotalHeigh);
|
|
|
206
|
|
|
207 /* Sets the background color value */
|
|
|
208 tmp = ((uint32_t)(hltdc->Init.Backcolor.Green) << 8);
|
|
|
209 tmp1 = ((uint32_t)(hltdc->Init.Backcolor.Red) << 16);
|
|
|
210 hltdc->Instance->BCCR &= ~(LTDC_BCCR_BCBLUE | LTDC_BCCR_BCGREEN | LTDC_BCCR_BCRED);
|
|
|
211 hltdc->Instance->BCCR |= (tmp1 | tmp | hltdc->Init.Backcolor.Blue);
|
|
|
212
|
|
|
213 /* Enable the transfer Error interrupt */
|
|
|
214 __HAL_LTDC_ENABLE_IT(hltdc, LTDC_IT_TE);
|
|
|
215
|
|
|
216 /* Enable the FIFO underrun interrupt */
|
|
|
217 __HAL_LTDC_ENABLE_IT(hltdc, LTDC_IT_FU);
|
|
|
218
|
|
|
219 /* Enable LTDC by setting LTDCEN bit */
|
|
|
220 __HAL_LTDC_ENABLE(hltdc);
|
|
|
221
|
|
|
222 /* Initialize the error code */
|
|
|
223 hltdc->ErrorCode = HAL_LTDC_ERROR_NONE;
|
|
|
224
|
|
|
225 /* Initialize the LTDC state*/
|
|
|
226 hltdc->State = HAL_LTDC_STATE_READY;
|
|
|
227
|
|
|
228 return HAL_OK;
|
|
|
229 }
|
|
|
230
|
|
|
231 /**
|
|
|
232 * @brief Deinitializes the LTDC peripheral registers to their default reset
|
|
|
233 * values.
|
|
|
234 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
|
|
|
235 * the configuration information for the LTDC.
|
|
|
236 * @retval None
|
|
|
237 */
|
|
|
238
|
|
|
239 HAL_StatusTypeDef HAL_LTDC_DeInit(LTDC_HandleTypeDef *hltdc)
|
|
|
240 {
|
|
|
241 /* DeInit the low level hardware */
|
|
|
242 HAL_LTDC_MspDeInit(hltdc);
|
|
|
243
|
|
|
244 /* Initialize the error code */
|
|
|
245 hltdc->ErrorCode = HAL_LTDC_ERROR_NONE;
|
|
|
246
|
|
|
247 /* Initialize the LTDC state*/
|
|
|
248 hltdc->State = HAL_LTDC_STATE_RESET;
|
|
|
249
|
|
|
250 /* Release Lock */
|
|
|
251 __HAL_UNLOCK(hltdc);
|
|
|
252
|
|
|
253 return HAL_OK;
|
|
|
254 }
|
|
|
255
|
|
|
256 /**
|
|
|
257 * @brief Initializes the LTDC MSP.
|
|
|
258 * @param hltdc : pointer to a LTDC_HandleTypeDef structure that contains
|
|
|
259 * the configuration information for the LTDC.
|
|
|
260 * @retval None
|
|
|
261 */
|
|
|
262 __weak void HAL_LTDC_MspInit(LTDC_HandleTypeDef* hltdc)
|
|
|
263 {
|
|
|
264 /* NOTE : This function Should not be modified, when the callback is needed,
|
|
|
265 the HAL_LTDC_MspInit could be implemented in the user file
|
|
|
266 */
|
|
|
267 }
|
|
|
268
|
|
|
269 /**
|
|
|
270 * @brief DeInitializes the LTDC MSP.
|
|
|
271 * @param hltdc : pointer to a LTDC_HandleTypeDef structure that contains
|
|
|
272 * the configuration information for the LTDC.
|
|
|
273 * @retval None
|
|
|
274 */
|
|
|
275 __weak void HAL_LTDC_MspDeInit(LTDC_HandleTypeDef* hltdc)
|
|
|
276 {
|
|
|
277 /* NOTE : This function Should not be modified, when the callback is needed,
|
|
|
278 the HAL_LTDC_MspDeInit could be implemented in the user file
|
|
|
279 */
|
|
|
280 }
|
|
|
281
|
|
|
282 /**
|
|
|
283 * @}
|
|
|
284 */
|
|
|
285
|
|
|
286 /** @defgroup LTDC_Exported_Functions_Group2 IO operation functions
|
|
|
287 * @brief IO operation functions
|
|
|
288 *
|
|
|
289 @verbatim
|
|
|
290 ===============================================================================
|
|
|
291 ##### IO operation functions #####
|
|
|
292 ===============================================================================
|
|
|
293 [..] This section provides function allowing to:
|
|
|
294 (+) Handle LTDC interrupt request
|
|
|
295
|
|
|
296 @endverbatim
|
|
|
297 * @{
|
|
|
298 */
|
|
|
299 /**
|
|
|
300 * @brief Handles LTDC interrupt request.
|
|
|
301 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
|
|
|
302 * the configuration information for the LTDC.
|
|
|
303 * @retval HAL status
|
|
|
304 */
|
|
|
305 void HAL_LTDC_IRQHandler(LTDC_HandleTypeDef *hltdc)
|
|
|
306 {
|
|
|
307 /* Transfer Error Interrupt management ***************************************/
|
|
|
308 if(__HAL_LTDC_GET_FLAG(hltdc, LTDC_FLAG_TE) != RESET)
|
|
|
309 {
|
|
|
310 if(__HAL_LTDC_GET_IT_SOURCE(hltdc, LTDC_IT_TE) != RESET)
|
|
|
311 {
|
|
|
312 /* Disable the transfer Error interrupt */
|
|
|
313 __HAL_LTDC_DISABLE_IT(hltdc, LTDC_IT_TE);
|
|
|
314
|
|
|
315 /* Clear the transfer error flag */
|
|
|
316 __HAL_LTDC_CLEAR_FLAG(hltdc, LTDC_FLAG_TE);
|
|
|
317
|
|
|
318 /* Update error code */
|
|
|
319 hltdc->ErrorCode |= HAL_LTDC_ERROR_TE;
|
|
|
320
|
|
|
321 /* Change LTDC state */
|
|
|
322 hltdc->State = HAL_LTDC_STATE_ERROR;
|
|
|
323
|
|
|
324 /* Process unlocked */
|
|
|
325 __HAL_UNLOCK(hltdc);
|
|
|
326
|
|
|
327 /* Transfer error Callback */
|
|
|
328 HAL_LTDC_ErrorCallback(hltdc);
|
|
|
329 }
|
|
|
330 }
|
|
|
331 /* FIFO underrun Interrupt management ***************************************/
|
|
|
332 if(__HAL_LTDC_GET_FLAG(hltdc, LTDC_FLAG_FU) != RESET)
|
|
|
333 {
|
|
|
334 if(__HAL_LTDC_GET_IT_SOURCE(hltdc, LTDC_IT_FU) != RESET)
|
|
|
335 {
|
|
|
336 /* Disable the FIFO underrun interrupt */
|
|
|
337 __HAL_LTDC_DISABLE_IT(hltdc, LTDC_IT_FU);
|
|
|
338
|
|
|
339 /* Clear the FIFO underrun flag */
|
|
|
340 __HAL_LTDC_CLEAR_FLAG(hltdc, LTDC_FLAG_FU);
|
|
|
341
|
|
|
342 /* Update error code */
|
|
|
343 hltdc->ErrorCode |= HAL_LTDC_ERROR_FU;
|
|
|
344
|
|
|
345 /* Change LTDC state */
|
|
|
346 hltdc->State = HAL_LTDC_STATE_ERROR;
|
|
|
347
|
|
|
348 /* Process unlocked */
|
|
|
349 __HAL_UNLOCK(hltdc);
|
|
|
350
|
|
|
351 /* Transfer error Callback */
|
|
|
352 HAL_LTDC_ErrorCallback(hltdc);
|
|
|
353 }
|
|
|
354 }
|
|
|
355 /* Line Interrupt management ************************************************/
|
|
|
356 if(__HAL_LTDC_GET_FLAG(hltdc, LTDC_FLAG_LI) != RESET)
|
|
|
357 {
|
|
|
358 if(__HAL_LTDC_GET_IT_SOURCE(hltdc, LTDC_IT_LI) != RESET)
|
|
|
359 {
|
|
|
360 /* Disable the Line interrupt */
|
|
|
361 __HAL_LTDC_DISABLE_IT(hltdc, LTDC_IT_LI);
|
|
|
362
|
|
|
363 /* Clear the Line interrupt flag */
|
|
|
364 __HAL_LTDC_CLEAR_FLAG(hltdc, LTDC_FLAG_LI);
|
|
|
365
|
|
|
366 /* Change LTDC state */
|
|
|
367 hltdc->State = HAL_LTDC_STATE_READY;
|
|
|
368
|
|
|
369 /* Process unlocked */
|
|
|
370 __HAL_UNLOCK(hltdc);
|
|
|
371
|
|
|
372 /* Line interrupt Callback */
|
|
|
373 HAL_LTDC_LineEvenCallback(hltdc);
|
|
|
374 }
|
|
|
375 }
|
|
|
376 }
|
|
|
377
|
|
|
378 /**
|
|
|
379 * @brief Error LTDC callback.
|
|
|
380 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
|
|
|
381 * the configuration information for the LTDC.
|
|
|
382 * @retval None
|
|
|
383 */
|
|
|
384 __weak void HAL_LTDC_ErrorCallback(LTDC_HandleTypeDef *hltdc)
|
|
|
385 {
|
|
|
386 /* NOTE : This function Should not be modified, when the callback is needed,
|
|
|
387 the HAL_LTDC_ErrorCallback could be implemented in the user file
|
|
|
388 */
|
|
|
389 }
|
|
|
390
|
|
|
391 /**
|
|
|
392 * @brief Line Event callback.
|
|
|
393 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
|
|
|
394 * the configuration information for the LTDC.
|
|
|
395 * @retval None
|
|
|
396 */
|
|
|
397 __weak void HAL_LTDC_LineEvenCallback(LTDC_HandleTypeDef *hltdc)
|
|
|
398 {
|
|
|
399 /* NOTE : This function Should not be modified, when the callback is needed,
|
|
|
400 the HAL_LTDC_LineEvenCallback could be implemented in the user file
|
|
|
401 */
|
|
|
402 }
|
|
|
403
|
|
|
404 /**
|
|
|
405 * @}
|
|
|
406 */
|
|
|
407
|
|
|
408 /** @defgroup LTDC_Exported_Functions_Group3 Peripheral Control functions
|
|
|
409 * @brief Peripheral Control functions
|
|
|
410 *
|
|
|
411 @verbatim
|
|
|
412 ===============================================================================
|
|
|
413 ##### Peripheral Control functions #####
|
|
|
414 ===============================================================================
|
|
|
415 [..] This section provides functions allowing to:
|
|
|
416 (+) Configure the LTDC foreground or/and background parameters.
|
|
|
417 (+) Set the active layer.
|
|
|
418 (+) Configure the color keying.
|
|
|
419 (+) Configure the C-LUT.
|
|
|
420 (+) Enable / Disable the color keying.
|
|
|
421 (+) Enable / Disable the C-LUT.
|
|
|
422 (+) Update the layer position.
|
|
|
423 (+) Update the layer size.
|
|
|
424 (+) Update pixel format on the fly.
|
|
|
425 (+) Update transparency on the fly.
|
|
|
426 (+) Update address on the fly.
|
|
|
427
|
|
|
428 @endverbatim
|
|
|
429 * @{
|
|
|
430 */
|
|
|
431
|
|
|
432 /**
|
|
|
433 * @brief Configure the LTDC Layer according to the specified
|
|
|
434 * parameters in the LTDC_InitTypeDef and create the associated handle.
|
|
|
435 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
|
|
|
436 * the configuration information for the LTDC.
|
|
|
437 * @param pLayerCfg: pointer to a LTDC_LayerCfgTypeDef structure that contains
|
|
|
438 * the configuration information for the Layer.
|
|
|
439 * @param LayerIdx: LTDC Layer index.
|
|
|
440 * This parameter can be one of the following values:
|
|
|
441 * 0 or 1
|
|
|
442 * @retval HAL status
|
|
|
443 */
|
|
|
444 HAL_StatusTypeDef HAL_LTDC_ConfigLayer(LTDC_HandleTypeDef *hltdc, LTDC_LayerCfgTypeDef *pLayerCfg, uint32_t LayerIdx)
|
|
|
445 {
|
|
|
446 /* Process locked */
|
|
|
447 __HAL_LOCK(hltdc);
|
|
|
448
|
|
|
449 /* Change LTDC peripheral state */
|
|
|
450 hltdc->State = HAL_LTDC_STATE_BUSY;
|
|
|
451
|
|
|
452 /* Check the parameters */
|
|
|
453 assert_param(IS_LTDC_LAYER(LayerIdx));
|
|
|
454 assert_param(IS_LTDC_PIXEL_FORMAT(pLayerCfg->PixelFormat));
|
|
|
455 assert_param(IS_LTDC_BLENDING_FACTOR1(pLayerCfg->BlendingFactor1));
|
|
|
456 assert_param(IS_LTDC_BLENDING_FACTOR2(pLayerCfg->BlendingFactor2));
|
|
|
457 assert_param(IS_LTDC_HCONFIGST(pLayerCfg->WindowX0));
|
|
|
458 assert_param(IS_LTDC_HCONFIGSP(pLayerCfg->WindowX1));
|
|
|
459 assert_param(IS_LTDC_VCONFIGST(pLayerCfg->WindowY0));
|
|
|
460 assert_param(IS_LTDC_VCONFIGSP(pLayerCfg->WindowY1));
|
|
|
461 assert_param(IS_LTDC_ALPHA(pLayerCfg->Alpha0));
|
|
|
462 assert_param(IS_LTDC_CFBLL(pLayerCfg->ImageWidth));
|
|
|
463 assert_param(IS_LTDC_CFBLNBR(pLayerCfg->ImageHeight));
|
|
|
464
|
|
|
465 /* Copy new layer configuration into handle structure */
|
|
|
466 hltdc->LayerCfg[LayerIdx] = *pLayerCfg;
|
|
|
467
|
|
|
468 /* Configure the LTDC Layer */
|
|
|
469 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
|
|
|
470
|
|
|
471 /* Sets the Reload type */
|
|
|
472 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
|
|
|
473
|
|
|
474 /* Initialize the LTDC state*/
|
|
|
475 hltdc->State = HAL_LTDC_STATE_READY;
|
|
|
476
|
|
|
477 /* Process unlocked */
|
|
|
478 __HAL_UNLOCK(hltdc);
|
|
|
479
|
|
|
480 return HAL_OK;
|
|
|
481 }
|
|
|
482
|
|
|
483 /**
|
|
|
484 * @brief Configure the color keying.
|
|
|
485 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
|
|
|
486 * the configuration information for the LTDC.
|
|
|
487 * @param RGBValue: the color key value
|
|
|
488 * @param LayerIdx: LTDC Layer index.
|
|
|
489 * This parameter can be one of the following values:
|
|
|
490 * 0 or 1
|
|
|
491 * @retval HAL status
|
|
|
492 */
|
|
|
493 HAL_StatusTypeDef HAL_LTDC_ConfigColorKeying(LTDC_HandleTypeDef *hltdc, uint32_t RGBValue, uint32_t LayerIdx)
|
|
|
494 {
|
|
|
495 /* Process locked */
|
|
|
496 __HAL_LOCK(hltdc);
|
|
|
497
|
|
|
498 /* Change LTDC peripheral state */
|
|
|
499 hltdc->State = HAL_LTDC_STATE_BUSY;
|
|
|
500
|
|
|
501 /* Check the parameters */
|
|
|
502 assert_param(IS_LTDC_LAYER(LayerIdx));
|
|
|
503
|
|
|
504 /* Configures the default color values */
|
|
|
505 LTDC_LAYER(hltdc, LayerIdx)->CKCR &= ~(LTDC_LxCKCR_CKBLUE | LTDC_LxCKCR_CKGREEN | LTDC_LxCKCR_CKRED);
|
|
|
506 LTDC_LAYER(hltdc, LayerIdx)->CKCR = RGBValue;
|
|
|
507
|
|
|
508 /* Sets the Reload type */
|
|
|
509 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
|
|
|
510
|
|
|
511 /* Change the LTDC state*/
|
|
|
512 hltdc->State = HAL_LTDC_STATE_READY;
|
|
|
513
|
|
|
514 /* Process unlocked */
|
|
|
515 __HAL_UNLOCK(hltdc);
|
|
|
516
|
|
|
517 return HAL_OK;
|
|
|
518 }
|
|
|
519
|
|
|
520 /**
|
|
|
521 * @brief Load the color lookup table.
|
|
|
522 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
|
|
|
523 * the configuration information for the LTDC.
|
|
|
524 * @param pCLUT: pointer to the color lookup table address.
|
|
|
525 * @param CLUTSize: the color lookup table size.
|
|
|
526 * @param LayerIdx: LTDC Layer index.
|
|
|
527 * This parameter can be one of the following values:
|
|
|
528 * 0 or 1
|
|
|
529 * @retval HAL status
|
|
|
530 */
|
|
|
531 HAL_StatusTypeDef HAL_LTDC_ConfigCLUT(LTDC_HandleTypeDef *hltdc, uint32_t *pCLUT, uint32_t CLUTSize, uint32_t LayerIdx)
|
|
|
532 {
|
|
|
533 uint32_t tmp = 0;
|
|
|
534 uint32_t counter = 0;
|
|
|
535 uint32_t pcounter = 0;
|
|
|
536
|
|
|
537 /* Process locked */
|
|
|
538 __HAL_LOCK(hltdc);
|
|
|
539
|
|
|
540 /* Change LTDC peripheral state */
|
|
|
541 hltdc->State = HAL_LTDC_STATE_BUSY;
|
|
|
542
|
|
|
543 /* Check the parameters */
|
|
|
544 assert_param(IS_LTDC_LAYER(LayerIdx));
|
|
|
545
|
|
|
546 for(counter = 0; (counter < CLUTSize); counter++)
|
|
|
547 {
|
|
|
548 if(hltdc->LayerCfg[LayerIdx].PixelFormat == LTDC_PIXEL_FORMAT_AL44)
|
|
|
549 {
|
|
|
550 tmp = (((counter + 16*counter) << 24) | ((uint32_t)(*pCLUT) & 0xFF) | ((uint32_t)(*pCLUT) & 0xFF00) | ((uint32_t)(*pCLUT) & 0xFF0000));
|
|
|
551 }
|
|
|
552 else
|
|
|
553 {
|
|
|
554 tmp = ((counter << 24) | ((uint32_t)(*pCLUT) & 0xFF) | ((uint32_t)(*pCLUT) & 0xFF00) | ((uint32_t)(*pCLUT) & 0xFF0000));
|
|
|
555 }
|
|
|
556 pcounter = (uint32_t)pCLUT + sizeof(*pCLUT);
|
|
|
557 pCLUT = (uint32_t *)pcounter;
|
|
|
558
|
|
|
559 /* Specifies the C-LUT address and RGB value */
|
|
|
560 LTDC_LAYER(hltdc, LayerIdx)->CLUTWR = tmp;
|
|
|
561 }
|
|
|
562
|
|
|
563 /* Change the LTDC state*/
|
|
|
564 hltdc->State = HAL_LTDC_STATE_READY;
|
|
|
565
|
|
|
566 /* Process unlocked */
|
|
|
567 __HAL_UNLOCK(hltdc);
|
|
|
568
|
|
|
569 return HAL_OK;
|
|
|
570 }
|
|
|
571
|
|
|
572 /**
|
|
|
573 * @brief Enable the color keying.
|
|
|
574 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
|
|
|
575 * the configuration information for the LTDC.
|
|
|
576 * @param LayerIdx: LTDC Layer index.
|
|
|
577 * This parameter can be one of the following values:
|
|
|
578 * 0 or 1
|
|
|
579 * @retval HAL status
|
|
|
580 */
|
|
|
581 HAL_StatusTypeDef HAL_LTDC_EnableColorKeying(LTDC_HandleTypeDef *hltdc, uint32_t LayerIdx)
|
|
|
582 {
|
|
|
583 /* Process locked */
|
|
|
584 __HAL_LOCK(hltdc);
|
|
|
585
|
|
|
586 /* Change LTDC peripheral state */
|
|
|
587 hltdc->State = HAL_LTDC_STATE_BUSY;
|
|
|
588
|
|
|
589 /* Check the parameters */
|
|
|
590 assert_param(IS_LTDC_LAYER(LayerIdx));
|
|
|
591
|
|
|
592 /* Enable LTDC color keying by setting COLKEN bit */
|
|
|
593 LTDC_LAYER(hltdc, LayerIdx)->CR |= (uint32_t)LTDC_LxCR_COLKEN;
|
|
|
594
|
|
|
595 /* Sets the Reload type */
|
|
|
596 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
|
|
|
597
|
|
|
598 /* Change the LTDC state*/
|
|
|
599 hltdc->State = HAL_LTDC_STATE_READY;
|
|
|
600
|
|
|
601 /* Process unlocked */
|
|
|
602 __HAL_UNLOCK(hltdc);
|
|
|
603
|
|
|
604 return HAL_OK;
|
|
|
605 }
|
|
|
606
|
|
|
607 /**
|
|
|
608 * @brief Disable the color keying.
|
|
|
609 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
|
|
|
610 * the configuration information for the LTDC.
|
|
|
611 * @param LayerIdx: LTDC Layer index.
|
|
|
612 * This parameter can be one of the following values:
|
|
|
613 * 0 or 1
|
|
|
614 * @retval HAL status
|
|
|
615 */
|
|
|
616 HAL_StatusTypeDef HAL_LTDC_DisableColorKeying(LTDC_HandleTypeDef *hltdc, uint32_t LayerIdx)
|
|
|
617 {
|
|
|
618 /* Process locked */
|
|
|
619 __HAL_LOCK(hltdc);
|
|
|
620
|
|
|
621 /* Change LTDC peripheral state */
|
|
|
622 hltdc->State = HAL_LTDC_STATE_BUSY;
|
|
|
623
|
|
|
624 /* Check the parameters */
|
|
|
625 assert_param(IS_LTDC_LAYER(LayerIdx));
|
|
|
626
|
|
|
627 /* Disable LTDC color keying by setting COLKEN bit */
|
|
|
628 LTDC_LAYER(hltdc, LayerIdx)->CR &= ~(uint32_t)LTDC_LxCR_COLKEN;
|
|
|
629
|
|
|
630 /* Sets the Reload type */
|
|
|
631 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
|
|
|
632
|
|
|
633 /* Change the LTDC state*/
|
|
|
634 hltdc->State = HAL_LTDC_STATE_READY;
|
|
|
635
|
|
|
636 /* Process unlocked */
|
|
|
637 __HAL_UNLOCK(hltdc);
|
|
|
638
|
|
|
639 return HAL_OK;
|
|
|
640 }
|
|
|
641
|
|
|
642 /**
|
|
|
643 * @brief Enable the color lookup table.
|
|
|
644 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
|
|
|
645 * the configuration information for the LTDC.
|
|
|
646 * @param LayerIdx: LTDC Layer index.
|
|
|
647 * This parameter can be one of the following values:
|
|
|
648 * 0 or 1
|
|
|
649 * @retval HAL status
|
|
|
650 */
|
|
|
651 HAL_StatusTypeDef HAL_LTDC_EnableCLUT(LTDC_HandleTypeDef *hltdc, uint32_t LayerIdx)
|
|
|
652 {
|
|
|
653
|
|
|
654 /* Process locked */
|
|
|
655 __HAL_LOCK(hltdc);
|
|
|
656
|
|
|
657 /* Change LTDC peripheral state */
|
|
|
658 hltdc->State = HAL_LTDC_STATE_BUSY;
|
|
|
659
|
|
|
660 /* Check the parameters */
|
|
|
661 assert_param(IS_LTDC_LAYER(LayerIdx));
|
|
|
662
|
|
|
663 /* Disable LTDC color lookup table by setting CLUTEN bit */
|
|
|
664 LTDC_LAYER(hltdc, LayerIdx)->CR |= (uint32_t)LTDC_LxCR_CLUTEN;
|
|
|
665
|
|
|
666 /* Sets the Reload type */
|
|
|
667 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
|
|
|
668
|
|
|
669 /* Change the LTDC state*/
|
|
|
670 hltdc->State = HAL_LTDC_STATE_READY;
|
|
|
671
|
|
|
672 /* Process unlocked */
|
|
|
673 __HAL_UNLOCK(hltdc);
|
|
|
674
|
|
|
675 return HAL_OK;
|
|
|
676 }
|
|
|
677
|
|
|
678 /**
|
|
|
679 * @brief Disable the color lookup table.
|
|
|
680 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
|
|
|
681 * the configuration information for the LTDC.
|
|
|
682 * @param LayerIdx: LTDC Layer index.
|
|
|
683 * This parameter can be one of the following values:
|
|
|
684 * 0 or 1
|
|
|
685 * @retval HAL status
|
|
|
686 */
|
|
|
687 HAL_StatusTypeDef HAL_LTDC_DisableCLUT(LTDC_HandleTypeDef *hltdc, uint32_t LayerIdx)
|
|
|
688 {
|
|
|
689
|
|
|
690 /* Process locked */
|
|
|
691 __HAL_LOCK(hltdc);
|
|
|
692
|
|
|
693 /* Change LTDC peripheral state */
|
|
|
694 hltdc->State = HAL_LTDC_STATE_BUSY;
|
|
|
695
|
|
|
696 /* Check the parameters */
|
|
|
697 assert_param(IS_LTDC_LAYER(LayerIdx));
|
|
|
698
|
|
|
699 /* Disable LTDC color lookup table by setting CLUTEN bit */
|
|
|
700 LTDC_LAYER(hltdc, LayerIdx)->CR &= ~(uint32_t)LTDC_LxCR_CLUTEN;
|
|
|
701
|
|
|
702 /* Sets the Reload type */
|
|
|
703 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
|
|
|
704
|
|
|
705 /* Change the LTDC state*/
|
|
|
706 hltdc->State = HAL_LTDC_STATE_READY;
|
|
|
707
|
|
|
708 /* Process unlocked */
|
|
|
709 __HAL_UNLOCK(hltdc);
|
|
|
710
|
|
|
711 return HAL_OK;
|
|
|
712 }
|
|
|
713
|
|
|
714 /**
|
|
|
715 * @brief Enables Dither.
|
|
|
716 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
|
|
|
717 * the configuration information for the LTDC.
|
|
|
718 * @retval HAL status
|
|
|
719 */
|
|
|
720
|
|
|
721 HAL_StatusTypeDef HAL_LTDC_EnableDither(LTDC_HandleTypeDef *hltdc)
|
|
|
722 {
|
|
|
723 /* Process locked */
|
|
|
724 __HAL_LOCK(hltdc);
|
|
|
725
|
|
|
726 /* Change LTDC peripheral state */
|
|
|
727 hltdc->State = HAL_LTDC_STATE_BUSY;
|
|
|
728
|
|
|
729 /* Enable Dither by setting DTEN bit */
|
|
|
730 LTDC->GCR |= (uint32_t)LTDC_GCR_DTEN;
|
|
|
731
|
|
|
732 /* Change the LTDC state*/
|
|
|
733 hltdc->State = HAL_LTDC_STATE_READY;
|
|
|
734
|
|
|
735 /* Process unlocked */
|
|
|
736 __HAL_UNLOCK(hltdc);
|
|
|
737
|
|
|
738 return HAL_OK;
|
|
|
739 }
|
|
|
740
|
|
|
741 /**
|
|
|
742 * @brief Disables Dither.
|
|
|
743 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
|
|
|
744 * the configuration information for the LTDC.
|
|
|
745 * @retval HAL status
|
|
|
746 */
|
|
|
747
|
|
|
748 HAL_StatusTypeDef HAL_LTDC_DisableDither(LTDC_HandleTypeDef *hltdc)
|
|
|
749 {
|
|
|
750 /* Process locked */
|
|
|
751 __HAL_LOCK(hltdc);
|
|
|
752
|
|
|
753 /* Change LTDC peripheral state */
|
|
|
754 hltdc->State = HAL_LTDC_STATE_BUSY;
|
|
|
755
|
|
|
756 /* Disable Dither by setting DTEN bit */
|
|
|
757 LTDC->GCR &= ~(uint32_t)LTDC_GCR_DTEN;
|
|
|
758
|
|
|
759 /* Change the LTDC state*/
|
|
|
760 hltdc->State = HAL_LTDC_STATE_READY;
|
|
|
761
|
|
|
762 /* Process unlocked */
|
|
|
763 __HAL_UNLOCK(hltdc);
|
|
|
764
|
|
|
765 return HAL_OK;
|
|
|
766 }
|
|
|
767
|
|
|
768 /**
|
|
|
769 * @brief Set the LTDC window size.
|
|
|
770 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
|
|
|
771 * the configuration information for the LTDC.
|
|
|
772 * @param XSize: LTDC Pixel per line
|
|
|
773 * @param YSize: LTDC Line number
|
|
|
774 * @param LayerIdx: LTDC Layer index.
|
|
|
775 * This parameter can be one of the following values:
|
|
|
776 * 0 or 1
|
|
|
777 * @retval HAL status
|
|
|
778 */
|
|
|
779 HAL_StatusTypeDef HAL_LTDC_SetWindowSize(LTDC_HandleTypeDef *hltdc, uint32_t XSize, uint32_t YSize, uint32_t LayerIdx)
|
|
|
780 {
|
|
|
781 LTDC_LayerCfgTypeDef *pLayerCfg;
|
|
|
782
|
|
|
783 /* Process locked */
|
|
|
784 __HAL_LOCK(hltdc);
|
|
|
785
|
|
|
786 /* Change LTDC peripheral state */
|
|
|
787 hltdc->State = HAL_LTDC_STATE_BUSY;
|
|
|
788
|
|
|
789 /* Get layer configuration from handle structure */
|
|
|
790 pLayerCfg = &hltdc->LayerCfg[LayerIdx];
|
|
|
791
|
|
|
792 /* Check the parameters (Layers parameters)*/
|
|
|
793 assert_param(IS_LTDC_LAYER(LayerIdx));
|
|
|
794 assert_param(IS_LTDC_HCONFIGST(pLayerCfg->WindowX0));
|
|
|
795 assert_param(IS_LTDC_HCONFIGSP(pLayerCfg->WindowX1));
|
|
|
796 assert_param(IS_LTDC_VCONFIGST(pLayerCfg->WindowY0));
|
|
|
797 assert_param(IS_LTDC_VCONFIGSP(pLayerCfg->WindowY1));
|
|
|
798 assert_param(IS_LTDC_CFBLL(XSize));
|
|
|
799 assert_param(IS_LTDC_CFBLNBR(YSize));
|
|
|
800
|
|
|
801 /* update horizontal start/stop */
|
|
|
802 pLayerCfg->WindowX0 = 0;
|
|
|
803 pLayerCfg->WindowX1 = XSize + pLayerCfg->WindowX0;
|
|
|
804
|
|
|
805 /* update vertical start/stop */
|
|
|
806 pLayerCfg->WindowY0 = 0;
|
|
|
807 pLayerCfg->WindowY1 = YSize + pLayerCfg->WindowY0;
|
|
|
808
|
|
|
809 /* Reconfigures the color frame buffer pitch in byte */
|
|
|
810 pLayerCfg->ImageWidth = XSize;
|
|
|
811
|
|
|
812 /* Reconfigures the frame buffer line number */
|
|
|
813 pLayerCfg->ImageHeight = YSize;
|
|
|
814
|
|
|
815 /* Set LTDC parameters */
|
|
|
816 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
|
|
|
817
|
|
|
818 /* Sets the Reload type */
|
|
|
819 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
|
|
|
820
|
|
|
821 /* Change the LTDC state*/
|
|
|
822 hltdc->State = HAL_LTDC_STATE_READY;
|
|
|
823
|
|
|
824 /* Process unlocked */
|
|
|
825 __HAL_UNLOCK(hltdc);
|
|
|
826
|
|
|
827 return HAL_OK;
|
|
|
828 }
|
|
|
829
|
|
|
830 /**
|
|
|
831 * @brief Set the LTDC window position.
|
|
|
832 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
|
|
|
833 * the configuration information for the LTDC.
|
|
|
834 * @param X0: LTDC window X offset
|
|
|
835 * @param Y0: LTDC window Y offset
|
|
|
836 * @param LayerIdx: LTDC Layer index.
|
|
|
837 * This parameter can be one of the following values:
|
|
|
838 * 0 or 1
|
|
|
839 * @retval HAL status
|
|
|
840 */
|
|
|
841 HAL_StatusTypeDef HAL_LTDC_SetWindowPosition(LTDC_HandleTypeDef *hltdc, uint32_t X0, uint32_t Y0, uint32_t LayerIdx)
|
|
|
842 {
|
|
|
843 LTDC_LayerCfgTypeDef *pLayerCfg;
|
|
|
844
|
|
|
845 /* Process locked */
|
|
|
846 __HAL_LOCK(hltdc);
|
|
|
847
|
|
|
848 /* Change LTDC peripheral state */
|
|
|
849 hltdc->State = HAL_LTDC_STATE_BUSY;
|
|
|
850
|
|
|
851 /* Get layer configuration from handle structure */
|
|
|
852 pLayerCfg = &hltdc->LayerCfg[LayerIdx];
|
|
|
853
|
|
|
854 /* Check the parameters */
|
|
|
855 assert_param(IS_LTDC_LAYER(LayerIdx));
|
|
|
856 assert_param(IS_LTDC_HCONFIGST(pLayerCfg->WindowX0));
|
|
|
857 assert_param(IS_LTDC_HCONFIGSP(pLayerCfg->WindowX1));
|
|
|
858 assert_param(IS_LTDC_VCONFIGST(pLayerCfg->WindowY0));
|
|
|
859 assert_param(IS_LTDC_VCONFIGSP(pLayerCfg->WindowY1));
|
|
|
860
|
|
|
861 /* update horizontal start/stop */
|
|
|
862 pLayerCfg->WindowX0 = X0;
|
|
|
863 pLayerCfg->WindowX1 = X0 + pLayerCfg->ImageWidth;
|
|
|
864
|
|
|
865 /* update vertical start/stop */
|
|
|
866 pLayerCfg->WindowY0 = Y0;
|
|
|
867 pLayerCfg->WindowY1 = Y0 + pLayerCfg->ImageHeight;
|
|
|
868
|
|
|
869 /* Set LTDC parameters */
|
|
|
870 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
|
|
|
871
|
|
|
872 /* Sets the Reload type */
|
|
|
873 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
|
|
|
874
|
|
|
875 /* Change the LTDC state*/
|
|
|
876 hltdc->State = HAL_LTDC_STATE_READY;
|
|
|
877
|
|
|
878 /* Process unlocked */
|
|
|
879 __HAL_UNLOCK(hltdc);
|
|
|
880
|
|
|
881 return HAL_OK;
|
|
|
882 }
|
|
|
883
|
|
|
884 /**
|
|
|
885 * @brief Reconfigure the pixel format.
|
|
|
886 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
|
|
|
887 * the configuration information for the LTDC.
|
|
|
888 * @param Pixelformat: new pixel format value.
|
|
|
889 * @param LayerIdx: LTDC Layer index.
|
|
|
890 * This parameter can be one of the following values:
|
|
|
891 * 0 or 1.
|
|
|
892 * @retval HAL status
|
|
|
893 */
|
|
|
894 HAL_StatusTypeDef HAL_LTDC_SetPixelFormat(LTDC_HandleTypeDef *hltdc, uint32_t Pixelformat, uint32_t LayerIdx)
|
|
|
895 {
|
|
|
896 LTDC_LayerCfgTypeDef *pLayerCfg;
|
|
|
897
|
|
|
898 /* Process locked */
|
|
|
899 __HAL_LOCK(hltdc);
|
|
|
900
|
|
|
901 /* Change LTDC peripheral state */
|
|
|
902 hltdc->State = HAL_LTDC_STATE_BUSY;
|
|
|
903
|
|
|
904 /* Check the parameters */
|
|
|
905 assert_param(IS_LTDC_LAYER(LayerIdx));
|
|
|
906 assert_param(IS_LTDC_PIXEL_FORMAT(Pixelformat));
|
|
|
907
|
|
|
908 /* Get layer configuration from handle structure */
|
|
|
909 pLayerCfg = &hltdc->LayerCfg[LayerIdx];
|
|
|
910
|
|
|
911 /* Reconfigure the pixel format */
|
|
|
912 pLayerCfg->PixelFormat = Pixelformat;
|
|
|
913
|
|
|
914 /* Set LTDC parameters */
|
|
|
915 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
|
|
|
916
|
|
|
917 /* Sets the Reload type */
|
|
|
918 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
|
|
|
919
|
|
|
920 /* Change the LTDC state*/
|
|
|
921 hltdc->State = HAL_LTDC_STATE_READY;
|
|
|
922
|
|
|
923 /* Process unlocked */
|
|
|
924 __HAL_UNLOCK(hltdc);
|
|
|
925
|
|
|
926 return HAL_OK;
|
|
|
927 }
|
|
|
928
|
|
|
929 /**
|
|
|
930 * @brief Reconfigure the layer alpha value.
|
|
|
931 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
|
|
|
932 * the configuration information for the LTDC.
|
|
|
933 * @param Alpha: new alpha value.
|
|
|
934 * @param LayerIdx: LTDC Layer index.
|
|
|
935 * This parameter can be one of the following values:
|
|
|
936 * 0 or 1
|
|
|
937 * @retval HAL status
|
|
|
938 */
|
|
|
939 HAL_StatusTypeDef HAL_LTDC_SetAlpha(LTDC_HandleTypeDef *hltdc, uint32_t Alpha, uint32_t LayerIdx)
|
|
|
940 {
|
|
|
941 LTDC_LayerCfgTypeDef *pLayerCfg;
|
|
|
942
|
|
|
943 /* Process locked */
|
|
|
944 __HAL_LOCK(hltdc);
|
|
|
945
|
|
|
946 /* Change LTDC peripheral state */
|
|
|
947 hltdc->State = HAL_LTDC_STATE_BUSY;
|
|
|
948
|
|
|
949 /* Check the parameters */
|
|
|
950 assert_param(IS_LTDC_ALPHA(Alpha));
|
|
|
951 assert_param(IS_LTDC_LAYER(LayerIdx));
|
|
|
952
|
|
|
953 /* Get layer configuration from handle structure */
|
|
|
954 pLayerCfg = &hltdc->LayerCfg[LayerIdx];
|
|
|
955
|
|
|
956 /* Reconfigure the Alpha value */
|
|
|
957 pLayerCfg->Alpha = Alpha;
|
|
|
958
|
|
|
959 /* Set LTDC parameters */
|
|
|
960 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
|
|
|
961
|
|
|
962 /* Sets the Reload type */
|
|
|
963 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
|
|
|
964
|
|
|
965 /* Change the LTDC state*/
|
|
|
966 hltdc->State = HAL_LTDC_STATE_READY;
|
|
|
967
|
|
|
968 /* Process unlocked */
|
|
|
969 __HAL_UNLOCK(hltdc);
|
|
|
970
|
|
|
971 return HAL_OK;
|
|
|
972 }
|
|
|
973 /**
|
|
|
974 * @brief Reconfigure the frame buffer Address.
|
|
|
975 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
|
|
|
976 * the configuration information for the LTDC.
|
|
|
977 * @param Address: new address value.
|
|
|
978 * @param LayerIdx: LTDC Layer index.
|
|
|
979 * This parameter can be one of the following values:
|
|
|
980 * 0 or 1.
|
|
|
981 * @retval HAL status
|
|
|
982 */
|
|
|
983 HAL_StatusTypeDef HAL_LTDC_SetAddress(LTDC_HandleTypeDef *hltdc, uint32_t Address, uint32_t LayerIdx)
|
|
|
984 {
|
|
|
985 LTDC_LayerCfgTypeDef *pLayerCfg;
|
|
|
986
|
|
|
987 /* Process locked */
|
|
|
988 __HAL_LOCK(hltdc);
|
|
|
989
|
|
|
990 /* Change LTDC peripheral state */
|
|
|
991 hltdc->State = HAL_LTDC_STATE_BUSY;
|
|
|
992
|
|
|
993 /* Check the parameters */
|
|
|
994 assert_param(IS_LTDC_LAYER(LayerIdx));
|
|
|
995
|
|
|
996 /* Get layer configuration from handle structure */
|
|
|
997 pLayerCfg = &hltdc->LayerCfg[LayerIdx];
|
|
|
998
|
|
|
999 /* Reconfigure the Address */
|
|
|
1000 pLayerCfg->FBStartAdress = Address;
|
|
|
1001
|
|
|
1002 /* Set LTDC parameters */
|
|
|
1003 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
|
|
|
1004
|
|
|
1005 /* Sets the Reload type */
|
|
|
1006 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
|
|
|
1007
|
|
|
1008 /* Change the LTDC state*/
|
|
|
1009 hltdc->State = HAL_LTDC_STATE_READY;
|
|
|
1010
|
|
|
1011 /* Process unlocked */
|
|
|
1012 __HAL_UNLOCK(hltdc);
|
|
|
1013
|
|
|
1014 return HAL_OK;
|
|
|
1015 }
|
|
|
1016
|
|
|
1017 /**
|
|
|
1018 * @brief Define the position of the line interrupt .
|
|
|
1019 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
|
|
|
1020 * the configuration information for the LTDC.
|
|
|
1021 * @param Line: Line Interrupt Position.
|
|
|
1022 * @retval HAL status
|
|
|
1023 */
|
|
|
1024 HAL_StatusTypeDef HAL_LTDC_ProgramLineEvent(LTDC_HandleTypeDef *hltdc, uint32_t Line)
|
|
|
1025 {
|
|
|
1026 /* Process locked */
|
|
|
1027 __HAL_LOCK(hltdc);
|
|
|
1028
|
|
|
1029 /* Change LTDC peripheral state */
|
|
|
1030 hltdc->State = HAL_LTDC_STATE_BUSY;
|
|
|
1031
|
|
|
1032 /* Check the parameters */
|
|
|
1033 assert_param(IS_LTDC_LIPOS(Line));
|
|
|
1034
|
|
|
1035 /* Enable the Line interrupt */
|
|
|
1036 __HAL_LTDC_ENABLE_IT(hltdc, LTDC_IT_LI);
|
|
|
1037
|
|
|
1038 /* Sets the Line Interrupt position */
|
|
|
1039 LTDC->LIPCR = (uint32_t)Line;
|
|
|
1040
|
|
|
1041 /* Change the LTDC state*/
|
|
|
1042 hltdc->State = HAL_LTDC_STATE_READY;
|
|
|
1043
|
|
|
1044 /* Process unlocked */
|
|
|
1045 __HAL_UNLOCK(hltdc);
|
|
|
1046
|
|
|
1047 return HAL_OK;
|
|
|
1048 }
|
|
|
1049
|
|
|
1050 /**
|
|
|
1051 * @}
|
|
|
1052 */
|
|
|
1053
|
|
|
1054 /** @defgroup LTDC_Exported_Functions_Group4 Peripheral State and Errors functions
|
|
|
1055 * @brief Peripheral State and Errors functions
|
|
|
1056 *
|
|
|
1057 @verbatim
|
|
|
1058 ===============================================================================
|
|
|
1059 ##### Peripheral State and Errors functions #####
|
|
|
1060 ===============================================================================
|
|
|
1061 [..]
|
|
|
1062 This subsection provides functions allowing to
|
|
|
1063 (+) Check the LTDC state.
|
|
|
1064 (+) Get error code.
|
|
|
1065
|
|
|
1066 @endverbatim
|
|
|
1067 * @{
|
|
|
1068 */
|
|
|
1069
|
|
|
1070 /**
|
|
|
1071 * @brief Return the LTDC state
|
|
|
1072 * @param hltdc: pointer to a LTDC_HandleTypeDef structure that contains
|
|
|
1073 * the configuration information for the LTDC.
|
|
|
1074 * @retval HAL state
|
|
|
1075 */
|
|
|
1076 HAL_LTDC_StateTypeDef HAL_LTDC_GetState(LTDC_HandleTypeDef *hltdc)
|
|
|
1077 {
|
|
|
1078 return hltdc->State;
|
|
|
1079 }
|
|
|
1080
|
|
|
1081 /**
|
|
|
1082 * @brief Return the LTDC error code
|
|
|
1083 * @param hltdc : pointer to a LTDC_HandleTypeDef structure that contains
|
|
|
1084 * the configuration information for the LTDC.
|
|
|
1085 * @retval LTDC Error Code
|
|
|
1086 */
|
|
|
1087 uint32_t HAL_LTDC_GetError(LTDC_HandleTypeDef *hltdc)
|
|
|
1088 {
|
|
|
1089 return hltdc->ErrorCode;
|
|
|
1090 }
|
|
|
1091
|
|
|
1092 /**
|
|
|
1093 * @}
|
|
|
1094 */
|
|
|
1095
|
|
|
1096 /**
|
|
|
1097 * @brief Configures the LTDC peripheral
|
|
|
1098 * @param hltdc : Pointer to a LTDC_HandleTypeDef structure that contains
|
|
|
1099 * the configuration information for the LTDC.
|
|
|
1100 * @param pLayerCfg: Pointer LTDC Layer Configuration structure
|
|
|
1101 * @param LayerIdx: LTDC Layer index.
|
|
|
1102 * This parameter can be one of the following values: 0 or 1
|
|
|
1103 * @retval None
|
|
|
1104 */
|
|
|
1105 static void LTDC_SetConfig(LTDC_HandleTypeDef *hltdc, LTDC_LayerCfgTypeDef *pLayerCfg, uint32_t LayerIdx)
|
|
|
1106 {
|
|
|
1107 uint32_t tmp = 0;
|
|
|
1108 uint32_t tmp1 = 0;
|
|
|
1109 uint32_t tmp2 = 0;
|
|
|
1110
|
|
|
1111 /* Configures the horizontal start and stop position */
|
|
|
1112 tmp = ((pLayerCfg->WindowX1 + ((hltdc->Instance->BPCR & LTDC_BPCR_AHBP) >> 16)) << 16);
|
|
|
1113 LTDC_LAYER(hltdc, LayerIdx)->WHPCR &= ~(LTDC_LxWHPCR_WHSTPOS | LTDC_LxWHPCR_WHSPPOS);
|
|
|
1114 LTDC_LAYER(hltdc, LayerIdx)->WHPCR = ((pLayerCfg->WindowX0 + ((hltdc->Instance->BPCR & LTDC_BPCR_AHBP) >> 16) + 1) | tmp);
|
|
|
1115
|
|
|
1116 /* Configures the vertical start and stop position */
|
|
|
1117 tmp = ((pLayerCfg->WindowY1 + (hltdc->Instance->BPCR & LTDC_BPCR_AVBP)) << 16);
|
|
|
1118 LTDC_LAYER(hltdc, LayerIdx)->WVPCR &= ~(LTDC_LxWVPCR_WVSTPOS | LTDC_LxWVPCR_WVSPPOS);
|
|
|
1119 LTDC_LAYER(hltdc, LayerIdx)->WVPCR = ((pLayerCfg->WindowY0 + (hltdc->Instance->BPCR & LTDC_BPCR_AVBP) + 1) | tmp);
|
|
|
1120
|
|
|
1121 /* Specifies the pixel format */
|
|
|
1122 LTDC_LAYER(hltdc, LayerIdx)->PFCR &= ~(LTDC_LxPFCR_PF);
|
|
|
1123 LTDC_LAYER(hltdc, LayerIdx)->PFCR = (pLayerCfg->PixelFormat);
|
|
|
1124
|
|
|
1125 /* Configures the default color values */
|
|
|
1126 tmp = ((uint32_t)(pLayerCfg->Backcolor.Green) << 8);
|
|
|
1127 tmp1 = ((uint32_t)(pLayerCfg->Backcolor.Red) << 16);
|
|
|
1128 tmp2 = (pLayerCfg->Alpha0 << 24);
|
|
|
1129 LTDC_LAYER(hltdc, LayerIdx)->DCCR &= ~(LTDC_LxDCCR_DCBLUE | LTDC_LxDCCR_DCGREEN | LTDC_LxDCCR_DCRED | LTDC_LxDCCR_DCALPHA);
|
|
|
1130 LTDC_LAYER(hltdc, LayerIdx)->DCCR = (pLayerCfg->Backcolor.Blue | tmp | tmp1 | tmp2);
|
|
|
1131
|
|
|
1132 /* Specifies the constant alpha value */
|
|
|
1133 LTDC_LAYER(hltdc, LayerIdx)->CACR &= ~(LTDC_LxCACR_CONSTA);
|
|
|
1134 LTDC_LAYER(hltdc, LayerIdx)->CACR = (pLayerCfg->Alpha);
|
|
|
1135
|
|
|
1136 /* Specifies the blending factors */
|
|
|
1137 LTDC_LAYER(hltdc, LayerIdx)->BFCR &= ~(LTDC_LxBFCR_BF2 | LTDC_LxBFCR_BF1);
|
|
|
1138 LTDC_LAYER(hltdc, LayerIdx)->BFCR = (pLayerCfg->BlendingFactor1 | pLayerCfg->BlendingFactor2);
|
|
|
1139
|
|
|
1140 /* Configures the color frame buffer start address */
|
|
|
1141 LTDC_LAYER(hltdc, LayerIdx)->CFBAR &= ~(LTDC_LxCFBAR_CFBADD);
|
|
|
1142 LTDC_LAYER(hltdc, LayerIdx)->CFBAR = (pLayerCfg->FBStartAdress);
|
|
|
1143
|
|
|
1144 if(pLayerCfg->PixelFormat == LTDC_PIXEL_FORMAT_ARGB8888)
|
|
|
1145 {
|
|
|
1146 tmp = 4;
|
|
|
1147 }
|
|
|
1148 else if (pLayerCfg->PixelFormat == LTDC_PIXEL_FORMAT_RGB888)
|
|
|
1149 {
|
|
|
1150 tmp = 3;
|
|
|
1151 }
|
|
|
1152 else if((pLayerCfg->PixelFormat == LTDC_PIXEL_FORMAT_ARGB4444) || \
|
|
|
1153 (pLayerCfg->PixelFormat == LTDC_PIXEL_FORMAT_RGB565) || \
|
|
|
1154 (pLayerCfg->PixelFormat == LTDC_PIXEL_FORMAT_ARGB1555) || \
|
|
|
1155 (pLayerCfg->PixelFormat == LTDC_PIXEL_FORMAT_AL88))
|
|
|
1156 {
|
|
|
1157 tmp = 2;
|
|
|
1158 }
|
|
|
1159 else
|
|
|
1160 {
|
|
|
1161 tmp = 1;
|
|
|
1162 }
|
|
|
1163
|
|
|
1164 /* Configures the color frame buffer pitch in byte */
|
|
|
1165 LTDC_LAYER(hltdc, LayerIdx)->CFBLR &= ~(LTDC_LxCFBLR_CFBLL | LTDC_LxCFBLR_CFBP);
|
|
|
1166 LTDC_LAYER(hltdc, LayerIdx)->CFBLR = (((pLayerCfg->ImageWidth * tmp) << 16) | ((pLayerCfg->ImageWidth * tmp) + 3));
|
|
|
1167
|
|
|
1168 /* Configures the frame buffer line number */
|
|
|
1169 LTDC_LAYER(hltdc, LayerIdx)->CFBLNR &= ~(LTDC_LxCFBLNR_CFBLNBR);
|
|
|
1170 LTDC_LAYER(hltdc, LayerIdx)->CFBLNR = (pLayerCfg->ImageHeight);
|
|
|
1171
|
|
|
1172 /* Enable LTDC_Layer by setting LEN bit */
|
|
|
1173 LTDC_LAYER(hltdc, LayerIdx)->CR |= (uint32_t)LTDC_LxCR_LEN;
|
|
|
1174 }
|
|
|
1175
|
|
|
1176 /**
|
|
|
1177 * @}
|
|
|
1178 */
|
|
|
1179 #endif /* STM32F429xx || STM32F439xx */
|
|
|
1180 #endif /* HAL_LTDC_MODULE_ENABLED */
|
|
|
1181 /**
|
|
|
1182 * @}
|
|
|
1183 */
|
|
|
1184
|
|
|
1185 /**
|
|
|
1186 * @}
|
|
|
1187 */
|
|
|
1188
|
|
|
1189 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
|
