MultiTimer ADC_MultiTimer;

/*!
  * @brief       ADC_MultiTimerCallback
  *
  * @param       None
  *
  * @retval      None
  *
  */
void ADC_MultiTimerCallback(MultiTimer *timer, void *userData)
{
    char buffer[50];

    memset(buffer, 0, sizeof(buffer));

    ADC_EnableSoftwareStartConv(ADC1);

    while (ADC_ReadSoftwareStartConvStatus(ADC1) != BIT_RESET)
    {
    }

    ADC_ClearStatusFlag(ADC1, ADC_FLAG_EOC);

    uint32_t Value = ADC_ReadConversionValue(ADC1);

    sprintf(buffer, "ADC Voltage : %0.1fv", (float)Value / 4096.0 * 3.3);

    LCD_DisplayString(0, 110, buffer, FORECOLOR, BACKCOLOR, 16, 0);

    MultiTimerStart(&ADC_MultiTimer, 100, ADC_MultiTimerCallback, "ADC");
}

/*!
  * @brief       ADC Init
  *
  * @param       None
  *
  * @retval      None
  *
  */
void ADC_Init(void)
{
    ADC_Config_T  ADC_ConfigStruct;
    GPIO_Config_T GPIO_ConfigStruct;

    RCM_ConfigADCCLK(RCM_PCLK2_DIV_4); /* ADCCLK = PCLK2/4 */

    RCM_EnableAPB2PeriphClock(RCM_APB2_PERIPH_ADC1);
    RCM_EnableAPB2PeriphClock(RCM_APB2_PERIPH_GPIOC);

    GPIO_ConfigStructInit(&GPIO_ConfigStruct);
    GPIO_ConfigStruct.pin   = GPIO_PIN_0;
    GPIO_ConfigStruct.mode  = GPIO_MODE_ANALOG;
    GPIO_Config(GPIOC, &GPIO_ConfigStruct);

    ADC_ConfigStructInit(&ADC_ConfigStruct);
    ADC_ConfigStruct.mode               = ADC_MODE_INDEPENDENT;
    ADC_ConfigStruct.scanConvMode       = DISABLE;
    ADC_ConfigStruct.continuosConvMode  = ENABLE;
    ADC_ConfigStruct.externalTrigConv   = ADC_EXT_TRIG_CONV_None;
    ADC_ConfigStruct.dataAlign          = ADC_DATA_ALIGN_RIGHT;
    ADC_ConfigStruct.nbrOfChannel       = 1;
    ADC_Config(ADC1, &ADC_ConfigStruct);

    ADC_ConfigRegularChannel(ADC1, ADC_CHANNEL_10, 1, ADC_SAMPLETIME_239CYCLES5);

    ADC_Enable(ADC1);

    ADC_ResetCalibration(ADC1);

    while (ADC_ReadResetCalibrationStatus(ADC1))
    {
    }

    ADC_StartCalibration(ADC1);

    while (ADC_ReadCalibrationStartFlag(ADC1))
    {
    }

    MultiTimerStart(&ADC_MultiTimer, 100, ADC_MultiTimerCallback, "ADC");
}

/**
  * @brief    W/R Err Count structure definition
  */
typedef struct
{
    uint32_t    ByteCount;
    uint32_t    HalfWordCount;
    uint32_t    WordCount;
} Err_Count_T;

Err_Count_T Err;

/* printf message */
#define MESSAGE0          "*******************************"
#define MESSAGE1          "* APM32E103xE DMC SDRAM Demo "
#define MESSAGE2          "* SystemCoreClock      :"
#define MESSAGE3          "* SDRAMClock           :"
#define MESSAGE4          "*  8 bit W/R Err Count :"
#define MESSAGE5          "* 16 bit W/R Err Count :"
#define MESSAGE6          "* 32 bit W/R Err Count :"

#define  RCM_SDRAM_GPIO_PERIPH   \
        (RCM_APB2_PERIPH_AFIO |  \
         RCM_APB2_PERIPH_GPIOB | \
         RCM_APB2_PERIPH_GPIOC | \
         RCM_APB2_PERIPH_GPIOD | \
         RCM_APB2_PERIPH_GPIOE | \
         RCM_APB2_PERIPH_GPIOF | \
         RCM_APB2_PERIPH_GPIOG)

#define  RCM_SDRAM_PERIPH (RCM_AHB_PERIPH_SMC)

