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

 *   Copyright (C) 2008 by Peter Marquardt   *

 *   p_marquardt@users.sourceforge.net   *

 *   code base Copyright (C) 2007 by Carsten Presser   *

 *                                                                         *

 *   This program is free software; you can redistribute it and/or modify  *

 *   it under the terms of the GNU General Public License as published by  *

 *   the Free Software Foundation; either version 2 of the License, or     *

 *   (at your option) any later version.                                   *

 *                                                                         *

 *   This program is distributed in the hope that it will be useful,       *

 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *

 *   GNU General Public License for more details.                          *

 *                                                                         *

 *   You should have received a copy of the GNU General Public License     *

 *   along with this program; if not, write to the                         *

 *   Free Software Foundation, Inc.,                                       *

 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *

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

/*! \file pcctldisplaytest.cpp

\brief A utility to test the picctl lcd display and interface

\author Peter Marquardt p_marquardt@users.sourceforge.net

\author Carsten Presser

\todo sanitize command line argument parsing

*/

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <iostream>

#include <cstdlib>

#include <termios.h>

#include <signal.h>

#include <fcntl.h>

#include "picctldisplaytest.h"

using namespace std;

config myconfig;

runtime_flags myflags;

int fd;

int main(int argc, char *argv[])

{

	bool kill_flag = false;

	struct termios options;

	struct sigaction saio;

	char key;

	cout << "** picctldisplaytest - simple test utility for picctl lcd displays **" << endl

		<< ">";

	// setting defaults

	myconfig.debug = false;

	myconfig.verbosity = 0;

	myconfig.modem_device = "/dev/ttyACM0";

	myflags.parse_return_clockram = false;

	// parsing arguments

	for (int i = 1; i < argc; i++) {

		if (*argv[i] == 'd') {

			i++;

			myconfig.modem_device = argv[i];

		}

		else if (*argv[i] == 'v') {

			i++;

			myconfig.verbosity = atoi(argv[i]);

		}

		else if (*argv[i] == 'D') {

			myconfig.debug =true;

		}

	}

	if (myconfig.verbosity > 0 || myconfig.debug) {

		cout << "picctldisplaytest called with\n"

			<< "device: " << myconfig.modem_device << endl

			<< "verbosity: " << myconfig.verbosity << endl

			<< "debug mode:" << boolalpha << myconfig.debug << endl;

	}

	/* open the device to be non-blocking (read will return immediatly) */

	fd = open(myconfig.modem_device, O_RDWR | O_NOCTTY | O_NONBLOCK);

	if (fd <0) {perror(myconfig.modem_device); exit(-1); }

	/* install the signal handler before making the device asynchronous */

	saio.sa_handler = signal_handler_IO;

	sigemptyset (&saio.sa_mask);

	saio.sa_flags = 0;

	saio.sa_restorer = NULL;

	sigaction(SIGIO,&saio,NULL);

   // allow the process to receive SIGIO

	fcntl(fd, F_SETOWN, getpid());

   // Make the file descriptor asynchronous

	fcntl(fd, F_SETFL, FASYNC);

	tcgetattr(fd, &options);

	cfsetispeed(&options, BAUDRATE);

	cfsetospeed(&options, BAUDRATE);

	options.c_cflag &= ~PARENB;

	options.c_cflag &= ~CSTOPB;

	options.c_cflag &= ~CSIZE;

	options.c_cflag |= CS8;

	options.c_cflag &= ~CRTSCTS;

	options.c_cflag |= (CLOCAL | CREAD);

	options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);

	options.c_iflag &= ~(IXON | IXOFF | IXANY);

	options.c_oflag &= ~OPOST;

	tcsetattr(fd, TCSANOW, &options);

	if (myconfig.debug || myconfig.verbosity > 0) print_help();

	while ( cin.get(key)) {

		switch(key) {

			case 'q':

				cout << "Exiting." << endl;

				return EXIT_SUCCESS;

				break;

			case 'u':

				cout << "Switching to unmanaged mode..." << endl;

				send_data(CMD_SET_MODE_UNMANAGED,(sizeof(CMD_SET_MODE_UNMANAGED)/sizeof(char)));

				break;

			case 'm':

				cout << "Switching to managed mode..." << endl;

				send_data(CMD_SET_MODE_MANAGED,(sizeof(CMD_SET_MODE_MANAGED)/sizeof(char)));

				break;		 

			case 'c':

				cout << "Sending Clear Display..." << endl;

				send_data(CMD_DISP_CLEAR_SCREEN,(sizeof(CMD_DISP_CLEAR_SCREEN)/sizeof(char)));

				break;

			case 'h':

				print_help();

				break;

			case 'j':

				print_cli_options();

				break;

			case '1':

				cout << "Display CG ROM charset..." << endl;

				send_data(TEST_STRING_1,(sizeof(TEST_STRING_1)/sizeof(char)));

				send_data(TEST_STRING_2,(sizeof(TEST_STRING_2)/sizeof(char)));

				send_data(TEST_STRING_3,(sizeof(TEST_STRING_3)/sizeof(char)));

				break;

			case '2':

				cout << "Filling the Display with CG ROM charset..." << endl;

				send_data(TEST_STRING_1,(sizeof(TEST_STRING_1)/sizeof(char)));

				send_data(TEST_STRING_2,(sizeof(TEST_STRING_2)/sizeof(char)));

				send_data(TEST_STRING_3,(sizeof(TEST_STRING_3)/sizeof(char)));

				send_data(TEST_STRING_4,(sizeof(TEST_STRING_4)/sizeof(char)));

				send_data(TEST_STRING_5,(sizeof(TEST_STRING_5)/sizeof(char)));

				break;

			case '3': {

				cout << "Sending Test String... one line per packet, 8 lines of 30 chars" << endl;

				for (int j = 0; j < 8; j++) {

					const unsigned char cmd[] = {0xAA,0x14,0x00,32,((j*30)),0x08,

						16,17,18,19,20,21,22,23,24,25,

						16,17,18,19,20,21,22,23,24,25,

						16,17,18,19,20,21,22,23,24,25};

					send_data(cmd,(sizeof(cmd)/sizeof(char)));

				}

		}

				break;

			case '4':

				cout << "Sending Test String.. one char per packet,8 lines of 30 chars" << endl;

				for (int j = 0; j < 8; j++) {

					for (int k = 0; k < 30; k++) {

						const unsigned char cmd[] = {0xAA,0x14,0x00,3,k+(j*30),0x08,

							(16+k)};

							send_data(cmd,(sizeof(cmd)/sizeof(char)));

					}

				}

				break;

			case 'a':

				cout << "Set PWM1 0%..." << endl;

				CMD_SET_PWM1[4] = 0x00;

				send_data(CMD_SET_PWM1,(sizeof(CMD_SET_PWM1)/sizeof(char)));

				break;

			case 's':

				cout << "SetPWM1 25%..." << endl;

				CMD_SET_PWM1[4] = 0x40;

				send_data(CMD_SET_PWM1,(sizeof(CMD_SET_PWM1)/sizeof(char)));

				break;

			case 'd':

				cout << "Set PWM1 50%..." << endl;

				CMD_SET_PWM1[4] = 0x80;

				send_data(CMD_SET_PWM1,(sizeof(CMD_SET_PWM1)/sizeof(char)));

				break;

			case 'f':

				cout << "Set PWM1 75%..." << endl;

				CMD_SET_PWM1[4] = 0xC0;

				send_data(CMD_SET_PWM1,(sizeof(CMD_SET_PWM1)/sizeof(char)));

				break;

			case 'g':

				cout << "Set PWM1 100%..." << endl;

				CMD_SET_PWM1[4] = 0xFF;

				send_data(CMD_SET_PWM1,(sizeof(CMD_SET_PWM1)/sizeof(char)));

				break;

			case 'A':

				cout << "Set PWM2 0%..." << endl;

				CMD_SET_PWM2[4] = 0x00;

				send_data(CMD_SET_PWM2,(sizeof(CMD_SET_PWM2)/sizeof(char)));

				break;

			case 'S':

				cout << "SetPWM2 25%..." << endl;

				CMD_SET_PWM2[4] = 0x40;

				send_data(CMD_SET_PWM2,(sizeof(CMD_SET_PWM2)/sizeof(char)));

				break;

			case 'D':

				cout << "Set PWM2 50%..." << endl;

				CMD_SET_PWM2[4] = 0x80;

				send_data(CMD_SET_PWM2,(sizeof(CMD_SET_PWM2)/sizeof(char)));

				break;

			case 'F':

				cout << "Set PWM2 75%..." << endl;

				CMD_SET_PWM2[4] = 0xC0;

				send_data(CMD_SET_PWM2,(sizeof(CMD_SET_PWM2)/sizeof(char)));

				break;

			case 'G':

				cout << "Set PWM2 100%..." << endl;

				CMD_SET_PWM2[4] = 0xFF;

				send_data(CMD_SET_PWM2,(sizeof(CMD_SET_PWM2)/sizeof(char)));

				break;

			case 'T': {

				cout << "Setting pcf8583 clock memory..." << endl;	

				time_t mytime = time(NULL);

				tm * myltime = localtime( &mytime);

				if (myconfig.debug || myconfig.verbosity > 0) cout << "Local Time is: " << myltime->tm_hour << ":" << myltime->tm_min << ":" << myltime->tm_sec << " " << myltime->tm_mday << "." << myltime->tm_mon+1 << endl;

				const unsigned char tcmd[] = {0xAA,0x41,0x00,0x10,

					0x04,0x00,dec2bcd(myltime->tm_sec),dec2bcd(myltime->tm_min),dec2bcd(myltime->tm_hour),dec2bcd(myltime->tm_mday),

					(dec2bcd(myltime->tm_mon+1)),0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};

					send_data(tcmd,(sizeof(tcmd)/sizeof(char)));

				}

				break;

			case 't' : {

				cout << "Dumping pcf8583 clock memory..." << endl;

				int oldverbosity = myconfig.verbosity;

				myflags.parse_return_clockram = true;

				if (myconfig.verbosity < 2) {

					myconfig.verbosity = 2;

				}

				send_data(CMD_GET_CLOCK_MEMORY,(sizeof(CMD_GET_CLOCK_MEMORY)/sizeof(char)));

				myconfig.verbosity  = oldverbosity;

				myflags.parse_return_clockram = false;

				}

				break;

			case '5': {

				cout << "Showing test picture 1..."<< endl;

				write_gfx_ram( TEST_PICTURE_1,(sizeof(TEST_PICTURE_1)/sizeof(char)));

			}

				break;

			case '6': {

				cout << "Showing test picture 2 - horizontal lines..."<< endl;

				unsigned char mycmd[36] = {0xAA,0x14,0x00,0x20,0x00,0x00,

					0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,

					0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,

					0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff

				} ;

				for (int i = 0; i <64;i+=2) {

					mycmd[5] = (i*30) / 256;

					mycmd[4] = (i*30) - (256 * mycmd[5]);

					send_data(mycmd, (sizeof(mycmd)/sizeof(char)));

				}

			}

				break;

			case '7': {

				cout << "Showing test picture 3 - vertical lines..."<< endl;

				unsigned char mycmd[36] = {0xAA,0x14,0x00,0x20,0x00,0x00,

					0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,

					0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,

					0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,0xaa,0xaa

				} ;

				for (int i = 0; i <64;i++) {

					mycmd[5] = (i*30) / 256;

					mycmd[4] = (i*30) - (256 * mycmd[5]);

					send_data(mycmd, (sizeof(mycmd)/sizeof(char)));

				}

			}

				break;

			case '8': {

				cout << "Showing test picture 4...Boxes"<< endl;

				write_gfx_ram(TEST_PICTURE_2,(sizeof(TEST_PICTURE_2)/sizeof(char)));

			}

				break;

			case '9': {

				cout << "Showing test picture 5 - outline + center cross..."<< endl;

				unsigned char mycmd_1[36] = {0xAA,0x14,0x00,0x20,0x00,0x00,

					0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,

					0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,

					0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff

				} ;

				unsigned char mycmd_2[36] = {0xAA,0x14,0x00,0x20,0x00,0x00,

					0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

					0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,

					0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01

				} ;

				int i = 1;

				for (int j = 0;j<2;j++) {

					send_data(mycmd_1, (sizeof(mycmd_1)/sizeof(char)));

					for ( i = 1; i <31;i++) {

						mycmd_2[5] = ((i*30) + (j*960)) / 256;

						mycmd_2[4] = ((i*30) + (j*960))  - (256 * mycmd_2[5]);

						send_data(mycmd_2, (sizeof(mycmd_2)/sizeof(char)));

					}

					mycmd_1[5] = ((i*30) + (j*960)) / 256;

					mycmd_1[4] = ((i*30) + (j*960))  - (256 * mycmd_1[5]);

				}

				send_data(mycmd_1, (sizeof(mycmd_1)/sizeof(char)));

			}

				break;

			default:

				break;

		}

		sleep(1);

		if (key != 0x13 && key != '\n') cout << ">";

	}

	close(fd);

	return EXIT_SUCCESS;

}

