text: /**
    ******************************************************************************
    * @file    stm32072b_eval_lcd.c
    * @author  MCD Application Team
    * @version V1.0.1
    * @date    13-October-2021
    * @brief   This file includes the LCD driver for AM240320LGTNQW00H (HX8347-D) 
    *          Liquid Crystal Display Module of STM32072B-EVAL board.
    ******************************************************************************
    * @attention
    *
    * Copyright (c) 2014 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.
    *
    ******************************************************************************
    */
  
  /* Includes ------------------------------------------------------------------*/
  #include "stm32072b_eval_lcd.h"
  #include "../Common/fonts.c"
  
  /** @addtogroup Utilities
    * @{
    */
  
  /** @addtogroup STM32_EVAL
    * @{
    */ 
  
  /** @addtogroup STM32072B_EVAL
    * @{
    */
      
  /** @defgroup STM32072B_EVAL_LCD 
    * @brief   This file includes the LCD driver for AM240320LGTNQW00H (HX8347-D) 
    *          Liquid Crystal Display Module of STM32072B-EVAL board.
    * @{
    */ 
  
  /* Private typedef -----------------------------------------------------------*/
  /* Private define ------------------------------------------------------------*/
  #define LCD_HX8347D        0x0047
  
  #define START_BYTE         0x70
  #define SET_INDEX          0x00
  #define READ_STATUS        0x01
  #define LCD_WRITE_REG      0x02
  #define LCD_READ_REG       0x03
  #define MAX_POLY_CORNERS   200
  
  #define POLY_Y(Z)          ((int32_t)((Points + (Z))->X))
  #define POLY_X(Z)          ((int32_t)((Points + (Z))->Y))
  
  /* Private macro -------------------------------------------------------------*/
  #define ABS(X)  ((X) > 0 ? (X) : -(X))
  
  /* Private variables ---------------------------------------------------------*/
  static sFONT *LCD_Currentfonts;
  /* Global variables to set the written text color */
  static __IO uint16_t TextColor = 0x0000, BackColor = 0xFFFF;
  
  /* Private function prototypes -----------------------------------------------*/
  #ifndef USE_Delay
   static void delay(__IO uint32_t nCount);
  #endif /* USE_Delay*/
  
  static void PutPixel(int16_t x, int16_t y);
  static void LCD_PolyLineRelativeClosed(pPoint Points, uint16_t PointCount, uint16_t Closed);
  
  /* Private functions ---------------------------------------------------------*/
  
  /** @defgroup STM32072B_EVAL_LCD_Private_Functions
    * @{
    */ 
  
  /**
    * @brief  DeInitializes the LCD.
    * @param  None
    * @retval None
    */
  void LCD_DeInit(void)
  {
    GPIO_InitTypeDef GPIO_InitStructure;
  
    /* LCD Display Off */
    LCD_DisplayOff();
  
    /* LCD_SPI disable */
    SPI_Cmd(LCD_SPI, DISABLE);
    
    /* LCD_SPI DeInit */
    SPI_I2S_DeInit(LCD_SPI);
     
    /* Disable SPI clock  */
    RCC_APB1PeriphClockCmd(LCD_SPI_CLK, DISABLE);
  
    /* Configure NCS in Output Push-Pull mode */
    GPIO_InitStructure.GPIO_Pin = LCD_NCS_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
    GPIO_Init(LCD_NCS_GPIO_PORT, &GPIO_InitStructure);
    
       
    /* Configure SPI pins: SCK, MISO and MOSI */
    GPIO_InitStructure.GPIO_Pin = LCD_SPI_SCK_PIN;
    GPIO_Init(LCD_SPI_SCK_GPIO_PORT, &GPIO_InitStructure);
  
    GPIO_InitStructure.GPIO_Pin = LCD_SPI_MISO_PIN;
    GPIO_Init(LCD_SPI_MISO_GPIO_PORT, &GPIO_InitStructure);
    
    GPIO_InitStructure.GPIO_Pin = LCD_SPI_MOSI_PIN;
    GPIO_Init(LCD_SPI_MOSI_GPIO_PORT, &GPIO_InitStructure);
  }
  
  /**
    * @brief  Setup the LCD for the HX8347D Controller.
    * @param  None
    * @retval None
    */
  void LCD_Setup(void)
  { 
      /* Driving ability setting */
      LCD_WriteReg(LCD_REG_234, 0x00);
      LCD_WriteReg(LCD_REG_235, 0x20);
      LCD_WriteReg(LCD_REG_236, 0x0C);
      LCD_WriteReg(LCD_REG_237, 0xC4);
      LCD_WriteReg(LCD_REG_232, 0x40);
      LCD_WriteReg(LCD_REG_233, 0x38);
      LCD_WriteReg(LCD_REG_241, 0x01); /* RGB 18-bit interface ;0x0110 */
      LCD_WriteReg(LCD_REG_242, 0x10);
      LCD_WriteReg(LCD_REG_39, 0xA3);
  
      /* Adjust the Gamma Curve */
      LCD_WriteReg(LCD_REG_64, 0x01);
      LCD_WriteReg(LCD_REG_65, 0x00);
      LCD_WriteReg(LCD_REG_66, 0x00);
      LCD_WriteReg(LCD_REG_67, 0x10);
      LCD_WriteReg(LCD_REG_68, 0x0E);
      LCD_WriteReg(LCD_REG_69, 0x24);
      LCD_WriteReg(LCD_REG_70, 0x04);
      LCD_WriteReg(LCD_REG_71, 0x50);
      LCD_WriteReg(LCD_REG_72, 0x02);
      LCD_WriteReg(LCD_REG_73, 0x13);
      LCD_WriteReg(LCD_REG_74, 0x19);
      LCD_WriteReg(LCD_REG_75, 0x19);
      LCD_WriteReg(LCD_REG_76, 0x16);
  
      LCD_WriteReg(LCD_REG_80, 0x1B);
      LCD_WriteReg(LCD_REG_81, 0x31);
      LCD_WriteReg(LCD_REG_82, 0x2F);
      LCD_WriteReg(LCD_REG_83, 0x3F);
      LCD_WriteReg(LCD_REG_84, 0x3F);
      LCD_WriteReg(LCD_REG_85, 0x3E);
      LCD_WriteReg(LCD_REG_86, 0x2F);
      LCD_WriteReg(LCD_REG_87, 0x7B);
      LCD_WriteReg(LCD_REG_88, 0x09);
      LCD_WriteReg(LCD_REG_89, 0x06);
      LCD_WriteReg(LCD_REG_90, 0x06);
      LCD_WriteReg(LCD_REG_91, 0x0C);
      LCD_WriteReg(LCD_REG_92, 0x1D);
      LCD_WriteReg(LCD_REG_93, 0xCC);
  
      /* Power voltage setting */
      LCD_WriteReg(LCD_REG_27, 0x1B);
      LCD_WriteReg(LCD_REG_26, 0x01);
      LCD_WriteReg(LCD_REG_36, 0x2F);
      LCD_WriteReg(LCD_REG_37, 0x57);
      /*****VCOM offset ****/
      LCD_WriteReg(LCD_REG_35, 0x86);
    
      /* Power on setting */
      LCD_WriteReg(LCD_REG_24, 0x36); /* Display frame rate:75Hz(2.85MHz X 117%) */
      LCD_WriteReg(LCD_REG_25, 0x01); /* Internal oscillator start to oscillate */
      LCD_WriteReg(LCD_REG_1,0x00);
      LCD_WriteReg(LCD_REG_31, 0x88); /* Step-up Circuit 1 on,open abnormal power-off monitor */
      _delay_(2);
      LCD_WriteReg(LCD_REG_31, 0x80); /* Step-up Circuit 1 off */
      _delay_(2);
      LCD_WriteReg(LCD_REG_31, 0x90); /* VCOML voltage can output to negative voltage,
                                  (1.0V ~ VCL+0.5V) */
      _delay_(2);
      LCD_WriteReg(LCD_REG_31, 0xD0); /* Step-up Circuit 2 on */
      _delay_(2);
  
      LCD_WriteReg(LCD_REG_23, 0x05);  /* COLMOD control */
  
      /* Set GRAM Area - Partial Display Control */
      LCD_WriteReg(LCD_REG_1, 0x00); /* Scroll off */
  
      LCD_WriteReg(LCD_REG_2, 0x00);
      LCD_WriteReg(LCD_REG_3, 0x00);
      LCD_WriteReg(LCD_REG_4, 0x01); /* X,Y swap */
      LCD_WriteReg(LCD_REG_5, 0x3F); /* X,Y swap */
  
      LCD_WriteReg(LCD_REG_6, 0x00);
      LCD_WriteReg(LCD_REG_7, 0x00);
      LCD_WriteReg(LCD_REG_8, 0x00); /* X,Y swap */
      LCD_WriteReg(LCD_REG_9, 0xEF); /* X,Y swap */
  
      /* Memory access control */
      /* bit7 controls left,right swap(X) */
      /* bit6 controls up,down swap(Y) */
      /* bit5 controls X,Y swap */
      LCD_WriteReg(LCD_REG_22, 0x28);
  
      /* SET PANEL */
      LCD_WriteReg(LCD_REG_54, 0x00); /* Panel characteristic control */
      LCD_WriteReg(LCD_REG_54, 0x04); /* Panel characteristic control: gate driver shift reverse[work] */
      LCD_WriteReg(LCD_REG_40, 0x38); /* Display control3: source output->PT(0,0) */
      _delay_(6);
      LCD_WriteReg(LCD_REG_40, 0x3C); /* Display control3: source output->Display */
  }
  
  /**
    * @brief  Initializes the LCD.
    * @param  None
    * @retval None
    */
  void STM32072B_LCD_Init(void)
  {
    /* Configure the LCD Control pins ------------------------------------------*/
    LCD_CtrlLinesConfig();
    
    /* Configure the LCD_SPI interface -----------------------------------------*/
    LCD_SPIConfig();
  
    LCD_Setup();
  
    LCD_SetFont(&LCD_DEFAULT_FONT);
  }
  
  /**
    * @brief  Sets the LCD Text and Background colors.
    * @param  _TextColor: specifies the Text Color.
    * @param  _BackColor: specifies the Background Color.
    * @retval None
    */
  void LCD_SetColors(__IO uint16_t _TextColor, __IO uint16_t _BackColor)
  {
    TextColor = _TextColor; 
    BackColor = _BackColor;
  }
  
  /**
    * @brief  Gets the LCD Text and Background colors.
    * @param  _TextColor: pointer to the variable that will contain the Text 
              Color.
    * @param  _BackColor: pointer to the variable that will contain the Background 
              Color.
    * @retval None
    */
  void LCD_GetColors(__IO uint16_t *_TextColor, __IO uint16_t *_BackColor)
  {
    *_TextColor = TextColor; *_BackColor = BackColor;
  }
  
  /**
    * @brief  Sets the Text color.
    * @param  Color: specifies the Text color code RGB(5-6-5).
    * @retval None
    */
  void LCD_SetTextColor(__IO uint16_t Color)
  {
    TextColor = Color;
  }
  
  
  /**
    * @brief  Sets the Background color.
    * @param  Color: specifies the Background color code RGB(5-6-5).
    * @retval None
    */
  void LCD_SetBackColor(__IO uint16_t Color)
  {
    BackColor = Color;
  }
  
  /**
    * @brief  Sets the Text Font.
    * @param  fonts: specifies the font to be used.
    * @retval None
    */
  void LCD_SetFont(sFONT *fonts)
  {
    LCD_Currentfonts = fonts;
  }
  
  /**
    * @brief  Gets the Text Font.
    * @param  None.
    * @retval the used font.
    */
  sFONT *LCD_GetFont(void)
  {
    return LCD_Currentfonts;
  }
  
  /**
    * @brief  Clears the selected line.
    * @param  Line: the Line to be cleared.
    *         This parameter can be one of the following values:
    *              @arg LCD_LINE_x: where x can be 0..29
    * @retval None
    */
  void LCD_ClearLine(uint16_t Line)
  {
    uint16_t refcolumn = LCD_PIXEL_WIDTH - 1;
    
    /* Send the string character by character on LCD */
    while (((refcolumn + 1) & 0xFFFF) >= LCD_Currentfonts->Width)
    {
      /* Display one character on LCD */
      LCD_DisplayChar(Line, refcolumn, ' ');
      /* Decrement the column position by 16 */
      refcolumn -= LCD_Currentfonts->Width;
    }   
  }
  
  
  /**
    * @brief  Clears the whole LCD.
    * @param  Color: the color of the background.
    * @retval None
    */
  void LCD_Clear(uint16_t Color)
  {
    uint32_t index = 0;
    
    LCD_SetCursor(0x00, 0x0000);
    LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */
    for(index = 0; index < 76800; index++)
    {
      LCD_WriteRAM(Color);
    }
    LCD_CtrlLinesWrite(LCD_NCS_GPIO_PORT, LCD_NCS_PIN, Bit_SET);   
  }
  
  
  /**
    * @brief  Sets the cursor position.
    * @param  Xpos: specifies the X position, can be a value from 0 to 239
    * @param  Ypos: specifies the Y position, can be a value from 0 to 319 
    * @retval None
    */
  void LCD_SetCursor(uint16_t Xpos, uint16_t Ypos)
  {
    LCD_WriteReg(LCD_REG_2, Ypos >> 8);
    LCD_WriteReg(LCD_REG_3, Ypos & 0xFF);
    LCD_WriteReg(LCD_REG_6, 0x00);
    LCD_WriteReg(LCD_REG_7, Xpos);
   }
  
  
  /**
    * @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.
    * @retval None
    */
  void LCD_DrawChar(uint16_t Xpos, uint16_t Ypos, const uint16_t *c)
  {
    uint32_t index = 0, i = 0;
    uint16_t Xaddress = 0;
     
    Xaddress = Xpos;
    
    LCD_SetCursor(Xaddress, Ypos);
    
    for(index = 0; index < LCD_Currentfonts->Height; index++)
    {
      LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */
      for(i = 0; i < LCD_Currentfonts->Width; i++)
      {
        if((((c[index] & ((0x80 << ((LCD_Currentfonts->Width / 12 ) * 8 ) ) >> i)) == 0x00) &&(LCD_Currentfonts->Width <= 12))||
          (((c[index] & (0x1 << i)) == 0x00)&&(LCD_Currentfonts->Width > 12 )))
  
        {
          LCD_WriteRAM(BackColor);
        }
        else
        {
          LCD_WriteRAM(TextColor);
        }
      }
      LCD_CtrlLinesWrite(LCD_NCS_GPIO_PORT, LCD_NCS_PIN, Bit_SET);
      Xaddress++;
      LCD_SetCursor(Xaddress, Ypos);
    }
  }
  
  /**
    * @brief  Displays one character.
    * @param  Line: the Line where to display the character shape .
    *          This parameter can be one of the following values:
    *            @arg LCD_LINE_x: where x can be 0..29
    * @param  Column: start column address.
    * @param  Ascii: character ascii code, must be between 0x20 and 0x7E.
    * @retval None
    */
  void LCD_DisplayChar(uint16_t Line, uint16_t Column, uint8_t Ascii)
  {
    Ascii -= 32;
    
    Column = 319 - Column;
    
    LCD_DrawChar(Line, Column, &LCD_Currentfonts->table[Ascii * LCD_Currentfonts->Height]);
  }
  
  
  /**
    * @brief  Displays a list of char on the LCD.
    * @param  Line: the Line where to display the character shape .
    *          This parameter can be one of the following values:
    *            @arg LCD_LINE_x: where x can be 0..29
    * @param  *ptr: pointer to string to display on LCD.
    * @retval None
    */
  void LCD_DisplayStringLine(uint16_t Line, uint8_t *ptr)
  {
    uint16_t refcolumn = LCD_PIXEL_WIDTH - 1;
  
    /* Send the string character by character on lCD */
    while ((*ptr != 0) & (((refcolumn + 1) & 0xFFFF) >= LCD_Currentfonts->Width))
    {
      /* Display one character on LCD */
      LCD_DisplayChar(Line, refcolumn, *ptr);
      /* Decrement the column position by 16 */
      refcolumn -= LCD_Currentfonts->Width;
      /* Point on the next character */
      ptr++;
    }
  }
  
  
  /**
    * @brief  Sets a display window
    * @param  Xpos: specifies the X buttom left position.
    * @param  Ypos: specifies the Y buttom left position.
    * @param  Height: display window height.
    * @param  Width: display window width.
    * @retval None
    */
  void LCD_SetDisplayWindow(uint16_t Xpos, uint16_t Ypos, uint8_t Height, uint16_t Width)
  {
    LCD_WriteReg(LCD_REG_2, (319 - Ypos) >> 8); /* SC */
    LCD_WriteReg(LCD_REG_3, (319 - Ypos) & 0xFF); /* SC */
  
    LCD_WriteReg(LCD_REG_4, (319 - (Ypos - Width + 1)) >> 8); /* EC */
    LCD_WriteReg(LCD_REG_5, (319 - (Ypos - Width + 1)) & 0xFF); /* EC */
  
    LCD_WriteReg(LCD_REG_6, 0x0); /* SP */
    LCD_WriteReg(LCD_REG_7, (239 - Xpos) & 0xFF); /* SP */
  
    LCD_WriteReg(LCD_REG_8, 0x0); /* EP */
    LCD_WriteReg(LCD_REG_9, (239 - (Xpos - Height + 1)) & 0xFF); /* EP */
    LCD_SetCursor(Xpos, Ypos);
    
    LCD_SetCursor(Xpos, Ypos);
  }
  
  /**
    * @brief  Disables LCD Window mode.
    * @param  None
    * @retval None
    */
  void LCD_WindowModeDisable(void)
  {
    LCD_SetDisplayWindow(239, 0x13F, 240, 320);
  }
  
  /**
    * @brief  Displays a line.
    * @param  Xpos: specifies the X position, can be a value from 0 to 239
    * @param  Ypos: specifies the Y position, can be a value from 0 to 319
    * @param  Length: line length.
    * @param  Direction: line direction.
    *          This parameter can be one of the following values: 
    *          LCD_DIR_HORIZONTAL or LCD_DIR_VERTICAL.
    * @retval None
    */
  void LCD_DrawLine(uint16_t Xpos, uint16_t Ypos, uint16_t Length, uint8_t Direction)
  {
    uint32_t i = 0;
  
    Ypos = (LCD_PIXEL_WIDTH - 1) - Ypos;
  
    LCD_SetCursor(Xpos, Ypos);
    
    if(Direction == LCD_DIR_HORIZONTAL)
    { 
      LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */
      for(i = 0; i < Length; i++)
      {
        LCD_WriteRAM(TextColor);
      }
      LCD_CtrlLinesWrite(LCD_NCS_GPIO_PORT, LCD_NCS_PIN, Bit_SET);
    }
    else
    {
     for(i = 0; i < Length; i++)
      {
        LCD_WriteRAMWord(TextColor);
        Xpos++;
        LCD_SetCursor(Xpos, Ypos);
      }
    }
  }
  
  /**
    * @brief  Displays a rectangle.
    * @param  Xpos: specifies the X position, can be a value from 0 to 239
    * @param  Ypos: specifies the Y position, can be a value from 0 to 319
    * @param  Height: display rectangle height.
    * @param  Width: display rectangle width.
    * @retval None
    */
  void LCD_DrawRect(uint16_t Xpos, uint16_t Ypos, uint8_t Height, uint16_t Width)
  {
     
    LCD_DrawLine(Xpos, Ypos, Width, LCD_DIR_HORIZONTAL);
    LCD_DrawLine((Xpos + Height), Ypos, Width, LCD_DIR_HORIZONTAL);
    
    LCD_DrawLine(Xpos, Ypos, Height, LCD_DIR_VERTICAL);
    LCD_DrawLine(Xpos, (Ypos - Width + 1), Height, LCD_DIR_VERTICAL);
  }
  
  /**
    * @brief  Displays a circle.
    * @param  Xpos: specifies the X position, can be a value from 0 to 239
    * @param  Ypos: specifies the Y position, can be a value from 0 to 319
    * @param  Radius
    * @retval None
    */
  void 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 */ 
    Ypos = (LCD_PIXEL_WIDTH - 1) - Ypos;
   
    D = 3 - (Radius << 1);
    CurX = 0;
    CurY = Radius;
    
    while (CurX <= CurY)
    {
      LCD_SetCursor(Xpos + CurX, Ypos + CurY);
      LCD_WriteRAMWord(TextColor);
      LCD_SetCursor(Xpos + CurX, Ypos - CurY);
  
      LCD_WriteRAMWord(TextColor);
      LCD_SetCursor(Xpos - CurX, Ypos + CurY);
  
      LCD_WriteRAMWord(TextColor);
      LCD_SetCursor(Xpos - CurX, Ypos - CurY);
  
  
      LCD_WriteRAMWord(TextColor);
      LCD_SetCursor(Xpos + CurY, Ypos + CurX);
      
      LCD_WriteRAMWord(TextColor);
      LCD_SetCursor(Xpos + CurY, Ypos - CurX);
  
      LCD_WriteRAMWord(TextColor);
      LCD_SetCursor(Xpos - CurY, Ypos + CurX);
  
      LCD_WriteRAMWord(TextColor);
      LCD_SetCursor(Xpos - CurY, Ypos - CurX);
  
      LCD_WriteRAMWord(TextColor);
      if (D < 0)
      { 
        D += (CurX << 2) + 6;
      }
      else
      {
        D += ((CurX - CurY) << 2) + 10;
        CurY--;
      }
      CurX++;
    }
  }
  
  /**
    * @brief  Displays a monocolor picture.
    * @param  Pict: pointer to the picture array.
    * @retval None
    */
  void LCD_DrawMonoPict(const uint32_t *Pict)
  {
    uint32_t index = 0, i = 0;
    
    LCD_SetCursor(0, 0); 
     
    LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */
  
    for(index = 0; index < 2400; index++)
    {
      for(i = 0; i < 32; i++)
      {
        if((Pict[index] & (1 << i)) == 0x00)
        {
          LCD_WriteRAM(BackColor);
        }
        else
        {
          LCD_WriteRAM(TextColor);
        }
      }
    }
  
    LCD_CtrlLinesWrite(LCD_NCS_GPIO_PORT, LCD_NCS_PIN, Bit_SET);
  }
  
  /**
    * @brief  Displays a full rectangle.
    * @param  Xpos: specifies the X position, can be a value from 0 to 239
    * @param  Ypos: specifies the Y position, can be a value from 0 to 319
    * @param  Height: rectangle height.
    * @param  Width: rectangle width.
    * @retval None
    */
  void LCD_DrawFullRect(uint16_t Xpos, uint16_t Ypos, uint16_t Width, uint16_t Height)
  {
    LCD_SetTextColor(TextColor);
  
    LCD_DrawLine(Xpos, Ypos, Width, LCD_DIR_HORIZONTAL);
    LCD_DrawLine((Xpos + Height), Ypos, Width, LCD_DIR_HORIZONTAL);
    
    LCD_DrawLine(Xpos, Ypos, Height, LCD_DIR_VERTICAL);
    LCD_DrawLine(Xpos, (Ypos - Width + 1), Height, LCD_DIR_VERTICAL);
  
    Width -= 2;
    Height--;
    Ypos--;
  
    LCD_SetTextColor(BackColor);
  
    while(Height--)
    {
      LCD_DrawLine(++Xpos, Ypos, Width, LCD_DIR_HORIZONTAL);    
    }
  
    LCD_SetTextColor(TextColor);
  }
  
  /**
    * @brief  Displays a full circle.
    * @param  Xpos: specifies the X position, can be a value from 0 to 239
    * @param  Ypos: specifies the Y position, can be a value from 0 to 319
    * @param  Radius: radius of the circle.
    * @retval None
    */
  void LCD_DrawFullCircle(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;
    
    LCD_SetTextColor(BackColor);
  
    while (CurX <= CurY)
    {
      if(CurY > 0) 
      {
        LCD_DrawLine(Xpos - CurX, Ypos + CurY, 2*CurY, LCD_DIR_HORIZONTAL);
        LCD_DrawLine(Xpos + CurX, Ypos + CurY, 2*CurY, LCD_DIR_HORIZONTAL);
      }
  
      if(CurX > 0) 
      {
        LCD_DrawLine(Xpos - CurY, Ypos + CurX, 2*CurX, LCD_DIR_HORIZONTAL);
        LCD_DrawLine(Xpos + CurY, Ypos + CurX, 2*CurX, LCD_DIR_HORIZONTAL);
      }
      if (D < 0)
      { 
        D += (CurX << 2) + 6;
      }
      else
      {
        D += ((CurX - CurY) << 2) + 10;
        CurY--;
      }
      CurX++;
    }
  
    LCD_SetTextColor(TextColor);
    LCD_DrawCircle(Xpos, Ypos, Radius);
  }
  
  /**
    * @brief  Displays an uni line (between two points).
    * @param  x1: specifies the point 1 x position.
    * @param  y1: specifies the point 1 y position.
    * @param  x2: specifies the point 2 x position.
    * @param  y2: specifies the point 2 y position.
    * @retval None
    */
  void LCD_DrawUniLine(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++)
    {
      PutPixel(x, y);             /* 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 an polyline (between many points).
    * @param  Points: pointer to the points array.
    * @param  PointCount: Number of points.
    * @retval None
    */
  void LCD_PolyLine(pPoint Points, uint16_t PointCount)
  {
    int16_t X = 0, Y = 0;
  
    if(PointCount < 2)
    {
      return;
    }
  
    while(--PointCount)
    {
      X = Points->X;
      Y = Points->Y;
      Points++;
      LCD_DrawUniLine(X, Y, Points->X, Points->Y);
    }
  }
  
  /**
    * @brief  Displays an relative polyline (between many points).
    * @param  Points: pointer to the points array.
    * @param  PointCount: Number of points.
    * @param  Closed: specifies if the draw is closed or not.
    *           1: closed, 0 : not closed.
    * @retval None
    */
  static void LCD_PolyLineRelativeClosed(pPoint Points, uint16_t PointCount, uint16_t Closed)
  {
    int16_t X = 0, Y = 0;
    pPoint First = Points;
  
    if(PointCount < 2)
    {
      return;
    }  
    X = Points->X;
    Y = Points->Y;
    while(--PointCount)
    {
      Points++;
      LCD_DrawUniLine(X, Y, X + Points->X, Y + Points->Y);
      X = X + Points->X;
      Y = Y + Points->Y;
    }
    if(Closed)
    {
      LCD_DrawUniLine(First->X, First->Y, X, Y);
    }  
  }
  
  /**
    * @brief  Displays a closed polyline (between many points).
    * @param  Points: pointer to the points array.
    * @param  PointCount: Number of points.
    * @retval None
    */
  void LCD_ClosedPolyLine(pPoint Points, uint16_t PointCount)
  {
    LCD_PolyLine(Points, PointCount);
    LCD_DrawUniLine(Points->X, Points->Y, (Points+PointCount-1)->X, (Points+PointCount-1)->Y);
  }
  
  /**
    * @brief  Displays a relative polyline (between many points).
    * @param  Points: pointer to the points array.
    * @param  PointCount: Number of points.
    * @retval None
    */
  void LCD_PolyLineRelative(pPoint Points, uint16_t PointCount)
  {
    LCD_PolyLineRelativeClosed(Points, PointCount, 0);
  }
  
  /**
    * @brief  Displays a closed relative polyline (between many points).
    * @param  Points: pointer to the points array.
    * @param  PointCount: Number of points.
    * @retval None
    */
  void LCD_ClosedPolyLineRelative(pPoint Points, uint16_t PointCount)
  {
    LCD_PolyLineRelativeClosed(Points, PointCount, 1);
  }
  
  
  /**
    * @brief  Displays a  full polyline (between many points).
    * @param  Points: pointer to the points array.
    * @param  PointCount: Number of points.
    * @retval None
    */
  void LCD_FillPolyLine(pPoint Points, uint16_t PointCount)
  {
    /*  public-domain code by Darel Rex Finley, 2007 */
    uint16_t  nodes = 0, nodeX[MAX_POLY_CORNERS], pixelX = 0, pixelY = 0, i = 0,
    j = 0, swap = 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(i = 1; i < PointCount; i++)
    {
      pixelX = POLY_X(i);
      if(pixelX < IMAGE_LEFT)
      {
        IMAGE_LEFT = pixelX;
      }
      if(pixelX > IMAGE_RIGHT)
      {
        IMAGE_RIGHT = pixelX;
      }
      
      pixelY = POLY_Y(i);
      if(pixelY < IMAGE_TOP)
      { 
        IMAGE_TOP = pixelY;
      }
      if(pixelY > IMAGE_BOTTOM)
      {
        IMAGE_BOTTOM = pixelY;
      }
    }
    
    LCD_SetTextColor(BackColor);  
  
    /*  Loop through the rows of the image. */
    for (pixelY = IMAGE_TOP; pixelY < IMAGE_BOTTOM; pixelY++) 
    {  
      /* Build a list of nodes. */
      nodes = 0; j = PointCount-1;
  
      for (i = 0; i < PointCount; i++) 
      {
        if (((POLY_Y(i)<(double) pixelY) && (POLY_Y(j)>=(double) pixelY)) || \
            ((POLY_Y(j)<(double) pixelY) && (POLY_Y(i)>=(double) pixelY)))
        {
          nodeX[nodes++]=(int) (POLY_X(i)+((pixelY-POLY_Y(i))*(POLY_X(j)-POLY_X(i)))/(POLY_Y(j)-POLY_Y(i))); 
        }
        j = i; 
      }
    
      /* Sort the nodes, via a simple "Bubble" sort. */
      i = 0;
      while (i < nodes-1) 
      {
        if (nodeX[i]>nodeX[i+1]) 
        {
          swap = nodeX[i]; 
          nodeX[i] = nodeX[i+1]; 
          nodeX[i+1] = swap; 
          if(i)
          {
            i--; 
          }
        }
        else 
        {
          i++;
        }
      }
    
      /*  Fill the pixels between node pairs. */
      for (i = 0; i < nodes; i+=2) 
      {
        if(nodeX[i] >= IMAGE_RIGHT) 
        {
          break;
        }
        if(nodeX[i+1] > IMAGE_LEFT) 
        {
          if (nodeX[i] < IMAGE_LEFT)
          {
            nodeX[i]=IMAGE_LEFT;
          }
          if(nodeX[i+1] > IMAGE_RIGHT)
          {
            nodeX[i+1] = IMAGE_RIGHT;
          }
          LCD_SetTextColor(BackColor);
          LCD_DrawLine(pixelY, nodeX[i+1], nodeX[i+1] - nodeX[i], LCD_DIR_HORIZONTAL);
          LCD_SetTextColor(TextColor);
          PutPixel(pixelY, nodeX[i+1]);
          PutPixel(pixelY, nodeX[i]);
          /* for (j=nodeX[i]; j<nodeX[i+1]; j++) PutPixel(j,pixelY); */
        }
      }
    } 
  
    /* draw the edges */
    LCD_SetTextColor(TextColor);
  }
  
  /**
    * @brief  Reset LCD control line(/CS) and Send Start-Byte
    * @param  Start_Byte: the Start-Byte to be sent
    * @retval None
    */
  void LCD_nCS_StartByte(uint8_t Start_Byte)
  {
    LCD_CtrlLinesWrite(LCD_NCS_GPIO_PORT, LCD_NCS_PIN, Bit_RESET);
  
    /* Wait until the transmit buffer is empty */ 
    while(SPI_I2S_GetFlagStatus(LCD_SD_SPI, SPI_I2S_FLAG_TXE) != SET)
    {
    }  
    /* Send the byte */
    SPI_SendData8(LCD_SPI, Start_Byte);
    
    while(SPI_I2S_GetFlagStatus(LCD_SPI, SPI_I2S_FLAG_BSY) != RESET)
    {
    }
  }
  
  /**
    * @brief  Writes index to select the LCD register.
    * @param  LCD_Reg: address of the selected register.
    * @retval None
    */
  void LCD_WriteRegIndex(uint8_t LCD_Reg)
  {
    /* Reset LCD control line(/CS) and Send Start-Byte */
    LCD_nCS_StartByte(START_BYTE | SET_INDEX);
  
    /* Write 16-bit Reg Index (High Byte is 0) */
    STM_SPI_WriteRead(0x00);
    
    STM_SPI_WriteRead(LCD_Reg);
  
    LCD_CtrlLinesWrite(LCD_NCS_GPIO_PORT, LCD_NCS_PIN, Bit_SET);
  }
  
  /**
    * @brief  Prepare to write to the LCD RAM.
    * @param  None
    * @retval None
    */
  void LCD_WriteRAM_Prepare(void)
  {
    LCD_WriteRegIndex(LCD_REG_34); /* Select GRAM Reg */
  
    /* Reset LCD control line(/CS) and Send Start-Byte */
    LCD_nCS_StartByte(START_BYTE | LCD_WRITE_REG);  
  }
  
  /**
    * @brief  Writes 1 word to the LCD RAM.
    * @param  RGB_Code: the pixel color in RGB mode (5-6-5).
    * @retval None
    */
  void LCD_WriteRAMWord(uint16_t RGB_Code)
  {
    LCD_WriteRAM_Prepare();
  
    LCD_WriteRAM(RGB_Code);
  
    LCD_CtrlLinesWrite(LCD_NCS_GPIO_PORT, LCD_NCS_PIN, Bit_SET);
  }
  
  /**
    * @brief  Writes to the selected LCD register.
    * @param  LCD_Reg: address of the selected register.
    * @param  LCD_RegValue: value to write to the selected register.
    * @retval None
    */
  void LCD_WriteReg(uint8_t LCD_Reg, uint16_t LCD_RegValue)
  {
    /* Write 16-bit Index (then Write Reg) */
    LCD_WriteRegIndex(LCD_Reg);
  
    /* Write 16-bit Reg */
    /* Reset LCD control line(/CS) and Send Start-Byte */
    LCD_nCS_StartByte(START_BYTE | LCD_WRITE_REG);
    STM_SPI_WriteRead(LCD_RegValue>>8);
    STM_SPI_WriteRead(LCD_RegValue & 0xFF);
    LCD_CtrlLinesWrite(LCD_NCS_GPIO_PORT, LCD_NCS_PIN, Bit_SET);
  }
  
  /**
    * @brief  Writes to the LCD RAM.
    * @param  RGB_Code: the pixel color in RGB mode (5-6-5).
    * @retval None
    */
  void LCD_WriteRAM(uint16_t RGB_Code)
  {
    STM_SPI_WriteRead(RGB_Code >> 8);
    STM_SPI_WriteRead(RGB_Code & 0xFF);
  }
  
  /**
    * @brief  Power on the LCD.
    * @param  None
    * @retval None
    */
  void LCD_PowerOn(void)
  {
    /* Power On sequence ---------------------------------------------------------*/
    LCD_WriteReg(LCD_REG_16, 0x0000); /* SAP, BT[3:0], AP, DSTB, SLP, STB */
    LCD_WriteReg(LCD_REG_17, 0x0000); /* DC1[2:0], DC0[2:0], VC[2:0] */
    LCD_WriteReg(LCD_REG_18, 0x0000); /* VREG1OUT voltage */
    LCD_WriteReg(LCD_REG_19, 0x0000); /* VDV[4:0] for VCOM amplitude */
    _delay_(20);               /* Dis-charge capacitor power voltage (200ms) */
    LCD_WriteReg(LCD_REG_16, 0x17B0); /* SAP, BT[3:0], AP, DSTB, SLP, STB */
    LCD_WriteReg(LCD_REG_17, 0x0137); /* DC1[2:0], DC0[2:0], VC[2:0] */
    _delay_(5);                /* Delay 50 ms */
    LCD_WriteReg(LCD_REG_18, 0x0139); /* VREG1OUT voltage */
    _delay_(5);                /* delay 50 ms */
    LCD_WriteReg(LCD_REG_19, 0x1d00); /* VDV[4:0] for VCOM amplitude */
    LCD_WriteReg(LCD_REG_41, 0x0013); /* VCM[4:0] for VCOMH */
    _delay_(5);                /* delay 50 ms */
    LCD_WriteReg(LCD_REG_7, 0x0173);  /* 262K color and display ON */
  }
  
  /**
    * @brief  Enables the Display.
    * @param  None
    * @retval None
    */
  void LCD_DisplayOn(void)
  {
    LCD_WriteReg(LCD_REG_40, 0x38);
    _delay_(6);
    LCD_WriteReg(LCD_REG_40, 0x3C);
  }
  
  /**
    * @brief  Disables the Display.
    * @param  None
    * @retval None
    */
  void LCD_DisplayOff(void)
  {
    LCD_WriteReg(LCD_REG_40, 0x38);
    _delay_(6);
    LCD_WriteReg(LCD_REG_40, 0x04);
  }
  
  /**
    * @brief  Configures LCD control lines in Output Push-Pull mode.
    * @param  None
    * @retval None
    */
  void LCD_CtrlLinesConfig(void)
  {
    GPIO_InitTypeDef GPIO_InitStructure;
  
    RCC_AHBPeriphClockCmd(LCD_NCS_GPIO_CLK, ENABLE);
    
    /* Configure NCS (PE.06) in Output Push-Pull mode */
    GPIO_InitStructure.GPIO_Pin = LCD_NCS_PIN;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
    GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
    GPIO_Init(LCD_NCS_GPIO_PORT, &GPIO_InitStructure);
      
    LCD_CtrlLinesWrite(LCD_NCS_GPIO_PORT, LCD_NCS_PIN, Bit_SET);
  }
  
  /**
    * @brief  Sets or reset LCD control lines.
    * @param  GPIOx: where x can be B or D to select the GPIO peripheral.
    * @param  CtrlPins: the Control line.
    *          This parameter can be:
    *            @arg LCD_NCS_PIN: Chip Select pin
    * @param  BitVal: specifies the value to be written to the selected bit.
    *          This parameter can be:
    *            @arg Bit_RESET: to clear the port pin
    *            @arg Bit_SET: to set the port pin
    * @retval None
    */
  void LCD_CtrlLinesWrite(GPIO_TypeDef* GPIOx, uint16_t CtrlPins, BitAction BitVal)
  {
    /* Set or Reset the control line */
    GPIO_WriteBit(GPIOx, CtrlPins, BitVal);
  }
  
  
  /**
    * @brief  Configures the LCD_SPI interface.
    * @param  None
    * @retval None
    */
  void LCD_SPIConfig(void)
  {
    SPI_InitTypeDef    SPI_InitStructure;
    GPIO_InitTypeDef   GPIO_InitStructure;
  
    /* Enable LCD_SPI_SCK_GPIO_CLK, LCD_SPI_MISO_GPIO_CLK and LCD_SPI_MOSI_GPIO_CLK clock */
    RCC_AHBPeriphClockCmd(LCD_SPI_SCK_GPIO_CLK | LCD_SPI_MISO_GPIO_CLK | LCD_SPI_MOSI_GPIO_CLK, ENABLE);
  
    /* Enable SPI and SYSCFG clock  */
    RCC_APB2PeriphClockCmd(LCD_SPI_CLK | RCC_APB2Periph_SYSCFG, ENABLE);
  
    /* Configure LCD_SPI SCK pin */
    GPIO_InitStructure.GPIO_Pin = LCD_SPI_SCK_PIN;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
    GPIO_Init(LCD_SPI_SCK_GPIO_PORT, &GPIO_InitStructure);
    
    /* Configure LCD_SPI MISO pin */
    GPIO_InitStructure.GPIO_Pin = LCD_SPI_MISO_PIN;
    GPIO_Init(LCD_SPI_MISO_GPIO_PORT, &GPIO_InitStructure);
      
    /* Configure LCD_SPI MOSI pin */
    GPIO_InitStructure.GPIO_Pin = LCD_SPI_MOSI_PIN;
    GPIO_Init(LCD_SPI_MOSI_GPIO_PORT, &GPIO_InitStructure);
    
    /* Set PB.2 as Out PP, as direction pin for MOSI */
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;  
    GPIO_Init(GPIOB, &GPIO_InitStructure);
    
    /* MOSI as output */
    GPIO_SetBits(GPIOB, GPIO_Pin_2);
      
    /* Connect PE.13 to SPI SCK */
    GPIO_PinAFConfig(LCD_SPI_SCK_GPIO_PORT, LCD_SPI_SCK_SOURCE, LCD_SPI_SCK_AF);
  
    /* Connect PE.14 to SPI MISO */
    GPIO_PinAFConfig(LCD_SPI_MISO_GPIO_PORT, LCD_SPI_MISO_SOURCE, LCD_SPI_MISO_AF);
  
    /* Connect PE.15 to SPI MOSI */
    GPIO_PinAFConfig(LCD_SPI_MOSI_GPIO_PORT, LCD_SPI_MOSI_SOURCE, LCD_SPI_MOSI_AF);
  
    SPI_I2S_DeInit(LCD_SPI);
    SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
    SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
    SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
    SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
    SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
    SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
    /* SPI baudrate is set to 12 MHz maximum (PCLK2/SPI_BaudRatePrescaler = 48/4 = 12 MHz)
       to verify these constraints:
            - SPI max baudrate is 18MHz
            - SPI baudrate is derived from PCLK clock and defined this way: PCLK/SPI_BaudRatePrescaler
            - HX8347 LCD SPI interface max baudrate is 50MHz for write and 6.66MHz for read
              Since the provided driver doesn't use read capability from LCD, only constraint 
              on write baudrate is considered.
            - SD card SPI interface max baudrate is 25MHz for write/read
         */
    SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
    SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
    SPI_InitStructure.SPI_CRCPolynomial = 7;
    SPI_Init(LCD_SPI, &SPI_InitStructure);
    
    /* Configure the RX FIFO Threshold to Quarter Full */
    SPI_RxFIFOThresholdConfig(LCD_SPI, SPI_RxFIFOThreshold_QF);
    
    SPI_Cmd(LCD_SPI, ENABLE); /* LCD_SPI enable */
  }
  
  /**
    * @brief  Displays a pixel.
    * @param  x: pixel x.
    * @param  y: pixel y.  
    * @retval None
    */
  static void PutPixel(int16_t x, int16_t y)
  { 
    if((x < 0) || (x > 239) || (y < 0) || (y > 319))
    {
      return;  
    }
    LCD_DrawLine(x, y, 1, LCD_DIR_HORIZONTAL);
  }
  
  #ifndef USE_Delay
  /**
    * @brief  Inserts a delay time.
    * @param  nCount: specifies the delay time length.
    * @retval None
    */
  static void delay(__IO uint32_t nCount)
  {
    __IO uint32_t index = 0; 
    for(index = (34000 * nCount); index != 0; index--)
    {
    }
  }
  #endif /* USE_Delay*/
  /**
    * @}
    */ 
  
  /**
    * @}
    */ 
  
  /**
    * @}
    */ 
  
  /**
    * @}
    */ 
  
  /**
    * @}
    */ 
      
  