gutilities.c

关于XD256的应用实例,用于汽车电子开发之用

/*****************************************************
 gutilities.c - functions to handle the display     
 ----------------------------------------------------
  
 *****************************************************/

#include "hidef.h" /* this file declares symbols user by the CodeWarrior environment */

#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include "VTypes.h"
#include "XDP512Regs.h"
#include "Globals.h"
#include "GUtilities.h"

void WaitTick(int ticks);
void WaitTrue(int *condition) ;

/*************************************************************************************/

void ClearGBuff(uchar *GBuffer)

 {
  
 /* Variable Declarations */

 
 /* Begin Function ClearGBuff() */
 
 (void)memset(GBuffer, 0, 1024); 
 
 XFormGBuff(GBuffer, ScreenBuff);	/* display the new data */
 
}	/* end ClearGBuff */



/*************************************************************************************/

void DoXGTransfer(void) 

{
   STData.transfering = 1;
   STData.y = 0;
   WaitTrue(&STData.transfering);
}

/*************************************************************************************/

static uchar XFormADSplit(uchar *AByte, uchar *DByte)

 {
  
 /* Variable Declarations */

 uchar XFormByte = 0;
 int x;
 uchar BMask = 0x80;
 
 /* Begin Function XFormADSplit() */
 
x = 7;
while (x > 0)
 {
  XFormByte |= (*DByte << x) & BMask;
  BMask >>= 2;
  DByte -= 16;
  x -= 2;
 }
 
 BMask = 0x40;

 for (x = 1; x <= 7; x += 2)
  {
   XFormByte |= (*AByte >> x) & BMask;
   BMask >>= 2;
   AByte -= 16;
  }
   
 return(XFormByte);
 
}	/* end XFormADSplit */

/*************************************************************************************/

static uchar XFormBCHigh(uchar *BCByte)

 {
  
 /* Variable Declarations */

 uchar XFormByte = 0;
 int x;
 uchar BMask = 0x30;
 
 /* Begin Function XFormBCHigh() */
 
  XFormByte |= (*BCByte << 1) & 0xc0;
  BCByte -= 16;

  for (x = 1; x <= 5; x += 2)
  {
   XFormByte |= (*BCByte >> x) & BMask;
   BMask >>= 2;
   BCByte -= 16;
  }

 return(XFormByte);
 
}	/* end XFormBCHigh */

/*************************************************************************************/

static uchar XFormADMid(uchar *ADByte)

 {
  
 /* Variable Declarations */

 uchar XFormByte = 0;
 int x;
 uchar BMask = 0x0c;
 
 /* Begin Function XFormADMid() */
 
  XFormByte |= (*ADByte << 3) & 0xc0;
  ADByte -= 16;
  XFormByte |= (*ADByte << 1) & 0x30;
  ADByte -= 16;

  for (x = 1; x <= 3; x += 2)
  {
   XFormByte |= (*ADByte >> x) & BMask;
   BMask >>= 2;
   ADByte -= 16;
  }

 return(XFormByte);
 
}	/* end XFormADMid */

/*************************************************************************************/

static uchar XFormBCLow(uchar *BCByte)

 {
  
 /* Variable Declarations */

 uchar XFormByte = 0;
 int x;
 uchar BMask = 0xc0;
 
 /* Begin Function XFormBCLow() */
 
 x = 5;
 while(x > 0)
  {
   XFormByte |= (*BCByte << x) & BMask;
   BMask >>= 2;
   BCByte -= 16;
   x -= 2;
  }

  XFormByte |= (*BCByte >> 1) & 0x03;
  BCByte -= 16;

 return(XFormByte);
 
}	/* end XFormBCLow */

/*************************************************************************************/

