开源社区 技术问答 口碑评测 资料下载

萤火工场GD32VW553国产开发板ST7789V2驱动

分享作者：topwolx
评测品牌：萤火工场
评测型号：GD32VW553-IOT
发布时间：2026-01-06 10:19:32
1
视频链接
https://www.bilibili.com/video/BV12uv9BUEMq
概要
本次基于ICEasy商城免费申请的萤火工场GD32VW553国产开发板，点亮一块ST7789V2驱动的屏幕
开源口碑分享内容

一、接线

二、代码

## 主程序逻辑 (main.c)

```c
#include "gd32vw55x.h"
#include "systick.h"
#include <stdio.h>
#include "main.h"
#include "gd32vw553h_eval.h"
#include "lcd_init.h"
#include "lcd.h"
#include "pic.h"

void led_spark(void)
{
    static __IO uint32_t timingdelaylocal = 0U;

    if(timingdelaylocal) {
        if(timingdelaylocal < 500U) {
            gd_eval_led_on(LED1);
        } else {
            gd_eval_led_off(LED1);
        }
        timingdelaylocal--;
    } else {
        timingdelaylocal = 1000U;
    }
}

int main(void)
{
#ifdef __FIRMWARE_VERSION_DEFINE
    uint32_t fw_ver = 0;
#endif

    systick_config();
    eclic_priority_group_set(ECLIC_PRIGROUP_LEVEL3_PRIO1);
    gd_eval_led_init(LED1);
    gd_eval_com_init(EVAL_COM0);
    gd_eval_key_init(KEY_TAMPER_WAKEUP, KEY_MODE_GPIO);

#ifdef __FIRMWARE_VERSION_DEFINE
    fw_ver = gd32vw55x_firmware_version_get();
    printf("\r\n= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =\r\n\n");
    printf("\r\nGD32VW55X series firmware version: V%d.%d.%d", (uint8_t)(fw_ver >> 24), (uint8_t)(fw_ver >> 16), (uint8_t)(fw_ver >> 8));
#endif

    printf("\r\nCK_SYS is %d\r\n", rcu_clock_freq_get(CK_SYS));
    printf("\r\nCK_AHB is %d\r\n", rcu_clock_freq_get(CK_AHB));
    printf("\r\nCK_APB1 is %d\r\n", rcu_clock_freq_get(CK_APB1));
    printf("\r\nCK_APB2 is %d\r\n", rcu_clock_freq_get(CK_APB2));

    float t = 0;

    LCD_Init();

    LCD_Fill(0,0,LCD_W,LCD_H,WHITE);
    delay_1ms(1000);

    LCD_Fill(0,0,LCD_W,LCD_H,RED);
    delay_1ms(1000);

    LCD_Fill(0,0,LCD_W,LCD_H,GREEN);
    delay_1ms(1000);

    LCD_Fill(0,0,LCD_W,LCD_H,BLUE);
    delay_1ms(1000);

    LCD_Fill(0,0,LCD_W,LCD_H,WHITE);
    delay_1ms(1000);
    while(1)
    {
        LCD_ShowString(0,0,"www.iceasy.com",RED,WHITE,32,0);
        LCD_ShowString(40,33,"GD32VW553",RED,WHITE,32,0);
        LCD_ShowString(10,66,"LCD_W:",RED,WHITE,32,0);
        LCD_ShowIntNum(106,66,LCD_W,3,RED,WHITE,32);
        LCD_ShowString(10,99,"LCD_H:",RED,WHITE,32,0);
        LCD_ShowIntNum(106,99,LCD_H,3,RED,WHITE,32);
        LCD_ShowFloatNum1(10,132,t,4,RED,WHITE,32);
        t+=0.11;
        LCD_ShowPicture(160,128,40,40,gImage_1);

        delay_1ms(100);
    }
}
```

## 中断服务程序 (gd32vw55x_it.c)

