//

//

//

#include "FutabaMDM166AA.h"

#include <stdio.h>

#include <time.h>

static void sleep(unsigned int mseconds)

	{

    clock_t goal = mseconds + clock();

    while (goal > clock());

	}

//

// class MDM166AA

//

MDM166AA::MDM166AA():

    iOffScreenMode(true),

    iFrameNext(NULL),

    iFrameCurrent(NULL),

    iFramePrevious(NULL),

    iFrameAlpha(NULL),

    iFrameBeta(NULL),

    iFrameGamma(NULL)

	{

	iDeviceId[0]=0;

	iFirmwareRevision[0]=0;

	//ResetBuffers();

	}

/**

*/

MDM166AA::~MDM166AA()

	{

    delete iFrameAlpha;

    iFrameAlpha=NULL;

    //

    delete iFrameBeta;

    iFrameBeta=NULL;

    //

    delete iFrameGamma;

    iFrameGamma=NULL;

    //

    iFrameNext=NULL;

    iFrameCurrent=NULL;

    iFramePrevious=NULL;

	}

/**

*/

int MDM166AA::Open()

	{

	int success = HidDevice::Open(KTargaVendorId,KFutabaProductIdMDM166AA,NULL);

	if (success)

		{

        //Allocate both frames

        delete iFrameAlpha;

        iFrameAlpha=NULL;

        iFrameAlpha=new BitArrayLow(KMDM166AAFrameBufferPixelCount);

        //

        delete iFrameBeta;

        iFrameBeta=NULL;

        iFrameBeta=new BitArrayLow(KMDM166AAFrameBufferPixelCount);

        //

        delete iFrameGamma;

        iFrameGamma=NULL;

        iFrameGamma=new BitArrayLow(KMDM166AAFrameBufferPixelCount);

        //

        iFrameNext=iFrameAlpha;

        iFrameCurrent=iFrameBeta;

        iFramePrevious=iFrameGamma;

        //

		SetNonBlocking(1);

		//

		SendCommandReset();

		//

		ShowClock();

		}

	return success;

	}

/**

*/

void MDM166AA::SetPixel(unsigned char aX, unsigned char aY, unsigned int aPixel)

	{

	//

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

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

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

	//Pixel is on if any of the non-alpha component is not null

	bool on = (aPixel&0x00FFFFFF)!=0x00000000;

    if (iOffScreenMode)

        {

        if (on)

            {

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

            }

        else

            {

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

            }

        }

    else

        {

        //Just specify a one pixel block

        //TODO

        }

	}

/**

*/

/*

void MDM166AA::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 MDM166AA::Clear()

    {

	//That one also clear the symbols

    SetAllPixels(0x00);

    }

/**

Turn on all pixels.

Must be followed by a SwapBuffers call.

*/

void MDM166AA::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 MDM166AA::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

        }

	//

	}

/**

Whole display RAM areas including invisible area are filled with 00H data.

(Include the symbol)

SL: Though there is no invisible area with that device.

*/

void MDM166AA::SendCommandClear()

	{

    //Send Clear Display Command

	FutabaVfdReport report;

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

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

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

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

	Write(report);

	}

/**

Put our off screen buffer on screen.

On screen buffer goes off screen.

*/

void MDM166AA::SwapBuffers()

	{

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

	if (OffScreenMode())

		{

		//Send next frame to our display RAM

		//We could attempt to implement a frame differencing algorithm much like we did for GP1212A01.

		//However we see little point doing that since we already run at above 20 FPS.

		SendCommandWriteGraphicData(FrameBufferSizeInBytes(),iFrameNext->Ptr());

        //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;

/**

*/

void MDM166AA::Request(TMiniDisplayRequest aRequest)

	{

	switch (aRequest)

		{

	case EMiniDisplayRequestDeviceId:

		RequestDeviceId();

		break;

	case EMiniDisplayRequestFirmwareRevision:

		RequestFirmwareRevision();

		break;

	case EMiniDisplayRequestPowerSupplyStatus:

		RequestPowerSupplyStatus();

		break;

	default:

		//Not supported

		break;

		};

	}

/**

*/

void MDM166AA::ResetBuffers()

	{

    //iNextFrame->ClearAll();

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

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

	}

/**

*/

void MDM166AA::RequestDeviceId()

    {

	//Not supported

    }

/**

*/

void MDM166AA::RequestFirmwareRevision()

    {

	//Not supported

    }

/**

*/

void MDM166AA::RequestPowerSupplyStatus()

    {

	//Not supported

    }

/**

This is for development purposes only.

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

*/

void MDM166AA::ToggleOffScreenMode()

	{

    SetOffScreenMode(!iOffScreenMode);

	}

/**

 * @brief MDM166AA::SetOffScreenMode

 * @param aOn

 * @return

 */

void MDM166AA::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 MDM166AA::AttemptRequestCompletion()

    {

	return EMiniDisplayRequestNone;

	}

/**

Set our screen brightness.

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

*/

void MDM166AA::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]=0x03; //Report size

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

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

    report[4]=aBrightness; //Brightness level

    Write(report);

    }