unsigned char bitendian (unsigned char in)

{

	unsigned char ret = 0x00;

	if (in & 0x01) ret+=0x80;

	if (in & 0x02) ret+=0x40;

	if (in & 0x04) ret+=0x20;

	if (in & 0x08) ret+=0x10;

	if (in & 0x10) ret+=0x08;

	if (in & 0x20) ret+=0x04;

	if (in & 0x40) ret+=0x02;

	if (in & 0x80) ret+=0x01;

	return (ret);

}

bool write_gfx_ram(const unsigned char * buffer, int numbytes) {

	if (numbytes > 1920) {

		cout << "Too much data for gfx RAM, ignoring..." << endl;

		return false;

	}

	int i = 0, offset = 6, memaddr = 0;

	bool all_sent = false;

	unsigned char mycmd[63] = {0xAA,0x14,0x00,0x02,0x00,0x00};

	while (i <numbytes) {

		all_sent = false;

		mycmd[offset] = bitendian(buffer[i]);

		i++;	

		offset++;

		if (offset == 63) {

			mycmd[3] = 59;

			send_data(mycmd,63);

			memaddr += 57;

			mycmd[5] = (memaddr / 256);

			mycmd[4] = (memaddr - (mycmd[5]*256));

			offset = 6;

			all_sent = true;

		}

	}

	if (!all_sent) {

		mycmd[3] = (offset-4);

		send_data(mycmd,offset);

	}

	return true;

}

