单片机常见的屏幕驱动移植

已于 2023-10-13 13:20:00 修改
阅读量649 收藏 3
点赞数
分类专栏： 分享 文章标签： 嵌入式硬件
于 2023-10-13 13:06:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38743772/article/details/133807499
版权

目录

一个驱动.c文件的典型模块划分（5）

1. Include files

2. Local type definitions ('typedef')

3. Local pre-processor symbols/macros ('#define')

4. Local variable definitions ('static')

5. Function implementation - global ('extern') and local ('static')

5.1 驱动初始化

5.2 底层函数

一个驱动.c文件的典型模块划分（5）

1. Include files

/*******************************************************************************
 * Include files
 ******************************************************************************/

在文件的顶部列出，.C文件所要包含的头文件

2. Local type definitions ('typedef')

/*******************************************************************************
 * Local type definitions ('typedef')
 ******************************************************************************/
 
/**
 * @brief LCD Device Structure Definition
 */
typedef struct {
    uint16_t u16Dir;        /*!< Direction: 0, Vertical; 1, Horizontal */
    uint16_t u16ID;         /*!< LCD ID */
    uint16_t u16Width;      /*!< LCD Width */
    uint16_t u16Height;     /*!< LCD Heigth */
    uint16_t u16WRamCmd;    /*!< Start to write GRAM */
    uint16_t u16SetXCmd;    /*!< Set X axis */
    uint16_t u16SetYCmd;    /*!< Set Y axis */
} stc_lcd_device_t;

这是基本通用的屏幕参数：

屏幕方向：水平显示，垂直显示

屏幕ID：通过不同方式读取屏幕ID，根据不同ID兼容不同型号的屏幕

屏幕宽度和高度：屏幕真实像素点个数

屏幕写指令：将像素点数据写入GRAM

屏幕坐标设置指令：将指针设置到指定像素点位置

对于屏幕宽高，指的是像素大小，如240*320屏幕，表示屏幕为240*320像素 即76800个像素点，而不是屏幕尺寸。

对于用过的 NT35310 / 9341 / 5310 / 7789 ，其写指令、坐标设置指令都一样，分别是0X2C,0X2A,0X2B。

/**
 * @brief LCD Device Controller Structure Definition
 */
typedef struct {
    volatile uint16_t u16REG;
    volatile uint16_t u16RAM;
} stc_lcd_controller_t;

这是最常用的LCD通讯实现方式，EXMC或FSMC。

EXMC接口一般用 D[0:18] 进行通讯，一般用RGB565即16根数据线进行通讯。

有WR\RD\CS\RS\RST五根控制线，CS用于片选器件，RS用于控制发送数据还是命令，WR和RS分别是写使能和读使能（基本都是低电平有效）。

用EXMC接口驱动LCD屏幕时，其实是把它当成SRAM来用，只不过这个SRAM有2个地址，一个是写寄存器地址，一个是写数据地址。具体可搜索“FSMC驱动LCD的原理”去理解。

具体地址定义如下：

/* Use EXMC A16 as the RS signal */
#define BSP_NT35510_BASE                (0x70000000UL | ((1UL << 17U) - 2UL))

对应到最终写寄存器、写数据，就是直接修改指定地址的数据。

FSMC一般有普通IO模拟、SPI和I2C等方式替代，FMC速率最高，普通IO并行模拟次之。

除此之外，高分辨率屏幕，一般用RGB LCD接口，RGB分别是8位以上的数据线，还有DE数据使能线、VS垂直同步线、HS水平同步线、和DCLK像素时钟线。STM32可以用LTDC接口直接驱动，还有DMA2D图形加速。

3. Local pre-processor symbols/macros ('#define')

/*******************************************************************************
 * Local pre-processor symbols/macros ('#define')
 ******************************************************************************/

/* LCD Scan Direction */
#define LCD_SCAN_DIR                (LCD_SCAN_DIR_L2R_U2D)

定义屏幕扫描方向为从左到右，从上到下

4. Local variable definitions ('static')

/*******************************************************************************
 * Local variable definitions ('static')
 ******************************************************************************/


static stc_lcd_device_t m_stcLcdDevice;

5. Function implementation - global ('extern') and local ('static')

5.1 驱动初始化

static void LCD_XXXX_Config(stc_lcd_controller_t *pstcLCD)

{

        NT35510_WriteReg(pstcLCD, 0xE0); //Set Gamma

        NT35510_WriteData(pstcLCD, 0x0F);

        ...

        NT35510_WriteData(pstcLCD, 0XE1); //Set Gamma

        NT35510_WriteData(pstcLCD, 0x00);

        ...

}

屏幕驱动初始化设置大同小异，也主要是屏幕的寄存器定义基本类似。

基本流程：

1.  复位

2.  进入正常模式或设置模式

3.  显示颜色和方向设置

4.  帧率设置

5.  电源设置

6.  gama设置