/**

*/

void MDM166AA::ShowClock()

	{

	SetClockData();

	SendCommandClockDisplay(EClockLarge,EClock24);

	}

/**

*/

void MDM166AA::HideClock()

	{

	//TODO: or reset

	Clear();

	}

/**

Clock setting 

[Code]1BH,00H,Pm,Ph 

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

Ph = hour 

Pm = minute 

*/

void MDM166AA::SendCommandSetClockData(unsigned char aHour, unsigned char aMinute)

	{

	FutabaVfdReport report;

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

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

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

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

	//Minutes and Hours needs to be in hexadecimal view

	//To get 21:59 you need to pass in 0x21:0x59

	//Weirdest format ever, I know 

	report[4]=(aMinute/10*16)+aMinute%10;

	report[5]=(aHour/10*16)+aHour%10;

    Write(report);

	}

/**

Set display clock data according to local system time.

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

*/

void MDM166AA::SetClockData()

	{

	time_t rawtime;

	struct tm * timeinfo;

	time ( &rawtime );

	timeinfo = localtime ( &rawtime );

	//Adjust minute as best as we can so that we have a 30 seconds offset at most rather a than a full minute.

	if (timeinfo->tm_sec>30)

		{

		//Use the next minute then

		timeinfo->tm_min++;

		if (timeinfo->tm_min==60)

			{

			//Use the next hour then

			timeinfo->tm_hour++;

			timeinfo->tm_min=0;

			if (timeinfo->tm_hour==24)

				{

				//Move to the next day then

				timeinfo->tm_hour=0;

				}

			}

		}

	//Send hours and minutes to our display

	SendCommandSetClockData(timeinfo->tm_hour,timeinfo->tm_min);

	}

/**

Clock display

[Code] 1BH,Ps,aL,aH,Pf

[Function] Clock is displayed small or big.

*/

void MDM166AA::SendCommandClockDisplay(TClockSize aClockSize, TClockFormat aClockFormat)

	{

	FutabaVfdReport report;

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

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

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

    report[3]=aClockSize; //

    report[4]=aClockFormat; //

    Write(report);

	}

/**

Display RAM filled with 00H.

Address Counter is set by 00H.

Dimming is set to 50%.

*/

void MDM166AA::SendCommandReset()

	{

	FutabaVfdReport report;

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

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

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

	Write(report);

	//Wait until reset is done. Is that needed?

	//sleep(2000);

	}

/**

Set Address Counter (AC) values: 1BH + 60H + xxH

xxH: 00 ~ BFH

AC value represents the start address for graphic data.

There are 192 bytes as display RAM. It can be set on anywhere even if AC value is not visible area.

The default value is 00H.

Default: 00H

When clock is displayed, AC value is set 00H.

*/

void MDM166AA::SendCommandSetAddressCounter(unsigned char aAddressCounter)

	{

	FutabaVfdReport report;

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

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

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

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

	report[4]=aAddressCounter;

	Write(report);

	}

/**

Set the defined pixel block to the given value.

@param The size of our pixel data. Number of pixels divided by 8.

@param Pointer to our pixel data.

*/

void MDM166AA::SendCommandWriteGraphicData(int aSize, unsigned char* aPixels)

    {

	//TODO: Remove that at some point

	SendCommandSetAddressCounter(0);

	const int KMaxPixelBytes=48;

	const int KHeaderSize=3;

	int remainingSize=aSize;

	int sizeWritten=0;

	while (remainingSize>0)

		{

		//Only send a maximum of 48 bytes worth of pixels per report

		const int KPixelDataSize=(remainingSize<=KMaxPixelBytes?remainingSize:KMaxPixelBytes);

		FutabaVfdReport report;

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

		report[1]=KPixelDataSize+KHeaderSize; //Report length. +3 is for our header first 3 bytes.

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

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

		report[4]=KPixelDataSize; //Size of pixel data in bytes		

		memcpy(report.Buffer()+5, aPixels+sizeWritten, KPixelDataSize);

		Write(report);

		//Advance

		sizeWritten+=KPixelDataSize;

		remainingSize-=KPixelDataSize;

		}

    }