/*! \brief sends size bytes of buffer data to the display

\warning send_data doesn't check if buffer really is numbytes big. Expect all kind of weirdness if abused.

\param buffer pointer to a char buffer conatining the data

\param numbytes Number of bytes in buffer

*/

bool send_data(const unsigned char * buffer, int numbytes) {

	if (numbytes > 64 ) {

		cout << "Buffer size exceeds 64 Bytes, send_data aborted." << endl;

		return false;

	}

	write(fd,buffer,numbytes);

	if (myconfig.debug || myconfig.verbosity > 0) cout << numbytes <<" bytes sent.";

	if (myconfig.debug || myconfig.verbosity > 1) {

		cout <<" Data: " << endl ;

		for ( int i = 0; i <numbytes; i++) {

			cout << " 0x" << ((int) buffer[i] < 10 ? "0" : "") << hex << (int) buffer[i] << dec;

			if (i > 0 && ((i-3)%8 ==0 || i == 3)) cout << endl;

		}

	}

	if (myconfig.debug || myconfig.verbosity > 0) cout <<   endl;

	usleep(100000);

	return true;

}

/*! \brief prints some help

*/

void print_help() {

	cout << endl;

	cout << "Usage:" << endl;

	cout << "u\tset unmanaged mode" << endl;

	cout << "m\tset managed mode" << endl;

	cout << endl;

	cout << "T\tset pcf8583 clock to system time" << endl;

	cout << "t\tdump pcf8583 clock memory" << endl;

	cout << endl;

	cout << "Set PWM:" << endl;

	cout << "PWM1\ta 0%\ts 25%\td 50%\tf 75%\tg 100%" << endl;

	cout << "PWM2\tA 0%\tS 25%\tD 50%\tF 75%\tG 100%" << endl;

	cout << endl;

	cout << "1\tshow ROM charset" << endl;

	cout << "2\tfill Text area with ROM charset" << endl;

	cout << "3\tfill Text area (8 lines / 30 chars, one line per packet)" << endl;

	cout << "4\tfill Text area (8 lines / 30 chars, one char per packet)" << endl;

	cout << endl;

	cout << "5\tshow test picture 1 (240x64px)" << endl;

	cout << "6\tshow test picture 2 - horizontal lines (240x64px)" << endl;

	cout << "7\tshow test picture 3 - vertical lines (240x64px)" << endl;

	cout << "8\tshow test picture 4 - Boxes (240x64px)" << endl;

	cout << "9\tshow test picture 5 - outline + center cross (240x64px)" << endl;

	cout << endl;

	cout << "c\tclear display" << endl;

	cout << endl;

	cout << "h\tprint this help" << endl;

	cout << "j\tprint command line options" << endl;

	cout << "q\tquit" << endl;

	cout << ">";

}

