lib_lcd.c

基于MSP430FG4618MCU的铭正同创LCD驱动程序。

#include "sys_def.h"
#include "sys_rsc.h"
#include "drv_lcd.h"
#include "lib_lcd.h"

/*******************************************************************************
// 全局变量
*******************************************************************************/
static char acBuffer[32];
/*******************************************************************************
// 外部函数定义:低级描画
*******************************************************************************/
/* 刷新帧缓冲 */
void RefreshScreen()
{
	for (UCHAR ucPage = 0; ucPage < 8; ucPage++){
		LcdSendCommand(LCD_ADS_PAG + ucPage);
		LcdSendCommand(LCD_ADS_CLML + 0);
		LcdSendCommand(LCD_ADS_CLMH + 0);
		for (UCHAR ucColumn = 0; ucColumn < 128; ucColumn++){
			LcdSendData(aFrameBuffer[ucPage][ucColumn]);
		}
	}
	return;
}

/* 清理帧缓冲 */
void ClearScreen()
{
	memset(aFrameBuffer, 0, sizeof(aFrameBuffer));
	return;
}

/* 描画实点 */
int DrawDot(POINT_t stPoint, UCHAR ucMode)
{
	UCHAR ucSrcBit;
	/* 裁剪 */
	if (0 > stPoint.ix || 0 > stPoint.iy
		|| 128 <= stPoint.ix || 64 <= stPoint.iy){
		return OK;
	}
	/* 绘图 */
	ucSrcBit = 0x01 << stPoint.iy % 8;
	stPoint.iy >>= 3;
	if (ucMode & 0x80){
		aFrameBuffer[stPoint.iy][stPoint.ix] |= ucSrcBit;
	}
	else{
		aFrameBuffer[stPoint.iy][stPoint.ix] &= ~ucSrcBit;
	}
	return OK;
}
/* 描画实线 */
int DrawLine(UCHAR StartX, UCHAR StartY, UCHAR EndX, UCHAR EndY)
{
  int iX = 0;
  int iY = 0;
  
  float fStaX = 0;
  float fStaY = 0;
  float fEndX = 0;
  float fEndY = 0;
  
  float fK = 0; /* 斜率 */
  float fKtmp = 0;
  float fT = 0; /* 直线公式常量 */
  
  int iPage = 0;	/* 点所在的PAGE */
  UCHAR cTmp;
        
  if (StartY > 127 || StartY > 63 || EndX > 127 || EndY > 63 )
  {	
    return ER;
  }
  
  fStaX = (float)StartX;
  fStaY = (float)StartY;
  fEndX = (float)EndX;
  fEndY = (float)EndY;

  fK = (fEndY - fStaY) / (fEndX - fStaX);	
  fT = fStaY - fK * fStaX;
  
  if (fK < 0)
  {
    fKtmp = (fStaY - fEndY) / (fEndX - fStaX);
  }
  else
  {
    fKtmp = fK;
  }

  if ((fKtmp > 1 && (StartY > EndY) ) || (fKtmp < 1 && (StartX > EndX)) 
      || ((StartX > EndX) && (StartY > EndY)))
  {
    iX = EndX;
    iY = EndY;
    EndX = StartX;
    EndY = StartY;
    StartX = iX;
    StartY = iY;
  }
  
  /* 画竖直线 */
  if (StartX == EndX)
  {
    for (iY = StartY; iY < EndY; iY++)
    {
      iX = StartX;
      iPage = iY / 8;
      cTmp = 1<<(iY%8);
      aFrameBuffer[iPage][iX] = aFrameBuffer[iPage][iX] | cTmp;
    }
    return OK;
  }
  else if(fKtmp > 1)
  {
    for (iY = StartY; iY < EndY; iY++)
    {
      iX = (int)((iY - fT) / fK);
      iPage = iY / 8;
      cTmp = 1<<(iY%8);
      
      aFrameBuffer[iPage][iX] = aFrameBuffer[iPage][iX] | cTmp;
    }
    return OK;
  }
  else
  {
    for (iX = StartX; iX < EndX; iX++)
    {
      iY = (int)(fK * iX + fT);
      iPage = iY / 8;
      cTmp = 1<<(iY%8);
      
      aFrameBuffer[iPage][iX] = aFrameBuffer[iPage][iX] | cTmp;
    }
    return OK;
  }
}