```c
#include "gd32vw55x_it.h"
#include "main.h"
#include "systick.h"

void eclic_mtip_handler(void)
{
    ECLIC_ClearPendingIRQ(CLIC_INT_TMR);
    led_spark();
    delay_decrement();
}
```

## 系统滴答定时器 (systick.c)

```c
#include "gd32vw55x.h"
#include "systick.h"

volatile static uint32_t delay;

void systick_config(void)
{
    SysTimer_SetControlValue(SysTimer_MTIMECTL_CMPCLREN_Msk);
    SysTimer_SetCompareValue(SystemCoreClock / 4000);
    __ECLIC_SetTrigIRQ(CLIC_INT_TMR, ECLIC_POSTIVE_EDGE_TRIGGER);
    eclic_irq_enable(CLIC_INT_TMR, 0, 0);
}

void delay_1us(uint32_t count)
{
    uint64_t ticks;
    uint64_t told, tnow;
    uint64_t tcnt = 0;
    uint64_t reload = SysTimer_GetCompareValue();

    ticks = (uint64_t)count * ((SystemCoreClock / 4) / 1000000);

    told = (uint64_t)SysTimer->MTIMER;

    while (1)
    {
        tnow = (uint64_t)SysTimer->MTIMER;

        if (tnow != told)
        {
            if (tnow < told)
            {
                tcnt += (reload - told) + tnow;
            }
            else
            {
                tcnt += tnow - told;
            }

            told = tnow;

            if (tcnt >= ticks)
            {
                break;
            }
        }
    }
}

void delay_1ms(uint32_t count)
{
    delay = count;
    while(0U != delay) {
    }
}

void delay_decrement(void)
{
    if(0U != delay) {
        delay--;
    }
}
```

## LCD初始化 (lcd_init.c)

