LanQiao Baseboard development’s log 01

LED、LCD and Key quick start

LED - LED Display and Floating

The Pins to LED is show as followed.
Pins

Due to The pin from PC8 to PC15 is used by both LED and LCD so there is D1 between pins and LEDs so that when PD2 is set to High, the value of pins can be also set to LED. Instead, if the PD2 is set to low, the value of pins only affect the LCD’s value.
So now we define the display function so that we can easily write the value of LED.

#define unsigned char uint8_t

void LED_Disp(uint8_t disLED)
{
  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_All, GPIO_PIN_SET);   // Turn off all the led
  HAL_GPIO_WritePin(GPIOC, disLED<<8, GPIO_PIN_RESET);    // Choose led(low 8th switch to high 8th) and turn on
  HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_SET);     // Set PD2 to high to enable D1(Lock)
  HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_RESET);   // ...........low to disable
}

The main concept is:
First, Set the values of all pin which control the LED. Then set the PD2 to High. After that, lock down the value so that you can easily operate the LCD rather influence the LED.

Now, you can use the display function to create a floating mode.

void LED_Float(void)
{
  // 0000 0001 -> 0000 0010 ...etc. If i = 1000 0000 Display the last time and exit.
  for (int i = 1; i <= 0xf0; i = i<<1)
  {
    LED_Disp(i);
    HAL_Delay(100);
    LED_Disp(0x00);     // Clear the last LED
  }
}

Floating, which means that the eight LED turn on and off one by one to make it looks like floating, requires controlling the LED’s sequence. You can write like:

HAL_GPIO_WritePin(GPIOC, GPIO_PIN_x, GPIO_PIN_SET);

and control its time sequence by yourselves but your code will become long and ugly. So this blog use the bit shift combine with loop. As you can see, the GPIO_Port such as GPIOC contains 16 pins, from PC0 to PC15.

And the number we can display in binary system:

Col1	Col2
GPIO_PIN_0	GPIO_PIN_15
0000 0000 0000 0001	1000 0000 0000 0000

In this way, I believe you can easily get to know why we can shift the bit(left side) to make each LED turn on. The PC0 refers to 0x01 and the PC15 refers to 0xf0. Everytime we want to turn the LED0~7 on, we only need to set the bits value that in the low eight position because we carry it to high eight position in our display function.

HAL_GPIO_WritePin(GPIOC, disLED<<8, GPIO_PIN_RESET);    // Choose led(low 8th switch to high 8th) and turn on

Then you can adjust the time of turning on to reach the final result you want. You can use the basic display function and the concept to generate your own display mode.

LCD - Display and show Info

The LCD original code is complex and difficult but it is lucky that we have the driver lib so all we need to do is transport it and use it.

In this blog we will support you with the driver lib file code and some most-use function with using tips.

/-----Driver Lib-----/
#include "LCD.h"
#include "Fonts.h"

static  vu16 TextColor = 0x0000, BackColor = 0xFFFF;
vu16 dummy;

/*******************************************************************************
* Function Name  : Delay_LCD
* Description    : Inserts a delay time.
* Input          : nCount: specifies the delay time length.
* Output         : None
* Return         : None
*******************************************************************************/
void Delay_LCD(u16 n)
{
    u16 i, j;
    for (i = 0; i < n; ++i)
        for(j = 0; j < 3000; ++j);
}

/*
	uC8230��Һ���������Ĵ�������
*/
void REG_8230_Init(void)
{
    LCD_WriteReg(0x0000, 0x0001);
    Delay_LCD(1000);
    LCD_WriteReg(0x0001, 0x0000);
    LCD_WriteReg(0x0010, 0x1790);
    LCD_WriteReg(0x0060, 0x2700);
    LCD_WriteReg(0x0061, 0x0001);
    LCD_WriteReg(0x0046, 0x0002);
    LCD_WriteReg(0x0013, 0x8010);
    LCD_WriteReg(0x0012, 0x80fe);
    LCD_WriteReg(0x0002, 0x0500);
    LCD_WriteReg(0x0003, 0x1030);

    LCD_WriteReg(0x0030, 0x0303);
    LCD_WriteReg(0x0031, 0x0303);
    LCD_WriteReg(0x0032, 0x0303);
    LCD_WriteReg(0x0033, 0x0300);
    LCD_WriteReg(0x0034, 0x0003);
    LCD_WriteReg(0x0035, 0x0303);
    LCD_WriteReg(0x0036, 0x0014);
    LCD_WriteReg(0x0037, 0x0303);
    LCD_WriteReg(0x0038, 0x0303);
    LCD_WriteReg(0x0039, 0x0303);
    LCD_WriteReg(0x003a, 0x0300);
    LCD_WriteReg(0x003b, 0x0003);
    LCD_WriteReg(0x003c, 0x0303);
    LCD_WriteReg(0x003d, 0x1400);

    LCD_WriteReg(0x0092, 0x0200);
    LCD_WriteReg(0x0093, 0x0303);
    LCD_WriteReg(0x0090, 0x080d);
    LCD_WriteReg(0x0003, 0x1018);
    LCD_WriteReg(0x0007, 0x0173);
}

