一、硬件部分
1.1、LCD显示屏硬件接口部分电路




" }3 [5 Z5 \. B: ~# Z6 e4 S
" o0 N3 n3 `  M6 d4 I
1.2、LTDC显示内部框图
LTDC可驱动24位的RGB显示屏，内部有两个显示层

. i/ f1 {2 Q9 a- W: ]


二、配置LTDC

5 ~* L1 M. P4 z0 V1 e, Q/ \2.1、屏幕的参数设置
, h$ ?2 T! n: s  L, c# W4 F

& S0 r0 I) z' ?1 o) ?) [. ]1 {
2.2、层参数设置




2.3、LTDC引脚设置
5 o/ v) d6 q6 D- _  g3 ^4 y0 w



三、程序部分
: c. a+ o* R& L! {0 p# D1 d
3.1、在项目中添加LCD驱动程序
使用官方BSP中的LCD驱动程序
stm32n6570_discovery_lcd.c

1. /**
   
2.   ******************************************************************************
   
3.   * @file    stm32n6570_discovery_lcd.c
   % e4 A: l2 R9 l  r
4.   * @author  MCD Application Team
   
5.   * @brief   This file includes the driver for Liquid Crystal Display (LCD) module
   
6.   *          mounted on STM32N6570_DK board.
   
7.   ******************************************************************************
   
8.   * @attention
   * @+ }/ k! E$ j
9.   *
   
10.   * Copyright (c) 2022 STMicroelectronics.
    6 a9 T: \3 X4 D4 _) H- L/ o9 v
11.   * All rights reserved.
    ) F' f+ M( x2 `
12.   *
    
13.   * This software is licensed under terms that can be found in the LICENSE file
    
14.   * in the root directory of this software component.
    
15.   * If no LICENSE file comes with this software, it is provided AS-IS.
    % B, R1 {  {' b- y& R9 r2 C
16.   *
    % F1 Z" T& a2 k. x! `0 u
17.   ******************************************************************************
    
18.   @verbatim
    ( j7 K. ~' k4 _0 X( X: n
19.   How To use this driver:
    
20.   --------------------------
    
21.    - This driver is used to drive directly a LCD TFT using the LTDC controller.
    3 W+ S! n. Z/ W, F# u) U6 I( N5 I  o
22.    - This driver uses the adequate timing and setting for the RK050HR18 LCD component
    
23. 
    4 ~! Q4 @" j% \" C9 z- t& J, d
24.   Driver description:
    
25.   ---------------------
    
26.    + Initialization steps:
    
27.      o Initialize the LCD in default mode using the BSP_LCD_Init() function with the
    
28.        following settings:
    
29.         - Pixelformat : LCD_PIXEL_FORMAT_RGB888
    
30.         - Orientation : LCD_ORIENTATION_LANDSCAPE.
    3 h, c6 o* ]9 [) @/ I1 u
31.         - Width       : LCD_DEFAULT_WIDTH (800)
    
32.         - Height      : LCD_DEFAULT_HEIGHT(480)
    " T. [1 {" o. m' s2 H
33.        The default LTDC layer configured is layer 0.
    + V, B$ Q9 n$ u7 m( v# W$ U
34.        BSP_LCD_Init() includes LTDC, LTDC Layer and clock configurations by calling:
    
35.         - MX_LTDC_ClockConfig()
      [, Y3 _% c7 s7 o# x
36.         - MX_LTDC_Init()
    0 D+ C& |5 I& W* b. [
37.         - MX_LTDC_ConfigLayer()
    4 b) i, b5 L* i) h
38. 
    3 S0 \8 x. q* ]0 [/ l2 t# B4 e# k
39.      o Initialize the LCD with required parameters using the BSP_LCD_InitEx() function.
    
40. 
    . T( R8 z, R- \% \0 |% F' `
41.      o Select the LCD layer to be used using the BSP_LCD_SelectLayer() function.
    ; A4 p) V9 Z# @, C
42.      o Enable the LCD display using the BSP_LCD_DisplayOn() function.
    
43.      o Disable the LCD display using the BSP_LCD_DisplayOff() function.
    6 q/ F+ x2 w$ Z) p! k1 M8 \5 \
44.      o Write a pixel to the LCD memory using the BSP_LCD_WritePixel() function.
    2 O' W/ V2 b8 k
45.      o Read a pixel from the LCD memory using the BSP_LCD_ReadPixel() function.
    
46.      o Draw an horizontal line using the BSP_LCD_DrawHLine() function.
    
47.      o Draw a vertical line using the BSP_LCD_DrawVLine() function.
    
48.      o Draw a bitmap image using the BSP_LCD_DrawBitmap() function.
    
49. 
    , I7 P1 ~5 y6 n! Y
50.    + Options
    # g; V, l# {7 x" z& u3 _. \- k/ g
51.      o Configure the LTDC reload mode by calling BSP_LCD_Reload(). By default, the
    
52.        reload mode is set to BSP_LCD_RELOAD_IMMEDIATE then LTDC is reloaded immediately.
    
53.        To control the reload mode:
    
54.          - Call BSP_LCD_Reload() with ReloadType parameter set to BSP_LCD_RELOAD_NONE
    
55.          - Configure LTDC (color keying, transparency ..)
    + T1 i. Y0 e) l  U7 c
56.          - Call BSP_LCD_Reload() with ReloadType parameter set to BSP_LCD_RELOAD_IMMEDIATE
    
57.            for immediate reload or BSP_LCD_RELOAD_VERTICAL_BLANKING for LTDC reload
    
58.            in the next vertical blanking
    / h7 H$ U% ?1 d' @& I. _
59.      o Configure LTDC layers using BSP_LCD_ConfigLayer()
    5 r/ W4 `* Q" g. K
60.      o Control layer visibility using BSP_LCD_SetLayerVisible()
    9 t: j. V" u) V  {# d; [2 K! R) s
61.      o Configure and enable the color keying functionality using the
    3 D) B/ o8 Y: T. `6 Q
62.        BSP_LCD_SetColorKeying() function.
    
63.      o Disable the color keying functionality using the BSP_LCD_ResetColorKeying() function.
    
64.      o Modify on the fly the transparency and/or the frame buffer address
    3 f( `4 y3 d, E* o5 H) E
65.        using the following functions:
    6 w8 c0 {7 S4 S* I' }& c
66.        - BSP_LCD_SetTransparency()
    
67.        - BSP_LCD_SetLayerAddress()
    
68. 
    
69.    + Display on LCD
    
70.      o To draw and fill a basic shapes (dot, line, rectangle, circle, ellipse, .. bitmap)
    % e; I# w; l; p: g4 N4 h
71.        on LCD and display text, utility basic_gui.c/.h must be called. Once the LCD is initialized,
    , A# ~1 k. Q; L! h- d' @# Q# ]
72.        user should call GUI_SetFuncDriver() API to link board LCD drivers to BASIC GUI LCD drivers.
    1 H. j* X5 D: r: I
73.        The basic gui services, defined in basic_gui utility, are ready for use.
    ) R" d1 L; v% s8 t
74. 
    
75.   Note:
    
76.   --------
    
77.     Regarding the "Instance" parameter, needed for all functions, it is used to select
    
78.     an LCD instance. On the STM32N6570 Discovery board, there's one instance. Then, this
    
79.     parameter should be 0.
    1 ^$ A$ e2 V: o
80. 
    9 W0 y& z7 A+ a) d( n8 L* ?/ U; P$ z
81.   @endverbatim
    - T- ]# \% u$ G9 g
82.   ******************************************************************************
    ; Q8 G; c7 M2 D# B. M# l
83.   */
    
84. 
    
85. /* Includes ------------------------------------------------------------------*/
    
86. #include "stm32n6570_discovery_lcd.h"
    
87. 
    
88. /** @addtogroup BSP
    # @! z8 f( f, I! |, d
89.   * @{
    
90.   */
    " S. G/ R- u: ~1 q# G
91. 
    1 g1 Z) V( C* D& @" X( d
92. /** @addtogroup STM32N6570_DK
    / h+ a7 M" U- t1 o; i; i: B
93.   * @{
    4 X# G! o% o7 M1 d! G) C
94.   */
    ' t3 T4 Q5 [7 D' p+ f
95. 
    
96. /** @defgroup STM32N6570_DK_LCD LCD
    & W! y& G; @. R. u
97.   * @{
    / F9 ~* R+ o2 O  y* V  Y. c
98.   */
    . U" P4 J/ b5 k1 N8 z% I" M! ~8 j
99. 
    : v" l, R; E2 g  ?. Z
100. /** @defgroup STM32N6570_DK_LCD_Private_Variables LCD Private Variables
     
101.   * @{
     " R  B) P" t+ g% R+ P
102.   */
     . O! h* Y& ]& \; ]8 u* l+ @4 T- y
103. 
     ; r) e9 j1 z3 y* F: d$ l
104. /**
     ; i) ~7 J8 z% v  n5 F
105.   * @}
     3 W$ q% L  `# m9 q
106.   */
     ; h5 Q% w! X- L7 i; v
107. 
     / ?! X9 j% g- t9 w/ c8 ^
108. /** @defgroup STM32N6570_DK_LCD_Private_TypesDefinitions LCD Private TypesDefinitions
     
109.   * @{
     
110.   */
     
111. const LCD_UTILS_Drv_t LCD_Driver =
     
112. {
     
113.   BSP_LCD_DrawBitmap,
     
114.   BSP_LCD_FillRGBRect,
     
115.   BSP_LCD_DrawHLine,
     , a7 }" u( W: ]! B) q
116.   BSP_LCD_DrawVLine,
     
117.   BSP_LCD_FillRect,
     4 Y# y( z% A* M; b( {
118.   BSP_LCD_ReadPixel,
     
119.   BSP_LCD_WritePixel,
     
120.   BSP_LCD_GetXSize,
     
121.   BSP_LCD_GetYSize,
     
122.   BSP_LCD_SetActiveLayer,
     ( V$ B/ i4 n8 a1 ^
123.   BSP_LCD_GetPixelFormat
     2 H: a2 M# j" \5 u
124. };
     / k2 U9 c( Q+ e
125. 
     
126. /**
     
127.   * @}
     # B2 \( r- e: f: `0 k0 p. B
128.   */
     
129. 
     ) Q& U( U/ x1 D$ E' G( A
130. /** @defgroup STM32N6570_DK_LCD_Exported_Variables LCD Exported Variables
     
131.   * @{
     
132.   */
     , F5 \( y. Y9 V) T
133. DMA2D_HandleTypeDef hlcd_dma2d;
     
134. LTDC_HandleTypeDef  hlcd_ltdc;
     4 B) \* G& z1 m
135. BSP_LCD_Ctx_t       Lcd_Ctx[LCD_INSTANCES_NBR];
     
136. /**
     
137.   * @}
     " `) K' p  s% p& I  h$ P
138.   */
     $ m. W9 v: b; ]& S* w7 x9 B, y% K
139. 
     9 @; a5 K; u* m" I7 H' x
140. /** @defgroup STM32N6570_DK_LCD_Private_FunctionPrototypes LCD Private FunctionPrototypes
     ) \% }  @) i$ m) }, K. O
141.   * @{
     
142.   */
     
143. 
     
144. static void LTDC_MspInit(LTDC_HandleTypeDef *hltdc);
     
145. static void LTDC_MspDeInit(LTDC_HandleTypeDef *hltdc);
     % T  @+ v6 N! d; k, q
146. static void DMA2D_MspInit(DMA2D_HandleTypeDef *hdma2d);
     
147. static void DMA2D_MspDeInit(DMA2D_HandleTypeDef *hdma2d);
     
148. static void LL_FillBuffer(uint32_t Instance, uint32_t *pDst, uint32_t xSize, uint32_t ySize, uint32_t OffLine, uint32_t Color);
     
149. static void LL_ConvertLineToRGB(uint32_t Instance, uint32_t *pSrc, uint32_t *pDst, uint32_t xSize, uint32_t ColorMode);
     
150. /**
     ; b; \6 f- P3 e7 _) A- u
151.   * @}
     , e( m$ y$ p7 S/ l
152.   */
     
153. /** @defgroup STM32N6570_DK_LCD_Private_Macros  Private Macros
     
154.   * @{
     
155.   */
     & O: z. l1 z' P. Y4 K% a- o& a, I- E
156. #define CONVERTRGB5652ARGB8888(Color)((((((((Color) >> (11U)) & 0x1FU) * 527U) + 23U) >> (6U)) << (16U)) |\
     
157.                                      (((((((Color) >> (5U)) & 0x3FU) * 259U) + 33U) >> (6U)) << (8U)) |\
     
158.                                      (((((Color) & 0x1FU) * 527U) + 23U) >> (6U)) | (0xFF000000U))
     - q$ K: V9 J9 a7 ?& u5 y
159. 
     6 T2 A* A. V' h
160. #define CONVERTARGB44442ARGB8888(Color)((((((Color) >> 12U) & 0xFU) * 17U) << 24U) |\
     + b" Z+ z+ P6 l% _& p
161.                                         (((((Color) >>  8U) & 0xFU) * 17U) << 16U) |\
     + _5 A/ [) I3 L$ m. F. R4 \- j
162.                                         (((((Color) >>  4U) & 0xFU) * 17U) << 8U) |\
     
163.                                         (((((Color) >>  0U) & 0xFU) * 17U) << 0U))
     
164. 
     $ J/ |2 L% Q( ]+ }8 C) k9 d, T
165. #define CONVERTRGB8882ARGB8888(Color)((Color) | 0xFF000000U)
     
166. 
     & X) z: D  D& A: k/ Y; c8 g5 a4 N& c
167. #define CONVERTARGB88882RGB888(Color)((Color) & 0x00FFFFFFU)
     
168. 
     0 K6 w6 B8 D. d3 m
169. /**
     : N) }/ J9 `% H5 z8 d
170.   * @}
     + S, b: G# i1 K+ s' O6 @
171.   */
     3 q2 N+ J* V  \" j1 w2 D! u! c
172. 
     3 ~& N9 l" L8 L& g1 K8 j
173. /** @defgroup STM32N6570_DK_LCD_Exported_Functions LCD Exported Functions
     * S6 D; G8 D& J4 {* I, L- w6 Z
174.   * @{
     ) f( L+ k9 V  @9 x% t8 j, [
175.   */
     
176. /**
     . E0 i2 Y: z( Q! n$ _8 t6 [
177.   * @brief  Initializes the LCD in default mode.
     
178.   * @param  Instance    LCD Instance
     * L" H! l% }5 K& R/ C( `7 L
179.   * @param  Orientation LCD_ORIENTATION_LANDSCAPE
     
180.   * @retval BSP status
     # N) r( D* A  F+ v- h& c; ?$ M' K
181.   */
     
182. 
     % m' k/ S0 }1 x% t, f( m0 [  R
183. int32_t BSP_LCD_Init(uint32_t Instance, uint32_t Orientation)
     ) q- ^$ X' W7 L3 |* S4 p' O: G5 G' q
184. {
     
185.   return BSP_LCD_InitEx(Instance, Orientation, LCD_PIXEL_FORMAT_RGB565, LCD_DEFAULT_WIDTH, LCD_DEFAULT_HEIGHT);
     
186. }
     $ B% c# W6 q: R
187. 
     
188. /**
     / }1 |" e1 {" `! z( P
189.   * @brief  Initializes the LCD.
     + p6 Z/ h) b& U$ N
190.   * @param  Instance    LCD Instance
     
191.   * @param  Orientation LCD_ORIENTATION_LANDSCAPE
     
192.   * @param  PixelFormat LCD_PIXEL_FORMAT_RGB565, LCD_PIXEL_FORMAT_ARGB4444, LCD_PIXEL_FORMAT_ARGB8888
     
193.   *                     or LCD_PIXEL_FORMAT_RGB888
       K, S5 H& p$ F* w- _
194.   * @param  Width       Display width
     * c: b- P& y2 V, c5 y' M* z4 s; O
195.   * @param  Height      Display height
     
196.   * @retval BSP status
     
197.   */
     
198. int32_t BSP_LCD_InitEx(uint32_t Instance, uint32_t Orientation, uint32_t PixelFormat, uint32_t Width, uint32_t Height)
     