不同屏幕的指令可能相同也有可能不一样，

相同驱动ID的屏幕，厂家不同，gama设置以及其它设置也有可能不一样。

具体都需要厂家提高参考代码。

5.2 底层函数

必备的底层函数一览：

void NT35510_Init(stc_lcd_controller_t *pstcLCD);
void NT35510_WriteData(stc_lcd_controller_t *pstcLCD, uint16_t u16Data);
void NT35510_WriteReg(stc_lcd_controller_t *pstcLCD, uint16_t u16Reg);
uint16_t NT35510_ReadData(stc_lcd_controller_t *pstcLCD);
void NT35510_WriteRegData(stc_lcd_controller_t *pstcLCD, uint16_t u16Reg, uint16_t u16Data);
uint16_t NT35510_ReadRegData(stc_lcd_controller_t *pstcLCD, uint16_t u16Reg);
uint16_t NT35510_ReadID(stc_lcd_controller_t *pstcLCD);
void NT35510_DisplayOn(stc_lcd_controller_t *pstcLCD);
void NT35510_DisplayOff(stc_lcd_controller_t *pstcLCD);
uint16_t NT35510_GetPixelWidth(void);
uint16_t NT35510_GetPixelHeight(void);
void NT35510_SetScanDir(stc_lcd_controller_t *pstcLCD, uint16_t u16Dir);
void NT35510_SetDisplayDir(stc_lcd_controller_t *pstcLCD, uint16_t u16Dir);
void NT35510_PrepareWriteRAM(stc_lcd_controller_t *pstcLCD);
void NT35510_SetBackLight(stc_lcd_controller_t *pstcLCD, uint8_t u8PWM);
void NT35510_SetCursor(stc_lcd_controller_t *pstcLCD, uint16_t u16Xpos, uint16_t u16Ypos);
void NT35510_WritePixel(stc_lcd_controller_t *pstcLCD, uint16_t u16Xpos, uint16_t u16Ypos, uint16_t u16RGBCode);
void NT35510_Clear(stc_lcd_controller_t *pstcLCD, uint16_t u16RGBCode);

具体实现：

需要做兼容处理的部分：

NT35510_Init                         驱动初始化

NT35510_ReadID                 读取驱动芯片ID

NT35510_SetScanDir           设置扫描方向 | 宽 高 写指令

void NT35510_Init(stc_lcd_controller_t *pstcLCD)
{
    /* NOP */
    NT35510_WriteRegData(pstcLCD, 0x0000U, 0x00U);

    /* Read ID */
    m_stcLcdDevice.u16ID = NT35510_ReadID(pstcLCD);
	
	/* Chip Init */
	if(m_stcLcdDevice.u16ID == 0x9341){
		LCD_9341_Config(pstcLCD);
	} else if(m_stcLcdDevice.u16ID == 0x7789){
		LCD_7789_Config(pstcLCD);
	} else {
        /* Unsupported LCD */
    }
	
	/* Set LCD cursor */
    NT35510_SetDisplayDir(pstcLCD, LCD_DISPLAY_VERTICAL);

    /* Set cursor */
    NT35510_SetCursor(pstcLCD, 0U, 0U);

    /* Prepare to write to LCD RAM */
    NT35510_PrepareWriteRAM(pstcLCD);
}

/**
 * @brief  Read LCD ID.
 * @param  [in] pstcLCD:                LCD controller @ref stc_lcd_controller_t structure.
 * @retval LCD Register Value.
 */
uint16_t NT35510_ReadID(stc_lcd_controller_t *pstcLCD)
{
    uint16_t u16ID;

    /* Try to read ID: 0x9341 */
    NT35510_WriteReg(pstcLCD, 0xD3U);
    (void)NT35510_ReadData(pstcLCD);                /* dummy read */
    (void)NT35510_ReadData(pstcLCD);                /* read: 0x00 */
    u16ID  = NT35510_ReadData(pstcLCD) << 8;        /* read: 0x93 */
    u16ID |= NT35510_ReadData(pstcLCD);             /* read: 0x41 */
	if (u16ID != 0x9341U) {
        /* Try to read ID: 0x8552 */
        NT35510_WriteReg(pstcLCD, 0x04U);
        (void)NT35510_ReadData(pstcLCD);            /* dummy read */
        (void)NT35510_ReadData(pstcLCD);            /* read: 0x85 */
        u16ID  = NT35510_ReadData(pstcLCD) << 8;    /* read: 0x85 */
        u16ID |= NT35510_ReadData(pstcLCD);         /* read: 0x41 */
        if (u16ID == 0x8552U) {
            u16ID = 0x7789U;                        /* ID convert to: 0x7789 */
        }
		else {
			u16ID = 0U;                         	/* Unsupported LCD */
		}
	}
    return u16ID;
}