void REG_932X_Init(void)
{
    LCD_WriteReg(R227, 0x3008);   // Set internal timing
    LCD_WriteReg(R231, 0x0012); // Set internal timing
    LCD_WriteReg(R239, 0x1231);   // Set internal timing
    LCD_WriteReg(R1, 0x0000);   // set SS and SM bit		  //0x0100
    LCD_WriteReg(R2, 0x0700);   // set 1 line inversion
    LCD_WriteReg(R3, 0x1030);     // set GRAM write direction and BGR=1.
    LCD_WriteReg(R4, 0x0000);     // Resize register
    LCD_WriteReg(R8, 0x0207);     // set the back porch and front porch
    LCD_WriteReg(R9, 0x0000);     // set non-display area refresh cycle ISC[3:0]
    LCD_WriteReg(R10, 0x0000);    // FMARK function
    LCD_WriteReg(R12, 0x0000);  // RGB interface setting
    LCD_WriteReg(R13, 0x0000);    // Frame marker Position
    LCD_WriteReg(R15, 0x0000);  // RGB interface polarity
    /**************Power On sequence ****************/
    LCD_WriteReg(R16, 0x0000);    // SAP, BT[3:0], AP, DSTB, SLP, STB
    LCD_WriteReg(R17, 0x0007);    // DC1[2:0], DC0[2:0], VC[2:0]
    LCD_WriteReg(R18, 0x0000);  // VREG1OUT voltage
    LCD_WriteReg(R19, 0x0000);    // VDV[4:0] for VCOM amplitude
    //	Delay_Ms(200);                    // Delay 200 MS , Dis-charge capacitor power voltage
    HAL_Delay(200);
    LCD_WriteReg(R16, 0x1690);    // SAP, BT[3:0], AP, DSTB, SLP, STB
    LCD_WriteReg(R17, 0x0227);  // R11H=0x0221 at VCI=3.3V, DC1[2:0], DC0[2:0], VC[2:0]
    //	Delay_Ms(50);      // Delay 50ms
    HAL_Delay(50);
    LCD_WriteReg(R18, 0x001D);  // External reference voltage= Vci;
    //	Delay_Ms(50);      // Delay 50ms
    HAL_Delay(50);
    LCD_WriteReg(R19, 0x0800);  // R13H=1D00 when R12H=009D;VDV[4:0] for VCOM amplitude
    LCD_WriteReg(R41, 0x0014);  // R29H=0013 when R12H=009D;VCM[5:0] for VCOMH
    LCD_WriteReg(R43, 0x000B);    // Frame Rate = 96Hz
    //	Delay_Ms(50);      // Delay 50ms
    HAL_Delay(50);
    LCD_WriteReg(R32, 0x0000);  // GRAM horizontal Address
    LCD_WriteReg(R33, 0x0000);  // GRAM Vertical Address
    /* ----------- Adjust the Gamma Curve ---------- */
    LCD_WriteReg(R48, 0x0007);
    LCD_WriteReg(R49, 0x0707);
    LCD_WriteReg(R50, 0x0006);
    LCD_WriteReg(R53, 0x0704);
    LCD_WriteReg(R54, 0x1F04);
    LCD_WriteReg(R55, 0x0004);
    LCD_WriteReg(R56, 0x0000);
    LCD_WriteReg(R57, 0x0706);
    LCD_WriteReg(R60, 0x0701);
    LCD_WriteReg(R61, 0x000F);
    /* ------------------ Set GRAM area --------------- */
    LCD_WriteReg(R80, 0x0000);    // Horizontal GRAM Start Address
    LCD_WriteReg(R81, 0x00EF);    // Horizontal GRAM End Address
    LCD_WriteReg(R82, 0x0000);  // Vertical GRAM Start Address
    LCD_WriteReg(R83, 0x013F);  // Vertical GRAM Start Address
    LCD_WriteReg(R96, 0x2700);  // Gate Scan Line		  0xA700
    LCD_WriteReg(R97, 0x0001);  // NDL,VLE, REV
    LCD_WriteReg(R106, 0x0000); // set scrolling line
    /* -------------- Partial Display Control --------- */
    LCD_WriteReg(R128, 0x0000);
    LCD_WriteReg(R129, 0x0000);
    LCD_WriteReg(R130, 0x0000);
    LCD_WriteReg(R131, 0x0000);
    LCD_WriteReg(R132, 0x0000);
    LCD_WriteReg(R133, 0x0000);
    /* -------------- Panel Control ------------------- */
    LCD_WriteReg(R144, 0x0010);
    LCD_WriteReg(R146, 0x0000);
    LCD_WriteReg(R147, 0x0003);
    LCD_WriteReg(R149, 0x0110);
    LCD_WriteReg(R151, 0x0000);
    LCD_WriteReg(R152, 0x0000);
    /* Set GRAM write direction and BGR = 1 */
    /* I/D=01 (Horizontal : increment, Vertical : decrement) */
    /* AM=1 (address is updated in vertical writing direction) */
    LCD_WriteReg(R3, 0x01018);    //0x1018

    LCD_WriteReg(R7, 0x0173);   // 262K color and display ON
}
/*******************************************************************************
* Function Name  : STM3210B_LCD_Init
* Description    : Initializes the LCD.
* Input          : None
* Output         : None
* Return         : None
*******************************************************************************/
void LCD_Init(void)
{
    LCD_CtrlLinesConfig();
    dummy = LCD_ReadReg(0);

    if(dummy == 0x8230)
    {
        REG_8230_Init();
    }
    else
    {
        REG_932X_Init();
    }
    dummy = LCD_ReadReg(0);

}
/*******************************************************************************
* Function Name  : LCD_SetTextColor
* Description    : Sets the Text color.
* Input          : - Color: specifies the Text color code RGB(5-6-5).
* Output         : - TextColor: Text color global variable used by LCD_DrawChar
*                  and LCD_DrawPicture functions.
* Return         : None
*******************************************************************************/
void LCD_SetTextColor(vu16 Color)
{
    TextColor = Color;
}
/*******************************************************************************
* Function Name  : LCD_SetBackColor
* Description    : Sets the Background color.
* Input          : - Color: specifies the Background color code RGB(5-6-5).
* Output         : - BackColor: Background color global variable used by
*                  LCD_DrawChar and LCD_DrawPicture functions.
* Return         : None
*******************************************************************************/
void LCD_SetBackColor(vu16 Color)
{
    BackColor = Color;
}
/*******************************************************************************
* Function Name  : LCD_ClearLine
* Description    : Clears the selected line.
* Input          : - Line: the Line to be cleared.
*                    This parameter can be one of the following values:
*                       - Linex: where x can be 0..9
* Output         : None
* Return         : None
*******************************************************************************/
void LCD_ClearLine(u8 Line)
{
    LCD_DisplayStringLine(Line, "                    ");
}
/*******************************************************************************
* Function Name  : LCD_Clear
* Description    : Clears the hole LCD.
* Input          : Color: the color of the background.
* Output         : None
* Return         : None
*******************************************************************************/
void LCD_Clear(u16 Color)
{
    u32 index = 0;
    LCD_SetCursor(0x00, 0x0000);
    LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */
    for(index = 0; index < 76800; index++)
    {
        LCD_WriteRAM(Color);
    }
}
/*******************************************************************************
* Function Name  : LCD_SetCursor
* Description    : Sets the cursor position.
* Input          : - Xpos: specifies the X position.
*                  - Ypos: specifies the Y position.
* Output         : None
* Return         : None
*******************************************************************************/
void LCD_SetCursor(u8 Xpos, u16 Ypos)
{
    LCD_WriteReg(R32, Xpos);
    LCD_WriteReg(R33, Ypos);
}
/*******************************************************************************
* Function Name  : LCD_DrawChar
* Description    : Draws a character on LCD.
* Input          : - Xpos: the Line where to display the character shape.
*                    This parameter can be one of the following values:
*                       - Linex: where x can be 0..9
*                  - Ypos: start column address.
*                  - c: pointer to the character data.
* Output         : None
* Return         : None
*******************************************************************************/
void LCD_DrawChar(u8 Xpos, u16 Ypos, uc16 *c)
{
    u32 index = 0, i = 0;
    u8 Xaddress = 0;

    Xaddress = Xpos;
    LCD_SetCursor(Xaddress, Ypos);

    for(index = 0; index < 24; index++)
    {
        LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */
        for(i = 0; i < 16; i++)
        {
            if((c[index] & (1 << i)) == 0x00)
            {
                LCD_WriteRAM(BackColor);
            }
            else
            {
                LCD_WriteRAM(TextColor);
            }
        }
        Xaddress++;
        LCD_SetCursor(Xaddress, Ypos);
    }
}
/*******************************************************************************
* Function Name  : LCD_DisplayChar
* Description    : Displays one character (16dots width, 24dots height).
* Input          : - Line: the Line where to display the character shape .
*                    This parameter can be one of the following values:
*                       - Linex: where x can be 0..9
*                  - Column: start column address.
*                  - Ascii: character ascii code, must be between 0x20 and 0x7E.
* Output         : None
* Return         : None
*******************************************************************************/
void LCD_DisplayChar(u8 Line, u16 Column, u8 Ascii)
{
    Ascii -= 32;
    LCD_DrawChar(Line, Column, &ASCII_Table[Ascii * 24]);
}
/*******************************************************************************
* Function Name  : LCD_DisplayStringLine
* Description    : Displays a maximum of 20 char on the LCD.
* Input          : - Line: the Line where to display the character shape .
*                    This parameter can be one of the following values:
*                       - Linex: where x can be 0..9
*                  - *ptr: pointer to string to display on LCD.
* Output         : None
* Return         : None
*******************************************************************************/
void LCD_DisplayStringLine(u8 Line, u8 *ptr)
{
    u32 i = 0;
    u16 refcolumn = 319;//319;

    while ((*ptr != 0) && (i < 20))	 //	20
    {
        LCD_DisplayChar(Line, refcolumn, *ptr);
        refcolumn -= 16;
        ptr++;
        i++;
    }
}
/*******************************************************************************
* Function Name  : LCD_SetDisplayWindow
* Description    : Sets a display window
* Input          : - Xpos: specifies the X buttom left position.
*                  - Ypos: specifies the Y buttom left position.
*                  - Height: display window height.
*                  - Width: display window width.
* Output         : None
* Return         : None
*******************************************************************************/
void LCD_SetDisplayWindow(u8 Xpos, u16 Ypos, u8 Height, u16 Width)
{
    if(Xpos >= Height)
    {
        LCD_WriteReg(R80, (Xpos - Height + 1));
    }
    else
    {
        LCD_WriteReg(R80, 0);
    }
    LCD_WriteReg(R81, Xpos);
    if(Ypos >= Width)
    {
        LCD_WriteReg(R82, (Ypos - Width + 1));
    }
    else
    {
        LCD_WriteReg(R82, 0);
    }
    /* Vertical GRAM End Address */
    LCD_WriteReg(R83, Ypos);
    LCD_SetCursor(Xpos, Ypos);
}
/*******************************************************************************
* Function Name  : LCD_WindowModeDisable
* Description    : Disables LCD Window mode.
* Input          : None
* Output         : None
* Return         : None
*******************************************************************************/
void LCD_WindowModeDisable(void)
{
    LCD_SetDisplayWindow(239, 0x13F, 240, 320);
    LCD_WriteReg(R3, 0x1018);
}
/*******************************************************************************
* Function Name  : LCD_DrawLine
* Description    : Displays a line.
* Input          : - Xpos: specifies the X position.
*                  - Ypos: specifies the Y position.
*                  - Length: line length.
*                  - Direction: line direction.
*                    This parameter can be one of the following values: Vertical
*                    or Horizontal.
* Output         : None
* Return         : None
*******************************************************************************/
void LCD_DrawLine(u8 Xpos, u16 Ypos, u16 Length, u8 Direction)
{
    u32 i = 0;

    LCD_SetCursor(Xpos, Ypos);
    if(Direction == Horizontal)
    {
        LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */
        for(i = 0; i < Length; i++)
        {
            LCD_WriteRAM(TextColor);
        }
    }
    else
    {
        for(i = 0; i < Length; i++)
        {
            LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */
            LCD_WriteRAM(TextColor);
            Xpos++;
            LCD_SetCursor(Xpos, Ypos);
        }
    }
}
/*******************************************************************************
* Function Name  : LCD_DrawRect
* Description    : Displays a rectangle.
* Input          : - Xpos: specifies the X position.
*                  - Ypos: specifies the Y position.
*                  - Height: display rectangle height.
*                  - Width: display rectangle width.
* Output         : None
* Return         : None
*******************************************************************************/
void LCD_DrawRect(u8 Xpos, u16 Ypos, u8 Height, u16 Width)
{
    LCD_DrawLine(Xpos, Ypos, Width, Horizontal);
    LCD_DrawLine((Xpos + Height), Ypos, Width, Horizontal);

    LCD_DrawLine(Xpos, Ypos, Height, Vertical);
    LCD_DrawLine(Xpos, (Ypos - Width + 1), Height, Vertical);
}
/*******************************************************************************
* Function Name  : LCD_DrawCircle
* Description    : Displays a circle.
* Input          : - Xpos: specifies the X position.
*                  - Ypos: specifies the Y position.
*                  - Height: display rectangle height.
*                  - Width: display rectangle width.
* Output         : None
* Return         : None
*******************************************************************************/
void LCD_DrawCircle(u8 Xpos, u16 Ypos, u16 Radius)
{
    s32  D;
    u32  CurX;
    u32  CurY;

    D = 3 - (Radius << 1);
    CurX = 0;
    CurY = Radius;

    while (CurX <= CurY)
    {
        LCD_SetCursor(Xpos + CurX, Ypos + CurY);
        LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */
        LCD_WriteRAM(TextColor);

        LCD_SetCursor(Xpos + CurX, Ypos - CurY);
        LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */
        LCD_WriteRAM(TextColor);

        LCD_SetCursor(Xpos - CurX, Ypos + CurY);
        LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */
        LCD_WriteRAM(TextColor);

        LCD_SetCursor(Xpos - CurX, Ypos - CurY);
        LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */
        LCD_WriteRAM(TextColor);

        LCD_SetCursor(Xpos + CurY, Ypos + CurX);
        LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */
        LCD_WriteRAM(TextColor);

        LCD_SetCursor(Xpos + CurY, Ypos - CurX);
        LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */
        LCD_WriteRAM(TextColor);

        LCD_SetCursor(Xpos - CurY, Ypos + CurX);
        LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */
        LCD_WriteRAM(TextColor);

        LCD_SetCursor(Xpos - CurY, Ypos - CurX);
        LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */
        LCD_WriteRAM(TextColor);

        if (D < 0)
        {
            D += (CurX << 2) + 6;
        }
        else
        {
            D += ((CurX - CurY) << 2) + 10;
            CurY--;
        }
        CurX++;
    }
}
/*******************************************************************************
* Function Name  : LCD_DrawMonoPict
* Description    : Displays a monocolor picture.
* Input          : - Pict: pointer to the picture array.
* Output         : None
* Return         : None
*******************************************************************************/
void LCD_DrawMonoPict(uc32 *Pict)
{
    u32 index = 0, i = 0;

    LCD_SetCursor(0, 319);

    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);
            }
        }
    }
}
/*******************************************************************************
* Function Name  : LCD_WriteBMP
* Description    : Displays a bitmap picture loaded in the internal Flash.
* Input          : - BmpAddress: Bmp picture address in the internal Flash.
* Output         : None
* Return         : None
*******************************************************************************/
void LCD_WriteBMP(u32 BmpAddress)
{
    u32 index = 0, size = 0;

    size = *(vu16 *) (BmpAddress + 2);
    size |= (*(vu16 *) (BmpAddress + 4)) << 16;

    index = *(vu16 *) (BmpAddress + 10);
    index |= (*(vu16 *) (BmpAddress + 12)) << 16;
    size = (size - index) / 2;
    BmpAddress += index;

    LCD_WriteReg(R3, 0x1008);
    LCD_WriteRAM_Prepare();
    for(index = 0; index < size; index++)
    {
        LCD_WriteRAM(*(vu16 *)BmpAddress);
        BmpAddress += 2;
    }
    LCD_WriteReg(R3, 0x1018);
}
/*******************************************************************************
* Function Name  : LCD_WriteReg
* Description    : Writes to the selected LCD register.
* Input          : - LCD_Reg: address of the selected register.
*                  - LCD_RegValue: value to write to the selected register.
* Output         : None
* Return         : None
*******************************************************************************/
void LCD_WriteReg(u8 LCD_Reg, u16 LCD_RegValue)
{
    GPIOB->BRR  |= GPIO_PIN_9;
    GPIOB->BRR  |= GPIO_PIN_8;
    GPIOB->BSRR |= GPIO_PIN_5;

    GPIOC->ODR = LCD_Reg;
    GPIOB->BRR  |= GPIO_PIN_5;
    __nop();
    __nop();
    __nop();
    GPIOB->BSRR |= GPIO_PIN_5;
    GPIOB->BSRR |= GPIO_PIN_8;

    GPIOC->ODR = LCD_RegValue;
    GPIOB->BRR  |= GPIO_PIN_5;
    __nop();
    __nop();
    __nop();
    GPIOB->BSRR |= GPIO_PIN_5;
    GPIOB->BSRR |= GPIO_PIN_8;
}
/*******************************************************************************
* Function Name  : LCD_ReadReg
* Description    : Reads the selected LCD Register.
* Input          : None
* Output         : None
* Return         : LCD Register Value.
*******************************************************************************/
u16 LCD_ReadReg(u8 LCD_Reg)
{
    u16 temp;

    GPIOB->BRR |= GPIO_PIN_9;
    GPIOB->BRR |= GPIO_PIN_8;
    GPIOB->BSRR |= GPIO_PIN_5;

    GPIOC->ODR = LCD_Reg;
    GPIOB->BRR |= GPIO_PIN_5;
    __nop();
    __nop();
    __nop();
    GPIOB->BSRR |= GPIO_PIN_5;
    GPIOB->BSRR |= GPIO_PIN_8;

    LCD_BusIn();
    GPIOA->BRR |= GPIO_PIN_8;
    __nop();
    __nop();
    __nop();
    temp = GPIOC->IDR;
    GPIOA->BSRR |= GPIO_PIN_8;

    LCD_BusOut();
    GPIOB->BSRR |= GPIO_PIN_9;

    return temp;
}
/*******************************************************************************
* Function Name  : LCD_WriteRAM_Prepare
* Description    : Prepare to write to the LCD RAM.
* Input          : None
* Output         : None
* Return         : None
*******************************************************************************/
void LCD_WriteRAM_Prepare(void)
{
    GPIOB->BRR  |=  GPIO_PIN_9;
    GPIOB->BRR  |=  GPIO_PIN_8;
    GPIOB->BSRR |=  GPIO_PIN_5;

    GPIOC->ODR = R34;
    GPIOB->BRR  |=  GPIO_PIN_5;
    __nop();
    __nop();
    __nop();
    GPIOB->BSRR |=  GPIO_PIN_5;
    GPIOB->BSRR |=  GPIO_PIN_8;
    __nop();
    __nop();
    __nop();
    GPIOB->BSRR |=  GPIO_PIN_9;
}
/*******************************************************************************
* Function Name  : LCD_WriteRAM
* Description    : Writes to the LCD RAM.
* Input          : - RGB_Code: the pixel color in RGB mode (5-6-5).
* Output         : None
* Return         : None
*******************************************************************************/
void LCD_WriteRAM(u16 RGB_Code)
{
    GPIOB->BRR  |=  GPIO_PIN_9;
    GPIOB->BSRR |=  GPIO_PIN_8;
    GPIOB->BSRR |=  GPIO_PIN_5;

    GPIOC->ODR = RGB_Code;
    GPIOB->BRR  |=  GPIO_PIN_5;
    __nop();
    __nop();
    __nop();
    GPIOB->BSRR |=  GPIO_PIN_5;
    GPIOB->BSRR |=  GPIO_PIN_8;
    __nop();
    __nop();
    __nop();
    GPIOB->BSRR |=  GPIO_PIN_9;
}
/*******************************************************************************
* Function Name  : LCD_ReadRAM
* Description    : Reads the LCD RAM.
* Input          : None
* Output         : None
* Return         : LCD RAM Value.
*******************************************************************************/
u16 LCD_ReadRAM(void)
{
    u16 temp;

    GPIOB->BRR  |=  GPIO_PIN_9;
    GPIOB->BRR  |=  GPIO_PIN_8;
    GPIOB->BSRR |=  GPIO_PIN_5;

    GPIOC->ODR = R34;
    GPIOB->BRR  |=  GPIO_PIN_5;
    __nop();
    __nop();
    __nop();
    GPIOB->BSRR |=  GPIO_PIN_5;
    GPIOB->BSRR |=  GPIO_PIN_8;

    LCD_BusIn();
    GPIOA->BRR |=  GPIO_PIN_8;
    __nop();
    __nop();
    __nop();
    temp = GPIOC->IDR;
    GPIOA->BSRR |=  GPIO_PIN_8;

    LCD_BusOut();
    GPIOB->BSRR |=  GPIO_PIN_9;

    return temp;
}
/*******************************************************************************
* Function Name  : LCD_PowerOn
* Description    : Power on the LCD.
* Input          : None
* Output         : None
* Return         : None
*******************************************************************************/
void LCD_PowerOn(void)
{
    LCD_WriteReg(R16, 0x0000);
    LCD_WriteReg(R17, 0x0000);
    LCD_WriteReg(R18, 0x0000);
    LCD_WriteReg(R19, 0x0000);
    Delay_LCD(20);
    LCD_WriteReg(R16, 0x17B0);
    LCD_WriteReg(R17, 0x0137);
    Delay_LCD(5);
    LCD_WriteReg(R18, 0x0139);
    Delay_LCD(5);
    LCD_WriteReg(R19, 0x1d00);
    LCD_WriteReg(R41, 0x0013);
    Delay_LCD(5);
    LCD_WriteReg(R7, 0x0173);
}
/*******************************************************************************
* Function Name  : LCD_DisplayOn
* Description    : Enables the Display.
* Input          : None
* Output         : None
* Return         : None
*******************************************************************************/
void LCD_DisplayOn(void)
{
    LCD_WriteReg(R7, 0x0173);
}
/*******************************************************************************
* Function Name  : LCD_DisplayOff
* Description    : Disables the Display.
* Input          : None
* Output         : None
* Return         : None
*******************************************************************************/
void LCD_DisplayOff(void)
{
    LCD_WriteReg(R7, 0x0);
}
/*******************************************************************************
* Function Name  : LCD_CtrlLinesConfig
* Description    : Configures LCD Control lines.
                   Push-Pull mode.
* Input          : None
* Output         : None
* Return         : None
*******************************************************************************/
void LCD_CtrlLinesConfig(void)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};

    __HAL_RCC_GPIOC_CLK_ENABLE();
    __HAL_RCC_GPIOA_CLK_ENABLE();
    __HAL_RCC_GPIOB_CLK_ENABLE();

    GPIO_InitStruct.Pin = GPIO_PIN_5 | GPIO_PIN_8 | GPIO_PIN_9;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    GPIO_InitStruct.Pin =  GPIO_PIN_8 ;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    LCD_BusOut();

    GPIOA->BSRR |= 0x0100;
    GPIOB->BSRR |= 0x0220;
}