/* 描画填充矩形 */
int DrawRectSolid(UCHAR LeftX, UCHAR TopY, UCHAR Width, UCHAR Height)
{
  int iX = 0;
  int iY = 0;
  
  int iPage = 0;
  int iEndX = 0;
  int iEndY = 0;

  char cTmp = 0;
  
  iEndX = LeftX + Width;
  iEndY = TopY + Height;
  
  if (LeftX > 127 || TopY > 63 || iEndX > 127 || iEndY > 63 )
  {
    return ER;
  }

  /* 画实体矩形 */
  for (iY = TopY; iY < iEndY; iY++)
  {
    for (iX = LeftX; iX < iEndX; iX++)
    {
      iPage = iY / 8 ;
      cTmp = 1<<(iY%8);
      aFrameBuffer[iPage][iX] = aFrameBuffer[iPage][iX] | cTmp;
    }
  }
  
  return OK;
}

/* 描画矩形框架 */
int DrawRectFrame(UCHAR LeftX, UCHAR TopY, UCHAR Width, UCHAR Height)
{
  int iX = 0;
  int iY = 0;
  int iX1 = 0;
  int iX2 = 0;
  int iY1 = 0;
  int iY2 = 0;
  int iPage = 0;
  int iPage1 = 0;
  int iPage2 = 0;
  int iEndX = 0;
  int iEndY = 0;
  
  UCHAR cTmp = 0;
  UCHAR cTmp1 = 0;
  UCHAR cTmp2 = 0;

  iEndX = LeftX + Width;
  iEndY = TopY + Height;

  if (LeftX > 127 || TopY > 63 || iEndX > 127 || iEndY > 63 )
  {
    return ER;
  }
  
  /* 画矩形框 */
  for (iY = TopY; iY < iEndY; iY++)
  {	
    iX1 = LeftX;
    iX2 = iEndX - 1;
    
    iPage = iY / 8;
    cTmp = 1<<(iY%8);
    
    aFrameBuffer[iPage][iX1] = aFrameBuffer[iPage][iX1] | cTmp;
    aFrameBuffer[iPage][iX2] = aFrameBuffer[iPage][iX2] | cTmp;
  }
  for (iX = LeftX; iX < iEndX; iX++)
  {
    iY1 = TopY;
    iY2 = iEndY - 1;

    iPage1 = iY1 / 8;
    iPage2 = iY2 / 8;

    cTmp1 = 1<<(iY1%8);
    cTmp2 = 1<<(iY2%8);
    
    aFrameBuffer[iPage1][iX] = aFrameBuffer[iPage1][iX] | cTmp1;
    aFrameBuffer[iPage2][iX] = aFrameBuffer[iPage2][iX] | cTmp2;
  } 
  
  return OK;
}

