/*

  * 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 <signal.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;

 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;

     keys_pos  = 0;

     keys_pos_ = 0;

 }

 cDriverPICCtl::~cDriverPICCtl()

 {

     delete port;

     port = NULL;

     delete oldConfig;

     oldConfig = NULL;

 }

 bool cDriverPICCtl::HasKeys()

 {

     return true;

 }

 int cDriverPICCtl::GetKey()

 {

     InputHandler();

     if (keys_pos != keys_pos_)

     {

         keys_pos_ = keys_pos;

         return(keys[keys_pos-1]);

     }

     else

     {

         return(-1);

     }

 }

 void cDriverPICCtl::InputHandler()

 {

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

     while (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)

 	    {

 	    	#ifdef DEBUG

     		uint8_t i;

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

 		#endif

                 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;

 	}

 	// escaping is not used so far...

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

 	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))

 	    {

 	        DecodeCmd(&buf[buf_cmd_start],buf_pos);

 		buf_pos = 0;

 		buf_cmd_start = 255;

 	    }

 	}

     }

 }

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

 {

     #ifdef DEBUG

     uint8_t i;

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

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

     printf("\n");

     #endif

     switch (cmd[CMD_HDR_COMMAND])

     {

         case CMD_SYS_ACK:	ack_flag = true;

 	 			break;

 	case CMD_SYS_IR:	keys[keys_pos] =   256 * cmd[CMD_DATA_START] + cmd[CMD_DATA_START+1];

 				keys_pos++;

 				#ifdef DEBUG

 				printf(" %s: recieved IR Command 0x%x \n",config->name.c_str(), cmd[CMD_DATA_START+1]);

 				#endif

 	  			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()) != 0)

         return -1;

     *oldConfig = *config;

     // clear display

     Clear();

     CmdDispClearScreen();

     CmdDispSetManaged();

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

     return 0;

 }

 int cDriverPICCtl::DeInit()

 {

     int y;

     CmdDispSetUnManaged();

     CmdDispClearScreen();

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

     }

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

 }

 int cDriverPICCtl::WaitForAck(void)

 {

     int timeout;

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

     {

         InputHandler();

     	usleep(100);

 	if (ack_flag) return 0;

     }

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

 #ifdef DEBUG

     int i;

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

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

     {

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

     }

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

 #endif

     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