/*! \brief prints command line options

*/

void print_cli_options() {

	cout << endl 

		<< " Command line options:\n"

		<< endl;

	cout << "d DEVICE\n"

		<< "\tSets the display device to DEVICE, default value is /dev/ttyACM0\n"

		<< "\tExample:\n"

		<< "\tpicctldisplaytest d /dev/ttyACM0\n"

		<< endl;

	cout << "v VERBOSITY\n"

			<< "\tSets verbosity to level VERBOSITY ( Range: 0-2, default 0 )\n"

			<< "\tExample:\n"

			<< "\tpicctldisplaytest v 1\n"

			<< endl;

	cout << "D\n"

			<< "\tRun in debugging mode (aka. very verbose)\n"

			<< "\tExample:\n"

			<< "\tpicctldisplaytest D\n"

			<< endl;

	cout << "Combining command line options\n"

			<< "\tAll command line options can be combined (though some combinations might not prove useful).\n"

			<< "\tExample:\n"

			<< "\tpicctldisplaytest D d /dev/ttyACM0\n"

			<< endl;

}

/*! \brief encodes an integer to a BCD value

 */

int dec2bcd(int decimal) {

	return  (decimal > 99 ?  false : ((decimal/10)<<4)+(decimal%10));

}

/*! \brief decodes a BCD value and returns it as integer

 */