```c
#include "lcd_init.h"
#include "systick.h"

#ifndef delay_ms
#define delay_ms(x)  delay_1ms(x)
#endif

#ifndef delay_us
#define delay_us(x)  delay_1us(x)
#endif

void LCD_GPIO_Init(void)
{
    LCD_RCU_ENABLE();

    gpio_af_set(LCD_SCL_PORT, LCD_SCL_AF, LCD_SCL_PIN);
    gpio_af_set(LCD_SDA_PORT, LCD_SDA_AF, LCD_SDA_PIN);
    gpio_mode_set(LCD_SCL_PORT, GPIO_MODE_AF, GPIO_PUPD_NONE, LCD_SCL_PIN);
    gpio_mode_set(LCD_SDA_PORT, GPIO_MODE_AF, GPIO_PUPD_NONE, LCD_SDA_PIN);
    gpio_mode_set(LCD_RES_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_PULLUP, LCD_RES_PIN);
    gpio_mode_set(LCD_DC_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_PULLUP, LCD_DC_PIN);
    gpio_mode_set(LCD_CS_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_PULLUP, LCD_CS_PIN);
    gpio_mode_set(LCD_BLK_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_PULLUP, LCD_BLK_PIN);
    gpio_output_options_set(LCD_SCL_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_MAX, LCD_SCL_PIN);
    gpio_output_options_set(LCD_SDA_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_MAX, LCD_SDA_PIN);
    gpio_output_options_set(LCD_RES_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_MAX, LCD_RES_PIN);
    gpio_output_options_set(LCD_DC_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_MAX, LCD_DC_PIN);
    gpio_output_options_set(LCD_CS_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_MAX, LCD_CS_PIN);
    gpio_output_options_set(LCD_BLK_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_MAX, LCD_BLK_PIN);

    LCD_CS_Set();
    LCD_DC_Set();

    spi_parameter_struct spi_init_struct;
    spi_init_struct.trans_mode             = SPI_TRANSMODE_FULLDUPLEX;
    spi_init_struct.device_mode            = SPI_MASTER;
    spi_init_struct.frame_size             = SPI_FRAMESIZE_8BIT;
    spi_init_struct.clock_polarity_phase   = SPI_CK_PL_HIGH_PH_2EDGE;
    spi_init_struct.nss                    = SPI_NSS_SOFT;
    spi_init_struct.prescale               = SPI_PSC_4;
    spi_init_struct.endian                 = SPI_ENDIAN_MSB;

    spi_init(&spi_init_struct);

    spi_enable();
}

void LCD_Writ_Bus(u8 dat)
{
    uint8_t recv_data = 0;

    LCD_CS_Clr();

    while(RESET == spi_flag_get(SPI_FLAG_TBE) );
    spi_data_transmit(dat);

    while(RESET == spi_flag_get(SPI_FLAG_RBNE) );
    recv_data = spi_data_receive();

    LCD_CS_Set();

    return recv_data;
}

void LCD_WR_DATA8(u8 dat)
{
    LCD_Writ_Bus(dat);
}

void LCD_WR_DATA(u16 dat)
{
    LCD_Writ_Bus(dat>>8);
    LCD_Writ_Bus(dat);
}

void LCD_WR_REG(u8 dat)
{
    LCD_DC_Clr();
    LCD_Writ_Bus(dat);
    LCD_DC_Set();
}

void LCD_Address_Set(u16 x1,u16 y1,u16 x2,u16 y2)
{
    if(USE_HORIZONTAL==0)
    {
        LCD_WR_REG(0x2a);
        LCD_WR_DATA(x1);
        LCD_WR_DATA(x2);
        LCD_WR_REG(0x2b);
        LCD_WR_DATA(y1);
        LCD_WR_DATA(y2);
        LCD_WR_REG(0x2c);
    }
    else if(USE_HORIZONTAL==1)
    {
        LCD_WR_REG(0x2a);
        LCD_WR_DATA(x1);
        LCD_WR_DATA(x2);
        LCD_WR_REG(0x2b);
        LCD_WR_DATA(y1);
        LCD_WR_DATA(y2);
        LCD_WR_REG(0x2c);
    }
    else if(USE_HORIZONTAL==2)
    {
        LCD_WR_REG(0x2a);
        LCD_WR_DATA(x1);
        LCD_WR_DATA(x2);
        LCD_WR_REG(0x2b);
        LCD_WR_DATA(y1);
        LCD_WR_DATA(y2);
        LCD_WR_REG(0x2c);
    }
    else
    {
        LCD_WR_REG(0x2a);
        LCD_WR_DATA(x1);
        LCD_WR_DATA(x2);
        LCD_WR_REG(0x2b);
        LCD_WR_DATA(y1);
        LCD_WR_DATA(y2);
        LCD_WR_REG(0x2c);
    }
}

void LCD_Init(void)
{
    LCD_GPIO_Init();
    
    LCD_RES_Clr();
    delay_ms(100);
    LCD_RES_Set();
    delay_ms(100);
    
    LCD_BLK_Set();
    delay_ms(100);
    
    LCD_WR_REG(0x11);
    delay_ms(120);
    LCD_WR_REG(0x36);
    if(USE_HORIZONTAL==0)LCD_WR_DATA8(0x00);
    else if(USE_HORIZONTAL==1)LCD_WR_DATA8(0xC0);
    else if(USE_HORIZONTAL==2)LCD_WR_DATA8(0x70);
    else LCD_WR_DATA8(0xA0);

    LCD_WR_REG(0x3A);
    LCD_WR_DATA8(0x05);

    LCD_WR_REG(0xB2);
    LCD_WR_DATA8(0x0C);
    LCD_WR_DATA8(0x0C);
    LCD_WR_DATA8(0x00);
    LCD_WR_DATA8(0x33);
    LCD_WR_DATA8(0x33);

    LCD_WR_REG(0xB7);
    LCD_WR_DATA8(0x35);

    LCD_WR_REG(0xBB);
    LCD_WR_DATA8(0x32);

    LCD_WR_REG(0xC2);
    LCD_WR_DATA8(0x01);

    LCD_WR_REG(0xC3);
    LCD_WR_DATA8(0x15);

    LCD_WR_REG(0xC4);
    LCD_WR_DATA8(0x20);

    LCD_WR_REG(0xC6);
    LCD_WR_DATA8(0x0F);

    LCD_WR_REG(0xD0);
    LCD_WR_DATA8(0xA4);
    LCD_WR_DATA8(0xA1);

    LCD_WR_REG(0xE0);
    LCD_WR_DATA8(0xD0);
    LCD_WR_DATA8(0x08);
    LCD_WR_DATA8(0x0E);
    LCD_WR_DATA8(0x09);
    LCD_WR_DATA8(0x09);
    LCD_WR_DATA8(0x05);
    LCD_WR_DATA8(0x31);
    LCD_WR_DATA8(0x33);
    LCD_WR_DATA8(0x48);
    LCD_WR_DATA8(0x17);
    LCD_WR_DATA8(0x14);
    LCD_WR_DATA8(0x15);
    LCD_WR_DATA8(0x31);
    LCD_WR_DATA8(0x34);

    LCD_WR_REG(0xE1);
    LCD_WR_DATA8(0xD0);
    LCD_WR_DATA8(0x08);
    LCD_WR_DATA8(0x0E);
    LCD_WR_DATA8(0x09);
    LCD_WR_DATA8(0x09);
    LCD_WR_DATA8(0x15);
    LCD_WR_DATA8(0x31);
    LCD_WR_DATA8(0x33);
    LCD_WR_DATA8(0x48);
    LCD_WR_DATA8(0x17);
    LCD_WR_DATA8(0x14);
    LCD_WR_DATA8(0x15);
    LCD_WR_DATA8(0x31);
    LCD_WR_DATA8(0x34);
    LCD_WR_REG(0x20);

    LCD_WR_REG(0x29);
}
```