199. {
     
200.   int32_t ret = BSP_ERROR_NONE;
     
201.   uint32_t ltdc_pixel_format;
     
202.   MX_LTDC_LayerConfig_t config = {0};
       r, a0 Y/ y  Y
203. 
     5 r! Z7 B$ ^6 |0 V, x+ A- x% ?+ Y% b
204.   if ((Orientation > LCD_ORIENTATION_LANDSCAPE) || (Instance >= LCD_INSTANCES_NBR) || \
     " x8 q' O; b/ _4 M- f* c
205.      ((PixelFormat != LCD_PIXEL_FORMAT_RGB565) && (PixelFormat != LCD_PIXEL_FORMAT_RGB888) && \
     
206.       (PixelFormat != LCD_PIXEL_FORMAT_ARGB8888) &&  (PixelFormat != LCD_PIXEL_FORMAT_ARGB4444)))
     
207.   {
     3 _' v% B" B: z' Z3 x& O
208.     ret = BSP_ERROR_WRONG_PARAM;
     
209.   }
     ( b3 J% X4 ~! q% T
210.   else
     - C% y( d, u7 u
211.   {
     
212.     if (PixelFormat == LCD_PIXEL_FORMAT_RGB565)
     
213.     {
     
214.       ltdc_pixel_format = LTDC_PIXEL_FORMAT_RGB565;
     
215.       Lcd_Ctx[Instance].BppFactor = 2U;
     * I( @# v" {6 R+ y5 N7 c8 P* f
216.     }
     2 _8 C5 }* C# p
217.     else if  (PixelFormat == LCD_PIXEL_FORMAT_RGB888)
     ' i+ V3 k7 I" a2 b$ g0 ]
218.     {
     
219.       ltdc_pixel_format = LTDC_PIXEL_FORMAT_RGB888;
     
220.       Lcd_Ctx[Instance].BppFactor = 3U;
     ' Y# o# q( H, @; o1 x
221.     }
     ) y0 W/ n9 C+ X3 p1 b% Z+ \
222.     else if  (PixelFormat == LCD_PIXEL_FORMAT_ARGB4444)
     ! s+ i$ ]9 R2 I2 T
223.     {
     ) k4 M0 p; N2 ^2 z5 B# Y* y/ _
224.       ltdc_pixel_format = LTDC_PIXEL_FORMAT_ARGB4444;
     
225.       Lcd_Ctx[Instance].BppFactor = 2U;
     
226.     }
     1 e4 ^1 o& L5 @" s2 r( j% R% c
227.     else /* LCD_PIXEL_FORMAT_ARGB8888 */
     
228.     {
     - b# m$ `( h4 K9 o
229.       ltdc_pixel_format = LTDC_PIXEL_FORMAT_ARGB8888;
     
230.       Lcd_Ctx[Instance].BppFactor = 4U;
     . C" z: n" y1 V. R
231.     }
     - h) Y# m1 `; [4 a* U/ E; A2 A9 n
232. 
     
233.     /* Store pixel format, xsize and ysize information */
     