/**
 * @brief  Set scan direction.
 * @param  [in] pstcLCD:                LCD controller
 * @param  [in] u16Dir:                 Scan direction
 *         This parameter can be one of the following values:
 *           @arg LCD_SCAN_DIR_L2R_U2D: From left to right && from up to down
 *           @arg LCD_SCAN_DIR_L2R_D2U: From left to right && from down to up
 *           @arg LCD_SCAN_DIR_R2L_U2D: From right to left && from up to down
 *           @arg LCD_SCAN_DIR_R2L_D2U: From right to left && from down to up
 *           @arg LCD_SCAN_DIR_U2D_L2R: From up to down && from left to right
 *           @arg LCD_SCAN_DIR_U2D_R2L: From up to down && from right to left
 *           @arg LCD_SCAN_DIR_D2U_L2R: From down to up && from left to right
 *           @arg LCD_SCAN_DIR_D2U_R2L: From down to up && from right to left
 * @retval None
 */
void NT35510_SetScanDir(stc_lcd_controller_t *pstcLCD, uint16_t u16Dir)
{
    uint16_t u16Temp;
    uint16_t dirreg;
    uint16_t regval = 0U;

    /* when display dir is VERTICAL, 1963 IC change scan-direction, other IC don't change
       when display dir is HORIZONTAL, 1963 IC don't change scan-direction, other IC change */
    if (((0U == m_stcLcdDevice.u16Dir) && (m_stcLcdDevice.u16ID == 0x1963U)) || \
        ((1U == m_stcLcdDevice.u16Dir) && (m_stcLcdDevice.u16ID != 0x1963U))) {
        if (0U == u16Dir) {
            u16Dir = 6U;
        } else if (1U == u16Dir) {
            u16Dir = 7U;
        } else if (2U == u16Dir) {
            u16Dir = 4U;
        } else if (3UL == u16Dir) {
            u16Dir = 5U;
        } else if (4U == u16Dir) {
            u16Dir = 1U;
        } else if (5U == u16Dir) {
            u16Dir = 0U;
        } else if (6U == u16Dir) {
            u16Dir = 3U;
        } else if (7U == u16Dir) {
            u16Dir = 2U;
        } else {
            u16Dir = 6U;
        }
    }

    switch (u16Dir) {
        case LCD_SCAN_DIR_L2R_U2D:
            regval |= ((0U << 7) | (0U << 6) | (0U << 5));
            break;
        case LCD_SCAN_DIR_L2R_D2U:
            regval |= ((1U << 7) | (0U << 6) | (0U << 5));
            break;
        case LCD_SCAN_DIR_R2L_U2D:
            regval |= ((0U << 7) | (1U << 6) | (0U << 5));
            break;
        case LCD_SCAN_DIR_R2L_D2U:
            regval |= ((1U << 7) | (1U << 6) | (0U << 5));
            break;
        case LCD_SCAN_DIR_U2D_L2R:
            regval |= ((0U << 7) | (0U << 6) | (1U << 5));
            break;
        case LCD_SCAN_DIR_U2D_R2L:
            regval |= ((0U << 7) | (1U << 6) | (1U << 5));
            break;
        case LCD_SCAN_DIR_D2U_L2R:
            regval |= ((1U << 7) | (0U << 6) | (1U << 5));
            break;
        case LCD_SCAN_DIR_D2U_R2L:
            regval |= ((1U << 7) | (1U << 6) | (1U << 5));
            break;
        default:
            break;
    }

    if (0x5510U == m_stcLcdDevice.u16ID) {
        dirreg = 0x3600U;
    } else {
        dirreg = 0x36U;
    }

    /* 0x9341 & 0x7789 set BGR bit */
    if ((0x9341U == m_stcLcdDevice.u16ID) || (0x7789U == m_stcLcdDevice.u16ID)) {
        regval |= 0x08U;
    }

    NT35510_WriteRegData(pstcLCD, dirreg, regval);

    /* 1963 don't handle coordinate */
    if (m_stcLcdDevice.u16ID != 0x1963U) {
        if ((regval & 0x20U) > 0U) {
            /* swap X,Y */
            if (m_stcLcdDevice.u16Width < m_stcLcdDevice.u16Height) {
                u16Temp = m_stcLcdDevice.u16Width;
                m_stcLcdDevice.u16Width = m_stcLcdDevice.u16Height;
                m_stcLcdDevice.u16Height = u16Temp;
            }
        } else {
            /* swap X,Y */
            if (m_stcLcdDevice.u16Width > m_stcLcdDevice.u16Height) {
                u16Temp = m_stcLcdDevice.u16Width;
                m_stcLcdDevice.u16Width = m_stcLcdDevice.u16Height;
                m_stcLcdDevice.u16Height = u16Temp;
            }
        }
    }

    /* Set display window size */
	NT35510_WriteReg(pstcLCD, m_stcLcdDevice.u16SetXCmd);
	NT35510_WriteData(pstcLCD, 0U);
	NT35510_WriteData(pstcLCD, 0U);
	NT35510_WriteData(pstcLCD, (m_stcLcdDevice.u16Width - 1U) >> 8);
	NT35510_WriteData(pstcLCD, (m_stcLcdDevice.u16Width - 1U) & 0xFFU);
	NT35510_WriteReg(pstcLCD, m_stcLcdDevice.u16SetYCmd);
	NT35510_WriteData(pstcLCD, 0U);
	NT35510_WriteData(pstcLCD, 0U);
	NT35510_WriteData(pstcLCD, (m_stcLcdDevice.u16Height - 1U) >> 8);
	NT35510_WriteData(pstcLCD, (m_stcLcdDevice.u16Height - 1U) & 0xFFU);
}

