/*

 * GraphLCD driver library

 *

 * picctl.c  -  PIC controlled LCD driver class

 *

 * This file is released under the GNU General Public License. Refer

 * to the COPYING file distributed with this package.

 *

 * Codebase by Andreas Regel <andreas.regel AT powarman.de>

 * (c) 2007 Carsten Presser

 */

#include <stdint.h>

#include <syslog.h>

#include <math.h>

#include "common.h"

#include "config.h"

#include "port.h"

#include "picctl.h"

namespace GLCD

{

/* command header:

**  8 bits  sync byte (0xAA for sent commands, 0x55 for received commands)

**  8 bits  command id

** 16 bits  command length (excluding header)

*/

const unsigned char CMD_HDR_SYNC    = 0;

const unsigned char CMD_HDR_COMMAND = 1;

const unsigned char CMD_HDR_LENGTH  = 2;

const unsigned char CMD_DATA_START  = 4;

const unsigned char CMD_SYNC_SEND   = 0xAA;

const unsigned char CMD_SYNC_RECV   = 0x55;

const unsigned char CMD_ESCAPE_BYTE = 0x42;

const unsigned char CMD_SYS_SYNC =		0x00;

const unsigned char CMD_SYS_ACK	=		0x01;

const unsigned char CMD_SYS_NACK =		0x02;

const unsigned char CMD_SYS_NIMP =		0xFF;

const unsigned char CMD_SYS_IR =		0x10;

const unsigned char CMD_DISP_CLEAR_SCREEN =	0x10;

const unsigned char CMD_DISP_SET_ROW_DATA =  	0x14;

const unsigned char CMD_DISP_SET_ADDRESS =	0x16;

const unsigned char CMD_READ_CLOCK =		0x40;

const unsigned char CMD_WRITE_CLOCK =		0x41;

const unsigned char CMD_SET_PWM1 =		0x45;

const unsigned char CMD_SET_PWM2 =		0x46;

const unsigned char CMD_SET_MODE_MANAGED =	0x70;

const unsigned char CMD_SET_MODE_UNMANAGED =	0x71;

const unsigned char CMD_BOOT =			0x80;

// globals...

uint8_t cDriverPICCtl::buf[255];

uint8_t cDriverPICCtl::buf_pos;

uint8_t cDriverPICCtl::buf_cmd_start;

bool cDriverPICCtl::buf_flag_escape;

// singleton

cDriverPICCtl* cDriverPICCtl::instance = NULL;

cDriverPICCtl* cDriverPICCtl::getInstance(cDriverConfig * config)

{

    if (!instance)

        instance = new cDriverPICCtl(config);

    return instance;

}

// end singleton-pattern

cDriverPICCtl::cDriverPICCtl(cDriverConfig * config)

:   config(config)

{

    oldConfig = new cDriverConfig(*config);

    port = new cSerialPort();

    width = config->width;

    height = config->height;

    refreshCounter = 0;

    ack_flag = false;

    buf_pos = 0;

    buf_cmd_start = 255;

    buf_flag_escape = false;

}

cDriverPICCtl::~cDriverPICCtl()

{

    instance = NULL;

    delete port;

    port = NULL;

    delete oldConfig;

    oldConfig = NULL;

}

void cDriverPICCtl::SignalHandler(int signal)

{

    //uint8_t i;

    // read all available data (always get single bytes...)

    while (instance->port->ReadData(&buf[buf_pos]) > 0)

    {

        // search for SYNC byte

        if ((buf[buf_pos] == CMD_SYNC_RECV) && (!buf_flag_escape))

	{

	    if (buf_cmd_start != 255)

	    {

		/*printf("Damaged Packet: ");

	        for (i=buf_cmd_start; i<buf_pos; i++)

		{

		  printf("0x%02x ",buf[i]);

		}

		printf("; buf_pos = %d, buf_cmd_start = %d\n",buf_pos,buf_cmd_start);*/

                syslog(LOG_INFO, "PICCtl received a malformed packet. Scrapped %d bytes\n",(buf_pos - buf_cmd_start));

		buf_pos = 0;

		buf[buf_pos] = CMD_SYNC_RECV;

	    }

 	    buf_cmd_start = buf_pos;

	}

        if ((buf[buf_pos] == CMD_ESCAPE_BYTE) && (!buf_flag_escape))

	{

	    // this byte was for masking only.. ignore it! 

	    buf_flag_escape = true;

	    continue;

	} 

        buf_flag_escape = false;

/*        printf("buf: ");

        for (i=1; i<=buf_pos; i++) { printf("0x%02x ",buf[i]);}

	printf("\n");*/

	buf_pos++;

        // we need to check for a valid packet...

	if ((buf_pos - buf_cmd_start) >= CMD_DATA_START)

	{

            // if we recieved a valid packet: start decoding

	    if (buf[buf_cmd_start + CMD_HDR_LENGTH+1] == (buf_pos - buf_cmd_start - CMD_DATA_START))

	    {

	        instance->DecodeCmd(&buf[buf_cmd_start],buf_pos);

		buf_pos = 0;

		buf_cmd_start = 255;

	    }

	}

    }

}

void cDriverPICCtl::DecodeCmd(uint8_t * cmd, uint8_t len)

{

/*    uint8_t i;

    printf("cmd(%2d): ",len);

    for (i=0; i<len; i++) { printf("0x%02x ",cmd[i]);}

    printf("\n"); */

    switch (cmd[CMD_HDR_COMMAND])

    {

        case CMD_SYS_ACK:	ack_flag = true;

	 			break;

	case CMD_SYS_IR:	syslog(LOG_INFO," %s: incoming Key-Event 0x%02x (Source 0x%02x)\n",config->name.c_str(), cmd[CMD_DATA_START+1], cmd[CMD_DATA_START]);

	                         //printf(" %s: incoming Key-Event 0x%02x (Source 0x%02x)\n",config->name.c_str(), cmd[CMD_DATA_START+1], cmd[CMD_DATA_START]);

	  			break;

	default:		syslog(LOG_INFO," %s: recieved Message 0x%x \n",config->name.c_str(), cmd[CMD_HDR_COMMAND]);

    }

}

int cDriverPICCtl::Init()

{

    int y;

    // fixed values so far...

    width = 240;

    height = 64;

    for (unsigned int i = 0; i < config->options.size(); i++)

    {

        if (config->options[i].name == "")

        {

        }

    }

    // setup lcd array (wanted state)

    newLCD = new unsigned char*[height];

    if (newLCD)

    {

        for (y = 0; y < height; y++)

        {

            newLCD[y] = new unsigned char[width/8];

            memset(newLCD[y], 0, (width/8));

        }

    }

    // setup lcd array (current state)

    oldLCD = new unsigned char*[height];

    if (oldLCD)

    {

        for (y = 0; y < height; y++)

        {

            oldLCD[y] = new unsigned char[width/8];

            memset(oldLCD[y], 0, (width/8));

        }

    }

    if (config->device == "")

    {

        return -1;

    }

    if (port->Open(config->device.c_str(), SignalHandler) != 0)

        return -1;

    *oldConfig = *config;

    // clear display

    Clear();

    CmdDispClearScreen();

    CmdDispSetManaged();

//    CmdDispSetBrightness(50);

    syslog(LOG_INFO, "%s: PICCtl initialized.\n", config->name.c_str());

    return 0;

}

int cDriverPICCtl::DeInit()

{

    int y;

    // free lcd array (wanted state)

    if (newLCD)

    {

        for (y = 0; y < height; y++)

        {

            delete[] newLCD[y];

        }

        delete[] newLCD;

    }

    // free lcd array (current state)

    if (oldLCD)

    {

        for (y = 0; y < height; y++)

        {

            delete[] oldLCD[y];

        }

        delete[] oldLCD;

    }

    CmdDispSetUnManaged();

    if (port->Close() != 0)

        return -1;

    return 0;

}

int cDriverPICCtl::CheckSetup()

{

    if (config->device != oldConfig->device ||

        config->width != oldConfig->width ||

        config->height != oldConfig->height)

    {

        DeInit();

        Init();

        return 0;

    }

    if (config->upsideDown != oldConfig->upsideDown ||

        config->invert != oldConfig->invert)

    {

        oldConfig->upsideDown = config->upsideDown;

        oldConfig->invert = config->invert;

        return 1;

    }

    return 0;

}

void cDriverPICCtl::Clear()

{

    for (int y = 0; y < height; y++)

        memset(newLCD[y], 0, (width/8));

}

void cDriverPICCtl::Set8Pixels(int x, int y, unsigned char data)

{

    if (x >= width || y >= height)

        return;

    if (!config->upsideDown)

    {

        newLCD[y][x/8] = data;

    }

    else

    {

        x = width - 1 - x;

        y = height - 1 - y;

        newLCD[y][x / 8] |= ReverseBits(data);

    }

}

void cDriverPICCtl::Refresh(bool refreshAll)

{

    int y;

    if (CheckSetup() == 1)

        refreshAll = true;

    if (config->refreshDisplay > 0)

    {

        refreshCounter = (refreshCounter + 1) % config->refreshDisplay;

        if (!refreshAll && !refreshCounter)

            refreshAll = true;

    }

    if (refreshAll)

    {

        // draw all

        // always draw a complete row! (30 bytes!)

        for (y = 0; y < height; y++)

        {

            CmdDispSetColData(y, 0, (width/8), newLCD[y]);

            memcpy(oldLCD[y], newLCD[y], (width/8));

        }

        // and reset RefreshCounter

        refreshCounter = 0;

    }

    else

    {

	// for every line

	for (y = 0; y< height; y++)

        {

            // did anysthing change? -> draw new line

	    if (memcmp(newLCD[y],oldLCD[y],(width/8)) != 0)

            {

                 CmdDispSetColData(y, 0, (width/8), newLCD[y]);

                 memcpy(oldLCD[y], newLCD[y], (width/8));

            }

        }

    }

}

void cDriverPICCtl::SetBrightness(unsigned int percent)

{

    CmdDispSetBrightness(percent);

}

void cDriverPICCtl::SetClock(unsigned int percent)

{

    CmdDispSetBrightness(percent);

}

int cDriverPICCtl::WaitForAck(void)

{

    int timeout;

    for (timeout=0; timeout<1000; timeout++)

    {

    	usleep(100);

	if (ack_flag) return 0;

    }

    syslog(LOG_INFO, "%s: PICCtl missed a ACK packet!\n", config->name.c_str());

    return 1;

}

void cDriverPICCtl::CmdDispClearScreen(void)

{

    uint8_t cmd[4];

    cmd[CMD_HDR_SYNC] = CMD_SYNC_SEND;

    cmd[CMD_HDR_COMMAND] = CMD_DISP_CLEAR_SCREEN;

    cmd[CMD_HDR_LENGTH] = 0;

    cmd[CMD_HDR_LENGTH+1] = 0;

    ack_flag = false;

    port->WriteData(cmd, 4);

    WaitForAck();

}

void cDriverPICCtl::CmdDispSetBrightness(uint8_t percent)

{

    uint8_t cmd[5];

    cmd[CMD_HDR_SYNC] = CMD_SYNC_SEND;

    cmd[CMD_HDR_COMMAND] = CMD_SET_PWM1;

    cmd[CMD_HDR_LENGTH] = 0;

    cmd[CMD_HDR_LENGTH+1] = 1;

    cmd[CMD_DATA_START] = (uint8_t) round(percent * 2.55);

    ack_flag = false;

    port->WriteData(cmd, 5);

    WaitForAck();

}

void cDriverPICCtl::CmdDispSetColData(uint8_t yoffset, uint8_t xoffset, uint8_t length, uint8_t * data)

{

    uint8_t cmd[64];

    uint16_t address;

    address = 0x1E * yoffset + xoffset;

    cmd[CMD_HDR_SYNC] = CMD_SYNC_SEND;

    cmd[CMD_HDR_COMMAND] = CMD_DISP_SET_ROW_DATA;

    cmd[CMD_HDR_LENGTH] = 0;

    cmd[CMD_HDR_LENGTH+1] = (length + 2);

    cmd[CMD_DATA_START] = (uint8_t)(address % 256);	// lower address

    cmd[CMD_DATA_START+1] = (uint8_t)(address / 256);	// upper address

    memcpy(&cmd[CMD_DATA_START+2], data, length);

    ack_flag = false;

    port->WriteData(cmd, length + 6);

    WaitForAck();

//    for (address = 0; address < length+6; address ++) printf("0x%02x ",cmd[address]);

//  printf("address=0x%x upper=0x%x lower=0x%x \n", address, (uint8_t)(address / 256), (uint8_t)(address % 256));

//    printf("\n");

}

void cDriverPICCtl::CmdDispSetManaged(void)

{

    uint8_t cmd[4];

    cmd[CMD_HDR_SYNC] = CMD_SYNC_SEND;

    cmd[CMD_HDR_COMMAND] = CMD_SET_MODE_MANAGED;

    cmd[CMD_HDR_LENGTH] = 0;

    cmd[CMD_HDR_LENGTH+1] = 0;

    ack_flag = false;

    port->WriteData(cmd,4);

    WaitForAck();

}

void cDriverPICCtl::CmdDispSetUnManaged(void)

{

    uint8_t cmd[4];

    cmd[CMD_HDR_SYNC] = CMD_SYNC_SEND;

    cmd[CMD_HDR_COMMAND] = CMD_SET_MODE_UNMANAGED;

    cmd[CMD_HDR_LENGTH] = 0;

    cmd[CMD_HDR_LENGTH+1] = 0;

    port->WriteData(cmd,4);

    WaitForAck();

}

} // end NameSpace