234.     Lcd_Ctx[Instance].PixelFormat = PixelFormat;
     7 ~$ t& N8 G( ^
235.     Lcd_Ctx[Instance].XSize  = Width;
     
236.     Lcd_Ctx[Instance].YSize  = Height;
     $ K7 {2 ~" _! H* F
237. 
     4 A4 I" v  _/ I* U1 m
238.     /* Initializes peripherals instance value */
     + g2 z6 S  E" b
239.     hlcd_ltdc.Instance = LTDC;
     ! J" r4 Z- M+ @+ Y- u$ A+ A- E% b
240.     hlcd_dma2d.Instance = DMA2D;
     5 N$ u3 v- |5 j, H$ i( t
241. 
     , k! J& o6 l, w6 W
242.     /* MSP initialization */
     
243. #if (USE_HAL_LTDC_REGISTER_CALLBACKS == 1)
     
244.     /* Register the LTDC MSP Callbacks */
     # u7 b# ^' n4 c, c! g
245.     if (Lcd_Ctx[Instance].IsMspCallbacksValid == 0U)
     
246.     {
     
247.       if (BSP_LCD_RegisterDefaultMspCallbacks(0) != BSP_ERROR_NONE)
     
248.       {
     9 M/ S# U9 t- i3 x5 q3 F: f
249.         return BSP_ERROR_PERIPH_FAILURE;
     : o+ j$ Z( n/ Z$ f* j" I2 L
250.       }
     
251.     }
     5 n5 H: h" ]; O" K7 a2 T, T
252. #else
     2 S) U) D3 i( }: C# V+ n3 J6 j
253.     LTDC_MspInit(&hlcd_ltdc);
     
254. #endif /* (USE_HAL_LTDC_REGISTER_CALLBACKS == 1) */
     7 U9 _2 o; _0 F0 {3 \$ |
255. 
     ; f1 E5 j4 t8 z+ a! T/ H* a
256.     DMA2D_MspInit(&hlcd_dma2d);
     
257. 
     
258.     if (MX_LTDC_ClockConfig(&hlcd_ltdc) != HAL_OK)
     ! q' _$ r7 F% r4 J/ t1 R+ g
259.     {
     . E' W( S; Q; M" r2 S; X
260.       ret = BSP_ERROR_PERIPH_FAILURE;
     * V2 S( b. t+ s/ E! M7 j% F! @
261.     }
     
262.     else
     
263.     {
     
264.       if (MX_LTDC_Init(&hlcd_ltdc, Width, Height) != HAL_OK)
     0 x* O* U$ n9 X9 Y
265.       {
     - l' d9 g5 p+ U
266.         ret = BSP_ERROR_PERIPH_FAILURE;
     ; v" T4 |3 ]! T
267.       }
     0 L  V6 W6 ~& D& W' B' [5 n9 D
268.     }
     2 y, G; x% n# Q8 F5 P
269. 
     
270.     if (ret == BSP_ERROR_NONE)
     4 `0 h7 w1 ~* R
271.     {
     
272. #if defined(DATA_IN_ExtRAM)
     6 H$ h7 c0 @1 r! ^- v0 @
273.       /* Before configuring LTDC layer, ensure XSPI RAM is initialized */
     ; E: Y" r9 a! K$ f# t. n2 m; p
274.       /* Initialize the XSPI RAM */
       i7 j, j0 y5 \
275.       if (BSP_XSPI_RAM_Init(0) != BSP_ERROR_NONE)
     : E1 ?, U1 z0 r7 {
276.       {
     / F7 ^5 O: j3 m  F
277.         ret = BSP_ERROR_NO_INIT;
     
278.       }
     # w1 E/ S, m7 \
279.       else if (BSP_XSPI_RAM_EnableMemoryMappedMode(0) != BSP_ERROR_NONE)
     4 m$ F. R# A  X3 r7 {; Q1 V
280.       {
     " v; f1 \5 j8 q" g& P, I
281.         ret = BSP_ERROR_PERIPH_FAILURE;
     5 g/ h& N8 s2 K$ w; f) ^+ |
282.       }
     
283.       else
     
284.       {
     
285. #endif /* DATA_IN_ExtRAM */
     . t) `( \# b3 ^8 |6 @6 @# d
286.         /* Configure default LTDC Layer 0. This configuration can be override by calling
     1 L/ e6 ]  A# w; O# r
287.         BSP_LCD_ConfigLayer() at application level */
     
288.         config.X0          = 0;
     
289.         config.X1          = Width;
       ^1 o! E% z4 R
290.         config.Y0          = 0;
     
291.         config.Y1          = Height;
     % q+ O) w  t+ ]" K/ F
292.         config.PixelFormat = ltdc_pixel_format;
     + d5 O( L; v% K( G! A
293.         config.Address     = LCD_LAYER_0_ADDRESS;
     - V6 ]. J# H& {: |# Z( F
294. 
     
295.         if (MX_LTDC_ConfigLayer(&hlcd_ltdc, 0, &config) != HAL_OK)
     . o7 j% _: x: l5 z
296.         {
     
297.           ret = BSP_ERROR_PERIPH_FAILURE;
     
298.         }
     
299. 
     4 K% K2 \& N2 W$ o9 I
300.         /* By default the reload is activated and executed immediately */
     
301.         Lcd_Ctx[Instance].ReloadEnable = 1U;
     2 \, N0 |6 x: p" g- ?4 i, T
302. #if defined(DATA_IN_ExtRAM)
     , y8 v5 M; Q( ]( Q2 X* `) J; M
303.       }
     # b' D; l0 b+ Y8 u1 E& @
304. #endif /* DATA_IN_ExtRAM */
     
305.     }
     
306.   }
     9 g' e9 p, B7 X9 i5 M1 U, J; ]! B
307. 
     
308.   return ret;
     6 Q$ x5 I; q1 S" k2 C
309. }
     $ {% x- N+ p# h( U( q! s
310. 
     
311. /**
     % m2 L, H$ D0 h. m' c& {
312.   * @brief  De-Initializes the LCD resources.
     
313.   * @param  Instance    LCD Instance
     + |4 @1 a+ C# \
314.   * @retval BSP status
     
315.   */
     * V2 J$ ^2 F& f! s  i( |  ]: w
316. int32_t BSP_LCD_DeInit(uint32_t Instance)
     " h2 t' [+ \4 Y+ A; c
317. {
     
318.   int32_t ret = BSP_ERROR_NONE;
     ' V3 C! ~1 n1 ], h7 R9 d
319. 
     6 {2 w: V! H3 t/ s9 K# ~7 O
320.   if(Instance >= LCD_INSTANCES_NBR)
     # v# G. j- @9 w  S, V, N: H. T
321.   {
     
322.     ret = BSP_ERROR_WRONG_PARAM;
     0 Z% I3 P; d8 X9 p) A8 y2 Z( M
323.   }
     : X! D; |. Y, ^  P* h  S; V) M1 c9 n+ ^
324.   else
     0 S! u% E  e+ Y) P% q  E$ W
325.   {
       {& Z# y' _1 ]* Z, g( n+ ]
326. #if (USE_HAL_LTDC_REGISTER_CALLBACKS == 0)
     
327.     LTDC_MspDeInit(&hlcd_ltdc);
     ' V  c: w- J% V, O' p" r9 w4 ]4 _
328. #endif /* (USE_HAL_LTDC_REGISTER_CALLBACKS == 0) */
     , M; ~% z" _; h8 \1 p" J  H$ v) z* I
329. 
     
330.     (void)HAL_LTDC_DeInit(&hlcd_ltdc);
     & x6 _" h8 d3 x  d1 j3 b- L
331.     if(HAL_DMA2D_DeInit(&hlcd_dma2d) != HAL_OK)
     
332.     {
     / X, m5 A! `* k$ e6 `! a
333.       ret = BSP_ERROR_PERIPH_FAILURE;
     $ r9 t% n6 W2 v9 a% Q
334.     }
     
335.     else
     / t  \5 z) E. X+ W  g1 y1 p# Z
336.     {
     5 J* C! E1 ?' r7 Q* l& n! x
337.       DMA2D_MspDeInit(&hlcd_dma2d);
     $ Q! O: W9 s; y' x! L' v" r8 [5 i
338.       Lcd_Ctx[Instance].IsMspCallbacksValid = 0;
     " g" _3 i: D5 b& h" |6 E
339.     }
     / \% |6 ~% w% l& f* p
340.   }
     ! g8 T9 _  m5 ]% o# f4 O
341. 
     % x5 R7 F. O/ C" O2 w
342.   return ret;
     % `9 y' R. K0 U2 A0 s
343. }
     
344. 
     1 a$ q) ^5 t6 z# Q/ e8 F! \  ?, Y
345. /**
     
346.   * @brief  Initializes the LTDC.
     6 @, U$ O& T! L  O* ]$ r
347.   * @param  hltdc  LTDC handle
     3 x& X% J% z$ S6 \4 m1 i: S: ^
348.   * @param  Width  LTDC width
     ! ~9 i; n! m/ L, D
349.   * @param  Height LTDC height
     
350.   * @retval HAL status
     
351.   */
     
352. __weak HAL_StatusTypeDef MX_LTDC_Init(LTDC_HandleTypeDef *hltdc, uint32_t Width, uint32_t Height)
     # J6 C. `; u4 c2 `( Z  O  E: y9 k4 ^
353. {
     
354.   hltdc->Instance = LTDC;
     
355.   hltdc->Init.HSPolarity = LTDC_HSPOLARITY_AL;
     
356.   hltdc->Init.VSPolarity = LTDC_VSPOLARITY_AL;
     
357.   hltdc->Init.DEPolarity = LTDC_DEPOLARITY_AL;
     , s" b1 k. ~( V3 Z! X  S* w  q9 F
358.   hltdc->Init.PCPolarity = LTDC_PCPOLARITY_IPC;
     
359. 
     ) ]1 X8 e( `! u4 ^3 R" c) S
360.   hltdc->Init.HorizontalSync     = (uint32_t)RK050HR18_HSYNC - 1U;
     
361.   hltdc->Init.AccumulatedHBP     = (uint32_t)RK050HR18_HSYNC + (uint32_t)RK050HR18_HBP - 1U;
     7 \& ]" t  ?0 i( {5 J- e1 H
362.   hltdc->Init.AccumulatedActiveW = (uint32_t)RK050HR18_HSYNC + Width + (uint32_t)RK050HR18_HBP -1U;
     ( d$ ]% Y: ?, A1 q$ Y# V  d
363.   hltdc->Init.TotalWidth         = (uint32_t)RK050HR18_HSYNC + Width + (uint32_t)RK050HR18_HBP + RK050HR18_HFP - 1U;
     8 {3 W, Z# X6 E1 }" w  z% z, r
364.   hltdc->Init.VerticalSync       = (uint32_t)RK050HR18_VSYNC - 1U;
     " p; {9 R' i1 S
365.   hltdc->Init.AccumulatedVBP     = (uint32_t)RK050HR18_VSYNC + (uint32_t)RK050HR18_VBP - 1U;
     
366.   hltdc->Init.AccumulatedActiveH = (uint32_t)RK050HR18_VSYNC + Height + (uint32_t)RK050HR18_VBP -1U;
     ) X) K+ C0 m$ B. g$ `
367.   hltdc->Init.TotalHeigh         = (uint32_t)RK050HR18_VSYNC + Height + (uint32_t)RK050HR18_VBP + RK050HR18_VFP - 1U;
     * s  a8 N% ?3 P! y% ~
368. 
     
369.   hltdc->Init.Backcolor.Blue  = 0x0;
     ( D' K9 X/ \+ c, x4 k" y
370.   hltdc->Init.Backcolor.Green = 0x0;
     9 m7 S$ W# u8 H5 T  A; ^; N
371.   hltdc->Init.Backcolor.Red   = 0x0;
     
372. 
     
373.   return HAL_LTDC_Init(hltdc);
     ; a7 W) {6 x) x  a
374. }
     . j7 d% {9 q1 m' G2 @
375. 
     
376. /**
     
377.   * @brief  MX LTDC layer configuration.
     ! A: Q! E+ X. C7 f; u4 l
378.   * @param  hltdc      LTDC handle
     
379.   * @param  LayerIndex Layer 0 or 1
     & j3 c+ W! x9 Q1 J3 @# A0 [
380.   * @param  Config     Layer configuration
     
381.   * @retval HAL status
     
382.   */
     
383. __weak HAL_StatusTypeDef MX_LTDC_ConfigLayer(LTDC_HandleTypeDef *hltdc, uint32_t LayerIndex, MX_LTDC_LayerConfig_t *Config)
     , K6 @& q  W0 a, i6 [
384. {
     
385.   LTDC_LayerCfgTypeDef pLayerCfg ={0};
     0 {5 k- N4 s6 |( J& Y
386. 
     . ?/ U) E6 q9 z3 K9 v3 }; L! \
387.   pLayerCfg.WindowX0 = Config->X0;
     
388.   pLayerCfg.WindowX1 = Config->X1;
     
389.   pLayerCfg.WindowY0 = Config->Y0;
     + H. d# e7 m6 F; c3 S7 @
390.   pLayerCfg.WindowY1 = Config->Y1;
     
391.   pLayerCfg.PixelFormat = Config->PixelFormat;
     8 N! g/ l) v+ D2 u
392.   pLayerCfg.Alpha = LTDC_LxCACR_CONSTA;
     - u+ _- S5 B7 k- I; A' f
393.   pLayerCfg.Alpha0 = 0;
     
394.   pLayerCfg.BlendingFactor1 = LTDC_BLENDING_FACTOR1_PAxCA;
     2 B  W1 n; d7 C6 L$ P: K
395.   pLayerCfg.BlendingFactor2 = LTDC_BLENDING_FACTOR2_PAxCA;
     
396.   pLayerCfg.FBStartAdress = Config->Address;
     
397.   pLayerCfg.ImageWidth = (Config->X1 - Config->X0);
     4 R( Z' r4 d5 v* d
398.   pLayerCfg.ImageHeight = (Config->Y1 - Config->Y0);
     
399.   pLayerCfg.Backcolor.Blue = 0;
     
400.   pLayerCfg.Backcolor.Green = 0;
     ; Q9 h- M: `9 F4 Y  J' a1 d
401.   pLayerCfg.Backcolor.Red = 0;
     $ p" Q3 d1 [, }- x2 B
402.   return HAL_LTDC_ConfigLayer(hltdc, &pLayerCfg, LayerIndex);
     
403. }
     8 o; R: d. r' z! B9 y/ h
404. 
     % n2 a7 t& s$ R3 {
405. /**
     2 [, v; a* I% \5 |% t4 k
406.   * @brief  LTDC Clock Config for LCD DPI display.
     + H2 f- a8 W) e  k: a. l  d
407.   * @param  hltdc  LTDC Handle
     " s, W0 k6 Q! H2 t7 u
408.   *         Being __weak it can be overwritten by the application
     
409.   * @retval HAL_status
     ' P, N- ]1 R* P, _. s
410.   */
     
411. __weak HAL_StatusTypeDef MX_LTDC_ClockConfig(LTDC_HandleTypeDef *hltdc)
     4 K# Y2 P  Y7 j% L5 D2 w8 X
412. {
     4 J# K$ a2 n/ I  A+ j6 p
413.   /* Prevent unused argument(s) compilation warning */
     
414.   UNUSED(hltdc);
     
415. 
     
416.   HAL_StatusTypeDef   status =  HAL_OK;
     
417.   RCC_PeriphCLKInitTypeDef RCC_PeriphCLKInitStruct = {0};
     5 v0 L9 W% E" N1 U7 `: ?; t& Q
418. 
     
419.   /* LCD clock configuration */
     & ]# I+ q; r/ M! Y2 F
420.   /* Typical PCLK is 25 MHz so the PLL4 is configured to provide this clock */
     
421.   /* LTDC - PLL4 */
     
422.   /* Configure LTDC clock to IC16 with PLL4  */
     & a: O$ W' L* y
423. 
     
424.   /* LCD clock configuration */
       S- R" `3 ^& Z# y; H8 a
425.   /* Typical PCLK is 25 MHz so the PLL4 is configured to provide this clock */
     
426.   /* LCD clock configuration */
     . O- `5 I) m9 }/ I( p' {' p# B4 J
427.   /* PLL3_VCO Input = HSE_VALUE/PLLM = 48 Mhz / 192 = 0.25 */
     
428.   /* PLL3_VCO Output = PLL3_VCO Input * PLLN = 0.25 Mhz * 100 = 25 */
     * k) b  W- {8 s9 c7 m; z+ ?
429.   /* PLLLCDCLK = PLL3_VCO Output/(PLLP1 * PLLP2) = 25/1 = 25Mhz */
     
430.   /* LTDC clock frequency = PLLLCDCLK = 25 Mhz */
     
431. 
     
432.   RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LTDC;
     ( A6 N' d- Y7 i* i$ O& [! L
433.   RCC_PeriphCLKInitStruct.LtdcClockSelection = RCC_LTDCCLKSOURCE_IC16;
     8 m) y& l# e9 t' P6 K
434.   RCC_PeriphCLKInitStruct.ICSelection[RCC_IC16].ClockSelection = RCC_ICCLKSOURCE_PLL4;
     7 [0 P) e8 b  u
435.   RCC_PeriphCLKInitStruct.ICSelection[RCC_IC16].ClockDivider = 2;
     9 M- M: ~, \* I! N( w
436.   if (HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct) != HAL_OK)
     5 X3 l9 J: \$ j" O3 ^
437.   {
     ) M" X. X3 k$ L# z9 ^* h
438.     status = HAL_ERROR;
     * g' t" d  b8 j# I) V
439.   }
     1 J) r' E) ~" C- I: a/ ^
440. 
     + x8 G. x3 _3 g% v! [
441.   return status;
     
442. }
     
443. 
     7 d/ z5 t% u. V; E' q
444. #if (USE_HAL_LTDC_REGISTER_CALLBACKS == 1)
     1 d1 x' a3 y2 o- O7 ~9 T
445. /**
     
446.   * @brief Default BSP LCD Msp Callbacks
     
447.   * @param Instance BSP LCD Instance
     
448.   * @retval BSP status
     
449.   */
     
450. int32_t BSP_LCD_RegisterDefaultMspCallbacks (uint32_t Instance)
     
451. {
     ! a8 u' `& r8 {7 [: \/ p
452.   int32_t ret = BSP_ERROR_NONE;
     
453. 
     
454.   if(Instance >= LCD_INSTANCES_NBR)
     
455.   {
     % a/ x" M, t" n$ G+ z  R5 P
456.     ret = BSP_ERROR_WRONG_PARAM;
     : d0 D  ?; t% k4 F  P. A9 u1 W  K
457.   }
     ( k0 T2 q, A# C: J. }- r, r& g
458.   else
     ' ~: J  o* M( P" t( j9 u8 Q
459.   {
     
460.     if(HAL_LTDC_RegisterCallback(&hlcd_ltdc, HAL_LTDC_MSPINIT_CB_ID, LTDC_MspInit) != HAL_OK)
     
461.     {
     
462.       ret = BSP_ERROR_PERIPH_FAILURE;
     7 M/ J# d  M1 M1 H! _! @. s/ Y
463.     }
     & M5 I4 F! s4 e4 `. O. \7 U% U) J! D0 o
464.     else
     # o# K* ~, e: n8 H
465.     {
     : O# t; e% D- b6 b: ^" ^
466.       if(HAL_LTDC_RegisterCallback(&hlcd_ltdc, HAL_LTDC_MSPDEINIT_CB_ID, LTDC_MspDeInit) != HAL_OK)
     4 G! D  ^9 w; {8 M" S- s7 n
467.       {
     
468.         ret = BSP_ERROR_PERIPH_FAILURE;
     : ?3 G7 K$ ]$ b9 n, U
469.       }
     
470.     }
     & a; _. d' u  f- w
471. 
     - M4 @/ q( \8 u. l) Y* x: u
472.     Lcd_Ctx[Instance].IsMspCallbacksValid = 1;
     
473.   }
     
474. 
     / r+ k+ Q. Z/ F) F: t
475.   return ret;
     
476. }
     7 r9 D. e, v6 I7 Y$ |
477. 
     7 I, T. Q; I. s
478. /**
     
479.   * @brief BSP LCD Msp Callback registering
     
480.   * @param Instance    LCD Instance
     - v  |, p1 `  ?( [
481.   * @param CallBacks   pointer to LCD MspInit/MspDeInit functions
     
482.   * @retval BSP status
     " V0 R- B! \% ?8 d4 C. g: ^, \
483.   */
     ) k7 B' r6 J5 ]2 C* S
484. int32_t BSP_LCD_RegisterMspCallbacks (uint32_t Instance, BSP_LCD_Cb_t *CallBacks)
     ; |6 N' z" T5 b, K
485. {
     
486.   int32_t ret = BSP_ERROR_NONE;
     
487. 
     : r9 {  @9 H' }/ y5 L# q8 Q8 K
488.   if(Instance >= LCD_INSTANCES_NBR)
     , Z& t( T5 ^) [6 i$ u, [5 y
489.   {
     
490.     ret = BSP_ERROR_WRONG_PARAM;
     , f  K/ P' v1 [0 ]% X
491.   }
     
492.   else
     5 F4 s) K" [# y8 ^% `( L; s$ N
493.   {
     4 U. d; [4 W' A% I! V* Q, R% Q% _+ _
494.     if(HAL_LTDC_RegisterCallback(&hlcd_ltdc, HAL_LTDC_MSPINIT_CB_ID, CallBacks->pMspLtdcInitCb) != HAL_OK)
     
495.     {
     
496.       ret = BSP_ERROR_PERIPH_FAILURE;
     
497.     }
     
498.     else
     . H: x# ]6 n5 s. ^' A2 r
499.     {
     . y* A8 U. g' f7 e" [4 t
500.       if(HAL_LTDC_RegisterCallback(&hlcd_ltdc, HAL_LTDC_MSPDEINIT_CB_ID, CallBacks->pMspLtdcDeInitCb) != HAL_OK)
     4 N  b) b5 {0 b) G$ f
501.       {
     ' c8 L2 {% e5 B1 Q( u- E5 e" [
502.         ret = BSP_ERROR_PERIPH_FAILURE;
     5 C1 }/ Q' n- @7 f$ K6 J) b, D
503.       }
     0 s+ H' `. d( L* X% D6 F
504.     }
     
505. 
     5 |) p# W* u6 L% k
506.     Lcd_Ctx[Instance].IsMspCallbacksValid = 1;
     $ \" f* {' z6 X
507.   }
     
508. 
     1 A! {+ a2 j. @2 H( J
509.   return ret;
     * w8 A% J$ M; t% a
510. }
     & l  T5 i+ Y' J5 o  _
511. #endif /*(USE_HAL_LTDC_REGISTER_CALLBACKS == 1) */
     
512. 
     
513. /**
     0 F0 y6 O& l; b
514.   * @brief  LTDC layer configuration.
     
515.   * @param  Instance   LCD instance
     
516.   * @param  LayerIndex Layer 0 or 1
     ' j% C" O. U* y$ }
517.   * @param  Config     Layer configuration
     
518.   * @retval HAL status
     
519.   */
     ; V# X2 p1 t  u" p. k
520. int32_t BSP_LCD_ConfigLayer(uint32_t Instance, uint32_t LayerIndex, BSP_LCD_LayerConfig_t *Config)
     
521. {
     
522.   int32_t ret = BSP_ERROR_NONE;
     ! ~7 ]- D1 c! Y
523.   if(Instance >= LCD_INSTANCES_NBR)
     
524.   {
     
525.     ret = BSP_ERROR_WRONG_PARAM;
     8 H3 h, |: y3 @6 u% I. Z: \3 U
526.   }
     
527.   else
     
528.   {
     ' R3 v6 \2 C5 }/ x+ [+ y
529.     if (Config->PixelFormat ==  LCD_PIXEL_FORMAT_RGB565)
     # ]: J  l5 i5 e: I$ Z( h1 S
530.     {
     " e* ]& K# D* z$ c
531.       Config->PixelFormat = LTDC_PIXEL_FORMAT_RGB565;
     ) x& P+ l8 v9 r8 W4 P# L
532.     }
     " y9 x* M4 l  X* G( R6 ]; @
533.     else if (Config->PixelFormat ==  LCD_PIXEL_FORMAT_ARGB4444)
     + W0 X! I4 k7 |5 R$ L0 A/ d
534.     {
       o6 U+ ^; D3 w+ n* M$ L9 @. z( Q
535.       Config->PixelFormat = LTDC_PIXEL_FORMAT_ARGB4444;
     
536.     }
     
537.     else if (Config->PixelFormat ==  LCD_PIXEL_FORMAT_ARGB8888)
     
538.     {
     
539.       Config->PixelFormat = LTDC_PIXEL_FORMAT_ARGB8888;
     # a# c- v% v8 U; f8 N
540.     }
     ) y( A' A) ]9 b0 W" `- _5 U9 [2 p9 H
541.     else
     7 E4 e, o" C7 \5 q3 @
542.     {
     1 y) ^) Q* C+ Q- c
543.       Config->PixelFormat = LTDC_PIXEL_FORMAT_RGB888;
     
544.     }
     % y6 U" @5 z% d( J7 o
545.     if (MX_LTDC_ConfigLayer(&hlcd_ltdc, LayerIndex, Config) != HAL_OK)
     
546.     {
     # i) ~$ Y# u$ @9 s
547.       ret = BSP_ERROR_PERIPH_FAILURE;
     0 e/ g; M0 ^9 D% u
548.     }
     . a+ ]# C/ Q2 M
549.   }
     
550.   return ret;
     : v0 d9 J1 H9 M* s) y; t, u& y
551. }
     & l) \/ q6 U- V1 `: A2 {
552. 
     4 n, u4 E) q9 G! e0 ^
553. /**
     
554.   * @brief  Gets the LCD Active LCD Pixel Format.
     5 H% [6 d6 e+ c9 `9 }3 x) `
555.   * @param  Instance    LCD Instance
     & \5 T0 m) m2 C' E& p4 ]" ?
556.   * @param  PixelFormat Active LCD Pixel Format
     
557.   * @retval BSP status
     - _7 H7 t8 o9 a- p
558.   */
     ) ^/ t" F" A5 Y7 z0 S% ?9 E% v
559. int32_t BSP_LCD_GetPixelFormat(uint32_t Instance, uint32_t *PixelFormat)
     + w* P" [) a9 f% J( J
560. {
     
561.   int32_t ret = BSP_ERROR_NONE;
       q1 f" e/ ]) S$ x0 a; R
562. 
     ' K+ g& O( q) ?) R1 N& N
563.   if(Instance >= LCD_INSTANCES_NBR)
     
564.   {
     
565.     ret = BSP_ERROR_WRONG_PARAM;
     ) g% f8 L( v  H/ m6 r$ B2 H; ?% T
566.   }
     
567.   else
     2 ?3 c# D& |  m  z; y
568.   {
     
569.     /* Only RGB565 format is supported */
       U# M6 P6 Z1 t: d% [! Z6 a, s
570.     *PixelFormat =  Lcd_Ctx[Instance].PixelFormat;
     * ^0 o' x6 E  C% B9 i' Q5 p
571.   }
     
572. 
     
573.   return ret;
     5 z, q6 n2 k# Q
574. }
     : K3 a) X$ L# V
575. 
     
576. /**
     
577.   * @brief  Set the LCD Active Layer.
     ) M! s5 s! U+ c3 Y  k
578.   * @param  Instance    LCD Instance
     ; K3 T) }. F! ]4 J# E: |
579.   * @param  LayerIndex  LCD layer index
     # m9 h4 ?' W+ c4 Z4 c/ h
580.   * @retval BSP status
     
581.   */
     4 J% T3 n4 U( t+ {" P6 o7 @; P
582. int32_t BSP_LCD_SetActiveLayer(uint32_t Instance, uint32_t LayerIndex)
     ; Z$ v. P5 [" a6 M* ^
583. {
     
584.   int32_t ret = BSP_ERROR_NONE;
     
585.   LTDC_LayerCfgTypeDef *pLayerCfg;
     + {  Y6 h% P" r# j/ k8 H
586. 
     
587.   if(Instance >= LCD_INSTANCES_NBR)
     
588.   {
     $ n: i( \8 ~& b6 F" z( b6 W0 ^: {* y
589.     ret = BSP_ERROR_WRONG_PARAM;
     + B" Y& @; F* M- U
590.   }
     * _+ j+ }' ^+ X0 V+ |: K9 F
591.   else
     & q! z! W  o2 ^, G
592.   {
     : M! J4 G1 @" g# `
593.     pLayerCfg = &hlcd_ltdc.LayerCfg[LayerIndex];
     
594. 
     
595.     Lcd_Ctx[Instance].ActiveLayer = LayerIndex;
     2 F) k6 d5 R: R* U( ]" K5 v
596.     Lcd_Ctx[Instance].XSize = pLayerCfg->ImageWidth;
     
597.     Lcd_Ctx[Instance].YSize = pLayerCfg->ImageHeight;
     
598. 
     
599.     if (pLayerCfg->PixelFormat ==  LTDC_PIXEL_FORMAT_RGB565)
     
600.     {
     
601.       Lcd_Ctx[Instance].BppFactor = 2;
     ! K; Q! N! A* ?$ i+ I, Z
602.       Lcd_Ctx[Instance].PixelFormat = LCD_PIXEL_FORMAT_RGB565;
     
603.     }
     
604.     else if (pLayerCfg->PixelFormat ==  LTDC_PIXEL_FORMAT_ARGB4444)
     
605.     {
     * h% W2 k! C' k; g- _/ K8 O
606.       Lcd_Ctx[Instance].BppFactor = 2;
     % O/ Q6 v$ P) g, }
607.       Lcd_Ctx[Instance].PixelFormat = LCD_PIXEL_FORMAT_ARGB4444;
     * z9 r7 L/ g9 o% E) {
608.     }
     7 {: g8 Z, L% j0 `& y" S- t
609.     else if (pLayerCfg->PixelFormat ==  LTDC_PIXEL_FORMAT_RGB888)
     
610.     {
     8 ?0 L! F! e: j2 Y
611.       Lcd_Ctx[Instance].BppFactor = 3;
     
612.       Lcd_Ctx[Instance].PixelFormat = LCD_PIXEL_FORMAT_RGB888;
     
613.     }
     
614.     else
     # t1 S  T0 Q1 w7 |8 ?
615.     {
     
616.       Lcd_Ctx[Instance].BppFactor = 4;
     3 _0 R  z3 i; t2 B2 r8 T/ v8 ?" e5 q
617.       Lcd_Ctx[Instance].PixelFormat = LCD_PIXEL_FORMAT_ARGB8888;
     
618.     }
     * v6 E, y: _- s) |# C6 ?
619.   }
     
620. 
     2 q- E5 T/ Y. V* H8 J  K8 _7 n
621.   return ret;
     
622. }
     7 c1 v' z& b9 g% W4 x- `" `
623. 
     # G$ f  R& ?9 y  @* U1 {+ G9 n2 Y
624. /**
     ! ?# i6 H* J7 P, v9 D
625.   * @brief  Control the LTDC reload
     # O* C$ a1 S7 u
626.   * @param  Instance    LCD Instance
     
627.   * @param  ReloadType can be one of the following values
     4 ]+ f& C: O( {: y$ I1 }
628.   *         - BSP_LCD_RELOAD_NONE
     
629.   *         - BSP_LCD_RELOAD_IMMEDIATE
     $ J6 k: S0 U; n1 H- R  }; F& ]
630.   *         - BSP_LCD_RELOAD_VERTICAL_BLANKING
     6 S" \2 |! C# m! B5 ~
631.   * @retval BSP status
     
632.   */
     
633. int32_t BSP_LCD_Reload(uint32_t Instance, uint32_t ReloadType)
     ) ^, v+ A* P+ h; b8 p- i$ c
634. {
     
635.   int32_t ret = BSP_ERROR_NONE;
     : D( P) G/ _: y8 a+ }  C9 A
636. 
     
637.   if(Instance >= LCD_INSTANCES_NBR)
     + R; b# m, e6 l1 Y+ y9 N4 O% O+ ^
638.   {
     
639.     ret = BSP_ERROR_WRONG_PARAM;
     
640.   }
     ; s/ c( X) I/ U( Y
641.   else if(ReloadType == BSP_LCD_RELOAD_NONE)
     
642.   {
     ' y" }; q4 I# L+ x, O! |  `) h1 ]9 q/ e
643.     Lcd_Ctx[Instance].ReloadEnable = 0U;
     
644.   }
     
645.   else if(HAL_LTDC_Reload(&hlcd_ltdc, ReloadType) != HAL_OK)
     
646.   {
     
647.     ret = BSP_ERROR_PERIPH_FAILURE;
     9 `6 Q- w- {1 R; n) B
648.   }
       i6 J6 K) C9 K) H8 B5 `
649.   else
     * w$ D3 Z* `0 C5 S( s
650.   {
     
651.     Lcd_Ctx[Instance].ReloadEnable = 1U;
     . I3 p* k# q* i* q8 w( u" _
652.   }
     
653. 
     
654.   return ret;
     ! {8 s: y$ {6 }) l8 c; o
655. }
     
656. 
       c+ v+ Q& b' Y! N' ^* v5 H: X' r5 z0 y
657. /**
     * S/ `% s0 x; ^7 \3 P, X
658.   * @brief  Sets an LCD Layer visible
     4 u3 o6 G& a3 B, i5 v1 s8 B* |
659.   * @param  Instance    LCD Instance
     
660.   * @param  LayerIndex  Visible Layer
     
661.   * @param  State  New state of the specified layer
     9 \1 Q6 S  N" v, Y4 H& c0 i
662.   *          This parameter can be one of the following values:
     ' G, c  c4 [, S; ?, H8 D& n) c
663.   *            @arg  ENABLE
     
664.   *            @arg  DISABLE
     8 Z/ l7 K6 A0 R' s/ ^2 [
665.   * @retval BSP status
     
666.   */
     
667. int32_t BSP_LCD_SetLayerVisible(uint32_t Instance, uint32_t LayerIndex, FunctionalState State)
     
668. {
     2 z6 V& L9 q6 N0 r0 |5 j
669.   int32_t ret = BSP_ERROR_NONE;
     
670. 
     
671.   if(Instance >= LCD_INSTANCES_NBR)
     
672.   {
     4 ~7 T) V& }0 u, C
673.     ret = BSP_ERROR_WRONG_PARAM;
     * W. y$ U. U9 ?6 U4 s" P+ ~
674.   }
     ! ?& D0 \2 B3 G+ H
675.   else
     - d8 D4 w3 }; a8 G5 v+ ?
676.   {
     9 c' k( g* P. J$ d/ Y* u. m. t
677.     if(State == ENABLE)
     & N; i% R* _. R1 P% Q
678.     {
     * A' O, j" g5 `
679.       __HAL_LTDC_LAYER_ENABLE(&hlcd_ltdc, LayerIndex);
     
680.     }
     " ]# O/ V- ~: G7 m& }: H0 _
681.     else
     ( z  m# `! R) h! H* N
682.     {
     
683.       __HAL_LTDC_LAYER_DISABLE(&hlcd_ltdc, LayerIndex);
     
684.     }
     $ P' _- P: ]7 l% a" y/ r- a* {
685. 
     
686.     if(Lcd_Ctx[Instance].ReloadEnable == 1U)
     ' `/ X: J8 q& S* j9 x3 g, U6 y
687.     {
     3 A5 u6 [9 N# S+ m$ W; D
688.       __HAL_LTDC_RELOAD_IMMEDIATE_CONFIG(&hlcd_ltdc);
     
689.     }
     
690.   }
     2 H% F2 C! T/ P$ _/ e+ f8 a
691. 
     
692.   return ret;
     
693. }
     
694. 
     8 N! `, Y# H- \. f& j$ {( Z: f# v
695. /**
     6 j# r0 R) q, a8 I2 c( E3 b9 \
696.   * @brief  Configures the transparency.
     ' y$ {! P% w5 t. I) G
697.   * @param  Instance      LCD Instance
     + G/ K' b. W) S9 \/ V
698.   * @param  LayerIndex    Layer foreground or background.
     
699.   * @param  Transparency  Transparency
     ! q1 }+ n  M  R
700.   *           This parameter must be a number between Min_Data = 0x00 and Max_Data = 0xFF
     
701.   * @retval BSP status
     2 l) i" C% s* ^) o
702.   */
     
703. int32_t BSP_LCD_SetTransparency(uint32_t Instance, uint32_t LayerIndex, uint8_t Transparency)
     
704. {
     " ~6 W6 g+ k4 R2 Y  @
705.   int32_t ret = BSP_ERROR_NONE;
     ; R4 O- Q* r) X; p
706. 
     
707.   if(Instance >= LCD_INSTANCES_NBR)
     ( t5 M. V- T! s: V: J5 @# f
708.   {
     
709.     ret = BSP_ERROR_WRONG_PARAM;
     ' r# e: d+ x: j( S5 G
710.   }
     
711.   else
     
712.   {
     + I$ s- c8 N7 h. u" A
713.     if(Lcd_Ctx[Instance].ReloadEnable == 1U)
     & K" k9 J+ o" l7 M  @: j  T  _
714.     {
     7 |" C# B/ r& N
715.       (void)HAL_LTDC_SetAlpha(&hlcd_ltdc, Transparency, LayerIndex);
     
716.     }
     
717.     else
     # z- F6 L7 G! v+ i
718.     {
     
719.       (void)HAL_LTDC_SetAlpha_NoReload(&hlcd_ltdc, Transparency, LayerIndex);
     1 d1 b+ T/ t4 h* v+ T
720.     }
     ; ^: W' {" t. c  p
721.   }
     
722. 
     ) `6 ~, v/ u/ ?8 @
723.   return ret;
     
724. }
     
725. 
     . c$ f5 A- O1 a7 u# G7 r1 B
726. /**
     / I' L* }3 G& b1 I3 u+ J
727.   * @brief  Sets an LCD layer frame buffer address.
     0 F' d7 C. x0 V( w* }6 x, F
728.   * @param  Instance    LCD Instance
     ' d& T9 c* I' H6 i" R
729.   * @param  LayerIndex  Layer foreground or background
     5 x; A- U/ g( d* B- C
730.   * @param  Address     New LCD frame buffer value
     # d+ S7 Q; d. n8 x$ d, L
731.   * @retval BSP status
     
732.   */
     
733. int32_t BSP_LCD_SetLayerAddress(uint32_t Instance, uint32_t LayerIndex, uint32_t Address)
     
734. {
     
735.   int32_t ret = BSP_ERROR_NONE;
     $ l  D3 \# D) v( s
736. 
     / U& @2 K( v9 j, I' i$ E
737.   if(Instance >= LCD_INSTANCES_NBR)
     6 Z! d' E% \2 n; F* r( d" y
738.   {
     ' O/ ]$ V- Z+ q8 w, j
739.     ret = BSP_ERROR_WRONG_PARAM;
     , j  P: J, {1 i5 a* g
740.   }
       S. a% P1 u4 I* c' K7 a
741.   else
     
742.   {
     0 e$ n  p5 `) i& o' Y
743.     if(Lcd_Ctx[Instance].ReloadEnable == 1U)
     
744.     {
     7 Y( |( t+ o" z- J7 S
745.       (void)HAL_LTDC_SetAddress(&hlcd_ltdc, Address, LayerIndex);
     
746.     }
     
747.     else
     / I4 L; A1 r0 B: i2 d; ?
748.     {
     * f0 H1 O1 D# [2 L* X; D- k
749.       (void)HAL_LTDC_SetAddress_NoReload(&hlcd_ltdc, Address, LayerIndex);
     
750.     }
     ( J' q7 c, d' c. c$ L. N
751.   }
     7 `# }1 _" C7 M4 R$ e
752. 
     
753.   return ret;
     
754. }
     
755. 
     
756. /**
     0 ^! E. ~- `/ w' {; G
757.   * @brief  Sets display window.
     
758.   * @param  Instance    LCD Instance
     
759.   * @param  LayerIndex  Layer index
     4 j* Z7 Q5 `  h3 k
760.   * @param  Xpos   LCD X position
     3 U, n# F% V% S$ C8 ^' m) @6 q
761.   * @param  Ypos   LCD Y position
     ! w) Z& p5 M  B  p/ o
762.   * @param  Width  LCD window width
     0 n( @1 \4 Y! b6 r
763.   * @param  Height LCD window height
     
764.   * @retval BSP status
     
765.   */
     : E, k( B: y* e9 R* L$ z  a; X) M
766. int32_t BSP_LCD_SetLayerWindow(uint32_t Instance, uint16_t LayerIndex, uint16_t Xpos, uint16_t Ypos, uint16_t Width, uint16_t Height)
     
767. {
     9 f5 m3 _# F$ Y4 {. Q
768.   int32_t ret = BSP_ERROR_NONE;
     
769. 
     6 k  v( e. F, {3 s6 n
770.   if(Instance >= LCD_INSTANCES_NBR)
     
771.   {
     # X3 L  Y5 T4 D" m
772.     ret = BSP_ERROR_WRONG_PARAM;
     
773.   }
     ! d5 a+ `6 F0 K$ J) h
774.   else
     
775.   {
     ! G: l9 j; A' q, [
776.     if(Lcd_Ctx[Instance].ReloadEnable == 1U)
     
777.     {
     
778.       /* Reconfigure the layer size  and position */
     
779.       (void)HAL_LTDC_SetWindowSize(&hlcd_ltdc, Width, Height, LayerIndex);
     8 t, b! F  z. e) G. q8 `
780.       (void)HAL_LTDC_SetWindowPosition(&hlcd_ltdc, Xpos, Ypos, LayerIndex);
     ) }- N( k0 E/ ?' \7 b6 e! r
781.     }
     $ l3 Q+ Y9 x1 f& T) j
782.     else
     & z0 b! c9 }* C$ c$ G$ k
783.     {
     % k% p& W3 J% {) V0 O1 b; K# g
784.       /* Reconfigure the layer size and position */
     
785.       (void)HAL_LTDC_SetWindowSize_NoReload(&hlcd_ltdc, Width, Height, LayerIndex);
     . h4 k& i% w( {( K  ?( z8 c% a
786.       (void)HAL_LTDC_SetWindowPosition_NoReload(&hlcd_ltdc, Xpos, Ypos, LayerIndex);
     
787.     }
     
788. 
     
789.     Lcd_Ctx[Instance].XSize = Width;
     4 ?' s: l+ m" @" K0 i2 @- T. I$ G
790.     Lcd_Ctx[Instance].YSize = Height;
     
791.   }
     
792. 
     
793.   return ret;
     
794. }
     ; }, E1 m, \" R1 I: e
795. 
       s- C7 k+ b+ O+ K0 g* v( P' G6 i
796. /**
     
797.   * @brief  Configures and sets the color keying.
     
798.   * @param  Instance    LCD Instance
     
799.   * @param  LayerIndex  Layer foreground or background
     
800.   * @param  Color       Color reference
       ]6 W. m; I/ ^2 {7 U7 Y
801.   * @retval BSP status
     % N9 g; \. n; E6 Q" {9 J3 \  \
802.   */
     
803. int32_t BSP_LCD_SetColorKeying(uint32_t Instance, uint32_t LayerIndex, uint32_t Color)
     
804. {
     
805.   int32_t ret = BSP_ERROR_NONE;
     
806. 
     6 B: P7 @! v" k% }9 o
807.   if(Instance >= LCD_INSTANCES_NBR)
     
808.   {
     
809.     ret = BSP_ERROR_WRONG_PARAM;
     9 {$ R/ X* b2 ]+ A" W$ `4 g
810.   }
     7 S" P7 H/ P" V5 P4 r+ I
811.   else
     
812.   {
     ( R8 k  D$ ~/ D6 w# v7 N3 H+ ^
813.     (void)HAL_LTDC_ConfigColorKeying(&hlcd_ltdc, Color, LayerIndex);
     : ]* N0 m" A. O& x9 `
814.     if(Lcd_Ctx[Instance].ReloadEnable == 1U)
     
815.     {
     / }* F* q0 G" f5 n1 b
816.       /* Configure and Enable the color Keying for LCD Layer */
     ) x6 ~. f5 n) T& ^9 W6 ]3 _3 ?
817. 
     $ G3 f- ?# V  c9 {+ Q4 x
818.       (void)HAL_LTDC_EnableColorKeying(&hlcd_ltdc, LayerIndex);
     % s% T- t3 c8 h
819.     }
     ! S1 o! M5 W" C  U1 O- O; X1 Z
820.     else
     , p& R0 @( l( O
821.     {
     ) h" Y7 _7 }8 Q* Q; F
822.       /* Configure and Enable the color Keying for LCD Layer */
     
823.       (void)HAL_LTDC_EnableColorKeying_NoReload(&hlcd_ltdc, LayerIndex);
     / h4 z9 A% c6 `
824.     }
     7 Z- K& D* C3 B
825.   }
     
826. 
     - L2 |2 _, P7 k1 a7 h: u. w6 r
827.   return ret;
     
828. }
     : J0 S* B$ R8 N* x' F8 b
829. 
     + l( k5 v# Z& k: n! [6 u  D
830. /**
     8 O7 A& @6 J* n2 L
831.   * @brief  Disables the color keying.
     2 e( S  h0 P$ b
832.   * @param  Instance    LCD Instance
     . B7 B, F1 i9 j. [' e2 b$ [  T
833.   * @param  LayerIndex Layer foreground or background
     
834.   * @retval BSP status
     * }* {9 u, e/ _5 j7 K& S  ?9 A
835.   */
     
836. int32_t BSP_LCD_ResetColorKeying(uint32_t Instance, uint32_t LayerIndex)
     
837. {
     3 r, [3 \. U# ?% x, c
838.   int32_t ret = BSP_ERROR_NONE;
     
839. 
     
840.   if(Instance >= LCD_INSTANCES_NBR)
     / _/ h& M5 n& ?8 ]* E6 J( b
841.   {
     # J2 J& z2 Z" X' p. \
842.     ret = BSP_ERROR_WRONG_PARAM;
     
843.   }
     5 g9 J# v1 k" v9 j
844.   else
     
845.   {
     
846.     if(Lcd_Ctx[Instance].ReloadEnable == 1U)
     7 ~3 W( s; ]7 U0 A2 X5 z
847.     {
     * O- T! D4 D& c, C
848.       /* Disable the color Keying for LCD Layer */
     1 v: b. V. O; x  E" x% ]9 R. z$ U& K
849.       (void)HAL_LTDC_DisableColorKeying(&hlcd_ltdc, LayerIndex);
     ) G/ \! L2 @5 [) m5 i: G
850.     }
     + p; t1 a% K* i4 t
851.     else
     
852.     {
     7 C! W7 f5 d+ s- ^
853.       /* Disable the color Keying for LCD Layer */
     # |2 |7 R/ X# k, i9 q( }& Z% _
854.       (void)HAL_LTDC_DisableColorKeying_NoReload(&hlcd_ltdc, LayerIndex);
     4 L& @1 P# J5 w2 Z! m9 {# C
855.     }
     ; `; a8 O+ r2 w
856.   }
     
857. 
     / a! s/ D( k- |+ O# s, O6 M8 Q
858.   return ret;
       a& F9 ]+ a$ t
859. }
     
860. 
     
861. /**
     
862.   * @brief  Gets the LCD X size.
     ; k# g* |' e# P4 R% X, L. T& g9 _
863.   * @param  Instance  LCD Instance
     
864.   * @param  XSize     LCD width
     * u8 |* k5 X! Q: H
865.   * @retval BSP status
     7 ^# f* V  z+ ~
866.   */
     6 U# i. J' n4 P# X1 D9 ~
867. int32_t BSP_LCD_GetXSize(uint32_t Instance, uint32_t *XSize)
     
868. {
     6 Y* u9 Q5 C5 u9 V
869.   int32_t ret = BSP_ERROR_NONE;
     7 v$ S1 S$ F/ R# z! {
870. 
     
871.   if(Instance >= LCD_INSTANCES_NBR)
     
872.   {
       Q2 k+ I; O3 |8 ^* h4 H
873.     ret = BSP_ERROR_WRONG_PARAM;
     
874.   }
     
875.   else
     
876.   {
     
877.     *XSize = Lcd_Ctx[Instance].XSize;
     8 v3 C( o) @7 {; C
878.   }
     
879. 
     ; _& n: X9 K  f
880.   return ret;
     
881. }
     
882. 
     & ]# H& |7 d- \" X
883. /**
     ( ?. d/ E+ e) B( q' e
884.   * @brief  Gets the LCD Y size.
     
885.   * @param  Instance  LCD Instance
     2 P. P& g1 m  K  ]2 ~! k
886.   * @param  YSize     LCD Height
     
887.   * @retval BSP status
     5 s6 ^9 K: z, _7 Y, a7 |
888.   */
       L0 m# {# Y* g
889. int32_t BSP_LCD_GetYSize(uint32_t Instance, uint32_t *YSize)
     9 C5 K2 T6 F. J0 w: u1 y
890. {
     3 a; s& l6 ]7 L) U8 G' i: L
891.   int32_t ret = BSP_ERROR_NONE;
     
892. 
     
893.   if(Instance >= LCD_INSTANCES_NBR)
     5 e3 L+ W, d. f3 t
894.   {
     8 G. ]5 _% X: W: _
895.     ret = BSP_ERROR_WRONG_PARAM;
     + ~( }8 ], @, ^/ v
896.   }
     4 a0 V2 m2 f1 ?- n: o$ B! U/ V/ B