/**
 * @brief  Set screen direction.
 * @param  [in] pstcLCD:                LCD controller
 * @param  [in] u16Dir:                 Screen direction
 *         This parameter can be one of the following values:
 *           @arg LCD_DISPLAY_VERTICAL:   LCD vertical display
 *           @arg LCD_DISPLAY_HORIZONTAL: LCD horizontal display
 * @retval None
 */
void NT35510_SetDisplayDir(stc_lcd_controller_t *pstcLCD, uint16_t u16Dir)
{
	/* NT35310 / 9341 / 5310 / 7789 etc */
	m_stcLcdDevice.u16WRamCmd = 0x2CU;
	m_stcLcdDevice.u16SetXCmd = 0x2AU;
	m_stcLcdDevice.u16SetYCmd = 0x2BU;
	m_stcLcdDevice.u16Width  = 320U;
	m_stcLcdDevice.u16Height = 240U;
	
    m_stcLcdDevice.u16Dir = u16Dir;
    NT35510_SetScanDir(pstcLCD, LCD_SCAN_DIR);
}

底层通用函数：

NT35510_WriteData               写数据

NT35510_WriteReg                写寄存器

NT35510_ReadData               读数据

NT35510_WriteRegData         写寄存器数据

NT35510_ReadRegData         读寄存器数据

NT35510_DisplayOn                打开显示

NT35510_DisplayOff                关闭显示

NT35510_GetPixelWidth         获取像素宽度

NT35510_GetPixelHeight        获取像素高度

NT35510_PrepareWriteRAM   写RAM

NT35510_SetCursor                设置坐标

NT35510_WritePixel                写单个像素点颜色

NT35510_Clear                        清屏

/**
 * @brief  Write data on LCD data register.
 * @param  [in] pstcLCD:                LCD controller @ref stc_lcd_controller_t structure.
 * @param  [in] u16Data:                Data to be written
 * @retval None
 */
void NT35510_WriteData(stc_lcd_controller_t *pstcLCD, uint16_t u16Data)
{
    pstcLCD->u16RAM = u16Data;
}

/**
 * @brief  Write register on LCD register.
 * @param  [in] pstcLCD:                LCD controller @ref stc_lcd_controller_t structure.
 * @param  [in] u16Reg:                 Address of the selected register.
 * @retval None
 */
void NT35510_WriteReg(stc_lcd_controller_t *pstcLCD, uint16_t u16Reg)
{
    pstcLCD->u16REG = u16Reg;
}

/**
 * @brief  Read data from LCD data register.
 * @param  [in] pstcLCD:                LCD controller @ref stc_lcd_controller_t structure.
 * @retval Read data.
 */
uint16_t NT35510_ReadData(stc_lcd_controller_t *pstcLCD)
{
    return pstcLCD->u16RAM;
}

/**
 * @brief  Write to the selected LCD register.
 * @param  [in] pstcLCD:                LCD controller @ref stc_lcd_controller_t structure.
 * @param  [in] u16Reg:                 Address of the selected register.
 * @param  [in] u16Data:                Data to be written
 * @retval None
 */
void NT35510_WriteRegData(stc_lcd_controller_t *pstcLCD, uint16_t u16Reg, uint16_t u16Data)
{
    /* Write 16-bit index */
    pstcLCD->u16REG = u16Reg;

    /* Write 16-bit Reg */
    pstcLCD->u16RAM = u16Data;
}

/**
 * @brief  Read the selected LCD register.
 * @param  [in] pstcLCD:                LCD controller @ref stc_lcd_controller_t structure.
 * @param  [in] u16Reg:                 Address of the selected register.
 * @retval Register value
 */
uint16_t NT35510_ReadRegData(stc_lcd_controller_t *pstcLCD, uint16_t u16Reg)
{
    /* Write 16-bit index*/
    pstcLCD->u16REG = u16Reg;

    return pstcLCD->u16RAM;
}

/**
 * @brief  Enable the Display.
 * @param  [in] pstcLCD:                LCD controller
 * @retval None
 */