/*******************************************************************************
* Function Name  : LCD_BusIn
* Description    : Configures the Parallel interface for LCD(PortC)
* Input          : None
* Output         : None
* Return         : None
*******************************************************************************/
void LCD_BusIn(void)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};

    GPIO_InitStruct.Pin = GPIO_PIN_All;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
}

/*******************************************************************************
* Function Name  : LCD_BusOut
* Description    : Configures the Parallel interface for LCD(PortC)
* Input          : None
* Output         : None
* Return         : None
*******************************************************************************/
void LCD_BusOut(void)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};

    GPIO_InitStruct.Pin = GPIO_PIN_All;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
}

/*******************************************************************************
* Function Name  : LCD_DrawPicture
* Description    : Displays a 16 color picture.
* Input          : - picture: pointer to the picture array.
* Output         : None
* Return         : None
*******************************************************************************/
void LCD_DrawPicture(const u8 *picture)
{
    int index;
    LCD_SetCursor(0x00, 0x0000);

    LCD_WriteRAM_Prepare(); /* Prepare to write GRAM */

    for(index = 0; index < 76800; index++)
    {
        LCD_WriteRAM(picture[2 * index + 1] << 8 | picture[2 * index]);
    }
}

/************************User Defined Functions********************************/
void My_LCD_Init(u16 Background_Color, vu16 Text_Color)
{
  LCD_Init();
  LCD_Clear(Background_Color);
  LCD_SetBackColor(Background_Color);
  LCD_SetTextColor(Text_Color);
  
  LCD_DisplayStringLine(Line0, (uint8_t*)"Hello World!");
  HAL_Delay(5000);
  LCD_Clear(Background_Color);
}