void XFormGBuff(uchar *GBuffer, uchar *VFDScreenBuff)

 {
  
 /* Variable Declarations */
 
 int x, y, z;
 uchar *GBufferP = GBuffer;
 
 /* Begin Function XFormGBuff() */
 
 if (BMPTfrByXG) { /* to be done by XGATE */
    DoXGTransfer();
    return;
 }

 y = 0;				/* stuff data at the start of display buffer */
 x = 1008;			/* start at the last row in the graphics buffer */
 while (x >= 0)			/*  */
  {
   VFDScreenBuff[y] = XFormADSplit(&GBuffer[x], &GBuffer[x + 15]);
   y++;
   x -= 64;
  }

 for (z = 0; z < 15; z++)
  {
   x = 1008 + z;
   while (x >= z)
    {
     VFDScreenBuff[y] = XFormBCHigh(&GBuffer[x]);
     y++;
     x -= 64;
    }

   x = 1008 + z;
   while (x >= z)
    {
     VFDScreenBuff[y] = XFormADMid(&GBuffer[x]);
     y++;
     x -= 64;
    }

   x = 1008 + z;
   while (x >= z)
    {
     VFDScreenBuff[y] = XFormBCLow(&GBuffer[x]);
     y++;
     x -= 64;
    }

   x = 1008 + z;
   while (x >= z)
    {
     VFDScreenBuff[y] = XFormADSplit(&GBuffer[x + 1], &GBuffer[x]);
     y++;
     x -= 64;
    }
  }
 
 x = 1008 + z;
 while (x >= z)
  {
   VFDScreenBuff[y] = XFormBCHigh(&GBuffer[x]);
   y++;
   x -= 64;
  }

 x = 1008 + z;
 while (x >= z)
  {
   VFDScreenBuff[y] = XFormADMid(&GBuffer[x]);
   y++;
   x -= 64;
  }

 x = 1008 + z;
 while (x >= z)
  {
   VFDScreenBuff[y] = XFormBCLow(&GBuffer[x]);
   y++;
   x -= 64;
  }
  WaitTick(1); 
 
}	/* end XFormGBuff */

/*************************************************************************************/

void GSlideDown(const uchar *GBuffSrc, uchar *GBuffDst)

 {
  
 /* Variable Declarations */
 
 uint x, y, z;				/* loop counters */
 uint *GBuffSrcW;			/* word pointer into the source buffer */
 uint *GBuffDstW;			/* word pointer into the destination buffer */
 
 /* Begin Function GSlideDown() */
 
 GBuffSrcW = (uint *)GBuffSrc + 511;	/* point to the last word in the source buffer */

 for (x = 0; x < 64; x++)		/* loop that moves all 64 display rows */
  {
   GBuffDstW = (uint *)GBuffDst + 503;	/* init pointer to the last word in row 62 of the display buffer */
   for (y = 0; y < 63; y++)		/* move 63 rows of display data down by 1 row */
    {
     for (z = 0; z < 8; z++)		/* move the 8 words in one row down one row */
      {
       *(GBuffDstW + 8) = *GBuffDstW;
       GBuffDstW--;
      }
    }
   GBuffDstW = GBuffDstW + 8;		/* adjust pionter to point at the last word in row 0 */
   if (GBuffSrc == 0)			/* source buffer to take data from? */
    {
     for (z = 0; z < 8; z++)		/* no. fill row 0 with zeros (blank pixles) */
      *GBuffDstW-- = 0x0000;
    }
   else	
    {
     for (z = 0; z < 8; z++)		/* yes. fill row 0 from source buffer */
      *GBuffDstW-- = *GBuffSrcW--;
    }
   XFormGBuff(GBuffDst, ScreenBuff);	/* display the new data */
  }
 
 }	/* end GSlideDown */

/*************************************************************************************/

