857 lines
24 KiB
C
857 lines
24 KiB
C
/**********************************************************************
|
|
* $Id$ lpc_lcd.c 2011-10-14
|
|
*//**
|
|
* @file lpc_lcd.c
|
|
* @brief Contains all functions support for LCD firmware library
|
|
* on LPC
|
|
* @version 1.0
|
|
* @date 14. October. 2011
|
|
* @author NXP MCU SW Application Team
|
|
*
|
|
* Copyright(C) 2011, NXP Semiconductor
|
|
* All rights reserved.
|
|
*
|
|
***********************************************************************
|
|
* Software that is described herein is for illustrative purposes only
|
|
* which provides customers with programming information regarding the
|
|
* products. This software is supplied "AS IS" without any warranties.
|
|
* NXP Semiconductors assumes no responsibility or liability for the
|
|
* use of the software, conveys no license or title under any patent,
|
|
* copyright, or mask work right to the product. NXP Semiconductors
|
|
* reserves the right to make changes in the software without
|
|
* notification. NXP Semiconductors also make no representation or
|
|
* warranty that such application will be suitable for the specified
|
|
* use without further testing or modification.
|
|
* Permission to use, copy, modify, and distribute this software and its
|
|
* documentation is hereby granted, under NXP Semiconductors'
|
|
* relevant copyright in the software, without fee, provided that it
|
|
* is used in conjunction with NXP Semiconductors microcontrollers. This
|
|
* copyright, permission, and disclaimer notice must appear in all copies of
|
|
* this code.
|
|
**********************************************************************/
|
|
#ifdef __BUILD_WITH_EXAMPLE__
|
|
#include "lpc_libcfg.h"
|
|
#else
|
|
#include "lpc_libcfg_default.h"
|
|
#endif /* __BUILD_WITH_EXAMPLE__ */
|
|
#ifdef _LCD
|
|
|
|
#include "lpc_clkpwr.h"
|
|
#include "lpc_pinsel.h"
|
|
#include "lpc_gpio.h"
|
|
#include "lpc_lcd.h"
|
|
|
|
uint32_t lcd_hsize = 0, lcd_vsize = 0;
|
|
uint32_t lcd_cursor_base_addr = 0;
|
|
uint32_t lcd_cursor_size = 64;
|
|
LCD_Config_Type lcd_config;
|
|
static uint8_t bits_per_pixel[] = { 1, 2, 4, 8, 16, 32, 16, 16 };
|
|
uint32_t rect[1024];
|
|
|
|
|
|
static void LCD_SetHorizontalTiming(LCD_HConfig_Type* pConfig);
|
|
static void LCD_SetVertialTiming(LCD_VConfig_Type* pConfig);
|
|
static void LCD_SetPolarity(LCD_TYPES lcd_type, LCD_POLARITY_Type* pConfig);
|
|
static void LCD_CtrlSetup(LCD_Config_Type* pConfig);
|
|
|
|
/** @addtogroup LCD_Private_Functions LCD Private Function
|
|
* @ingroup LCD
|
|
* @{
|
|
*/
|
|
|
|
|
|
/*********************************************************************//**
|
|
* @brief Init LCD. The input clock is CClk
|
|
*
|
|
* @param[in] pConfig Configuration Information
|
|
*
|
|
* @return LCD_FUNC_OK Execute successfully
|
|
* LCD_FUNC_ERR Error occurred.
|
|
*
|
|
**********************************************************************/
|
|
LCD_RET_CODE LCD_Init (LCD_Config_Type* pConfig)
|
|
{
|
|
uint8_t clkdiv;
|
|
|
|
if(pConfig == NULL)
|
|
return LCD_FUNC_ERR;
|
|
|
|
if(pConfig->big_endian_byte & !pConfig->big_endian_pixel)
|
|
return LCD_FUNC_ERR;
|
|
|
|
lcd_config = *pConfig;
|
|
|
|
// Assign pins
|
|
PINSEL_ConfigPin(0,4,7);
|
|
PINSEL_ConfigPin(0,5,7);
|
|
PINSEL_ConfigPin(0,6,7);
|
|
PINSEL_ConfigPin(0,7,7);
|
|
PINSEL_ConfigPin(0,8,7);
|
|
PINSEL_ConfigPin(0,9,7);
|
|
PINSEL_ConfigPin(1,20,7);
|
|
PINSEL_ConfigPin(1,21,7);
|
|
PINSEL_ConfigPin(1,22,7);
|
|
PINSEL_ConfigPin(1,23,7);
|
|
PINSEL_ConfigPin(1,24,7);
|
|
PINSEL_ConfigPin(1,25,7);
|
|
PINSEL_ConfigPin(1,26,7);
|
|
PINSEL_ConfigPin(1,27,7);
|
|
PINSEL_ConfigPin(1,28,7);
|
|
PINSEL_ConfigPin(1,29,7);
|
|
PINSEL_ConfigPin(2,0,7);
|
|
PINSEL_ConfigPin(2,1,7);
|
|
PINSEL_ConfigPin(2,2,7);
|
|
PINSEL_ConfigPin(2,3,7);
|
|
PINSEL_ConfigPin(2,4,7);
|
|
PINSEL_ConfigPin(2,5,7);
|
|
PINSEL_ConfigPin(2,6,7);
|
|
#ifdef CORE_M4
|
|
PINSEL_ConfigPin(0,10,7);
|
|
#else
|
|
PINSEL_ConfigPin(2,7,7);
|
|
#endif
|
|
PINSEL_ConfigPin(2,8,7);
|
|
PINSEL_ConfigPin(2,9,7);
|
|
PINSEL_ConfigPin(2,11,7);
|
|
PINSEL_ConfigPin(2,12,7);
|
|
PINSEL_ConfigPin(2,13,7);
|
|
PINSEL_ConfigPin(4,28,7);
|
|
PINSEL_ConfigPin(4,29,7);
|
|
|
|
//Turn on LCD clock
|
|
CLKPWR_ConfigPPWR(CLKPWR_PCONP_PCLCD, ENABLE);
|
|
|
|
// Set clock
|
|
LPC_LCD->POL &= ~(0x01 << 5);
|
|
if( pConfig->panel_clk > 0) {
|
|
clkdiv = CLKPWR_GetCLK(CLKPWR_CLKTYPE_CPU) / pConfig->panel_clk - 1;
|
|
LPC_SC->LCD_CFG = clkdiv & 0x1F;
|
|
LPC_LCD->POL |=(1<<26);
|
|
}
|
|
|
|
// init Horizontal Timing
|
|
LCD_SetHorizontalTiming(&pConfig->hConfig);
|
|
|
|
// Init Vertical Timing
|
|
LCD_SetVertialTiming(&pConfig->vConfig);
|
|
|
|
// Set Polarity
|
|
LCD_SetPolarity(pConfig->lcd_type, &pConfig->polarity);
|
|
|
|
if(NULL != pConfig->lcd_palette)
|
|
{
|
|
LCD_SetPalette(pConfig->lcd_palette);
|
|
}
|
|
|
|
// Set Base address
|
|
LCD_SetBaseAddress(LCD_PANEL_UPPER, pConfig->lcd_panel_upper);
|
|
LCD_SetBaseAddress(LCD_PANEL_LOWER, pConfig->lcd_panel_lower);
|
|
|
|
// Setup
|
|
LCD_CtrlSetup(pConfig);
|
|
|
|
return LCD_FUNC_OK;
|
|
|
|
|
|
}
|
|
/*********************************************************************//**
|
|
* @brief Horizontal Timing Setting
|
|
*
|
|
* @param[in] pConfig Configuration Information
|
|
*
|
|
* @return None.
|
|
*
|
|
**********************************************************************/
|
|
void LCD_SetHorizontalTiming(LCD_HConfig_Type* pConfig)
|
|
{
|
|
LPC_LCD->TIMH = 0; //reset TIMH before set value
|
|
LPC_LCD->TIMH |= ((pConfig->hbp - 1)& 0xFF)<<24;
|
|
LPC_LCD->TIMH |= ((pConfig->hfp - 1)& 0xFF)<<16;
|
|
LPC_LCD->TIMH |= ((pConfig->hsw - 1)& 0xFF)<<8;
|
|
LPC_LCD->TIMH |= ((pConfig->ppl/16 - 1)& 0x3F)<<2;
|
|
lcd_hsize = pConfig->ppl;
|
|
}
|
|
|
|
/*********************************************************************//**
|
|
* @brief Vertical Timing Setting
|
|
*
|
|
* @param[in] pConfig Configuration Information
|
|
*
|
|
* @return None.
|
|
*
|
|
**********************************************************************/
|
|
void LCD_SetVertialTiming(LCD_VConfig_Type* pConfig)
|
|
{
|
|
LPC_LCD->TIMV = 0; //reset TIMV value before setting
|
|
LPC_LCD->TIMV |= ((pConfig->vbp)& 0xFF)<<24;
|
|
LPC_LCD->TIMV |= ((pConfig->vfp)& 0xFF)<<16;
|
|
LPC_LCD->TIMV |= ((pConfig->vsw - 1)& 0x3F)<<10;
|
|
LPC_LCD->TIMV |= ((pConfig->lpp - 1)& 0x03FF)<<0;
|
|
lcd_vsize = pConfig->lpp;
|
|
}
|
|
|
|
/*********************************************************************//**
|
|
* @brief Polarity Setting
|
|
*
|
|
* @param[in] pConfig Configuration Information
|
|
* @param[in] lcd_type It can be:
|
|
* - LCD_STN_MONOCHROME
|
|
* - LCD_STN_COLOR
|
|
* - LCD_TFT
|
|
*
|
|
* @return None.
|
|
*
|
|
**********************************************************************/
|
|
void LCD_SetPolarity(LCD_TYPES lcd_type, LCD_POLARITY_Type* pConfig)
|
|
{
|
|
// LCDFP pin is active LOW and inactive HIGH
|
|
if(pConfig->invert_vsync)
|
|
LPC_LCD->POL |= (1<<11);
|
|
else
|
|
LPC_LCD->POL &= ~(1<<11);
|
|
// LCDLP pin is active LOW and inactive HIGH
|
|
if(pConfig->invert_hsync)
|
|
LPC_LCD->POL |= (1<<12);
|
|
else
|
|
LPC_LCD->POL &= ~(1<<12);
|
|
// data is driven out into the LCD on the falling edge
|
|
if(pConfig->invert_panel_clock)
|
|
LPC_LCD->POL |= (1<<13);
|
|
else
|
|
LPC_LCD->POL &= ~(1<<13);
|
|
|
|
// active high
|
|
if(pConfig->active_high) {
|
|
LPC_LCD->POL &= ~(1<<14);
|
|
}
|
|
else
|
|
{
|
|
LPC_LCD->POL |= (1<<14);
|
|
}
|
|
|
|
LPC_LCD->POL &= ~(0x3FF <<16);
|
|
LPC_LCD->POL |= (pConfig->cpl - 1)<<16;
|
|
|
|
if(lcd_type == LCD_STN_COLOR || lcd_type == LCD_STN_MONOCHROME)
|
|
LPC_LCD->POL |= (pConfig->acb & 0x1F) << 6;
|
|
}
|
|
|
|
/*********************************************************************//**
|
|
* @brief Set base address of frame buffer
|
|
*
|
|
* @param[in] panel identify which panel is.
|
|
* @param[in] pAddress base address of the inputted panel.
|
|
*
|
|
* @return None.
|
|
*
|
|
**********************************************************************/
|
|
void LCD_SetBaseAddress(LCD_PANEL panel, uint32_t pAddress)
|
|
{
|
|
// Frame Base Address doubleword aligned
|
|
if(panel == LCD_PANEL_UPPER)
|
|
LPC_LCD->UPBASE = pAddress & ~7UL ;
|
|
else
|
|
LPC_LCD->LPBASE = pAddress & ~7UL ;
|
|
}
|
|
|
|
/*********************************************************************//**
|
|
* @brief LCD Setup.
|
|
*
|
|
* @param[in] pConfig Configuration information.
|
|
*
|
|
* @return None.
|
|
*
|
|
**********************************************************************/
|
|
void LCD_CtrlSetup(LCD_Config_Type* pConfig)
|
|
{
|
|
// disable LCD controller
|
|
LPC_LCD->CTRL = 0;
|
|
|
|
// bpp
|
|
LPC_LCD->CTRL &= ~(0x07 <<1);
|
|
LPC_LCD->CTRL |=((pConfig->lcd_bpp & 0x07)<<1);
|
|
|
|
if(pConfig->lcd_type == LCD_TFT) {
|
|
LPC_LCD->CTRL |= (0x01 << 5); // TFT
|
|
}
|
|
else {
|
|
// Color/Mono
|
|
if(pConfig->lcd_type == LCD_STN_COLOR) {
|
|
LPC_LCD->CTRL &= ~ (0x01 << 4); // Color
|
|
}
|
|
else if (pConfig->lcd_type == LCD_STN_MONOCHROME) {
|
|
LPC_LCD->CTRL |= (0x01 << 4); // Mono
|
|
}
|
|
|
|
// STN/TFT
|
|
LPC_LCD->CTRL &= ~ (0x01 << 5); // STN
|
|
|
|
// Mono4/8
|
|
if(pConfig->lcd_mono8)
|
|
LPC_LCD->CTRL |= (0x01 << 6);
|
|
else
|
|
LPC_LCD->CTRL &= ~(0x01 << 6);
|
|
|
|
// Single/dual
|
|
if(pConfig->lcd_dual)
|
|
LPC_LCD->CTRL |= (0x01 << 7);
|
|
else
|
|
LPC_LCD->CTRL &= ~(0x01 << 7);
|
|
}
|
|
|
|
// notmal output
|
|
if(pConfig->lcd_bgr)
|
|
LPC_LCD->CTRL |= (1<<8); // BGR
|
|
else
|
|
LPC_LCD->CTRL &= ~(1<<8); // RGB
|
|
|
|
// Byte order
|
|
if(pConfig->big_endian_byte)
|
|
LPC_LCD->CTRL |= (1<<9);
|
|
else
|
|
LPC_LCD->CTRL &= ~(1<<9);
|
|
|
|
// Pixel order
|
|
if(pConfig->big_endian_pixel)
|
|
LPC_LCD->CTRL |= (1<<10);
|
|
else
|
|
LPC_LCD->CTRL &= ~(1<<10);
|
|
|
|
// disable power
|
|
LPC_LCD->CTRL &= ~(1<<11);
|
|
}
|
|
|
|
/*********************************************************************//**
|
|
* @brief Enable/disable LCD Display.
|
|
*
|
|
* @param[in] bEna 0: disable, 1: enable.
|
|
*
|
|
* @return None.
|
|
*
|
|
**********************************************************************/
|
|
void LCD_Enable (Bool bEna)
|
|
{
|
|
volatile uint32_t i;
|
|
if (bEna)
|
|
{
|
|
LPC_LCD->CTRL |= (1<<0);
|
|
for(i = LCD_PWR_ENA_DIS_DLY; i; i--);
|
|
LPC_LCD->CTRL |= (1<<11);
|
|
}
|
|
else
|
|
{
|
|
LPC_LCD->CTRL &= ~(1<<11);
|
|
for(i = LCD_PWR_ENA_DIS_DLY; i; i--);
|
|
LPC_LCD->CTRL &= ~(1<<0);
|
|
}
|
|
}
|
|
|
|
|
|
/*********************************************************************//**
|
|
* @brief Set palette.
|
|
*
|
|
* @param[in] bEna 0: disable, 1: enable.
|
|
*
|
|
* @return None.
|
|
*
|
|
**********************************************************************/
|
|
void LCD_SetPalette (const uint8_t* pPallete)
|
|
{
|
|
uint32_t i;
|
|
uint32_t size = (0x01 << bits_per_pixel[lcd_config.lcd_bpp])/2 ;
|
|
uint32_t * pDst = (uint32_t *)LPC_LCD->PAL;
|
|
uint32_t * pInput = (uint32_t*) pPallete;
|
|
|
|
for (i = 0; i < size; i++)
|
|
{
|
|
*pDst = *pInput;
|
|
pDst++;
|
|
pInput++;
|
|
}
|
|
}
|
|
/*********************************************************************//**
|
|
* @brief Get word offset for the given pixel
|
|
*
|
|
* @param[in] x x position of input pixel
|
|
* @param[in] y y position of input pixel
|
|
*
|
|
* @return Offset
|
|
*
|
|
**********************************************************************/
|
|
uint32_t LCD_GetWordOffset(uint32_t x, uint32_t y)
|
|
{
|
|
uint32_t pixel_num = x + y*lcd_hsize;
|
|
|
|
return (pixel_num * bits_per_pixel[lcd_config.lcd_bpp])/32;
|
|
}
|
|
/*********************************************************************//**
|
|
* @brief Get bit offset for the given pixel
|
|
*
|
|
* @param[in] x x position of input pixel
|
|
* @param[in] y y position of input pixel
|
|
*
|
|
* @return Offset
|
|
*
|
|
**********************************************************************/
|
|
uint32_t LCD_GetBitOffset(uint32_t x, uint32_t y)
|
|
{
|
|
uint32_t pixel_num;
|
|
uint32_t ofs;
|
|
pixel_num = x + y*lcd_hsize;
|
|
|
|
ofs = (pixel_num * bits_per_pixel[lcd_config.lcd_bpp])%32;
|
|
|
|
if(lcd_config.big_endian_pixel & lcd_config.big_endian_byte)
|
|
{
|
|
ofs = 32 - bits_per_pixel[lcd_config.lcd_bpp] - ofs;
|
|
}
|
|
else if (lcd_config.big_endian_pixel & !lcd_config.big_endian_byte)
|
|
{
|
|
if(bits_per_pixel[lcd_config.lcd_bpp] < 8)
|
|
{
|
|
ofs = (ofs/8)*8 + (8 - (ofs%8)-bits_per_pixel[lcd_config.lcd_bpp]);
|
|
}
|
|
}
|
|
return ofs;
|
|
}
|
|
|
|
|
|
|
|
/*********************************************************************//**
|
|
* @brief Copy pixel values from image buffer to frame buffer.
|
|
*
|
|
* @param[in] panel It can be:
|
|
* - LCD_PANEL_UPPER
|
|
* - LCD_PANEL_LOWER
|
|
* @param[in] pPain point to image buffer.
|
|
*
|
|
* @return None.
|
|
*
|
|
**********************************************************************/
|
|
void LCD_SetImage(LCD_PANEL panel, const uint8_t *pPain)
|
|
{
|
|
volatile uint32_t i;
|
|
uint32_t * pWordDst = NULL;
|
|
uint8_t* pByteDst = NULL;
|
|
uint32_t bytes_num;
|
|
|
|
if(panel == LCD_PANEL_UPPER)
|
|
pWordDst = (uint32_t*) LPC_LCD->UPBASE;
|
|
else
|
|
pWordDst = (uint32_t*) LPC_LCD->LPBASE;
|
|
|
|
pByteDst = (uint8_t*) pWordDst;
|
|
bytes_num = ((lcd_hsize * lcd_vsize) * bits_per_pixel[lcd_config.lcd_bpp]) /8;
|
|
|
|
if (NULL == pPain)
|
|
{
|
|
// clear display memory
|
|
for( i = 0; bytes_num > i; i++)
|
|
{
|
|
*pByteDst++ = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// set display memory
|
|
for(i = 0; bytes_num > i; i++)
|
|
{
|
|
*pByteDst++ = *pPain++;
|
|
}
|
|
}
|
|
|
|
for(i = LCD_PWR_ENA_DIS_DLY; i; i--);
|
|
}
|
|
/*********************************************************************//**
|
|
* @brief Draw a pixel on the given panel.
|
|
*
|
|
* @param[in] panel It can be:
|
|
* - LCD_PANEL_UPPER
|
|
* - LCD_PANEL_LOWER
|
|
* @param[in] X_Left X position.
|
|
* @param[in] Y_Up Y position.
|
|
* @param[in] color Color which is placed to the given pixel.
|
|
*
|
|
* @return None.
|
|
*
|
|
**********************************************************************/
|
|
void LCD_PutPixel (LCD_PANEL panel, uint32_t X_Left, uint32_t Y_Up, LcdPixel_t color)
|
|
{
|
|
uint32_t k;
|
|
uint32_t * pWordData = NULL;
|
|
uint8_t* pByteData = NULL;
|
|
uint32_t bitOffset;
|
|
uint8_t* pByteSrc = (uint8_t*)&color;
|
|
uint8_t bpp = bits_per_pixel[lcd_config.lcd_bpp];
|
|
uint8_t bytes_per_pixel = bpp/8;
|
|
uint32_t start_bit;
|
|
|
|
if((X_Left >= lcd_hsize)||(Y_Up >= lcd_vsize))
|
|
return;
|
|
|
|
if(panel == LCD_PANEL_UPPER)
|
|
pWordData = (uint32_t*) LPC_LCD->UPBASE + LCD_GetWordOffset(X_Left,Y_Up);
|
|
else
|
|
pWordData = (uint32_t*) LPC_LCD->LPBASE + LCD_GetWordOffset(X_Left,Y_Up);
|
|
|
|
bitOffset = LCD_GetBitOffset(X_Left,Y_Up);
|
|
pByteData = (uint8_t*) pWordData;
|
|
pByteData += bitOffset/8;
|
|
|
|
start_bit = bitOffset%8;
|
|
|
|
if(bpp < 8)
|
|
{
|
|
uint8_t bit_pos = start_bit;
|
|
uint8_t bit_ofs = 0;
|
|
for(bit_ofs = 0;bit_ofs <bpp; bit_ofs++,bit_pos++)
|
|
{
|
|
*pByteData &= ~ (0x01 << bit_pos);
|
|
*pByteData |= ((*pByteSrc >> (k+bit_ofs)) & 0x01) << bit_pos;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(k = 0; k < bytes_per_pixel; k++)
|
|
{
|
|
*(pByteData+ k) = *pByteSrc++;
|
|
}
|
|
}
|
|
}
|
|
/*********************************************************************//**
|
|
* @brief Place given image to given position.
|
|
*
|
|
* @param[in] panel It can be:
|
|
* - LCD_PANEL_UPPER
|
|
* - LCD_PANEL_LOWER
|
|
* @param[in] X_Left Start X position.
|
|
* @param[in] Y_Up Start Y position.
|
|
* @param[in] pBmp Image information.
|
|
* @param[in] Mask Mask on pixel values.
|
|
*
|
|
* @return None.
|
|
*
|
|
**********************************************************************/
|
|
void LCD_LoadPic (LCD_PANEL panel, uint32_t X_Left, uint32_t Y_Up,
|
|
Bmp_t * pBmp, uint32_t Mask)
|
|
{
|
|
uint32_t i, j, k, inc;
|
|
uint32_t * pWordData = NULL;
|
|
uint8_t* pByteData = NULL;
|
|
uint32_t bitOffset;
|
|
uint8_t* pByteSrc = (uint8_t*) pBmp->pPicStream;
|
|
uint32_t X_LeftHold = X_Left;
|
|
uint8_t bpp = bits_per_pixel[lcd_config.lcd_bpp];
|
|
uint8_t bytes_per_pixel = bpp/8;
|
|
uint8_t pixels_per_byte = 8/bpp;
|
|
uint32_t hsize, vsize;
|
|
uint32_t start_bit;
|
|
|
|
if(pBmp->BytesPP == 0)
|
|
pBmp->BytesPP = bytes_per_pixel;
|
|
|
|
hsize = pBmp->H_Size;
|
|
vsize = pBmp->V_Size;
|
|
inc = (pixels_per_byte > 0) ? pixels_per_byte:1;
|
|
|
|
for(i = 0; i < vsize; i++)
|
|
{
|
|
if(panel == LCD_PANEL_UPPER)
|
|
pWordData = (uint32_t*) LPC_LCD->UPBASE + LCD_GetWordOffset(X_Left,Y_Up);
|
|
else
|
|
pWordData = (uint32_t*) LPC_LCD->LPBASE + LCD_GetWordOffset(X_Left,Y_Up);
|
|
|
|
bitOffset = LCD_GetBitOffset(X_Left,Y_Up);
|
|
pByteData = (uint8_t*) pWordData;
|
|
pByteData += bitOffset/8;
|
|
|
|
start_bit = bitOffset%8;
|
|
|
|
if(pBmp->BytesPP > 0)
|
|
pByteSrc = (uint8_t*) pBmp->pPicStream + i*hsize*pBmp->BytesPP; // storage of each line must be word alignment
|
|
else
|
|
pByteSrc = (uint8_t*) pBmp->pPicStream + (i*hsize*pBmp->BitsPP + 7)/8; // storage of each line must be word alignment
|
|
|
|
X_LeftHold = X_Left;
|
|
|
|
for(j = 0; j <= hsize; j+= inc)
|
|
{
|
|
if((X_LeftHold >= lcd_hsize) || (X_LeftHold - X_Left >= hsize))
|
|
break;
|
|
if(bpp < 8)
|
|
{
|
|
uint8_t bit_pos = start_bit;
|
|
uint8_t bit_ofs = 0;
|
|
for(k = 0; k < 8; k+= bpp)
|
|
{
|
|
for(bit_ofs = 0;bit_ofs <bpp; bit_ofs++,bit_pos++)
|
|
{
|
|
*pByteData &= ~ (0x01 << bit_pos);
|
|
*pByteData |= ((*pByteSrc >> (k+bit_ofs)) & 0x01) << bit_pos;
|
|
}
|
|
if(lcd_config.big_endian_byte && lcd_config.big_endian_pixel)
|
|
{
|
|
if(bit_pos >= bpp*2)
|
|
bit_pos -= bpp*2;
|
|
else
|
|
{
|
|
bit_pos = 8-bpp;
|
|
if((((uint32_t)pByteData)%4) == 0)
|
|
pByteData += 7; // change to next word
|
|
else
|
|
pByteData--; // change to previous byte
|
|
}
|
|
}
|
|
else if( !lcd_config.big_endian_byte && lcd_config.big_endian_pixel)
|
|
{
|
|
if(bit_pos >= bpp*2)
|
|
bit_pos -= bpp*2;
|
|
else
|
|
{
|
|
bit_pos = 8-bpp;
|
|
pByteData++; // change to next byte
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(bit_pos >= 8)
|
|
{
|
|
bit_pos = 0;
|
|
pByteData++; // change to next byte
|
|
}
|
|
|
|
}
|
|
X_LeftHold++;
|
|
if((X_LeftHold >= lcd_hsize) ||
|
|
(X_LeftHold - X_Left >= hsize))
|
|
break;
|
|
}
|
|
pByteSrc++;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
for(k = 0; k < pBmp->BytesPP; k++)
|
|
{
|
|
*(pByteData+ k) = *pByteSrc++ ^ Mask;
|
|
}
|
|
if(lcd_config.big_endian_byte)
|
|
{
|
|
if((uint32_t)pByteData %4 > 0)
|
|
pByteData -= bytes_per_pixel;
|
|
else
|
|
pByteData += 8 - bytes_per_pixel;
|
|
}
|
|
else
|
|
pByteData+= bytes_per_pixel;
|
|
X_LeftHold++;
|
|
}
|
|
}
|
|
if(Y_Up++ >= lcd_vsize)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*********************************************************************//**
|
|
* @brief Fill a rectangle.
|
|
*
|
|
* @param[in] panel It can be:
|
|
* - LCD_PANEL_UPPER
|
|
* - LCD_PANEL_LOWER
|
|
* @param[in] startx Start X position.
|
|
* @param[in] endy End X position.
|
|
* @param[in] starty Start Y position.
|
|
* @param[in] endy End Y position.
|
|
*
|
|
* @return None.
|
|
*
|
|
**********************************************************************/
|
|
void LCD_FillRect (LCD_PANEL panel, uint32_t startx,uint32_t endx,
|
|
uint32_t starty, uint32_t endy,
|
|
LcdPixel_t color)
|
|
{
|
|
uint32_t x, xs, xe, ys, ye;
|
|
uint8_t bpp, pixels_per_word;
|
|
uint32_t word_val, mask;
|
|
uint32_t max_vsize = 0;
|
|
Bmp_t bitmap;
|
|
uint32_t hsize, vsize;
|
|
|
|
bpp = bits_per_pixel[lcd_config.lcd_bpp];
|
|
pixels_per_word = 32/bpp;
|
|
|
|
mask = 0;
|
|
for( x = 0; x < bpp; x++)
|
|
mask |= 0x01 << x;
|
|
|
|
color &= mask;
|
|
|
|
word_val = 0;
|
|
for(x = 0; x < pixels_per_word; x++)
|
|
word_val |= color << (x*bpp);
|
|
|
|
ys = (starty > endy) ? endy : starty;
|
|
ye = (starty > endy) ? starty : endy;
|
|
|
|
xs = (startx > endx) ? endx : startx;
|
|
xe = (startx > endx) ? startx : endx;
|
|
|
|
bitmap.BitsPP = bpp;
|
|
bitmap.BytesPP = bpp/8;
|
|
hsize = xe - xs + 1;
|
|
bitmap.H_Size = hsize;
|
|
vsize = ye - ys + 1;
|
|
bitmap.pPicStream = (uint8_t*)rect;
|
|
|
|
max_vsize = ((1024 * 32)/(hsize*bpp));
|
|
|
|
for( x = 0; x < 1024; x++)
|
|
{
|
|
rect[x] = word_val;
|
|
}
|
|
|
|
while(1)
|
|
{
|
|
if(max_vsize >= vsize)
|
|
{
|
|
bitmap.V_Size = vsize;
|
|
LCD_LoadPic(panel,xs,ys, &bitmap, 0);
|
|
break;
|
|
}
|
|
else {
|
|
bitmap.V_Size = max_vsize;
|
|
vsize -= bitmap.V_Size;
|
|
LCD_LoadPic(panel,xs,ys, &bitmap, 0);
|
|
ys += max_vsize;
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
/*********************************************************************//**
|
|
* @brief Configure display of cursor.
|
|
*
|
|
* @param[in] pConfig Configuration information.
|
|
*
|
|
* @return None.
|
|
*
|
|
**********************************************************************/
|
|
void LCD_Cursor_Cfg(LCD_Cursor_Config_Type* pConfig)
|
|
{
|
|
if(pConfig->size32) {
|
|
LPC_LCD->CRSR_CFG &= ~(0x01 << 0);
|
|
lcd_cursor_size = 32;
|
|
}
|
|
else {
|
|
LPC_LCD->CRSR_CFG |= (0x01 << 0);
|
|
lcd_cursor_size = 64;
|
|
}
|
|
|
|
if(pConfig->framesync)
|
|
LPC_LCD->CRSR_CFG &= ~(0x01 << 1);
|
|
else
|
|
LPC_LCD->CRSR_CFG |= (0x01 << 1);
|
|
|
|
lcd_cursor_base_addr = pConfig->baseaddress;
|
|
|
|
LPC_LCD->CRSR_PAL0 = pConfig->palette[0].Red |
|
|
pConfig->palette[0].Green << 8 |
|
|
pConfig->palette[0].Blue << 16;
|
|
LPC_LCD->CRSR_PAL1 = pConfig->palette[1].Red |
|
|
pConfig->palette[1].Green << 8 |
|
|
pConfig->palette[1].Blue << 16;
|
|
|
|
}
|
|
/*********************************************************************//**
|
|
* @brief Enable/disable cursor display.
|
|
*
|
|
* @param[in] enable 0: disable, 1: enable.
|
|
* @param[in] cursor identify which cursor image is used.
|
|
*
|
|
* @return None.
|
|
*
|
|
**********************************************************************/
|
|
void LCD_Cursor_Enable(int enable, int cursor)
|
|
{
|
|
if(enable) {
|
|
LPC_LCD->CRSR_CTRL |= (1<<0);
|
|
LPC_LCD->CRSR_CTRL |= (cursor<<4);
|
|
}
|
|
else {
|
|
LPC_LCD->CRSR_CTRL &= ~(1<<0);
|
|
}
|
|
}
|
|
|
|
|
|
/*********************************************************************//**
|
|
* @brief move the cursor to the inputted position.
|
|
*
|
|
* @param[in] x Position in x-direction.
|
|
* @param[in] y Position in y-direction.
|
|
*
|
|
* @return None.
|
|
*
|
|
**********************************************************************/
|
|
void LCD_Move_Cursor(int x, int y)
|
|
{
|
|
LPC_LCD->CRSR_CLIP = 0;
|
|
LPC_LCD->CRSR_XY = 0;
|
|
if(0 <= x)
|
|
{//no clipping
|
|
LPC_LCD->CRSR_XY |= (x & 0x3FF);
|
|
}
|
|
else
|
|
{//clip x
|
|
LPC_LCD->CRSR_CLIP |= -x;
|
|
}
|
|
|
|
if(0 <= y)
|
|
{//no clipping
|
|
|
|
LPC_LCD->CRSR_XY |= (y << 16);
|
|
}
|
|
else
|
|
{//clip y
|
|
LPC_LCD->CRSR_CLIP |= (-y << 8);
|
|
}
|
|
}
|
|
|
|
/*********************************************************************//**
|
|
* @brief Set the cursor image.
|
|
*
|
|
* @param[in] pCursor point to cursor image.
|
|
* @param[in] cursor cursor image number. It has no meaning when cursor size is 64x64
|
|
* @param[in] cursor cursor size in words.
|
|
*
|
|
* @return None.
|
|
*
|
|
**********************************************************************/
|
|
void LCD_Cursor_SetImage (const uint32_t *pCursor, int cursor, int size)
|
|
{
|
|
uint32_t i ;
|
|
uint32_t * pDst = (uint32_t *)lcd_cursor_base_addr;
|
|
|
|
if(lcd_cursor_size == 32)
|
|
pDst += cursor*GET_CURSOR_IMG_SIZE(lcd_cursor_size);
|
|
|
|
|
|
for(i = 0; i < size ; i++)
|
|
{
|
|
*pDst = *pCursor;
|
|
pDst++;
|
|
pCursor++;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
#endif /*_LCD*/
|
|
|
|
|
|
|