void NT35510_DisplayOn(stc_lcd_controller_t *pstcLCD)
{
    if (m_stcLcdDevice.u16ID == 0x5510U) {
        NT35510_WriteReg(pstcLCD, 0x2900U);     /* 5510 */
    } else {
        NT35510_WriteReg(pstcLCD, 0x29U);       /* 9341/5310/1963/7789 */
    }
}

/**
 * @brief  Disable the Display.
 * @param  [in] pstcLCD:                LCD controller
 * @retval None
 */
void NT35510_DisplayOff(stc_lcd_controller_t *pstcLCD)
{
    if (m_stcLcdDevice.u16ID == 0x5510U) {
        NT35510_WriteReg(pstcLCD, 0x2800U);     /* 5510 */
    } else {
        NT35510_WriteReg(pstcLCD, 0x28U);       /* 9341/5310/1963/7789 */
    }
}

/**
 * @brief  Get LCD PIXEL WIDTH.
 * @param  None
 * @retval LCD PIXEL WIDTH.
 */
uint16_t NT35510_GetPixelWidth(void)
{
    return m_stcLcdDevice.u16Width;
}

/**
 * @brief  Get LCD PIXEL HEIGHT.
 * @param  None
 * @retval LCD PIXEL HEIGHT.
 */
uint16_t NT35510_GetPixelHeight(void)
{
    return m_stcLcdDevice.u16Height;
}

/**
 * @brief  Prepare to write LCD RAM.
 * @param  [in] pstcLCD:                LCD controller
 * @retval None
 */
void NT35510_PrepareWriteRAM(stc_lcd_controller_t *pstcLCD)
{
    NT35510_WriteReg(pstcLCD, m_stcLcdDevice.u16WRamCmd);
}

/**
 * @brief  Set screen backlight.
 * @param  [in] pstcLCD:                LCD controller
 * @param  [in] u8PWM:                  PWM level
           This parameter can be a value between Min_Data = 0 and Max_Data = 100
 * @retval None
 */
void NT35510_SetBackLight(stc_lcd_controller_t *pstcLCD, uint8_t u8PWM)
{
    float32_t f32PWM = ((float32_t)u8PWM * 2.55F);

    NT35510_WriteReg(pstcLCD, 0xBEU);
    NT35510_WriteData(pstcLCD, 0x05U);
    NT35510_WriteData(pstcLCD, (uint16_t)f32PWM);
    NT35510_WriteData(pstcLCD, 0x01U);
    NT35510_WriteData(pstcLCD, 0xFFU);
    NT35510_WriteData(pstcLCD, 0x00U);
    NT35510_WriteData(pstcLCD, 0x00U);
}

/**
 * @brief  Set Cursor position.
 * @param  [in] pstcLCD:                LCD controller
 * @param  u16Xpos:                     Specifies the X position.
 * @param  u16Ypos:                     Specifies the Y position.
 * @retval None
 */
void NT35510_SetCursor(stc_lcd_controller_t *pstcLCD, uint16_t u16Xpos, uint16_t u16Ypos)
{
	NT35510_WriteReg(pstcLCD, m_stcLcdDevice.u16SetXCmd);
	NT35510_WriteData(pstcLCD, (u16Xpos >> 8));
	NT35510_WriteData(pstcLCD, (u16Xpos & 0xFFU));
	NT35510_WriteReg(pstcLCD, m_stcLcdDevice.u16SetYCmd);
	NT35510_WriteData(pstcLCD, (u16Ypos >> 8));
	NT35510_WriteData(pstcLCD, (u16Ypos & 0xFFU));
}

/**
 * @brief  Write pixel.
 * @param  [in] pstcLCD:                LCD controller
 * @param  u16Xpos:                     Specifies the X position.
 * @param  u16Ypos:                     Specifies the Y position.
 * @param  u16RGBCode:                  The RGB pixel color in RGB565 format
 * @retval None
 */
void NT35510_WritePixel(stc_lcd_controller_t *pstcLCD, uint16_t u16Xpos, uint16_t u16Ypos, uint16_t u16RGBCode)
{
    /* Set cursor */
    NT35510_SetCursor(pstcLCD, u16Xpos, u16Ypos);

    /* Prepare to write to LCD RAM */
    NT35510_PrepareWriteRAM(pstcLCD);

    NT35510_WriteData(pstcLCD, u16RGBCode);
}

/**
 * @brief  Clear screen.
 * @param  [in] pstcLCD:                LCD controller
 * @param  u16RGBCode:                  The RGB pixel color in RGB565 format
 * @retval None
 */
void NT35510_Clear(stc_lcd_controller_t *pstcLCD, uint16_t u16RGBCode)
{
    uint32_t i;
    uint32_t u32TotalPoint;

    /* Set cursor */
    NT35510_SetCursor(pstcLCD, 0U, 0U);

    /* Prepare to write to LCD RAM */
    NT35510_PrepareWriteRAM(pstcLCD);

    u32TotalPoint = (uint32_t)m_stcLcdDevice.u16Width * (uint32_t)m_stcLcdDevice.u16Height;

    for (i = 0UL; i < u32TotalPoint; i++) {
        NT35510_WriteData(pstcLCD, u16RGBCode);
    }
}