897.   else
     
898.   {
     ' w- ?. A: s: Q6 O, Q+ {
899.     *YSize = Lcd_Ctx[Instance].YSize;
     
900.   }
     
901. 
     & Q  E  r: S0 U; J& a
902.   return ret;
     
903. }
     
904. 
     . q9 i, A8 t8 \5 ~5 }# X7 T  G6 w
905. /**
     
906.   * @brief  Switch On the display.
     : K8 _$ ^- }) v; E! n; ?* k( i7 }
907.   * @param  Instance    LCD Instance
     , Z: d. ~8 m! J, |4 K, _9 T& x
908.   * @retval BSP status
     
909.   */
     
910. int32_t BSP_LCD_DisplayOn(uint32_t Instance)
     : f& T# Q: E4 }: r4 u: l9 h& {
911. {
     
912.   int32_t ret = BSP_ERROR_NONE;
     
913.   GPIO_InitTypeDef gpio_init_structure = {0};
     3 ^+ Q* s6 B8 d& x: m, k) @" `2 H
914. 
     
915.   if(Instance >= LCD_INSTANCES_NBR)
     
916.   {
     
917.     ret = BSP_ERROR_WRONG_PARAM;
     
918.   }
     
919.   else
     8 k# Q6 E# V5 A" r
920.   {
     ! Y3 q& b, i/ X; y4 v
921.     __HAL_LTDC_ENABLE(&hlcd_ltdc);
     " q- y! @# P  u3 i9 X  |
922.     gpio_init_structure.Mode = GPIO_MODE_OUTPUT_PP;
     9 a0 a* m3 t  i3 M2 x& `
923.     gpio_init_structure.Pull = GPIO_PULLUP;
     3 i2 D0 H1 W5 v* T1 ]
924.     gpio_init_structure.Pin  = LCD_DISP_EN_PIN;
     
925.     HAL_GPIO_Init(LCD_DISP_EN_GPIO_PORT, &gpio_init_structure);
     . r7 A: Y. R9 Z* L
926. 
     
927.     /* Assert LCD_DISP_EN pin */
     
928.     HAL_GPIO_WritePin(LCD_DISP_EN_GPIO_PORT,LCD_DISP_EN_PIN, GPIO_PIN_SET);
     
929.   }
     
930. 
     7 R5 s' u, w9 d# j
931.   return ret;
     # P% \3 B; R7 n( v
932. }
     # L0 k) b# E+ @- S, X" v# J
933. 
     
934. /**
     % F4 H* Y) U( w" Z' K
935.   * @brief  Switch Off the display.
     8 ?' N0 l# C- Q4 {2 ~
936.   * @param  Instance    LCD Instance
     " H* L5 s8 c9 W: A
937.   * @retval BSP status
     9 ~% S7 C3 Z2 @- d8 H
938.   */
     # r' w' Y5 Q! ~$ L7 f
939. int32_t BSP_LCD_DisplayOff(uint32_t Instance)
     
940. {
     
941.   int32_t ret = BSP_ERROR_NONE;
     ; ^" \% u; n; Q, x% |7 _
942.   GPIO_InitTypeDef gpio_init_structure = {0};
     
943. 
     
944.   if(Instance >= LCD_INSTANCES_NBR)
     3 f$ V7 E" s1 p9 c% N' Z2 U( P
945.   {
     & H4 P* Z0 Y9 N1 u
946.     ret = BSP_ERROR_WRONG_PARAM;
     
947.   }
     & o. Y0 d6 a& S7 d3 [
948.   else
     ( F9 ?& `6 [: k. d
949.   {
     
950.     gpio_init_structure.Mode      = GPIO_MODE_OUTPUT_PP;
     
951.     gpio_init_structure.Pull      = GPIO_NOPULL;
     
952.     gpio_init_structure.Speed     = GPIO_SPEED_FREQ_MEDIUM;
     
953.     gpio_init_structure.Pin       = LCD_DISP_EN_PIN;
     
954.     HAL_GPIO_Init(LCD_DISP_EN_GPIO_PORT, &gpio_init_structure);
     # A: ~( _) t4 G' \3 m. E
955. 
     * ^1 M. h. u% w
956.     HAL_GPIO_WritePin(LCD_DISP_EN_GPIO_PORT,LCD_DISP_EN_PIN, GPIO_PIN_RESET);
       y/ S3 r- Z, K) `; X
957. 
     
958.     __HAL_LTDC_DISABLE(&hlcd_ltdc);
     0 q, F* J2 q) W9 b/ c& J
959. 
     / r# e2 ~8 h4 ^
960.   }
     * _0 y7 x$ x0 B- l9 }& o: m$ _
961. 
     
962.   return ret;
     . E  A; @8 a& M4 X( J
963. }
     ( l) I* i- L0 A" @8 X; @2 A$ [
964. 
     ( C' g! v& A$ M. N. d7 H
965. /**
     , J2 r% A4 l7 U% z7 O; X9 O: e9 X! M
966.   * @brief  Draws a bitmap picture loaded in the internal Flash in currently active layer.
     
967.   * @param  Instance LCD Instance
     ; L9 n$ \. X3 ^& O: |
968.   * @param  Xpos Bmp X position in the LCD
     
969.   * @param  Ypos Bmp Y position in the LCD
     
970.   * @param  pBmp Pointer to Bmp picture address in the internal Flash.
     * C% k5 D( ~% j8 p! S* x3 u/ h
971.   * @retval BSP status
       l& p; }% b$ E
972.   */
     
973. int32_t BSP_LCD_DrawBitmap(uint32_t Instance, uint32_t Xpos, uint32_t Ypos, uint8_t *pBmp)
     9 K0 ~( z& C8 U9 p8 \4 y; l
974. {
     3 @0 }/ l5 j- s  d
975.   int32_t ret = BSP_ERROR_NONE;
     . U/ L5 f' Z" j, \% J
976.   uint32_t index;
     
977.   uint32_t width;
     . U" ~. t( @% N5 e
978.   uint32_t height;
     + E' b3 o, i& `8 E! z* W
979.   uint32_t bit_pixel;
     : A. ]6 G$ ~/ s' i" u, i
980.   uint32_t Address;
     ' b3 r* X7 P6 q, L3 N8 n
981.   uint32_t input_color_mode;
     
982.   uint8_t *pbmp;
     3 I& O4 X7 b! K  Y8 T
983. 
     ; F7 L+ x6 [. m; P) `/ m# J4 |
984.   /* Get bitmap data address offset */
     
985.   index = (uint32_t)pBmp[10] + ((uint32_t)pBmp[11] << 8) + ((uint32_t)pBmp[12] << 16)  + ((uint32_t)pBmp[13] << 24);
     4 d9 m. j0 {1 V; F% {' e
986. 
     
987.   /* Read bitmap width */
     1 S% p* {. ^! V
988.   width = (uint32_t)pBmp[18] + ((uint32_t)pBmp[19] << 8) + ((uint32_t)pBmp[20] << 16)  + ((uint32_t)pBmp[21] << 24);
     & Q# I( R/ \5 ?0 i" G% Q# d; T3 P: @# l
989. 
     
990.   /* Read bitmap height */
     
991.   height = (uint32_t)pBmp[22] + ((uint32_t)pBmp[23] << 8) + ((uint32_t)pBmp[24] << 16)  + ((uint32_t)pBmp[25] << 24);
     $ u$ a! y* p7 Q# E( Z' e) w
992. 
     
993.   /* Read bit/pixel */
     + D6 B3 l  [  j% h: N; T
994.   bit_pixel = (uint32_t)pBmp[28] + ((uint32_t)pBmp[29] << 8);
     
995. 
     
996.   /* Set the address */
     
997.   Address = hlcd_ltdc.LayerCfg[Lcd_Ctx[Instance].ActiveLayer].FBStartAdress + (((Lcd_Ctx[Instance].XSize*Ypos) + Xpos)*Lcd_Ctx[Instance].BppFactor);
     5 o, Z: l1 |2 x) A; W% Y/ x
998. 
     
999.   /* Get the layer pixel format */
     # z$ h$ t; k3 x3 Q7 Z: W
1000.   if ((bit_pixel/8U) == 4U)
      
1001.   {
      
1002.     input_color_mode = DMA2D_INPUT_ARGB8888;
      $ p/ A" F, L; G4 l0 E, z
1003.   }
      / d# x2 j- D- o. d7 k/ \+ z
1004.   else if ((bit_pixel/8U) == 2U)
      9 j; M' j; Q; F. ?$ @/ p% E
1005.   {
      
1006.     input_color_mode = DMA2D_INPUT_RGB565;
      
1007.   }
      3 [3 V0 N0 v5 q% P6 B
1008.   else
      5 \# y' N& z! E
1009.   {
      & W  _: Q' K; F3 r
1010.     input_color_mode = DMA2D_INPUT_RGB888;
      1 k! x8 ~6 N8 |5 h1 _8 }* L
1011.   }
      
1012. 
      ( N! _, f  r# l" y
1013.   /* Bypass the bitmap header */
      2 K1 F# q' `, v/ {
1014.   pbmp = pBmp + (index + (width * (height - 1U) * (bit_pixel/8U)));
      
1015. 
      ; F  q9 d( J9 T& h& U  z' X
1016.   /* Convert picture to ARGB8888 pixel format */
      7 _3 U6 @# _( v' b7 ]
1017.   for(index=0; index < height; index++)
      
1018.   {
      
1019.     /* Pixel format conversion */
      
1020.     LL_ConvertLineToRGB(Instance, (uint32_t *)pbmp, (uint32_t *)Address, width, input_color_mode);
      + M5 a0 I) T+ c9 o  n
1021. 
      
1022.     /* Increment the source and destination buffers */
      
1023.     Address+=  (Lcd_Ctx[Instance].XSize * Lcd_Ctx[Instance].BppFactor);
      
1024.     pbmp -= width*(bit_pixel/8U);
      
1025.   }
      
1026. 
      
1027.   return ret;
      
1028. }
      8 `8 \: B1 E  S9 l3 c3 K/ X! B! F$ L
1029. 
      0 L/ \  c3 Q/ g1 z% C9 p  d) E" i4 S
1030. /**
      
1031.   * @brief  Draw a horizontal line on LCD.
      , f7 W" {, y+ _; u; T: g7 L
1032.   * @param  Instance LCD Instance.
      
1033.   * @param  Xpos X position.
      1 Q4 v7 `% d; y8 C7 E
1034.   * @param  Ypos Y position.
      
1035.   * @param  pData Pointer to RGB line data
      ; B1 }. v: x$ d/ J- q