#define SDRAM_START_ADDR  ((uint32_t)0x60000000)
#define SDRAM_END_ADDR    ((uint32_t)0x60200000)

/*!
  * @brief       SDRAM GPIO Config
  *
  * @param       None
  *
  * @retval      None
  *
  */
static void SDRAM_GPIO_ConfigStruct(void)
{
    GPIO_Config_T GPIO_ConfigStruct;

    RCM_EnableAPB2PeriphClock(RCM_SDRAM_GPIO_PERIPH);

    /** SDRAM pins assignment */
    /**
      +-------------------------+--------------------------+--------------------------+
      | PB10 <-> MMC_SDRAM_UNQM | PC10 <-> MMC_SDRAM_D8    | PD2  <-> MMC_SDRAM_D10   |
      | PB11 <-> MMC_SDRAM_CKE  | PC11 <-> MMC_SDRAM_D9    | PD3  <-> MMC_SDRAM_D11   |
      |                         |                          | PD4  <-> MMC_SDRAM_D12   |
      |                         |                          | PD5  <-> MMC_SDRAM_D13   |
      |                         |                          | PD6  <-> MMC_SDRAM_D14   |
      +-------------------------+--------------------------+--------------------------+
      | PE3  <-> MMC_SDRAM_D4   | PF0  <-> MMC_SDRAM_D7    | PG0  <-> MMC_SDRAM_D15   |
      | PE5  <-> MMC_SDRAM_D5   | PF2  <-> MMC_SDRAM_NCS   | PG9  <-> MMC_SDRAM_D9    |
      | PE6  <-> MMC_SDRAM_D6   | PF4  <-> MMC_SDRAM_NRAS  | PG12 <-> MMC_SDRAM_D0    |
      | PE8  <-> MMC_SDRAM_A4   | PF5  <-> MMC_SDRAM_NCAS  | PG13 <-> MMC_SDRAM_D1    |
      | PE9  <-> MMC_SDRAM_A5   | PF6  <-> MMC_SDRAM_NWE   | PG14 <-> MMC_SDRAM_D2    |
      | PE10 <-> MMC_SDRAM_A6   | PF10 <-> MMC_SDRAM_LDQM  | PG15 <-> MMC_SDRAM_D3    |
      | PE11 <-> MMC_SDRAM_A7   | PF11 <-> MMC_SDRAM_Bank  |                          |
      | PE12 <-> MMC_SDRAM_A8   | PF12 <-> MMC_SDRAM_A10   |                          |
      | PE13 <-> MMC_SDRAM_A9   | PF13 <-> MMC_SDRAM_A0    |                          |
      | PE14 <-> MMC_SDRAM_A5   | PF14 <-> MMC_SDRAM_A1    |                          |
      | PE15 <-> MMC_SDRAM_CLK  | PF15 <-> MMC_SDRAM_A2    |                          |
      +-------------------------+--------------------------+--------------------------+
      */

    GPIO_ConfigStruct.speed = GPIO_SPEED_50MHz;
    GPIO_ConfigStruct.mode  = GPIO_MODE_AF_PP;

    GPIO_ConfigStruct.pin = GPIO_PIN_10 | GPIO_PIN_11;
    GPIO_Config(GPIOB, &GPIO_ConfigStruct);

    GPIO_ConfigStruct.pin = GPIO_PIN_10 | GPIO_PIN_11;
    GPIO_Config(GPIOC, &GPIO_ConfigStruct);

    GPIO_ConfigStruct.pin = GPIO_PIN_2 | GPIO_PIN_3 |
                     GPIO_PIN_4 | GPIO_PIN_5 |
                     GPIO_PIN_6;
    GPIO_Config(GPIOD, &GPIO_ConfigStruct);

    GPIO_ConfigStruct.pin = GPIO_PIN_3 | GPIO_PIN_5 |
                     GPIO_PIN_6 | GPIO_PIN_8 |
                     GPIO_PIN_9 | GPIO_PIN_10 |
                     GPIO_PIN_11 | GPIO_PIN_12 |
                     GPIO_PIN_13 | GPIO_PIN_15;
    GPIO_Config(GPIOE, &GPIO_ConfigStruct);

    GPIO_ConfigStruct.pin = GPIO_PIN_0 | GPIO_PIN_2 | GPIO_PIN_4 |
                     GPIO_PIN_5 | GPIO_PIN_6 |
                     GPIO_PIN_10 | GPIO_PIN_11 |
                     GPIO_PIN_12 | GPIO_PIN_13 |
                     GPIO_PIN_14 | GPIO_PIN_15;
    GPIO_Config(GPIOF, &GPIO_ConfigStruct);

    GPIO_ConfigStruct.pin = GPIO_PIN_0 | GPIO_PIN_9 |
                     GPIO_PIN_12 | GPIO_PIN_13 |
                     GPIO_PIN_14 | GPIO_PIN_15;
    GPIO_Config(GPIOG, &GPIO_ConfigStruct);
}