5.3 画线

利用差值法画线。包括水平线、垂直线、斜线。

画线是最基本的函数，基于画线函数可以衍生出画圆、画弧线、画矩形等多种图形。

/**
 * @brief  Draw line.
 * @param  [in] pstcLCD:                LCD controller
 * @param  u16X1:                       Specifies the X position 1.
 * @param  u16X2:                       Specifies the X position 2.
 * @param  u16Y1:                       Specifies the Y position 1.
 * @param  u16Y2:                       Specifies the Y position 2.
 * @param  u16RGBCode:                  The RGB pixel color in RGB565 format
 * @retval None
 */
void NT35510_DrawLine(stc_lcd_controller_t *pstcLCD, uint16_t u16X1, uint16_t u16Y1,
                      uint16_t u16X2, uint16_t u16Y2, uint16_t u16RGBCode)
{
    int16_t t;
    int16_t xerr = 0;
    int16_t yerr = 0;
    int16_t delta_x;
    int16_t delta_y;
    int16_t distance;
    int16_t incx;
    int16_t incy;
    int16_t Row;
    int16_t Col;

    Row = (int16_t)u16X1;
    Col = (int16_t)u16Y1;
    delta_x = ((int16_t)u16X2 - (int16_t)u16X1);      /* calc delta X, Y*/
    delta_y = ((int16_t)u16Y2 - (int16_t)u16Y1);

    if (delta_x > 0) {
        incx = 1;           /* forward u8Direction */
    } else if (delta_x == 0) {
        incx = 0;           /* vertical line */
    } else {
        incx = -1;          /* reverse direction */
        delta_x = -delta_x;
    }

    if (delta_y > 0) {
        incy = 1;             /* downward direction */
    } else if (delta_y == 0) {
        incy = 0;             /* horizontal line */
    } else {
        incy = -1;            /* upward direction */
        delta_y = -delta_y;
    }

    if (delta_x > delta_y) {
        distance = delta_x; /* set axis */
    } else {
        distance = delta_y;
    }

    for (t = 0; t <= (distance + 1); t++) {
        NT35510_WritePixel(pstcLCD, (uint16_t)Row, (uint16_t)Col, u16RGBCode);   /* draw pixel */

        xerr += delta_x ;
        yerr += delta_y ;

        if (xerr > distance) {
            xerr -= distance;
            Row += incx;
        }

        if (yerr > distance) {
            yerr -= distance;
            Col += incy;
        }
    }
}
 

Bresenham算法画圆


/**
 * @brief  Draw a circle.
 * @param  [in] pstcLCD:                LCD controller
 * @param  [in]                         u16Xpos: X position
 * @param  [in]                         u16Ypos: Y position
 * @param  [in]                         u16Radius: Circle radius
 * @param  u16RGBCode:                  The RGB pixel color in RGB565 format
 * @retval None
 */
void NT35510_DrawCircle(stc_lcd_controller_t *pstcLCD, uint16_t u16Xpos, uint16_t u16Ypos,
                        uint16_t u16Radius, uint16_t u16RGBCode)
{
    int32_t  decision;       /* Decision Variable */
    uint32_t current_x;      /* Current X Value */
    uint32_t current_y;      /* Current Y Value */

    decision = 3 - ((int32_t)u16Radius * 2);
    current_x = 0U;
    current_y = u16Radius;

    while (current_x <= current_y) {
        NT35510_WritePixel(pstcLCD, (u16Xpos + (uint16_t)current_x), (u16Ypos - (uint16_t)current_y), u16RGBCode);
        NT35510_WritePixel(pstcLCD, (u16Xpos + (uint16_t)current_y), (u16Ypos - (uint16_t)current_x), u16RGBCode);
        NT35510_WritePixel(pstcLCD, (u16Xpos + (uint16_t)current_y), (u16Ypos + (uint16_t)current_x), u16RGBCode);
        NT35510_WritePixel(pstcLCD, (u16Xpos + (uint16_t)current_x), (u16Ypos + (uint16_t)current_y), u16RGBCode);
        NT35510_WritePixel(pstcLCD, (u16Xpos - (uint16_t)current_x), (u16Ypos + (uint16_t)current_y), u16RGBCode);
        NT35510_WritePixel(pstcLCD, (u16Xpos - (uint16_t)current_y), (u16Ypos + (uint16_t)current_x), u16RGBCode);
        NT35510_WritePixel(pstcLCD, (u16Xpos - (uint16_t)current_x), (u16Ypos - (uint16_t)current_y), u16RGBCode);
        NT35510_WritePixel(pstcLCD, (u16Xpos - (uint16_t)current_y), (u16Ypos - (uint16_t)current_x), u16RGBCode);
        current_x++;
        /* Bresenham algorithm */
        if (decision < 0) {
            decision += ((4 * (int32_t)current_x) + 6);
        } else {
            decision += (10 + (4 * ((int32_t)current_x - (int32_t)current_y)));
            current_y--;
        }
    }
}