int bcd2dec(int bcd) {

	return (((bcd>>4)*10)+bcd%16);

}

/*! \brief handles SIGIO

 */

void signal_handler_IO (int status) {

	unsigned char buf[255];

	int res = read(fd,buf,255);

	if (myconfig.debug || myconfig.verbosity > 0) {

		//cout << "Received Data\n";

		if (buf[0] == 0x55) {

			switch (buf[1]) {

				case 0x01:

					cout << "Received an ACK packet, payload: " << (int) buf[3] << " bytes." << endl;

					break;

				case 0x02:

					cout << "Received a NACK packet." << endl;

					break;

				case 0xFF:

					cout << "Received COMMAND NOT IMPLEMENTED." << endl;

					break;

				case 0x10:

					cout << "Received IR/Key data." << endl;

					break;

				default:

					cout <<"Unknown Response code 0x" << hex << buf[1] << endl;

					break;	

			}

		}

	}

	if (myflags.parse_return_clockram || myconfig.debug || myconfig.verbosity > 1) {

		for (int i=0; i<res; i++) {

			cout << "0x" << ((int) buf[i] < 10 ? "0" : "") << hex << (int) buf[i] << " ";

			if (myflags.parse_return_clockram && i > 3) { 

				switch (i) {

					case 4:

						cout << "(ctrl: " << dec << bcd2dec((int) buf[i]) << ") ";

						break;

					case 5:

						cout << "(1/100s: " << dec << bcd2dec((int) buf[i]) << ") ";

						break;

					case 6:

						cout << "(sec: " << dec << bcd2dec((int) buf[i]) << ") ";

						break;

					case 7:

						cout << "(min: " << dec << bcd2dec((int) buf[i]) << ") ";

						break;

					case 8:

						cout << "(hours: " << dec << bcd2dec((int) buf[i]) << ") ";

						break;

					case 9:

						cout << "(year/date: " << dec << bcd2dec((int) buf[i]) << ") ";

						break;

					case 10:

						cout << "(wday/month: " << dec << bcd2dec((int) buf[i]) << ") ";

						break;

					case 11:

						cout << "(timer day: " << dec << bcd2dec((int) buf[i]) << ") ";

						break;

					case 12:

						cout << "(alarm ctrl: " << dec << bcd2dec((int) buf[i]) << ") ";

						break;

					default:

						cout << "(bcd2int: " << dec << bcd2dec((int) buf[i]) << ") ";

						break;

				}

			}

			if (i == 3 || (i+3)%8==0) cout << endl;

		}

		cout << endl;

	}

	if (myconfig.debug || myconfig.verbosity > 0) cout <<  dec << res << " bytes received.\n";

}