/*!
  * @brief       SDRAM DMC Config
  *
  * @param       None
  *
  * @retval      None
  *
  */
static void SDRAM_DMC_ConfigStruct(void)
{
    uint32_t SDRAM_Capacity;
    DMC_Config_T DMC_ConfigStruct;
    DMC_TimingConfig_T DMC_TimingConfigStruct;

    RCM_EnableAHBPeriphClock(RCM_SDRAM_PERIPH);

    DMC_TimingConfigStruct.latencyCAS = DMC_CAS_LATENCY_3;     //!< Configure CAS latency period
    DMC_TimingConfigStruct.tARP       = DMC_AUTO_REFRESH_10;   //!< Configure auto refresh period
    DMC_TimingConfigStruct.tRAS       = DMC_RAS_MINIMUM_5;     //!< Configure line activation and precharging minimum time
    DMC_TimingConfigStruct.tCMD       = DMC_ATA_CMD_7;         //!< Configure active to active period
    DMC_TimingConfigStruct.tRCD       = DMC_DELAY_TIME_2;      //!< Configure RAS To CAS delay Time
    DMC_TimingConfigStruct.tRP        = DMC_PRECHARGE_2;       //!< Configure precharge period
    DMC_TimingConfigStruct.tWR        = DMC_NEXT_PRECHARGE_2;  //!< Configure time between the Last Data and The Next Precharge for write
    DMC_TimingConfigStruct.tXSR       = 6;                     //!< Configure XSR0
    DMC_TimingConfigStruct.tRFP       = 0xC3;                  //!< Configure refresh Cycle

    DMC_ConfigStruct.bankWidth     = DMC_BANK_WIDTH_1;      //!< Configure bank address width
    DMC_ConfigStruct.clkPhase      = DMC_CLK_PHASE_REVERSE; //!< Configure clock phase
    DMC_ConfigStruct.rowWidth      = DMC_ROW_WIDTH_11;      //!< Configure row address width
    DMC_ConfigStruct.colWidth      = DMC_COL_WIDTH_8;       //!< Configure column address width
    DMC_ConfigStruct.memorySize    = DMC_MEMORY_SIZE_2MB;
    DMC_ConfigStruct.timing        = DMC_TimingConfigStruct;

    DMC_Config(&DMC_ConfigStruct);
    DMC_ConfigOpenBank(DMC_BANK_NUMBER_2);
    DMC_EnableAccelerateModule();

    DMC_Enable();

    /* SDRAM_Capacity = row * col * 16bit * bank (16bit == 2Bytes) */
    SDRAM_Capacity = (1 << (DMC_ConfigStruct.rowWidth + 1)) * (1 << (DMC_ConfigStruct.colWidth + 1)) * 2 * (1 << (DMC_ConfigStruct.bankWidth + 1));

    printf("This is an example of DMC SDRAM \r\n");
    printf("> Row Address Width    :%d bit\r\n", DMC_ConfigStruct.rowWidth + 1);
    printf("> Column Address Width :%d bit\r\n", DMC_ConfigStruct.colWidth + 1);
    printf("> Bank Address Width   :%d bit band addr\r\n", DMC_ConfigStruct.bankWidth + 1);
    printf("> capacity             :%d MByte\r\n\r\n", SDRAM_Capacity / 1024 / 1024);
}

/*!
  * @brief       SDRAM Write Word
  *
  * @param       address:the address to be programmed.
  *
  * @param       data: the data to be programmed.
  *
  * @retval      None
  *
  */
void SDRAM_WriteWord(uint32_t address, uint32_t data)
{
    *(__IOM uint32_t *)address = data;
}