5.4 显示图片

像素点其实就是：

1）事先将要显示的图，转化成位图，确定每个像素点要显示的颜色

2）依次显示这些点

基于这种方法，可以衍生出显示文字符合、特殊图像等等。

不过该方法对内存要求高，需要占用RAM或ROM 来存储这些像素点颜色数据。

/**
 * @brief  Show Picture.
 * @param  [in] pstcLCD:                LCD controller
 * @param  u16RGBCode:                  The RGB pixel color in RGB565 format
 * @retval None
 */
void NT35510_Picture(stc_lcd_controller_t *pstcLCD, uint16_t *pu16RGBData)
{
    uint32_t i;
    uint32_t u32TotalPoint;

    /* Set cursor */
    NT35510_SetCursor(pstcLCD, 0U, 0U);

    /* Prepare to write to LCD RAM */
    NT35510_PrepareWriteRAM(pstcLCD);

    u32TotalPoint = (uint32_t)m_stcLcdDevice.u16Width * (uint32_t)m_stcLcdDevice.u16Height;

    for (i = 0UL; i < u32TotalPoint; i++) {
        NT35510_WriteData(pstcLCD, pu16RGBData[i]);
    }
}

猪熊
关注
专栏目录
GD32F303开发之EXMC与LCD显示
qq_41335522的博客
09-06 5762
介绍LCD显示控制芯片NT35510和驱动NT35510芯片的EXMC外设的工作原理，在LCD显示模块上绘制出DAC实验的正弦波
TFT_LCD 驱动芯片 SSD1963QL9
zhejfl的博客
12-05 5998
SSD1963
3.5寸TFT液晶屏验证板设计过程——硬件篇
ic2121的博客
10-31 4226
3.5寸液晶屏采用MCU16bit通信，可以说是采用该种通信方式中可以做的最大尺寸了，3.5寸以上的尺寸一般通过RGB方式通信，根据目前手中可用的MCU，可选STM32F103VCT6（或者GD32F303VCT6），选择的原因就是就是100pin的MCU带FSMC（或者EXMC），相比较目前的市场环境，优先选择国产的GD32F303VCT6，原因就是便宜。：通信模块的通信功能主要是USB和串口，均为预留功能用于调试使用，再硬件方面，接口比较简单，其中串口通过查询MCU的技术手册，选用以下两个引脚，
【程序】STM32F107VC单片机驱动DP83848以太网PHY芯片，移植lwip 2.1.2协议栈，并加入网线热插拔检测的功能（HAL库）
01-06
Keil5工程下载地址：https://pan.baidu.com/s/1Uf0eRFB35_-Sw_ovQf2Kwg（提取码：694k） 开发板： 杜邦线传输高速数字信号容易出错，所以在用面包板搭建开发环境时，最好使用25MHz时钟的MII接口。如果要用50MHz的RMII接口，那么杜邦线必须要非常非常短，否则时钟信号一旦失真，就无法收发数据！ 如果DP83848的运行时钟是由单片机的PA8 MCO引脚输出的，那么DP83848的复位引脚一定要接一个下拉电阻。当单片机没有启动的时候，这个下拉电阻会使DP83848处于复位状态。因为单片机没有运行的时候，DP83848没有时钟信号，如果此时D
[综合信息]华大HC32F460之ADC
ic2121的博客
08-17 3727
当序列 A 全部通道转换结束时，序列 A 转换结束标志位 ADC_ISR.EOCAF 置 1，并产生序列 A 转换结束事件 ADC_EOCA，若 ADC_ISCR.EOCAIEN 为 1，中断许可的状态下，同时产生序列 A 转换结束中断请求。当序列 B 全部通道转换结束时，序列 B 转换结束标志位 ADC_ISR.EOCBF 置 1，并产生序列 B 转换结束事件 ADC_EOCB，若ADC_ISCR.EOCBIEN 为 1，中断许可的状态下，同时产生序列 B 转换结束中断请求。...
STM32H750驱动触摸屏【支持STM32H7系列单片机_HAL库驱动】.zip
02-14
在STM32H750驱动程序中，HAL库驱动通常包括初始化、数据读写、中断处理等函数，对于触摸屏驱动，可能还会有坐标转换、触摸事件检测等功能。 STM32H7系列单片机的特性包括： 1. 高性能：Cortex-M7内核，工作频率高达...
STM32F103单片机开发例程-UCGUI触摸屏驱动移植代码(4.3寸、5.0寸、7.0寸驱动芯片SSD1963横竖屏)
03-18
1、嵌入式物联网单片机项目开发实战。例程经过精心编写，简单好用。 2、代码使用KEIL 标准库开发，当前在STM32F103运行，如果是STM32F103其他型号芯片，依然适用，请自行更改KEIL芯片型号以及FLASH容量即可。 3、...
STM32F103单片机开发例程-UCGUI触摸屏驱动移植代码(2.4寸、2.8寸、3.2寸驱动芯片ILI9325横竖屏)
03-18
1、嵌入式物联网单片机项目开发实战。例程经过精心编写，简单好用。 2、代码使用KEIL 标准库开发，当前在STM32F103运行，如果是STM32F103其他型号芯片，依然适用，请自行更改KEIL芯片型号以及FLASH容量即可。 3、...
3.2寸触摸屏驱动（屏幕驱动芯片ILI9341，触摸屏驱动芯片XPT2046）
06-11
在这个场景中，我们关注的是一个3.2英寸的触摸屏，其驱动主要包括两部分：屏幕驱动芯片ILI9341和触摸屏驱动芯片XPT2046。 ili9341是一款广泛应用的TFT LCD控制器，它支持RGB接口，可以驱动多种分辨率的显示屏。在...
Linux 内核 5 寸触摸屏驱动移植
weixin_51332399的博客
06-04 143
Linux 内核 5 寸触摸屏驱动移植
24_EXMC_SDRAM_TLI_IPA.zip
01-20
MCU型号为GD32F450IGH6+SDRAM+液晶屏 SDRAM型号为MT48LC16MA2P-6AIT 液晶屏TFT接口，由HX8257-A驱动芯片和XPT2046电阻式触摸控制器进行控制，厂家是雪微电子
GD32VF103-LCD:通过Logan Nano板将LCD驱动器转换为GD32VF103
03-07
GD32VF103-液晶显示器 通过Logan Nano板将LCD驱动器转换为GD32VF103。 开发中使用的生态系统是Bronzebeard（ ）
正点原子STM32F4探索者开发板HAL库TFT LCD屏幕例程移植到STM32CubeMX+CLion
weixin_45449477的博客
05-10 6547
前言 在学习STM32时，跟着教程学标准库都是用Keil软件开发，HAL库配套的例程也是Keil开发的， 同时发现配套例程的HAL库程序的硬件配置代码都是自己编写的，而在网上搜的HAL库程序都是用STM32CubeMX+Keil编写的，而这种方法极大的节省了硬件配置的时间，但是对于Keil的风格并不太满意，于是跟着网上的教程搭了CLion编写STM32程序的平台…
STM32 OLED显示屏移植工程方法
Lushengshi的博客
07-19 666
移植操作
LCD显示器的接口协议
路过的熊的博客
10-22 1359
LCD显示器的接口协议
【GD32F427开发板试用】EXMC方式驱动LCD屏幕
weixin_47569031的博客
01-29 1810
本篇文章来自极术社区与兆易创新组织的GD32F427开发板评测活动，更多开发板试用活动请关注极术社区网站。作者：[小会]
单片机驱动LCD
m0_61687959的博客
11-28 1826
在讨论怎么写LCD驱动之前，我们先大概了解一下嵌入式常用LCD。概述一些跟驱动架构设计有关的概念，在此不对原理和细节做深入讨论，会有专门文章介绍，或者参考网络文档。TFT lcdTFT LCD，也就是我们常说的彩屏。通常像素较高，例如常见的2.8寸，320X240像素。4.0寸的，像素800X400。这些屏通常使用并口，也就是8080或6800接口（STM32 的FSMC接口）；或者是RGB接口，STM32F429等芯片支持。其他例如手机上使用的有MIPI接口。总之，接口种类很多。
小花语音机器人(零)-单片机控制驱动板PCB
qq_44179528的博客
11-24 1877
2019年11月24日，心来来潮准备做一块机器人的综合控制驱动板。 板载stm32f103rct6芯片，工作频率72Mhz，配合8eeprom。搭配了3.7v电池供电及充电系统，无线通讯，舵机拓展端口，直流电机驱动端口，红外定位以，串口屏驱动端口以及串口驱动 第一部分：单片机基础控制单元； boot这里我直接把模式连接好了，单片机供电采用了MIC5205芯片，把5V的板载电压转换为3.3V电压稳...
使用STM32实现LCD显示
最新发布
2401_85258012的博客
09-08 699
接下来，我将为您提供一个使用STM32实现LCD显示内容的示例代码。请注意，由于LCD的规格和接口类型可能有所不同，您需要根据您使用的LCD进行适当的修改。这是一个简单的示例代码，用于在STM32上实现LCD显示内容。请将示例代码中的GPIO引脚和LCD命令/数据根据您实际使用的硬件进行适当修改。配置LCD控制器：根据LCD的规格和接口类型，需要配置STM32的LCD控制器，使其能够正确地与LCD进行通信。LCD（液晶显示器）是一种常用的平面显示技术，使用电场对液晶材料进行控制，从而显示图像或文本。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

猪熊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值