static void RShiftBuff(uchar *GBuffSrc, uchar *GBuffDst)

 {
  
 /* Variable Declarations */
 
 
 /* Begin Function RShiftBuff() */
 
#asm 

#ifdef __MWERKS__  
  ldy   GBuffSrc
  ldx   GBuffDst
#else
	tfr	d,y		; pointer to source bits to be shifted in.
	ldx	2,sp		; pointer to destination (graphics buffer).
#endif
	ldab	#64		; number of rows to shift.
RoLoop:	lsr	1,y+		; shift source 1 bit to right.
	rorw	2,x+		; rotate 1st word in row to the right.
	rorw	2,x+		; rotate 2nd word in row to the right.
	rorw	2,x+		; rotate 3rd word in row to the right.
	rorw	2,x+		; rotate 4th word in row to the right.
	rorw	2,x+		; rotate 5th word in row to the right.
	rorw	2,x+		; rotate 6th word in row to the right.
	rorw	2,x+		; rotate 7th word in row to the right.
	rorw	2,x+		; rotate 8th word in row to the right.
	dbne	b,RoLoop
 
#endasm
//#endif
 
 
 }	/* end RShiftBuff */

/*************************************************************************************/

void GSlideRight(const uchar *GBuffSrc, uchar *GBuffDst)

 {
  
 /* Variable Declarations */
 
 uint x, y;				/* loop counters */
 uchar SrcByteBuff[64];			/* source column buffer */
 uchar *SrcByteBuffP;
 uchar *GBuffSrcP;
 
 /* Begin Function GSlideRight() */

 for (x = 0; x < 16; x++)
  {
   GBuffSrcP = (uchar *)((uint)(GBuffSrc + 15) - x);
   SrcByteBuffP = SrcByteBuff;
   for (y = 0; y < 64; y++)
    {
     if (GBuffSrc != 0)
      {
       *SrcByteBuffP++ = *GBuffSrcP;
       GBuffSrcP += 16;
      }
     else
      *SrcByteBuffP++ = 0x00;
    }
   for (y = 0; y < 8; y++)
    {
     RShiftBuff(SrcByteBuff, GBuffDst);
     XFormGBuff(GBuffDst, ScreenBuff);	/* display the new data */
    }

  }
 
 }	/* end GSlideRight */

/*************************************************************************************/

void GBarnDoorOpen(const uchar *GBuffSrc, uchar *GBuffDst)

 {
  
 /* Variable Declarations */
 
 uint x, y, z;				/* loop counter */
 uchar MaskLeft;
 uchar MaskRight;
 uchar *DstBuffLeftP;
 uchar *DstBuffRightP;
 uchar *SrcBuffLeftP;
 uchar *SrcBuffRightP;

 /* Begin Function GBarnDoorOpen() */
 
 for (x = 0; x < 8; x++)
  {
   MaskLeft = 0x01;
   MaskRight = 0x80;
   for (y = 0; y < 8; y++)
    {
     DstBuffLeftP = (uchar *)((uint)(GBuffDst + 7) - x);
     DstBuffRightP = (uchar *)((uint)(GBuffDst + 8) + x);
     SrcBuffLeftP = (uchar *)((uint)(GBuffSrc + 7) - x);
     SrcBuffRightP = (uchar *)((uint)(GBuffSrc + 8) + x);
     for (z = 0; z < 64; z++)
      {
       *DstBuffLeftP = (*DstBuffLeftP & ~MaskLeft) | (*SrcBuffLeftP & MaskLeft);
       *DstBuffRightP = (*DstBuffRightP & ~MaskRight) | (*SrcBuffRightP & MaskRight);
       DstBuffLeftP += 16;
       DstBuffRightP += 16;
       SrcBuffLeftP += 16;
       SrcBuffRightP += 16;
      }
     MaskLeft <<= 1;
     MaskRight >>= 1;
     XFormGBuff(GBuffDst, ScreenBuff);	/* display the new data */
    }
  }
 
 }	/* end GBarnDoorOpen() */

/*************************************************************************************/

void GInvert(uchar *GBuffSrc)

 {
  
 /* Variable Declarations */
 
 uint x;
 uchar *GBuffSrcP;
 
 /* Begin Function GInvert() */
 
 GBuffSrcP = GBuffSrc;

 for (x = 0; x < ScreenBuffSize; x++)
  {
   *GBuffSrcP = ~*GBuffSrcP;
   GBuffSrcP++;
  }
 
 XFormGBuff(GBuffSrc, ScreenBuff);	/* display the new data */
 
 }	/* end GInvert() */

/*************************************************************************************/