The .h file need you to define by yourselves. And after you add the files’ path and include the .h files, you will be able to use the function and show information, even picture if you like.

Tips:

• The initial background color is white, and we provide a function called LCD_SetBackColor(vu16 Color) which can set the background of your text to any define color as its default color is white.
• However, when you use this function, you may find out that only the space where you show texts will change its background color. And other place is still white. So you need LCD_Clear(u16 Color) which can clear and set the whole LCD to one background color. So we usually set color and clear with the color as necessary step for init.
• After you set the background color, you may want to change the text color for better performance. Then you can write LCD_SetTextColor(vu16 Color). So that you finish all the basic init step.

Key - Trigger mode and event

One key bottom contains different trigger mode such as single-press, double-press, long-press and so on. So it is important to define how you memorize keys’ states and judge its trigger event. In this blog, we use structure to store info of key, and the relevant define as followed.

typedef struct Key
{
  uint8_t long_press;   // long press check (count times)
  uint8_t judge_sta;    // whether the key is press when last time enter callback(when the key is press)
  bool now_key;         // the key state when enter TIM callback
  bool Ispress;         // Flag of key is pressed
}Key;

You need to set a TIM(This blog uses TIM3) and configure its Prescaler and Period value to make your timer enter interrupt callback function every 10ms(the time between twice key check to eliminate the error caused by key itself) one time.