/*!
  * @brief       SDRAM Write Half Word
  *
  * @param       address:the address to be programmed.
  *
  * @param       data: the data to be programmed.
  *
  * @retval      None
  *
  */
void SDRAM_WriteHalfWord(uint32_t address, uint16_t data)
{
    *(uint16_t *)address = (uint16_t)data;
}

/*!
  * @brief       SDRAM Write Byte
  *
  * @param       address:the address to be programmed.
  *
  * @param       data: the data to be programmed.
  *
  * @retval      None
  *
  */
void SDRAM_WriteByte(uint32_t address, uint8_t data)
{
    *(uint8_t *)address = data;
}

/*!
  * @brief       SDRAM Word Test
  *
  * @param       None
  *
  * @retval      i : W/R Err Count
  *
  */
uint32_t SDRAM_Word_Test(void)
{
    uint32_t Addr = 0;
    uint32_t i    = 0;

    for (Addr = SDRAM_START_ADDR; Addr < SDRAM_END_ADDR; Addr += 0x4)
    {
        SDRAM_WriteWord(Addr, (uint32_t)Addr);
    }

    for (Addr = SDRAM_START_ADDR; Addr < SDRAM_END_ADDR; Addr += 0x4)
    {
        if (*(__IO uint32_t *)(Addr) != (uint32_t)Addr)
        {
            i++;
        }
    }

    return (i);
}

/*!
  * @brief       SDRAM HalfWord Test
  *
  * @param       None
  *
  * @retval      i : W/R Err Count
  *
  */
uint32_t SDRAM_HalfWord_Test(void)
{
    uint32_t Addr = 0;
    uint32_t i    = 0;

    for (Addr = SDRAM_START_ADDR; Addr < SDRAM_END_ADDR; Addr += 0x2)
    {
        SDRAM_WriteHalfWord(Addr, (uint16_t)Addr);
    }

    for (Addr = SDRAM_START_ADDR; Addr < SDRAM_END_ADDR; Addr += 0x2)
    {
        if (*(__IO uint16_t *)(Addr) != (uint16_t)Addr)
        {
            i++;
        }
    }

    return (i);
}

/*!
  * @brief       SDRAM Byte Test
  *
  * @param       None
  *
  * @retval      i : W/R Err Count
  *
  */
uint32_t SDRAM_Byte_Test(void)
{
    uint32_t Addr = 0;
    uint32_t i    = 0;

    for (Addr = SDRAM_START_ADDR; Addr < SDRAM_END_ADDR; Addr += 0x1)
    {
        SDRAM_WriteByte(Addr, (uint8_t)Addr);
    }

    for (Addr = SDRAM_START_ADDR; Addr < SDRAM_END_ADDR; Addr += 0x1)
    {
        if (*(__IO uint8_t *)(Addr) != (uint8_t)Addr)
        {
            i++;
        }
    }

    return (i);
}

/*!
  * @brief       SDRAM Init
  *
  * @param       None
  *
  * @retval      None
  *
  */
void SDRAM_Init(void)
{
    SDRAM_GPIO_ConfigStruct();
    SDRAM_DMC_ConfigStruct();

    printf("\r\n");
    printf("%s \r\n", MESSAGE0);
    printf("%s \r\n", MESSAGE1);
    printf("%s %d MHz\r\n", MESSAGE2, RCM_ReadSYSCLKFreq() / 1000000);

    printf("%s %d MHz\r\n", MESSAGE3, RCM_ReadSYSCLKFreq() / 1000000 / (RCM->CFG_B.SDRAMPSC + 1));

    /* SDRAM byte write/read test */
    Err.ByteCount = SDRAM_Byte_Test();
    printf("%s %d\r\n", MESSAGE4, Err.ByteCount);

    /* SDRAM halfword write/read test */
    Err.HalfWordCount = SDRAM_HalfWord_Test();
    printf("%s %d\r\n", MESSAGE5, Err.HalfWordCount);

    /* SDRAM word write/read test */
    Err.WordCount = SDRAM_Word_Test();
    printf("%s %d\r\n", MESSAGE6, Err.WordCount);

    printf("%s \r\n", MESSAGE0);

    /* The SDRAM test failed */
    if ((Err.ByteCount != 0) || (Err.HalfWordCount != 0) || ((Err.WordCount != 0)))
    {
        printf("The SDRAM test failed\r\n");
    }
    else
    {
        printf("The SDRAM test success\r\n");
    }
}

