STM32F4xx HAL Driver master
STM32CubeF4 HAL / LL Drivers API Reference
Loading...
Searching...
No Matches
stm32f4xx_hal_ltdc.c
Go to the documentation of this file.
1
161
162/* Includes ------------------------------------------------------------------*/
163#include "stm32f4xx_hal.h"
164
168
169#ifdef HAL_LTDC_MODULE_ENABLED
170
171#if defined (LTDC)
172
177
178
179/* Private typedef -----------------------------------------------------------*/
180/* Private define ------------------------------------------------------------*/
184#define LTDC_TIMEOUT_VALUE ((uint32_t)100U) /* 100ms */
188/* Private macro -------------------------------------------------------------*/
189/* Private variables ---------------------------------------------------------*/
190/* Private function prototypes -----------------------------------------------*/
191static void LTDC_SetConfig(LTDC_HandleTypeDef *hltdc, LTDC_LayerCfgTypeDef *pLayerCfg, uint32_t LayerIdx);
192/* Private functions ---------------------------------------------------------*/
193
197
212
219HAL_StatusTypeDef HAL_LTDC_Init(LTDC_HandleTypeDef *hltdc)
220{
221 uint32_t tmp;
222 uint32_t tmp1;
223
224 /* Check the LTDC peripheral state */
225 if (hltdc == NULL)
226 {
227 return HAL_ERROR;
228 }
229
230 /* Check function parameters */
231 assert_param(IS_LTDC_ALL_INSTANCE(hltdc->Instance));
232 assert_param(IS_LTDC_HSYNC(hltdc->Init.HorizontalSync));
233 assert_param(IS_LTDC_VSYNC(hltdc->Init.VerticalSync));
234 assert_param(IS_LTDC_AHBP(hltdc->Init.AccumulatedHBP));
235 assert_param(IS_LTDC_AVBP(hltdc->Init.AccumulatedVBP));
236 assert_param(IS_LTDC_AAH(hltdc->Init.AccumulatedActiveH));
237 assert_param(IS_LTDC_AAW(hltdc->Init.AccumulatedActiveW));
238 assert_param(IS_LTDC_TOTALH(hltdc->Init.TotalHeigh));
239 assert_param(IS_LTDC_TOTALW(hltdc->Init.TotalWidth));
240 assert_param(IS_LTDC_HSPOL(hltdc->Init.HSPolarity));
241 assert_param(IS_LTDC_VSPOL(hltdc->Init.VSPolarity));
242 assert_param(IS_LTDC_DEPOL(hltdc->Init.DEPolarity));
243 assert_param(IS_LTDC_PCPOL(hltdc->Init.PCPolarity));
244
245#if (USE_HAL_LTDC_REGISTER_CALLBACKS == 1)
246 if (hltdc->State == HAL_LTDC_STATE_RESET)
247 {
248 /* Allocate lock resource and initialize it */
249 hltdc->Lock = HAL_UNLOCKED;
250
251 /* Reset the LTDC callback to the legacy weak callbacks */
252 hltdc->LineEventCallback = HAL_LTDC_LineEventCallback; /* Legacy weak LineEventCallback */
253 hltdc->ReloadEventCallback = HAL_LTDC_ReloadEventCallback; /* Legacy weak ReloadEventCallback */
254 hltdc->ErrorCallback = HAL_LTDC_ErrorCallback; /* Legacy weak ErrorCallback */
255
256 if (hltdc->MspInitCallback == NULL)
257 {
258 hltdc->MspInitCallback = HAL_LTDC_MspInit;
259 }
260 /* Init the low level hardware */
261 hltdc->MspInitCallback(hltdc);
262 }
263#else
264 if (hltdc->State == HAL_LTDC_STATE_RESET)
265 {
266 /* Allocate lock resource and initialize it */
267 hltdc->Lock = HAL_UNLOCKED;
268 /* Init the low level hardware */
269 HAL_LTDC_MspInit(hltdc);
270 }
271#endif /* USE_HAL_LTDC_REGISTER_CALLBACKS */
272
273 /* Change LTDC peripheral state */
274 hltdc->State = HAL_LTDC_STATE_BUSY;
275
276 /* Configure the HS, VS, DE and PC polarity */
277 hltdc->Instance->GCR &= ~(LTDC_GCR_HSPOL | LTDC_GCR_VSPOL | LTDC_GCR_DEPOL | LTDC_GCR_PCPOL);
278 hltdc->Instance->GCR |= (uint32_t)(hltdc->Init.HSPolarity | hltdc->Init.VSPolarity | \
279 hltdc->Init.DEPolarity | hltdc->Init.PCPolarity);
280
281 /* Set Synchronization size */
282 tmp = (hltdc->Init.HorizontalSync << 16U);
283 WRITE_REG(hltdc->Instance->SSCR, (tmp | hltdc->Init.VerticalSync));
284
285 /* Set Accumulated Back porch */
286 tmp = (hltdc->Init.AccumulatedHBP << 16U);
287 WRITE_REG(hltdc->Instance->BPCR, (tmp | hltdc->Init.AccumulatedVBP));
288
289 /* Set Accumulated Active Width */
290 tmp = (hltdc->Init.AccumulatedActiveW << 16U);
291 WRITE_REG(hltdc->Instance->AWCR, (tmp | hltdc->Init.AccumulatedActiveH));
292
293 /* Set Total Width */
294 tmp = (hltdc->Init.TotalWidth << 16U);
295 WRITE_REG(hltdc->Instance->TWCR, (tmp | hltdc->Init.TotalHeigh));
296
297 /* Set the background color value */
298 tmp = ((uint32_t)(hltdc->Init.Backcolor.Green) << 8U);
299 tmp1 = ((uint32_t)(hltdc->Init.Backcolor.Red) << 16U);
300 hltdc->Instance->BCCR &= ~(LTDC_BCCR_BCBLUE | LTDC_BCCR_BCGREEN | LTDC_BCCR_BCRED);
301 hltdc->Instance->BCCR |= (tmp1 | tmp | hltdc->Init.Backcolor.Blue);
302
303 /* Enable the Transfer Error and FIFO underrun interrupts */
304 __HAL_LTDC_ENABLE_IT(hltdc, LTDC_IT_TE | LTDC_IT_FU);
305
306 /* Enable LTDC by setting LTDCEN bit */
307 __HAL_LTDC_ENABLE(hltdc);
308
309 /* Initialize the error code */
310 hltdc->ErrorCode = HAL_LTDC_ERROR_NONE;
311
312 /* Initialize the LTDC state*/
313 hltdc->State = HAL_LTDC_STATE_READY;
314
315 return HAL_OK;
316}
317
324
325HAL_StatusTypeDef HAL_LTDC_DeInit(LTDC_HandleTypeDef *hltdc)
326{
327 uint32_t tickstart;
328
329 /* Check the LTDC peripheral state */
330 if (hltdc == NULL)
331 {
332 return HAL_ERROR;
333 }
334
335 /* Check function parameters */
336 assert_param(IS_LTDC_ALL_INSTANCE(hltdc->Instance));
337
338 /* Disable LTDC Layer 1 */
339 __HAL_LTDC_LAYER_DISABLE(hltdc, LTDC_LAYER_1);
340
341#if defined(LTDC_Layer2_BASE)
342 /* Disable LTDC Layer 2 */
343 __HAL_LTDC_LAYER_DISABLE(hltdc, LTDC_LAYER_2);
344#endif /* LTDC_Layer2_BASE */
345
346 /* Reload during vertical blanking period */
347 __HAL_LTDC_VERTICAL_BLANKING_RELOAD_CONFIG(hltdc);
348
349 /* Get tick */
350 tickstart = HAL_GetTick();
351
352 /* Wait for VSYNC Interrupt */
353 while (READ_BIT(hltdc->Instance->CDSR, LTDC_CDSR_VSYNCS) == 0U)
354 {
355 /* Check for the Timeout */
356 if ((HAL_GetTick() - tickstart) > LTDC_TIMEOUT_VALUE)
357 {
358 break;
359 }
360 }
361
362 /* Disable LTDC */
363 __HAL_LTDC_DISABLE(hltdc);
364
365#if (USE_HAL_LTDC_REGISTER_CALLBACKS == 1)
366 if (hltdc->MspDeInitCallback == NULL)
367 {
368 hltdc->MspDeInitCallback = HAL_LTDC_MspDeInit;
369 }
370 /* DeInit the low level hardware */
371 hltdc->MspDeInitCallback(hltdc);
372#else
373 /* DeInit the low level hardware */
374 HAL_LTDC_MspDeInit(hltdc);
375#endif /* USE_HAL_LTDC_REGISTER_CALLBACKS */
376
377 /* Initialize the error code */
378 hltdc->ErrorCode = HAL_LTDC_ERROR_NONE;
379
380 /* Initialize the LTDC state*/
381 hltdc->State = HAL_LTDC_STATE_RESET;
382
383 /* Release Lock */
384 __HAL_UNLOCK(hltdc);
385
386 return HAL_OK;
387}
388
395__weak void HAL_LTDC_MspInit(LTDC_HandleTypeDef *hltdc)
396{
397 /* Prevent unused argument(s) compilation warning */
398 UNUSED(hltdc);
399
400 /* NOTE : This function should not be modified, when the callback is needed,
401 the HAL_LTDC_MspInit could be implemented in the user file
402 */
403}
404
411__weak void HAL_LTDC_MspDeInit(LTDC_HandleTypeDef *hltdc)
412{
413 /* Prevent unused argument(s) compilation warning */
414 UNUSED(hltdc);
415
416 /* NOTE : This function should not be modified, when the callback is needed,
417 the HAL_LTDC_MspDeInit could be implemented in the user file
418 */
419}
420
421#if (USE_HAL_LTDC_REGISTER_CALLBACKS == 1)
436HAL_StatusTypeDef HAL_LTDC_RegisterCallback(LTDC_HandleTypeDef *hltdc, HAL_LTDC_CallbackIDTypeDef CallbackID,
437 pLTDC_CallbackTypeDef pCallback)
438{
439 HAL_StatusTypeDef status = HAL_OK;
440
441 if (pCallback == NULL)
442 {
443 /* Update the error code */
444 hltdc->ErrorCode |= HAL_LTDC_ERROR_INVALID_CALLBACK;
445
446 return HAL_ERROR;
447 }
448 /* Process locked */
449 __HAL_LOCK(hltdc);
450
451 if (hltdc->State == HAL_LTDC_STATE_READY)
452 {
453 switch (CallbackID)
454 {
455 case HAL_LTDC_LINE_EVENT_CB_ID :
456 hltdc->LineEventCallback = pCallback;
457 break;
458
459 case HAL_LTDC_RELOAD_EVENT_CB_ID :
460 hltdc->ReloadEventCallback = pCallback;
461 break;
462
463 case HAL_LTDC_ERROR_CB_ID :
464 hltdc->ErrorCallback = pCallback;
465 break;
466
467 case HAL_LTDC_MSPINIT_CB_ID :
468 hltdc->MspInitCallback = pCallback;
469 break;
470
471 case HAL_LTDC_MSPDEINIT_CB_ID :
472 hltdc->MspDeInitCallback = pCallback;
473 break;
474
475 default :
476 /* Update the error code */
477 hltdc->ErrorCode |= HAL_LTDC_ERROR_INVALID_CALLBACK;
478 /* Return error status */
479 status = HAL_ERROR;
480 break;
481 }
482 }
483 else if (hltdc->State == HAL_LTDC_STATE_RESET)
484 {
485 switch (CallbackID)
486 {
487 case HAL_LTDC_MSPINIT_CB_ID :
488 hltdc->MspInitCallback = pCallback;
489 break;
490
491 case HAL_LTDC_MSPDEINIT_CB_ID :
492 hltdc->MspDeInitCallback = pCallback;
493 break;
494
495 default :
496 /* Update the error code */
497 hltdc->ErrorCode |= HAL_LTDC_ERROR_INVALID_CALLBACK;
498 /* Return error status */
499 status = HAL_ERROR;
500 break;
501 }
502 }
503 else
504 {
505 /* Update the error code */
506 hltdc->ErrorCode |= HAL_LTDC_ERROR_INVALID_CALLBACK;
507 /* Return error status */
508 status = HAL_ERROR;
509 }
510
511 /* Release Lock */
512 __HAL_UNLOCK(hltdc);
513
514 return status;
515}
516
530HAL_StatusTypeDef HAL_LTDC_UnRegisterCallback(LTDC_HandleTypeDef *hltdc, HAL_LTDC_CallbackIDTypeDef CallbackID)
531{
532 HAL_StatusTypeDef status = HAL_OK;
533
534 /* Process locked */
535 __HAL_LOCK(hltdc);
536
537 if (hltdc->State == HAL_LTDC_STATE_READY)
538 {
539 switch (CallbackID)
540 {
541 case HAL_LTDC_LINE_EVENT_CB_ID :
542 hltdc->LineEventCallback = HAL_LTDC_LineEventCallback; /* Legacy weak LineEventCallback */
543 break;
544
545 case HAL_LTDC_RELOAD_EVENT_CB_ID :
546 hltdc->ReloadEventCallback = HAL_LTDC_ReloadEventCallback; /* Legacy weak ReloadEventCallback */
547 break;
548
549 case HAL_LTDC_ERROR_CB_ID :
550 hltdc->ErrorCallback = HAL_LTDC_ErrorCallback; /* Legacy weak ErrorCallback */
551 break;
552
553 case HAL_LTDC_MSPINIT_CB_ID :
554 hltdc->MspInitCallback = HAL_LTDC_MspInit; /* Legcay weak MspInit Callback */
555 break;
556
557 case HAL_LTDC_MSPDEINIT_CB_ID :
558 hltdc->MspDeInitCallback = HAL_LTDC_MspDeInit; /* Legcay weak MspDeInit Callback */
559 break;
560
561 default :
562 /* Update the error code */
563 hltdc->ErrorCode |= HAL_LTDC_ERROR_INVALID_CALLBACK;
564 /* Return error status */
565 status = HAL_ERROR;
566 break;
567 }
568 }
569 else if (hltdc->State == HAL_LTDC_STATE_RESET)
570 {
571 switch (CallbackID)
572 {
573 case HAL_LTDC_MSPINIT_CB_ID :
574 hltdc->MspInitCallback = HAL_LTDC_MspInit; /* Legcay weak MspInit Callback */
575 break;
576
577 case HAL_LTDC_MSPDEINIT_CB_ID :
578 hltdc->MspDeInitCallback = HAL_LTDC_MspDeInit; /* Legcay weak MspDeInit Callback */
579 break;
580
581 default :
582 /* Update the error code */
583 hltdc->ErrorCode |= HAL_LTDC_ERROR_INVALID_CALLBACK;
584 /* Return error status */
585 status = HAL_ERROR;
586 break;
587 }
588 }
589 else
590 {
591 /* Update the error code */
592 hltdc->ErrorCode |= HAL_LTDC_ERROR_INVALID_CALLBACK;
593 /* Return error status */
594 status = HAL_ERROR;
595 }
596
597 /* Release Lock */
598 __HAL_UNLOCK(hltdc);
599
600 return status;
601}
602#endif /* USE_HAL_LTDC_REGISTER_CALLBACKS */
603
607
627void HAL_LTDC_IRQHandler(LTDC_HandleTypeDef *hltdc)
628{
629 uint32_t isrflags = READ_REG(hltdc->Instance->ISR);
630 uint32_t itsources = READ_REG(hltdc->Instance->IER);
631
632 /* Transfer Error Interrupt management ***************************************/
633 if (((isrflags & LTDC_ISR_TERRIF) != 0U) && ((itsources & LTDC_IER_TERRIE) != 0U))
634 {
635 /* Disable the transfer Error interrupt */
636 __HAL_LTDC_DISABLE_IT(hltdc, LTDC_IT_TE);
637
638 /* Clear the transfer error flag */
639 __HAL_LTDC_CLEAR_FLAG(hltdc, LTDC_FLAG_TE);
640
641 /* Update error code */
642 hltdc->ErrorCode |= HAL_LTDC_ERROR_TE;
643
644 /* Change LTDC state */
645 hltdc->State = HAL_LTDC_STATE_ERROR;
646
647 /* Process unlocked */
648 __HAL_UNLOCK(hltdc);
649
650 /* Transfer error Callback */
651#if (USE_HAL_LTDC_REGISTER_CALLBACKS == 1)
652 /*Call registered error callback*/
653 hltdc->ErrorCallback(hltdc);
654#else
655 /* Call legacy error callback*/
656 HAL_LTDC_ErrorCallback(hltdc);
657#endif /* USE_HAL_LTDC_REGISTER_CALLBACKS */
658 }
659
660 /* FIFO underrun Interrupt management ***************************************/
661 if (((isrflags & LTDC_ISR_FUIF) != 0U) && ((itsources & LTDC_IER_FUIE) != 0U))
662 {
663 /* Disable the FIFO underrun interrupt */
664 __HAL_LTDC_DISABLE_IT(hltdc, LTDC_IT_FU);
665
666 /* Clear the FIFO underrun flag */
667 __HAL_LTDC_CLEAR_FLAG(hltdc, LTDC_FLAG_FU);
668
669 /* Update error code */
670 hltdc->ErrorCode |= HAL_LTDC_ERROR_FU;
671
672 /* Change LTDC state */
673 hltdc->State = HAL_LTDC_STATE_ERROR;
674
675 /* Process unlocked */
676 __HAL_UNLOCK(hltdc);
677
678 /* Transfer error Callback */
679#if (USE_HAL_LTDC_REGISTER_CALLBACKS == 1)
680 /*Call registered error callback*/
681 hltdc->ErrorCallback(hltdc);
682#else
683 /* Call legacy error callback*/
684 HAL_LTDC_ErrorCallback(hltdc);
685#endif /* USE_HAL_LTDC_REGISTER_CALLBACKS */
686 }
687
688 /* Line Interrupt management ************************************************/
689 if (((isrflags & LTDC_ISR_LIF) != 0U) && ((itsources & LTDC_IER_LIE) != 0U))
690 {
691 /* Disable the Line interrupt */
692 __HAL_LTDC_DISABLE_IT(hltdc, LTDC_IT_LI);
693
694 /* Clear the Line interrupt flag */
695 __HAL_LTDC_CLEAR_FLAG(hltdc, LTDC_FLAG_LI);
696
697 /* Change LTDC state */
698 hltdc->State = HAL_LTDC_STATE_READY;
699
700 /* Process unlocked */
701 __HAL_UNLOCK(hltdc);
702
703 /* Line interrupt Callback */
704#if (USE_HAL_LTDC_REGISTER_CALLBACKS == 1)
705 /*Call registered Line Event callback */
706 hltdc->LineEventCallback(hltdc);
707#else
708 /*Call Legacy Line Event callback */
709 HAL_LTDC_LineEventCallback(hltdc);
710#endif /* USE_HAL_LTDC_REGISTER_CALLBACKS */
711 }
712
713 /* Register reload Interrupt management ***************************************/
714 if (((isrflags & LTDC_ISR_RRIF) != 0U) && ((itsources & LTDC_IER_RRIE) != 0U))
715 {
716 /* Disable the register reload interrupt */
717 __HAL_LTDC_DISABLE_IT(hltdc, LTDC_IT_RR);
718
719 /* Clear the register reload flag */
720 __HAL_LTDC_CLEAR_FLAG(hltdc, LTDC_FLAG_RR);
721
722 /* Change LTDC state */
723 hltdc->State = HAL_LTDC_STATE_READY;
724
725 /* Process unlocked */
726 __HAL_UNLOCK(hltdc);
727
728 /* Reload interrupt Callback */
729#if (USE_HAL_LTDC_REGISTER_CALLBACKS == 1)
730 /*Call registered reload Event callback */
731 hltdc->ReloadEventCallback(hltdc);
732#else
733 /*Call Legacy Reload Event callback */
734 HAL_LTDC_ReloadEventCallback(hltdc);
735#endif /* USE_HAL_LTDC_REGISTER_CALLBACKS */
736 }
737}
738
745__weak void HAL_LTDC_ErrorCallback(LTDC_HandleTypeDef *hltdc)
746{
747 /* Prevent unused argument(s) compilation warning */
748 UNUSED(hltdc);
749
750 /* NOTE : This function should not be modified, when the callback is needed,
751 the HAL_LTDC_ErrorCallback could be implemented in the user file
752 */
753}
754
761__weak void HAL_LTDC_LineEventCallback(LTDC_HandleTypeDef *hltdc)
762{
763 /* Prevent unused argument(s) compilation warning */
764 UNUSED(hltdc);
765
766 /* NOTE : This function should not be modified, when the callback is needed,
767 the HAL_LTDC_LineEventCallback could be implemented in the user file
768 */
769}
770
777__weak void HAL_LTDC_ReloadEventCallback(LTDC_HandleTypeDef *hltdc)
778{
779 /* Prevent unused argument(s) compilation warning */
780 UNUSED(hltdc);
781
782 /* NOTE : This function should not be modified, when the callback is needed,
783 the HAL_LTDC_ReloadEvenCallback could be implemented in the user file
784 */
785}
786
790
814
827HAL_StatusTypeDef HAL_LTDC_ConfigLayer(LTDC_HandleTypeDef *hltdc, LTDC_LayerCfgTypeDef *pLayerCfg, uint32_t LayerIdx)
828{
829 /* Check the parameters */
830 assert_param(IS_LTDC_LAYER(LayerIdx));
831 assert_param(IS_LTDC_HCONFIGST(pLayerCfg->WindowX0));
832 assert_param(IS_LTDC_HCONFIGSP(pLayerCfg->WindowX1));
833 assert_param(IS_LTDC_VCONFIGST(pLayerCfg->WindowY0));
834 assert_param(IS_LTDC_VCONFIGSP(pLayerCfg->WindowY1));
835 assert_param(IS_LTDC_PIXEL_FORMAT(pLayerCfg->PixelFormat));
836 assert_param(IS_LTDC_ALPHA(pLayerCfg->Alpha));
837 assert_param(IS_LTDC_ALPHA(pLayerCfg->Alpha0));
838 assert_param(IS_LTDC_BLENDING_FACTOR1(pLayerCfg->BlendingFactor1));
839 assert_param(IS_LTDC_BLENDING_FACTOR2(pLayerCfg->BlendingFactor2));
840 assert_param(IS_LTDC_CFBLL(pLayerCfg->ImageWidth));
841 assert_param(IS_LTDC_CFBLNBR(pLayerCfg->ImageHeight));
842
843 /* Process locked */
844 __HAL_LOCK(hltdc);
845
846 /* Change LTDC peripheral state */
847 hltdc->State = HAL_LTDC_STATE_BUSY;
848
849 /* Copy new layer configuration into handle structure */
850 hltdc->LayerCfg[LayerIdx] = *pLayerCfg;
851
852 /* Configure the LTDC Layer */
853 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
854
855 /* Set the Immediate Reload type */
856 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
857
858 /* Initialize the LTDC state*/
859 hltdc->State = HAL_LTDC_STATE_READY;
860
861 /* Process unlocked */
862 __HAL_UNLOCK(hltdc);
863
864 return HAL_OK;
865}
866
877HAL_StatusTypeDef HAL_LTDC_ConfigColorKeying(LTDC_HandleTypeDef *hltdc, uint32_t RGBValue, uint32_t LayerIdx)
878{
879 /* Check the parameters */
880 assert_param(IS_LTDC_LAYER(LayerIdx));
881
882 /* Process locked */
883 __HAL_LOCK(hltdc);
884
885 /* Change LTDC peripheral state */
886 hltdc->State = HAL_LTDC_STATE_BUSY;
887
888 /* Configure the default color values */
889 LTDC_LAYER(hltdc, LayerIdx)->CKCR &= ~(LTDC_LxCKCR_CKBLUE | LTDC_LxCKCR_CKGREEN | LTDC_LxCKCR_CKRED);
890 LTDC_LAYER(hltdc, LayerIdx)->CKCR = RGBValue;
891
892 /* Set the Immediate Reload type */
893 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
894
895 /* Change the LTDC state*/
896 hltdc->State = HAL_LTDC_STATE_READY;
897
898 /* Process unlocked */
899 __HAL_UNLOCK(hltdc);
900
901 return HAL_OK;
902}
903
915HAL_StatusTypeDef HAL_LTDC_ConfigCLUT(LTDC_HandleTypeDef *hltdc, const uint32_t *pCLUT, uint32_t CLUTSize,
916 uint32_t LayerIdx)
917{
918 uint32_t tmp;
919 uint32_t counter;
920 const uint32_t *pcolorlut = pCLUT;
921 /* Check the parameters */
922 assert_param(IS_LTDC_LAYER(LayerIdx));
923
924 /* Process locked */
925 __HAL_LOCK(hltdc);
926
927 /* Change LTDC peripheral state */
928 hltdc->State = HAL_LTDC_STATE_BUSY;
929
930 for (counter = 0U; (counter < CLUTSize); counter++)
931 {
932 if (hltdc->LayerCfg[LayerIdx].PixelFormat == LTDC_PIXEL_FORMAT_AL44)
933 {
934 tmp = (((counter + (16U * counter)) << 24U) | ((uint32_t)(*pcolorlut) & 0xFFU) | \
935 ((uint32_t)(*pcolorlut) & 0xFF00U) | ((uint32_t)(*pcolorlut) & 0xFF0000U));
936 }
937 else
938 {
939 tmp = ((counter << 24U) | ((uint32_t)(*pcolorlut) & 0xFFU) | \
940 ((uint32_t)(*pcolorlut) & 0xFF00U) | ((uint32_t)(*pcolorlut) & 0xFF0000U));
941 }
942
943 pcolorlut++;
944
945 /* Specifies the C-LUT address and RGB value */
946 LTDC_LAYER(hltdc, LayerIdx)->CLUTWR = tmp;
947 }
948
949 /* Change the LTDC state*/
950 hltdc->State = HAL_LTDC_STATE_READY;
951
952 /* Process unlocked */
953 __HAL_UNLOCK(hltdc);
954
955 return HAL_OK;
956}
957
967HAL_StatusTypeDef HAL_LTDC_EnableColorKeying(LTDC_HandleTypeDef *hltdc, uint32_t LayerIdx)
968{
969 /* Check the parameters */
970 assert_param(IS_LTDC_LAYER(LayerIdx));
971
972 /* Process locked */
973 __HAL_LOCK(hltdc);
974
975 /* Change LTDC peripheral state */
976 hltdc->State = HAL_LTDC_STATE_BUSY;
977
978 /* Enable LTDC color keying by setting COLKEN bit */
979 LTDC_LAYER(hltdc, LayerIdx)->CR |= (uint32_t)LTDC_LxCR_COLKEN;
980
981 /* Set the Immediate Reload type */
982 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
983
984 /* Change the LTDC state*/
985 hltdc->State = HAL_LTDC_STATE_READY;
986
987 /* Process unlocked */
988 __HAL_UNLOCK(hltdc);
989
990 return HAL_OK;
991}
992
1002HAL_StatusTypeDef HAL_LTDC_DisableColorKeying(LTDC_HandleTypeDef *hltdc, uint32_t LayerIdx)
1003{
1004 /* Check the parameters */
1005 assert_param(IS_LTDC_LAYER(LayerIdx));
1006
1007 /* Process locked */
1008 __HAL_LOCK(hltdc);
1009
1010 /* Change LTDC peripheral state */
1011 hltdc->State = HAL_LTDC_STATE_BUSY;
1012
1013 /* Disable LTDC color keying by setting COLKEN bit */
1014 LTDC_LAYER(hltdc, LayerIdx)->CR &= ~(uint32_t)LTDC_LxCR_COLKEN;
1015
1016 /* Set the Immediate Reload type */
1017 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
1018
1019 /* Change the LTDC state*/
1020 hltdc->State = HAL_LTDC_STATE_READY;
1021
1022 /* Process unlocked */
1023 __HAL_UNLOCK(hltdc);
1024
1025 return HAL_OK;
1026}
1027
1037HAL_StatusTypeDef HAL_LTDC_EnableCLUT(LTDC_HandleTypeDef *hltdc, uint32_t LayerIdx)
1038{
1039 /* Check the parameters */
1040 assert_param(IS_LTDC_LAYER(LayerIdx));
1041
1042 /* Process locked */
1043 __HAL_LOCK(hltdc);
1044
1045 /* Change LTDC peripheral state */
1046 hltdc->State = HAL_LTDC_STATE_BUSY;
1047
1048 /* Enable LTDC color lookup table by setting CLUTEN bit */
1049 LTDC_LAYER(hltdc, LayerIdx)->CR |= (uint32_t)LTDC_LxCR_CLUTEN;
1050
1051 /* Set the Immediate Reload type */
1052 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
1053
1054 /* Change the LTDC state*/
1055 hltdc->State = HAL_LTDC_STATE_READY;
1056
1057 /* Process unlocked */
1058 __HAL_UNLOCK(hltdc);
1059
1060 return HAL_OK;
1061}
1062
1072HAL_StatusTypeDef HAL_LTDC_DisableCLUT(LTDC_HandleTypeDef *hltdc, uint32_t LayerIdx)
1073{
1074 /* Check the parameters */
1075 assert_param(IS_LTDC_LAYER(LayerIdx));
1076
1077 /* Process locked */
1078 __HAL_LOCK(hltdc);
1079
1080 /* Change LTDC peripheral state */
1081 hltdc->State = HAL_LTDC_STATE_BUSY;
1082
1083 /* Disable LTDC color lookup table by setting CLUTEN bit */
1084 LTDC_LAYER(hltdc, LayerIdx)->CR &= ~(uint32_t)LTDC_LxCR_CLUTEN;
1085
1086 /* Set the Immediate Reload type */
1087 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
1088
1089 /* Change the LTDC state*/
1090 hltdc->State = HAL_LTDC_STATE_READY;
1091
1092 /* Process unlocked */
1093 __HAL_UNLOCK(hltdc);
1094
1095 return HAL_OK;
1096}
1097
1104
1105HAL_StatusTypeDef HAL_LTDC_EnableDither(LTDC_HandleTypeDef *hltdc)
1106{
1107 /* Process locked */
1108 __HAL_LOCK(hltdc);
1109
1110 /* Change LTDC peripheral state */
1111 hltdc->State = HAL_LTDC_STATE_BUSY;
1112
1113 /* Enable Dither by setting DTEN bit */
1114 LTDC->GCR |= (uint32_t)LTDC_GCR_DEN;
1115
1116 /* Change the LTDC state*/
1117 hltdc->State = HAL_LTDC_STATE_READY;
1118
1119 /* Process unlocked */
1120 __HAL_UNLOCK(hltdc);
1121
1122 return HAL_OK;
1123}
1124
1131
1132HAL_StatusTypeDef HAL_LTDC_DisableDither(LTDC_HandleTypeDef *hltdc)
1133{
1134 /* Process locked */
1135 __HAL_LOCK(hltdc);
1136
1137 /* Change LTDC peripheral state */
1138 hltdc->State = HAL_LTDC_STATE_BUSY;
1139
1140 /* Disable Dither by setting DTEN bit */
1141 LTDC->GCR &= ~(uint32_t)LTDC_GCR_DEN;
1142
1143 /* Change the LTDC state*/
1144 hltdc->State = HAL_LTDC_STATE_READY;
1145
1146 /* Process unlocked */
1147 __HAL_UNLOCK(hltdc);
1148
1149 return HAL_OK;
1150}
1151
1163HAL_StatusTypeDef HAL_LTDC_SetWindowSize(LTDC_HandleTypeDef *hltdc, uint32_t XSize, uint32_t YSize, uint32_t LayerIdx)
1164{
1165 LTDC_LayerCfgTypeDef *pLayerCfg;
1166
1167 /* Check the parameters (Layers parameters)*/
1168 assert_param(IS_LTDC_LAYER(LayerIdx));
1169 assert_param(IS_LTDC_CFBLL(XSize));
1170 assert_param(IS_LTDC_CFBLNBR(YSize));
1171
1172 /* Process locked */
1173 __HAL_LOCK(hltdc);
1174
1175 /* Change LTDC peripheral state */
1176 hltdc->State = HAL_LTDC_STATE_BUSY;
1177
1178 /* Get layer configuration from handle structure */
1179 pLayerCfg = &hltdc->LayerCfg[LayerIdx];
1180
1181 /* update horizontal stop */
1182 pLayerCfg->WindowX1 = XSize + pLayerCfg->WindowX0;
1183
1184 /* update vertical stop */
1185 pLayerCfg->WindowY1 = YSize + pLayerCfg->WindowY0;
1186
1187 /* Reconfigures the color frame buffer pitch in byte */
1188 pLayerCfg->ImageWidth = XSize;
1189
1190 /* Reconfigures the frame buffer line number */
1191 pLayerCfg->ImageHeight = YSize;
1192
1193 /* Set LTDC parameters */
1194 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
1195
1196 /* Set the Immediate Reload type */
1197 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
1198
1199 /* Change the LTDC state*/
1200 hltdc->State = HAL_LTDC_STATE_READY;
1201
1202 /* Process unlocked */
1203 __HAL_UNLOCK(hltdc);
1204
1205 return HAL_OK;
1206}
1207
1219HAL_StatusTypeDef HAL_LTDC_SetWindowPosition(LTDC_HandleTypeDef *hltdc, uint32_t X0, uint32_t Y0, uint32_t LayerIdx)
1220{
1221 LTDC_LayerCfgTypeDef *pLayerCfg;
1222
1223 /* Check the parameters */
1224 assert_param(IS_LTDC_LAYER(LayerIdx));
1225 assert_param(IS_LTDC_CFBLL(X0));
1226 assert_param(IS_LTDC_CFBLNBR(Y0));
1227
1228 /* Process locked */
1229 __HAL_LOCK(hltdc);
1230
1231 /* Change LTDC peripheral state */
1232 hltdc->State = HAL_LTDC_STATE_BUSY;
1233
1234 /* Get layer configuration from handle structure */
1235 pLayerCfg = &hltdc->LayerCfg[LayerIdx];
1236
1237 /* update horizontal start/stop */
1238 pLayerCfg->WindowX0 = X0;
1239 pLayerCfg->WindowX1 = X0 + pLayerCfg->ImageWidth;
1240
1241 /* update vertical start/stop */
1242 pLayerCfg->WindowY0 = Y0;
1243 pLayerCfg->WindowY1 = Y0 + pLayerCfg->ImageHeight;
1244
1245 /* Set LTDC parameters */
1246 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
1247
1248 /* Set the Immediate Reload type */
1249 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
1250
1251 /* Change the LTDC state*/
1252 hltdc->State = HAL_LTDC_STATE_READY;
1253
1254 /* Process unlocked */
1255 __HAL_UNLOCK(hltdc);
1256
1257 return HAL_OK;
1258}
1259
1270HAL_StatusTypeDef HAL_LTDC_SetPixelFormat(LTDC_HandleTypeDef *hltdc, uint32_t Pixelformat, uint32_t LayerIdx)
1271{
1272 LTDC_LayerCfgTypeDef *pLayerCfg;
1273
1274 /* Check the parameters */
1275 assert_param(IS_LTDC_PIXEL_FORMAT(Pixelformat));
1276 assert_param(IS_LTDC_LAYER(LayerIdx));
1277
1278 /* Process locked */
1279 __HAL_LOCK(hltdc);
1280
1281 /* Change LTDC peripheral state */
1282 hltdc->State = HAL_LTDC_STATE_BUSY;
1283
1284 /* Get layer configuration from handle structure */
1285 pLayerCfg = &hltdc->LayerCfg[LayerIdx];
1286
1287 /* Reconfigure the pixel format */
1288 pLayerCfg->PixelFormat = Pixelformat;
1289
1290 /* Set LTDC parameters */
1291 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
1292
1293 /* Set the Immediate Reload type */
1294 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
1295
1296 /* Change the LTDC state*/
1297 hltdc->State = HAL_LTDC_STATE_READY;
1298
1299 /* Process unlocked */
1300 __HAL_UNLOCK(hltdc);
1301
1302 return HAL_OK;
1303}
1304
1315HAL_StatusTypeDef HAL_LTDC_SetAlpha(LTDC_HandleTypeDef *hltdc, uint32_t Alpha, uint32_t LayerIdx)
1316{
1317 LTDC_LayerCfgTypeDef *pLayerCfg;
1318
1319 /* Check the parameters */
1320 assert_param(IS_LTDC_ALPHA(Alpha));
1321 assert_param(IS_LTDC_LAYER(LayerIdx));
1322
1323 /* Process locked */
1324 __HAL_LOCK(hltdc);
1325
1326 /* Change LTDC peripheral state */
1327 hltdc->State = HAL_LTDC_STATE_BUSY;
1328
1329 /* Get layer configuration from handle structure */
1330 pLayerCfg = &hltdc->LayerCfg[LayerIdx];
1331
1332 /* Reconfigure the Alpha value */
1333 pLayerCfg->Alpha = Alpha;
1334
1335 /* Set LTDC parameters */
1336 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
1337
1338 /* Set the Immediate Reload type */
1339 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
1340
1341 /* Change the LTDC state*/
1342 hltdc->State = HAL_LTDC_STATE_READY;
1343
1344 /* Process unlocked */
1345 __HAL_UNLOCK(hltdc);
1346
1347 return HAL_OK;
1348}
1359HAL_StatusTypeDef HAL_LTDC_SetAddress(LTDC_HandleTypeDef *hltdc, uint32_t Address, uint32_t LayerIdx)
1360{
1361 LTDC_LayerCfgTypeDef *pLayerCfg;
1362
1363 /* Check the parameters */
1364 assert_param(IS_LTDC_LAYER(LayerIdx));
1365
1366 /* Process locked */
1367 __HAL_LOCK(hltdc);
1368
1369 /* Change LTDC peripheral state */
1370 hltdc->State = HAL_LTDC_STATE_BUSY;
1371
1372 /* Get layer configuration from handle structure */
1373 pLayerCfg = &hltdc->LayerCfg[LayerIdx];
1374
1375 /* Reconfigure the Address */
1376 pLayerCfg->FBStartAdress = Address;
1377
1378 /* Set LTDC parameters */
1379 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
1380
1381 /* Set the Immediate Reload type */
1382 hltdc->Instance->SRCR = LTDC_SRCR_IMR;
1383
1384 /* Change the LTDC state*/
1385 hltdc->State = HAL_LTDC_STATE_READY;
1386
1387 /* Process unlocked */
1388 __HAL_UNLOCK(hltdc);
1389
1390 return HAL_OK;
1391}
1392
1408HAL_StatusTypeDef HAL_LTDC_SetPitch(LTDC_HandleTypeDef *hltdc, uint32_t LinePitchInPixels, uint32_t LayerIdx)
1409{
1410 uint32_t tmp;
1411 uint32_t pitchUpdate;
1412 uint32_t pixelFormat;
1413
1414 /* Check the parameters */
1415 assert_param(IS_LTDC_LAYER(LayerIdx));
1416
1417 /* Process locked */
1418 __HAL_LOCK(hltdc);
1419
1420 /* Change LTDC peripheral state */
1421 hltdc->State = HAL_LTDC_STATE_BUSY;
1422
1423 /* get LayerIdx used pixel format */
1424 pixelFormat = hltdc->LayerCfg[LayerIdx].PixelFormat;
1425
1426 if (pixelFormat == LTDC_PIXEL_FORMAT_ARGB8888)
1427 {
1428 tmp = 4U;
1429 }
1430 else if (pixelFormat == LTDC_PIXEL_FORMAT_RGB888)
1431 {
1432 tmp = 3U;
1433 }
1434 else if ((pixelFormat == LTDC_PIXEL_FORMAT_ARGB4444) || \
1435 (pixelFormat == LTDC_PIXEL_FORMAT_RGB565) || \
1436 (pixelFormat == LTDC_PIXEL_FORMAT_ARGB1555) || \
1437 (pixelFormat == LTDC_PIXEL_FORMAT_AL88))
1438 {
1439 tmp = 2U;
1440 }
1441 else
1442 {
1443 tmp = 1U;
1444 }
1445
1446 pitchUpdate = ((LinePitchInPixels * tmp) << 16U);
1447
1448 /* Clear previously set standard pitch */
1449 LTDC_LAYER(hltdc, LayerIdx)->CFBLR &= ~LTDC_LxCFBLR_CFBP;
1450
1451 /* Set the Reload type as immediate update of LTDC pitch configured above */
1452 LTDC->SRCR |= LTDC_SRCR_IMR;
1453
1454 /* Set new line pitch value */
1455 LTDC_LAYER(hltdc, LayerIdx)->CFBLR |= pitchUpdate;
1456
1457 /* Set the Reload type as immediate update of LTDC pitch configured above */
1458 LTDC->SRCR |= LTDC_SRCR_IMR;
1459
1460 /* Change the LTDC state*/
1461 hltdc->State = HAL_LTDC_STATE_READY;
1462
1463 /* Process unlocked */
1464 __HAL_UNLOCK(hltdc);
1465
1466 return HAL_OK;
1467}
1468
1477HAL_StatusTypeDef HAL_LTDC_ProgramLineEvent(LTDC_HandleTypeDef *hltdc, uint32_t Line)
1478{
1479 /* Check the parameters */
1480 assert_param(IS_LTDC_LIPOS(Line));
1481
1482 /* Process locked */
1483 __HAL_LOCK(hltdc);
1484
1485 /* Change LTDC peripheral state */
1486 hltdc->State = HAL_LTDC_STATE_BUSY;
1487
1488 /* Disable the Line interrupt */
1489 __HAL_LTDC_DISABLE_IT(hltdc, LTDC_IT_LI);
1490
1491 /* Set the Line Interrupt position */
1492 LTDC->LIPCR = (uint32_t)Line;
1493
1494 /* Enable the Line interrupt */
1495 __HAL_LTDC_ENABLE_IT(hltdc, LTDC_IT_LI);
1496
1497 /* Change the LTDC state*/
1498 hltdc->State = HAL_LTDC_STATE_READY;
1499
1500 /* Process unlocked */
1501 __HAL_UNLOCK(hltdc);
1502
1503 return HAL_OK;
1504}
1505
1516HAL_StatusTypeDef HAL_LTDC_Reload(LTDC_HandleTypeDef *hltdc, uint32_t ReloadType)
1517{
1518 /* Check the parameters */
1519 assert_param(IS_LTDC_RELOAD(ReloadType));
1520
1521 /* Process locked */
1522 __HAL_LOCK(hltdc);
1523
1524 /* Change LTDC peripheral state */
1525 hltdc->State = HAL_LTDC_STATE_BUSY;
1526
1527 /* Enable the Reload interrupt */
1528 __HAL_LTDC_ENABLE_IT(hltdc, LTDC_IT_RR);
1529
1530 /* Apply Reload type */
1531 hltdc->Instance->SRCR = ReloadType;
1532
1533 /* Change the LTDC state*/
1534 hltdc->State = HAL_LTDC_STATE_READY;
1535
1536 /* Process unlocked */
1537 __HAL_UNLOCK(hltdc);
1538
1539 return HAL_OK;
1540}
1541
1555HAL_StatusTypeDef HAL_LTDC_ConfigLayer_NoReload(LTDC_HandleTypeDef *hltdc, LTDC_LayerCfgTypeDef *pLayerCfg,
1556 uint32_t LayerIdx)
1557{
1558 /* Check the parameters */
1559 assert_param(IS_LTDC_LAYER(LayerIdx));
1560 assert_param(IS_LTDC_HCONFIGST(pLayerCfg->WindowX0));
1561 assert_param(IS_LTDC_HCONFIGSP(pLayerCfg->WindowX1));
1562 assert_param(IS_LTDC_VCONFIGST(pLayerCfg->WindowY0));
1563 assert_param(IS_LTDC_VCONFIGSP(pLayerCfg->WindowY1));
1564 assert_param(IS_LTDC_PIXEL_FORMAT(pLayerCfg->PixelFormat));
1565 assert_param(IS_LTDC_ALPHA(pLayerCfg->Alpha));
1566 assert_param(IS_LTDC_ALPHA(pLayerCfg->Alpha0));
1567 assert_param(IS_LTDC_BLENDING_FACTOR1(pLayerCfg->BlendingFactor1));
1568 assert_param(IS_LTDC_BLENDING_FACTOR2(pLayerCfg->BlendingFactor2));
1569 assert_param(IS_LTDC_CFBLL(pLayerCfg->ImageWidth));
1570 assert_param(IS_LTDC_CFBLNBR(pLayerCfg->ImageHeight));
1571
1572 /* Process locked */
1573 __HAL_LOCK(hltdc);
1574
1575 /* Change LTDC peripheral state */
1576 hltdc->State = HAL_LTDC_STATE_BUSY;
1577
1578 /* Copy new layer configuration into handle structure */
1579 hltdc->LayerCfg[LayerIdx] = *pLayerCfg;
1580
1581 /* Configure the LTDC Layer */
1582 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
1583
1584 /* Initialize the LTDC state*/
1585 hltdc->State = HAL_LTDC_STATE_READY;
1586
1587 /* Process unlocked */
1588 __HAL_UNLOCK(hltdc);
1589
1590 return HAL_OK;
1591}
1592
1605HAL_StatusTypeDef HAL_LTDC_SetWindowSize_NoReload(LTDC_HandleTypeDef *hltdc, uint32_t XSize, uint32_t YSize,
1606 uint32_t LayerIdx)
1607{
1608 LTDC_LayerCfgTypeDef *pLayerCfg;
1609
1610 /* Check the parameters (Layers parameters)*/
1611 assert_param(IS_LTDC_LAYER(LayerIdx));
1612 assert_param(IS_LTDC_CFBLL(XSize));
1613 assert_param(IS_LTDC_CFBLNBR(YSize));
1614
1615 /* Process locked */
1616 __HAL_LOCK(hltdc);
1617
1618 /* Change LTDC peripheral state */
1619 hltdc->State = HAL_LTDC_STATE_BUSY;
1620
1621 /* Get layer configuration from handle structure */
1622 pLayerCfg = &hltdc->LayerCfg[LayerIdx];
1623
1624 /* update horizontal stop */
1625 pLayerCfg->WindowX1 = XSize + pLayerCfg->WindowX0;
1626
1627 /* update vertical stop */
1628 pLayerCfg->WindowY1 = YSize + pLayerCfg->WindowY0;
1629
1630 /* Reconfigures the color frame buffer pitch in byte */
1631 pLayerCfg->ImageWidth = XSize;
1632
1633 /* Reconfigures the frame buffer line number */
1634 pLayerCfg->ImageHeight = YSize;
1635
1636 /* Set LTDC parameters */
1637 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
1638
1639 /* Change the LTDC state*/
1640 hltdc->State = HAL_LTDC_STATE_READY;
1641
1642 /* Process unlocked */
1643 __HAL_UNLOCK(hltdc);
1644
1645 return HAL_OK;
1646}
1647
1660HAL_StatusTypeDef HAL_LTDC_SetWindowPosition_NoReload(LTDC_HandleTypeDef *hltdc, uint32_t X0, uint32_t Y0,
1661 uint32_t LayerIdx)
1662{
1663 LTDC_LayerCfgTypeDef *pLayerCfg;
1664
1665 /* Check the parameters */
1666 assert_param(IS_LTDC_LAYER(LayerIdx));
1667 assert_param(IS_LTDC_CFBLL(X0));
1668 assert_param(IS_LTDC_CFBLNBR(Y0));
1669
1670 /* Process locked */
1671 __HAL_LOCK(hltdc);
1672
1673 /* Change LTDC peripheral state */
1674 hltdc->State = HAL_LTDC_STATE_BUSY;
1675
1676 /* Get layer configuration from handle structure */
1677 pLayerCfg = &hltdc->LayerCfg[LayerIdx];
1678
1679 /* update horizontal start/stop */
1680 pLayerCfg->WindowX0 = X0;
1681 pLayerCfg->WindowX1 = X0 + pLayerCfg->ImageWidth;
1682
1683 /* update vertical start/stop */
1684 pLayerCfg->WindowY0 = Y0;
1685 pLayerCfg->WindowY1 = Y0 + pLayerCfg->ImageHeight;
1686
1687 /* Set LTDC parameters */
1688 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
1689
1690 /* Change the LTDC state*/
1691 hltdc->State = HAL_LTDC_STATE_READY;
1692
1693 /* Process unlocked */
1694 __HAL_UNLOCK(hltdc);
1695
1696 return HAL_OK;
1697}
1698
1710HAL_StatusTypeDef HAL_LTDC_SetPixelFormat_NoReload(LTDC_HandleTypeDef *hltdc, uint32_t Pixelformat, uint32_t LayerIdx)
1711{
1712 LTDC_LayerCfgTypeDef *pLayerCfg;
1713
1714 /* Check the parameters */
1715 assert_param(IS_LTDC_PIXEL_FORMAT(Pixelformat));
1716 assert_param(IS_LTDC_LAYER(LayerIdx));
1717
1718 /* Process locked */
1719 __HAL_LOCK(hltdc);
1720
1721 /* Change LTDC peripheral state */
1722 hltdc->State = HAL_LTDC_STATE_BUSY;
1723
1724 /* Get layer configuration from handle structure */
1725 pLayerCfg = &hltdc->LayerCfg[LayerIdx];
1726
1727 /* Reconfigure the pixel format */
1728 pLayerCfg->PixelFormat = Pixelformat;
1729
1730 /* Set LTDC parameters */
1731 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
1732
1733 /* Change the LTDC state*/
1734 hltdc->State = HAL_LTDC_STATE_READY;
1735
1736 /* Process unlocked */
1737 __HAL_UNLOCK(hltdc);
1738
1739 return HAL_OK;
1740}
1741
1753HAL_StatusTypeDef HAL_LTDC_SetAlpha_NoReload(LTDC_HandleTypeDef *hltdc, uint32_t Alpha, uint32_t LayerIdx)
1754{
1755 LTDC_LayerCfgTypeDef *pLayerCfg;
1756
1757 /* Check the parameters */
1758 assert_param(IS_LTDC_ALPHA(Alpha));
1759 assert_param(IS_LTDC_LAYER(LayerIdx));
1760
1761 /* Process locked */
1762 __HAL_LOCK(hltdc);
1763
1764 /* Change LTDC peripheral state */
1765 hltdc->State = HAL_LTDC_STATE_BUSY;
1766
1767 /* Get layer configuration from handle structure */
1768 pLayerCfg = &hltdc->LayerCfg[LayerIdx];
1769
1770 /* Reconfigure the Alpha value */
1771 pLayerCfg->Alpha = Alpha;
1772
1773 /* Set LTDC parameters */
1774 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
1775
1776 /* Change the LTDC state*/
1777 hltdc->State = HAL_LTDC_STATE_READY;
1778
1779 /* Process unlocked */
1780 __HAL_UNLOCK(hltdc);
1781
1782 return HAL_OK;
1783}
1784
1796HAL_StatusTypeDef HAL_LTDC_SetAddress_NoReload(LTDC_HandleTypeDef *hltdc, uint32_t Address, uint32_t LayerIdx)
1797{
1798 LTDC_LayerCfgTypeDef *pLayerCfg;
1799
1800 /* Check the parameters */
1801 assert_param(IS_LTDC_LAYER(LayerIdx));
1802
1803 /* Process locked */
1804 __HAL_LOCK(hltdc);
1805
1806 /* Change LTDC peripheral state */
1807 hltdc->State = HAL_LTDC_STATE_BUSY;
1808
1809 /* Get layer configuration from handle structure */
1810 pLayerCfg = &hltdc->LayerCfg[LayerIdx];
1811
1812 /* Reconfigure the Address */
1813 pLayerCfg->FBStartAdress = Address;
1814
1815 /* Set LTDC parameters */
1816 LTDC_SetConfig(hltdc, pLayerCfg, LayerIdx);
1817
1818 /* Change the LTDC state*/
1819 hltdc->State = HAL_LTDC_STATE_READY;
1820
1821 /* Process unlocked */
1822 __HAL_UNLOCK(hltdc);
1823
1824 return HAL_OK;
1825}
1826
1843HAL_StatusTypeDef HAL_LTDC_SetPitch_NoReload(LTDC_HandleTypeDef *hltdc, uint32_t LinePitchInPixels, uint32_t LayerIdx)
1844{
1845 uint32_t tmp;
1846 uint32_t pitchUpdate;
1847 uint32_t pixelFormat;
1848
1849 /* Check the parameters */
1850 assert_param(IS_LTDC_LAYER(LayerIdx));
1851
1852 /* Process locked */
1853 __HAL_LOCK(hltdc);
1854
1855 /* Change LTDC peripheral state */
1856 hltdc->State = HAL_LTDC_STATE_BUSY;
1857
1858 /* get LayerIdx used pixel format */
1859 pixelFormat = hltdc->LayerCfg[LayerIdx].PixelFormat;
1860
1861 if (pixelFormat == LTDC_PIXEL_FORMAT_ARGB8888)
1862 {
1863 tmp = 4U;
1864 }
1865 else if (pixelFormat == LTDC_PIXEL_FORMAT_RGB888)
1866 {
1867 tmp = 3U;
1868 }
1869 else if ((pixelFormat == LTDC_PIXEL_FORMAT_ARGB4444) || \
1870 (pixelFormat == LTDC_PIXEL_FORMAT_RGB565) || \
1871 (pixelFormat == LTDC_PIXEL_FORMAT_ARGB1555) || \
1872 (pixelFormat == LTDC_PIXEL_FORMAT_AL88))
1873 {
1874 tmp = 2U;
1875 }
1876 else
1877 {
1878 tmp = 1U;
1879 }
1880
1881 pitchUpdate = ((LinePitchInPixels * tmp) << 16U);
1882
1883 /* Clear previously set standard pitch */
1884 LTDC_LAYER(hltdc, LayerIdx)->CFBLR &= ~LTDC_LxCFBLR_CFBP;
1885
1886 /* Set new line pitch value */
1887 LTDC_LAYER(hltdc, LayerIdx)->CFBLR |= pitchUpdate;
1888
1889 /* Change the LTDC state*/
1890 hltdc->State = HAL_LTDC_STATE_READY;
1891
1892 /* Process unlocked */
1893 __HAL_UNLOCK(hltdc);
1894
1895 return HAL_OK;
1896}
1897
1898
1910HAL_StatusTypeDef HAL_LTDC_ConfigColorKeying_NoReload(LTDC_HandleTypeDef *hltdc, uint32_t RGBValue, uint32_t LayerIdx)
1911{
1912 /* Check the parameters */
1913 assert_param(IS_LTDC_LAYER(LayerIdx));
1914
1915 /* Process locked */
1916 __HAL_LOCK(hltdc);
1917
1918 /* Change LTDC peripheral state */
1919 hltdc->State = HAL_LTDC_STATE_BUSY;
1920
1921 /* Configure the default color values */
1922 LTDC_LAYER(hltdc, LayerIdx)->CKCR &= ~(LTDC_LxCKCR_CKBLUE | LTDC_LxCKCR_CKGREEN | LTDC_LxCKCR_CKRED);
1923 LTDC_LAYER(hltdc, LayerIdx)->CKCR = RGBValue;
1924
1925 /* Change the LTDC state*/
1926 hltdc->State = HAL_LTDC_STATE_READY;
1927
1928 /* Process unlocked */
1929 __HAL_UNLOCK(hltdc);
1930
1931 return HAL_OK;
1932}
1933
1944HAL_StatusTypeDef HAL_LTDC_EnableColorKeying_NoReload(LTDC_HandleTypeDef *hltdc, uint32_t LayerIdx)
1945{
1946 /* Check the parameters */
1947 assert_param(IS_LTDC_LAYER(LayerIdx));
1948
1949 /* Process locked */
1950 __HAL_LOCK(hltdc);
1951
1952 /* Change LTDC peripheral state */
1953 hltdc->State = HAL_LTDC_STATE_BUSY;
1954
1955 /* Enable LTDC color keying by setting COLKEN bit */
1956 LTDC_LAYER(hltdc, LayerIdx)->CR |= (uint32_t)LTDC_LxCR_COLKEN;
1957
1958 /* Change the LTDC state*/
1959 hltdc->State = HAL_LTDC_STATE_READY;
1960
1961 /* Process unlocked */
1962 __HAL_UNLOCK(hltdc);
1963
1964 return HAL_OK;
1965}
1966
1977HAL_StatusTypeDef HAL_LTDC_DisableColorKeying_NoReload(LTDC_HandleTypeDef *hltdc, uint32_t LayerIdx)
1978{
1979 /* Check the parameters */
1980 assert_param(IS_LTDC_LAYER(LayerIdx));
1981
1982 /* Process locked */
1983 __HAL_LOCK(hltdc);
1984
1985 /* Change LTDC peripheral state */
1986 hltdc->State = HAL_LTDC_STATE_BUSY;
1987
1988 /* Disable LTDC color keying by setting COLKEN bit */
1989 LTDC_LAYER(hltdc, LayerIdx)->CR &= ~(uint32_t)LTDC_LxCR_COLKEN;
1990
1991 /* Change the LTDC state*/
1992 hltdc->State = HAL_LTDC_STATE_READY;
1993
1994 /* Process unlocked */
1995 __HAL_UNLOCK(hltdc);
1996
1997 return HAL_OK;
1998}
1999
2010HAL_StatusTypeDef HAL_LTDC_EnableCLUT_NoReload(LTDC_HandleTypeDef *hltdc, uint32_t LayerIdx)
2011{
2012 /* Check the parameters */
2013 assert_param(IS_LTDC_LAYER(LayerIdx));
2014
2015 /* Process locked */
2016 __HAL_LOCK(hltdc);
2017
2018 /* Change LTDC peripheral state */
2019 hltdc->State = HAL_LTDC_STATE_BUSY;
2020
2021 /* Disable LTDC color lookup table by setting CLUTEN bit */
2022 LTDC_LAYER(hltdc, LayerIdx)->CR |= (uint32_t)LTDC_LxCR_CLUTEN;
2023
2024 /* Change the LTDC state*/
2025 hltdc->State = HAL_LTDC_STATE_READY;
2026
2027 /* Process unlocked */
2028 __HAL_UNLOCK(hltdc);
2029
2030 return HAL_OK;
2031}
2032
2043HAL_StatusTypeDef HAL_LTDC_DisableCLUT_NoReload(LTDC_HandleTypeDef *hltdc, uint32_t LayerIdx)
2044{
2045 /* Check the parameters */
2046 assert_param(IS_LTDC_LAYER(LayerIdx));
2047
2048 /* Process locked */
2049 __HAL_LOCK(hltdc);
2050
2051 /* Change LTDC peripheral state */
2052 hltdc->State = HAL_LTDC_STATE_BUSY;
2053
2054 /* Disable LTDC color lookup table by setting CLUTEN bit */
2055 LTDC_LAYER(hltdc, LayerIdx)->CR &= ~(uint32_t)LTDC_LxCR_CLUTEN;
2056
2057 /* Change the LTDC state*/
2058 hltdc->State = HAL_LTDC_STATE_READY;
2059
2060 /* Process unlocked */
2061 __HAL_UNLOCK(hltdc);
2062
2063 return HAL_OK;
2064}
2065
2069
2085
2092HAL_LTDC_StateTypeDef HAL_LTDC_GetState(const LTDC_HandleTypeDef *hltdc)
2093{
2094 return hltdc->State;
2095}
2096
2103uint32_t HAL_LTDC_GetError(const LTDC_HandleTypeDef *hltdc)
2104{
2105 return hltdc->ErrorCode;
2106}
2107
2111
2115
2119
2129static void LTDC_SetConfig(LTDC_HandleTypeDef *hltdc, LTDC_LayerCfgTypeDef *pLayerCfg, uint32_t LayerIdx)
2130{
2131 uint32_t tmp;
2132 uint32_t tmp1;
2133 uint32_t tmp2;
2134
2135 /* Configure the horizontal start and stop position */
2136 tmp = ((pLayerCfg->WindowX1 + ((hltdc->Instance->BPCR & LTDC_BPCR_AHBP) >> 16U)) << 16U);
2137 LTDC_LAYER(hltdc, LayerIdx)->WHPCR &= ~(LTDC_LxWHPCR_WHSTPOS | LTDC_LxWHPCR_WHSPPOS);
2138 LTDC_LAYER(hltdc, LayerIdx)->WHPCR = ((pLayerCfg->WindowX0 + \
2139 ((hltdc->Instance->BPCR & LTDC_BPCR_AHBP) >> 16U) + 1U) | tmp);
2140
2141 /* Configure the vertical start and stop position */
2142 tmp = ((pLayerCfg->WindowY1 + (hltdc->Instance->BPCR & LTDC_BPCR_AVBP)) << 16U);
2143 LTDC_LAYER(hltdc, LayerIdx)->WVPCR &= ~(LTDC_LxWVPCR_WVSTPOS | LTDC_LxWVPCR_WVSPPOS);
2144 LTDC_LAYER(hltdc, LayerIdx)->WVPCR = ((pLayerCfg->WindowY0 + (hltdc->Instance->BPCR & LTDC_BPCR_AVBP) + 1U) | tmp);
2145
2146 /* Specifies the pixel format */
2147 LTDC_LAYER(hltdc, LayerIdx)->PFCR &= ~(LTDC_LxPFCR_PF);
2148 LTDC_LAYER(hltdc, LayerIdx)->PFCR = (pLayerCfg->PixelFormat);
2149
2150 /* Configure the default color values */
2151 tmp = ((uint32_t)(pLayerCfg->Backcolor.Green) << 8U);
2152 tmp1 = ((uint32_t)(pLayerCfg->Backcolor.Red) << 16U);
2153 tmp2 = (pLayerCfg->Alpha0 << 24U);
2154 WRITE_REG(LTDC_LAYER(hltdc, LayerIdx)->DCCR, (pLayerCfg->Backcolor.Blue | tmp | tmp1 | tmp2));
2155
2156 /* Specifies the constant alpha value */
2157 LTDC_LAYER(hltdc, LayerIdx)->CACR &= ~(LTDC_LxCACR_CONSTA);
2158 LTDC_LAYER(hltdc, LayerIdx)->CACR = (pLayerCfg->Alpha);
2159
2160 /* Specifies the blending factors */
2161 LTDC_LAYER(hltdc, LayerIdx)->BFCR &= ~(LTDC_LxBFCR_BF2 | LTDC_LxBFCR_BF1);
2162 LTDC_LAYER(hltdc, LayerIdx)->BFCR = (pLayerCfg->BlendingFactor1 | pLayerCfg->BlendingFactor2);
2163
2164 /* Configure the color frame buffer start address */
2165 WRITE_REG(LTDC_LAYER(hltdc, LayerIdx)->CFBAR, pLayerCfg->FBStartAdress);
2166
2167 if (pLayerCfg->PixelFormat == LTDC_PIXEL_FORMAT_ARGB8888)
2168 {
2169 tmp = 4U;
2170 }
2171 else if (pLayerCfg->PixelFormat == LTDC_PIXEL_FORMAT_RGB888)
2172 {
2173 tmp = 3U;
2174 }
2175 else if ((pLayerCfg->PixelFormat == LTDC_PIXEL_FORMAT_ARGB4444) || \
2176 (pLayerCfg->PixelFormat == LTDC_PIXEL_FORMAT_RGB565) || \
2177 (pLayerCfg->PixelFormat == LTDC_PIXEL_FORMAT_ARGB1555) || \
2178 (pLayerCfg->PixelFormat == LTDC_PIXEL_FORMAT_AL88))
2179 {
2180 tmp = 2U;
2181 }
2182 else
2183 {
2184 tmp = 1U;
2185 }
2186
2187 /* Configure the color frame buffer pitch in byte */
2188 LTDC_LAYER(hltdc, LayerIdx)->CFBLR &= ~(LTDC_LxCFBLR_CFBLL | LTDC_LxCFBLR_CFBP);
2189 LTDC_LAYER(hltdc, LayerIdx)->CFBLR = (((pLayerCfg->ImageWidth * tmp) << 16U) | \
2190 (((pLayerCfg->WindowX1 - pLayerCfg->WindowX0) * tmp) + 3U));
2191 /* Configure the frame buffer line number */
2192 LTDC_LAYER(hltdc, LayerIdx)->CFBLNR &= ~(LTDC_LxCFBLNR_CFBLNBR);
2193 LTDC_LAYER(hltdc, LayerIdx)->CFBLNR = (pLayerCfg->ImageHeight);
2194
2195 /* Enable LTDC_Layer by setting LEN bit */
2196 LTDC_LAYER(hltdc, LayerIdx)->CR |= (uint32_t)LTDC_LxCR_LEN;
2197}
2198
2202
2203
2207
2208#endif /* LTDC */
2209
2210#endif /* HAL_LTDC_MODULE_ENABLED */
2211
2215
HAL_GetTick
uint32_t HAL_GetTick(void)
Provides a tick value in millisecond.
Definition stm32f4xx_hal.c:323
assert_param
#define assert_param(expr)
Definition stm32_assert_template.h:46
stm32f4xx_hal.h
This file contains all the functions prototypes for the HAL module driver.
HAL_StatusTypeDef
HAL_StatusTypeDef
HAL Status structures definition.
Definition stm32f4xx_hal_def.h:39
HAL_ERROR
@ HAL_ERROR
Definition stm32f4xx_hal_def.h:41
HAL_OK
@ HAL_OK
Definition stm32f4xx_hal_def.h:40
__HAL_UNLOCK
#define __HAL_UNLOCK(__HANDLE__)
Definition stm32f4xx_hal_def.h:105
HAL_UNLOCKED
@ HAL_UNLOCKED
Definition stm32f4xx_hal_def.h:51
__HAL_LOCK
#define __HAL_LOCK(__HANDLE__)
Definition stm32f4xx_hal_def.h:93