And you need to rewrite the Period elapsed callback function, check and judge the key event in the callback function. The concrete code is below.

Key keys[4] = {0, 0, 0, 0};     // define a list to store 4 keys' structure

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
  // judge which TIMER finish its period(important especially when you have different TIMER callback)
  if (htim->Instance == TIM3)
  {
    // every 10ms(Timer CallBack time) check key state and update the value of now_key
    keys[0].now_key = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_0);
    keys[1].now_key = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1);
    keys[2].now_key = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2);
    keys[3].now_key = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0);
    
    // for every key judge one time
    // judge 1 times per 10ms (Delay to eliminate the error of key)
    for (int i = 0; i < 4; i++)
    {
      switch (keys[i].judge_sta)
      {
        // key wasn't press before
        case 0:
        {
          // the first check is pressed.
          if (keys[i].now_key == 0) keys[i].judge_sta = 1;  // this time the key is check press
          break;
        }
        // key is checked to be pressed last time
        case 1:
        {
          // the second check is also pressed.
          if (keys[i].now_key == 0) 
          {
            keys[i].judge_sta = 2;
            keys[i].Ispress = 1;      // The key is truly pressed
          }
          // the second check failed. It is an error and init again.
          else
          {
            keys[i].judge_sta = 0;
          }
          break;
        }
        case 2:
        {
          if (keys[i].now_key == 1)
          {
            keys[i].judge_sta = 0;  // leave the key and return judge's value. Start next press check.
            // If want a leave check(one press event when leave key)
            // Write: keys[i].Ispress = 1;
          }
          // hold the key
          else
          {
            // judge is 2 unless leave key. The long press is continue plus(limit to 100 -> 1s).
            keys[i].long_press++;
            if (keys[i].long_press >= 100) keys[i].long_press = 100;
          }
          break;
        }
      }
    }
  }
}