#define TFT_LCD_CS_H()  GPIO_WriteBitValue(GPIOA, GPIO_PIN_4, BIT_SET)
#define TFT_LCD_CS_L()  GPIO_WriteBitValue(GPIOA, GPIO_PIN_4, BIT_RESET)

#define TFT_LCD_DC_H()  GPIO_WriteBitValue(GPIOA, GPIO_PIN_6, BIT_SET)
#define TFT_LCD_DC_L()  GPIO_WriteBitValue(GPIOA, GPIO_PIN_6, BIT_RESET)

#define TFT_LCD_RES_H() GPIO_WriteBitValue(GPIOA, GPIO_PIN_1, BIT_SET)
#define TFT_LCD_RES_L() GPIO_WriteBitValue(GPIOA, GPIO_PIN_1, BIT_RESET)

#define TFT_LCD_BLK_H() GPIO_WriteBitValue(GPIOA, GPIO_PIN_8, BIT_SET)
#define TFT_LCD_BLK_L() GPIO_WriteBitValue(GPIOA, GPIO_PIN_8, BIT_RESET)

/*!
  * @brief       TFT LCD Init SPI1
  *
  * @param       None
  *
  * @retval      None
  *
  */
void TFT_LCD_InitSPI1(void)
{
    GPIO_Config_T GPIO_ConfigStruct;
    SPI_Config_T  SPI_ConfigStruct;

    RCM_EnableAPB2PeriphClock(RCM_APB2_PERIPH_GPIOA);

    GPIO_ConfigStructInit(&GPIO_ConfigStruct);
    GPIO_ConfigStruct.pin   = GPIO_PIN_7 | GPIO_PIN_5;
    GPIO_ConfigStruct.speed = GPIO_SPEED_50MHz;
    GPIO_ConfigStruct.mode  = GPIO_MODE_AF_PP;
    GPIO_Config(GPIOA, &GPIO_ConfigStruct);

    GPIO_ConfigStructInit(&GPIO_ConfigStruct);
    GPIO_ConfigStruct.pin   = GPIO_PIN_4;
    GPIO_ConfigStruct.speed = GPIO_SPEED_50MHz;
    GPIO_ConfigStruct.mode  = GPIO_MODE_OUT_PP;
    GPIO_Config(GPIOA, &GPIO_ConfigStruct);

    TFT_LCD_CS_H();

    RCM_EnableAPB2PeriphClock(RCM_APB2_PERIPH_SPI1);

    SPI_ConfigStructInit(&SPI_ConfigStruct);
    SPI_ConfigStruct.mode           = SPI_MODE_MASTER;
    SPI_ConfigStruct.length         = SPI_DATA_LENGTH_8B;
    SPI_ConfigStruct.phase          = SPI_CLKPHA_2EDGE;
    SPI_ConfigStruct.polarity       = SPI_CLKPOL_HIGH;
    SPI_ConfigStruct.nss            = SPI_NSS_SOFT;
    SPI_ConfigStruct.firstBit       = SPI_FIRSTBIT_MSB;
    SPI_ConfigStruct.direction      = SPI_DIRECTION_2LINES_FULLDUPLEX;
    SPI_ConfigStruct.baudrateDiv    = SPI_BAUDRATE_DIV_2;
    SPI_ConfigStruct.crcPolynomial  = 7;
    SPI_Config(SPI1, &SPI_ConfigStruct);

    SPI_Enable(SPI1);
}

/*!
  * @brief       LCD SPI sends a byte through the SPI
  *
  * @param       data: byte send
  *
  * @retval      The error code
  *
  */
void TFT_LCD_SPI_ReadWriteByte(uint8_t Data)
{
    while (RESET == SPI_I2S_ReadStatusFlag(SPI1, SPI_FLAG_TXBE))
    {
    }

    SPI_I2S_TxData(SPI1, Data);

    while (RESET != SPI_I2S_ReadStatusFlag(SPI1, SPI_FLAG_BSY))
    {
    }
}

/*!
  * @brief       TFT LCD Init GPIO
  *
  * @param       None
  *
  * @retval      None
  *
  */