1036.   * @param  Width Rectangle width.
      
1037.   * @param  Height Rectangle Height.
      , f& h3 n) s+ p# l- @$ D/ P5 h
1038.   * @retval BSP status.
      
1039.   */
      
1040. int32_t BSP_LCD_FillRGBRect(uint32_t Instance, uint32_t Xpos, uint32_t Ypos, uint8_t *pData, uint32_t Width, uint32_t Height)
      ; T7 T- S: Q+ B7 |' c
1041. {
      
1042.   uint32_t i;
      
1043.   uint8_t *pdata = pData;
      
1044. 
      # u$ n* H0 C  M) o5 h
1045. #if (USE_DMA2D_TO_FILL_RGB_RECT == 1)
      
1046.   uint32_t  Xaddress;
      
1047.   for(i = 0; i < Height; i++)
      
1048.   {
      
1049.     /* Get the line address */
      
1050.     Xaddress = hlcd_ltdc.LayerCfg[Lcd_Ctx[Instance].ActiveLayer].FBStartAdress + (Lcd_Ctx[Instance].BppFactor*((Lcd_Ctx[Instance].XSize*(Ypos + i)) + Xpos));
      
1051. 
      7 U- M, L8 `$ s
1052. #if (USE_BSP_CPU_CACHE_MAINTENANCE == 1)
      
1053.     SCB_CleanDCache_by_Addr((uint32_t *)pdata, Lcd_Ctx[Instance].BppFactor*Lcd_Ctx[Instance].XSize);
      6 i2 a. I7 w% k: p: U/ K% e" X
1054. #endif /* USE_BSP_CPU_CACHE_MAINTENANCE */
      9 ?" T) B- @. i& ~3 S
1055. 
      
1056.     /* Write line */
      
1057.     if(Lcd_Ctx[Instance].PixelFormat == LCD_PIXEL_FORMAT_RGB565)
      ! I3 Z5 a! b. V7 P# N
1058.     {
      
1059.       LL_ConvertLineToRGB(Instance, (uint32_t *)pdata, (uint32_t *)Xaddress, Width, DMA2D_INPUT_RGB565);
      4 l6 u  J* V0 i
1060.     }
      , {. L/ v& U' K3 v$ S' M
1061.     else if(Lcd_Ctx[Instance].PixelFormat == LCD_PIXEL_FORMAT_ARGB4444)
      
1062.     {
      / L2 }( g6 Y+ p) _# Z0 K* H
1063.       LL_ConvertLineToRGB(Instance, (uint32_t *)pdata, (uint32_t *)Xaddress, Width, DMA2D_INPUT_ARGB4444);
      
1064.     }
      
1065.     else if(Lcd_Ctx[Instance].PixelFormat == LCD_PIXEL_FORMAT_RGB888)
      
1066.     {
      
1067.       LL_ConvertLineToRGB(Instance, (uint32_t *)pdata, (uint32_t *)Xaddress, Width, DMA2D_INPUT_RGB888);
      8 Y) J8 M: V" H1 v, w/ X& y/ p
1068.     }
      
1069.     else
      ' ?. L  e. I0 s  q4 H! V( k3 z
1070.     {
      
1071.       LL_ConvertLineToRGB(Instance, (uint32_t *)pdata, (uint32_t *)Xaddress, Width, DMA2D_INPUT_ARGB8888);
      
1072.     }
      
1073.     pdata += Lcd_Ctx[Instance].BppFactor*Width;
      , j+ {" `$ X0 j- |, u& k
1074.   }
      1 E3 V% T+ m  _
1075. #else
      # G, c! ]) G$ t' i3 ~$ @- J5 F
1076.   uint32_t color;
      / J" X' w7 S% b3 W
1077.   uint32_t j;
      ! p* A( O/ Z  p& [8 x6 A7 Q
1078.   for(i = 0; i < Height; i++)
      
1079.   {
      
1080.     for(j = 0; j < Width; j++)
      * e7 Z% i$ B5 V. m
1081.     {
      3 D* o' A6 i$ ^; r/ ~: t# [
1082.       color = (uint32_t)((uint32_t)*pdata | ((uint32_t)(*(pdata + 1U)) << 8U) | ((uint32_t)(*(pdata + 2U)) << 16U) | ((uint32_t)(*(pdata + 3U)) << 24U));
      
1083.       (void)BSP_LCD_WritePixel(Instance, Xpos + j, Ypos + i, color);
      
1084.       pdata += Lcd_Ctx[Instance].BppFactor;
      5 J7 ^: r4 K6 d: q+ u
1085.     }
      / K$ {, K" r2 d8 E9 r
1086.   }
      , q# k" E5 U* u. I  O* V: l+ _
1087. #endif /* (USE_DMA2D_TO_FILL_RGB_RECT == 1) */
      : G- V# I( E& {6 ~+ _8 X
1088. 
      8 i7 y) d7 v1 q7 p7 t8 Z) [* q( x
1089.   return BSP_ERROR_NONE;
      
1090. }
        ~5 X& P4 Q. Y1 Q) Z, y
1091. 
      
1092. /**
      
1093.   * @brief  Draws an horizontal line in currently active layer.
      
1094.   * @param  Instance   LCD Instance
      9 g5 U! e; g. x! A6 y+ `* F
1095.   * @param  Xpos  X position
      $ |/ `1 n( n& m+ T* ?  c! a# W
1096.   * @param  Ypos  Y position
      
1097.   * @param  Length  Line length
      * h/ s( G- s/ j9 }6 C9 Q
1098.   * @param  Color RGB color
      
1099.   * @retval BSP status
      + m9 p6 |3 l5 L: E0 S0 C
1100.   */
      + y( M1 @5 T& s5 t& Z
1101. int32_t BSP_LCD_DrawHLine(uint32_t Instance, uint32_t Xpos, uint32_t Ypos, uint32_t Length, uint32_t Color)
      
1102. {
      
1103.   uint32_t  Xaddress;
      - Q1 c6 i: t8 n5 q4 \
1104. 
      / n0 \( a! r- \; o
1105.   /* Get the line address */
      
1106.   Xaddress = hlcd_ltdc.LayerCfg[Lcd_Ctx[Instance].ActiveLayer].FBStartAdress + (Lcd_Ctx[Instance].BppFactor*((Lcd_Ctx[Instance].XSize*Ypos) + Xpos));
      
1107. 
      . a6 i! m7 r1 }2 Y
1108.   /* Write line */
      
1109.   LL_FillBuffer(Instance, (uint32_t *)Xaddress, Length, 1, 0, Color);
      
1110. 
      . ]3 J! x* F3 k& ]2 o% K5 n+ ?
1111.   return BSP_ERROR_NONE;
      0 G, r# N5 ^2 V4 [) d! J
1112. }
      $ i; g. N* T! C
1113. 
        H; a. Z% f+ F& J5 @
1114. /**
      6 i" U8 V8 K9 t. w. O
1115.   * @brief  Draws a vertical line in currently active layer.
      $ Q7 Q8 U6 t! _: s9 F# L. J
1116.   * @param  Instance   LCD Instance
      3 O) D2 `& R/ C2 Q/ n: e
1117.   * @param  Xpos  X position
      
1118.   * @param  Ypos  Y position
      
1119.   * @param  Length  Line length
      0 ]; h. d2 ?. g6 b' ?  S& e% \  K/ C
1120.   * @param  Color RGB color
      - [* \% B9 w7 U
1121.   * @retval BSP status
      " V  S5 E' L2 [; B. d4 e
1122.   */
      
1123. int32_t BSP_LCD_DrawVLine(uint32_t Instance, uint32_t Xpos, uint32_t Ypos, uint32_t Length, uint32_t Color)
      + O& u& Y. C% o: \/ G
1124. {
      
1125.   uint32_t  Xaddress;
      & l- n/ d* q$ p  X; g' ~
1126. 
      7 d; Q3 X& {* T! d: {
1127.   /* Get the line address */
      - A5 e: v9 V) T! g1 b# g1 L
1128.   Xaddress = (hlcd_ltdc.LayerCfg[Lcd_Ctx[Instance].ActiveLayer].FBStartAdress) + (Lcd_Ctx[Instance].BppFactor*((Lcd_Ctx[Instance].XSize*Ypos) + Xpos));
      
1129. 
      ! V0 r; I, C2 U  X% ]  B
1130.   /* Write line */
      
1131.   LL_FillBuffer(Instance, (uint32_t *)Xaddress, 1, Length, (Lcd_Ctx[Instance].XSize - 1U), Color);
      
1132. 
      
1133.   return BSP_ERROR_NONE;
      
1134. }
      + q2 [* e' b9 I2 k: {' @- z$ T3 S+ V
1135. 
      
1136. /**
      
1137.   * @brief  Draws a full rectangle in currently active layer.
      
1138.   * @param  Instance   LCD Instance
      4 G' |2 E/ s3 L" \: b7 r
1139.   * @param  Xpos X position
      
1140.   * @param  Ypos Y position
      
1141.   * @param  Width Rectangle width
      
1142.   * @param  Height Rectangle height
      
1143.   * @param  Color RGB color
        ?6 x9 g: F, P; r% ]
1144.   * @retval BSP status
      
1145.   */
      
1146. int32_t BSP_LCD_FillRect(uint32_t Instance, uint32_t Xpos, uint32_t Ypos, uint32_t Width, uint32_t Height, uint32_t Color)
      1 m/ v* p" E2 g' D% w
1147. {
      
1148.   uint32_t  Xaddress;
      4 N5 x+ u9 m; @& J
1149. 
      9 r+ D( o4 o+ [" A; G
1150.   /* Get the rectangle start address */
      2 _2 i2 s' }: l1 k& b
1151.   Xaddress = (hlcd_ltdc.LayerCfg[Lcd_Ctx[Instance].ActiveLayer].FBStartAdress) + (Lcd_Ctx[Instance].BppFactor*((Lcd_Ctx[Instance].XSize*Ypos) + Xpos));
      
1152. 
      & {5 E5 n0 J% r) @9 n  c* F5 {
1153.   /* Fill the rectangle */
      
1154.   LL_FillBuffer(Instance, (uint32_t *)Xaddress, Width, Height, (Lcd_Ctx[Instance].XSize - Width), Color);
      
1155. 
      5 i' S" ^5 [& l
1156.   return BSP_ERROR_NONE;
      % j: f8 C* ?' \- L) s
1157. }
      
1158. 
      . k6 n! S0 j5 R" y" y
1159. /**
      
1160.   * @brief  Reads a LCD pixel.
      / N  j- Y" V7 G# ~$ |# k& U
1161.   * @param  Instance    LCD Instance
      
1162.   * @param  Xpos X position
      
1163.   * @param  Ypos Y position
      
1164.   * @param  Color RGB pixel color
      7 w/ w: L. w, I( Q6 k9 M7 W
1165.   * @retval BSP status
      7 E+ M# m2 F3 H. _5 E8 X0 V0 u
1166.   */
        Q, Z6 F0 X: Z, q6 s
1167. int32_t BSP_LCD_ReadPixel(uint32_t Instance, uint32_t Xpos, uint32_t Ypos, uint32_t *Color)
      
1168. {
      
1169.   if(hlcd_ltdc.LayerCfg[Lcd_Ctx[Instance].ActiveLayer].PixelFormat == LTDC_PIXEL_FORMAT_ARGB8888)
      
1170.   {
      
1171.     /* Read data value from RAM memory */
      
1172.     *Color = *(__IO uint32_t*) (hlcd_ltdc.LayerCfg[Lcd_Ctx[Instance].ActiveLayer].FBStartAdress + (4U*((Ypos*Lcd_Ctx[Instance].XSize) + Xpos)));
      
1173.   }
      
1174.   else if(hlcd_ltdc.LayerCfg[Lcd_Ctx[Instance].ActiveLayer].PixelFormat == LTDC_PIXEL_FORMAT_RGB888)
      
1175.   {
      + k: u' `2 u, a1 N$ O
1176.     /* Read data value from RAM memory */
      7 T4 X( i2 @1 N, U
1177.     *Color = *(__IO uint32_t*) (hlcd_ltdc.LayerCfg[Lcd_Ctx[Instance].ActiveLayer].FBStartAdress + (3U*((Ypos*Lcd_Ctx[Instance].XSize) + Xpos)));
      3 ]& {9 ?! i. d# X& ~
1178.     *Color = CONVERTARGB88882RGB888(*Color);
      # k! e1 r$ M) z( E/ {  z( {# J
1179.   }
      % j, T& t. N" |8 @! l9 S9 r' {
1180.   else /* if((hlcd_ltdc.LayerCfg[layer].PixelFormat == LTDC_PIXEL_FORMAT_RGB565) */
      # I9 [- G; K* b! J! B
1181.   {
      0 w5 E+ V& ~# _
1182.     /* Read data value from RAM memory */
      * e6 i0 U$ N& O3 r- v) [5 k. \
1183.     *Color = *(__IO uint16_t*) (hlcd_ltdc.LayerCfg[Lcd_Ctx[Instance].ActiveLayer].FBStartAdress + (2U*((Ypos*Lcd_Ctx[Instance].XSize) + Xpos)));
        m6 e2 J& f: n9 D7 }) l+ e0 p
1184.   }
      
1185. 
      
1186.   return BSP_ERROR_NONE;
      
1187. }
      
1188. 
      1 C. F5 i8 _0 [  @8 b  ]4 s& D
1189. /**
      
1190.   * @brief  Draws a pixel on LCD.
      $ e2 h* j7 R" M+ z+ T: C& U
1191.   * @param  Instance    LCD Instance
      7 }, K& Z, n; X! O* S
1192.   * @param  Xpos X position
      7 k1 K  ~8 f7 K. ~9 I( j
1193.   * @param  Ypos Y position
      
1194.   * @param  Color Pixel color
      
1195.   * @retval BSP status
      % Y* l+ v$ z/ \4 b
1196.   */
      
1197. int32_t BSP_LCD_WritePixel(uint32_t Instance, uint32_t Xpos, uint32_t Ypos, uint32_t Color)
      " L8 t# V( w" @7 d/ B1 t
1198. {
      7 H( R* J) q0 F* t3 x/ N9 }, S' p
1199.   if(hlcd_ltdc.LayerCfg[Lcd_Ctx[Instance].ActiveLayer].PixelFormat == LTDC_PIXEL_FORMAT_ARGB8888)
      
1200.   {
      
1201.     /* Write data value to RAM memory */
      + }6 f5 R9 ^/ o) E6 r  f" \
1202.     *(__IO uint32_t*) (hlcd_ltdc.LayerCfg[Lcd_Ctx[Instance].ActiveLayer].FBStartAdress + (4U*((Ypos*Lcd_Ctx[Instance].XSize) + Xpos))) = Color;
      
1203.   }
      
1204.   else if(hlcd_ltdc.LayerCfg[Lcd_Ctx[Instance].ActiveLayer].PixelFormat == LTDC_PIXEL_FORMAT_RGB888)
      
1205.   {
      ) K, M1 K; o4 Z; k$ T
1206.     /* Write data value to RAM memory */
      9 C5 N+ x0 ]6 L' ~
1207.     *(__IO uint8_t*) (hlcd_ltdc.LayerCfg[Lcd_Ctx[Instance].ActiveLayer].FBStartAdress + ((3U*((Ypos*Lcd_Ctx[Instance].XSize) + Xpos))-3U)) = (uint8_t) (Color);
      
1208.     *(__IO uint8_t*) (hlcd_ltdc.LayerCfg[Lcd_Ctx[Instance].ActiveLayer].FBStartAdress + ((3U*((Ypos*Lcd_Ctx[Instance].XSize) + Xpos))-2U)) = (uint8_t) (Color>>8U);
      . o2 i8 I1 t- k5 m, D- V; v
1209.     *(__IO uint8_t*) (hlcd_ltdc.LayerCfg[Lcd_Ctx[Instance].ActiveLayer].FBStartAdress + ((3U*((Ypos*Lcd_Ctx[Instance].XSize) + Xpos))-1U)) = (uint8_t) (Color>>16U);
      
1210.   }
      " S4 e* o$ @7 F' {  f% d( d! ~$ r
