dplimin
/
F203
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
F203/Core/Src/ltdc.c

1704 lines
50 KiB
C
Raw Blame History

/**
******************************************************************************
* File Name : LTDC.c
* Description : This file provides code for the configuration
* of the LTDC instances.
******************************************************************************
* This notice applies to any and all portions of this file
* that are not between comment pairs USER CODE BEGIN and
* USER CODE END. Other portions of this file, whether
* inserted by the user or by software development tools
* are owned by their respective copyright owners.
*
* Copyright (c) 2018 STMicroelectronics International N.V.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted, provided that the following conditions are met:
*
* 1. Redistribution of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. Neither the name of STMicroelectronics nor the names of other
* contributors to this software may be used to endorse or promote products
* derived from this software without specific written permission.
* 4. This software, including modifications and/or derivative works of this
* software, must execute solely and exclusively on microcontroller or
* microprocessor devices manufactured by or for STMicroelectronics.
* 5. Redistribution and use of this software other than as permitted under
* this license is void and will automatically terminate your rights under
* this license.
*
* THIS SOFTWARE IS PROVIDED BY STMICROELECTRONICS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS, IMPLIED OR STATUTORY WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
* PARTICULAR PURPOSE AND NON-INFRINGEMENT OF THIRD PARTY INTELLECTUAL PROPERTY
* RIGHTS ARE DISCLAIMED TO THE FULLEST EXTENT PERMITTED BY LAW. IN NO EVENT
* SHALL STMICROELECTRONICS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "ltdc.h"
#include "gpio.h"
#include <stdbool.h>
#include <string.h>
#include "arm_math.h"
#include "stm32756g_eval_lcd.h"
uint16_t LAYER_1[320*240] = {0};
uint16_t LAYER_2[320*240] = {0};
#define POLY_X(Z) ((int32_t)((Points + Z)->X))
#define POLY_Y(Z) ((int32_t)((Points + Z)->Y))
extern const uint16_t Font17_Table[];
static DMA2D_HandleTypeDef hDma2dHandler;
static LCD_DrawPropTypeDef DrawProp[MAX_LAYER_NUMBER];
static uint32_t ActiveLayer = 1;
volatile uint32_t RenderingLayer = 0;
static void TransferComplete(DMA2D_HandleTypeDef *hdma2d);
static void TransferError(DMA2D_HandleTypeDef *hdma2d);
static void DrawChar(uint16_t Xpos, uint16_t Ypos, const uint8_t *c);
static void LCD_DrawRusChar(uint16_t Xpos, uint16_t Ypos, const uint16_t *c);
//static void FillTriangle(uint16_t x1, uint16_t x2, uint16_t x3, uint16_t y1, uint16_t y2, uint16_t y3);
static void LL_FillBuffer(uint32_t LayerIndex, void *pDst, uint32_t xSize, uint32_t ySize, uint32_t OffLine, uint32_t ColorIndex);
static void LL_ConvertLineToARGB8888(void * pSrc, void *pDst, uint32_t xSize, uint32_t ColorMode);
volatile uint32_t DMA2D_TransferOk = 1;
volatile bool RefreshScreen = false;
volatile bool RefreshNums = false;
volatile uint32_t TimerRefreshLCD = 0;
sFONT *CurrentFont;
LTDC_HandleTypeDef hLtdcHandler;
uint32_t RGB565_TO_RGB888(uint16_t rgb565)
{
uint32_t r8, g8, b8;
uint32_t rgb888 = 0xff000000;
r8 = (uint32_t) (((float32_t) R5(rgb565) * 8.22580645f) + 0.5f);
g8 = (uint32_t) (((float32_t) G6(rgb565) * 4.047619f) + 0.5f);
b8 = (uint32_t) (((float32_t) B5(rgb565) * 8.22580645f) + 0.5f);
if(r8 > 255) r8 = 255;
if(g8 > 255) g8 = 255;
if(b8 > 255) b8 = 255;
rgb888 |= ((r8 << 16) | (g8 << 8) | b8);
return rgb888;
}
void LTDC_Reset(void)
{
HAL_GPIO_WritePin(RESET_GPIO_Port, RESET_Pin, GPIO_PIN_SET); HAL_Delay(100);
HAL_GPIO_WritePin(RESET_GPIO_Port, RESET_Pin, GPIO_PIN_RESET); HAL_Delay(100);
HAL_GPIO_WritePin(RESET_GPIO_Port, RESET_Pin, GPIO_PIN_SET); HAL_Delay(100);
}
/* LTDC init function */
void MX_LTDC_Init(void)
{
LTDC_LayerCfgTypeDef pLayerCfg;
LTDC_LayerCfgTypeDef pLayerCfg1;
__IO uint32_t tickstart;
// SET_BIT(RCC->CR, RCC_CR_PLLSAION);
// HAL_Delay(100);
LTDC_Reset();
__HAL_RCC_PLLSAI_ENABLE();
tickstart = HAL_GetTick();
while(__HAL_RCC_PLLSAI_GET_FLAG() == RESET)
{
if((HAL_GetTick() - tickstart) >= PLLSAI_TIMEOUT_VALUE) {
Error_Handler();
}
}
hLtdcHandler.Instance = LTDC;
hLtdcHandler.Init.HSPolarity = LTDC_HSPOLARITY_AL;
hLtdcHandler.Init.VSPolarity = LTDC_VSPOLARITY_AL;
hLtdcHandler.Init.DEPolarity = LTDC_DEPOLARITY_AH;
hLtdcHandler.Init.PCPolarity = LTDC_PCPOLARITY_IPC;
hLtdcHandler.Init.HorizontalSync = 38;
hLtdcHandler.Init.VerticalSync = 4;
hLtdcHandler.Init.AccumulatedHBP = 68;
hLtdcHandler.Init.AccumulatedVBP = 18;
hLtdcHandler.Init.AccumulatedActiveW = 388;
hLtdcHandler.Init.AccumulatedActiveH = 262;
hLtdcHandler.Init.TotalWidth = 408;
hLtdcHandler.Init.TotalHeigh = 263;
hLtdcHandler.Init.Backcolor.Blue = 0;
hLtdcHandler.Init.Backcolor.Green = 0;
hLtdcHandler.Init.Backcolor.Red = 0;
if (HAL_LTDC_Init(&hLtdcHandler) != HAL_OK) {
Error_Handler();
}
pLayerCfg.WindowX0 = 0;
pLayerCfg.WindowX1 = 320;
pLayerCfg.WindowY0 = 0;
pLayerCfg.WindowY1 = 240;
pLayerCfg.PixelFormat = LTDC_PIXEL_FORMAT_RGB565;
pLayerCfg.Alpha = 255;
pLayerCfg.Alpha0 = 0;
pLayerCfg.BlendingFactor1 = LTDC_BLENDING_FACTOR1_PAxCA;
pLayerCfg.BlendingFactor2 = LTDC_BLENDING_FACTOR2_PAxCA;
pLayerCfg.FBStartAdress = (uint32_t) &LAYER_1[0];
pLayerCfg.ImageWidth = 320;
pLayerCfg.ImageHeight = 240;
pLayerCfg.Backcolor.Blue = 0;
pLayerCfg.Backcolor.Green = 0;
pLayerCfg.Backcolor.Red = 0;
if(HAL_LTDC_ConfigLayer(&hLtdcHandler, &pLayerCfg, 0) != HAL_OK) {
Error_Handler();
}
pLayerCfg1.WindowX0 = 0;
pLayerCfg1.WindowX1 = 320;
pLayerCfg1.WindowY0 = 0;
pLayerCfg1.WindowY1 = 240;
pLayerCfg1.PixelFormat = LTDC_PIXEL_FORMAT_RGB565;
pLayerCfg1.Alpha = 255;
pLayerCfg1.Alpha0 = 0;
pLayerCfg1.BlendingFactor1 = LTDC_BLENDING_FACTOR1_PAxCA;
pLayerCfg1.BlendingFactor2 = LTDC_BLENDING_FACTOR2_PAxCA;
pLayerCfg1.FBStartAdress = (uint32_t) &LAYER_2[0];
pLayerCfg1.ImageWidth = 320;
pLayerCfg1.ImageHeight = 240;
pLayerCfg1.Backcolor.Blue = 0;
pLayerCfg1.Backcolor.Green = 0;
pLayerCfg1.Backcolor.Red = 0;
if(HAL_LTDC_ConfigLayer(&hLtdcHandler, &pLayerCfg1, 1) != HAL_OK) {
Error_Handler();
}
//HAL_LTDC_EnableCLUT(&hLtdcHandler, 0);
//HAL_LTDC_EnableCLUT(&hLtdcHandler, 1);
ActiveLayer = 1;
RenderingLayer = 0;
BSP_LCD_DisplayOff();
BSP_LCD_SelectLayer(0);
BSP_LCD_Clear(0xFF000000);
BSP_LCD_SelectLayer(1);
BSP_LCD_Clear(0xFF000000);
BSP_LCD_SetLayerVisible(RenderingLayer, DISABLE);
BSP_LCD_SetLayerVisible(ActiveLayer, DISABLE);
HAL_LTDC_Reload(&hLtdcHandler, LTDC_RELOAD_IMMEDIATE);
DrawProp[0].BackColor = LCD_COLOR_BLACK;
DrawProp[0].pFont = &Font17;
DrawProp[0].TextColor = LCD_COLOR_WHITE;
DrawProp[1].BackColor = LCD_COLOR_BLACK;
DrawProp[1].pFont = &Font17;
DrawProp[1].TextColor = LCD_COLOR_WHITE;
CurrentFont = &Font17;
BSP_LCD_DisplayOn();
HAL_GPIO_WritePin(DISP_ON_GPIO_Port, DISP_ON_Pin, GPIO_PIN_SET); // BACKLIGHT IS OFF
RefreshScreen = true;
HAL_LTDC_ProgramLineEvent(&hLtdcHandler, 255);
while(RefreshScreen);
BSP_LCD_SetLayerVisible(RenderingLayer, ENABLE);
}
void BSP_LCD_DisplayOn(void)
{
//__HAL_LTDC_ENABLE(&hLtdcHandler);
HAL_GPIO_WritePin(GPIOF, GPIO_PIN_10, GPIO_PIN_SET); // DISPLAY_ON
}
/**
* @brief Disables the display.
* @retval None
*/
void BSP_LCD_DisplayOff(void)
{
//__HAL_LTDC_DISABLE(&hLtdcHandler);
HAL_GPIO_WritePin(GPIOF, GPIO_PIN_10, GPIO_PIN_RESET); // DISPLAY_OFF
}
void HAL_LTDC_MspInit(LTDC_HandleTypeDef* ltdcHandle)
{
GPIO_InitTypeDef GPIO_InitStruct;
if(ltdcHandle->Instance == LTDC)
{
__HAL_RCC_LTDC_CLK_ENABLE();
/* LTDC GPIO Configuration
PA3 ------> LTDC_B5
PA4 ------> LTDC_VSYNC
PA6 ------> LTDC_G2
PA11 ------> LTDC_R4
PA12 ------> LTDC_R5
PB0 ------> LTDC_R3
PB1 ------> LTDC_R6
PB8 ------> LTDC_B6
PB9 ------> LTDC_B7
PB10 ------> LTDC_G4
PB11 ------> LTDC_G5
PC6 ------> LTDC_HSYNC
PC7 ------> LTDC_G6
PD3 ------> LTDC_G7
PF10 ------> LTDC_DE
PG6 ------> LTDC_R7
PG7 ------> LTDC_CLK
PG10 ------> LTDC_G3
PG11 ------> LTDC_B3
PG12 ------> LTDC_B4 */
GPIO_InitStruct.Pin = GPIO_PIN_10;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
GPIO_InitStruct.Pin = GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_6 | GPIO_PIN_11 |GPIO_PIN_12;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF14_LTDC;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
GPIO_InitStruct.Pin = GPIO_PIN_0 | GPIO_PIN_1;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF9_LTDC;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
GPIO_InitStruct.Pin = GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_8 | GPIO_PIN_9;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF14_LTDC;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
GPIO_InitStruct.Pin = GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_11;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF14_LTDC;
HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
GPIO_InitStruct.Pin = GPIO_PIN_6 | GPIO_PIN_7;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF14_LTDC;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
GPIO_InitStruct.Pin = GPIO_PIN_3;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF14_LTDC;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
GPIO_InitStruct.Pin = GPIO_PIN_10 | GPIO_PIN_12;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF9_LTDC;
HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
HAL_NVIC_SetPriority(LTDC_IRQn, 6, 0);
HAL_NVIC_EnableIRQ(LTDC_IRQn);
}
}
void HAL_LTDC_MspDeInit(LTDC_HandleTypeDef* ltdcHandle)
{
if(ltdcHandle->Instance==LTDC)
{
__HAL_RCC_LTDC_CLK_DISABLE();
HAL_GPIO_DeInit(GPIOF, GPIO_PIN_10);
HAL_GPIO_DeInit(GPIOA, GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_6|GPIO_PIN_11|GPIO_PIN_12);
HAL_GPIO_DeInit(GPIOB, GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_8|GPIO_PIN_9);
HAL_GPIO_DeInit(GPIOG, GPIO_PIN_6|GPIO_PIN_7|GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12);
HAL_GPIO_DeInit(GPIOC, GPIO_PIN_6|GPIO_PIN_7);
HAL_GPIO_DeInit(GPIOD, GPIO_PIN_3);
HAL_NVIC_DisableIRQ(LTDC_IRQn);
}
}
uint32_t BSP_LCD_GetXSize(void)
{
return hLtdcHandler.LayerCfg[ActiveLayer].ImageWidth;
}
/**
* @brief Gets the LCD Y size.
* @retval Used LCD Y size
*/
uint32_t BSP_LCD_GetYSize(void)
{
return hLtdcHandler.LayerCfg[ActiveLayer].ImageHeight;
}
/**
* @brief Set the LCD X size.
* @param imageWidthPixels : image width in pixels unit
* @retval None
*/
void BSP_LCD_SetXSize(uint32_t imageWidthPixels)
{
hLtdcHandler.LayerCfg[ActiveLayer].ImageWidth = imageWidthPixels;
}
/**
* @brief Set the LCD Y size.
* @param imageHeightPixels : image height in lines unit
* @retval None
*/
void BSP_LCD_SetYSize(uint32_t imageHeightPixels)
{
hLtdcHandler.LayerCfg[ActiveLayer].ImageHeight = imageHeightPixels;
}
void BSP_LCD_SelectLayer(uint32_t LayerIndex)
{
ActiveLayer = LayerIndex;
}
/**
* @brief Sets an LCD Layer visible
* @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(uint32_t LayerIndex, FunctionalState State)
{
if(State == ENABLE)
__HAL_LTDC_LAYER_ENABLE(&hLtdcHandler, LayerIndex);
else __HAL_LTDC_LAYER_DISABLE(&hLtdcHandler, LayerIndex);
__HAL_LTDC_RELOAD_CONFIG(&hLtdcHandler);
}
/**
* @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(&hLtdcHandler, LayerIndex);
else __HAL_LTDC_LAYER_DISABLE(&hLtdcHandler, LayerIndex);
}
/**
* @brief Configures the transparency.
* @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(uint32_t LayerIndex, uint8_t Transparency)
{
HAL_LTDC_SetAlpha(&hLtdcHandler, 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(&hLtdcHandler, Transparency, LayerIndex);
}
/**
* @brief Sets an LCD layer frame buffer address.
* @param LayerIndex: Layer foreground or background
* @param Address: New LCD frame buffer value
* @retval None
*/
void BSP_LCD_SetLayerAddress(uint32_t LayerIndex, uint32_t Address)
{
HAL_LTDC_SetAddress(&hLtdcHandler, 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(&hLtdcHandler, Address, LayerIndex);
}
/**
* @brief Sets 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
* @retval None
*/
void BSP_LCD_SetLayerWindow(uint16_t LayerIndex, uint16_t Xpos, uint16_t Ypos, uint16_t Width, uint16_t Height)
{
HAL_LTDC_SetWindowSize(&hLtdcHandler, Width, Height, LayerIndex);/* Reconfigure the layer size */
HAL_LTDC_SetWindowPosition(&hLtdcHandler, Xpos, Ypos, LayerIndex);/* Reconfigure the layer position */
}
/**
* @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)
{
HAL_LTDC_SetWindowSize_NoReload(&hLtdcHandler, Width, Height, LayerIndex);/* Reconfigure the layer size */
HAL_LTDC_SetWindowPosition_NoReload(&hLtdcHandler, Xpos, Ypos, LayerIndex); /* Reconfigure the layer position */
}
/**
* @brief Configures and sets the color keying.
* @param LayerIndex: Layer foreground or background
* @param RGBValue: Color reference
* @retval None
*/
void BSP_LCD_SetColorKeying(uint32_t LayerIndex, uint32_t RGBValue)
{
/* Configure and Enable the color Keying for LCD Layer */
HAL_LTDC_ConfigColorKeying(&hLtdcHandler, RGBValue, LayerIndex);
HAL_LTDC_EnableColorKeying(&hLtdcHandler, 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(&hLtdcHandler, RGBValue, LayerIndex);
HAL_LTDC_EnableColorKeying_NoReload(&hLtdcHandler, LayerIndex);
}
/**
* @brief Disables the color keying.
* @param LayerIndex: Layer foreground or background
* @retval None
*/
void BSP_LCD_ResetColorKeying(uint32_t LayerIndex)
{
/* Disable the color Keying for LCD Layer */
HAL_LTDC_DisableColorKeying(&hLtdcHandler, 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(&hLtdcHandler, LayerIndex);
}
/** BSP_LCD_Reload(LCD_RELOAD_VERTICAL_BLANKING);
* @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_Reload(uint32_t ReloadType)
{
HAL_LTDC_Reload (&hLtdcHandler, ReloadType);
}
/**
* @brief Sets the LCD text color.
* @param Color: Text color code ARGB(8-8-8-8)
* @retval None
*/
void LCD_SetColors(uint32_t ColorUp, uint32_t ColorDn)
{
DrawProp[ActiveLayer].TextColor = ColorUp;
DrawProp[ActiveLayer].BackColor = ColorDn;
}
void BSP_LCD_SetTextColor(uint32_t Color)
{
DrawProp[ActiveLayer].TextColor = Color;
}
/**
* @brief Gets the LCD text color.
* @retval Used text color.
*/
uint32_t BSP_LCD_GetTextColor(void)
{
return DrawProp[ActiveLayer].TextColor;
}
/**
* @brief Sets the LCD background color.
* @param Color: Layer background color code ARGB(8-8-8-8)
* @retval None
*/
void BSP_LCD_SetBackColor(uint32_t Color)
{
DrawProp[ActiveLayer].BackColor = Color;
}
/**
* @brief Gets the LCD background color.
* @retval Used background colour
*/
uint32_t BSP_LCD_GetBackColor(void)
{
return DrawProp[ActiveLayer].BackColor;
}
/**
* @brief Sets the LCD text font.
* @param fonts: Layer font to be used
* @retval None
*/
void BSP_LCD_SetFont(sFONT *fonts)
{
DrawProp[ActiveLayer].pFont = fonts;
CurrentFont = fonts;
}
/**
* @brief Gets the LCD text font.
* @retval Used layer font
*/
sFONT *BSP_LCD_GetFont(void)
{
return DrawProp[ActiveLayer].pFont;
}
/**
* @brief Reads an LCD pixel.
* @param Xpos: X position
* @param Ypos: Y position
* @retval RGB pixel color
*/
uint32_t BSP_LCD_ReadPixel(uint16_t Xpos, uint16_t Ypos)
{
uint32_t ret = 0;
if(hLtdcHandler.LayerCfg[ActiveLayer].PixelFormat == LTDC_PIXEL_FORMAT_ARGB8888)
{
/* Read data value from SDRAM memory */
ret = *(__IO uint32_t*) (hLtdcHandler.LayerCfg[ActiveLayer].FBStartAdress + (4*(Ypos*BSP_LCD_GetXSize() + Xpos)));
}
else if(hLtdcHandler.LayerCfg[ActiveLayer].PixelFormat == LTDC_PIXEL_FORMAT_RGB888)
{
/* Read data value from SDRAM memory */
ret = (*(__IO uint32_t*) (hLtdcHandler.LayerCfg[ActiveLayer].FBStartAdress + (4*(Ypos*BSP_LCD_GetXSize() + Xpos))) & 0x00FFFFFF);
}
else if((hLtdcHandler.LayerCfg[ActiveLayer].PixelFormat == LTDC_PIXEL_FORMAT_RGB565) || \
(hLtdcHandler.LayerCfg[ActiveLayer].PixelFormat == LTDC_PIXEL_FORMAT_ARGB4444) || \
(hLtdcHandler.LayerCfg[ActiveLayer].PixelFormat == LTDC_PIXEL_FORMAT_AL88))
{
/* Read data value from SDRAM memory */
ret = *(__IO uint16_t*) (hLtdcHandler.LayerCfg[ActiveLayer].FBStartAdress + (2*(Ypos*BSP_LCD_GetXSize() + Xpos)));
}
else
{
/* Read data value from SDRAM memory */
ret = *(__IO uint8_t*) (hLtdcHandler.LayerCfg[ActiveLayer].FBStartAdress + (2*(Ypos*BSP_LCD_GetXSize() + Xpos)));
}
return ret;
}
/**
* @brief Clears the hole LCD.
* @param Color: Color of the background
* @retval None
*/
void BSP_LCD_Clear(uint32_t Color)
{
LL_FillBuffer(ActiveLayer, (uint32_t *)(hLtdcHandler.LayerCfg[ActiveLayer].FBStartAdress), BSP_LCD_GetXSize(), BSP_LCD_GetYSize(), 0, Color);
}
/**
* @brief Clears the selected line.
* @param Line: Line to be cleared
* @retval None
*/
void BSP_LCD_ClearStringLine(uint32_t Line)
{
uint32_t color_backup = 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 = color_backup;
BSP_LCD_SetTextColor(DrawProp[ActiveLayer].TextColor);
}
/**
* @brief Displays one character.
* @param Xpos: Start column address
* @param Ypos: Line where to display the character shape.
* @param Ascii: Character ascii code
* This parameter must be a number between Min_Data = 0x20 and Max_Data = 0x7E
* @retval None
*/
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 characters on the LCD.
* @param Xpos: X position (in pixel)
* @param Ypos: Y position (in pixel)
* @param Text: Pointer to string to display on LCD
* @param Mode: Display mode
* This parameter can be one of the following values:
* @arg CENTER_MODE
* @arg RIGHT_MODE
* @arg LEFT_MODE
* @retval None
*/
void BSP_LCD_DisplayStringAt(uint16_t Xpos, uint16_t Ypos, char *Text, Text_AlignModeTypdef Mode)
{
uint16_t ref_column = 1, i = 0, ll = 0;
uint32_t size = 0;
uint8_t *ptr;
ptr = (uint8_t *) Text;
/* Get the text size */
while (*ptr++) size++ ;
/* Characters number per line */
// xsize = (BSP_LCD_GetXSize() / DrawProp[ActiveLayer].pFont->Width);
switch (Mode)
{
case CENTER_MODE:
{
ll = DrawProp[ActiveLayer].pFont->Width * size;
ref_column = Xpos - (ll >> 1);
//if((ref_column + ll > 319) || (ref_column > 319))
// ref_column = Xpos + ((xsize - size)* DrawProp[ActiveLayer].pFont->Width) / 2;
break;
}
case LEFT_MODE:
{
ref_column = Xpos;
break;
}
case RIGHT_MODE:
{
ll = DrawProp[ActiveLayer].pFont->Width * size;
ref_column = Xpos - ll;
// ref_column = - Xpos + ((xsize - size)*DrawProp[ActiveLayer].pFont->Width);
break;
}
default:
{
ref_column = Xpos;
break;
}
}
/* Check that the Start column is located in the screen */
if ((ref_column < 1) || (ref_column >= 0x8000))
{
ref_column = 1;
}
/* Send the string character by character on LCD */
while ((*Text != 0) & (((BSP_LCD_GetXSize() - (i*DrawProp[ActiveLayer].pFont->Width)) & 0xFFFF) >= DrawProp[ActiveLayer].pFont->Width))
{
/* Display one character on LCD */
BSP_LCD_DisplayChar(ref_column, Ypos, *Text);
/* Decrement the column position by 16 */
ref_column += DrawProp[ActiveLayer].pFont->Width;
/* Point on the next character */
Text++;
i++;
}
}
/**
* @brief Displays a maximum of 60 characters on the LCD.
* @param Line: Line where to display the character shape
* @param ptr: Pointer to string to display on LCD
* @retval None
*/
void BSP_LCD_DisplayStringAtLine(uint16_t Line, char *ptr)
{
BSP_LCD_DisplayStringAt(0, LINE(Line), ptr, LEFT_MODE);
}
/**
* @brief Draws an horizontal line.
* @param Xpos: X position
* @param Ypos: Y position
* @param Length: Line length
* @retval None
*/
void BSP_LCD_DrawHLine(uint16_t Xpos, uint16_t Ypos, uint16_t Length)
{
uint32_t Xaddress = 0;
/* Get the line address */
if(hLtdcHandler.LayerCfg[ActiveLayer].PixelFormat == LTDC_PIXEL_FORMAT_RGB565)
{ /* RGB565 format */
Xaddress = (hLtdcHandler.LayerCfg[ActiveLayer].FBStartAdress) + 2*(BSP_LCD_GetXSize()*Ypos + Xpos);
}
else
{ /* ARGB8888 format */
Xaddress = (hLtdcHandler.LayerCfg[ActiveLayer].FBStartAdress) + 4*(BSP_LCD_GetXSize()*Ypos + Xpos);
}
/* Write line */
LL_FillBuffer(ActiveLayer, (uint32_t *)Xaddress, Length, 1, 0, DrawProp[ActiveLayer].TextColor);
}
/**
* @brief Draws a vertical line.
* @param Xpos: X position
* @param Ypos: Y position
* @param Length: Line length
* @retval None
*/
void BSP_LCD_DrawVLine(uint16_t Xpos, uint16_t Ypos, uint16_t Length)
{
uint32_t Xaddress = 0;
/* Get the line address */
if(hLtdcHandler.LayerCfg[ActiveLayer].PixelFormat == LTDC_PIXEL_FORMAT_RGB565)
{ /* RGB565 format */
Xaddress = (hLtdcHandler.LayerCfg[ActiveLayer].FBStartAdress) + 2*(BSP_LCD_GetXSize()*Ypos + Xpos);
}
else
{ /* ARGB8888 format */
Xaddress = (hLtdcHandler.LayerCfg[ActiveLayer].FBStartAdress) + 4*(BSP_LCD_GetXSize()*Ypos + Xpos);
}
/* Write line */
LL_FillBuffer(ActiveLayer, (uint32_t *)Xaddress, 1, Length, (BSP_LCD_GetXSize() - 1), DrawProp[ActiveLayer].TextColor);
}
void BSP_LCD_DrawVLineThick(uint16_t Xpos, uint16_t Ypos, uint16_t Length, uint16_t Thick)
{
uint32_t Xaddress = 0;
uint32_t thickness = (uint32_t) Thick;
uint32_t lx = 0, rx = 0;
uint32_t x = (uint32_t) Xpos;
uint32_t dx = (uint32_t) Thick;
if(thickness == 0)
thickness = 1;
if(thickness > 2)
{
lx = rx = thickness >> 1;
// rx = thickness - lx - 1;
if(lx > x)
lx = x;
if((x + rx) >= 320)
rx = 319 - x;
dx = ((x + rx) - (x - lx)) + 1;
x -= lx;
}
/* Get the line address */
if(hLtdcHandler.LayerCfg[ActiveLayer].PixelFormat == LTDC_PIXEL_FORMAT_RGB565)
{ /* RGB565 format */
Xaddress = (hLtdcHandler.LayerCfg[ActiveLayer].FBStartAdress) + 2*(BSP_LCD_GetXSize()*Ypos + x);
}
else
{ /* ARGB8888 format */
Xaddress = (hLtdcHandler.LayerCfg[ActiveLayer].FBStartAdress) + 4*(BSP_LCD_GetXSize()*Ypos + x);
}
/* Write line */
LL_FillBuffer(ActiveLayer, (uint32_t *)Xaddress, dx, Length, /*(BSP_LCD_GetXSize() - 1)*/x + rx, DrawProp[ActiveLayer].TextColor);
}
/**
* @brief Draws an uni-line (between two points).
* @param x1: Point 1 X position
* @param y1: Point 1 Y position
* @param x2: Point 2 X position
* @param y2: Point 2 Y position
* @retval None
*/
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, num_add = 0, num_pixels = 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;
num_add = deltay;
num_pixels = 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;
num_add = deltax;
num_pixels = deltay; /* There are more y-values than x-values */
}
for (curpixel = 0; curpixel <= num_pixels; curpixel++)
{
BSP_LCD_DrawPixel(x, y, DrawProp[ActiveLayer].TextColor); /* Draw the current pixel */
num += num_add; /* 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 Draws a rectangle.
* @param Xpos: X position
* @param Ypos: Y position
* @param Width: Rectangle width
* @param Height: Rectangle height
* @retval None
*/
void BSP_LCD_DrawRect(uint16_t Xpos, uint16_t Ypos, uint16_t Width, uint16_t Height)
{
BSP_LCD_DrawHLine(Xpos, Ypos, Width);
BSP_LCD_DrawVLine(Xpos, Ypos, Height);
BSP_LCD_DrawHLine(Xpos, (Ypos + Height), Width);
BSP_LCD_DrawVLine((Xpos + Width), Ypos, Height + 1);
}
/**
* @brief Draws a circle.
* @param Xpos: X position
* @param Ypos: Y position
* @param Radius: Circle radius
* @retval None
*/
void BSP_LCD_DrawCircle(uint16_t Xpos, uint16_t Ypos, uint16_t Radius)
{
int32_t decision; /* Decision Variable */
uint32_t current_x; /* Current X Value */
uint32_t current_y; /* Current Y Value */
decision = 3 - (Radius << 1);
current_x = 0;
current_y = Radius;
while (current_x <= current_y)
{
BSP_LCD_DrawPixel((Xpos + current_x), (Ypos - current_y), DrawProp[ActiveLayer].TextColor);
BSP_LCD_DrawPixel((Xpos - current_x), (Ypos - current_y), DrawProp[ActiveLayer].TextColor);
BSP_LCD_DrawPixel((Xpos + current_y), (Ypos - current_x), DrawProp[ActiveLayer].TextColor);
BSP_LCD_DrawPixel((Xpos - current_y), (Ypos - current_x), DrawProp[ActiveLayer].TextColor);
BSP_LCD_DrawPixel((Xpos + current_x), (Ypos + current_y), DrawProp[ActiveLayer].TextColor);
BSP_LCD_DrawPixel((Xpos - current_x), (Ypos + current_y), DrawProp[ActiveLayer].TextColor);
BSP_LCD_DrawPixel((Xpos + current_y), (Ypos + current_x), DrawProp[ActiveLayer].TextColor);
BSP_LCD_DrawPixel((Xpos - current_y), (Ypos + current_x), DrawProp[ActiveLayer].TextColor);
if (decision < 0)
{
decision += (current_x << 2) + 6;
}
else
{
decision += ((current_x - current_y) << 2) + 10;
current_y--;
}
current_x++;
}
}
/**
* @brief Draws an poly-line (between many points).
* @param Points: Pointer to the points array
* @param PointCount: Number of points
* @retval None
*/
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 Draws an ellipse on LCD.
* @param Xpos: X position
* @param Ypos: Y position
* @param XRadius: Ellipse X radius
* @param YRadius: Ellipse Y radius
* @retval None
*/
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 Draws a pixel on LCD.
* @param Xpos: X position
* @param Ypos: Y position
* @param RGB_Code: Pixel color in ARGB mode (8-8-8-8)
* @retval None
*/
void BSP_LCD_DrawPixel(uint16_t Xpos, uint16_t Ypos, uint32_t RGB_Code)
{
/* Write data value to all SDRAM memory */
if(hLtdcHandler.LayerCfg[ActiveLayer].PixelFormat == LTDC_PIXEL_FORMAT_RGB565)
{ /* RGB565 format */
*(__IO uint16_t*) (hLtdcHandler.LayerCfg[ActiveLayer].FBStartAdress + (2*(Ypos*BSP_LCD_GetXSize() + Xpos))) = COLOR24TO16(RGB_Code);
}
else
{ /* ARGB8888 format */
*(__IO uint32_t*) (hLtdcHandler.LayerCfg[ActiveLayer].FBStartAdress + (4*(Ypos*BSP_LCD_GetXSize() + Xpos))) = RGB_Code;
}
}
/**
* @brief Draws a bitmap picture loaded in the internal Flash in ARGB888 format (32 bits per pixel).
* @param Xpos: Bmp X position in the LCD
* @param Ypos: Bmp Y position in the LCD
* @param pbmp: Pointer to Bmp picture address in the internal Flash
* @retval None
*/
void BSP_LCD_DrawBitmap(uint32_t Xpos, uint32_t Ypos, uint8_t *pbmp)
{
uint32_t index = 0, width = 0, height = 0, bit_pixel = 0;
uint32_t address;
uint32_t input_color_mode = 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 */
bit_pixel = pbmp[28] + (pbmp[29] << 8);
/* Set the address */
address = hLtdcHandler.LayerCfg[ActiveLayer].FBStartAdress + (((BSP_LCD_GetXSize()*Ypos) + Xpos)*(4));
/* Get the layer pixel format */
if ((bit_pixel/8) == 4)
{
input_color_mode = CM_ARGB8888;
}
else if ((bit_pixel/8) == 2)
{
input_color_mode = CM_RGB565;
}
else
{
input_color_mode = CM_RGB888;
}
/* Bypass the bitmap header */
pbmp += (index + (width * (height - 1) * (bit_pixel/8)));
/* Convert picture to ARGB8888 pixel format */
for(index=0; index < height; index++)
{
/* Pixel format conversion */
LL_ConvertLineToARGB8888((uint32_t *)pbmp, (uint32_t *)address, width, input_color_mode);
/* Increment the source and destination buffers */
address+= (BSP_LCD_GetXSize()*4);
pbmp -= width*(bit_pixel/8);
}
}
/**
* @brief Draws a full rectangle.
* @param Xpos: X position
* @param Ypos: Y position
* @param Width: Rectangle width
* @param Height: Rectangle height
* @retval None
*/
void BSP_LCD_FillRect(uint16_t Xpos, uint16_t Ypos, uint16_t Width, uint16_t Height)
{
uint32_t x_address = 0;
/* Set the text color */
BSP_LCD_SetTextColor(DrawProp[ActiveLayer].TextColor);
/* Get the rectangle start address */
if(hLtdcHandler.LayerCfg[ActiveLayer].PixelFormat == LTDC_PIXEL_FORMAT_RGB565)
{ /* RGB565 format */
x_address = (hLtdcHandler.LayerCfg[ActiveLayer].FBStartAdress) + 2*(BSP_LCD_GetXSize()*Ypos + Xpos);
}
else
{ /* ARGB8888 format */
x_address = (hLtdcHandler.LayerCfg[ActiveLayer].FBStartAdress) + 4*(BSP_LCD_GetXSize()*Ypos + Xpos);
}
/* Fill the rectangle */
LL_FillBuffer(ActiveLayer, (uint32_t *)x_address, Width, Height, (BSP_LCD_GetXSize() - Width), DrawProp[ActiveLayer].TextColor);
}
/**
* @brief Draws a full circle.
* @param Xpos: X position
* @param Ypos: Y position
* @param Radius: Circle radius
* @retval None
*/
void BSP_LCD_FillCircle(uint16_t Xpos, uint16_t Ypos, uint16_t Radius)
{
int32_t decision; /* Decision Variable */
uint32_t current_x; /* Current X Value */
uint32_t current_y; /* Current Y Value */
decision = 3 - (Radius << 1);
current_x = 0;
current_y = Radius;
BSP_LCD_SetTextColor(DrawProp[ActiveLayer].TextColor);
while (current_x <= current_y)
{
if(current_y > 0)
{
BSP_LCD_DrawHLine(Xpos - current_y, Ypos + current_x, 2*current_y);
BSP_LCD_DrawHLine(Xpos - current_y, Ypos - current_x, 2*current_y);
}
if(current_x > 0)
{
BSP_LCD_DrawHLine(Xpos - current_x, Ypos - current_y, 2*current_x);
BSP_LCD_DrawHLine(Xpos - current_x, Ypos + current_y, 2*current_x);
}
if (decision < 0)
{
decision += (current_x << 2) + 6;
}
else
{
decision += ((current_x - current_y) << 2) + 10;
current_y--;
}
current_x++;
}
BSP_LCD_SetTextColor(DrawProp[ActiveLayer].TextColor);
BSP_LCD_DrawCircle(Xpos, Ypos, Radius);
}
/**
* @brief Draws a full poly-line (between many points).
* @param Points: Pointer to the points array
* @param PointCount: Number of points
* @retval None
*/
void BSP_LCD_FillPolygon(pPoint Points, uint16_t PointCount)
{
int16_t X = 0, Y = 0, X2 = 0, Y2 = 0, X_center = 0, Y_center = 0, X_first = 0, Y_first = 0, pixelX = 0, pixelY = 0, counter = 0;
uint16_t image_left = 0, image_right = 0, image_top = 0, image_bottom = 0;
image_left = image_right = Points->X;
image_top= image_bottom = Points->Y;
for(counter = 1; counter < PointCount; counter++)
{
pixelX = POLY_X(counter);
if(pixelX < image_left)
{
image_left = pixelX;
}
if(pixelX > image_right)
{
image_right = pixelX;
}
pixelY = POLY_Y(counter);
if(pixelY < image_top)
{
image_top = pixelY;
}
if(pixelY > image_bottom)
{
image_bottom = pixelY;
}
}
if(PointCount < 2)
{
return;
}
X_center = (image_left + image_right)/2;
Y_center = (image_bottom + image_top)/2;
X_first = Points->X;
Y_first = Points->Y;
while(--PointCount)
{
X = Points->X;
Y = Points->Y;
Points++;
X2 = Points->X;
Y2 = Points->Y;
FillTriangle(X, X2, X_center, Y, Y2, Y_center);
FillTriangle(X, X_center, X2, Y, Y_center, Y2);
FillTriangle(X_center, X2, X, Y_center, Y2, Y);
}
FillTriangle(X_first, X2, X_center, Y_first, Y2, Y_center);
FillTriangle(X_first, X_center, X2, Y_first, Y_center, Y2);
FillTriangle(X_center, X2, X_first, Y_center, Y2, Y_first);
}
/**
* @brief Draws a full ellipse.
* @param Xpos: X position
* @param Ypos: Y position
* @param XRadius: Ellipse X radius
* @param YRadius: Ellipse Y radius
* @retval None
*/
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);
}
void LCD_DisplayString(uint16_t X, uint16_t Line, char *ptr)
{
BSP_LCD_SetFont(&Font15);
BSP_LCD_DisplayStringAt(X, Line, ptr, LEFT_MODE);
/*uint16_t refcolumn = 320 - X - 1;
while ((*ptr != 0) & (((refcolumn + 1) & 0xFFFF) >= 12))
{
LCD_DisplayChar(Line, refcolumn, *ptr);
refcolumn -= 12;
ptr++;
}*/
}
void LCD_DisplayStringC(uint16_t X, uint16_t Y, char *ptr)
{
BSP_LCD_SetFont(&Font15);
BSP_LCD_DisplayStringAt(X, Y, ptr, CENTER_MODE);
/*uint16_t refcolumn;
uint32_t len = 0;
len = strlen(ptr);
refcolumn = 320 - (X - ((len*12) >> 1)) - 1;
while ((*ptr != 0) & (((refcolumn + 1) & 0xFFFF) >= 12))
{
LCD_DisplayChar(Y, refcolumn, *ptr);
refcolumn -= 12;
ptr++;
}*/
}
void LCD_DisplayStringR(uint16_t X, uint16_t Y, char *ptr)
{
BSP_LCD_SetFont(&Font15);
BSP_LCD_DisplayStringAt(X, Y, ptr, RIGHT_MODE);
/*uint16_t refcolumn;
uint32_t len = 0;
len = strlen(ptr);
refcolumn = 320 - (X - len*12) - 1;
while ((*ptr != 0) & (((refcolumn + 1) & 0xFFFF) >= 12))
{
LCD_DisplayChar(Y, refcolumn, *ptr);
refcolumn -= 12;
ptr++;
}*/
}
/*******************************************************************************
Static Functions
*******************************************************************************/
void LCD_DisplayChar(uint16_t Line, uint16_t Column, uint8_t Ascii)
{
Ascii -= 32;
LCD_DrawRusChar(Line, Column, &Font17_Table[Ascii * 17]);
}
/*
void LCD_DisplayChar(uint16_t Column, uint16_t Line, uint8_t Ascii)
{
Ascii -= 32;
LCD_DrawRusChar(Column, Line, &Font17_Table[Ascii * 17]);
}
*/
static void LCD_DrawRusChar(uint16_t Xpos, uint16_t Ypos, const uint16_t *c)
{
uint32_t index = 0, counter = 0, xpos = 0;
uint32_t Xaddress = 0;
uint16_t chr, b;
xpos = Xpos * (320 << 1);
Xaddress += (320 - Ypos - 1);
for(index = 0; index < 17; index++)
{
chr = SWAP_BITS(c[index]);
for(counter = 0; counter < 12; counter++)
{
b = 1 << counter;
if(!(chr & b))
*(__IO uint16_t *) (hLtdcHandler.LayerCfg[ActiveLayer].FBStartAdress + (Xaddress << 1) + xpos) = COLOR24TO16(DrawProp[ActiveLayer].BackColor);
else *(__IO uint16_t *) (hLtdcHandler.LayerCfg[ActiveLayer].FBStartAdress + (Xaddress << 1) + xpos) = COLOR24TO16(DrawProp[ActiveLayer].TextColor);
Xaddress++;
}
Xaddress += (320 - 12);
}
}
/**
* @brief Draws a character on LCD.
* @param Xpos: Line where to display the character shape
* @param Ypos: Start column address
* @param c: Pointer to the character data
* @retval None
*/
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;
//uint16_t b;
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++;
}
}
uint16_t SWAP_BITS(uint16_t a)
{
uint16_t i, j, out = 0;
for(i = 0, j = 15; i < 16; i++, j--)
if(a & (1 << i))
out |= (1 << j);
return out;
}
/**
* @brief Fills a triangle (between 3 points).
* @param x1: Point 1 X position
* @param y1: Point 1 Y position
* @param x2: Point 2 X position
* @param y2: Point 2 Y position
* @param x3: Point 3 X position
* @param y3: Point 3 Y position
* @retval None
*/
void 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, num_add = 0, num_pixels = 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;
num_add = deltay;
num_pixels = 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;
num_add = deltax;
num_pixels = deltay; /* There are more y-values than x-values */
}
for (curpixel = 0; curpixel <= num_pixels; curpixel++)
{
BSP_LCD_DrawLine(x, y, x3, y3);
num += num_add; /* 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 Fills a buffer.
* @param LayerIndex: Layer index
* @param pDst: Pointer to destination buffer
* @param xSize: Buffer width
* @param ySize: Buffer height
* @param OffLine: Offset
* @param ColorIndex: Color index
* @retval None
*/
static void LL_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 */
hDma2dHandler.Init.Mode = DMA2D_R2M;
if(hLtdcHandler.LayerCfg[ActiveLayer].PixelFormat == LTDC_PIXEL_FORMAT_RGB565)
hDma2dHandler.Init.ColorMode = DMA2D_RGB565;
else hDma2dHandler.Init.ColorMode = DMA2D_ARGB8888;
hDma2dHandler.Init.OutputOffset = OffLine;
hDma2dHandler.Instance = DMA2D;
if(HAL_DMA2D_Init(&hDma2dHandler) == HAL_OK)
{
if(HAL_DMA2D_ConfigLayer(&hDma2dHandler, LayerIndex) == HAL_OK)
{
if (HAL_DMA2D_Start(&hDma2dHandler, ColorIndex, (uint32_t)pDst, xSize, ySize) == HAL_OK)
{
HAL_DMA2D_PollForTransfer(&hDma2dHandler, 30);
}
}
}
}
/**
* @brief Converts a line to an ARGB8888 pixel format.
* @param pSrc: Pointer to source buffer
* @param pDst: Output color
* @param xSize: Buffer width
* @param ColorMode: Input color mode
* @retval None
*/
static void LL_ConvertLineToARGB8888(void *pSrc, void *pDst, uint32_t xSize, uint32_t ColorMode)
{
/* Configure the DMA2D Mode, Color Mode and output offset */
hDma2dHandler.Init.Mode = DMA2D_M2M_PFC;
hDma2dHandler.Init.ColorMode = DMA2D_ARGB8888;
hDma2dHandler.Init.OutputOffset = 0;
/* Foreground Configuration */
hDma2dHandler.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA;
hDma2dHandler.LayerCfg[1].InputAlpha = 0xFF;
hDma2dHandler.LayerCfg[1].InputColorMode = ColorMode;
hDma2dHandler.LayerCfg[1].InputOffset = 0;
hDma2dHandler.Instance = DMA2D;
/* DMA2D Initialization */
if(HAL_DMA2D_Init(&hDma2dHandler) == HAL_OK)
{
if(HAL_DMA2D_ConfigLayer(&hDma2dHandler, 1) == HAL_OK)
{
if (HAL_DMA2D_Start(&hDma2dHandler, (uint32_t)pSrc, (uint32_t)pDst, xSize, 1) == HAL_OK)
{
/* Polling For DMA transfer */
HAL_DMA2D_PollForTransfer(&hDma2dHandler, 30);
}
}
}
}
void DrawImage(const GUI_BITMAP * pBM, uint16_t x0, uint16_t y0)
{
//HAL_StatusTypeDef hal_status = HAL_OK;
uint32_t Xaddress = 0;
uint8_t * p;
uint16_t xSize = pBM->XSize;
uint16_t ySize = pBM->YSize;
//uint16_t BytesPerLine = pBM->BytesPerLine;
p = (uint8_t *) pBM->pData;
Xaddress = hLtdcHandler.LayerCfg[ActiveLayer].FBStartAdress + ((320 * y0 + x0) << 1);
hDma2dHandler.Init.Mode = DMA2D_M2M;
hDma2dHandler.Init.ColorMode = DMA2D_RGB565;
hDma2dHandler.Init.OutputOffset = 320 - xSize;
/* DMA2D Callbacks Configuration */
hDma2dHandler.XferCpltCallback = TransferComplete;
hDma2dHandler.XferErrorCallback = TransferError;
/* Foreground layer Configuration : layer 1 */
hDma2dHandler.LayerCfg[ActiveLayer].AlphaMode = DMA2D_NO_MODIF_ALPHA;
hDma2dHandler.LayerCfg[ActiveLayer].InputAlpha = 255; /* Alpha fully opaque */
hDma2dHandler.LayerCfg[ActiveLayer].InputColorMode = DMA2D_INPUT_RGB565; /* Layer 1 input format is ARGB8888 (32 bpp) */
hDma2dHandler.LayerCfg[ActiveLayer].InputOffset = 0; /* No offset in input */
hDma2dHandler.Instance = DMA2D;
/* DMA2D Initialization */
HAL_DMA2D_Init(&hDma2dHandler);
HAL_DMA2D_ConfigLayer(&hDma2dHandler, ActiveLayer);
DMA2D_TransferOk = 0;
HAL_DMA2D_Start(&hDma2dHandler, (uint32_t) p, Xaddress, xSize, ySize);
HAL_DMA2D_PollForTransfer(&hDma2dHandler, 30);
//SCB_CleanInvalidateDCache();
}
static void TransferComplete(DMA2D_HandleTypeDef *hdma2d)
{
DMA2D_TransferOk = 1;
}
static void TransferError(DMA2D_HandleTypeDef *hdma2d)
{
}
void LCD_Refresh(void)
{
ActiveLayer ^= 1;
RenderingLayer ^= 1;
BSP_LCD_SetLayerVisible_NoReload(ActiveLayer, DISABLE);
BSP_LCD_SetLayerVisible_NoReload(RenderingLayer, ENABLE);
HAL_LTDC_Reload(&hLtdcHandler, LTDC_RELOAD_IMMEDIATE);
//BSP_LCD_Reload(LCD_RELOAD_VERTICAL_BLANKING);
}
void HAL_LTDC_LineEventCallback(LTDC_HandleTypeDef *hltdc)
{
if(RefreshScreen)
{
LCD_Refresh();
RefreshScreen = false;
}
}
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
Reference in New Issue View Git Blame Copy Permalink