libs/rt-thread
libs
/
rt-thread
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
rt-thread/bsp/stm32/stm32h750-weact-ministm32h7xx/board/port/st7735/st7735.c

1089 lines
28 KiB
C
Raw Normal View History

[bsp/stm32] add weact mini stm32h7xx board bsp
2022-10-16 20:42:31 +08:00
/**
******************************************************************************
* @file st7735.c
* @author MCD Application Team
* @brief This file includes the driver for ST7735 LCD mounted on the Adafruit
* 1.8" TFT LCD shield (reference ID 802).
******************************************************************************
* @attention
*
* <h2><center>&copy; Copyright (c) 2018 STMicroelectronics.
* All rights reserved.</center></h2>
*
* This software component is licensed by ST under BSD 3-Clause license,
* the "License"; You may not use this file except in compliance with the
* License. You may obtain a copy of the License at:
* opensource.org/licenses/BSD-3-Clause
*
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include <rtthread.h>
#include <rtdevice.h>
#include <board.h>
#include "st7735.h"
#define DRV_DEBUG
#define LOG_TAG "st7735"
#include <drv_log.h>
#define IS_BOE_PANEL (0)
/** @addtogroup BSP
* @{
*/
/** @addtogroup Components
* @{
*/
/** @addtogroup ST7735
* @brief This file provides a set of functions needed to drive the
* ST7735 LCD.
* @{
*/
/** @defgroup ST7735_Private_Types Private Types
* @{
*/
typedef struct
{
uint32_t Width;
uint32_t Height;
uint32_t Orientation;
} ST7735_Ctx_t;
/**
* @}
*/
/** @defgroup ST7735_Private_Variables Private Variables
* @{
*/
ST7735_LCD_Drv_t ST7735_LCD_Driver =
{
ST7735_Init,
ST7735_DeInit,
ST7735_ReadID,
ST7735_DisplayOn,
ST7735_DisplayOff,
ST7735_SetBrightness,
ST7735_GetBrightness,
ST7735_SetOrientation,
ST7735_GetOrientation,
ST7735_SetCursor,
ST7735_DrawBitmap,
ST7735_FillRGBRect,
ST7735_DrawHLine,
ST7735_DrawVLine,
ST7735_FillRect,
ST7735_GetPixel,
ST7735_SetPixel,
ST7735_GetXSize,
ST7735_GetYSize,
};
/* The below table handle the different values to be set to Memory Data Access Control
depending on the orientation and pbm image writing where the data order is inverted
*/
static uint32_t OrientationTab[4][2] =
{
{0x48U , 0xC8U}, /* Portrait orientation choice of LCD screen */
[bsp/stm32] format code
2022-10-16 20:42:31 +08:00
{0x88U , 0x08U}, /* Portrait rotated 180° orientation choice of LCD screen */
[bsp/stm32] add weact mini stm32h7xx board bsp
2022-10-16 20:42:31 +08:00
{0x28U , 0x68U}, /* Landscape orientation choice of LCD screen */
[bsp/stm32] format code
2022-10-16 20:42:31 +08:00
{0xE8U , 0xA8U} /* Landscape rotated 180° orientation choice of LCD screen */
[bsp/stm32] add weact mini stm32h7xx board bsp
2022-10-16 20:42:31 +08:00
};
static ST7735_Ctx_t ST7735Ctx;
/**
* @}
*/
/** @defgroup ST7735_Private_FunctionsPrototypes Private Functions Prototypes
* @{
*/
static int32_t ST7735_SetDisplayWindow(ST7735_Object_t *pObj, uint32_t Xpos, uint32_t Ypos, uint32_t Width, uint32_t Height);
static int32_t ST7735_ReadRegWrap(void *Handle, uint8_t Reg, uint8_t* pData);
static int32_t ST7735_WriteRegWrap(void *Handle, uint8_t Reg, uint8_t *pData, uint32_t Length);
static int32_t ST7735_SendDataWrap(void *Handle, uint8_t *pData, uint32_t Length);
static int32_t ST7735_RecvDataWrap(void *Handle, uint8_t *pData, uint32_t Length);
static int32_t ST7735_IO_Delay(ST7735_Object_t *pObj, uint32_t Delay);
/**
* @}
*/
/** @addtogroup ST7735_Exported_Functions
* @{
*/
/**
* @brief Register component IO bus
* @param pObj Component object pointer
* @param pIO Component IO structure pointer
* @retval Component status
*/
int32_t ST7735_RegisterBusIO (ST7735_Object_t *pObj, ST7735_IO_t *pIO)
{
int32_t ret;
if(pObj == NULL)
{
ret = ST7735_ERROR;
}
else
{
pObj->IO.Init = pIO->Init;
pObj->IO.DeInit = pIO->DeInit;
pObj->IO.Address = pIO->Address;
pObj->IO.WriteReg = pIO->WriteReg;
pObj->IO.ReadReg = pIO->ReadReg;
pObj->IO.SendData = pIO->SendData;
pObj->IO.RecvData = pIO->RecvData;
pObj->IO.GetTick = pIO->GetTick;
pObj->Ctx.ReadReg = ST7735_ReadRegWrap;
pObj->Ctx.WriteReg = ST7735_WriteRegWrap;
pObj->Ctx.SendData = ST7735_SendDataWrap;
pObj->Ctx.RecvData = ST7735_RecvDataWrap;
pObj->Ctx.handle = pObj;
if(pObj->IO.Init != NULL)
{
ret = pObj->IO.Init();
}
else
{
ret = ST7735_ERROR;
}
}
return ret;
}
/**
* @brief Initialize the st7735 LCD Component.
* @param pObj Component object
* @param ColorCoding RGB mode
* @param Orientation Display orientation
* @retval Component status
*/
int32_t ST7735_Init(ST7735_Object_t *pObj, uint32_t ColorCoding, uint32_t Orientation)
{
uint8_t tmp;
int32_t ret;
if(pObj == NULL)
{
ret = ST7735_ERROR;
}
else
{
[bsp/stm32] format code
2022-10-16 20:42:31 +08:00
/* Out of sleep mode, 0 args, delay 120ms */
[bsp/stm32] add weact mini stm32h7xx board bsp
2022-10-16 20:42:31 +08:00
tmp = 0x00U;
ret = st7735_write_reg(&pObj->Ctx, ST7735_SW_RESET, &tmp, 0);
[bsp/stm32] format code
2022-10-16 20:42:31 +08:00
(void)ST7735_IO_Delay(pObj, 120);
[bsp/stm32] add weact mini stm32h7xx board bsp
2022-10-16 20:42:31 +08:00
/* Out of sleep mode, 0 args, no delay */
tmp = 0x00U;
ret += st7735_write_reg(&pObj->Ctx, ST7735_SLEEP_OUT, &tmp, 1);
[bsp/stm32] format code
2022-10-16 20:42:31 +08:00
/* Frame rate ctrl - normal mode, 3 args:Rate = fosc/(1x2+40) * (LINE+2C+2D)*/
[bsp/stm32] add weact mini stm32h7xx board bsp
2022-10-16 20:42:31 +08:00
ret += st7735_write_reg(&pObj->Ctx, ST7735_FRAME_RATE_CTRL1, &tmp, 0);
tmp = 0x01U;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x2CU;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x2DU;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
/* Frame rate control - idle mode, 3 args:Rate = fosc/(1x2+40) * (LINE+2C+2D) */
tmp = 0x01U;
ret += st7735_write_reg(&pObj->Ctx, ST7735_FRAME_RATE_CTRL2, &tmp, 1);
tmp = 0x2CU;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x2DU;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
/* Frame rate ctrl - partial mode, 6 args: Dot inversion mode, Line inversion mode */
tmp = 0x01U;
ret += st7735_write_reg(&pObj->Ctx, ST7735_FRAME_RATE_CTRL3, &tmp, 1);
tmp = 0x2CU;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x2DU;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x01U;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x2CU;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x2DU;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
/* Display inversion ctrl, 1 arg, no delay: No inversion */
tmp = 0x07U;
ret += st7735_write_reg(&pObj->Ctx, ST7735_FRAME_INVERSION_CTRL, &tmp, 1);
/* Power control, 3 args, no delay: -4.6V , AUTO mode */
tmp = 0xA2U;
ret += st7735_write_reg(&pObj->Ctx, ST7735_PWR_CTRL1, &tmp, 1);
tmp = 0x02U;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x84U;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
/* Power control, 1 arg, no delay: VGH25 = 2.4C VGSEL = -10 VGH = 3 * AVDD */
tmp = 0xC5U;
ret += st7735_write_reg(&pObj->Ctx, ST7735_PWR_CTRL2, &tmp, 1);
/* Power control, 2 args, no delay: Opamp current small, Boost frequency */
tmp = 0x0AU;
ret += st7735_write_reg(&pObj->Ctx, ST7735_PWR_CTRL3, &tmp, 1);
tmp = 0x00U;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
/* Power control, 2 args, no delay: BCLK/2, Opamp current small & Medium low */
tmp = 0x8AU;
ret += st7735_write_reg(&pObj->Ctx, ST7735_PWR_CTRL4, &tmp, 1);
tmp = 0x2AU;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
/* Power control, 2 args, no delay */
tmp = 0x8AU;
ret += st7735_write_reg(&pObj->Ctx, ST7735_PWR_CTRL5, &tmp, 1);
tmp = 0xEEU;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
/* Power control, 1 arg, no delay */
tmp = 0x0EU;
ret += st7735_write_reg(&pObj->Ctx, ST7735_VCOMH_VCOML_CTRL1, &tmp, 1);
#if IS_BOE_PANEL
/* Not Invert display, no args, no delay */
ret += st7735_write_reg(&pObj->Ctx, ST7735_DISPLAY_INVERSION_OFF, &tmp, 0);
#else
/* Invert display, no args, no delay */
ret += st7735_write_reg(&pObj->Ctx, ST7735_DISPLAY_INVERSION_ON, &tmp, 0);
#endif
/* Set color mode, 1 arg, no delay */
ret += st7735_write_reg(&pObj->Ctx, ST7735_COLOR_MODE, (uint8_t*)&ColorCoding, 1);
/* Magical unicorn dust, 16 args, no delay */
tmp = 0x02U;
ret += st7735_write_reg(&pObj->Ctx, ST7735_PV_GAMMA_CTRL, &tmp, 1);
tmp = 0x1CU;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x07U;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x12U;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x37U;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x32U;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x29U;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x2DU;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x29U;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x25U;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x2BU;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x39U;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x00U;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x01U;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x03U;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x10U;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
/* Sparkles and rainbows, 16 args, no delay */
tmp = 0x03U;
ret += st7735_write_reg(&pObj->Ctx, ST7735_NV_GAMMA_CTRL, &tmp, 1);
tmp = 0x1DU;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x07U;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x06U;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x2EU;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x2CU;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x29U;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x2DU;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x2EU;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x2EU;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x37U;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x3FU;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x00U;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x00U;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x02U;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = 0x10U;
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
/* Normal display on, no args, no delay */
tmp = 0x00U;
ret += st7735_write_reg(&pObj->Ctx, ST7735_NORMAL_DISPLAY_OFF, &tmp, 1);
/* Main screen turn on, no delay */
ret += st7735_write_reg(&pObj->Ctx, ST7735_DISPLAY_ON, &tmp, 1);
/* Set the display Orientation and the default display window */
ret += ST7735_SetOrientation(pObj, Orientation);
}
if(ret != ST7735_OK)
{
LOG_E("error %d", ret);
ret = ST7735_ERROR;
}
return ret;
}
/**
* @brief De-Initialize the st7735 LCD Component.
* @param pObj Component object
* @retval Component status
*/
int32_t ST7735_DeInit(ST7735_Object_t *pObj)
{
(void)(pObj);
return ST7735_OK;
}
/**
* @brief Get the st7735 ID.
* @param pObj Component object
* @param Id Component ID
* @retval The component status
*/
int32_t ST7735_ReadID(ST7735_Object_t *pObj, uint32_t *Id)
{
int32_t ret;
uint8_t tmp[3];
if(st7735_read_reg(&pObj->Ctx, ST7735_READ_ID1, &tmp[0]) != ST7735_OK)
{
ret = ST7735_ERROR;
}
else if(st7735_read_reg(&pObj->Ctx, ST7735_READ_ID2, &tmp[1]) != ST7735_OK)
{
ret = ST7735_ERROR;
}
[bsp/stm32] format code
2022-10-16 20:42:31 +08:00
else if(st7735_read_reg(&pObj->Ctx, ST7735_READ_ID3, &tmp[2]) != ST7735_OK)
[bsp/stm32] add weact mini stm32h7xx board bsp
2022-10-16 20:42:31 +08:00
{
ret = ST7735_ERROR;
}
else
{
*Id = ((uint32_t)tmp[2])<<0| ((uint32_t)tmp[1])<<8 | ((uint32_t)tmp[0])<<16;
[bsp/stm32] format code
2022-10-16 20:42:31 +08:00
//*Id = __rbit(*Id);
[bsp/stm32] add weact mini stm32h7xx board bsp
2022-10-16 20:42:31 +08:00
ret = ST7735_OK;
}
return ret;
}
/**
* @brief Enables the Display.
* @param pObj Component object
* @retval The component status
*/
int32_t ST7735_DisplayOn(ST7735_Object_t *pObj)
{
int32_t ret;
uint8_t tmp = 0;
ret = st7735_write_reg(&pObj->Ctx, ST7735_NORMAL_DISPLAY_OFF, &tmp, 0);
(void)ST7735_IO_Delay(pObj, 10);
ret += st7735_write_reg(&pObj->Ctx, ST7735_DISPLAY_ON, &tmp, 0);
(void)ST7735_IO_Delay(pObj, 10);
ret += st7735_write_reg(&pObj->Ctx, ST7735_MADCTL, &tmp, 0);
tmp = (uint8_t)OrientationTab[ST7735Ctx.Orientation][1];
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
if(ret != ST7735_OK)
{
ret = ST7735_ERROR;
}
return ret;
}
/**
* @brief Disables the Display.
* @param pObj Component object
* @retval The component status
*/
int32_t ST7735_DisplayOff(ST7735_Object_t *pObj)
{
int32_t ret;
uint8_t tmp = 0;
ret = st7735_write_reg(&pObj->Ctx, ST7735_NORMAL_DISPLAY_OFF, &tmp, 0);
(void)ST7735_IO_Delay(pObj, 10);
ret += st7735_write_reg(&pObj->Ctx, ST7735_DISPLAY_OFF, &tmp, 0);
(void)ST7735_IO_Delay(pObj, 10);
ret += st7735_write_reg(&pObj->Ctx, ST7735_MADCTL, &tmp, 0);
tmp = (uint8_t)OrientationTab[ST7735Ctx.Orientation][1];
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
if(ret != ST7735_OK)
{
ret = ST7735_ERROR;
}
return ret;
}
/**
* @brief Set the display brightness.
* @param pObj Component object
* @param Brightness display brightness to be set
* @retval Component status
*/
int32_t ST7735_SetBrightness(ST7735_Object_t *pObj, uint32_t Brightness)
{
(void)(pObj);
(void)(Brightness);
/* Feature not supported */
return ST7735_ERROR;
}
/**
* @brief Get the display brightness.
* @param pObj Component object
* @param Brightness display brightness to be returned
* @retval Component status
*/
int32_t ST7735_GetBrightness(ST7735_Object_t *pObj, uint32_t *Brightness)
{
(void)(pObj);
(void)(Brightness);
/* Feature not supported */
return ST7735_ERROR;
}
/**
* @brief Set the Display Orientation.
* @param pObj Component object
* @param Orientation ST7735_ORIENTATION_PORTRAIT, ST7735_ORIENTATION_PORTRAIT_ROT180
* ST7735_ORIENTATION_LANDSCAPE or ST7735_ORIENTATION_LANDSCAPE_ROT180
* @retval The component status
*/
int32_t ST7735_SetOrientation(ST7735_Object_t *pObj, uint32_t Orientation)
{
int32_t ret;
uint8_t tmp;
if((Orientation == ST7735_ORIENTATION_PORTRAIT) || (Orientation == ST7735_ORIENTATION_PORTRAIT_ROT180))
{
ST7735Ctx.Width = ST7735_WIDTH;
ST7735Ctx.Height = ST7735_HEIGHT;
}
else
{
ST7735Ctx.Width = ST7735_HEIGHT;
ST7735Ctx.Height = ST7735_WIDTH;
}
[bsp/stm32] format code
2022-10-16 20:42:31 +08:00
ST7735Ctx.Orientation = Orientation;
[bsp/stm32] add weact mini stm32h7xx board bsp
2022-10-16 20:42:31 +08:00
ret = ST7735_SetDisplayWindow(pObj, 0U, 0U, ST7735Ctx.Width, ST7735Ctx.Height);
tmp = (uint8_t)OrientationTab[Orientation][1];
ret += st7735_write_reg(&pObj->Ctx, ST7735_MADCTL, &tmp, 1);
if(ret != ST7735_OK)
{
ret = ST7735_ERROR;
}
return ret;
}
/**
* @brief Set the Display Orientation.
* @param pObj Component object
* @param Orientation ST7735_ORIENTATION_PORTRAIT, ST7735_ORIENTATION_LANDSCAPE
* or ST7735_ORIENTATION_LANDSCAPE_ROT180
* @retval The component status
*/
int32_t ST7735_GetOrientation(ST7735_Object_t *pObj, uint32_t *Orientation)
{
*Orientation = ST7735Ctx.Orientation;
return ST7735_OK;
}
/**
* @brief Set Cursor position.
* @param pObj Component object
* @param Xpos specifies the X position.
* @param Ypos specifies the Y position.
* @retval The component status
*/
int32_t ST7735_SetCursor(ST7735_Object_t *pObj, uint32_t Xpos, uint32_t Ypos)
{
int32_t ret;
uint8_t tmp;
[bsp/stm32] format code
2022-10-16 20:42:31 +08:00
/* Cursor calibration */
if(ST7735Ctx.Orientation <= ST7735_ORIENTATION_PORTRAIT_ROT180)
{
[bsp/stm32] add weact mini stm32h7xx board bsp
2022-10-16 20:42:31 +08:00
#if IS_BOE_PANEL
[bsp/stm32] format code
2022-10-16 20:42:31 +08:00
Xpos += 24;
Ypos += 0;
[bsp/stm32] add weact mini stm32h7xx board bsp
2022-10-16 20:42:31 +08:00
#else
[bsp/stm32] format code
2022-10-16 20:42:31 +08:00
Xpos += 26;
Ypos += 1;
[bsp/stm32] add weact mini stm32h7xx board bsp
2022-10-16 20:42:31 +08:00
#endif
[bsp/stm32] format code
2022-10-16 20:42:31 +08:00
}
else
{
[bsp/stm32] add weact mini stm32h7xx board bsp
2022-10-16 20:42:31 +08:00
#if IS_BOE_PANEL
[bsp/stm32] format code
2022-10-16 20:42:31 +08:00
Xpos += 0;
Ypos += 24;
[bsp/stm32] add weact mini stm32h7xx board bsp
2022-10-16 20:42:31 +08:00
#else
[bsp/stm32] format code
2022-10-16 20:42:31 +08:00
Xpos += 1;
Ypos += 26;
[bsp/stm32] add weact mini stm32h7xx board bsp
2022-10-16 20:42:31 +08:00
#endif
[bsp/stm32] format code
2022-10-16 20:42:31 +08:00
}
[bsp/stm32] add weact mini stm32h7xx board bsp
2022-10-16 20:42:31 +08:00
ret = st7735_write_reg(&pObj->Ctx, ST7735_CASET, &tmp, 0);
tmp = (uint8_t)(Xpos >> 8U);
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = (uint8_t)(Xpos & 0xFFU);
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
ret += st7735_write_reg(&pObj->Ctx, ST7735_RASET, &tmp, 0);
tmp = (uint8_t)(Ypos >> 8U);
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = (uint8_t)(Ypos & 0xFFU);
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
ret += st7735_write_reg(&pObj->Ctx, ST7735_WRITE_RAM, &tmp, 0);
if(ret != ST7735_OK)
{
ret = ST7735_ERROR;
}
return ret;
}
/**
* @brief Displays a bitmap picture.
* @param pObj Component object
* @param Xpos Bmp X position in the LCD
* @param Ypos Bmp Y position in the LCD
* @param pBmp Bmp picture address.
* @retval The component status
*/
int32_t ST7735_DrawBitmap(ST7735_Object_t *pObj, uint32_t Xpos, uint32_t Ypos, uint8_t *pBmp)
{
int32_t ret = ST7735_OK;
uint32_t index, size, width, height, y_pos;
uint8_t pixel_val[2], tmp;
uint8_t *pbmp;
uint32_t counter = 0;
/* Get bitmap data address offset */
index = (uint32_t)pBmp[10] + ((uint32_t)pBmp[11] << 8) + ((uint32_t)pBmp[12] << 16) + ((uint32_t)pBmp[13] << 24);
/* Read bitmap width */
width = (uint32_t)pBmp[18] + ((uint32_t)pBmp[19] << 8) + ((uint32_t)pBmp[20] << 16) + ((uint32_t)pBmp[21] << 24);
/* Read bitmap height */
height = (uint32_t)pBmp[22] + ((uint32_t)pBmp[23] << 8) + ((uint32_t)pBmp[24] << 16) + ((uint32_t)pBmp[25] << 24);
/* Read bitmap size */
size = (uint32_t)pBmp[2] + ((uint32_t)pBmp[3] << 8) + ((uint32_t)pBmp[4] << 16) + ((uint32_t)pBmp[5] << 24);
size = size - index;
pbmp = pBmp + index;
/* Remap Ypos, st7735 works with inverted X in case of bitmap */
/* X = 0, cursor is on Top corner */
y_pos = ST7735Ctx.Height - Ypos - height;
if(ST7735_SetDisplayWindow(pObj, Xpos, y_pos, width, height) != ST7735_OK)
{
ret = ST7735_ERROR;
}
else
{
/* Set GRAM write direction and BGR = 0 */
tmp = (uint8_t)OrientationTab[ST7735Ctx.Orientation][0];
if(st7735_write_reg(&pObj->Ctx, ST7735_MADCTL, &tmp, 1) != ST7735_OK)
{
ret = ST7735_ERROR;
}/* Set Cursor */
else if(ST7735_SetCursor(pObj, Xpos, y_pos) != ST7735_OK)
{
ret = ST7735_ERROR;
}
else
{
do
{
pixel_val[0] = *(pbmp + 1);
pixel_val[1] = *(pbmp);
if(st7735_send_data(&pObj->Ctx, pixel_val, 2U) != ST7735_OK)
{
ret = ST7735_ERROR;
break;
}
counter +=2U;
pbmp += 2;
}while(counter < size);
tmp = (uint8_t)OrientationTab[ST7735Ctx.Orientation][1];
if(st7735_write_reg(&pObj->Ctx, ST7735_MADCTL, &tmp, 1) != ST7735_OK)
{
ret = ST7735_ERROR;
}
else
{
if(ST7735_SetDisplayWindow(pObj, 0U, 0U, ST7735Ctx.Width, ST7735Ctx.Height) != ST7735_OK)
{
ret = ST7735_ERROR;
}
}
}
}
return ret;
}
/**
* @brief Draws a full RGB rectangle
* @param pObj Component object
* @param Xpos specifies the X position.
* @param Ypos specifies the Y position.
* @param pData pointer to RGB data
* @param Width specifies the rectangle width.
* @param Height Specifies the rectangle height
* @retval The component status
*/
int32_t ST7735_FillRGBRect(ST7735_Object_t *pObj, uint32_t Xpos, uint32_t Ypos, uint8_t *pData, uint32_t Width, uint32_t Height)
{
int32_t ret = ST7735_OK;
static uint8_t pdata[640];
uint8_t *rgb_data = pData;
uint32_t i, j;
if(((Xpos + Width) > ST7735Ctx.Width) || ((Ypos + Height) > ST7735Ctx.Height))
{
ret = ST7735_ERROR;
}/* Set Cursor */
else
{
for(j = 0; j < Height; j++)
{
if(ST7735_SetCursor(pObj, Xpos, Ypos+j) != ST7735_OK)
{
ret = ST7735_ERROR;
}
else
{
for(i = 0; i < Width; i++)
{
pdata[2U*i] = (uint8_t)(*(rgb_data));
pdata[(2U*i) + 1U] = (uint8_t)(*(rgb_data + 1));
rgb_data +=2;
}
if(st7735_send_data(&pObj->Ctx, (uint8_t*)&pdata[0], 2U*Width) != ST7735_OK)
{
ret = ST7735_ERROR;
}
}
}
}
return ret;
}
/**
* @brief Draw Horizontal line.
* @param pObj Component object
* @param Xpos specifies the X position.
* @param Ypos specifies the Y position.
* @param Length specifies the Line length.
* @param Color Specifies the RGB color in RGB565 format
* @retval The component status
*/
int32_t ST7735_DrawHLine(ST7735_Object_t *pObj, uint32_t Xpos, uint32_t Ypos, uint32_t Length, uint32_t Color)
{
int32_t ret = ST7735_OK;
uint32_t i;
static uint8_t pdata[640];
if((Xpos + Length) > ST7735Ctx.Width)
{
ret = ST7735_ERROR;
}/* Set Cursor */
else if(ST7735_SetCursor(pObj, Xpos, Ypos) != ST7735_OK)
{
ret = ST7735_ERROR;
}
else
{
for(i = 0; i < Length; i++)
{
/* Exchange LSB and MSB to fit LCD specification */
pdata[2U*i] = (uint8_t)(Color >> 8);
pdata[(2U*i) + 1U] = (uint8_t)(Color);
// pdata[(2U*i) + 1U] = (uint8_t)(Color >> 8);
// pdata[2U*i] = (uint8_t)(Color);
}
if(st7735_send_data(&pObj->Ctx, (uint8_t*)&pdata[0], 2U*Length) != ST7735_OK)
{
ret = ST7735_ERROR;
}
}
return ret;
}
/**
* @brief Draw vertical line.
* @param pObj Component object
* @param Color Specifies the RGB color
* @param Xpos specifies the X position.
* @param Ypos specifies the Y position.
* @param Length specifies the Line length.
* @retval The component status
*/
int32_t ST7735_DrawVLine(ST7735_Object_t *pObj, uint32_t Xpos, uint32_t Ypos, uint32_t Length, uint32_t Color)
{
int32_t ret = ST7735_OK;
uint32_t counter;
if((Ypos + Length) > ST7735Ctx.Height)
{
ret = ST7735_ERROR;
}
else
{
for(counter = 0; counter < Length; counter++)
{
if(ST7735_SetPixel(pObj, Xpos, Ypos + counter, Color) != ST7735_OK)
{
ret = ST7735_ERROR;
break;
}
}
}
return ret;
}
/**
* @brief Fill rectangle
* @param pObj Component object
* @param Xpos X position
* @param Ypos Y position
* @param Width Rectangle width
* @param Height Rectangle height
* @param Color Draw color
* @retval Component status
*/
int32_t ST7735_FillRect(ST7735_Object_t *pObj, uint32_t Xpos, uint32_t Ypos, uint32_t Width, uint32_t Height, uint32_t Color)
{
int32_t ret = ST7735_OK;
uint32_t i, y_pos = Ypos;
for(i = 0; i < Height; i++)
{
if(ST7735_DrawHLine(pObj, Xpos, y_pos, Width, Color) != ST7735_OK)
{
ret = ST7735_ERROR;
break;
}
y_pos++;
}
return ret;
}
/**
* @brief Write pixel.
* @param pObj Component object
* @param Xpos specifies the X position.
* @param Ypos specifies the Y position.
* @param Color the RGB pixel color in RGB565 format
* @retval The component status
*/
int32_t ST7735_SetPixel(ST7735_Object_t *pObj, uint32_t Xpos, uint32_t Ypos, uint32_t Color)
{
int32_t ret = ST7735_OK;
uint16_t color;
/* Exchange LSB and MSB to fit LCD specification */
color = (uint16_t)((uint16_t)Color << 8);
color |= (uint16_t)((uint16_t)(Color >> 8));
if((Xpos >= ST7735Ctx.Width) || (Ypos >= ST7735Ctx.Height))
{
ret = ST7735_ERROR;
}/* Set Cursor */
else if(ST7735_SetCursor(pObj, Xpos, Ypos) != ST7735_OK)
{
ret = ST7735_ERROR;
}
else
{
/* Write RAM data */
if(st7735_send_data(&pObj->Ctx, (uint8_t*)&color, 2) != ST7735_OK)
{
ret = ST7735_ERROR;
}
}
return ret;
}
/**
* @brief Read pixel.
* @param pObj Component object
* @param Xpos specifies the X position.
* @param Ypos specifies the Y position.
* @param Color the RGB pixel color in RGB565 format
* @retval The component status
*/
int32_t ST7735_GetPixel(ST7735_Object_t *pObj, uint32_t Xpos, uint32_t Ypos, uint32_t *Color)
{
int32_t ret;
uint8_t pixel_lsb, pixel_msb;
uint8_t tmp;
/* Set Cursor */
ret = ST7735_SetCursor(pObj, Xpos, Ypos);
/* Prepare to read LCD RAM */
ret += st7735_read_reg(&pObj->Ctx, ST7735_READ_RAM, &tmp); /* RAM read data command */
/* Dummy read */
ret += st7735_recv_data(&pObj->Ctx, &tmp, 1);
/* Read first part of the RGB888 data */
ret += st7735_recv_data(&pObj->Ctx, &pixel_lsb, 1);
/* Read first part of the RGB888 data */
ret += st7735_recv_data(&pObj->Ctx, &pixel_msb, 1);
*Color = ((uint32_t)(pixel_lsb)) + ((uint32_t)(pixel_msb) << 8);
if(ret != ST7735_OK)
{
ret = ST7735_ERROR;
}
return ret;
}
/**
* @brief Get the LCD pixel Width.
* @param pObj Component object
* @retval The Lcd Pixel Width
*/
int32_t ST7735_GetXSize(ST7735_Object_t *pObj, uint32_t *XSize)
{
(void)pObj;
*XSize = ST7735Ctx.Width;
return ST7735_OK;
}
/**
* @brief Get the LCD pixel Height.
* @param pObj Component object
* @retval The Lcd Pixel Height
*/
int32_t ST7735_GetYSize(ST7735_Object_t *pObj, uint32_t *YSize)
{
(void)pObj;
*YSize = ST7735Ctx.Height;
return ST7735_OK;
}
/**
* @}
*/
/** @defgroup ST7735_Private_Functions Private Functions
* @{
*/
/**
* @brief Sets a display window
* @param Xpos specifies the X bottom left position.
* @param Ypos specifies the Y bottom left position.
* @param Height display window height.
* @param Width display window width.
* @retval Component status
*/
static int32_t ST7735_SetDisplayWindow(ST7735_Object_t *pObj, uint32_t Xpos, uint32_t Ypos, uint32_t Width, uint32_t Height)
{
int32_t ret;
uint8_t tmp;
[bsp/stm32] format code
2022-10-16 20:42:31 +08:00
/* Cursor calibration */
if(ST7735Ctx.Orientation <= ST7735_ORIENTATION_PORTRAIT_ROT180)
{
[bsp/stm32] add weact mini stm32h7xx board bsp
2022-10-16 20:42:31 +08:00
#if IS_BOE_PANEL
[bsp/stm32] format code
2022-10-16 20:42:31 +08:00
Xpos += 24;
Ypos += 0;
[bsp/stm32] add weact mini stm32h7xx board bsp
2022-10-16 20:42:31 +08:00
#else
[bsp/stm32] format code
2022-10-16 20:42:31 +08:00
Xpos += 26;
Ypos += 1;
[bsp/stm32] add weact mini stm32h7xx board bsp
2022-10-16 20:42:31 +08:00
#endif
[bsp/stm32] format code
2022-10-16 20:42:31 +08:00
}
else
{
[bsp/stm32] add weact mini stm32h7xx board bsp
2022-10-16 20:42:31 +08:00
#if IS_BOE_PANEL
[bsp/stm32] format code
2022-10-16 20:42:31 +08:00
Xpos += 0;
Ypos += 24;
[bsp/stm32] add weact mini stm32h7xx board bsp
2022-10-16 20:42:31 +08:00
#else
[bsp/stm32] format code
2022-10-16 20:42:31 +08:00
Xpos += 1;
Ypos += 26;
[bsp/stm32] add weact mini stm32h7xx board bsp
2022-10-16 20:42:31 +08:00
#endif
[bsp/stm32] format code
2022-10-16 20:42:31 +08:00
}
[bsp/stm32] add weact mini stm32h7xx board bsp
2022-10-16 20:42:31 +08:00
/* Column addr set, 4 args, no delay: XSTART = Xpos, XEND = (Xpos + Width - 1) */
ret = st7735_write_reg(&pObj->Ctx, ST7735_CASET, &tmp, 0);
tmp = (uint8_t)(Xpos >> 8U);
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = (uint8_t)(Xpos & 0xFFU);
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = (uint8_t)((Xpos + Width - 1U) >> 8U);
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = (uint8_t)((Xpos + Width - 1U) & 0xFFU);
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
/* Row addr set, 4 args, no delay: YSTART = Ypos, YEND = (Ypos + Height - 1) */
ret += st7735_write_reg(&pObj->Ctx, ST7735_RASET, &tmp, 0);
tmp = (uint8_t)(Ypos >> 8U);
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = (uint8_t)(Ypos & 0xFFU);
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = (uint8_t)((Ypos + Height - 1U) >> 8U);
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
tmp = (uint8_t)((Ypos + Height - 1U) & 0xFFU);
ret += st7735_send_data(&pObj->Ctx, &tmp, 1);
if(ret != ST7735_OK)
{
ret = ST7735_ERROR;
}
return ret;
}
/**
* @brief Wrap component ReadReg to Bus Read function
* @param Handle Component object handle
* @param Reg The target register address to write
* @param pData The target register value to be written
* @retval Component error status
*/
static int32_t ST7735_ReadRegWrap(void *Handle, uint8_t Reg, uint8_t* pData)
{
ST7735_Object_t *pObj = (ST7735_Object_t *)Handle;
return pObj->IO.ReadReg(Reg, pData);
}
/**
* @brief Wrap component WriteReg to Bus Write function
* @param handle Component object handle
* @param Reg The target register address to write
* @param pData The target register value to be written
* @param Length buffer size to be written
* @retval Component error status
*/
static int32_t ST7735_WriteRegWrap(void *Handle, uint8_t Reg, uint8_t *pData, uint32_t Length)
{
ST7735_Object_t *pObj = (ST7735_Object_t *)Handle;
return pObj->IO.WriteReg(Reg, pData, Length);
}
/**
* @brief Wrap component SendData to Bus Write function
* @param handle Component object handle
* @param pData The target register value to be written
* @retval Component error status
*/
static int32_t ST7735_SendDataWrap(void *Handle, uint8_t *pData, uint32_t Length)
{
ST7735_Object_t *pObj = (ST7735_Object_t *)Handle;
return pObj->IO.SendData(pData, Length);
}
/**
* @brief Wrap component SendData to Bus Write function
* @param handle Component object handle
* @param pData The target register value to be written
* @retval Component error status
*/
static int32_t ST7735_RecvDataWrap(void *Handle, uint8_t *pData, uint32_t Length)
{
ST7735_Object_t *pObj = (ST7735_Object_t *)Handle;
return pObj->IO.RecvData(pData, Length);
}
/**
* @brief ST7735 delay
* @param Delay Delay in ms
* @retval Component error status
*/
static int32_t ST7735_IO_Delay(ST7735_Object_t *pObj, uint32_t Delay)
{
rt_thread_mdelay(Delay);
return ST7735_OK;
}
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/