1211.   else
      4 @3 o" A' H0 ^+ t; \
1212.   {
      # n: j' a5 K, L/ a0 g  `/ U
1213.     /* Write data value to RAM memory */
      ! \7 N8 W# m( ^, @; b! ?! e5 S! m
1214.     *(__IO uint16_t*) (hlcd_ltdc.LayerCfg[Lcd_Ctx[Instance].ActiveLayer].FBStartAdress + (2U*((Ypos*Lcd_Ctx[Instance].XSize) + Xpos))) = (uint16_t)Color;
      
1215.   }
      
1216. 
      * T' C2 K5 {( [  n. i: D; T
1217.   return BSP_ERROR_NONE;
      
1218. }
      . P9 v( }5 L" ?( v- s2 A# v" Y
1219. 
      5 _6 I8 Z- A$ C4 B2 Q( F' e
1220. /**
      , ?' {$ R/ ?: x" q
1221.   * @}
      5 F( s- u" Z9 u3 _" S3 U
1222.   */
      ; k0 t1 H, ?) u3 P. C
1223. 
      
1224. /** @defgroup STM32N6570_DK_LCD_Private_Functions LCD Private Functions
      
1225.   * @{
      " w$ I4 X2 o( c# a
1226.   */
      $ `9 D0 n6 ^: A9 U3 d" F( Q
1227. /**
      
1228.   * @brief  Fills a buffer.
      
1229.   * @param  Instance LCD Instance
      
1230.   * @param  pDst Pointer to destination buffer
      
1231.   * @param  xSize Buffer width
      
1232.   * @param  ySize Buffer height
      
1233.   * @param  OffLine Offset
      9 I' z0 z' j9 c* P" M# Y% L
1234.   * @param  Color RGB color
      & |4 |8 r8 T; I' Z
1235.   */
      : R6 f5 A. b. g' P+ E, t' h+ V
1236. static void LL_FillBuffer(uint32_t Instance, uint32_t *pDst, uint32_t xSize, uint32_t ySize, uint32_t OffLine, uint32_t Color)
      
1237. {
      ' V# d( [/ ?1 H" I1 F
1238.   uint32_t output_color_mode;
      
1239.   uint32_t input_color = Color;
      
1240. 
      . @( o. Z) U. z! W+ t4 F, J- b0 x! C
1241.   switch(Lcd_Ctx[Instance].PixelFormat)
      
1242.   {
      
1243.   case LCD_PIXEL_FORMAT_RGB565:
      2 Y3 I, n$ h# ?( m* [2 Y
1244.     output_color_mode = DMA2D_OUTPUT_RGB565; /* RGB565 */
      
1245.     input_color = CONVERTRGB5652ARGB8888(Color);
      
1246.     break;
      
1247.   case LCD_PIXEL_FORMAT_ARGB4444:
      
1248.     output_color_mode = DMA2D_OUTPUT_ARGB4444; /* ARGB4444 */
      
1249.     input_color = CONVERTARGB44442ARGB8888(Color);
      0 N, H' m; `8 b7 r( {; g
1250.     break;
      
1251.   case LCD_PIXEL_FORMAT_RGB888:
      4 n8 b8 _( |& d8 Y4 J% \+ d
1252.     output_color_mode = DMA2D_OUTPUT_RGB888; /* RGB888 */
      
1253.     input_color = CONVERTRGB8882ARGB8888(Color);
      5 z+ s4 M7 j6 i. q6 I
1254.     break;
      
1255.   default:
      
1256.     output_color_mode = DMA2D_OUTPUT_ARGB8888; /* ARGB8888 */
      
1257.     break;
      
1258.   }
      
1259. 
      
1260.   /* Register to memory mode with ARGB8888 as color Mode */
      2 N  _# f' w' S; `1 \- ^  F2 q
1261.   hlcd_dma2d.Init.Mode         = DMA2D_R2M;
      ; \( W8 P% ]# }
1262.   hlcd_dma2d.Init.ColorMode    = output_color_mode;
      
1263.   hlcd_dma2d.Init.OutputOffset = OffLine;
      
1264. 
      6 R" Q$ Z# U* @5 N& y' c3 _: l
1265.   hlcd_dma2d.Instance = DMA2D;
      9 x0 m1 S! x1 R; `9 t  M) N
1266. 
      + Q" U* x* i! }6 w, E
1267.   /* DMA2D Initialization */
      
1268.   if(HAL_DMA2D_Init(&hlcd_dma2d) == HAL_OK)
      
1269.   {
      ( v( Q! F1 t) x+ I, K9 b$ X7 G5 \
1270.     if (HAL_DMA2D_Start(&hlcd_dma2d, input_color, (uint32_t)pDst, xSize, ySize) == HAL_OK)
      . L+ u- {& T9 c, @6 ^* I- r. s. z
1271.     {
      
1272.       /* Polling For DMA transfer */
      
1273.       (void)HAL_DMA2D_PollForTransfer(&hlcd_dma2d, 50);
      
1274.     }
      
1275.   }
      
1276. }
      
1277. 
      
1278. /**
      0 v! [" E7 Y8 O  R3 J& D) c
1279.   * @brief  Converts a line to an RGB pixel format.
      * c, z  f! V. B: v
1280.   * @param  Instance LCD Instance
      
1281.   * @param  pSrc Pointer to source buffer
      
1282.   * @param  pDst Output color
      + d+ X+ F4 S0 S) U6 C+ D- u' [
1283.   * @param  xSize Buffer width
      ! P' l9 G6 ~, p  [
1284.   * @param  ColorMode Input color mode
      ; {7 W7 H  w+ Z, Y# Q
1285.   */
      ; W  w4 R$ T) \1 h. w9 T
1286. static void LL_ConvertLineToRGB(uint32_t Instance, uint32_t *pSrc, uint32_t *pDst, uint32_t xSize, uint32_t ColorMode)
      
1287. {
      
1288.   uint32_t output_color_mode;
      ( E1 M+ f- N' n" \& p
1289. 
      
1290.   switch(Lcd_Ctx[Instance].PixelFormat)
      
1291.   {
      
1292.   case LCD_PIXEL_FORMAT_RGB565:
      3 x/ g/ i5 Z& j9 i8 ^, `
1293.     output_color_mode = DMA2D_OUTPUT_RGB565; /* RGB565 */
      
1294.     break;
      
1295.   case LCD_PIXEL_FORMAT_ARGB4444:
      7 M2 r8 k8 Q" j; U$ ?- Z
1296.     output_color_mode = DMA2D_OUTPUT_ARGB4444; /* ARGB4444 */
      3 _; v9 V6 n9 y* K: L! k4 _5 l9 ^
1297.     break;
      . E( ?# f7 E+ m, c0 W6 D
1298.   case LCD_PIXEL_FORMAT_RGB888:
      
1299.     output_color_mode = DMA2D_OUTPUT_RGB888; /* RGB888 */
      4 Q' o" c" R+ T, J9 K' Z
1300.     break;
      
1301.   default:
      
1302.     output_color_mode = DMA2D_OUTPUT_ARGB8888; /* ARGB8888 */
      * N- q9 n7 _7 \0 H
1303.     break;
      
1304.   }
      
1305. 
      
1306.   /* Configure the DMA2D Mode, Color Mode and output offset */
      , z+ Y7 w# d# x
1307.   hlcd_dma2d.Init.Mode         = DMA2D_M2M_PFC;
      
1308.   hlcd_dma2d.Init.ColorMode    = output_color_mode;
      
1309.   hlcd_dma2d.Init.OutputOffset = 0;
      
1310. 
      1 I, C8 X* }% L& k* i2 _, j
1311.   /* Foreground Configuration */
      
1312.   hlcd_dma2d.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA;
      . l( [) x8 V) U% Z
1313.   hlcd_dma2d.LayerCfg[1].InputAlpha = 0xFF;
      
1314.   hlcd_dma2d.LayerCfg[1].InputColorMode = ColorMode;
      2 @5 q  B/ m# i8 i: L: B$ `
1315.   hlcd_dma2d.LayerCfg[1].InputOffset = 0;
      , W" p+ j/ }: A" L" [$ K8 R
1316. 
      
1317.   hlcd_dma2d.Instance = DMA2D;
      ' h$ c5 S; q$ I2 p
1318. 
      3 F/ Z5 i  q) `, p: \
1319.   /* DMA2D Initialization */
      
1320.   if(HAL_DMA2D_Init(&hlcd_dma2d) == HAL_OK)
      - f( N! q6 o+ w2 X! ]0 x
1321.   {
      
1322.     if(HAL_DMA2D_ConfigLayer(&hlcd_dma2d, 1) == HAL_OK)
      ) W; |$ k9 J& |7 V) x
1323.     {
      
1324.       if (HAL_DMA2D_Start(&hlcd_dma2d, (uint32_t)pSrc, (uint32_t)pDst, xSize, 1) == HAL_OK)
      $ J9 i! L# Y3 C. S7 @6 f
1325.       {
      
1326.         /* Polling For DMA transfer */
      
1327.         (void)HAL_DMA2D_PollForTransfer(&hlcd_dma2d, 50);
      ; v6 j) \* g' l( E9 b# m$ j- \, |1 ^
1328.       }
      
1329.     }
      
1330.   }
      7 Q' D% G/ Y( P) S/ {
1331. }
      
1332. 
      5 x+ }0 |4 D( a# d6 S
1333. /**
      
1334.   * @brief  Initialize the BSP LTDC Msp.
      4 F& W7 i% }, O. i) z: O
1335.   * @param  hltdc  LTDC handle
      , m5 f1 Y3 E' P0 r9 e! a
1336.   * @retval None
      
1337.   */
      % \  ~9 f& S# \. ~# b! ~4 o& |
1338. static void LTDC_MspInit(LTDC_HandleTypeDef *hltdc)
      
1339. {
      ; ]9 c/ @! \& n+ I* R  J$ V* i$ k
1340.   GPIO_InitTypeDef  gpio_init_structure = {0};
      
1341. 
      7 z# U* R, a) A! u% f( y- z7 @; d
1342.   if (hltdc->Instance == LTDC)
      
1343.   {
      
1344.     __HAL_RCC_LTDC_CLK_ENABLE();
      
1345. 
        O  |3 s4 O7 o( o5 c9 N
1346.     __HAL_RCC_LTDC_FORCE_RESET();
      
1347.     __HAL_RCC_LTDC_RELEASE_RESET();
      
1348. 
      / f  i: J% F. G+ G* D4 T
1349.     /* STM32N6570-DK MB1860A RK050HR18 */
      1 v" o5 k0 }! ~
1350.     /* PG0  R0          */
      - n" B1 n- R% y& l- g
1351.     /* PD9  R1          */
      $ L8 `1 ?9 f6 U; f. ?; c; [3 {! \
1352.     /* PD15 R2          */
      0 \1 j$ [6 E& X  e
1353.     /* PB4  R3          */ // JTAG
      
1354.     /* PH4  R4          */
      ' H& K& @2 R* A1 A) x
1355.     /* PA15 R5          */ // JTAG JTDI
      , ?, d& j4 R; W; g
1356.     /* PG11 R6          */
      $ ^  u6 l4 |  D" v# I" I; L
1357.     /* PD8  R7          */
      8 U6 b- {  J: v& Y2 S1 d
1358.     /* PG12 G0          */
      
1359.     /* PG1  G1          */
      
1360.     /* PA1  G2          */
      
1361.     /* PA0  G3          */
      5 @6 ~% c- M8 l2 T! n5 T" l7 b) q) s
1362.     /* PB15 G4          */
      5 s: |7 a- z  N! M& i& {
1363.     /* PB12 G5          */
      
1364.     /* PB11 G6          */
      # b) O; i2 [! ]7 R% I
1365.     /* PG8  G7          */
      
1366.     /* P15  B0          */
      
1367.     /* PA7  B1          */
      
1368.     /* PB2  B2          */
      
1369.     /* PG6  B3          */
      
1370.     /* PH3  B4          */
      
1371.     /* PH6  B5          */
      
1372.     /* PA8  B6          */
      ' p6 ]0 N4 a: o! s. }- a
1373.     /* PA2  B7          */
        V) U' `7 c  n# l5 R! A- {# Z8 N
1374.     /*                  */
      
1375.     /* PG13 LCD_DE      */
      
1376.     /* PQ3  LCD_ONOFF   */
      4 J6 u# z7 T& H/ l- }1 K
1377.     /* PB14 LCD_HSYNC   */
      , e3 e6 y5 v( B! P- {( e: T) q
1378.     /* PE11 PCD_VSYNC   */
      
1379.     /* PB13 LCD_CLK     */
      : M9 N" a; N0 ~+ x6 r
1380.     /* PQ4  LCD_INT     */
      ' J  C- p* C+ `* P) M
1381.     /* PQ6  LCD_BL_CTRL */
      
1382.     /* PE1  NRST        */
      
1383. 
      % K- P$ S) s8 q' G
1384.     __HAL_RCC_GPIOA_CLK_ENABLE();
      
1385.     __HAL_RCC_GPIOB_CLK_ENABLE();
      : B( m5 \( c. H7 }
1386.     __HAL_RCC_GPIOD_CLK_ENABLE();
      
1387.     __HAL_RCC_GPIOE_CLK_ENABLE();
      
1388.     __HAL_RCC_GPIOG_CLK_ENABLE();
      
1389.     __HAL_RCC_GPIOH_CLK_ENABLE();
      
1390.     __HAL_RCC_GPIOQ_CLK_ENABLE();
      8 H1 p% i4 i" Z0 `7 l
1391. 
      
1392.     gpio_init_structure.Mode      = GPIO_MODE_AF_PP;
      
1393.     gpio_init_structure.Pull      = GPIO_NOPULL;
      
1394.     gpio_init_structure.Speed     = GPIO_SPEED_FREQ_HIGH;
      & }: o3 H2 ~( e& Z' x+ L
1395. 
      
1396.     /* G3, G2, B7, B1, B6, R5 */
      . B" L- M" m" O5 h. ?0 f
1397.     gpio_init_structure.Pin       = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_7 | GPIO_PIN_8 | GPIO_PIN_15;
      " D* x2 u$ Z8 R  c9 y) p1 r& ~
1398.     gpio_init_structure.Alternate = GPIO_AF14_LCD;
      ; \/ [: \1 H. w, r( J
1399.     HAL_GPIO_Init(GPIOA, &gpio_init_structure);
      
1400. 
      
1401.     /* LCD_CLK, LCD_HSYNC B2, R3, G6, G5, G4 */
      
1402.     gpio_init_structure.Pin       = GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_2 | GPIO_PIN_4 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_15;
      / b$ x$ C) S* E$ @! w- \/ b) J
1403.     gpio_init_structure.Alternate = GPIO_AF14_LCD;
      9 L' D6 v& Q+ p  `. @  `
1404.     HAL_GPIO_Init(GPIOB, &gpio_init_structure);
        Z: i  B9 n% N/ c2 S! T" R* W
1405. 
      4 Y6 A, A" F1 D7 w
1406.     /* R7, R1, R2 */
      
1407.     gpio_init_structure.Pin       = GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_15;
      
1408.     gpio_init_structure.Alternate = GPIO_AF14_LCD;
      : e/ \& L& E  p
1409.     HAL_GPIO_Init(GPIOD, &gpio_init_structure);
      0 D/ J. J& q; T+ U+ J
1410. 
      
1411.     /* LCD_VSYNC */
      
1412.     gpio_init_structure.Pin       = GPIO_PIN_11;
      % l+ J% K) i4 R1 M4 ?
1413.     gpio_init_structure.Alternate = GPIO_AF14_LCD;
      
1414.     HAL_GPIO_Init(GPIOE, &gpio_init_structure);
      
1415. 
      6 J4 A* ?1 H- z
1416.     /* R0, G1, B3, G7, R6, G0 */
      
1417.     gpio_init_structure.Pin       = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_6 | GPIO_PIN_8 | GPIO_PIN_11 | GPIO_PIN_12 ;
      2 B5 L  U  |2 m7 }' A
1418.     gpio_init_structure.Alternate = GPIO_AF14_LCD;
      ( c. |3 R' S0 q* o) A6 P) T
1419.     HAL_GPIO_Init(GPIOG, &gpio_init_structure);
      9 g) v# B; u3 m! y% U' n
1420. 
      
1421.     /* B4, R4, B5 */
      
1422.     gpio_init_structure.Pin       = GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_6;
      8 ^5 O4 t9 g! {' ^, {% {
1423.     gpio_init_structure.Alternate = GPIO_AF14_LCD;
      1 n; N- `* d# R/ u1 L  w7 K% |
1424.     HAL_GPIO_Init(GPIOH, &gpio_init_structure);
      ) B4 n( f: o, o" R. W# J
1425. 
      9 o& Z1 a# N* o, y
1426.     /* NRST */
      
1427.     gpio_init_structure.Pin       = GPIO_PIN_1;
      
1428.     gpio_init_structure.Mode      = GPIO_MODE_OUTPUT_PP;
      9 E; T# v1 H) {: \+ v. V7 K  J
1429.     HAL_GPIO_Init(GPIOE, &gpio_init_structure);
        @) P! L8 q% Q, b! ?# G
1430. 
      
1431.     /* LCD_ONOFF, LCD_BL_CTRL */
      
1432.     gpio_init_structure.Pin       = GPIO_PIN_3 | GPIO_PIN_6;
      ( ~) V! {. C/ U5 E1 ~5 |
1433.     gpio_init_structure.Mode      = GPIO_MODE_OUTPUT_PP;
      
1434.     HAL_GPIO_Init(GPIOQ, &gpio_init_structure);
      
1435. 
      
1436.     /* LCD_DE */
      ' C; S) o* z" O0 R  y" t
1437.     gpio_init_structure.Pin       = GPIO_PIN_13;
      " p$ k) s; ]% I5 \7 j$ H
1438.     gpio_init_structure.Mode      = GPIO_MODE_OUTPUT_PP;
      
1439.     HAL_GPIO_Init(GPIOG, &gpio_init_structure);
      ( d8 p1 Y& o; A- b- J1 H
1440. 
      
1441.     HAL_GPIO_WritePin(GPIOQ, GPIO_PIN_3, GPIO_PIN_SET); /* LCD On */ /* PQ3  LCD_ONOFF   */
      
1442.     HAL_GPIO_WritePin(GPIOG, GPIO_PIN_13, GPIO_PIN_SET); /* Display Enable */ /* PG13 LCD_DE      */
      
1443.     HAL_GPIO_WritePin(GPIOQ, GPIO_PIN_6, GPIO_PIN_SET); /* 100% Brightness */ /* PQ6  LCD_BL_CTRL */
      
1444. 
      
1445.   }
      6 G& G* L+ X' m7 w3 h7 I. s2 M
1446. }
      " Q) j% P( j2 v
1447. 
      
1448. /**
      
1449.   * @brief  De-Initializes the BSP LTDC Msp
      7 O4 G2 o* }# Y9 m) [
1450.   * @param  hltdc  LTDC handle
      
1451.   * @retval None
      
1452.   */
      
1453. static void LTDC_MspDeInit(LTDC_HandleTypeDef *hltdc)
      ! Z$ j. ^7 C, |6 \
1454. {
      % D- G% v6 Q6 Z' B* C
1455.   GPIO_InitTypeDef  gpio_init_structure;
      
1456. 
      
1457.   if(hltdc->Instance == LTDC)
      1 _' R; s7 S! H5 b
1458.   {
      
1459.     /* LTDC Pins deactivation */
      
1460.     /* GPIOA deactivation */
      
1461.     gpio_init_structure.Pin       = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_8|GPIO_PIN_11 |GPIO_PIN_12| GPIO_PIN_15 | GPIO_PIN_6 | GPIO_PIN_9|GPIO_PIN_10;
      . C" k( {5 F+ o6 |; e+ x/ L
1462.     HAL_GPIO_DeInit(GPIOA, gpio_init_structure.Pin);
      
1463. 
      
1464.     /* GPIOB deactivation */
      ( h+ E: D) K: L0 e6 P1 A. L1 c
1465.     gpio_init_structure.Pin       = GPIO_PIN_13 | GPIO_PIN_15 | GPIO_PIN_3 |GPIO_PIN_4 | GPIO_PIN_10| GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_14;
      
1466.     HAL_GPIO_DeInit(GPIOB, gpio_init_structure.Pin);
      * e& F0 M- D) v* a
1467. 
      4 g6 S" N3 N/ G( z. a* l7 N+ q
1468.     /* GPIOE deactivation */
      2 O! H! \& U( a; A8 R) o
1469.     gpio_init_structure.Pin       = GPIO_PIN_11 | GPIO_PIN_15;
      
1470.     HAL_GPIO_DeInit(GPIOE, gpio_init_structure.Pin);
      
1471. 
      
1472.     /* GPIOF deactivation */
      ! R+ h  Q9 U% _" Q* J2 [
1473.     gpio_init_structure.Pin       = GPIO_PIN_0 | GPIO_PIN_10|GPIO_PIN_11 | GPIO_PIN_9 | GPIO_PIN_7 | GPIO_PIN_15;
      # m$ h8 F! M* X
1474.     HAL_GPIO_DeInit(GPIOF, gpio_init_structure.Pin);
      & a6 X8 q# N7 R6 u1 i; j( s
1475. 
      , X- U1 y7 t  Q2 M( p* B/ X
1476.     /* GPIOG deactivation */
      
1477.     gpio_init_structure.Pin       = GPIO_PIN_0 | GPIO_PIN_1| GPIO_PIN_2 | GPIO_PIN_13|GPIO_PIN_14;
      
1478.     HAL_GPIO_DeInit(GPIOG, gpio_init_structure.Pin);
      
1479. 
      , X$ ~1 X1 r) f7 P  J
1480.     /** Force and let in reset state LTDC */
      / l9 D, Y) \5 h8 s5 ?, I! G: |' g
1481.     __HAL_RCC_LTDC_FORCE_RESET();
      
1482. 
      ) `9 K2 N# y" s8 @5 X
1483.     __HAL_RCC_LTDC_RELEASE_RESET();
      1 C* ~0 m% g- K) c
1484. 
      
1485.     /** Disable the LTDC */
      
1486.     __HAL_RCC_LTDC_CLK_DISABLE();
      
1487.   }
      ! q- |; e, t- m5 Y+ `" E' L6 v
1488. }
      1 D! e) f6 @- O' M9 q( j9 R5 ]
1489. 
      
1490. /**
      / T$ y: n0 Y3 M% F
1491.   * @brief  Initialize the BSP DMA2D Msp.
      
1492.   * @param  hdma2d  DMA2D handle
      
1493.   * @retval None
      
1494.   */
      
1495. static void DMA2D_MspInit(DMA2D_HandleTypeDef *hdma2d)
      
1496. {
      
1497.   if(hdma2d->Instance == DMA2D)
      ; z/ u9 C5 W- B/ ^* b- e% O# i/ S
1498.   {
      
1499.     /** Enable the DMA2D clock */
      ' P9 `* u, E7 h: h$ N2 N% m. L  {
1500.     __HAL_RCC_DMA2D_CLK_ENABLE();
      
1501. 
      
1502.     /** Toggle Sw reset of DMA2D IP */
      
1503.     __HAL_RCC_DMA2D_FORCE_RESET();
      - i9 c* G* Z' G/ |2 b8 e
1504.     __HAL_RCC_DMA2D_RELEASE_RESET();
      
1505.   }
      
1506. }
      
1507. 
      5 X5 e& S, s2 l
1508. /**
      # Z$ i* p( x5 H
1509.   * @brief  De-Initializes the BSP DMA2D Msp
      / _1 t& V# K5 h
1510.   * @param  hdma2d  DMA2D handle
      3 z, x# f) A( O, X
1511.   * @retval None
      8 K3 P3 g0 U; x& ?2 ~& g
1512.   */
      
1513. static void DMA2D_MspDeInit(DMA2D_HandleTypeDef *hdma2d)
      3 ^2 j" n6 S! Q4 n; C
1514. {
      % f! Z3 p# B8 a! G
1515.   if(hdma2d->Instance == DMA2D)
      3 X5 S# d# g0 {' b+ n) \- ?
1516.   {
      
1517.     /** Disable IRQ of DMA2D IP */
      4 B; @4 t1 g- n3 t% l% c$ k
1518.     HAL_NVIC_DisableIRQ(DMA2D_IRQn);
      . X+ D: F* G+ W0 t7 n
1519. 
      
1520.     /** Force and let in reset state DMA2D */
      4 X, ?1 R% R& I& Q; N3 X
1521.     __HAL_RCC_DMA2D_FORCE_RESET();
      
1522.     __HAL_RCC_DMA2D_RELEASE_RESET();
      
1523. 
      
1524.     /** Disable the DMA2D */
      
1525.     __HAL_RCC_DMA2D_CLK_DISABLE();
      " h+ ^- ?: u7 t
1526.   }
      # m3 d, m: g7 U% S; z$ t! T5 y* O
1527. }
      7 K# X+ G' v" f! b3 L
1528. 
        U8 T4 y% j& J/ N
1529. /**
      & [" U7 Z8 f. r& c# p) O
1530.   * @}
      ; Z& \% A9 Y1 C# O
1531.   */
      
1532. 
      % v) @' R! W5 p1 L- w
1533. /**
      ; E# _4 m+ S/ Y
1534.   * @}
      
1535.   */
      
1536. 
      
1537. /**
      1 p% v6 z: V: }' ~# z
1538.   * @}
      / {$ e  M0 r: r* G) T
1539.   */
      
1540. 
      
1541. /**
      " |. n/ y$ A6 k+ P
1542.   * @}
      , o0 V  I5 E: x  A7 K! }- y; l7 \
1543.   */
      - p! o! O* b, Q! Y$ n  a
1544. 
      + r9 G8 q9 g' G3 H8 ?: q

复制代码

! P* u* E$ C3 [
4 e5 |2 Z2 h* c) H9 j4 A5 K: e) C2.2、main.c
1 K9 }6 T5 F/ S! E( e0 ~

1. int main(void)
   
2. {
   
3.   uint32_t x_size;
   , x) J2 |! I- I& A" B
4.   uint32_t y_size;
   
5.   uint16_t i,j;
   
6. 
   " y0 t% i5 t& U4 M" W7 h
7.   HAL_Init();
   8 n9 y  ]: U# |$ }4 q0 C3 W
