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

  *   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 <fcntl.h>

 #include "picctldisplaytest.h"

 using namespace std;

 config myconfig;

 runtime_flags myflags;

 int fd;

 bool ack_flag;

 uint8_t buf[255];

 uint8_t buf_pos;

 uint8_t buf_cmd_start;

 bool buf_flag_escape;

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

 {

 	bool kill_flag = false;

 	struct termios options;

 	char key;

 	buf_pos = 0;

 	ack_flag = false;

 	buf_cmd_start = 255;

 	buf_flag_escape = false;

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

 	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 'b':

 				cout << "Sending Bootload Start..." << endl;

 				send_data(CMD_BOOT,(sizeof(CMD_BOOT)/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;

 }

 void read_data()

 {

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

     while (read(fd,&buf[buf_pos],1) > 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

 		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_pos = 0;

 		buf_cmd_start = 255;

 	    }

 	}

     }

 }

 /*! \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 << "b\tenter bootload mode" << 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 DecodeCMD() {

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

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

 		if (buf[buf_cmd_start] == CMD_SYNC_RECV) {

 			switch (buf[buf_cmd_start + 1]) {

 				case 0x01:

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

 					ack_flag = true;

 					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=buf_cmd_start; i<buf_pos; 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 << (buf_pos - buf_cmd_start) << " bytes received.\n";

 }

 /*! \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) {

 	int tout = 0;

 	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;

 	ack_flag = false;

 	while (!ack_flag && tout < 1000) {

 		tout++;

 		read_data();

 		usleep(100);

 	}

 	return ack_flag;

 }