## LCD显示功能 (lcd.c)

```c
#include "lcd.h"
#include "lcd_init.h"
#include "lcdfont.h"
#include "systick.h"

void LCD_Fill(u16 xsta,u16 ysta,u16 xend,u16 yend,u16 color)
{
    u16 i,j;
    LCD_Address_Set(xsta,ysta,xend-1,yend-1);
    for(i=ysta;i<yend;i++)
    {
        for(j=xsta;j<xend;j++)
        {
            LCD_WR_DATA(color);
        }
    }
}

void LCD_DrawPoint(u16 x,u16 y,u16 color)
{
    LCD_Address_Set(x,y,x,y);
    LCD_WR_DATA(color);
}

void LCD_DrawLine(u16 x1,u16 y1,u16 x2,u16 y2,u16 color)
{
    u16 t;
    int xerr=0,yerr=0,delta_x,delta_y,distance;
    int incx,incy,uRow,uCol;
    delta_x=x2-x1;
    delta_y=y2-y1;
    uRow=x1;
    uCol=y1;
    if(delta_x>0)incx=1;
    else if (delta_x==0)incx=0;
    else {incx=-1;delta_x=-delta_x;}
    if(delta_y>0)incy=1;
    else if (delta_y==0)incy=0;
    else {incy=-1;delta_y=-delta_y;}
    if(delta_x>delta_y)distance=delta_x;
    else distance=delta_y;
    for(t=0;t<distance+1;t++)
    {
        LCD_DrawPoint(uRow,uCol,color);
        xerr+=delta_x;
        yerr+=delta_y;
        if(xerr>distance)
        {
            xerr-=distance;
            uRow+=incx;
        }
        if(yerr>distance)
        {
            yerr-=distance;
            uCol+=incy;
        }
    }
}

void LCD_DrawRectangle(u16 x1, u16 y1, u16 x2, u16 y2,u16 color)
{
    LCD_DrawLine(x1,y1,x2,y1,color);
    LCD_DrawLine(x1,y1,x1,y2,color);
    LCD_DrawLine(x1,y2,x2,y2,color);
    LCD_DrawLine(x2,y1,x2,y2,color);
}

void Draw_Circle(u16 x0,u16 y0,u8 r,u16 color)
{
    int a,b;
    a=0;b=r;
    while(a<=b)
    {
        LCD_DrawPoint(x0-b,y0-a,color);
        LCD_DrawPoint(x0+b,y0-a,color);
        LCD_DrawPoint(x0-a,y0+b,color);
        LCD_DrawPoint(x0-a,y0-b,color);
        LCD_DrawPoint(x0+b,y0+a,color);
        LCD_DrawPoint(x0+a,y0-b,color);
        LCD_DrawPoint(x0+a,y0+b,color);
        LCD_DrawPoint(x0-b,y0+a,color);
        a++;
        if((a*a+b*b)>(r*r))
        {
            b--;
        }
    }
}

void LCD_ShowChinese(u16 x,u16 y,u8 *s,u16 fc,u16 bc,u8 sizey,u8 mode)
{
    while(*s!=0)
    {
        if(sizey==12) LCD_ShowChinese12x12(x,y,s,fc,bc,sizey,mode);
        else if(sizey==16) LCD_ShowChinese16x16(x,y,s,fc,bc,sizey,mode);
        else if(sizey==24) LCD_ShowChinese24x24(x,y,s,fc,bc,sizey,mode);
        else if(sizey==32) LCD_ShowChinese32x32(x,y,s,fc,bc,sizey,mode);
        else return;
        s+=3;
        x+=sizey;
    }
}

void LCD_ShowChinese12x12(u16 x,u16 y,u8 *s,u16 fc,u16 bc,u8 sizey,u8 mode)
{
    u8 i,j,m=0;
    u16 k;
    u16 HZnum;
    u16 TypefaceNum;
    u16 x0=x;
    TypefaceNum=(sizey/8+((sizey%8)?1:0))*sizey;

    HZnum=sizeof(tfont12)/sizeof(typFNT_GB12);
    for(k=0;k<HZnum;k++)
    {
        if((tfont12[k].Index[0]==*(s))&&(tfont12[k].Index[1]==*(s+1)))
        {
            LCD_Address_Set(x,y,x+sizey-1,y+sizey-1);
            for(i=0;i<TypefaceNum;i++)
            {
                for(j=0;j<8;j++)
                {
                    if(!mode)
                    {
                        if(tfont12[k].Msk[i]&(0x01<<j))LCD_WR_DATA(fc);
                        else LCD_WR_DATA(bc);
                        m++;
                        if(m%sizey==0)
                        {
                            m=0;
                            break;
                        }
                    }
                    else
                    {
                        if(tfont12[k].Msk[i]&(0x01<<j))	LCD_DrawPoint(x,y,fc);
                        x++;
                        if((x-x0)==sizey)
                        {
                            x=x0;
                            y++;
                            break;
                        }
                    }
                }
            }
        }
        continue;
    }
}

void LCD_ShowChinese16x16(u16 x,u16 y,u8 *s,u16 fc,u16 bc,u8 sizey,u8 mode)
{
    u8 i,j,m=0;
    u16 k;
    u16 HZnum;
    u16 TypefaceNum;
    u16 x0=x;
    TypefaceNum=(sizey/8+((sizey%8)?1:0))*sizey;
    HZnum=sizeof(tfont16)/sizeof(typFNT_GB16);
    for(k=0;k<HZnum;k++)
    {
        if ((tfont16[k].Index[0]==*(s))&&(tfont16[k].Index[1]==*(s+1)))
        {
            LCD_Address_Set(x,y,x+sizey-1,y+sizey-1);
            for(i=0;i<TypefaceNum;i++)
            {
                for(j=0;j<8;j++)
                {
                    if(!mode)
                    {
                        if(tfont16[k].Msk[i]&(0x01<<j))LCD_WR_DATA(fc);
                        else LCD_WR_DATA(bc);
                        m++;
                        if(m%sizey==0)
                        {
                            m=0;
                            break;
                        }
                    }
                    else
                    {
                        if(tfont16[k].Msk[i]&(0x01<<j))	LCD_DrawPoint(x,y,fc);
                        x++;
                        if((x-x0)==sizey)
                        {
                            x=x0;
                            y++;
                            break;
                        }
                    }
                }
            }
        }
        continue;
    }
}

void LCD_ShowChinese24x24(u16 x,u16 y,u8 *s,u16 fc,u16 bc,u8 sizey,u8 mode)
{
    u8 i,j,m=0;
    u16 k;
    u16 HZnum;
    u16 TypefaceNum;
    u16 x0=x;
    TypefaceNum=(sizey/8+((sizey%8)?1:0))*sizey;
    HZnum=sizeof(tfont24)/sizeof(typFNT_GB24);
    for(k=0;k<HZnum;k++)
    {
        if ((tfont24[k].Index[0]==*(s))&&(tfont24[k].Index[1]==*(s+1)))
        {
            LCD_Address_Set(x,y,x+sizey-1,y+sizey-1);
            for(i=0;i<TypefaceNum;i++)
            {
                for(j=0;j<8;j++)
                {
                    if(!mode)
                    {
                        if(tfont24[k].Msk[i]&(0x01<<j))LCD_WR_DATA(fc);
                        else LCD_WR_DATA(bc);
                        m++;
                        if(m%sizey==0)
                        {
                            m=0;
                            break;
                        }
                    }
                    else
                    {
                        if(tfont24[k].Msk[i]&(0x01<<j))	LCD_DrawPoint(x,y,fc);
                        x++;
                        if((x-x0)==sizey)
                        {
                            x=x0;
                            y++;
                            break;
                        }
                    }
                }
            }
        }
        continue;
    }
}

void LCD_ShowChinese32x32(u16 x,u16 y,u8 *s,u16 fc,u16 bc,u8 sizey,u8 mode)
{
    u8 i,j,m=0;
    u16 k;
    u16 HZnum;
    u16 TypefaceNum;
    u16 x0=x;
    TypefaceNum=(sizey/8+((sizey%8)?1:0))*sizey;
    HZnum=sizeof(tfont32)/sizeof(typFNT_GB32);
    for(k=0;k<HZnum;k++)
    {
        if ((tfont32[k].Index[0]==*(s))&&(tfont32[k].Index[1]==*(s+1)))
        {
            LCD_Address_Set(x,y,x+sizey-1,y+sizey-1);
            for(i=0;i<TypefaceNum;i++)
            {
                for(j=0;j<8;j++)
                {
                    if(!mode)
                    {
                        if(tfont32[k].Msk[i]&(0x01<<j))LCD_WR_DATA(fc);
                        else LCD_WR_DATA(bc);
                        m++;
                        if(m%sizey==0)
                        {
                            m=0;
                            break;
                        }
                    }
                    else
                    {
                        if(tfont32[k].Msk[i]&(0x01<<j))	LCD_DrawPoint(x,y,fc);
                        x++;
                        if((x-x0)==sizey)
                        {
                            x=x0;
                            y++;
                            break;
                        }
                    }
                }
            }
        }
        continue;
    }
}

void LCD_ShowChar(u16 x,u16 y,u8 num,u16 fc,u16 bc,u8 sizey,u8 mode)
{
    u8 temp,sizex,t,m=0;
    u16 i,TypefaceNum;
    u16 x0=x;
    sizex=sizey/2;
    TypefaceNum=(sizex/8+((sizex%8)?1:0))*sizey;
    num=num-' ';
    LCD_Address_Set(x,y,x+sizex-1,y+sizey-1);
    for(i=0;i<TypefaceNum;i++)
    {
        if(sizey==12)temp=ascii_1206[num][i];
        else if(sizey==16)temp=ascii_1608[num][i];
        else if(sizey==24)temp=ascii_2412[num][i];
        else if(sizey==32)temp=ascii_3216[num][i];
        else return;
        for(t=0;t<8;t++)
        {
            if(!mode)
            {
                if(temp&(0x01<<t))LCD_WR_DATA(fc);
                else LCD_WR_DATA(bc);
                m++;
                if(m%sizex==0)
                {
                    m=0;
                    break;
                }
            }
            else
            {
                if(temp&(0x01<<t))LCD_DrawPoint(x,y,fc);
                x++;
                if((x-x0)==sizex)
                {
                    x=x0;
                    y++;
                    break;
                }
            }
        }
    }
}

void LCD_ShowString(u16 x,u16 y,const u8 *p,u16 fc,u16 bc,u8 sizey,u8 mode)
{
    while(*p!='\0')
    {
        LCD_ShowChar(x,y,*p,fc,bc,sizey,mode);
        x+=sizey/2;
        p++;
    }
}

u32 mypow(u8 m,u8 n)
{
    u32 result=1;
    while(n--)result*=m;
    return result;
}

void LCD_ShowIntNum(u16 x,u16 y,u16 num,u8 len,u16 fc,u16 bc,u8 sizey)
{
    u8 t,temp;
    u8 enshow=0;
    u8 sizex=sizey/2;
    for(t=0;t<len;t++)
    {
        temp=(num/mypow(10,len-t-1))%10;
        if(enshow==0&&t<(len-1))
        {
            if(temp==0)
            {
                LCD_ShowChar(x+t*sizex,y,' ',fc,bc,sizey,0);
                continue;
            }else enshow=1;
        }
        LCD_ShowChar(x+t*sizex,y,temp+48,fc,bc,sizey,0);
    }
}

void LCD_ShowFloatNum1(u16 x,u16 y,float num,u8 len,u16 fc,u16 bc,u8 sizey)
{
    u8 t,temp,sizex;
    u16 num1;
    sizex=sizey/2;
    num1=num*100;
    for(t=0;t<len;t++)
    {
        temp=(num1/mypow(10,len-t-1))%10;
        if(t==(len-2))
        {
            LCD_ShowChar(x+(len-2)*sizex,y,'.',fc,bc,sizey,0);
            t++;
            len+=1;
        }
        LCD_ShowChar(x+t*sizex,y,temp+48,fc,bc,sizey,0);
    }
}

void LCD_ShowPicture(u16 x,u16 y,u16 length,u16 width,const u8 pic[])
{
    u16 i,j;
    u32 k=0;
    LCD_Address_Set(x,y,x+length-1,y+width-1);
    for(i=0;i<length;i++)
    {
        for(j=0;j<width;j++)
        {
            LCD_WR_DATA8(pic[k*2]);
            LCD_WR_DATA8(pic[k*2+1]);
            k++;
        }
    }
}
```