void TFT_LCD_InitGPIO(void)
{
    GPIO_Config_T GPIO_ConfigStruct;

    RCM_EnableAPB2PeriphClock(RCM_APB2_PERIPH_GPIOA);

    GPIO_ConfigStructInit(&GPIO_ConfigStruct);
    GPIO_ConfigStruct.pin   = GPIO_PIN_1 | GPIO_PIN_6 | GPIO_PIN_8;
    GPIO_ConfigStruct.speed = GPIO_SPEED_50MHz;
    GPIO_ConfigStruct.mode  = GPIO_MODE_OUT_PP;
    GPIO_Config(GPIOA, &GPIO_ConfigStruct);

    TFT_LCD_DC_H();

    TFT_LCD_RES_H();
    TFT_LCD_BLK_H();
}

/*!
  * @brief       TFT LCD Write Byte
  *
  * @param       Data
  *
  * @retval      None
  *
  */
void TFT_LCD_WriteByte(uint8_t Data)
{
    TFT_LCD_DC_H();
    TFT_LCD_CS_L();
    TFT_LCD_SPI_ReadWriteByte(Data);
    TFT_LCD_CS_H();
}

/*!
  * @brief       TFT LCD Write Half-word
  *
  * @param       Data
  *
  * @retval      None
  *
  */
void TFT_LCD_WriteHalfword(uint16_t Data)
{
    TFT_LCD_DC_H();
    TFT_LCD_CS_L();
    TFT_LCD_SPI_ReadWriteByte(Data >> 8);
    TFT_LCD_SPI_ReadWriteByte(Data >> 0);
    TFT_LCD_CS_H();
}

/*!
  * @brief       TFT LCD Write Command
  *
  * @param       Data
  *
  * @retval      None
  *
  */
void TFT_LCD_WriteCommand(uint8_t Data)
{
    TFT_LCD_DC_L();
    TFT_LCD_CS_L();
    TFT_LCD_SPI_ReadWriteByte(Data);
    TFT_LCD_CS_H();
}

/*!
  * @brief       TFT LCD Set Cursor Address
  *
  * @param       StartX
  *
  * @param       StartY
  *
  * @param       EndX
  *
  * @param       EndY
  *
  * @retval      None
  *
  */
void TFT_LCD_SetCursorAddress(uint16_t StartX, uint16_t StartY, uint16_t EndX, uint16_t EndY)
{
    TFT_LCD_WriteCommand(0x2A);
    TFT_LCD_WriteHalfword(StartX);
    TFT_LCD_WriteHalfword(EndX);

    TFT_LCD_WriteCommand(0x2B);
    TFT_LCD_WriteHalfword(StartY);
    TFT_LCD_WriteHalfword(EndY);

    TFT_LCD_WriteCommand(0x2C);
}

/*!
  * @brief       TFT LCD Draw Point
  *
  * @param       x: Row Lable
  *
  * @param       y: Column Lable
  *
  * @param       Color: Color To Be Filled
  *
  * @retval      None
  *
  */
void TFT_LCD_DrawPoint(uint16_t x, uint16_t y, uint16_t Color)
{
    TFT_LCD_SetCursorAddress(x, y, x, y);
    TFT_LCD_WriteHalfword(Color);
}

/*!
  * @brief       LCD clear content
  *
  * @param       StartX
  *
  * @param       StartY
  *
  * @param       EndY
  *
  * @param       EndY
  *
  * @param       Color
  *
  * @retval      None
  *
  */
void TFT_LCD_Clear(uint16_t StartX, uint16_t StartY, uint16_t EndX, uint16_t EndY, uint16_t Color)
{
    TFT_LCD_SetCursorAddress(StartX, StartY, EndX - 1, EndY - 1);

    for (uint16_t y = StartY; y < EndY; y++)
    {
        for (uint16_t x = StartX; x < EndX; x++)
        {
            TFT_LCD_WriteHalfword(Color);
        }
    }
}

/*!
  * @brief       TFT LCD Display Character
  *
  * @param       x: Row Lable
  *
  * @param       y: Column Lable
  *
  * @param       ForeColor: Foreground Color
  *
  * @param       BackColor: Background Color
  *
  * @param       FontSize: Font Size
  *
  * @param       Mode: Superposition Mode
  *
  * @retval      None
  *
  */