The code contains detailed comments which can help you understand how it works. And you can write more judge function with this concept. And the overall method is every 10ms read the keys’ value which is set to high as default.

And as judge is 0 at first, all the key will enter the case:0. And then if this time read pin is low which means the key is pressed, it will set judge to 1. When next 10ms enter the callback function, read pins’ state as well, but this time will enter case:1 as judge is set to 1 at the last 10ms.

If this time read pin is still low(key pressed), set the judge to 2 and Ispress to 1 which indicate that the key is truly pressed. Else, it indicates that it is an error so reset the judge value to 0. The case:2 means only if you leave the key that you can start next event, which avoid continuously triggering if you hold the key. Also I add a long-press check in the case:2.

If you hold the key, the judge is always 2 and enter case:2 every 10ms. In this way, if you enter the case:2, the long_press add one and if you enter for over 100 times we suppose it is a long press and limit it to 100 which means long press.

What is more? You can define a clear function to clear the state value after you read the value in main function which is like:

void clear_keys(void)
{
  for (int i = 0; i < 4; i++)
  {
    keys[i].Ispress = 0;
    keys[i].judge_sta = 0;
    keys[i].long_press = 0;
    keys[i].now_key = 0;
  }
}

Above is all the content for these three modules. I will start the next study log soon, please wait and see!