/* 描画矩形点阵 */
int DrawLattice(const UCHAR* pLattice, POINT_t stOrigin, SIZE_t stSize, UCHAR ucMode)
{
	RECT_t stSrcRect;
	RECT_t stDstRect;
	UCHAR ucSrcBit;
	UCHAR ucDstBit;
	const UCHAR* pSrcLine;
	UCHAR* pDstLine;
	int isx,isy,idx,idy;

	/* 初始化矩形 */
	stSrcRect.ilx = 0;
	stSrcRect.ity = 0;
	stSrcRect.irx = stSize.iw;
	stSrcRect.iby = stSize.ih;
	
	stDstRect.ilx = stOrigin.ix;
	stDstRect.ity = stOrigin.iy;
	stDstRect.irx = stOrigin.ix + stSize.iw;
	stDstRect.iby = stOrigin.iy + stSize.ih;
	if (128 <= stDstRect.ilx || 64 <= stDstRect.ity
		|| 0 >= stDstRect.irx || 0 >= stDstRect.iby
		|| stSize.iw == 0 || stSize.ih == 0){
		return OK;
	}
	
	/* 裁剪矩形 */
	if (stDstRect.ilx < 0){
		stSrcRect.ilx += 0 - stDstRect.ilx;
		stDstRect.ilx = 0;
	}
	if (stDstRect.ity < 0){
		stSrcRect.ity += 0 - stDstRect.ity;
		stDstRect.ity = 0;
	}
	if (stDstRect.irx > 128){
		stSrcRect.irx += 128 - stDstRect.ity;
		stDstRect.irx = 128;
	}
	if (stDstRect.iby > 64){
		stSrcRect.iby += 64 - stDstRect.ity;
		stDstRect.iby = 64;
	}
	
	/* 复制数据 */
	isy = stSrcRect.ity;
	idy = stDstRect.ity;
	while (idy < stDstRect.iby){
		pSrcLine = pLattice + stSize.iw * (isy >> 3);
		pDstLine = aFrameBuffer[idy>>3];
		ucSrcBit = 0x01 << isy % 8;
		ucDstBit = 0x01 << idy % 8;
		isx = stSrcRect.ilx;
		idx = stDstRect.ilx;
		while (idx < stDstRect.irx){
			if (ucMode & 0x80){
				if (pSrcLine[isx] & ucSrcBit){
					pDstLine[idx] |= ucDstBit;
				}
				else{
					pDstLine[idx] &= ~ucDstBit;
				}
			}
			else{
				if (!(pSrcLine[isx] & ucSrcBit)){
					pDstLine[idx] |= ucDstBit;
				}
				else{
					pDstLine[idx] &= ~ucDstBit;
				}
			}
			++isx;
			++idx;
		}
		++isy;
		++idy;
	}

	return OK;
}

/*******************************************************************************
// 外部函数定义:高级描画
*******************************************************************************/
/* 加载图片 */
int DrawBMP(UCHAR BmpId, UCHAR LeftX, UCHAR TopY, UCHAR ucMode)
{
	POINT_t stOrigin;
	SIZE_t stSize;
	const UCHAR* pLattice;
	
	stOrigin.ix	= LeftX;
	stOrigin.iy	= TopY;
	stSize.iw	= strBMP_ID[BmpId].Width;
	stSize.ih	= strBMP_ID[BmpId].Height;
	pLattice	= strBMP_ID[BmpId].pBMP;
	return DrawLattice(pLattice, stOrigin, stSize, ucMode);
}

/* 描画字符串 */
int DrawString(const char* pString, UCHAR ucLength, UCHAR LeftX, UCHAR TopY, UCHAR ucStyle)
{
	POINT_t stOrigin;
	SIZE_t stSize;
	const UCHAR* pLattice;
	UCHAR ucMode;
	//UCHAR ucFont;

	stOrigin.ix	= LeftX;
	stOrigin.iy	= TopY;
	ucMode = ucStyle & 0x80;
	for (UCHAR i=0; i<ucLength && '\0' != pString[i]; ++i){
		char ch = pString[i];
		/* 写汉字 */
		if (ch >= 128){
			ch -= 128;
			stSize.iw	= 16;
			stSize.ih	= 16;
			pLattice = paucGB1616[ch];
			LeftX += 16;
		}
		else if(32 <= ch && ch < 128){
			ch -= 32;
			stSize.iw	= 8;
			stSize.ih	= 16;
			pLattice = Asii0816 + 16 * ch;
			LeftX += 8;
		}
		else{
			stSize.iw	= 0;
			stSize.ih	= 0;
			pLattice = NULL;
		}
		DrawLattice(pLattice, stOrigin, stSize, ucMode);
		stOrigin.ix += stSize.iw;
	}
	return OK;
}

/* 描画字符串 */
int DrawInt(int iInteger, UCHAR LeftX, UCHAR TopY, UCHAR ucStyle)
{
	UCHAR ucMode = ucStyle & 0x80;
	sprintf(acBuffer, "%d", iInteger);
	DrawString(acBuffer, (UCHAR)-1, LeftX, TopY, ucMode);
	
	return OK;
}