8.   SystemClock_Config();
   : ]  u$ x$ |7 B/ A  C. ]
9.   
   
10.   /* Update the RIF config for the used peripherals */
    . N1 R9 Q  P, a0 q
11.   RIMC_MasterConfig_t RIMC_master = {0};
    5 M0 ]5 w8 X, x0 |* ~* j; a( g% l
12.   RIMC_master.MasterCID = RIF_CID_1;
    9 x; E1 q" w' ?+ G) [' X6 y( p( C; a& \5 V
13.   RIMC_master.SecPriv = RIF_ATTRIBUTE_SEC | RIF_ATTRIBUTE_PRIV;
    
14.   HAL_RIF_RIMC_ConfigMasterAttributes(RIF_MASTER_INDEX_DCMIPP, &RIMC_master);
    
15.   HAL_RIF_RIMC_ConfigMasterAttributes(RIF_MASTER_INDEX_DMA2D, &RIMC_master);
    8 u& A/ o# Z& J% D$ J/ `  u
16.   HAL_RIF_RIMC_ConfigMasterAttributes(RIF_MASTER_INDEX_LTDC1 , &RIMC_master);
    
17.   HAL_RIF_RIMC_ConfigMasterAttributes(RIF_MASTER_INDEX_LTDC2 , &RIMC_master);
    $ K( }8 S# Z4 D
18.   HAL_RIF_RIMC_ConfigMasterAttributes(RIF_MASTER_INDEX_VENC  , &RIMC_master);
    ) q5 ?  P- N3 x: q
