diff --git a/Core/Inc/stm32f429i_discovery_lcd.h b/Core/Inc/stm32f429i_discovery_lcd.h new file mode 100644 index 0000000..1869696 --- /dev/null +++ b/Core/Inc/stm32f429i_discovery_lcd.h @@ -0,0 +1,246 @@ +/** + ****************************************************************************** + * @file stm32f429i_discovery_lcd.h + * @author MCD Application Team + * @brief This file contains all the functions prototypes for the + * stm32f429i_discovery_lcd.c driver. + ****************************************************************************** + * @attention + * + * Copyright (c) 2017 STMicroelectronics. + * All rights reserved. + * + * This software is licensed under terms that can be found in the LICENSE file + * in the root directory of this software component. + * If no LICENSE file comes with this software, it is provided AS-IS. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __STM32F429I_DISCOVERY_LCD_H +#define __STM32F429I_DISCOVERY_LCD_H + +#ifdef __cplusplus +extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f429i_discovery.h" +/* Include SDRAM Driver */ +#include "stm32f429i_discovery_sdram.h" +#include "../../../Utilities/Fonts/fonts.h" +/* Include LCD component driver */ +#include "../Components/ili9341/ili9341.h" + +/** @addtogroup BSP + * @{ + */ + +/** @addtogroup STM32F429I_DISCOVERY + * @{ + */ + +/** @addtogroup STM32F429I_DISCOVERY_LCD + * @{ + */ + +/** @defgroup STM32F429I_DISCOVERY_LCD_Exported_Types STM32F429I DISCOVERY LCD Exported Types + * @{ + */ +typedef enum +{ + LCD_OK = 0, + LCD_ERROR = 1, + LCD_TIMEOUT = 2 +} LCD_StatusTypeDef; + +typedef struct +{ + uint32_t TextColor; + uint32_t BackColor; + sFONT *pFont; +} LCD_DrawPropTypeDef; + +typedef struct +{ + int16_t X; + int16_t Y; +} Point, * pPoint; + +/** + * @brief Line mode structures definition + */ +typedef enum +{ + CENTER_MODE = 0x01, /* center mode */ + RIGHT_MODE = 0x02, /* right mode */ + LEFT_MODE = 0x03, /* left mode */ +} Text_AlignModeTypdef; +/** + * @} + */ + +/** @defgroup STM32F429I_DISCOVERY_LCD_Exported_Constants STM32F429I DISCOVERY LCD Exported Constants + * @{ + */ +#define LCD_LayerCfgTypeDef LTDC_LayerCfgTypeDef + +/** + * @brief LCD status structure definition + */ +#define MAX_LAYER_NUMBER 2 +#define LCD_FRAME_BUFFER ((uint32_t)0xD0000000) +#define BUFFER_OFFSET ((uint32_t)0x50000) + +/** + * @brief LCD color + */ +#define LCD_COLOR_BLUE 0xFF0000FF +#define LCD_COLOR_GREEN 0xFF00FF00 +#define LCD_COLOR_RED 0xFFFF0000 +#define LCD_COLOR_CYAN 0xFF00FFFF +#define LCD_COLOR_MAGENTA 0xFFFF00FF +#define LCD_COLOR_YELLOW 0xFFFFFF00 +#define LCD_COLOR_LIGHTBLUE 0xFF8080FF +#define LCD_COLOR_LIGHTGREEN 0xFF80FF80 +#define LCD_COLOR_LIGHTRED 0xFFFF8080 +#define LCD_COLOR_LIGHTCYAN 0xFF80FFFF +#define LCD_COLOR_LIGHTMAGENTA 0xFFFF80FF +#define LCD_COLOR_LIGHTYELLOW 0xFFFFFF80 +#define LCD_COLOR_DARKBLUE 0xFF000080 +#define LCD_COLOR_DARKGREEN 0xFF008000 +#define LCD_COLOR_DARKRED 0xFF800000 +#define LCD_COLOR_DARKCYAN 0xFF008080 +#define LCD_COLOR_DARKMAGENTA 0xFF800080 +#define LCD_COLOR_DARKYELLOW 0xFF808000 +#define LCD_COLOR_WHITE 0xFFFFFFFF +#define LCD_COLOR_LIGHTGRAY 0xFFD3D3D3 +#define LCD_COLOR_GRAY 0xFF808080 +#define LCD_COLOR_DARKGRAY 0xFF404040 +#define LCD_COLOR_BLACK 0xFF000000 +#define LCD_COLOR_BROWN 0xFFA52A2A +#define LCD_COLOR_ORANGE 0xFFFFA500 +#define LCD_COLOR_TRANSPARENT 0xFF000000 +/** + * @brief LCD default font + */ +#define LCD_DEFAULT_FONT Font24 + +/** + * @brief LCD Reload Types + */ +#define LCD_RELOAD_IMMEDIATE ((uint32_t)LTDC_SRCR_IMR) +#define LCD_RELOAD_VERTICAL_BLANKING ((uint32_t)LTDC_SRCR_VBR) + +/** + * @brief LCD Layer + */ +#define LCD_BACKGROUND_LAYER 0x0000 +#define LCD_FOREGROUND_LAYER 0x0001 + +/** + * @} + */ + +/** @defgroup STM32F429I_DISCOVERY_LCD_Exported_Macros STM32F429I DISCOVERY LCD Exported Macros + * @{ + */ +/** + * @brief LCD Pixel format + */ +#define LCD_PIXEL_FORMAT_ARGB8888 LTDC_PIXEL_FORMAT_ARGB8888 +#define LCD_PIXEL_FORMAT_RGB888 LTDC_PIXEL_FORMAT_RGB888 +#define LCD_PIXEL_FORMAT_RGB565 LTDC_PIXEL_FORMAT_RGB565 +#define LCD_PIXEL_FORMAT_ARGB1555 LTDC_PIXEL_FORMAT_ARGB1555 +#define LCD_PIXEL_FORMAT_ARGB4444 LTDC_PIXEL_FORMAT_ARGB4444 +#define LCD_PIXEL_FORMAT_L8 LTDC_PIXEL_FORMAT_L8 +#define LCD_PIXEL_FORMAT_AL44 LTDC_PIXEL_FORMAT_AL44 +#define LCD_PIXEL_FORMAT_AL88 LTDC_PIXEL_FORMAT_AL88 +/** + * @} + */ + +/** @defgroup STM32F429I_DISCOVERY_LCD_Exported_Functions STM32F429I DISCOVERY LCD Exported Functions + * @{ + */ +uint8_t BSP_LCD_Init(void); +uint32_t BSP_LCD_GetXSize(void); +uint32_t BSP_LCD_GetYSize(void); + +/* functions using the LTDC controller */ +void BSP_LCD_LayerDefaultInit(uint16_t LayerIndex, uint32_t FrameBuffer); +void BSP_LCD_SetTransparency(uint32_t LayerIndex, uint8_t Transparency); +void BSP_LCD_SetTransparency_NoReload(uint32_t LayerIndex, uint8_t Transparency); +void BSP_LCD_SetLayerAddress(uint32_t LayerIndex, uint32_t Address); +void BSP_LCD_SetLayerAddress_NoReload(uint32_t LayerIndex, uint32_t Address); +void BSP_LCD_SetColorKeying(uint32_t LayerIndex, uint32_t RGBValue); +void BSP_LCD_SetColorKeying_NoReload(uint32_t LayerIndex, uint32_t RGBValue); +void BSP_LCD_ResetColorKeying(uint32_t LayerIndex); +void BSP_LCD_ResetColorKeying_NoReload(uint32_t LayerIndex); +void BSP_LCD_SetLayerWindow(uint16_t LayerIndex, uint16_t Xpos, uint16_t Ypos, uint16_t Width, uint16_t Height); +void BSP_LCD_SetLayerWindow_NoReload(uint16_t LayerIndex, uint16_t Xpos, uint16_t Ypos, uint16_t Width, + uint16_t Height); +void BSP_LCD_SelectLayer(uint32_t LayerIndex); +void BSP_LCD_SetLayerVisible(uint32_t LayerIndex, FunctionalState state); +void BSP_LCD_SetLayerVisible_NoReload(uint32_t LayerIndex, FunctionalState State); +void BSP_LCD_Relaod(uint32_t ReloadType); + +void BSP_LCD_SetTextColor(uint32_t Color); +void BSP_LCD_SetBackColor(uint32_t Color); +uint32_t BSP_LCD_GetTextColor(void); +uint32_t BSP_LCD_GetBackColor(void); +void BSP_LCD_SetFont(sFONT *pFonts); +sFONT *BSP_LCD_GetFont(void); + +uint32_t BSP_LCD_ReadPixel(uint16_t Xpos, uint16_t Ypos); +void BSP_LCD_DrawPixel(uint16_t Xpos, uint16_t Ypos, uint32_t pixel); +void BSP_LCD_Clear(uint32_t Color); +void BSP_LCD_ClearStringLine(uint32_t Line); +void BSP_LCD_DisplayStringAtLine(uint16_t Line, uint8_t *ptr); +void BSP_LCD_DisplayStringAt(uint16_t X, uint16_t Y, uint8_t *pText, Text_AlignModeTypdef mode); +void BSP_LCD_DisplayChar(uint16_t Xpos, uint16_t Ypos, uint8_t Ascii); + +void BSP_LCD_DrawHLine(uint16_t Xpos, uint16_t Ypos, uint16_t Length); +void BSP_LCD_DrawVLine(uint16_t Xpos, uint16_t Ypos, uint16_t Length); +void BSP_LCD_DrawLine(uint16_t X1, uint16_t Y1, uint16_t X2, uint16_t Y2); +void BSP_LCD_DrawRect(uint16_t Xpos, uint16_t Ypos, uint16_t Width, uint16_t Height); +void BSP_LCD_DrawCircle(uint16_t Xpos, uint16_t Ypos, uint16_t Radius); +void BSP_LCD_DrawPolygon(pPoint Points, uint16_t PointCount); +void BSP_LCD_DrawEllipse(int Xpos, int Ypos, int XRadius, int YRadius); +void BSP_LCD_DrawBitmap(uint32_t X, uint32_t Y, uint8_t *pBmp); + +void BSP_LCD_FillRect(uint16_t Xpos, uint16_t Ypos, uint16_t Width, uint16_t Height); +void BSP_LCD_FillCircle(uint16_t Xpos, uint16_t Ypos, uint16_t Radius); +void BSP_LCD_FillTriangle(uint16_t X1, uint16_t X2, uint16_t X3, uint16_t Y1, uint16_t Y2, uint16_t Y3); +void BSP_LCD_FillPolygon(pPoint Points, uint16_t PointCount); +void BSP_LCD_FillEllipse(int Xpos, int Ypos, int XRadius, int YRadius); + +void BSP_LCD_DisplayOff(void); +void BSP_LCD_DisplayOn(void); + +/* This function can be modified in case the current settings need to be changed + for specific application needs */ +void BSP_LCD_MspInit(void); + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F429I_DISCOVERY_LCD_H */ diff --git a/Core/Src/stm32f429i_discovery_lcd.c b/Core/Src/stm32f429i_discovery_lcd.c new file mode 100644 index 0000000..efc2210 --- /dev/null +++ b/Core/Src/stm32f429i_discovery_lcd.c @@ -0,0 +1,1440 @@ +/** + ****************************************************************************** + * @file stm32f429i_discovery_lcd.c + * @author MCD Application Team + * @brief This file includes the LCD driver for ILI9341 Liquid Crystal + * Display Modules of STM32F429I-Discovery kit (MB1075). + ****************************************************************************** + * @attention + * + * Copyright (c) 2017 STMicroelectronics. + * All rights reserved. + * + * This software is licensed under terms that can be found in the LICENSE file + * in the root directory of this software component. + * If no LICENSE file comes with this software, it is provided AS-IS. + * + ****************************************************************************** + */ + +/* File Info : ----------------------------------------------------------------- + User NOTES +1. How To use this driver: +-------------------------- + - This driver is used to drive directly an LCD TFT using LTDC controller. + - This driver select dynamically the mounted LCD, ILI9341 240x320 LCD mounted + on MB1075B discovery board, and use the adequate timing and setting for + the specified LCD using device ID of the ILI9341 mounted on MB1075B discovery board + +2. Driver description: +--------------------- + + Initialization steps : + o Initialize the LCD using the LCD_Init() function. + o Apply the Layer configuration using LCD_LayerDefaultInit() function + o Select the LCD layer to be used using LCD_SelectLayer() function. + o Enable the LCD display using LCD_DisplayOn() function. + + + Options + o Configure and enable the color keying functionality using LCD_SetColorKeying() + function. + o Modify in the fly the transparency and/or the frame buffer address + using the following functions : + - LCD_SetTransparency() + - LCD_SetLayerAddress() + + + Display on LCD + o Clear the hole LCD using LCD_Clear() function or only one specified string + line using LCD_ClearStringLine() function. + o Display a character on the specified line and column using LCD_DisplayChar() + function or a complete string line using LCD_DisplayStringAtLine() function. + o Display a string line on the specified position (x,y in pixel) and align mode + using LCD_DisplayStringAtLine() function. + o Draw and fill a basic shapes (dot, line, rectangle, circle, ellipse, .. bitmap) + on LCD using the available set of functions + +------------------------------------------------------------------------------*/ + +/* Includes ------------------------------------------------------------------*/ +#include "stm32f429i_discovery_lcd.h" +#include "../../../Utilities/Fonts/fonts.h" +#include "../../../Utilities/Fonts/font24.c" +#include "../../../Utilities/Fonts/font20.c" +#include "../../../Utilities/Fonts/font16.c" +#include "../../../Utilities/Fonts/font12.c" +#include "../../../Utilities/Fonts/font8.c" + +/** @addtogroup BSP + * @{ + */ + +/** @addtogroup STM32F429I_DISCOVERY + * @{ + */ + +/** @defgroup STM32F429I_DISCOVERY_LCD STM32F429I DISCOVERY LCD + * @brief This file includes the LCD driver for (ILI9341) + * @{ + */ + +/** @defgroup STM32F429I_DISCOVERY_LCD_Private_TypesDefinitions STM32F429I DISCOVERY LCD Private TypesDefinitions + * @{ + */ +/** + * @} + */ + +/** @defgroup STM32F429I_DISCOVERY_LCD_Private_Defines STM32F429I DISCOVERY LCD Private Defines + * @{ + */ +#define POLY_X(Z) ((int32_t)((Points + Z)->X)) +#define POLY_Y(Z) ((int32_t)((Points + Z)->Y)) +/** + * @} + */ + +/** @defgroup STM32F429I_DISCOVERY_LCD_Private_Macros STM32F429I DISCOVERY LCD Private Macros + * @{ + */ +#define ABS(X) ((X) > 0 ? (X) : -(X)) +/** + * @} + */ + +/** @defgroup STM32F429I_DISCOVERY_LCD_Private_Variables STM32F429I DISCOVERY LCD Private Variables + * @{ + */ +LTDC_HandleTypeDef LtdcHandler; +static DMA2D_HandleTypeDef Dma2dHandler; +static RCC_PeriphCLKInitTypeDef PeriphClkInitStruct; + +/* Default LCD configuration with LCD Layer 1 */ +static uint32_t ActiveLayer = 0; +static LCD_DrawPropTypeDef DrawProp[MAX_LAYER_NUMBER]; +LCD_DrvTypeDef *LcdDrv; +/** + * @} + */ + +/** @defgroup STM32F429I_DISCOVERY_LCD_Private_FunctionPrototypes STM32F429I DISCOVERY LCD Private FunctionPrototypes + * @{ + */ +static void DrawChar(uint16_t Xpos, uint16_t Ypos, const uint8_t *c); +static void FillBuffer(uint32_t LayerIndex, void *pDst, uint32_t xSize, uint32_t ySize, uint32_t OffLine, + uint32_t ColorIndex); +static void ConvertLineToARGB8888(void *pSrc, void *pDst, uint32_t xSize, uint32_t ColorMode); +/** + * @} + */ + +/** @defgroup STM32F429I_DISCOVERY_LCD_Private_Functions STM32F429I DISCOVERY LCD Private Functions + * @{ + */ + +/** + * @brief Initializes the LCD. + * @retval LCD state + */ +uint8_t BSP_LCD_Init(void) +{ + /* On STM32F429I-DISCO, it is not possible to read ILI9341 ID because */ + /* PIN EXTC is not connected to VDD and then LCD_READ_ID4 is not accessible. */ + /* In this case, ReadID function is bypassed.*/ + /*if(ili9341_drv.ReadID() == ILI9341_ID)*/ + + /* LTDC Configuration ----------------------------------------------------*/ + LtdcHandler.Instance = LTDC; + + /* Timing configuration (Typical configuration from ILI9341 datasheet) + HSYNC=10 (9+1) + HBP=20 (29-10+1) + ActiveW=240 (269-20-10+1) + HFP=10 (279-240-20-10+1) + + VSYNC=2 (1+1) + VBP=2 (3-2+1) + ActiveH=320 (323-2-2+1) + VFP=4 (327-320-2-2+1) + */ + + /* Configure horizontal synchronization width */ + LtdcHandler.Init.HorizontalSync = ILI9341_HSYNC; + /* Configure vertical synchronization height */ + LtdcHandler.Init.VerticalSync = ILI9341_VSYNC; + /* Configure accumulated horizontal back porch */ + LtdcHandler.Init.AccumulatedHBP = ILI9341_HBP; + /* Configure accumulated vertical back porch */ + LtdcHandler.Init.AccumulatedVBP = ILI9341_VBP; + /* Configure accumulated active width */ + LtdcHandler.Init.AccumulatedActiveW = 269; + /* Configure accumulated active height */ + LtdcHandler.Init.AccumulatedActiveH = 323; + /* Configure total width */ + LtdcHandler.Init.TotalWidth = 279; + /* Configure total height */ + LtdcHandler.Init.TotalHeigh = 327; + + /* Configure R,G,B component values for LCD background color */ + LtdcHandler.Init.Backcolor.Red = 0; + LtdcHandler.Init.Backcolor.Blue = 0; + LtdcHandler.Init.Backcolor.Green = 0; + + /* LCD clock configuration */ + /* PLLSAI_VCO Input = HSE_VALUE/PLL_M = 1 Mhz */ + /* PLLSAI_VCO Output = PLLSAI_VCO Input * PLLSAIN = 192 Mhz */ + /* PLLLCDCLK = PLLSAI_VCO Output/PLLSAIR = 192/4 = 48 Mhz */ + /* LTDC clock frequency = PLLLCDCLK / LTDC_PLLSAI_DIVR_8 = 48/4 = 6Mhz */ + PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LTDC; + PeriphClkInitStruct.PLLSAI.PLLSAIN = 192; + PeriphClkInitStruct.PLLSAI.PLLSAIR = 4; + PeriphClkInitStruct.PLLSAIDivR = RCC_PLLSAIDIVR_8; + HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct); + + /* Polarity */ + LtdcHandler.Init.HSPolarity = LTDC_HSPOLARITY_AL; + LtdcHandler.Init.VSPolarity = LTDC_VSPOLARITY_AL; + LtdcHandler.Init.DEPolarity = LTDC_DEPOLARITY_AL; + LtdcHandler.Init.PCPolarity = LTDC_PCPOLARITY_IPC; + + BSP_LCD_MspInit(); + HAL_LTDC_Init(&LtdcHandler); + + /* Select the device */ + LcdDrv = &ili9341_drv; + + /* LCD Init */ + LcdDrv->Init(); + + /* Initialize the SDRAM */ + BSP_SDRAM_Init(); + + /* Initialize the font */ + BSP_LCD_SetFont(&LCD_DEFAULT_FONT); + + return LCD_OK; +} + +/** + * @brief Gets the LCD X size. + * @retval The used LCD X size + */ +uint32_t BSP_LCD_GetXSize(void) +{ + return LcdDrv->GetLcdPixelWidth(); +} + +/** + * @brief Gets the LCD Y size. + * @retval The used LCD Y size + */ +uint32_t BSP_LCD_GetYSize(void) +{ + return LcdDrv->GetLcdPixelHeight(); +} + +/** + * @brief Initializes the LCD layers. + * @param LayerIndex: the layer foreground or background. + * @param FB_Address: the layer frame buffer. + */ +void BSP_LCD_LayerDefaultInit(uint16_t LayerIndex, uint32_t FB_Address) +{ + LCD_LayerCfgTypeDef Layercfg; + + /* Layer Init */ + Layercfg.WindowX0 = 0; + Layercfg.WindowX1 = BSP_LCD_GetXSize(); + Layercfg.WindowY0 = 0; + Layercfg.WindowY1 = BSP_LCD_GetYSize(); + Layercfg.PixelFormat = LTDC_PIXEL_FORMAT_ARGB8888; + Layercfg.FBStartAdress = FB_Address; + Layercfg.Alpha = 255; + Layercfg.Alpha0 = 0; + Layercfg.Backcolor.Blue = 0; + Layercfg.Backcolor.Green = 0; + Layercfg.Backcolor.Red = 0; + Layercfg.BlendingFactor1 = LTDC_BLENDING_FACTOR1_PAxCA; + Layercfg.BlendingFactor2 = LTDC_BLENDING_FACTOR2_PAxCA; + Layercfg.ImageWidth = BSP_LCD_GetXSize(); + Layercfg.ImageHeight = BSP_LCD_GetYSize(); + + HAL_LTDC_ConfigLayer(&LtdcHandler, &Layercfg, LayerIndex); + + DrawProp[LayerIndex].BackColor = LCD_COLOR_WHITE; + DrawProp[LayerIndex].pFont = &Font24; + DrawProp[LayerIndex].TextColor = LCD_COLOR_BLACK; + + /* Dithering activation */ + HAL_LTDC_EnableDither(&LtdcHandler); +} + +/** + * @brief Selects the LCD Layer. + * @param LayerIndex: the Layer foreground or background. + */ +void BSP_LCD_SelectLayer(uint32_t LayerIndex) +{ + ActiveLayer = LayerIndex; +} + +/** + * @brief Sets a LCD Layer visible. + * @param LayerIndex: the visible Layer. + * @param state: new state of the specified layer. + * This parameter can be: ENABLE or DISABLE. + */ +void BSP_LCD_SetLayerVisible(uint32_t LayerIndex, FunctionalState state) +{ + if (state == ENABLE) + { + __HAL_LTDC_LAYER_ENABLE(&LtdcHandler, LayerIndex); + } + else + { + __HAL_LTDC_LAYER_DISABLE(&LtdcHandler, LayerIndex); + } + __HAL_LTDC_RELOAD_CONFIG(&LtdcHandler); +} + +/** + * @brief Sets an LCD Layer visible without reloading. + * @param LayerIndex: Visible Layer + * @param State: New state of the specified layer + * This parameter can be one of the following values: + * @arg ENABLE + * @arg DISABLE + * @retval None + */ +void BSP_LCD_SetLayerVisible_NoReload(uint32_t LayerIndex, FunctionalState State) +{ + if (State == ENABLE) + { + __HAL_LTDC_LAYER_ENABLE(&LtdcHandler, LayerIndex); + } + else + { + __HAL_LTDC_LAYER_DISABLE(&LtdcHandler, LayerIndex); + } + /* Do not Sets the Reload */ +} + +/** + * @brief Configures the Transparency. + * @param LayerIndex: the Layer foreground or background. + * @param Transparency: the Transparency, + * This parameter must range from 0x00 to 0xFF. + */ +void BSP_LCD_SetTransparency(uint32_t LayerIndex, uint8_t Transparency) +{ + HAL_LTDC_SetAlpha(&LtdcHandler, Transparency, LayerIndex); +} + +/** + * @brief Configures the transparency without reloading. + * @param LayerIndex: Layer foreground or background. + * @param Transparency: Transparency + * This parameter must be a number between Min_Data = 0x00 and Max_Data = 0xFF + * @retval None + */ +void BSP_LCD_SetTransparency_NoReload(uint32_t LayerIndex, uint8_t Transparency) +{ + HAL_LTDC_SetAlpha_NoReload(&LtdcHandler, Transparency, LayerIndex); +} + +/** + * @brief Sets a LCD layer frame buffer address. + * @param LayerIndex: specifies the Layer foreground or background + * @param Address: new LCD frame buffer value + */ +void BSP_LCD_SetLayerAddress(uint32_t LayerIndex, uint32_t Address) +{ + HAL_LTDC_SetAddress(&LtdcHandler, Address, LayerIndex); +} + +/** + * @brief Sets an LCD layer frame buffer address without reloading. + * @param LayerIndex: Layer foreground or background + * @param Address: New LCD frame buffer value + * @retval None + */ +void BSP_LCD_SetLayerAddress_NoReload(uint32_t LayerIndex, uint32_t Address) +{ + HAL_LTDC_SetAddress_NoReload(&LtdcHandler, Address, LayerIndex); +} + +/** + * @brief Sets the Display window. + * @param LayerIndex: layer index + * @param Xpos: LCD X position + * @param Ypos: LCD Y position + * @param Width: LCD window width + * @param Height: LCD window height + */ +void BSP_LCD_SetLayerWindow(uint16_t LayerIndex, uint16_t Xpos, uint16_t Ypos, uint16_t Width, uint16_t Height) +{ + /* reconfigure the layer size */ + HAL_LTDC_SetWindowSize(&LtdcHandler, Width, Height, LayerIndex); + + /* reconfigure the layer position */ + HAL_LTDC_SetWindowPosition(&LtdcHandler, Xpos, Ypos, LayerIndex); +} + +/** + * @brief Sets display window without reloading. + * @param LayerIndex: Layer index + * @param Xpos: LCD X position + * @param Ypos: LCD Y position + * @param Width: LCD window width + * @param Height: LCD window height + * @retval None + */ +void BSP_LCD_SetLayerWindow_NoReload(uint16_t LayerIndex, uint16_t Xpos, uint16_t Ypos, uint16_t Width, uint16_t Height) +{ + /* Reconfigure the layer size */ + HAL_LTDC_SetWindowSize_NoReload(&LtdcHandler, Width, Height, LayerIndex); + + /* Reconfigure the layer position */ + HAL_LTDC_SetWindowPosition_NoReload(&LtdcHandler, Xpos, Ypos, LayerIndex); +} + +/** + * @brief Configures and sets the color Keying. + * @param LayerIndex: the Layer foreground or background + * @param RGBValue: the Color reference + */ +void BSP_LCD_SetColorKeying(uint32_t LayerIndex, uint32_t RGBValue) +{ + /* Configure and Enable the color Keying for LCD Layer */ + HAL_LTDC_ConfigColorKeying(&LtdcHandler, RGBValue, LayerIndex); + HAL_LTDC_EnableColorKeying(&LtdcHandler, LayerIndex); +} + +/** + * @brief Configures and sets the color keying without reloading. + * @param LayerIndex: Layer foreground or background + * @param RGBValue: Color reference + * @retval None + */ +void BSP_LCD_SetColorKeying_NoReload(uint32_t LayerIndex, uint32_t RGBValue) +{ + /* Configure and Enable the color Keying for LCD Layer */ + HAL_LTDC_ConfigColorKeying_NoReload(&LtdcHandler, RGBValue, LayerIndex); + HAL_LTDC_EnableColorKeying_NoReload(&LtdcHandler, LayerIndex); +} + +/** + * @brief Disables the color Keying. + * @param LayerIndex: the Layer foreground or background + */ +void BSP_LCD_ResetColorKeying(uint32_t LayerIndex) +{ + /* Disable the color Keying for LCD Layer */ + HAL_LTDC_DisableColorKeying(&LtdcHandler, LayerIndex); +} + +/** + * @brief Disables the color keying without reloading. + * @param LayerIndex: Layer foreground or background + * @retval None + */ +void BSP_LCD_ResetColorKeying_NoReload(uint32_t LayerIndex) +{ + /* Disable the color Keying for LCD Layer */ + HAL_LTDC_DisableColorKeying_NoReload(&LtdcHandler, LayerIndex); +} + +/** + * @brief Disables the color keying without reloading. + * @param ReloadType: can be one of the following values + * - LCD_RELOAD_IMMEDIATE + * - LCD_RELOAD_VERTICAL_BLANKING + * @retval None + */ +void BSP_LCD_Relaod(uint32_t ReloadType) +{ + HAL_LTDC_Relaod(&LtdcHandler, ReloadType); +} + +/** + * @brief Gets the LCD Text color. + * @retval Text color + */ +uint32_t BSP_LCD_GetTextColor(void) +{ + return DrawProp[ActiveLayer].TextColor; +} + +/** + * @brief Gets the LCD Background color. + * @retval Background color + */ +uint32_t BSP_LCD_GetBackColor(void) +{ + return DrawProp[ActiveLayer].BackColor; +} + +/** + * @brief Sets the Text color. + * @param Color: the Text color code ARGB(8-8-8-8) + */ +void BSP_LCD_SetTextColor(uint32_t Color) +{ + DrawProp[ActiveLayer].TextColor = Color; +} + +/** + * @brief Sets the Background color. + * @param Color: the layer Background color code ARGB(8-8-8-8) + */ +void BSP_LCD_SetBackColor(uint32_t Color) +{ + DrawProp[ActiveLayer].BackColor = Color; +} + +/** + * @brief Sets the Text Font. + * @param pFonts: the layer font to be used + */ +void BSP_LCD_SetFont(sFONT *pFonts) +{ + DrawProp[ActiveLayer].pFont = pFonts; +} + +/** + * @brief Gets the Text Font. + * @retval Layer font + */ +sFONT *BSP_LCD_GetFont(void) +{ + return DrawProp[ActiveLayer].pFont; +} + +/** + * @brief Reads Pixel. + * @param Xpos: the X position + * @param Ypos: the Y position + * @retval RGB pixel color + */ +uint32_t BSP_LCD_ReadPixel(uint16_t Xpos, uint16_t Ypos) +{ + uint32_t ret = 0; + + if (LtdcHandler.LayerCfg[ActiveLayer].PixelFormat == LTDC_PIXEL_FORMAT_ARGB8888) + { + /* Read data value from SDRAM memory */ + ret = *(__IO uint32_t *)(LtdcHandler.LayerCfg[ActiveLayer].FBStartAdress + (4 * (Ypos * BSP_LCD_GetXSize() + Xpos))); + } + else if (LtdcHandler.LayerCfg[ActiveLayer].PixelFormat == LTDC_PIXEL_FORMAT_RGB888) + { + /* Read data value from SDRAM memory */ + ret = (*(__IO uint32_t *)(LtdcHandler.LayerCfg[ActiveLayer].FBStartAdress + (4 * (Ypos * BSP_LCD_GetXSize() + Xpos))) & 0x00FFFFFF); + } + else if ((LtdcHandler.LayerCfg[ActiveLayer].PixelFormat == LTDC_PIXEL_FORMAT_RGB565) || \ + (LtdcHandler.LayerCfg[ActiveLayer].PixelFormat == LTDC_PIXEL_FORMAT_ARGB4444) || \ + (LtdcHandler.LayerCfg[ActiveLayer].PixelFormat == LTDC_PIXEL_FORMAT_AL88)) + { + /* Read data value from SDRAM memory */ + ret = *(__IO uint16_t *)(LtdcHandler.LayerCfg[ActiveLayer].FBStartAdress + (2 * (Ypos * BSP_LCD_GetXSize() + Xpos))); + } + else + { + /* Read data value from SDRAM memory */ + ret = *(__IO uint8_t *)(LtdcHandler.LayerCfg[ActiveLayer].FBStartAdress + (2 * (Ypos * BSP_LCD_GetXSize() + Xpos))); + } + + return ret; +} + +/** + * @brief Clears the hole LCD. + * @param Color: the color of the background + */ +void BSP_LCD_Clear(uint32_t Color) +{ + /* Clear the LCD */ + FillBuffer(ActiveLayer, (uint32_t *)(LtdcHandler.LayerCfg[ActiveLayer].FBStartAdress), BSP_LCD_GetXSize(), + BSP_LCD_GetYSize(), 0, Color); +} + +/** + * @brief Clears the selected line. + * @param Line: the line to be cleared + */ +void BSP_LCD_ClearStringLine(uint32_t Line) +{ + uint32_t colorbackup = DrawProp[ActiveLayer].TextColor; + DrawProp[ActiveLayer].TextColor = DrawProp[ActiveLayer].BackColor; + + /* Draw rectangle with background color */ + BSP_LCD_FillRect(0, (Line * DrawProp[ActiveLayer].pFont->Height), BSP_LCD_GetXSize(), + DrawProp[ActiveLayer].pFont->Height); + + DrawProp[ActiveLayer].TextColor = colorbackup; + BSP_LCD_SetTextColor(DrawProp[ActiveLayer].TextColor); +} + +/** + * @brief Displays one character. + * @param Xpos: start column address + * @param Ypos: the Line where to display the character shape + * @param Ascii: character ascii code, must be between 0x20 and 0x7E + */ +void BSP_LCD_DisplayChar(uint16_t Xpos, uint16_t Ypos, uint8_t Ascii) +{ + DrawChar(Xpos, Ypos, &DrawProp[ActiveLayer].pFont->table[(Ascii - ' ') *\ + DrawProp[ActiveLayer].pFont->Height * ((DrawProp[ActiveLayer].pFont->Width + 7) / 8)]); +} + +/** + * @brief Displays a maximum of 60 char on the LCD. + * @param X: pointer to x position (in pixel) + * @param Y: pointer to y position (in pixel) + * @param pText: pointer to string to display on LCD + * @param mode: The display mode + * This parameter can be one of the following values: + * @arg CENTER_MODE + * @arg RIGHT_MODE + * @arg LEFT_MODE + */ +void BSP_LCD_DisplayStringAt(uint16_t X, uint16_t Y, uint8_t *pText, Text_AlignModeTypdef mode) +{ + uint16_t refcolumn = 1, i = 0; + uint32_t size = 0, xsize = 0; + uint8_t *ptr = pText; + + /* Get the text size */ + while (*ptr++) { size ++ ; } + + /* Characters number per line */ + xsize = (BSP_LCD_GetXSize() / DrawProp[ActiveLayer].pFont->Width); + + switch (mode) + { + case CENTER_MODE: + { + refcolumn = X + ((xsize - size) * DrawProp[ActiveLayer].pFont->Width) / 2; + break; + } + case LEFT_MODE: + { + refcolumn = X; + break; + } + case RIGHT_MODE: + { + refcolumn = X + ((xsize - size) * DrawProp[ActiveLayer].pFont->Width); + break; + } + default: + { + refcolumn = X; + break; + } + } + + /* Send the string character by character on LCD */ + while ((*pText != 0) & (((BSP_LCD_GetXSize() - (i * DrawProp[ActiveLayer].pFont->Width)) & 0xFFFF) >= + DrawProp[ActiveLayer].pFont->Width)) + { + /* Display one character on LCD */ + BSP_LCD_DisplayChar(refcolumn, Y, *pText); + /* Decrement the column position by 16 */ + refcolumn += DrawProp[ActiveLayer].pFont->Width; + /* Point on the next character */ + pText++; + i++; + } +} + +/** + * @brief Displays a maximum of 20 char on the LCD. + * @param Line: the Line where to display the character shape + * @param ptr: pointer to string to display on LCD + */ +void BSP_LCD_DisplayStringAtLine(uint16_t Line, uint8_t *ptr) +{ + BSP_LCD_DisplayStringAt(0, LINE(Line), ptr, LEFT_MODE); +} + +/** + * @brief Displays an horizontal line. + * @param Xpos: the X position + * @param Ypos: the Y position + * @param Length: line length + */ +void BSP_LCD_DrawHLine(uint16_t Xpos, uint16_t Ypos, uint16_t Length) +{ + uint32_t xaddress = 0; + + /* Get the line address */ + xaddress = (LtdcHandler.LayerCfg[ActiveLayer].FBStartAdress) + 4 * (BSP_LCD_GetXSize() * Ypos + Xpos); + + /* Write line */ + FillBuffer(ActiveLayer, (uint32_t *)xaddress, Length, 1, 0, DrawProp[ActiveLayer].TextColor); +} + +/** + * @brief Displays a vertical line. + * @param Xpos: the X position + * @param Ypos: the Y position + * @param Length: line length + */ +void BSP_LCD_DrawVLine(uint16_t Xpos, uint16_t Ypos, uint16_t Length) +{ + uint32_t xaddress = 0; + + /* Get the line address */ + xaddress = (LtdcHandler.LayerCfg[ActiveLayer].FBStartAdress) + 4 * (BSP_LCD_GetXSize() * Ypos + Xpos); + + /* Write line */ + FillBuffer(ActiveLayer, (uint32_t *)xaddress, 1, Length, (BSP_LCD_GetXSize() - 1), DrawProp[ActiveLayer].TextColor); +} + +/** + * @brief Displays an uni-line (between two points). + * @param X1: the point 1 X position + * @param Y1: the point 1 Y position + * @param X2: the point 2 X position + * @param Y2: the point 2 Y position + */ +void BSP_LCD_DrawLine(uint16_t X1, uint16_t Y1, uint16_t X2, uint16_t Y2) +{ + int16_t deltax = 0, deltay = 0, x = 0, y = 0, xinc1 = 0, xinc2 = 0, + yinc1 = 0, yinc2 = 0, den = 0, num = 0, numadd = 0, numpixels = 0, + curpixel = 0; + + deltax = ABS(X2 - X1); /* The difference between the x's */ + deltay = ABS(Y2 - Y1); /* The difference between the y's */ + x = X1; /* Start x off at the first pixel */ + y = Y1; /* Start y off at the first pixel */ + + if (X2 >= X1) /* The x-values are increasing */ + { + xinc1 = 1; + xinc2 = 1; + } + else /* The x-values are decreasing */ + { + xinc1 = -1; + xinc2 = -1; + } + + if (Y2 >= Y1) /* The y-values are increasing */ + { + yinc1 = 1; + yinc2 = 1; + } + else /* The y-values are decreasing */ + { + yinc1 = -1; + yinc2 = -1; + } + + if (deltax >= deltay) /* There is at least one x-value for every y-value */ + { + xinc1 = 0; /* Don't change the x when numerator >= denominator */ + yinc2 = 0; /* Don't change the y for every iteration */ + den = deltax; + num = deltax / 2; + numadd = deltay; + numpixels = deltax; /* There are more x-values than y-values */ + } + else /* There is at least one y-value for every x-value */ + { + xinc2 = 0; /* Don't change the x for every iteration */ + yinc1 = 0; /* Don't change the y when numerator >= denominator */ + den = deltay; + num = deltay / 2; + numadd = deltax; + numpixels = deltay; /* There are more y-values than x-values */ + } + + for (curpixel = 0; curpixel <= numpixels; curpixel++) + { + BSP_LCD_DrawPixel(x, y, DrawProp[ActiveLayer].TextColor); /* Draw the current pixel */ + num += numadd; /* Increase the numerator by the top of the fraction */ + if (num >= den) /* Check if numerator >= denominator */ + { + num -= den; /* Calculate the new numerator value */ + x += xinc1; /* Change the x as appropriate */ + y += yinc1; /* Change the y as appropriate */ + } + x += xinc2; /* Change the x as appropriate */ + y += yinc2; /* Change the y as appropriate */ + } +} + +/** + * @brief Displays a rectangle. + * @param Xpos: the X position + * @param Ypos: the Y position + * @param Height: display rectangle height + * @param Width: display rectangle width + */ +void BSP_LCD_DrawRect(uint16_t Xpos, uint16_t Ypos, uint16_t Width, uint16_t Height) +{ + /* Draw horizontal lines */ + BSP_LCD_DrawHLine(Xpos, Ypos, Width); + BSP_LCD_DrawHLine(Xpos, (Ypos + Height), Width); + + /* Draw vertical lines */ + BSP_LCD_DrawVLine(Xpos, Ypos, Height); + BSP_LCD_DrawVLine((Xpos + Width), Ypos, Height); +} + +/** + * @brief Displays a circle. + * @param Xpos: the X position + * @param Ypos: the Y position + * @param Radius: the circle radius + */ +void BSP_LCD_DrawCircle(uint16_t Xpos, uint16_t Ypos, uint16_t Radius) +{ + int32_t d;/* Decision Variable */ + uint32_t curx;/* Current X Value */ + uint32_t cury;/* Current Y Value */ + + d = 3 - (Radius << 1); + curx = 0; + cury = Radius; + + while (curx <= cury) + { + BSP_LCD_DrawPixel((Xpos + curx), (Ypos - cury), DrawProp[ActiveLayer].TextColor); + BSP_LCD_DrawPixel((Xpos - curx), (Ypos - cury), DrawProp[ActiveLayer].TextColor); + BSP_LCD_DrawPixel((Xpos + cury), (Ypos - curx), DrawProp[ActiveLayer].TextColor); + BSP_LCD_DrawPixel((Xpos - cury), (Ypos - curx), DrawProp[ActiveLayer].TextColor); + BSP_LCD_DrawPixel((Xpos + curx), (Ypos + cury), DrawProp[ActiveLayer].TextColor); + BSP_LCD_DrawPixel((Xpos - curx), (Ypos + cury), DrawProp[ActiveLayer].TextColor); + BSP_LCD_DrawPixel((Xpos + cury), (Ypos + curx), DrawProp[ActiveLayer].TextColor); + BSP_LCD_DrawPixel((Xpos - cury), (Ypos + curx), DrawProp[ActiveLayer].TextColor); + + if (d < 0) + { + d += (curx << 2) + 6; + } + else + { + d += ((curx - cury) << 2) + 10; + cury--; + } + curx++; + } +} + +/** + * @brief Displays an poly-line (between many points). + * @param Points: pointer to the points array + * @param PointCount: Number of points + */ +void BSP_LCD_DrawPolygon(pPoint Points, uint16_t PointCount) +{ + int16_t x = 0, y = 0; + + if (PointCount < 2) + { + return; + } + + BSP_LCD_DrawLine(Points->X, Points->Y, (Points + PointCount - 1)->X, (Points + PointCount - 1)->Y); + + while (--PointCount) + { + x = Points->X; + y = Points->Y; + Points++; + BSP_LCD_DrawLine(x, y, Points->X, Points->Y); + } +} + +/** + * @brief Displays an Ellipse. + * @param Xpos: the X position + * @param Ypos: the Y position + * @param XRadius: the X radius of ellipse + * @param YRadius: the Y radius of ellipse + */ +void BSP_LCD_DrawEllipse(int Xpos, int Ypos, int XRadius, int YRadius) +{ + int x = 0, y = -YRadius, err = 2 - 2 * XRadius, e2; + float k = 0, rad1 = 0, rad2 = 0; + + rad1 = XRadius; + rad2 = YRadius; + + k = (float)(rad2 / rad1); + + do + { + BSP_LCD_DrawPixel((Xpos - (uint16_t)(x / k)), (Ypos + y), DrawProp[ActiveLayer].TextColor); + BSP_LCD_DrawPixel((Xpos + (uint16_t)(x / k)), (Ypos + y), DrawProp[ActiveLayer].TextColor); + BSP_LCD_DrawPixel((Xpos + (uint16_t)(x / k)), (Ypos - y), DrawProp[ActiveLayer].TextColor); + BSP_LCD_DrawPixel((Xpos - (uint16_t)(x / k)), (Ypos - y), DrawProp[ActiveLayer].TextColor); + + e2 = err; + if (e2 <= x) + { + err += ++x * 2 + 1; + if (-y == x && e2 <= y) { e2 = 0; } + } + if (e2 > y) { err += ++y * 2 + 1; } + } while (y <= 0); +} + +/** + * @brief Displays a bitmap picture loaded in the internal Flash (32 bpp). + * @param X: the bmp x position in the LCD + * @param Y: the bmp Y position in the LCD + * @param pBmp: Bmp picture address in the internal Flash + */ +void BSP_LCD_DrawBitmap(uint32_t X, uint32_t Y, uint8_t *pBmp) +{ + uint32_t index = 0, width = 0, height = 0, bitpixel = 0; + uint32_t address; + uint32_t inputcolormode = 0; + + /* Get bitmap data address offset */ + index = pBmp[10] + (pBmp[11] << 8) + (pBmp[12] << 16) + (pBmp[13] << 24); + + /* Read bitmap width */ + width = pBmp[18] + (pBmp[19] << 8) + (pBmp[20] << 16) + (pBmp[21] << 24); + + /* Read bitmap height */ + height = pBmp[22] + (pBmp[23] << 8) + (pBmp[24] << 16) + (pBmp[25] << 24); + + /* Read bit/pixel */ + bitpixel = pBmp[28] + (pBmp[29] << 8); + + /* Set Address */ + address = LtdcHandler.LayerCfg[ActiveLayer].FBStartAdress + (((BSP_LCD_GetXSize() * Y) + X) * (4)); + + /* Get the Layer pixel format */ + if ((bitpixel / 8) == 4) + { + inputcolormode = CM_ARGB8888; + } + else if ((bitpixel / 8) == 2) + { + inputcolormode = CM_RGB565; + } + else + { + inputcolormode = CM_RGB888; + } + + /* bypass the bitmap header */ + pBmp += (index + (width * (height - 1) * (bitpixel / 8))); + + /* Convert picture to ARGB8888 pixel format */ + for (index = 0; index < height; index++) + { + /* Pixel format conversion */ + ConvertLineToARGB8888((uint32_t *)pBmp, (uint32_t *)address, width, inputcolormode); + + /* Increment the source and destination buffers */ + address += ((BSP_LCD_GetXSize() - width + width) * 4); + pBmp -= width * (bitpixel / 8); + } +} + +/** + * @brief Displays a full rectangle. + * @param Xpos: the X position + * @param Ypos: the Y position + * @param Height: rectangle height + * @param Width: rectangle width + */ +void BSP_LCD_FillRect(uint16_t Xpos, uint16_t Ypos, uint16_t Width, uint16_t Height) +{ + uint32_t xaddress = 0; + + /* Set the text color */ + BSP_LCD_SetTextColor(DrawProp[ActiveLayer].TextColor); + + /* Get the rectangle start address */ + xaddress = (LtdcHandler.LayerCfg[ActiveLayer].FBStartAdress) + 4 * (BSP_LCD_GetXSize() * Ypos + Xpos); + + /* Fill the rectangle */ + FillBuffer(ActiveLayer, (uint32_t *)xaddress, Width, Height, (BSP_LCD_GetXSize() - Width), + DrawProp[ActiveLayer].TextColor); +} + +/** + * @brief Displays a full circle. + * @param Xpos: the X position + * @param Ypos: the Y position + * @param Radius: the circle radius + */ +void BSP_LCD_FillCircle(uint16_t Xpos, uint16_t Ypos, uint16_t Radius) +{ + int32_t d; /* Decision Variable */ + uint32_t curx;/* Current X Value */ + uint32_t cury;/* Current Y Value */ + + d = 3 - (Radius << 1); + + curx = 0; + cury = Radius; + + BSP_LCD_SetTextColor(DrawProp[ActiveLayer].TextColor); + + while (curx <= cury) + { + if (cury > 0) + { + BSP_LCD_DrawHLine(Xpos - cury, Ypos + curx, 2 * cury); + BSP_LCD_DrawHLine(Xpos - cury, Ypos - curx, 2 * cury); + } + + if (curx > 0) + { + BSP_LCD_DrawHLine(Xpos - curx, Ypos - cury, 2 * curx); + BSP_LCD_DrawHLine(Xpos - curx, Ypos + cury, 2 * curx); + } + if (d < 0) + { + d += (curx << 2) + 6; + } + else + { + d += ((curx - cury) << 2) + 10; + cury--; + } + curx++; + } + + BSP_LCD_SetTextColor(DrawProp[ActiveLayer].TextColor); + BSP_LCD_DrawCircle(Xpos, Ypos, Radius); +} + +/** + * @brief Fill triangle. + * @param X1: the point 1 x position + * @param Y1: the point 1 y position + * @param X2: the point 2 x position + * @param Y2: the point 2 y position + * @param X3: the point 3 x position + * @param Y3: the point 3 y position + */ +void BSP_LCD_FillTriangle(uint16_t X1, uint16_t X2, uint16_t X3, uint16_t Y1, uint16_t Y2, uint16_t Y3) +{ + int16_t deltax = 0, deltay = 0, x = 0, y = 0, xinc1 = 0, xinc2 = 0, + yinc1 = 0, yinc2 = 0, den = 0, num = 0, numadd = 0, numpixels = 0, + curpixel = 0; + + deltax = ABS(X2 - X1); /* The difference between the x's */ + deltay = ABS(Y2 - Y1); /* The difference between the y's */ + x = X1; /* Start x off at the first pixel */ + y = Y1; /* Start y off at the first pixel */ + + if (X2 >= X1) /* The x-values are increasing */ + { + xinc1 = 1; + xinc2 = 1; + } + else /* The x-values are decreasing */ + { + xinc1 = -1; + xinc2 = -1; + } + + if (Y2 >= Y1) /* The y-values are increasing */ + { + yinc1 = 1; + yinc2 = 1; + } + else /* The y-values are decreasing */ + { + yinc1 = -1; + yinc2 = -1; + } + + if (deltax >= deltay) /* There is at least one x-value for every y-value */ + { + xinc1 = 0; /* Don't change the x when numerator >= denominator */ + yinc2 = 0; /* Don't change the y for every iteration */ + den = deltax; + num = deltax / 2; + numadd = deltay; + numpixels = deltax; /* There are more x-values than y-values */ + } + else /* There is at least one y-value for every x-value */ + { + xinc2 = 0; /* Don't change the x for every iteration */ + yinc1 = 0; /* Don't change the y when numerator >= denominator */ + den = deltay; + num = deltay / 2; + numadd = deltax; + numpixels = deltay; /* There are more y-values than x-values */ + } + + for (curpixel = 0; curpixel <= numpixels; curpixel++) + { + BSP_LCD_DrawLine(x, y, X3, Y3); + + num += numadd; /* Increase the numerator by the top of the fraction */ + if (num >= den) /* Check if numerator >= denominator */ + { + num -= den; /* Calculate the new numerator value */ + x += xinc1; /* Change the x as appropriate */ + y += yinc1; /* Change the y as appropriate */ + } + x += xinc2; /* Change the x as appropriate */ + y += yinc2; /* Change the y as appropriate */ + } +} + +/** + * @brief Displays a full poly-line (between many points). + * @param Points: pointer to the points array + * @param PointCount: Number of points + */ +void BSP_LCD_FillPolygon(pPoint Points, uint16_t PointCount) +{ + + int16_t x = 0, y = 0, x2 = 0, y2 = 0, xcenter = 0, ycenter = 0, xfirst = 0, yfirst = 0, pixelx = 0, pixely = 0, counter = 0; + uint16_t imageleft = 0, imageright = 0, imagetop = 0, imagebottom = 0; + + imageleft = imageright = Points->X; + imagetop = imagebottom = Points->Y; + + for (counter = 1; counter < PointCount; counter++) + { + pixelx = POLY_X(counter); + if (pixelx < imageleft) + { + imageleft = pixelx; + } + if (pixelx > imageright) + { + imageright = pixelx; + } + + pixely = POLY_Y(counter); + if (pixely < imagetop) + { + imagetop = pixely; + } + if (pixely > imagebottom) + { + imagebottom = pixely; + } + } + + if (PointCount < 2) + { + return; + } + + xcenter = (imageleft + imageright) / 2; + ycenter = (imagebottom + imagetop) / 2; + + xfirst = Points->X; + yfirst = Points->Y; + + while (--PointCount) + { + x = Points->X; + y = Points->Y; + Points++; + x2 = Points->X; + y2 = Points->Y; + + BSP_LCD_FillTriangle(x, x2, xcenter, y, y2, ycenter); + BSP_LCD_FillTriangle(x, xcenter, x2, y, ycenter, y2); + BSP_LCD_FillTriangle(xcenter, x2, x, ycenter, y2, y); + } + + BSP_LCD_FillTriangle(xfirst, x2, xcenter, yfirst, y2, ycenter); + BSP_LCD_FillTriangle(xfirst, xcenter, x2, yfirst, ycenter, y2); + BSP_LCD_FillTriangle(xcenter, x2, xfirst, ycenter, y2, yfirst); +} + +/** + * @brief Draw a full ellipse. + * @param Xpos: the X position + * @param Ypos: the Y position + * @param XRadius: X radius of ellipse + * @param YRadius: Y radius of ellipse. + */ +void BSP_LCD_FillEllipse(int Xpos, int Ypos, int XRadius, int YRadius) +{ + int x = 0, y = -YRadius, err = 2 - 2 * XRadius, e2; + float K = 0, rad1 = 0, rad2 = 0; + + rad1 = XRadius; + rad2 = YRadius; + K = (float)(rad2 / rad1); + + do + { + BSP_LCD_DrawHLine((Xpos - (uint16_t)(x / K)), (Ypos + y), (2 * (uint16_t)(x / K) + 1)); + BSP_LCD_DrawHLine((Xpos - (uint16_t)(x / K)), (Ypos - y), (2 * (uint16_t)(x / K) + 1)); + + e2 = err; + if (e2 <= x) + { + err += ++x * 2 + 1; + if (-y == x && e2 <= y) { e2 = 0; } + } + if (e2 > y) { err += ++y * 2 + 1; } + } while (y <= 0); +} + +/** + * @brief Enables the Display. + */ +void BSP_LCD_DisplayOn(void) +{ + if (LcdDrv->DisplayOn != NULL) + { + LcdDrv->DisplayOn(); + } +} + +/** + * @brief Disables the Display. + */ +void BSP_LCD_DisplayOff(void) +{ + if (LcdDrv->DisplayOff != NULL) + { + LcdDrv->DisplayOff(); + } +} + +/******************************************************************************* + LTDC and DMA2D BSP Routines + *******************************************************************************/ + +/** + * @brief Initializes the LTDC MSP. + */ +__weak void BSP_LCD_MspInit(void) +{ + GPIO_InitTypeDef GPIO_InitStructure; + + /* Enable the LTDC and DMA2D Clock */ + __HAL_RCC_LTDC_CLK_ENABLE(); + __HAL_RCC_DMA2D_CLK_ENABLE(); + + /* Enable GPIOs clock */ + __HAL_RCC_GPIOA_CLK_ENABLE(); + __HAL_RCC_GPIOB_CLK_ENABLE(); + __HAL_RCC_GPIOC_CLK_ENABLE(); + __HAL_RCC_GPIOD_CLK_ENABLE(); + __HAL_RCC_GPIOF_CLK_ENABLE(); + __HAL_RCC_GPIOG_CLK_ENABLE(); + + /* GPIOs Configuration */ + /* + +------------------------+-----------------------+----------------------------+ + + LCD pins assignment + + +------------------------+-----------------------+----------------------------+ + | LCD_TFT R2 <-> PC.10 | LCD_TFT G2 <-> PA.06 | LCD_TFT B2 <-> PD.06 | + | LCD_TFT R3 <-> PB.00 | LCD_TFT G3 <-> PG.10 | LCD_TFT B3 <-> PG.11 | + | LCD_TFT R4 <-> PA.11 | LCD_TFT G4 <-> PB.10 | LCD_TFT B4 <-> PG.12 | + | LCD_TFT R5 <-> PA.12 | LCD_TFT G5 <-> PB.11 | LCD_TFT B5 <-> PA.03 | + | LCD_TFT R6 <-> PB.01 | LCD_TFT G6 <-> PC.07 | LCD_TFT B6 <-> PB.08 | + | LCD_TFT R7 <-> PG.06 | LCD_TFT G7 <-> PD.03 | LCD_TFT B7 <-> PB.09 | + ------------------------------------------------------------------------------- + | LCD_TFT HSYNC <-> PC.06 | LCDTFT VSYNC <-> PA.04 | + | LCD_TFT CLK <-> PG.07 | LCD_TFT DE <-> PF.10 | + ----------------------------------------------------- + */ + + /* GPIOA configuration */ + GPIO_InitStructure.Pin = GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_6 | + GPIO_PIN_11 | GPIO_PIN_12; + GPIO_InitStructure.Mode = GPIO_MODE_AF_PP; + GPIO_InitStructure.Pull = GPIO_NOPULL; + GPIO_InitStructure.Speed = GPIO_SPEED_FAST; + GPIO_InitStructure.Alternate = GPIO_AF14_LTDC; + HAL_GPIO_Init(GPIOA, &GPIO_InitStructure); + + /* GPIOB configuration */ + GPIO_InitStructure.Pin = GPIO_PIN_8 | \ + GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_11; + HAL_GPIO_Init(GPIOB, &GPIO_InitStructure); + + /* GPIOC configuration */ + GPIO_InitStructure.Pin = GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_10; + HAL_GPIO_Init(GPIOC, &GPIO_InitStructure); + + /* GPIOD configuration */ + GPIO_InitStructure.Pin = GPIO_PIN_3 | GPIO_PIN_6; + HAL_GPIO_Init(GPIOD, &GPIO_InitStructure); + + /* GPIOF configuration */ + GPIO_InitStructure.Pin = GPIO_PIN_10; + HAL_GPIO_Init(GPIOF, &GPIO_InitStructure); + + /* GPIOG configuration */ + GPIO_InitStructure.Pin = GPIO_PIN_6 | GPIO_PIN_7 | \ + GPIO_PIN_11; + HAL_GPIO_Init(GPIOG, &GPIO_InitStructure); + + /* GPIOB configuration */ + GPIO_InitStructure.Pin = GPIO_PIN_0 | GPIO_PIN_1; + GPIO_InitStructure.Alternate = GPIO_AF9_LTDC; + HAL_GPIO_Init(GPIOB, &GPIO_InitStructure); + + /* GPIOG configuration */ + GPIO_InitStructure.Pin = GPIO_PIN_10 | GPIO_PIN_12; + HAL_GPIO_Init(GPIOG, &GPIO_InitStructure); +} + +/******************************************************************************* + Static Functions + *******************************************************************************/ + +/** + * @brief Writes Pixel. + * @param Xpos: the X position + * @param Ypos: the Y position + * @param RGB_Code: the pixel color in ARGB mode (8-8-8-8) + */ +void BSP_LCD_DrawPixel(uint16_t Xpos, uint16_t Ypos, uint32_t RGB_Code) +{ + /* Write data value to all SDRAM memory */ + *(__IO uint32_t *)(LtdcHandler.LayerCfg[ActiveLayer].FBStartAdress + (4 * (Ypos * BSP_LCD_GetXSize() + Xpos))) = RGB_Code; +} + +/** + * @brief Draws a character on LCD. + * @param Xpos: the Line where to display the character shape + * @param Ypos: start column address + * @param c: pointer to the character data + */ +static void DrawChar(uint16_t Xpos, uint16_t Ypos, const uint8_t *c) +{ + uint32_t i = 0, j = 0; + uint16_t height, width; + uint8_t offset; + uint8_t *pchar; + uint32_t line = 0; + + height = DrawProp[ActiveLayer].pFont->Height; + width = DrawProp[ActiveLayer].pFont->Width; + + offset = 8 * ((width + 7) / 8) - width ; + + for (i = 0; i < height; i++) + { + pchar = ((uint8_t *)c + (width + 7) / 8 * i); + + switch (((width + 7) / 8)) + { + case 1: + line = pchar[0]; + break; + + case 2: + line = (pchar[0] << 8) | pchar[1]; + break; + + case 3: + default: + line = (pchar[0] << 16) | (pchar[1] << 8) | pchar[2]; + break; + } + + for (j = 0; j < width; j++) + { + if (line & (1 << (width - j + offset - 1))) + { + BSP_LCD_DrawPixel((Xpos + j), Ypos, DrawProp[ActiveLayer].TextColor); + } + else + { + BSP_LCD_DrawPixel((Xpos + j), Ypos, DrawProp[ActiveLayer].BackColor); + } + } + Ypos++; + } +} + +/** + * @brief Fills buffer. + * @param LayerIndex: layer index + * @param pDst: output color + * @param xSize: buffer width + * @param ySize: buffer height + * @param OffLine: offset + * @param ColorIndex: color Index + */ +static void FillBuffer(uint32_t LayerIndex, void *pDst, uint32_t xSize, uint32_t ySize, uint32_t OffLine, + uint32_t ColorIndex) +{ + + /* Register to memory mode with ARGB8888 as color Mode */ + Dma2dHandler.Init.Mode = DMA2D_R2M; + Dma2dHandler.Init.ColorMode = DMA2D_ARGB8888; + Dma2dHandler.Init.OutputOffset = OffLine; + + Dma2dHandler.Instance = DMA2D; + + /* DMA2D Initialization */ + if (HAL_DMA2D_Init(&Dma2dHandler) == HAL_OK) + { + if (HAL_DMA2D_ConfigLayer(&Dma2dHandler, LayerIndex) == HAL_OK) + { + if (HAL_DMA2D_Start(&Dma2dHandler, ColorIndex, (uint32_t)pDst, xSize, ySize) == HAL_OK) + { + /* Polling For DMA transfer */ + HAL_DMA2D_PollForTransfer(&Dma2dHandler, 10); + } + } + } +} + +/** + * @brief Converts Line to ARGB8888 pixel format. + * @param pSrc: pointer to source buffer + * @param pDst: output color + * @param xSize: buffer width + * @param ColorMode: input color mode + */ +static void ConvertLineToARGB8888(void *pSrc, void *pDst, uint32_t xSize, uint32_t ColorMode) +{ + /* Configure the DMA2D Mode, Color Mode and output offset */ + Dma2dHandler.Init.Mode = DMA2D_M2M_PFC; + Dma2dHandler.Init.ColorMode = DMA2D_ARGB8888; + Dma2dHandler.Init.OutputOffset = 0; + + /* Foreground Configuration */ + Dma2dHandler.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA; + Dma2dHandler.LayerCfg[1].InputAlpha = 0xFF; + Dma2dHandler.LayerCfg[1].InputColorMode = ColorMode; + Dma2dHandler.LayerCfg[1].InputOffset = 0; + + Dma2dHandler.Instance = DMA2D; + + /* DMA2D Initialization */ + if (HAL_DMA2D_Init(&Dma2dHandler) == HAL_OK) + { + if (HAL_DMA2D_ConfigLayer(&Dma2dHandler, 1) == HAL_OK) + { + if (HAL_DMA2D_Start(&Dma2dHandler, (uint32_t)pSrc, (uint32_t)pDst, xSize, 1) == HAL_OK) + { + /* Polling For DMA transfer */ + HAL_DMA2D_PollForTransfer(&Dma2dHandler, 10); + } + } + } +} + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ + +/** + * @} + */ diff --git a/Makefile b/Makefile index 9b86639..94e1bec 100644 --- a/Makefile +++ b/Makefile @@ -39,6 +39,7 @@ C_SOURCES = \ Core/Src/main.c \ Core/Src/stm32f4xx_it.c \ Core/Src/stm32f4xx_hal_msp.c \ +Core/Src/stm32f429i_discovery_lcd.c \ Drivers/STM32F4xx_HAL_Driver/Src/stm32f4xx_hal_rcc.c \ Drivers/STM32F4xx_HAL_Driver/Src/stm32f4xx_hal_rcc_ex.c \ Drivers/STM32F4xx_HAL_Driver/Src/stm32f4xx_hal_flash.c \