void LCD_DisplayChar(uint16_t x, uint16_t y, char ch, uint16_t ForeColor, uint16_t BackColor, uint8_t FontSize, uint8_t Mode)
{
    const uint8_t *FontTable;
    uint8_t        TableSize = 0;

    uint8_t FontHeight = FontSize;
    uint8_t FontWidth  = FontSize / 2;

    uint16_t StartX    = x;

    switch (FontSize)
    {
        case 12:
            FontTable = &ASCII_FONT_1206[ch - 0x20][0];
            TableSize = 12;
            break;

        case 16:
            FontTable = &ASCII_FONT_1608[ch - 0x20][0];
            TableSize = 16;
            break;

        case 24:
            FontTable = &ASCII_FONT_2412[ch - 0x20][0];
            TableSize = 48;
            break;

        case 32:
            FontTable = &ASCII_FONT_3216[ch - 0x20][0];
            TableSize = 64;
            break;

        default:
            break;
    }

    if (0 == Mode)
    {
        TFT_LCD_SetCursorAddress(x, y, x + FontWidth - 1, y + FontHeight - 1);

        for (uint8_t i = 0; i < TableSize; i++)
        {
            for (uint8_t j = 0; j < 8; j++)
            {
                if (FontTable & (0x01 << j))
                {
                    TFT_LCD_WriteHalfword(ForeColor);
                }
                else
                {
                    TFT_LCD_WriteHalfword(BackColor);
                }

                x++;

                if (x % FontWidth == 0)
                {
                    x = 0;
                    break;
                }
            }
        }
    }
    else
    {
        for (uint8_t i = 0; i < TableSize; i++)
        {
            for (uint8_t j = 0; j < 8; j++)
            {
                if (FontTable & (0x01 << j))
                {
                    TFT_LCD_DrawPoint(x, y, ForeColor);
                }

                x++;

                if ((x - StartX) == FontWidth)
                {
                    x = StartX;
                    y = y + 01;
                    break;
                }
            }
        }
    }
}

/*!
  * @brief       TFT LCD Display String
  *
  * @param       x: Row Lable
  *
  * @param       y: Column Lable
  *
  * @param       ForeColor: Foreground Color
  *
  * @param       BackColor: Background Color
  *
  * @param       str: Point To String Buffer
  *
  * @param       FontSize: Font Size
  *
  * @param       Mode: Superposition Mode
  *
  * @retval      None
  *
  */
void LCD_DisplayString(uint16_t x, uint16_t y, const char *str, uint16_t ForeColor, uint16_t BackColor, uint8_t FontSize, uint8_t Mode)
{
    while (*str != '\0')
    {
        LCD_DisplayChar(x, y, *str, ForeColor, BackColor, FontSize, Mode);

        switch (FontSize)
        {
            case 12:
                x += 6;
                break;

            case 16:
                x += 8;
                break;

            case 24:
                x += 12;
                break;

            case 32:
                x += 16;
                break;

            default:
                break;
        }

        if(x >= 240)
        {
            x  = 0;
            y += FontSize;
        }

        str++;
    }
}

/*!
  * @brief       TFT LCD DelayMS
  *
  * @param       Tick
  *
  * @retval      None
  *
  */
void TFT_LCD_DelayMS(uint32_t Tick)
{
    extern volatile uint32_t SysTick_Tick;

    uint32_t Start = SysTick_Tick;

    if ((UINT32_MAX - Start) >= Tick)
    {
        while ((SysTick_Tick - Start) != Tick)
        {
        }
    }
    else
    {
        while ((SysTick_Tick + (UINT32_MAX - Start)) != Tick)
        {
        }
    }
}

/*!
  * @brief       TFT LCD Configure
  *
  * @param       None
  *
  * @retval      None
  *
  */