19.   HAL_RIF_RISC_SetSlaveSecureAttributes(RIF_RISC_PERIPH_INDEX_DMA2D  , RIF_ATTRIBUTE_SEC | RIF_ATTRIBUTE_PRIV);
    
20.   HAL_RIF_RISC_SetSlaveSecureAttributes(RIF_RISC_PERIPH_INDEX_DCMIPP , RIF_ATTRIBUTE_SEC | RIF_ATTRIBUTE_PRIV);
    ! ]! ~& n8 \% G6 {
21.   HAL_RIF_RISC_SetSlaveSecureAttributes(RIF_RISC_PERIPH_INDEX_CSI    , RIF_ATTRIBUTE_SEC | RIF_ATTRIBUTE_PRIV);
    
22.   HAL_RIF_RISC_SetSlaveSecureAttributes(RIF_RISC_PERIPH_INDEX_LTDC   , RIF_ATTRIBUTE_SEC | RIF_ATTRIBUTE_PRIV);
    
23.   HAL_RIF_RISC_SetSlaveSecureAttributes(RIF_RISC_PERIPH_INDEX_LTDCL1 , RIF_ATTRIBUTE_SEC | RIF_ATTRIBUTE_PRIV);
    
24.   HAL_RIF_RISC_SetSlaveSecureAttributes(RIF_RISC_PERIPH_INDEX_LTDCL2 , RIF_ATTRIBUTE_SEC | RIF_ATTRIBUTE_PRIV);
    
25. 
    / S4 b* D3 J% b$ f5 R+ G
26.   BSP_LED_Init(LED_GREEN);
    
27.   BSP_LED_Init(LED_RED);
    1 G$ W* E! w' L
28.   
    0 w$ G* s% I; V: ?7 H
29.   #if USE_COM_LOG
    
30.   COM_InitTypeDef COM_Init;
    
31. 
    + C) T# T! p# F& y6 K- T) p
32.   /* Initialize COM init structure */
    
33.   COM_Init.BaudRate   = 115200;
    
34.   COM_Init.WordLength = COM_WORDLENGTH_8B;
    # n6 Q+ U& R) i- Z& w
35.   COM_Init.StopBits   = COM_STOPBITS_1;
    
36.   COM_Init.Parity     = COM_PARITY_NONE;
    . J& J  x5 U  D$ f2 A( l+ Q- \# Z
37.   COM_Init.HwFlowCtl  = COM_HWCONTROL_NONE;
    ) Q3 V- w8 c$ G: K8 m. f4 R
38. 
    
39.   BSP_COM_Init(COM1, &COM_Init);
    
40. 
    7 U; ^/ ~8 {# `  F3 e. B) a9 d
41.   if (BSP_COM_SelectLogPort(COM1) != BSP_ERROR_NONE)
    , S: d% V- ]- c! h' A; L) m
42.   {
    
43.     Error_Handler();
    
44.   }
    - e' L9 q! T/ L) _
45. #endif
    
46.   
    
47.   BSP_LCD_Init(0, LCD_ORIENTATION_LANDSCAPE);
    
48.   UTIL_LCD_SetFuncDriver(&LCD_Driver);
    , G4 V# c/ d4 L) I! R
49.   UTIL_LCD_Clear(UTIL_LCD_COLOR_RED);
    ' X4 V* L! g" E6 @
50.   UTIL_LCD_SetTextColor(UTIL_LCD_COLOR_RED);
    
51.   UTIL_LCD_SetBackColor(UTIL_LCD_COLOR_WHITE);
    , @# Z6 _" p1 R. T6 w, J4 b
52.   UTIL_LCD_SetFont(&Font24);
      s$ A- F- p9 N
53.   
    ( O1 ^1 h  ]5 {% d* y# a
54.   while (1)
    
55.   {
    
56.     switch (i)
    
57.     {
    ! v3 D' {1 K) @, X# Z+ Q
58.       case 0:
    6 G! W: V- |/ n0 y8 K$ `9 @
59.       {
    
60.           UTIL_LCD_Clear(UTIL_LCD_COLOR_WHITE);
    
61.           break;
    & @' R. m" D' y3 I$ R
62.       }
    9 R- Z( O, S7 a4 g6 G0 X6 Y
63.       case 1:
    : h4 f1 s2 v9 k2 K
64.       {
    
65.           UTIL_LCD_Clear(UTIL_LCD_COLOR_RED);
    . e0 E/ k1 a2 u+ s7 \! j% Q6 e
66.           break;
    4 t) e9 e. e; ]% u
67.       }
    
68.       case 2:
    
69.       {
    7 ^+ n6 j( _, D4 s" }0 O" ]  L
70.           UTIL_LCD_Clear(UTIL_LCD_COLOR_GREEN);
    
71.           break;
    , ^) u. ]4 e! L7 @/ U+ ~) m
72.       }
    
73.       case 3:
    
74.       {
    ) s5 n0 q3 p9 s
75.           UTIL_LCD_Clear(UTIL_LCD_COLOR_BLUE);
    " E4 l$ x! k; O3 a. v
76.           break;
    / m/ B) [9 G+ n; q& ^
77.       }
    2 @, B4 Z& ]1 Y/ [! ^
78.       case 4:
    
79.       {
    
80.           UTIL_LCD_Clear(UTIL_LCD_COLOR_MAGENTA);
    
81.           break;
      }! `1 j, n9 U2 G
82.       }
    
83.       case 5:
    
84.       {
    
85.           UTIL_LCD_Clear(UTIL_LCD_COLOR_YELLOW);
    
86.           break;
    . }" [( t7 p: r8 K: @/ ?
87.       }
    
88.     }
    
89.    
    ) @' F2 z8 s/ p! c8 _2 g1 J! S
90.     if(i==6)
    
91.     {
    
92.       i=0;
    " A! a; R5 S  F  w/ D; @1 ~  B
93.     }
    
94.     else
    
95.     {
    # K, v. o: F! ~3 `6 {
96.       i++;
    % v7 ~7 G* R2 S0 t
97.     }
    
98.     UTIL_LCD_DisplayStringAt(10, 50, (uint8_t *)"STM32N6570 BOARD LCD TEST!", LEFT_MODE);
    6 G! c3 l- k) r. h8 J& v& b; M
99.     BSP_LED_On(LED1);
    
100.     HAL_Delay(500);
     
101.     BSP_LED_Off(LED1);
     9 \1 u' {  z5 U3 K) _: {
102.     HAL_Delay(500);
     
103.   }
     2 m$ K( D4 V3 n' L( H( W4 v
104. }

复制代码

* m% q  y; E' @8 o; V7 [  [
0 o! {& Y; V( \2 G1 b8 [8 R$ x
6 [: ?% Q! d" @7 f  b: `, W) b三、结果


0 W# I' K# f3 }: p# `) c下载程序到开发板，运行开发板屏幕显示如下:
! ]) O; Z5 o  p

+ y' }# G7 a; M/ k/ [+ \


& Q9 K; Z, G. U3 h# g