全部评论
暂无评论
0/144
    • 联系我们
    • 服务热线：
    • 客服邮箱：
    • 服务时间：周一至周五 9:00-17:00
    • 联系地址：珠海市横琴新区福临道55号906办公-1

    iCEasy公众号

    iCEasy商城
    品牌索引：
    ams OSRAM AWINIC EPSON iceasy MK Founder Molex Murata Electronics Nexperia NVIDIA Orient Quectel RENESAS Seeed Studio StarFive WUQI 高通 海凌科 航顺芯片 华润微电子 江波龙 乐鑫 灵动微电子 日清纺微电子 上海贝岭 圣邦微电子 树莓派 小华半导体 野火 萤火工场 兆易创新 正点原子
    友情链接 （400-626-1616转1）
    热门友链：
    中电港 芯查查 iCEasy商城海外站
    原厂友链：
    Phytium飞腾 兆易创新GD32 物奇微电子 小华半导体 艾为电子 航顺芯片 扬兴晶振 润石半导体 中国星坤连接 雷卯电子TVS ESD 米客方德 飞虹半导体 台容积电 轮趣科技 中科云 进迭时空 赛昉科技 奥伦德 龙芯中科 移柯通信 庆科信息
    行业友链：
    元器件商城
    © 粤公网安备44040002000016 营业执照
    增值电信业务经营许可证