//

 //

 //

 #include "FutabaGP1212A02.h"

 #include <stdio.h>

 #include <time.h>

 const unsigned short KMaxDataMemoryAddress = 0x4FFF;

 const unsigned short KFrameSizeInBytes = 0x800;

 //

 // class GP1212A02A

 //

 GP1212A02A::GP1212A02A():

 	iDisplayPositionX(0),iDisplayPositionY(0),

     iOffScreenMode(true),

     iUseFrameDifferencing(true),

     iFrameNext(NULL),

     iFrameCurrent(NULL),

     iFramePrevious(NULL),

     iFrameAlpha(NULL),

     iFrameBeta(NULL),

     iFrameGamma(NULL),

     iNeedFullFrameUpdate(0),

     iPowerOn(false)

 	{

 	iDeviceId[0]=0;

 	iFirmwareRevision[0]=0;

 	//ResetBuffers();

 	}

 /**

 */

 GP1212A02A::~GP1212A02A()

 	{

     delete iFrameAlpha;

     iFrameAlpha=NULL;

     //

     delete iFrameBeta;

     iFrameBeta=NULL;

     //

     delete iFrameGamma;

     iFrameGamma=NULL;

     //

     iFrameNext=NULL;

     iFrameCurrent=NULL;

     iFramePrevious=NULL;

     //

     iNeedFullFrameUpdate=0;

 	}

 /**

 */

 int GP1212A02A::Open()

 	{

 	int success = HidDevice::Open(KFutabaVendorId,KFutabaProductIdGP1212A02A,NULL);

 	if (success)

 		{

         //Allocate both frames

         delete iFrameAlpha;

         iFrameAlpha=NULL;

         iFrameAlpha=new BitArrayLow(KGP12xFrameBufferPixelCount);

         //

         delete iFrameBeta;

         iFrameBeta=NULL;

         iFrameBeta=new BitArrayLow(KGP12xFrameBufferPixelCount);

         //

         delete iFrameGamma;

         iFrameGamma=NULL;

         iFrameGamma=new BitArrayLow(KGP12xFrameBufferPixelCount);

         //

         iFrameNext=iFrameAlpha;

         iFrameCurrent=iFrameBeta;

         iFramePrevious=iFrameGamma;

         //To make sure it is synced properly

         iNeedFullFrameUpdate=0;

         //

 		SetNonBlocking(1);

 		//

 		SendCommandClear();

 		//

 		SetClockSetting();

 		//BMP box setup could be removed if we don't use it anymore

 		//Setup BMP box

 		BmpBoxSetting(EBmpBoxIdOne,0x0000,256,64);

 		//Select current BMP box

 		BmpBoxSelect(EBmpBoxIdOne);

 		//

 		iNextFrameAddress = 0x0000;

 		}

 	return success;

 	}

 /**

  Setting the BMP box

 [Code] 1BH,5CH,42H,Pn,aL,aH,Pw,Ph

 [Function] Setting the BMP box. BMP box can be defined the 3 area to DW. The position of BMP 

 box is set based on the address of DW. 

 * To write data in BMP box, BMP box select is necessary. 

 * Specifiable horizontal size is 256dot (100H) MAX. If horizontal size specify 256dot, Pw = 00H 

 Pn = Number of a BMP box 

 aL = Lower byte of address 

 aH = Upper byte of address 

 Pw = BMP box width 

 Ph = BMP box height 

 [Definable area]

 Pn = 31H - BMP box 1

 Pn = 32H - BMP box 2

 Pn = 33H - BMP box 3

 0000H <= aL + aH * 100 <= 07FFH 

 01H <= Pw <= 00H (=100H) 

 01H <= Ph <= 08H

 */

 void GP1212A02A::BmpBoxSetting(TBmpBoxId aBoxId, unsigned short aAddress, int aWidth, int aHeight)

 	{

 	//TODO: check parameters validity

 	//1BH,5CH,42H,Pn,aL,aH,Pw,Ph

 	FutabaVfdReport report;

 	report[0]=0x00; //Report ID

 	report[1]=0x08; //Report length.

 	report[2]=0x1B; //Command ID

 	report[3]=0x5C; //Command ID

 	report[4]=0x42; //Command ID

 	report[5]=aBoxId; 

 	report[6]=(unsigned char)aAddress; //aL = DM lower byte

 	report[7]=aAddress>>8; //aH = DM upper byte

 	report[8]=(aWidth==256?0x00:aWidth); //Pw = BMP box width 00==256

 	report[9]=aHeight/8; //Ph = BMP box height.

 	Write(report);

 	}

 /**

 [Code]1BH,5CH,48H,Pn

 [Function]Select of BMP box 

 * Execution "BMP box select" is necessary before "Setting the Text box". 

 * In case of writing by the specified dot writing, it is necessary to cancel this command. 

 [Definable area]

 Pn = 30H - Remove the BMP box 

 Pn = 31H - BMP box 1

 Pn = 32H - BMP box 2

 Pn = 33H - BMP box 3

 */

 void GP1212A02A::BmpBoxSelect(TBmpBoxId aBoxId)

 	{

 	//TODO: check parameters validity 

 	FutabaVfdReport report;

 	report[0]=0x00; //Report ID

 	report[1]=0x04; //Report length.

 	report[2]=0x1B; //Command ID

 	report[3]=0x5C; //Command ID

 	report[4]=0x48; //Command ID

 	report[5]=aBoxId; //BMP box ID

 	Write(report);

 	}

 /**

 */

 void GP1212A02A::SetPixel(unsigned char aX, unsigned char aY, bool aOn)

 	{

 	//

 	//int byteOffset=(aX*HeightInPixels()+aY)/8;

 	//int bitOffset=(aX*HeightInPixels()+aY)%8;

     //iNextFrame[byteOffset] |= ( (aOn?0x01:0x00) << bitOffset );

     if (iOffScreenMode)

         {

         if (aOn)

             {

             iFrameNext->SetBit(aX*HeightInPixels()+aY);

             }

         else

             {

             iFrameNext->ClearBit(aX*HeightInPixels()+aY);

             }

         }

     else

         {

         //Just specify a one pixel block

         //TODO

         }

 	}

 /**

 */

 /*

 void GP1212A02A::BitBlit(const BitArray& aBitmap, int aSrcWidth, int aSrcHeight, int aTargetX, int aTargetY) const

 	{

 	//TODO: amend loop values so that we don't keep on looping past our frame buffer dimensions.

 	for (int i=0;i<aSrcWidth;i++)

 		{

 		for (int j=0;j<aSrcHeight;j++)

 			{

             iFrameNext->SetBitValue((aTargetX+i)*HeightInPixels()+aTargetY+j,aBitmap[+i*aSrcHeight+j]);

 			}

 		}

 	}

 */

 /**

 Clear our client side back buffer.

 Call to SwapBuffers must follow to actually clear the display.

 */

 void GP1212A02A::Clear()

     {

     //memset(iNextFrame->Ptr(),0x00,FrameBufferSizeInBytes());

     if (iOffScreenMode)

         {

         iFrameNext->ClearAll();

         }

     else

         {

         SendCommandClear();

         }

     }

 /**

 Turn on all pixels.

 Must be followed by a SwapBuffers call.

 */

 void GP1212A02A::Fill()

 	{

 	SetAllPixels(0xFF);

 	}

 /**

 Set all pixels on our screen to the desired value.

 This operation is performed off screen to avoid tearing.

 @param 8 pixels pattern

 */

 void GP1212A02A::SetAllPixels(unsigned char aPattern)

 	{

 	//With a single buffer

 	//unsigned char screen[2048]; //One screen worth of pixels

 	//memset(screen,0xFF,sizeof(screen));

 	//SetPixelBlock(0,0,63,sizeof(screen),screen);

     if (iOffScreenMode)

         {

         memset(iFrameNext->Ptr(),aPattern,FrameBufferSizeInBytes());

         }

     else

         {

         //Using pattern SetPixelBlock variant.

         //TODO

         }

 	//

 	}

 /**

 BMP data input 

 [Code] 1BH,4AH,Pm,aL,aH,Ps,nL,nH,Pd...Pd

 [Function] The BMP data is written in the DW(Display Window) or the Data memory. 

 Pm= DW or Data memory 

 aL = DW lower byte 

 aH = DW upper byte 

 Ps = Direction of writing 

 nL = number of BMP data length lower byte 

 nH = number of BMP data length upper byte 

 Pd = BMP data 

 * If X direction is selected as Ps and data is written in the last address, the data in the last address is 

 overwritten with the remaining data.  

 [Definable area] Pm = 30H : DW

  Pm = 31H: Data memory 

 0000H <= aL + aH * 100 <= 07FFH (DW)

 0000H <= aL + aH * 100 <= 4FFFH (Data memory) 

 Ps = 30H: Y direction 

 Ps = 31H: X direction 

 0001H <= nL + nH * 100 <= 0100H(DW: X direction) 

 0001H <= nL + nH * 100 <= 0800H(DW: Y direction) 

 0001H <= nL + nH * 100 <= 0A00H(Data memory: X direction) 

 0001H <= nL + nH * 100 <= 5000H(Data memory: Y direction) 

 */

 void GP1212A02A::BmpDataInput(TTarget aTarget, unsigned short aAddress, TDirection aDirection, unsigned short aSize, unsigned char* aPixels)

 {

 	FutabaVfdReport report;

     report[0]=0x00; //Report ID

     report[1]=(aSize<=report.Size()-10?aSize+0x08:64); //Report length. -10 is for our header first 10 bytes. +8 is for our Futaba header size

     report[2]=0x1B; //Command ID

     report[3]=0x4A; //Command ID

     report[4]=aTarget; //Display Window or Data Memory

     report[5]=(unsigned char)aAddress; //aL = DW lower byte

     report[6]=aAddress>>8; //aH = DW upper byte

     report[7]=aDirection; //Direction of writing: Y or X

 	report[8]=(unsigned char)aSize; //Size of pixel data in bytes (LSB)

 	report[9]=aSize>>8;	//Size of pixel data in bytes (MSB)

     int sizeWritten=MIN(aSize,report.Size()-10);

     memcpy(report.Buffer()+10, aPixels, sizeWritten);

     Write(report);

     int remainingSize=aSize;

     //We need to keep on sending our pixel data until we are done

     while (report[1]==64)

         {

         report.Reset();

         remainingSize-=sizeWritten;

         report[0]=0x00; //Report ID

         report[1]=(remainingSize<=report.Size()-2?remainingSize:64); //Report length, should be 64 or the remaining size

         sizeWritten=(report[1]==64?63:report[1]);

         memcpy(report.Buffer()+2, aPixels+(aSize-remainingSize), sizeWritten);

         Write(report);

         }

 }

 /**

 Data memory transfer

 [Code] 1BH,5CH,44H,aL,aH

 [Function] BMP data transfer from Data memory to DW. 

 Although source data is updated, data in BMP box is not updated. To reflect the update, 

 re-executing this command is necessary. 

 aL = Lower byte of address 

 aH = Upper byte of address 

 [Definable area]

 0000H <= aL + aH * 100 <= 4FFFH 

 */

 void GP1212A02A::BmpBoxDataMemoryTransfer(unsigned short aAddress)

 	{

 	FutabaVfdReport report;

 	report[0]=0x00; //Report ID

     report[1]=0x05; //Report length.

     report[2]=0x1B; //Command ID

     report[3]=0x5C; //Command ID

     report[4]=0x44; //Command ID

     report[5]=(unsigned char)aAddress; //aL = DM lower byte

     report[6]=aAddress>>8; //aH = DM upper byte

 	Write(report);

 	}

 /**

 Input BMP data in the BMP box 

 [Code] 1BH,5CH,5DH,nL,nH,Pd...Pd

 [Function] BMP data is written the BMP box 

 * Number of definable data is due to BMP box size. If the data is over range, the over range data is 

 rewritten the final address. 

 nL = Lower byte of number of definition byte 

 nH = Upper byte of number of definition byte 

 Pd = BMP data 

 [Definable area] Pn : BMP box size (Pw * Ph)

 */

 void GP1212A02A::BmpBoxDataInput(unsigned short aSize, unsigned char* aPixels)

 	{

 	FutabaVfdReport report;

     report[0]=0x00; //Report ID

     report[1]=(aSize<=report.Size()-7?aSize+0x05:64); //Report length. -7 is for our header first 10 bytes. +5 is for our Futaba header size

     report[2]=0x1B; //Command ID

     report[3]=0x5C; //Command ID

     report[4]=0x5D; //Display Window or Data Memory

 	report[5]=(unsigned char)aSize; //Size of pixel data in bytes (LSB)

 	report[6]=aSize>>8;	//Size of pixel data in bytes (MSB)

     int sizeWritten=MIN(aSize,report.Size()-7);

     memcpy(report.Buffer()+7, aPixels, sizeWritten);

     Write(report);

     int remainingSize=aSize;

     //We need to keep on sending our pixel data until we are done

     while (report[1]==64)

         {

         report.Reset();

         remainingSize-=sizeWritten;

         report[0]=0x00; //Report ID

         report[1]=(remainingSize<=report.Size()-2?remainingSize:64); //Report length, should be 64 or the remaining size

         sizeWritten=(report[1]==64?63:report[1]);

         memcpy(report.Buffer()+2, aPixels+(aSize-remainingSize), sizeWritten);

         Write(report);

         }

 	}

 /**

 Using this function is advised against as is causes tearing.

 Use Clear instead.

 */

 void GP1212A02A::SendCommandClear()

 	{

     //1BH,4AH,43H,44H

     //Send Clear Display Command

 	FutabaVfdReport report;

 	report[0]=0x00; //Report ID

 	report[1]=0x04; //Report length

 	report[2]=0x1B; //Command ID

 	report[3]=0x4A; //Command ID

 	report[4]=0x43; //Command ID

 	report[5]=0x44; //Command ID

 	Write(report);

 	}

 /**

 Provide Y coordinate of our off screen buffer.

 */

 unsigned char GP1212A02A::OffScreenY() const

 	{

 	//Overflowing is fine this is just what we want

 	return iDisplayPositionY+HeightInPixels();

 	}

 /**

 Put our off screen buffer on screen.

 On screen buffer goes off screen.

 */

 void GP1212A02A::SwapBuffers()

 	{

 	//Only perform buffer swapping if off screen mode is enabled

 	if (OffScreenMode())

 		{

 		//Send pixel directly into BMP box

 		//BmpBoxDataInput(FrameBufferSizeInBytes(),iFrameNext->Ptr());

 		//Send pixel data directly into the display window

 		//BmpDataInput(ETargetDisplayWindow,0x0000,EDirectionY, FrameBufferSizeInBytes(),iFrameNext->Ptr());

 		//Send pixel data first to Data Memory then copy into the selected BMP box	

 		//BmpDataInput(ETargetDataMemory,0x0000,EDirectionY, FrameBufferSizeInBytes(),iFrameNext->Ptr());

 		//BmpBoxDataMemoryTransfer(0x0000);

 		//Send pixel data first to Data Memory then copy into the selected BMP box, cycling through our Data Memory frmae

 		BmpDataInput(ETargetDataMemory,iNextFrameAddress,EDirectionY, FrameBufferSizeInBytes(),iFrameNext->Ptr());

 		BmpBoxDataMemoryTransfer(iNextFrameAddress);

 		iNextFrameAddress+=KFrameSizeInBytes;

 		if (iNextFrameAddress>KMaxDataMemoryAddress)

 		{

 			iNextFrameAddress=0x0000;

 		}

         //Cycle through our frame buffers

         //We keep track of previous frame which is in fact our device back buffer.

         //We can then compare previous and next frame and send only the differences to our device.

         //This mechanism allows us to reduce traffic over our USB bus thus improving our frame rate from 14 FPS to 30 FPS.

         //Keep our previous frame pointer

         BitArrayLow* previousFrame=iFramePrevious;

         //Current frame becomes the previous one

         iFramePrevious = iFrameCurrent;

         //Next frame becomes the current one

         iFrameCurrent = iFrameNext;

         //Next frame is now our former previous

         iFrameNext = previousFrame;

 		}

 	}

 //Define the edge of our pixel block

 //Pixel blocks of 32x32 seems to run almost as fast as full screen update in worse case scenarii.

 //Though I wonder if in some situations 16 could be better. Make this an attribute at some point if need be.

 const int KPixelBlockEdge = 32;

 const int KPixelBlockSizeInBits = KPixelBlockEdge*KPixelBlockEdge;

 const int KPixelBlockSizeInBytes = KPixelBlockSizeInBits/8;

 /**

 Translate the given pixel coordinate according to our off screen mode.

 */

 void GP1212A02A::OffScreenTranslation(unsigned char& aX, unsigned char& aY)

 	{

 	if (OffScreenMode())

 		{

 		aX+=WidthInPixels()-iDisplayPositionX;

 		aY+=HeightInPixels()-iDisplayPositionY;

 		}

 	}

 /**

 */

 void GP1212A02A::Request(TMiniDisplayRequest aRequest)

 	{

 	switch (aRequest)

 		{

 	case EMiniDisplayRequestDeviceId:

 		RequestDeviceId();

 		break;

 	case EMiniDisplayRequestFirmwareRevision:

 		RequestFirmwareRevision();

 		break;

 	case EMiniDisplayRequestPowerSupplyStatus:

 		RequestPowerSupplyStatus();

 		break;

 	default:

 		//Not supported

 		break;

 		};

 	}

 /**

 */

 void GP1212A02A::ResetBuffers()

 	{

     //iNextFrame->ClearAll();

     //memset(iFrameAlpha,0x00,sizeof(iFrameAlpha));

 	//memset(iFrameBeta,0x00,sizeof(iFrameBeta));

 	}

 /**

 */

 void GP1212A02A::RequestDeviceId()

     {

 	//Not supported

     }

 /**

 ID code 

 [Code] 1BH,6AH,49H,44H

 [Function] Send the ID code to the Host system. ID code is software version.

 */

 void GP1212A02A::RequestFirmwareRevision()

     {

     if (RequestPending())

         {

         //Abort silently for now

         return;

         }

     //1BH,6AH,49H,44H

     //Send Software Revision Read Command

     FutabaVfdReport report;

     report[0]=0x00; //Report ID

     report[1]=0x04; //Report length

     report[2]=0x1B; //Command ID

     report[3]=0x6A; //Command ID

     report[4]=0x49; //Command ID

     report[5]=0x44; //Command ID

     if (Write(report)==report.Size())

         {

         SetRequest(EMiniDisplayRequestFirmwareRevision);

         }

     }

 /**

 */

 void GP1212A02A::RequestPowerSupplyStatus()

     {

 	//Not supported

     }

 /**

 This is for development purposes only.

 Production application should stick to off-screen mode to avoid tearing.

 */

 void GP1212A02A::ToggleOffScreenMode()

 	{

     SetOffScreenMode(!iOffScreenMode);

 	}

 /**

  * @brief GP1212A02A::SetOffScreenMode

  * @param aOn

  * @return

  */

 void GP1212A02A::SetOffScreenMode(bool aOn)

     {

     if (aOn==iOffScreenMode)

     {

         //Nothing to do here

         return;

     }

     iOffScreenMode=aOn;

     //Clean up our buffers upon switching modes

     Clear();

     SwapBuffers();

     Clear();

     }

 /**

 Tries to complete our current request if we have one pending.

  */

 TMiniDisplayRequest GP1212A02A::AttemptRequestCompletion()

     {

     if (!RequestPending())

         {

         return EMiniDisplayRequestNone;

         }

     int res=Read(iInputReport);

     if (!res)

         {

         return EMiniDisplayRequestNone;

         }

     //Process our request

 	if (CurrentRequest()==EMiniDisplayRequestFirmwareRevision)

 		{

 			unsigned char* ptr=&iInputReport[2];

 			iInputReport[7]=0x00;

 			strcpy(iFirmwareRevision,(const char*)ptr);

 		}

     TMiniDisplayRequest completed=CurrentRequest();

     //Our request was completed

     SetRequest(EMiniDisplayRequestNone);

     return completed;

 	}

 /**

 Set our screen brightness.

 @param The desired brightness level. Must be between MinBrightness and MaxBrightness.

 */

 void GP1212A02A::SetBrightness(int aBrightness)

     {

     if (aBrightness<MinBrightness()||aBrightness>MaxBrightness())

         {

         //Brightness out of range.

         //Just ignore that request.

         return;

         }

     FutabaVfdReport report;

     report[0]=0x00; //Report ID

     report[1]=0x04; //Report size

     report[2]=0x1B; //Command ID

     report[3]=0x4A; //Command ID

     report[4]=0x44; //Command ID

     report[5]=0x30+aBrightness; //Brightness level

     Write(report);

     }

 /**

 */

 bool GP1212A02A::IsPowerOn()

 	{

 	return iPowerOn;

 	}

 /**

 */

 char* GP1212A02A::DeviceId()

 	{

 	return iDeviceId;

 	}

 /**

 */

 char* GP1212A02A::FirmwareRevision()

 	{

 	return iFirmwareRevision;

 	}

 /**

 VFD Power ON/OFF 

 [Code]1BH,4AH,42H,Ps

 [Function]Control of the power supply for VFD 

 * If VFD power ON or OFF, at interval of 10s or more. 

 * When the VFD power off, VFD display is turn off, but the module can receive a data and 

 process.

 Ps = VFD Power control 

 [Definable area]

 Ps = 30H : VFD Power OFF 

 Ps = 31H : VFD Power ON  (Default)

 */

 void GP1212A02A::SendCommandPower(TPowerStatus aPowerStatus)

 	{

 	FutabaVfdReport report;

     report[0]=0x00; //Report ID

     report[1]=0x04; //Report size

     report[2]=0x1B; //Command ID

     report[3]=0x4A; //Command ID

     report[4]=0x42; //Command ID

     report[5]=aPowerStatus; //ON or OFF

     Write(report);

 	}

 /**

 */

 void GP1212A02A::TurnPowerOn()

 	{

 	SendCommandPower(EPowerOn);

 	SetClockSetting();

 	}

 /**

 */

 void GP1212A02A::TurnPowerOff()

 	{

 	SendCommandPower(EPowerOff);

 	}

 /**

 Number of characters for the given clock format.

 @return 

 */

 int GP1212A02A::ClockCharCount(TClockFormat aFormat)

 	{

 	switch (aFormat)

 		{

 	case EClockDay12:

 		return 13;

 	case EClockDay24:

 		return 10;

 	case EClock12:

 		return 8;

 	case EClock24:

 		return 5;

 		}

 	return 10;

 	}

 /**

 @return 

 */

 int GP1212A02A::ClockCharWidthInPixels(TClockSize aSize)

 	{

 	switch (aSize)

 		{

 	case EClockTiny:

 		return 6;

 	case EClockSmall:

 		return 8;

 	case EClockMedium:

 		return 12;

 	case EClockLarge:

 		return 16;

 		}

 	return 16;

 	}

 /**

 @return 

 */

 int GP1212A02A::ClockCharHeightInPixels(TClockSize aSize)

 	{

 	switch (aSize)

 		{

 	case EClockTiny:

 		return 8;

 	case EClockSmall:

 		return 16;

 	case EClockMedium:

 		return 24;

 	case EClockLarge:

 		return 32;

 		}

 	return 32;

 	}

 /**

 Return the Display Window address for centering the clock corresponding to the given parameters.

 */

 unsigned short GP1212A02A::ClockCenterAddress(TClockFormat aFormat, TClockSize aSize)

 	{

 		int charCount=ClockCharCount(aFormat);

 		int halfWidth=(ClockCharWidthInPixels(aSize)*charCount)/2;

 		int halfHeight=(ClockCharHeightInPixels(aSize))/2;

 		int x=(WidthInPixels()/2)-halfWidth;

 		int y=(HeightInPixels()/2)-halfHeight;

 		int yOffset=y/8;

 		int xOffset=x*8; //Not sure why...

 		unsigned short address = yOffset+xOffset;

 		//

 		return address;

 	}

 /**

 */

 void GP1212A02A::ShowClock()

 	{

 	SendCommandClockDisplay(EClockDay24,ClockCenterAddress(EClockDay24,EClockLarge),EClockLarge);

 	}

 /**

 */

 void GP1212A02A::HideClock()

 	{

 	SendCommandClockCancel();

 	}

 /**

 Clock setting 

 [Code]1BH,6BH,53H,Pd,Ph,Pm 

 [Function]Setting the clock data. The setting data is cleared, if the Reset command is input or power 

 is turned off. 

 Pd = Day of the week 

 Ph = hour 

 Pm = minute 

 [Definable area]

 Pd = 00H : Sunday 

 Pd = 01H : Monday 

 ...

 Pd = 06H : Saturday 

 * Clock setting is canceled, when Pd is input value that is larger than 07H, or Ph is input value that is 

 larger than 18H,or Pm is input value that is larger than 3CH. 

 */

 void GP1212A02A::SendCommandClockSetting(TWeekDay aWeekDay, unsigned char aHour, unsigned char aMinute)

 	{

 	FutabaVfdReport report;

     report[0]=0x00; //Report ID

     report[1]=0x06; //Report size

     report[2]=0x1B; //Command ID

     report[3]=0x6B; //Command ID

     report[4]=0x53; //Command ID

     report[5]=aWeekDay; //Sunday to Saturday

 	report[6]=aHour;

 	report[7]=aMinute;

     Write(report);

 	}

 /**

 Set display clock settings according to local system time.

 This needs to be redone whenever we open or turn on our display.

 */

 void GP1212A02A::SetClockSetting()

 	{

 	time_t rawtime;

 	struct tm * timeinfo;

 	time ( &rawtime );

 	timeinfo = localtime ( &rawtime );

 	//

 	SendCommandClockSetting((TWeekDay)timeinfo->tm_wday,timeinfo->tm_hour,timeinfo->tm_min);

 	}

 /**

 Clock display

 [Code] 1BH,6BH,55H,Ps,aL,aH,Pf

 [Function] Clock is displayed. The display position and the font size can be freely decided. 

 Ps = Display type select 

 aL,aH = Address 

 Pf = Font size select 

 [Definable area]

 Ps = 00H : 24hour Ex.[12:34] 

 Ps = 01H : 24hour + day of the week  Ex.[Wed._12:34] 

 Ps = 10H : 12hour Ex.[PM_00:34] 

 Ps = 11H : 12hour + day of the week  Ex.[Wed._PM_00:34] 

 Pf = 30H : 6x8 dot 

 Pf = 31H : 8x16dot

 Pf = 32H : 12x24 dot 

 Pf = 33H : 16x32 dot 

 * When the clock data is not input, clock is not displayed. 

 * The clock display is maintained until Clock display cancel "Clear display" RESET command is input 

 or power is turned off. 

 The clock display area

 Graphic can be displayed excluding the clock display area.

 The self adjustment for the position 

 that cannot be displayed. 

 * Excluding the clock display area can be input other display commands.

 */

 void GP1212A02A::SendCommandClockDisplay(TClockFormat aClockFormat, unsigned short aAddress, TClockSize aSize)

 	{

 	FutabaVfdReport report;

     report[0]=0x00; //Report ID

     report[1]=0x07; //Report size

     report[2]=0x1B; //Command ID

     report[3]=0x6B; //Command ID

     report[4]=0x55; //Command ID

     report[5]=aClockFormat; //

 	report[6]=(unsigned char)aAddress;	//aL

 	report[7]=aAddress>>8;				//aH

 	report[8]=aSize;

     Write(report);

 	}

 /**

  Clock display cancel 

 [Code] 1BH,6BH,3DH,58H

 [Function] Clock display is canceled.

 */

 void GP1212A02A::SendCommandClockCancel()

 	{

 	FutabaVfdReport report;

     report[0]=0x00; //Report ID

     report[1]=0x04; //Report size

     report[2]=0x1B; //Command ID

     report[3]=0x6B; //Command ID

     report[4]=0x3D; //Command ID

     report[5]=0x58; //

     Write(report);

 	}