void TFT_LCD_Configure(void)
{
    TFT_LCD_WriteCommand(0x11);
    TFT_LCD_DelayMS(120);

    TFT_LCD_WriteCommand(0xCF);
    TFT_LCD_WriteByte(0x00);
    TFT_LCD_WriteByte(0xD9);
    TFT_LCD_WriteByte(0X30);

    TFT_LCD_WriteCommand(0xED);
    TFT_LCD_WriteByte(0x64);
    TFT_LCD_WriteByte(0x03);
    TFT_LCD_WriteByte(0X12);
    TFT_LCD_WriteByte(0X81);

    TFT_LCD_WriteCommand(0xE8);
    TFT_LCD_WriteByte(0x85);
    TFT_LCD_WriteByte(0x10);
    TFT_LCD_WriteByte(0x78);

    TFT_LCD_WriteCommand(0xCB);
    TFT_LCD_WriteByte(0x39);
    TFT_LCD_WriteByte(0x2C);
    TFT_LCD_WriteByte(0x00);
    TFT_LCD_WriteByte(0x34);
    TFT_LCD_WriteByte(0x02);

    TFT_LCD_WriteCommand(0xF7);
    TFT_LCD_WriteByte(0x20);

    TFT_LCD_WriteCommand(0xEA);
    TFT_LCD_WriteByte(0x00);
    TFT_LCD_WriteByte(0x00);

    TFT_LCD_WriteCommand(0xC0);
    TFT_LCD_WriteByte(0x21);

    TFT_LCD_WriteCommand(0xC1);
    TFT_LCD_WriteByte(0x12);

    TFT_LCD_WriteCommand(0xC5);
    TFT_LCD_WriteByte(0x32);
    TFT_LCD_WriteByte(0x3C);

    TFT_LCD_WriteCommand(0xC7);
    TFT_LCD_WriteByte(0XC1);

    TFT_LCD_WriteCommand(0x36);
    TFT_LCD_WriteByte(0xC8);

    TFT_LCD_WriteCommand(0x3A);
    TFT_LCD_WriteByte(0x55);

    TFT_LCD_WriteCommand(0xB1);
    TFT_LCD_WriteByte(0x00);
    TFT_LCD_WriteByte(0x18);

    TFT_LCD_WriteCommand(0xB6);
    TFT_LCD_WriteByte(0x0A);
    TFT_LCD_WriteByte(0xA2);

    TFT_LCD_WriteCommand(0xF2);
    TFT_LCD_WriteByte(0x00);

    TFT_LCD_WriteCommand(0x26);
    TFT_LCD_WriteByte(0x01);

    TFT_LCD_WriteCommand(0xE0);
    TFT_LCD_WriteByte(0x0F);
    TFT_LCD_WriteByte(0x20);
    TFT_LCD_WriteByte(0x1E);
    TFT_LCD_WriteByte(0x09);
    TFT_LCD_WriteByte(0x12);
    TFT_LCD_WriteByte(0x0B);
    TFT_LCD_WriteByte(0x50);
    TFT_LCD_WriteByte(0XBA);
    TFT_LCD_WriteByte(0x44);
    TFT_LCD_WriteByte(0x09);
    TFT_LCD_WriteByte(0x14);
    TFT_LCD_WriteByte(0x05);
    TFT_LCD_WriteByte(0x23);
    TFT_LCD_WriteByte(0x21);
    TFT_LCD_WriteByte(0x00);

    TFT_LCD_WriteCommand(0XE1);
    TFT_LCD_WriteByte(0x00);
    TFT_LCD_WriteByte(0x19);
    TFT_LCD_WriteByte(0x19);
    TFT_LCD_WriteByte(0x00);
    TFT_LCD_WriteByte(0x12);
    TFT_LCD_WriteByte(0x07);
    TFT_LCD_WriteByte(0x2D);
    TFT_LCD_WriteByte(0x28);
    TFT_LCD_WriteByte(0x3F);
    TFT_LCD_WriteByte(0x02);
    TFT_LCD_WriteByte(0x0A);
    TFT_LCD_WriteByte(0x08);
    TFT_LCD_WriteByte(0x25);
    TFT_LCD_WriteByte(0x2D);
    TFT_LCD_WriteByte(0x0F);

    TFT_LCD_WriteCommand(0x29);
}

/*!
  * @brief       TFT LCD Init
  *
  * @param       None
  *
  * @retval      None
  *
  */
void TFT_LCD_Init(void)
{
    TFT_LCD_InitSPI1();

    TFT_LCD_InitGPIO();

    TFT_LCD_RES_L();
    TFT_LCD_DelayMS(99);
    TFT_LCD_RES_H();
    TFT_LCD_DelayMS(99);

    TFT_LCD_BLK_H();
    TFT_LCD_DelayMS(99);

    TFT_LCD_Configure();

    TFT_LCD_Clear(0, 0, 240, 320, BACKCOLOR);

    LCD_DisplayString(0, 10, "Geehy", FORECOLOR, BACKCOLOR, 32, 1);

    LCD_DisplayString(0, 50, "APM32E103ZE EVAL V1.0", FORECOLOR, BACKCOLOR, 16, 1);
}