Browse the code

Differences between 37 and 38 on /.

Number of edited files:

2 (0 added, 0 deleted and 2 modified)

Author:

ematech

Log message:

Indentation cleanup, no code change

Date:

2010-07-08 20:10:25

Added file(s)	Deleted file(s)	Modified file(s)
		/trunk/src/moglk.cc ↓ /trunk/src/moglk.h ↓



 You should have received a copy of the GNU General Public License
 along with libmoglk. If not, see <http://www.gnu.org/licenses/>.
 */
*/

// C headers
#include <termios.h>	// POSIX Terminal IOs
#include <fcntl.h>	// POSIX File Control Operations
#include <fcntl.h>		// POSIX File Control Operations

// C++ headers
#include <cstring>      // ISO C99 String handling
#include <cstdio>	// C++ standard IO
#include <iostream>     // C++ input output stream
#include <sstream>      // C++ string stream
#include <cstring>		// ISO C99 String handling
#include <cstdio>		// C++ standard IO
#include <iostream>		// C++ input output stream
#include <sstream>		// C++ string stream

// libmoglk header
#include "moglk.h"

//#define NDEBUG

//Namespaces
// Namespaces
using namespace std;

int serial_port;

Moglk::~Moglk()
{
        close(serial_port);
	close(serial_port);
}

//TODO: Autodetect device
                 unsigned long int baud_rate)
{

    if (!baud_rate)
    {
        baud_rate = autodetectBaudRate(device_ptr);
    }
	if (!baud_rate)
	{
		baud_rate = autodetectBaudRate(device_ptr);
	}

    if(!openPort(device_ptr))
    {
        configurePort();
        setPortBaudRate(baud_rate);
	if(!openPort(device_ptr))
	{
		configurePort();
		setPortBaudRate(baud_rate);
/*
        setFlowControl(1,
                       8,
                       119);
		setFlowControl(1,
		               8,
		               119);
*/

#ifndef NDEBUG
        cout << "DEBUG init(): libmoglk initialized!" << endl;
	cout &lt;< "DEBUG init(): libmoglk initialized!" << endl;
#endif /* #ifndef NDEBUG */

        return false;
    }
		return false;
	}

    return true;
	return true;

} /* init() */

unsigned long int Moglk::autodetectBaudRate(char * device_ptr)
{

        unsigned long int detected_baud_rate = 0;
        unsigned char module_type;
        long int baud_rate[] = {B9600,
                                B19200,
                                B38400,
                                B115200,
                                EOF};
	unsigned long int detected_baud_rate = 0;
	unsigned char module_type;
	long int baud_rate[] = {B9600,
	                        B19200,
	                        B38400,
	                        B115200,
	                        EOF};

        for (unsigned char n = 0;baud_rate[n] != EOF;n++)
        {
                init(device_ptr,
                     baud_rate[n]);
                module_type = getModuleType();
                if (module_type)
                {
                        detected_baud_rate = baud_rate[n];
                }
        }
	for (unsigned char n = 0;baud_rate[n] != EOF;n++)
	{
		init(device_ptr,
		     baud_rate[n]);
		module_type = getModuleType();
		if (module_type)
		{
			detected_baud_rate = baud_rate[n];
		}
	}

#ifndef NDEBUG
	cout << "DEBUG autodetectBaudRate() : detectedBaudrate = " << dec << detected_baud_rate << endl;
	cout << "DEBUG autodetectBaudRate() : detectedBaudrate = " << dec <<
		detected_baud_rate << endl;
#endif /* #ifndef NDEBUG */

        return detected_baud_rate;
	return detected_baud_rate;

} /* autodetectBaudRate */

bool Moglk::openPort(char * device_ptr)
{
        // Open serial port:
	// Open serial port:
	// read/write, no control terminal
	serial_port = open(device_ptr,
                           O_RDWR | O_NOCTTY);
	                   O_RDWR | O_NOCTTY);

        // Handle errors
	// Handle errors
	if (serial_port < 0)
	{
		cerr << "ERROR openPort(): can't open serial port on " << device_ptr << endl;
		cerr << "ERROR openPort(): can't open serial port on " << device_ptr <<
			endl;
		return true;
	}
        else
        {
	else
	{
#ifndef NDEBUG
        cout << "DEBUG openPort(): sucessfully opened serial port on " << device_ptr << endl;
		cout << "DEBUG openPort(): sucessfully opened serial port on " <<
			device_ptr << endl;
#endif /* #ifndef NDEBUG */
                return false;
        }
		return false;
	}

        return true;
	return true;

} /* openPort() */

void Moglk::configurePort(void)
{
        // Port options
	// Port options
	struct termios options;

	// Get current port options
	tcgetattr(serial_port,
                  &options);
	          &options);

	// Control options:
	// 8 data bits, no parity, 1 stopbit, local line, enable receiver
	// Raw output
	options.c_oflag &= ~OPOST;

        // Character control options:
        // Timeout after X*0.1 sec
        options.c_cc[VTIME] = 1;
        // No minimum number of bytes received
        options.c_cc[VMIN] = 0;
	// Character control options:
	// Timeout after X*0.1 sec
	options.c_cc[VTIME] = 1;
	// No minimum number of bytes received
	options.c_cc[VMIN] = 0;

	// Flush line
	tcflush(serial_port,
                TCIFLUSH);
	        TCIFLUSH);

	// Set port options
	tcsetattr(serial_port,
                  TCSANOW,
                  &options);
	          TCSANOW,
	          &options);

#ifndef NDEBUG
        cout << "DEBUG configurePort()" << endl;
	cout &lt;< "DEBUG configurePort()" << endl;
#endif /* #ifndef NDEBUG */

} /* configurePort() */

void Moglk::setPortBaudRate(unsigned long int baud_rate)
{
        // Port rate flag
	// Port rate flag
	tcflag_t port_rate;

	// baudrate to rate flag
		}
	} /* switch(baud_rate) */

        // Port options
	// Port options
	struct termios options;

	// Get current port options
	tcgetattr(serial_port,
                  &options);
	          &options);

	// Control options:
	// global baud rate
	options.c_cflag |= (port_rate);

        // Set input baud rate
	// Set input baud rate
	cfsetispeed(&options,
                    port_rate);
	            port_rate);

	// Set output baud rate
	cfsetospeed(&options,
                    port_rate);
	            port_rate);

	// Flush line
	tcflush(serial_port,
                TCIFLUSH);
	        TCIFLUSH);

	// Set port options
	tcsetattr(serial_port,
                  TCSANOW,
                  &options);
	          TCSANOW,
	          &options);

#ifndef NDEBUG
        cout << "DEBUG setPortBaudRate(): " << dec << baud_rate << " bauds" << endl;
	cout << "DEBUG setPortBaudRate(): " << dec << baud_rate << " bauds" <<
		endl;
#endif /* #ifndef NDEBUG */

} /* setPortBaudRate() */

void Moglk::setPortFlowControl(bool state)
{
        // Port options
	// Port options
	struct termios options;

	// Get current port options
	tcgetattr(serial_port,
                  &options);
	          &options);

	if (state)
	{
        // Input options:
        // enable flow control
        options.c_iflag |= (IXON | IXOFF);
		// Input options:
		// enable flow control
		options.c_iflag |= (IXON | IXOFF);

        // Control characters for flow control
        options.c_cc[VSTART] = RET_ALMOST_EMPTY; // XON
        options.c_cc[VSTOP] = RET_ALMOST_FULL; // XOFF
		// Control characters for flow control
		options.c_cc[VSTART] = RET_ALMOST_EMPTY;	// XON
		options.c_cc[VSTOP] = RET_ALMOST_FULL;		// XOFF

#ifndef NDEBUG
        cout << "DEBUG setPortFlowControl(): enabled" << endl;
	cout &lt;< "DEBUG setPortFlowControl(): enabled" << endl;
#endif /* #ifndef NDEBUG */

	}
	{
		// Input options:
		// disable flow control
                options.c_iflag &= ~(IXON | IXOFF | IXANY);
		options.c_iflag &= ~(IXON | IXOFF | IXANY);

#ifndef NDEBUG
                cout << "DEBUG setPortFlowControl(): disabled" << endl;
	cout << &quot;DEBUG setPortFlowControl(): disabled" << endl;
#endif /* #ifndef NDEBUG */

	}

        // Flush line
	// Flush line
	tcflush(serial_port,
                TCIFLUSH);
	        TCIFLUSH);

	// Set port options
	tcsetattr(serial_port,
                  TCSANOW,
                  &options);
	          TCSANOW,
	          &options);

} /* setPortFlowControl() */

void Moglk::transmit(int * data_ptr)
{
        ssize_t retval = 0;
	ssize_t retval = 0;

        // Write data to the serial port
	// Write data to the serial port
	while (retval <= 0)
	{
	    retval = write(serial_port,
                           data_ptr,
                           1);
		retval = write(serial_port,
		               data_ptr,
		               1);
	}

#ifndef NDEBUG
        cout << "DEBUG transmit(): transmited 0x" << hex << (int)*data_ptr << endl;
	cout << "DEBUG transmit(): transmited 0x" << hex << (int)*data_ptr <<
		endl;
#endif /* #ifndef NDEBUG */

} /* transmit() */

bool Moglk::receive(unsigned char * data_ptr)
{
        unsigned char byte;
	unsigned char byte;

        ssize_t retval = -1;
	ssize_t retval = -1;

        retval = read(serial_port,
                      &byte,
                      1);
	retval = read(serial_port,
	              &byte,
	              1);


        if (!retval) 
        {
                clog << "WARNING receive(): read timed out" << endl;
                return true;
        }
	if (!retval) 
	{
		clog << "WARNING receive(): read timed out" << endl;
		return true;
	}
	else
        {
	{
#ifndef NDEBUG
                cout << "DEBUG receive(): received 0x" << hex << (int)byte << endl;
		cout << "DEBUG receive(): received 0x" << hex << (int)byte << endl;
#endif /* #ifndef NDEBUG */
                *data_ptr = byte;
                return false;
        }
		*data_ptr = byte;
		return false;
	}

return true;
	return true;

} /* receive() */

void Moglk::send(int * message_ptr)
{
        unsigned int n = 0;
	unsigned int n = 0;
	int value = *(message_ptr + n);

	while (value != EOF)
	{
                int * data_ptr;
                data_ptr = &value;
                transmit(data_ptr);
                n++;
                value = *(message_ptr + n);
		int * data_ptr;
		data_ptr = &value;
		transmit(data_ptr);
		n++;
		value = *(message_ptr + n);
	}

#ifndef NDEBUG

bool Moglk::receiveFile(int * file_ptr)
{
    unsigned char size[3];
	unsigned char size[3];

    unsigned int n = 0;
    while (n < 4)
    {
        receive(&size[n]);
        n++;
    }
	unsigned int n = 0;
	while (n < 4)
	{
		receive(&size[n]);
		n++;
	}

    unsigned int file_size = size[0] + size[1] * 256 + size[2] * 65536 + size[3] * 16777216;
	unsigned int file_size = size[0] + size[1] * 256 + size[2] * 65536 +
		size[3] * 16777216;

#ifndef NDEBUG
    cout << "DEBUG receiveFile(): file size = " << dec << file_size << "B" << endl;
	cout << "DEBUG receiveFile(): file size = " << dec << file_size << "B" <<
		endl;
#endif /* #ifndef NDEBUG */

        if (file_size)
        {
            int file[file_size + 1];
	if (file_size)
	{
		int file[file_size + 1];

            file_ptr = &file[0];
		file_ptr = &file[0];

            unsigned long int i = 0;
            while (i < (file_size + 1))
            {
		unsigned long int i = 0;
		while (i < (file_size + 1))
		{
#ifndef NDEBUG
            cout << "DEBUG receiveFile(): receiving byte #" << dec << i << " : ";
			cout << "DEBUG receiveFile(): receiving byte #" << dec << i <<
				" : ";
#endif /* #ifndef NDEBUG */

                unsigned char * byte_ptr;
                receive(byte_ptr);
                file[i] = *byte_ptr;
                i++;
            }
            file[i] = EOF;
			unsigned char * byte_ptr;
			receive(byte_ptr);
			file[i] = *byte_ptr;
			i++;
		}
		file[i] = EOF;

#ifndef NDEBUG
            cout << "DEBUG receiveFile(): received file data = ";
            unsigned long int k = 0;
            while (file[k] != EOF)
            {
                cout << hex << (int)file[k];
                k++;
            }
            cout << endl;
            cout << "DEBUG receiveFile(): received " << dec << k - 1 << "B" << endl;
		cout << "DEBUG receiveFile(): received file data = ";
		unsigned long int k = 0;
		while (file[k] != EOF)
		{
			cout << hex << (int)file[k];
			k++;
		}
		cout << endl;
		cout << "DEBUG receiveFile(): received " << dec << k - 1 << "B" <<
				endl;
#endif /* #ifndef NDEBUG */
            return false;
        }
        else
        {
                cerr << "ERROR receiveFile(): file doesn't exist" << endl;
                return true;
        }
		return false;
		}
		else
		{
			cerr << "ERROR receiveFile(): file doesn't exist" << endl;
			return true;
		}

        return true;
		return true;

} /* receiveFile() */


	switch (baud_rate)
	{
                case 0:
                {
                        device_rate = BAUD_RATE_DEFAULT;
                        break;
                }
		case 0:
		{
				device_rate = BAUD_RATE_DEFAULT;
				break;
		}
		case 9600:
		{
			device_rate = BAUD_RATE_9600;
		case 14400:
		{
			device_rate = BAUD_RATE_14400;
			clog << "WARNING Linux host doesn't support "<< baud_rate << "bauds rate" << endl;
			clog << "WARNING Linux host doesn't support "<< baud_rate <<
				"bauds rate" << endl;
			break;
		}

		case 28800:
		{
			device_rate = BAUD_RATE_28800;
			clog << "WARNING Linux host doesn't support "<< baud_rate << "bauds rate" << endl;
			clog << "WARNING Linux host doesn't support "<< baud_rate <<
				"bauds rate" << endl;
			break;
		}

		case 57600:
		{
			device_rate = BAUD_RATE_57600;
			clog << "WARNING Linux host doesn't support "<< baud_rate << "bauds rate" << endl;
			clog << "WARNING Linux host doesn't support "<< baud_rate <<
				"bauds rate" << endl;
			break;
		}

		case 76800:
		{
			device_rate = BAUD_RATE_76800;
			clog << "WARNING Linux host doesn't support "<< baud_rate << "bauds rate" << endl;
			clog << "WARNING Linux host doesn't support "<< baud_rate <<
				"bauds rate" << endl;
			break;
		}

		}
		default:
		{
                        standard = 0;
                        if (baud_rate >= 977 && baud_rate <= 153800)
                        {
                                unsigned short int non_standard_rate = (16000000 / 8 * baud_rate) - 1;
                                clog << "WARNING Linux host doesn't support custom rates (" << baud_rate << ")" << endl;
                                non_standard_rate_lsb = non_standard_rate;
                                non_standard_rate_msb = non_standard_rate / 256;
                        }
                        else
                        {
                                clog << "WARNING Device doesn't support " << dec << baud_rate << " bauds rate" << endl;
                        }
			standard = 0;
			if (baud_rate >= 977 && baud_rate <= 153800)
			{
					unsigned short int non_standard_rate =
						(16000000 / 8 * baud_rate) - 1;
					clog <<
						"WARNING Linux host doesn't support custom rates (" <<
						baud_rate << ")" << endl;
					non_standard_rate_lsb = non_standard_rate;
					non_standard_rate_msb = non_standard_rate / 256;
			}
			else
			{
				clog << "WARNING Device doesn't support " << dec <<	baud_rate <<
				" bauds rate" << endl;
			}
			break;
		}

	} /* switch(baud_rate) */

        if (!standard)
        {
	if (!standard)
	{
#ifndef NDEBUG
                cout << "DEBUG setBaudRate(): non-standard "<< dec << baud_rate << " (0x" << hex << (int)device_rate << ")" << endl;
		cout << "DEBUG setBaudRate(): non-standard "<< dec << baud_rate <<
			" (0x" << hex << (int)device_rate << ")" << endl;
#endif /* #ifndef NDEBUG */
                if ((non_standard_rate_lsb < 12 && non_standard_rate_msb == 0) || (non_standard_rate_lsb == 0xFF && non_standard_rate_msb > 0x07))
                {
                        int message[] = {CMD_INIT,
                                         CMD_NON_STANDARD_BAUD_RATE,
                                         non_standard_rate_lsb,
                                         non_standard_rate_msb,
                                         EOF};
                        send(&message[0]);
                }
                else
                {
                        cerr << "ERROR setBaudRate(): command ignored" << endl;
                        return true;
                }
        }
        else
        {
		if ((non_standard_rate_lsb < 12 && non_standard_rate_msb == 0) ||
			(non_standard_rate_lsb == 0xFF && non_standard_rate_msb > 0x07))
		{
			int message[] = {CMD_INIT,
			                 CMD_NON_STANDARD_BAUD_RATE,
			                 non_standard_rate_lsb,
			                 non_standard_rate_msb,
			                 EOF};
			send(&message[0]);
		}
		else
		{
			cerr << "ERROR setBaudRate(): command ignored" << endl;
			return true;
		}
	}
	else
	{
#ifndef NDEBUG
                cout << "DEBUG setBaudRate(): " << dec << baud_rate << " (0x" << hex << (int)device_rate << ")" << endl;
		cout << "DEBUG setBaudRate(): " << dec << baud_rate << " (0x" <<
			hex << (int)device_rate << ")" << endl;
#endif /* #ifndef NDEBUG */

                int message[] = {CMD_INIT,
                                 CMD_BAUD_RATE,
                                 device_rate,
                                 EOF};
                send(&message[0]);
        }
		int message[] = {CMD_INIT,
		                 CMD_BAUD_RATE,
		                 device_rate,
		                 EOF};
		send(&message[0]);
	}

        setPortBaudRate(baud_rate);
	setPortBaudRate(baud_rate);

        return false;
	return false;

} /* setBaudRate */

	if (state)
	{
#ifndef NDEBUG
		cout << "DEBUG setFlowControl(): on, full at "<< dec << (int)full << " byte(s), empty at " << (int)empty << " bytes(s)" << endl;
		cout << "DEBUG setFlowControl(): on, full at "<< dec << (int)full <<
			" byte(s), empty at " << (int)empty << " bytes(s)" << endl;
#endif /* #ifndef NDEBUG */

		int message[] = {CMD_INIT,
                                 CMD_FLOW_CONTROL_ON,
                                 full,
                                 empty,
                                 EOF};
		                 CMD_FLOW_CONTROL_ON,
		                 full,
		                 empty,
		                 EOF};
		send(&message[0]);
	}
    else
	else
	{
#ifndef NDEBUG
		cout << "DEBUG setFlowControl(): off" << endl;
#endif /* #ifndef NDEBUG */

		int message[] = {CMD_INIT,
                                 CMD_FLOW_CONTROL_OFF,
                                 EOF};
		                 CMD_FLOW_CONTROL_OFF,
		                 EOF};
		send(&message[0]);
	}

    setPortFlowControl(state);
	setPortFlowControl(state);

} /* setFlowControl */

{


    if (font != 0)
    {
        setFont(font);
    }
	if (font != 0)
	{
		setFont(font);
	}

    if (x != 255 && y != 255)
    {
        setCursor(x,
                  y);
    }
	if (x != 255 && y != 255)
	{
		setCursor(x,
		          y);
	}

    unsigned int n = 0;
    unsigned int message_length = strlen(text);
    int message[message_length + 1];
    while (n < message_length + 1)
    {
        message[n] = text[n];
        n++;
    }
    message[n] = EOF;
	unsigned int n = 0;
	unsigned int message_length = strlen(text);
	int message[message_length + 1];
	while (n < message_length + 1)
	{
		message[n] = text[n];
		n++;
	}
	message[n] = EOF;

#ifndef NDEBUG
	cout << "DEBUG display(): \"" << text << "\" of " << dec << n - 1 << " characters" << endl;
	cout << "DEBUG display(): \"" << text << "\" of " << dec << n - 1 <<
		" characters" << endl;
#endif /* #ifndef NDEBUG */

	send(&message[0]);
#endif /* #ifndef NDEBUG */

	int message[] = {CMD_INIT,
                         CMD_CLEAR_SCREEN,
                         EOF};
	                 CMD_CLEAR_SCREEN,
	                 EOF};
	send(&message[0]);

} /* clearScreen() */
#endif /* #ifndef NDEBUG */

	int message[] = {CMD_INIT,
                         CMD_HOME,
                         EOF};
	                 CMD_HOME,
	                 EOF};
	send(&message[0]);

} /* goHome() */
#endif /* #ifndef NDEBUG */

	int message[] = {CMD_INIT,
                         CMD_USE_FONT,
                         id,
                         EOF};
	                 CMD_USE_FONT,
	                 id,
	                 EOF};
	send(&message[0]);

	//Don't forget to set the font metrics
	setFontMetrics(lm,
                       tm,
                       csp,
                       lsp,
                       srow);
	               tm,
	               csp,
	               lsp,
	               srow);

} /* setFont() */

#endif /* #ifndef NDEBUG */

	int message[] = {CMD_INIT,
                         CMD_FONT_METRICS,
                         lm,
                         tm,
                         csp,
                         lsp,
                         srow,
                         EOF};
	                 CMD_FONT_METRICS,
	                 lm,
	                 tm,
	                 csp,
	                 lsp,
	                 srow,
	                 EOF};
	send(&message[0]);

} /* setFontMetrics() */
{

#ifndef NDEBUG
    cout << "DEBUG setBoxSpace(): ";
	cout << "DEBUG setBoxSpace(): ";
	if (!mode)
	{
		cout << "off";
#endif /* #ifndef NDEBUG */

	int message[] = {CMD_INIT,
                         CMD_BOX_SPACE_MODE,
                         mode,
                         EOF};
	                 CMD_BOX_SPACE_MODE,
	                 mode,
	                 EOF};
	send(&message[0]);

} /* setBoxSpace() */
#endif /* #ifndef NDEBUG */

		int message[] = {CMD_INIT,
                                 CMD_AUTO_SCROLL_OFF,
                                 EOF};
		                 CMD_AUTO_SCROLL_OFF,
		                 EOF};
		send(&message[0]);
    }
    else
    {
	}
	else
	{
#ifndef NDEBUG
		cout << "DEBUG setAutoScroll(): on" << endl;
#endif /* #ifndef NDEBUG */

		int message[] = {CMD_INIT,
                                 CMD_AUTO_SCROLL_ON,
                                 EOF};
		                 CMD_AUTO_SCROLL_ON,
		                 EOF};
		send(&message[0]);
	}


void Moglk::setCursor(unsigned char x,
                      unsigned char y,
		      bool mode)
                      bool mode)
{

    if (x < 0 || y < 0)
    {
        cerr << "ERROR setCursor(): coodinates should be positive" << endl;
    }
	if (x < 0 || y < 0)
	{
		cerr << "ERROR setCursor(): coodinates should be positive" << endl;
	}

	if (!mode)
	{
#ifndef NDEBUG
		cout << "DEBUG setCursor(): absolute pixel mode, X=" << dec << (int)x << "px, Y=" << (int)y << "px" << endl;
		cout << "DEBUG setCursor(): absolute pixel mode, X=" << dec << (int)x <<
			"px, Y=" << (int)y << "px" << endl;
#endif /* #ifndef NDEBUG */

		int message[] = {CMD_INIT,
                                 CMD_CURSOR_COORDINATE,
                                 x,
                                 y,
                                 EOF};
		                 CMD_CURSOR_COORDINATE,
		                 x,
		                 y,
		                 EOF};
		send(&message[0]);
    }
    else
    {
	}
	else
	{
#ifndef NDEBUG
			cout << "DEBUG setCursor(): absolute character size relative mode, X=" << dec << (int)x << ", Y=" << (int)y << endl;
		cout <<
			"DEBUG setCursor(): absolute character size relative mode, X=" <<
			dec << (int)x << ", Y=" << (int)y << endl;
#endif /* #ifndef NDEBUG */

		int message[] = {CMD_INIT,
                                 CMD_CURSOR_POSITION,
                                 x,
                                 y,
                                 EOF};
		                 CMD_CURSOR_POSITION,
		                 x,
		                 y,
		                 EOF};
		send(&message[0]);
	}

#endif /* #ifndef NDEBUG */

	int message[] = {CMD_INIT,
                         CMD_VERSION_NUMBER,
                         EOF};
	                 CMD_VERSION_NUMBER,
	                 EOF};
	send(&message[0]);

        unsigned char version;
	unsigned char version;
	receive(&version);

#ifndef NDEBUG
    stringstream tmp;
    tmp << hex << (int)version;
    unsigned char v[3];
    tmp >> v;
    v[2] = v[1]; // move second digit right
    v[1] = '.'; // add dot between the two digits
    v[3] = 0; // end string
	stringstream tmp;
	tmp << hex << (int)version;
	unsigned char v[3];
	tmp >> v;
	v[2] = v[1];	// move second digit right
	v[1] = '.';		// add dot between the two digits
	v[3] = 0;		// end string
	cout << "DEBUG getVersion(): " << v << endl;
#endif /* #ifndef NDEBUG */

{

#ifndef NDEBUG
    cout << "DEBUG getModuleType()" << endl;
	cout << "DEBUG getModuleType()" << endl;
#endif /* #ifndef NDEBUG */

	int message[] = {CMD_INIT,
                         CMD_MODULE_TYPE,
                         EOF};
	                 CMD_MODULE_TYPE,
	                 EOF};
	send(&message[0]);

        unsigned char type;
	unsigned char type;
	receive(&type);

#ifndef NDEBUG
	cout << "DEBUG getModuleType(): ";
    switch (type)
    {
        case RET_LCD0821:
        {
            cout << "LCD0821";
            break;
        }
	switch (type)
	{
		case RET_LCD0821:
		{
			cout << "LCD0821";
			break;
		}

        case RET_LCD2021:
        {
            cout << "LCD2021";
            break;
        }
		case RET_LCD2021:
		{
			cout << "LCD2021";
			break;
		}

        case RET_LCD2041:
        {
            cout << "LCD2041";
            break;
        }
		case RET_LCD2041:
		{
			cout << "LCD2041";
			break;
		}

        case RET_LCD4021:
        {
            cout << "LCD4021";
            break;
        }
		case RET_LCD4021:
		{
			cout << "LCD4021";
			break;
		}

        case RET_LCD4041:
        {
            cout << "LCD4041";
            break;
        }
		case RET_LCD4041:
		{
			cout << "LCD4041";
			break;
		}

        case RET_LK202_25:
        {
            cout << "LK202-25";
            break;
        }
		case RET_LK202_25:
		{
			cout << "LK202-25";
			break;
		}


        case RET_LK204_25:
        {
            cout << "LK204-25";
            break;
        }
		case RET_LK204_25:
		{
			cout << "LK204-25";
			break;
		}

        case RET_LK404_55:
        {
            cout << "LK404-55";
            break;
        }
		case RET_LK404_55:
		{
			cout << "LK404-55";
			break;
		}

        case RET_VFD2021:
        {
            cout << "VFD2021";
            break;
        }
		case RET_VFD2021:
		{
			cout << "VFD2021";
			break;
		}

        case RET_VFD2041:
        {
            cout << "VFD2041";
            break;
        }
        case RET_VFD4021:
        {
            cout << "VFD4021";
            break;
        }
		case RET_VFD2041:
		{
			cout << "VFD2041";
			break;
		}
		case RET_VFD4021:
		{
			cout << "VFD4021";
			break;
		}

        case RET_VK202_25:
        {
            cout << "VK202-25";
            break;
        }
		case RET_VK202_25:
		{
			cout << "VK202-25";
			break;
		}

        case RET_VK204_25:
        {
            cout << "VK204-25";
            break;
        }
		case RET_VK204_25:
		{
			cout << "VK204-25";
			break;
		}

        case RET_GLC12232:
        {
            cout << "GLC12232";
            break;
        }
		case RET_GLC12232:
		{
			cout << "GLC12232";
			break;
		}

        case RET_GLC24064:
        {
            cout << "GLC24064";
            break;
        }
		case RET_GLC24064:
		{
			cout << "GLC24064";
			break;
		}

        case RET_GLK24064_25:
        {
            cout << "GLK24064-25";
            break;
        }
		case RET_GLK24064_25:
		{
			cout << "GLK24064-25";
			break;
		}

        case RET_GLK12232_25:
        {
            cout << "GLK12232-25";
            break;
        }
		case RET_GLK12232_25:
		{
			cout << "GLK12232-25";
			break;
		}

        case RET_GLK12232_25_SM:
        {
            cout << "GLK12232-25-SM";
            break;
        }
		case RET_GLK12232_25_SM:
		{
			cout << "GLK12232-25-SM";
			break;
		}

		case RET_GLK24064_16_1U_USB:
		{
			cout << "GLK24064-16-1U-USB";
			break;
		}

        case RET_GLK24064_16_1U_USB:
        {
            cout << "GLK24064-16-1U-USB";
            break;
        }
		case RET_GLK24064_16_1U:
		{
			cout << "GLK24064-16-1U";
			break;
		}

        case RET_GLK24064_16_1U:
        {
            cout << "GLK24064-16-1U";
            break;
        }
		case RET_GLK19264_7T_1U_USB:
		{
			cout << "GLK19264-7T-1U-USB";
			break;
		}

        case RET_GLK19264_7T_1U_USB:
        {
            cout << "GLK19264-7T-1U-USB";
            break;
        }
		case RET_GLK12236_16:
		{
			cout << "GLK12236-16";
			break;
		}

        case RET_GLK12236_16:
        {
            cout << "GLK12236-16";
            break;
        }
		case RET_GLK12232_16_SM:
		{
			cout << "GLK12232-16-SM";
			break;
		}

        case RET_GLK12232_16_SM:
        {
            cout << "GLK12232-16-SM";
            break;
        }
		case RET_GLK19264_7T_1U:
		{
			cout << "GLK19264-7T-1U";
			break;
		}

        case RET_GLK19264_7T_1U:
        {
            cout << "GLK19264-7T-1U";
            break;
        }
		case RET_LK204_7T_1U:
		{
			cout << "LK204-7T-1U";
			break;
		}

        case RET_LK204_7T_1U:
        {
            cout << "LK204-7T-1U";
            break;
        }
		case RET_LK204_7T_1U_USB:
		{
			cout << "LK204-7T-1U-USB";
			break;
		}

        case RET_LK204_7T_1U_USB:
        {
            cout << "LK204-7T-1U-USB";
            break;
        }
		case RET_LK404_AT:
		{
			cout << "LK404-AT";
			break;
		}

        case RET_LK404_AT:
        {
            cout << "LK404-AT";
            break;
        }
		case RET_MOS_AV_162A:
		{
			cout << "MOS-AV-162A";
			break;
		}

        case RET_MOS_AV_162A:
        {
            cout << "MOS-AV-162A";
            break;
        }
		case RET_LK402_12:
		{
			cout << "LK402-12";
			break;
		}

        case RET_LK402_12:
        {
            cout << "LK402-12";
            break;
        }
		case RET_LK162_12:
		{
			cout << "LK162-12";
			break;
		}

        case RET_LK162_12:
        {
            cout << "LK162-12";
            break;
        }
		case RET_LK204_25PC:
		{
			cout << "LK204-25PC";
			break;
		}

        case RET_LK204_25PC:
        {
            cout << "LK204-25PC";
            break;
        }
		case RET_LK202_24_USB:
		{
			cout << "LK202-24-USB";
			break;
		}

        case RET_LK202_24_USB:
        {
            cout << "LK202-24-USB";
            break;
        }
		case RET_VK202_24_USB:
		{
			cout << "VK202-24-USB";
			break;
		}

        case RET_VK202_24_USB:
        {
            cout << "VK202-24-USB";
            break;
        }
		case RET_LK204_24_USB:
		{
			cout << "LK204-24-USB";
			break;
		}

        case RET_LK204_24_USB:
        {
            cout << "LK204-24-USB";
            break;
        }
		case RET_VK204_24_USB:
		{
			cout << "VK204-24-USB";
			break;
		}

        case RET_VK204_24_USB:
        {
            cout << "VK204-24-USB";
            break;
        }
		case RET_PK162_12:
		{
			cout << "PK162-12";
			break;
		}

        case RET_PK162_12:
        {
            cout << "PK162-12";
            break;
        }
		case RET_VK162_12:
		{
			cout << "VK162-12";
			break;
		}

        case RET_VK162_12:
        {
            cout << "VK162-12";
            break;
        }
		case RET_MOS_AP_162A:
		{
			cout << "MOS-AP-162A";
			break;
		}

        case RET_MOS_AP_162A:
        {
            cout << "MOS-AP-162A";
            break;
        }
		case RET_PK202_25:
		{
			cout << "PK202-25";
			break;
		}

        case RET_PK202_25:
        {
            cout << "PK202-25";
            break;
        }
		case RET_MOS_AL_162A:
		{
			cout << "MOS-AL-162A";
			break;
		}

        case RET_MOS_AL_162A:
        {
            cout << "MOS-AL-162A";
            break;
        }
		case RET_MOS_AL_202A:
		{
			cout << "MOS-AL-202A";
			break;
		}

        case RET_MOS_AL_202A:
        {
            cout << "MOS-AL-202A";
            break;
        }
		case RET_MOS_AV_202A:
		{
			cout << "MOS-AV-202A";
			break;
		}

        case RET_MOS_AV_202A:
        {
            cout << "MOS-AV-202A";
            break;
        }
		case RET_MOS_AP_202A:
		{
			cout << "MOS-AP-202A";
			break;
		}

        case RET_MOS_AP_202A:
        {
            cout << "MOS-AP-202A";
            break;
        }
		case RET_PK202_24_USB:
		{
			cout << "PK202-24-USB";
			break;
		}

        case RET_PK202_24_USB:
        {
            cout << "PK202-24-USB";
            break;
        }
		case RET_MOS_AL_082:
		{
			cout << "MOS-AL-082";
			break;
		}

        case RET_MOS_AL_082:
        {
            cout << "MOS-AL-082";
            break;
        }
		case RET_MOS_AL_204:
		{
			cout << "MOS-AL-204";
			break;
		}

        case RET_MOS_AL_204:
        {
            cout << "MOS-AL-204";
            break;
        }
		case RET_MOS_AV_204:
		{
			cout << "MOS-AV-204";
			break;
		}

        case RET_MOS_AV_204:
        {
            cout << "MOS-AV-204";
            break;
        }
		case RET_MOS_AL_402:
		{
			cout << "MOS-AL-402";
			break;
		}

        case RET_MOS_AL_402:
        {
            cout << "MOS-AL-402";
            break;
        }
		case RET_MOS_AV_402:
		{
			cout << "MOS-AV-402";
			break;
		}

        case RET_MOS_AV_402:
        {
            cout << "MOS-AV-402";
            break;
        }
		case RET_LK082_12:
		{
			cout << "LK082-12";
			break;
		}

        case RET_LK082_12:
        {
            cout << "LK082-12";
            break;
        }
		case RET_VK402_12:
		{
			cout << "VK402-12";
			break;
		}

        case RET_VK402_12:
        {
            cout << "VK402-12";
            break;
        }
		case RET_VK404_55:
		{
			cout << "VK404-55";
			break;
		}

        case RET_VK404_55:
        {
            cout << "VK404-55";
            break;
        }
		case RET_LK402_25:
		{
			cout << "LK402-25";
			break;
		}

        case RET_LK402_25:
        {
            cout << "LK402-25";
            break;
        }
		case RET_VK402_25:
		{
			cout << "VK402-25";
			break;
		}

        case RET_VK402_25:
        {
            cout << "VK402-25";
            break;
        }
		case RET_PK204_25:
		{
			cout << "PK204-25";
			break;
		}

        case RET_PK204_25:
        {
            cout << "PK204-25";
            break;
        }
		case RET_MOS:
		{
			cout << "MOS";
			break;
		}

        case RET_MOS:
        {
            cout << "MOS";
            break;
        }
		case RET_MOI:
		{
			cout << "MOI";
			break;
		}

        case RET_MOI:
        {
            cout << "MOI";
            break;
        }
		case RET_XBOARD_S:
		{
			cout << "XBOARD-S";
			break;
		}

        case RET_XBOARD_S:
        {
            cout << "XBOARD-S";
            break;
        }
		case RET_XBOARD_I:
		{
			cout << "XBOARD-I";
			break;
		}

        case RET_XBOARD_I:
        {
            cout << "XBOARD-I";
            break;
        }
		case RET_MOU:
		{
			cout << "MOU";
			break;
		}

        case RET_MOU:
        {
            cout << "MOU";
            break;
        }
		case RET_XBOARD_U:
		{
			cout << "XBOARD-U";
			break;
		}

        case RET_XBOARD_U:
        {
            cout << "XBOARD-U";
            break;
        }
		case RET_LK202_25_USB:
		{
			cout << "LK202-25-USB";
			break;
		}

        case RET_LK202_25_USB:
        {
            cout << "LK202-25-USB";
            break;
        }
		case RET_VK202_25_USB:
		{
			cout << "VK202-25-USB";
			break;
		}

        case RET_VK202_25_USB:
        {
            cout << "VK202-25-USB";
            break;
        }
		case RET_LK204_25_USB:
		{
			cout << "LK204-25-USB";
			break;
		}

        case RET_LK204_25_USB:
        {
            cout << "LK204-25-USB";
            break;
        }
		case RET_VK204_25_USB:
		{
			cout << "VK204-25-USB";
			break;
		}

        case RET_VK204_25_USB:
        {
            cout << "VK204-25-USB";
            break;
        }
		case RET_LK162_12_TC:
		{
			cout << "LK162-12-TC";
			break;
		}

        case RET_LK162_12_TC:
        {
            cout << "LK162-12-TC";
            break;
        }
		case RET_GLK240128_25:
		{
			cout << "GLK240128-25";
			break;
		}

        case RET_GLK240128_25:
        {
            cout << "GLK240128-25";
            break;
        }
		case RET_LK404_25:
		{
			cout << "LK404-25";
			break;
		}

        case RET_LK404_25:
        {
            cout << "LK404-25";
            break;
        }
		case RET_VK404_25:
		{
			cout << "VK404-25";
			break;
		}

        case RET_VK404_25:
        {
            cout << "VK404-25";
            break;
        }
		default:
		{
			cerr << "ERROR getModuleType: unknown module of type 0x" << hex << (int)type << endl;
			break;
		}
	} /* switch(type) */

        default:
        {
            cerr << "ERROR getModuleType: unknown module of type 0x" << hex << (int)type << endl;
            break;
        }
    } /* switch(type) */

    cout << " (0x" << hex << (int)type << ")" << endl;
	cout << " (0x" << hex << (int)type << ")" << endl;
#endif /* #ifndef NDEBUG */

	return type;
#endif /* #ifndef NDEBUG */

	int message[] = {CMD_INIT,
                         CMD_READ_CUSTOMER_DATA,
                         EOF};
	                 CMD_READ_CUSTOMER_DATA,
	                 EOF};
	send(&message[0]);

    unsigned int n = 0;
    while (n < 16)
    {
        receive((data + n));
        n++;
    }
    *(data + n) = EOF;
	unsigned int n = 0;
	while (n < 16)
	{
		receive((data + n));
		n++;
	}
	*(data + n) = EOF;

#ifndef NDEBUG
	cout << "DEBUG getCustomerData(): " << data << endl;
{

#ifndef NDEBUG
	cout << "DEBUG drawMemBmp(): bitmap #" << dec << (int)id << ", X=" << (int)x << "px ,Y=" << (int)y << "px"<< endl;
	cout << "DEBUG drawMemBmp(): bitmap #" << dec << (int)id << ", X=" <<
		(int)x << "px ,Y=" << (int)y << "px"<< endl;
#endif /* #ifndef NDEBUG */

	int message[] = {CMD_INIT,
                         CMD_DRAW_MEMORY_BMP,
                         id,
                         x,
                         y,
                         EOF};
	                 CMD_DRAW_MEMORY_BMP,
	                 id,
	                 x,
	                 y,
	                 EOF};
	send(&message[0]);

} /* drawMemBmp() */
{

#ifndef NDEBUG
    cout << "DEBUG setDrawingColor(): ";
	cout << "DEBUG setDrawingColor(): ";
	if (!color)
	{
        cout << "white";
    }
    else
    {
        cout << "black";
		cout << "white";
	}
	else
	{
		cout << "black";
	}
	cout << endl;

#endif /* #ifndef NDEBUG */

	int message[] = {CMD_INIT,
                         CMD_DRAWING_COLOR,
                         color,
                         EOF};
	                 CMD_DRAWING_COLOR,
 	                 color,
	                 EOF};
	send(&message[0]);

} /* setDrawingColor() */
                      bool color)
{

    setDrawingColor(color);
	setDrawingColor(color);

#ifndef NDEBUG
	cout << "DEBUG drawPixel(): X=" << dec << (int)x << "px, Y=" << (int)y << "px"<< endl;
	cout << "DEBUG drawPixel(): X=" << dec << (int)x << "px, Y=" << (int)y <<
		"px"<< endl;
#endif /* #ifndef NDEBUG */

    int message[] = {CMD_INIT,
                     CMD_DRAW_PIXEL,
                     x,
                     y,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	             CMD_DRAW_PIXEL,
	             x,
	             y,
	             EOF};
	send(&message[0]);

} /* drawPixel() */

                     bool color)
{

    setDrawingColor(color);
	setDrawingColor(color);

    if (x2 < 255 && y2 < 255)
    {
	if (x2 < 255 && y2 < 255)
	{

#ifndef NDEBUG
        cout << "DEBUG drawLine(): X1=" << dec << (int)x1 << "px, Y1=" << (int)y1 << "px, X2=" << (int)x2 << "px, Y2=" << (int)y2 << "px" << endl;
		cout << "DEBUG drawLine(): X1=" << dec << (int)x1 << "px, Y1=" <<
			(int)y1 << "px, X2=" << (int)x2 << "px, Y2=" << (int)y2 << "px" <<
			endl;
#endif /* #ifndef NDEBUG */

        int message[] = {CMD_INIT,
                         CMD_DRAW_LINE,
                         x1,
                         y1,
                         x2,
                         y2,
                         EOF};
        send(&message[0]);
    }
    if (x2 == 255 || y2 == 255)
    {
            cerr << "ERROR drawLine(): command ignored, only one value of X2 or Y2 set!" << endl;
            return true;
    }
    if (x2 == 255 && y2 == 255)
    {
		int message[] = {CMD_INIT,
		                 CMD_DRAW_LINE,
		                 x1,
		                 y1,
		                 x2,
		                 y2,
		                 EOF};
		send(&message[0]);
	}
	if (x2 == 255 || y2 == 255)
	{
		cerr <<
			"ERROR drawLine(): command ignored," <<
			" only one value of X2 or Y2 set!" << endl;
		return true;
	}
	if (x2 == 255 && y2 == 255)
	{

#ifndef NDEBUG
        cout << "DEBUG drawLine(): continue previous line to X=" << dec << (int)x1 << "px, Y=" << (int)y1 << "px" << endl;
		cout << "DEBUG drawLine(): continue previous line to X=" << dec <<
			(int)x1 << "px, Y=" << (int)y1 << "px" << endl;
#endif /* #ifndef NDEBUG */

        int message[] = {CMD_INIT,
                         CMD_CONTINUE_LINE,
                         x1,
                         y1,
                         EOF};
        send(&message[0]);
    }
		int message[] = {CMD_INIT,
		                 CMD_CONTINUE_LINE,
		                 x1,
		                 y1,
		                 EOF};
		send(&message[0]);
	}

    return false;
	return false;

} /* drawLine() */

                          bool color)
{

    if (!mode)
    {
	if (!mode)
	{
#ifndef NDEBUG
        cout << "DEBUG drawRectangle(): empty, ";
        if (color) cout << "black";
        else cout << "white";
        cout << ", X1=" << dec << (int)x1 << "px, Y1=" << (int)y1 << "px, X2=" << (int)x2 << "px, Y2=" << (int)y2 << "px" << endl;
		cout << "DEBUG drawRectangle(): empty, ";
		if (color) cout << "black";
		else cout << "white";
		cout << ", X1=" << dec << (int)x1 << "px, Y1=" << (int)y1 <<
			"px, X2=" << (int)x2 << "px, Y2=" << (int)y2 << "px" << endl;
#endif /* #ifndef NDEBUG */

        int message[] = {CMD_INIT,
                         CMD_DRAW_RECTANGLE,
                         color,
                         x1,
                         y1,
                         x2,
                         y2,
                         EOF};
        send(&message[0]);
    }
    else
    {
		int message[] = {CMD_INIT,
		                 CMD_DRAW_RECTANGLE,
		                 color,
		                 x1,
		                 y1,
		                 x2,
		                 y2,
		                 EOF};
		send(&message[0]);
	}
	else
	{
#ifndef NDEBUG
        cout << "DEBUG drawRectangle(): solid, ";
        if (color) cout << "black";
        else cout << "white";
        cout << ", X1=" << dec << (int)x1 << "px, Y1=" << (int)y1 << "px, X2=" << (int)x2 << "px, Y2=" << (int)y2 << "px" << endl;
		cout << "DEBUG drawRectangle(): solid, ";
		if (color) cout << "black";
		else cout << "white";
		cout << ", X1=" << dec << (int)x1 << "px, Y1=" << (int)y1 <<
			"px, X2=" << (int)x2 << "px, Y2=" << (int)y2 << "px" << endl;
#endif /* #ifndef NDEBUG */

        int message[] = {CMD_INIT,
                         CMD_DRAW_SOLID_RECTANGLE,
                         color,
                         x1,
                         y1,
                         x2,
                         y2,
                         EOF};
        send(&message[0]);
    }
		int message[] = {CMD_INIT,
		                 CMD_DRAW_SOLID_RECTANGLE,
		                 color,
		                 x1,
		                 y1,
		                 x2,
		                 y2,
		                 EOF};
		send(&message[0]);
	}

} /* drawRectangle() */

                         unsigned char id)
{

    if (id > 15)
    {
        cerr << "ERROR initBarGraph(): id should be within 0-15" << endl;
        return true;
    }
	if (id > 15)
	{
		cerr << "ERROR initBarGraph(): id should be within 0-15" << endl;
		return true;
	}

    if (type > 3)
    {
        cerr << "ERROR initBarGraph(): type should be within 0-3" << endl;
        return true;
    }
	if (type > 3)
	{
		cerr << "ERROR initBarGraph(): type should be within 0-3" << endl;
		return true;
	}

    if (x1 > x2)
    {
        cerr << "ERROR initBarGraph(): x1 should be less than x2, please use type to choose the direction" << endl;
        return true;
    }
	if (x1 > x2)
	{
		cerr << "ERROR initBarGraph(): x1 should be less than x2," <<
			" please use type to choose the direction" << endl;
		return true;
	}

    if (y1 > y2)
    {
        cerr << "ERROR initBarGraph(): y1 should be less than y2, please use type to choose the direction" << endl;
        return true;
    }
	if (y1 > y2)
	{
		cerr << "ERROR initBarGraph(): y1 should be less than y2," <<
			" please use type to choose the direction" << endl;
		return true;
	}

#ifndef NDEBUG
    cout << "DEBUG initBarGraph(): bar graph #" << dec << (int)id << ", ";
    switch (type)
    {
        case 0:
        {
            cout << "vertical from bottom";
            break;
        }
	#ifndef NDEBUG
	cout << "DEBUG initBarGraph(): bar graph #" << dec << (int)id << ", ";
	switch (type)
	{
		case 0:
		{
			cout << "vertical from bottom";
			break;
		}

        case 1:
        {
            cout << "horizontal from left";
            break;
        }
		case 1:
		{
			cout << "horizontal from left";
			break;
		}

        case 2:
        {
            cout << "vertical from top";
            break;
        }
		case 2:
		{
			cout << "vertical from top";
			break;
		}

        case 3:
        {
            cout << "horizontal from right";
            break;
        }
    } /* switch(type) */
    cout << ", X1=" << dec << (int)x1 << "px, Y1=" << (int)y1 << "px, X2=" << (int)x2 << "px, Y2=" << (int)y2 << "px" << endl;
		case 3:
		{
			cout << "horizontal from right";
			break;
		}
	} /* switch(type) */
	cout << ", X1=" << dec << (int)x1 << "px, Y1=" << (int)y1 << "px, X2=" <<
		(int)x2 << "px, Y2=" << (int)y2 << "px" << endl;
#endif /* #ifndef NDEBUG */

    int message[] = {CMD_INIT,
                     CMD_INITIALIZE_BAR_GRAPH,
                     id,
                     type,
                     x1,
                     y1,
                     x2,
                     y2,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_INITIALIZE_BAR_GRAPH,
	                 id,
	                 type,
	                 x1,
	                 y1,
	                 x2,
	                 y2,
	                 EOF};
	send(&message[0]);

    return false;
	return false;

} /* initBarGraph() */

bool Moglk::drawBarGraph(unsigned char value,
                         unsigned char id)
{
    if (id > 15)
    {
        cerr << "ERROR drawBarGraph(): id should be within 0-15" << endl;
        return true;
    }
	if (id > 15)
	{
		cerr << "ERROR drawBarGraph(): id should be within 0-15" << endl;
		return true;
	}

#ifndef NDEBUG
    cout << "DEBUG drawBarGraph(): bar graph #" << dec << (int)id << " to " << (int)value << "px" << endl;
	cout << "DEBUG drawBarGraph(): bar graph #" << dec << (int)id << " to " <<
		(int)value << "px" << endl;
#endif /* #ifndef NDEBUG */

    int message[] = {CMD_INIT,
                     CMD_DRAW_BAR_GRAPH,
                     id,
                     value,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_DRAW_BAR_GRAPH,
	                 id,
	                 value,
	                 EOF};
	send(&message[0]);

    return false;
	return false;

} /* drawBarGraph() */

                           unsigned char id)
{

    if (id > 6)
    {
        cerr << "ERROR initStripChart(): id should be within 0-6" << endl;
        return true;
    }
	if (id > 6)
	{
		cerr << "ERROR initStripChart(): id should be within 0-6" << endl;
		return true;
	}

    if (x1 > x2)
    {
        cerr << "ERROR initStripChart(): x1 should be less than x2, please use type to choose the direction" << endl;
        return true;
    }
	if (x1 > x2)
	{
		cerr << "ERROR initStripChart(): x1 should be less than x2," <<
			" please use type to choose the direction" << endl;
		return true;
	}

    if (y1 > y2)
    {
        cerr << "ERROR initStripChart(): y1 should be less than y2, please use type to choose the direction" << endl;
        return true;
    }
	if (y1 > y2)
	{
		cerr << "ERROR initStripChart(): y1 should be less than y2," <<
			" please use type to choose the direction" << endl;
		return true;
	}

#ifndef NDEBUG
    cout << "DEBUG initStripChart(): strip chart #" << dec << (int)id << ", X1=" << (int)x1 << ", Y1=" << (int)y1 << ", X2=" << (int)x2 << ", Y2=" << (int)y2 << endl;
	cout << "DEBUG initStripChart(): strip chart #" << dec << (int)id <<
		", X1=" << (int)x1 << ", Y1=" << (int)y1 << ", X2=" << (int)x2 <<
		", Y2=" << (int)y2 << endl;
#endif /* #ifndef NDEBUG */

    int message[] = {CMD_INIT,
                     CMD_INITIALIZE_STRIP_CHART,
                     id,
                     x1,
                     y1,
                     x2,
                     y2,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_INITIALIZE_STRIP_CHART,
	                 id,
	                 x1,
	                 y1,
	                 x2,
	                 y2,
	                 EOF};
	send(&message[0]);

    return false;
	return false;

} /* initStripChart() */

                            unsigned char id)
{

    if (id > 6)
    {
        cerr << "ERROR initStripChart(): id should be within 0-6" << endl;
        return true;
    }
	if (id > 6)
	{
		cerr << "ERROR initStripChart(): id should be within 0-6" << endl;
		return true;
	}


#ifndef NDEBUG
    cout << "DEBUG shiftStripChart(): strip chart #" << dec << (int)id << ", shifted";
    if (!direction)
    {
        cout << "left";
    }
    else
    {
        cout << "right";
    }
    cout << endl;
	cout << "DEBUG shiftStripChart(): strip chart #" << dec << (int)id <<;
		", shifted";
	if (!direction)
	{
		cout << "left";
	}
	else
	{
		cout << "right";
	}
	cout << endl;
#endif /* #ifndef NDEBUG */

    unsigned char ref = id + direction * 128;
	unsigned char ref = id + direction * 128;

    int message[] = {CMD_INIT,
                     CMD_SHIFT_STRIP_CHART,
                     ref,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_SHIFT_STRIP_CHART,
	                 ref,
	                 EOF};
	send(&message[0]);

    return false;
	return false;

} /* shiftStripChart() */

                   bool state)
{

    if (id == 0 || id > 6)
    {
        cerr << "ERROR setGpo(): id should be within 1-6" << endl;
        return true;
    }
	if (id == 0 || id > 6)
	{
		cerr << "ERROR setGpo(): id should be within 1-6" << endl;
		return true;
	}

    if (!state)
    {
	if (!state)
	{
#ifndef NDEBUG
        cout << "DEBUG setGpo(): GPO #" << dec << (int)id << ", off" << endl;
		cout &lt;< "DEBUG setGpo(): GPO #" << dec << (int)id << ", off" << endl;
#endif /* #ifndef NDEBUG */

        int message[] = {CMD_INIT,
                         CMD_GPO_OFF,
                         id,
                         EOF};
        send(&message[0]);
    }
    else
    {
		int message[] = {CMD_INIT,
		                 CMD_GPO_OFF,
		                 id,
		                 EOF};
		send(&message[0]);
	}
	else
	{
#ifndef NDEBUG
        cout << "DEBUG setGpo(): GPO #" << dec << (int)id << ", on" << endl;
		cout &lt;< "DEBUG setGpo(): GPO #" << dec << (int)id << ", on" << endl;
#endif /* #ifndef NDEBUG */

        int message[] = {CMD_INIT,
                         CMD_GPO_ON,
                         id,
                         EOF};
        send(&message[0]);
    }
		int message[] = {CMD_INIT,
		                 CMD_GPO_ON,
		                 id,
		                 EOF};
		send(&message[0]);
	}

    return false;
	return false;

} /* setGpo() */

                   unsigned char state)
{

    if (id == 0 || id > 3)
    {
        cerr << "ERROR setLed(): id should be within 1-3" << endl;
        return true;
    };
	if (id == 0 || id > 3)
	{
		cerr << "ERROR setLed(): id should be within 1-3" << endl;
		return true;
	};

    if (state > 3)
    {
        cerr << "ERROR setLed(): state should be within 0-3" << endl;
        return true;
    }
	if (state > 3)
	{
		cerr << "ERROR setLed(): state should be within 0-3" << endl;
		return true;
	}

#ifndef NDEBUG
    cout << "DEBUG setLed(): ";
    switch (id)
    {
        case 1:
        {
            cout << "top LED";
            break;
        }
	cout << "DEBUG setLed(): ";
	switch (id)
	{
		case 1:
		{
			cout << "top LED";
			break;
		}

        case 2:
        {
            cout << "middle LED";
            break;
        }
		case 2:
		{
			cout << "middle LED";
			break;
		}

        case 3:
        {
            cout << "bottom LED";
            break;
        }
    } /* swicth(id) */
    cout << ", ";
		case 3:
		{
			cout << "bottom LED";
			break;
		}
	} /* swicth(id) */
	cout << ", ";
#endif /* #ifndef NDEBUG */

    switch (state)
    {
        case 0:
        {
	switch (state)
	{
		case 0:
		{
#ifndef NDEBUG
            cout << "yellow" << endl;
			cout << "yellow" << endl;
#endif /* #ifndef NDEBUG */

            setGpo(id * 2 - 1,
                   0);
            setGpo(id * 2,
                   0);
            break;
        }
			setGpo(id * 2 - 1,
			       0);
			setGpo(id * 2,
			       0);
			break;
		}

        case 1:
        {
		case 1:
		{
#ifndef NDEBUG
            cout << "green" << endl;
			cout << "green" << endl;
#endif /* #ifndef NDEBUG */

            setGpo(id * 2 - 1,
                   1);
            setGpo(id * 2,
                   0);
            break;
        }
			setGpo(id * 2 - 1,
			       1);
			setGpo(id * 2,
			       0);
			break;
		}

        case 2:
        {
		case 2:
		{
#ifndef NDEBUG
            cout << "red" << endl;
			cout << "red" << endl;
#endif /* #ifndef NDEBUG */

            setGpo(id * 2 - 1,
                   0);
            setGpo(id * 2,
                   1);
            break;
        }
			setGpo(id * 2 - 1,
			       0);
			setGpo(id * 2,
			       1);
			break;
		}

        case 3:
        {
		case 3:
		{
#ifndef NDEBUG
            cout << "off" << endl;
			cout << "off" << endl;
#endif /* #ifndef NDEBUG */

            setGpo(id * 2 - 1,
                   1);
            setGpo(id * 2,
                   1);
            break;
        }
    } /* switch (state)*/
			setGpo(id * 2 - 1,
			       1);
			setGpo(id * 2,
			       1);
			break;
		}
	} /* switch (state)*/

    return false;
	return false;

} /* setLed() */

bool Moglk::ledYellow(unsigned char id)
{
    if (id == 0 || id > 3)
    {
        cerr << "ERROR ledYellow(): id should be within 1-3" << endl;
        return true;
    }
	if (id == 0 || id > 3)
	{
		cerr << "ERROR ledYellow(): id should be within 1-3" << endl;
		return true;
	}

#ifndef NDEBUG
    cout << "DEBUG ledYellow(): ";
    switch (id)
    {
        case 1:
        {
            cout << "top LED";
            break;
        }
	#ifndef NDEBUG
	cout << "DEBUG ledYellow(): ";
	switch (id)
	{
		case 1:
		{
			cout << "top LED";
			break;
		}

        case 2:
        {
            cout << "middle LED";
            break;
        }
		case 2:
		{
			cout << "middle LED";
			break;
		}

        case 3:
        {
            cout << "bottom LED";
            break;
        }
    } /* switch(id) */
    cout << endl;
		case 3:
		{
			cout << "bottom LED";
			break;
		}
	} /* switch(id) */
	cout << endl;
#endif /* #ifndef NDEBUG */

    setLed(id,
           0);
	setLed(id,
		   0);

    return false;
	return false;

} /* ledYellow */

bool Moglk::ledGreen(unsigned char id)
{
    if (id == 0 || id > 3)
    {
        cerr << "ERROR ledGreen(): id should be within 1-3" << endl;
        return true;
    }
	if (id == 0 || id > 3)
	{
		cerr << "ERROR ledGreen(): id should be within 1-3" << endl;
		return true;
	}

#ifndef NDEBUG
    cout << "DEBUG ledGreen(): ";
    switch (id)
    {
        case 1:
        {
            cout << "top LED";
            break;
        }
	cout << "DEBUG ledGreen(): ";
	switch (id)
	{
		case 1:
		{
			cout << "top LED";
			break;
		}

        case 2:
        {
            cout << "middle LED";
            break;
        }
		case 2:
		{
			cout << "middle LED";
			break;
		}

        case 3:
        {
            cout << "bottom LED";
            break;
        }
    } /* switch(id) */
    cout << endl;
		case 3:
		{
			cout << "bottom LED";
			break;
		}
	} /* switch(id) */
	cout << endl;
#endif /* #ifndef NDEBUG */

    setLed(id,
           1);
	setLed(id,
		   1);

    return false;
	return false;

} /* ledGreen*/

bool Moglk::ledRed(unsigned char id)
{
    if (id == 0 || id > 3)
    {
        cerr << "ERROR ledRed(): id should be within 1-3" << endl;
        return true;
    }
	if (id == 0 || id > 3)
	{
		cerr << "ERROR ledRed(): id should be within 1-3" << endl;
		return true;
	}

#ifndef NDEBUG
    cout << "DEBUG ledRed(): ";
    switch (id)
    {
        case 1:
        {
            cout << "top LED";
            break;
        }
	cout << "DEBUG ledRed(): ";
	switch (id)
	{
		case 1:
		{
			cout << "top LED";
			break;
		}

        case 2:
        {
            cout << "middle LED";
            break;
        }
		case 2:
		{
			cout << "middle LED";
			break;
		}

        case 3:
        {
            cout << "bottom LED";
            break;
        }
    } /* switch(id) */
    cout << endl;
		case 3:
		{
			cout << "bottom LED";
			break;
		}
	} /* switch(id) */
	cout << endl;
#endif /* #ifndef NDEBUG */

    setLed(id,
           2);
	setLed(id,
		   2);

    return false;
	return false;

} /* ledRed */

bool Moglk::ledOff(unsigned char id)
{
    if (id == 0 || id > 3)
    {
        cerr << "ERROR ledOff(): id should be within 1-3" << endl;
        return true;
    }
	if (id == 0 || id > 3)
	{
		cerr << "ERROR ledOff(): id should be within 1-3" << endl;
		return true;
	}

#ifndef NDEBUG
    cout << "DEBUG ledOff(): ";
    switch (id)
    {
        case 1:
        {
            cout << "top LED";
            break;
        }
	cout << "DEBUG ledOff(): ";
	switch (id)
	{
		case 1:
		{
			cout << "top LED";
			break;
		}

        case 2:
        {
            cout << "middle LED";
            break;
        }
		case 2:
		{
			cout << "middle LED";
			break;
		}

        case 3:
        {
            cout << "bottom LED";
            break;
        }
    } /* switch(id) */
    cout << endl;
		case 3:
		{
			cout << "bottom LED";
			break;
		}
	} /* switch(id) */
	cout << endl;
#endif /* #ifndef NDEBUG */

    setLed(id,
           3);
	setLed(id,
		   3);

    return false;
	return false;

} /* ledOff */

                       bool state)
{

    if (id == 0 || id > 6)
    {
        cerr << "ERROR startupGpo(): id should be within 1-6" << endl;
        return true;
    }
	if (id == 0 || id > 6)
	{
		cerr << "ERROR startupGpo(): id should be within 1-6" << endl;
		return true;
	}

#ifndef NDEBUG
    cout << "DEBUG startupGpo(): GPO #" << dec << (int)id << ", ";
    if (!state)
    {
        cout << "off";
    }
    else
    {
        cout << "on";
    }
    cout << endl;
	cout << "DEBUG startupGpo(): GPO #" << dec << (int)id << ", ";
	if (!state)
	{
		cout << "off";
	}
	else
	{
		cout << "on";
	}
	cout << endl;
#endif /* #ifndef NDEBUG */

    int message[] = {CMD_INIT,
                     CMD_STARTUP_GPO_STATE,
                     id,
                     state,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_STARTUP_GPO_STATE,
	                 id,
	                 state,
	                 EOF};
	send(&message[0]);

    return false;
	return false;

} /* startupGpo() */

{

#ifndef NDEBUG
    cout << "DEBUG setAutoTxKey(): ";
	cout << "DEBUG setAutoTxKey(): ";
#endif /* #ifndef NDEBUG */

    if (!state)
    {
	if (!state)
	{
#ifndef NDEBUG
        cout << "off" << endl;
		cout &lt;< "off" << endl;
#endif /* #ifndef NDEBUG */

        int message[] = {CMD_INIT,
                         CMD_AUTO_TRANSMIT_KEY_OFF,
                         EOF};
        send(&message[0]);
    }
    else
    {
		int message[] = {CMD_INIT,
		                 CMD_AUTO_TRANSMIT_KEY_OFF,
		                 EOF};
		send(&message[0]);
	}
	else
	{
#ifndef NDEBUG
       cout << "on" << endl;
		   cout << "on" << endl;
#endif /* #ifndef NDEBUG */

       int message[] = {CMD_INIT,
                        CMD_AUTO_TRANSMIT_KEY_ON,
                        EOF};
       send(&message[0]);
    }
		int message[] = {CMD_INIT,
		                 CMD_AUTO_TRANSMIT_KEY_ON,
		                 EOF};
		send(&message[0]);
	}

} /* setAutotxKey() */

bool Moglk::setBacklight(bool state,
                         unsigned char time)
{
    if (time > 90)
    {
        cerr << "ERROR setBacklight(): time must be less than 90 minutes" << endl;
        return true;
    }
	if (time > 90)
	{
		cerr << "ERROR setBacklight(): " <<
			"time must be less than 90 minutes" << endl;
		return true;
	}

#ifndef NDEBUG
    cout << "DEBUG setBacklight(): ";
	cout << "DEBUG setBacklight(): ";
#endif /* #ifndef NDEBUG */

    if (!state)
    {
	if (!state)
	{
#ifndef NDEBUG
        cout << "off" << endl;
		cout &lt;< "off" << endl;
#endif /* #ifndef NDEBUG */
        if (time)
        {
            clog << "WARNING setBacklight(): unused time value only available for set backlight on" << endl;
        };
		if (time)
		{
			clog << "WARNING setBacklight(): " <<
				"unused time value only available for set backlight on" << endl;
		};

        int message[] = {CMD_INIT,
                         CMD_DISPLAY_OFF,
                         EOF};
        send(&message[0]);
    }
    else
    {
		int message[] = {CMD_INIT,
		                 CMD_DISPLAY_OFF,
		                 EOF};
		send(&message[0]);
	}
	else
	{
#ifndef NDEBUG
        cout << "on in " << dec << (int)time << " minute(s)"<< endl;
		cout &lt;< "on in " << dec << (int)time << " minute(s)"<< endl;
#endif /* #ifndef NDEBUG */

        int message[] = {CMD_INIT,
                         CMD_DISPLAY_ON,
                         time,
                         EOF};
        send(&message[0]);
    }
		int message[] = {CMD_INIT,
		                 CMD_DISPLAY_ON,
		                 time,
		                 EOF};
		send(&message[0]);
	}

    return false;
	return false;

} /* setBacklight() */

{

#ifndef NDEBUG
    cout << "DEBUG clearKeyBuffer()" << endl;
	cout << "DEBUG clearKeyBuffer()" << endl;
#endif /* #ifndef NDEBUG */

    int message[] = {CMD_INIT,
                     CMD_CLEAR_KEY_BUFFER,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_CLEAR_KEY_BUFFER,
	                 EOF};
	send(&message[0]);

} /* clearKeyBuffer() */

void Moglk::setDebounce(unsigned char time)
{
#ifndef NDEBUG
    cout << "DEBUG setDebounce(): " << dec << (int)time * 8 << "ms" << endl;
	cout << "DEBUG setDebounce(): " << dec << (int)time * 8 << "ms" << endl;
#endif /* #ifndef NDEBUG */

    int message[] = {CMD_INIT,
                     CMD_DEBOUNCE_TIME,
                     time,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_DEBOUNCE_TIME,
	                 time,
	                 EOF};
	send(&message[0]);


} /* setDebounce() */
void Moglk::setAutoRepeat(bool mode)
{
#ifndef NDEBUG
    cout << "DEBUG setAutoRepeat(): ";
    if (!mode)
    {
        cout << "resend key";
    }
    else
    {
        cout << "key up/key down";
    }
    cout << endl;
	cout << "DEBUG setAutoRepeat(): ";
	if (!mode)
	{
		cout << "resend key";
	}
	else
	{
		cout << "key up/key down";
	}
	cout << endl;
#endif /* #ifndef NDEBUG */

    int message[] = {CMD_INIT,
                     CMD_AUTO_REPEAT_MODE,
                     mode,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_AUTO_REPEAT_MODE,
	                 mode,
	                 EOF};
	send(&message[0]);

} /* setAutoRepeat() */

void Moglk::autoRepeatOff(void)
{
#ifndef NDEBUG
    cout << "DEBUG autoRepeatOff()" << endl;
	cout << "DEBUG autoRepeatOff()" << endl;
#endif /* #ifndef NDEBUG */

    int message[] = {CMD_INIT,
                     CMD_AUTO_REPEAT_OFF,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_AUTO_REPEAT_OFF,
	                 EOF};
	send(&message[0]);

} /* autoRepeatOff() */

void Moglk::setBrightness(unsigned char value)
{
#ifndef NDEBUG
    cout << "DEBUG setBrightness(): " << dec << (int)value << endl;
	cout << "DEBUG setBrightness(): " << dec << (int)value << endl;
#endif /* #ifndef NDEBUG */

    int message[] = {CMD_INIT,
                     CMD_BRIGHTNESS,
                     value,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_BRIGHTNESS,
	                 value,
	                 EOF};
	send(&message[0]);

} /* setBrightness() */

void Moglk::setDefaultBrightness(unsigned char value)
{
#ifndef NDEBUG
    cout << "DEBUG setDefaultBrightness(): " << dec << (int)value << endl;
	cout << "DEBUG setDefaultBrightness(): " << dec << (int)value << endl;
#endif /* #ifndef NDEBUG */

    int message[] = {CMD_INIT,
                     CMD_DEFAULT_BRIGHTNESS,
                     value,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_DEFAULT_BRIGHTNESS,
	                 value,
	                 EOF};
	send(&message[0]);

} /* setDefaultBrightness() */

void Moglk::setContrast(unsigned char value)
{
#ifndef NDEBUG
    cout << "DEBUG setContrast(): " << dec << (int)value << endl;
	cout << "DEBUG setContrast(): " << dec << (int)value << endl;
#endif /* #ifndef NDEBUG */

    int message[] = {CMD_INIT,
                     CMD_CONTRAST,
                     value,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_CONTRAST,
	                 value,
	                 EOF};
	send(&message[0]);

} /* setContrast() */

void Moglk::setDefaultContrast(unsigned char value)
{
#ifndef NDEBUG
    cout << "DEBUG setDefaultContrast(): " << dec << (int)value << endl;
	cout << "DEBUG setDefaultContrast(): " << dec << (int)value << endl;
#endif /* #ifndef NDEBUG */

    int message[] = {CMD_INIT,
                     CMD_DEFAULT_CONTRAST,
                     value,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_DEFAULT_CONTRAST,
	                 value,
	                 EOF};
	send(&message[0]);

} /* setDefaultContrast() */

void Moglk::wipeFs(void)
{
#ifndef NDEBUG
    cout << "DEBUG wipeFs()" << endl;
	cout << "DEBUG wipeFs()" << endl;
#endif /* #ifndef NDEBUG */

    int message[] = {CMD_INIT,
                     CMD_WIPE_FILESYSTEM,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_WIPE_FILESYSTEM,
	                 EOF};
	send(&message[0]);

} /* wipeFs() */

unsigned short int Moglk::getFreeSpace(void)
{
#ifndef NDEBUG
    cout << "DEBUG getFreeSpace()" << endl;
	cout << "DEBUG getFreeSpace()" << endl;
#endif /* #ifndef NDEBUG */

    int message[] = {CMD_INIT,
                     CMD_FREE_SPACE,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_FREE_SPACE,
	                 EOF};
	send(&message[0]);

    unsigned char size[3];
	unsigned char size[3];

    unsigned int n = 0;
    while (n < 4)
    {
        receive(&size[n]);
        n++;
    }
	unsigned int n = 0;
	while (n < 4)
	{
		receive(&size[n]);
		n++;
	}

    unsigned short int free_space = size[0] + size[1] * 256 + size[2] * 65536 + size[3] * 16777216;
	unsigned short int free_space = size[0] + size[1] * 256 + size[2] * 65536
		+ size[3] * 16777216;

#ifndef NDEBUG
    cout << "DEBUG getFreeSpace(): " << dec << free_space << "B" << endl;
	cout << "DEBUG getFreeSpace(): " << dec << free_space << "B" << endl;
#endif /* #ifndef NDEBUG */

    return free_space;
	return free_space;

} /* getFreeSpace() */

void Moglk::setRemember(bool mode)
{
#ifndef NDEBUG
    cout << "DEBUG setRemember(): ";
    if (!mode)
    {
        cout << "off";
    }
    else
    {
        cout << "on";
    }
    cout << endl;
	cout << "DEBUG setRemember(): ";
	if (!mode)
	{
		cout << "off";
	}
	else
	{
		cout << "on";
	}
	cout << endl;
#endif /* #ifndef NDEBUG */

    int message[] = {CMD_INIT,
                     CMD_REMEMBER,
                     mode,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_REMEMBER,
	                 mode,
	                 EOF};
	send(&message[0]);

} /* setRemember() */

void Moglk::setCustomerData(const char * data)
{
#ifndef NDEBUG
    cout << "DEBUG setCustomerData(): " << data << endl;
	cout << "DEBUG setCustomerData(): " << data << endl;
#endif /* #ifndef NDEBUG */

    int n = 0;
    int message_length = strlen(data);
    int message[message_length+1];
    while (n < message_length+1)
    {
        message[n] = *(data + n);
        n++;
    }
    message[n] = EOF;
    send(&message[0]);
	int n = 0;
	int message_length = strlen(data);
	int message[message_length+1];
	while (n < message_length+1)
	{
		message[n] = *(data + n);
		n++;
	}
	message[n] = EOF;
	send(&message[0]);

} /* setCustomerData() */

void Moglk::getDirectory(void)
{
#ifndef NDEBUG
    cout << "DEBUG getDirectory()" << endl;
	cout << "DEBUG getDirectory()" << endl;
#endif /* #ifndef NDEBUG */

    int message[] = {CMD_INIT,
                     CMD_DIRECTORY,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_DIRECTORY,
	                 EOF};
	send(&message[0]);

    unsigned char entriesCount;
	unsigned char entriesCount;

    receive(&entriesCount);
	receive(&entriesCount);

#ifndef NDEBUG
    cout << "DEBUG getDirectory(): " << dec << (int)entriesCount << " files" << endl;
	cout << "DEBUG getDirectory(): " << dec << (int)entriesCount << " files"
		<< endl;
#endif /* #ifndef NDEBUG */

    for (unsigned int i = 0;i < entriesCount;i++)
    {
        unsigned char flag;
        bitset<8> id;
        unsigned char size_lsb;
        unsigned char size_msb;
	for (unsigned int i = 0;i < entriesCount;i++)
	{
		unsigned char flag;
		bitset<8> id;
		unsigned char size_lsb;
		unsigned char size_msb;

        // Get data
        receive(&flag);
        unsigned char * byte_ptr;
        receive(byte_ptr);
        id = *byte_ptr;
        receive(&size_lsb);
        receive(&size_msb);
		// Get data
		receive(&flag);
		unsigned char * byte_ptr;
		receive(byte_ptr);
		id = *byte_ptr;
		receive(&size_lsb);
		receive(&size_msb);

        // Extract type from id (first bit)
        bool type = id[7];
        // Strip type from id (first bit)
        id[7] = 0;
		// Extract type from id (first bit)
		bool type = id[7];
		// Strip type from id (first bit)
		id[7] = 0;

#ifndef NDEBUG
        cout << "DEBUG getDirectory(): file #" << dec << i << ", ";
        if (!flag)
        {
            cout << "unused" << endl;
        }
        else
        {
		cout << "DEBUG getDirectory(): file #" << dec << i << ", ";
		if (!flag)
		{
			cout << "unused" << endl;
		}
		else
		{

            if (!type)
            {
                cout << "font";
            }
            else
            {
                cout << "bitmap";
            }
			if (!type)
			{
				cout << "font";
			}
			else
			{
				cout << "bitmap";
			}

            cout << " #" << id.to_ulong() << ", " << dec << (int)size_lsb + (int)size_msb * 256 << "B" << endl;
        }
			cout << " #" << id.to_ulong() << ", " << dec << (int)size_lsb +
				(int)size_msb * 256 << "B" << endl;
		}
#endif /* #ifndef NDEBUG */

    }
	}

} /* getDirectory() */

                       unsigned char id)
{
#ifndef NDEBUG
    cout << "DEBUG deleteFile(): ";
    if (!type)
    {
        cout << "font";
    }
    else
    {
        cout << "bitmap";
    }
    cout << " #" << dec << (int)id << endl;
	cout << "DEBUG deleteFile(): ";
	if (!type)
	{
		cout << "font";
	}
	else
	{
		cout << "bitmap";
	}
	cout << " #" << dec << (int)id << endl;
#endif /* #ifndef NDEBUG */

    int message[] = {CMD_INIT,
                     CMD_DELETE_FILE,
                     type,
                     id,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_DELETE_FILE,
	                 type,
	                 id,
	                 EOF};
	send(&message[0]);

} /* deleteFile() */

if (id)
{
#ifndef NDEBUG
    cout << "DEBUG downloadFile(): ";
    if (!type)
    {
        cout << "font";
    }
    else
    {
        cout << "bitmap";
    }
    cout << " #" << dec << (int)id << endl;
	cout << "DEBUG downloadFile(): ";
	if (!type)
	{
		cout << "font";
	}
	else
	{
		cout << "bitmap";
	}
	cout << " #" << dec << (int)id << endl;
#endif /* #ifndef NDEBUG */

    int message[] = {CMD_INIT,
                     CMD_DOWNLOAD_FILE,
                     type,
                     id,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_DOWNLOAD_FILE,
	                 type,
	             id,
	                 EOF};
	send(&message[0]);

    receiveFile(file_ptr);
	receiveFile(file_ptr);
}
else
{
    cerr << "ERROR downloadFile(): ID should not be null";
	cerr << "ERROR downloadFile(): ID should not be null";
}

        return(file_ptr);
	return(file_ptr);

} /* downloadFile() */

                     unsigned char new_id)
{
#ifndef NDEBUG
    cout << "DEBUG moveFile(): ";
    if (!old_type)
    {
        cout << "font";
    }
    else
    {
        cout << "bitmap";
    }
    cout << " #" << dec << (int)old_id << " to ";
    if (!new_type)
    {
        cout << "font";
    }
    else
    {
        cout << "bitmap";
    }
    cout << " #" << dec << (int)new_id << endl;
	cout << "DEBUG moveFile(): ";
	if (!old_type)
	{
		cout << "font";
	}
	else
	{
		cout << "bitmap";
	}
	cout << " #" << dec << (int)old_id << " to ";
	if (!new_type)
	{
		cout << "font";
	}
	else
	{
		cout << "bitmap";
	}
	cout << " #" << dec << (int)new_id << endl;
#endif /* #ifndef NDEBUG */

    int message[] = {CMD_INIT,
                     CMD_MOVE_FILE,
                     old_type,
                     old_id,
                     new_type,
                     new_id,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_MOVE_FILE,
	                 old_type,
	                 old_id,
	                 new_type,
	                 new_id,
	                 EOF};
	send(&message[0]);

} /* moveFile() */

//TODO: test!
void Moglk::setLock(bitset<8> level)
{
    // Bits reserved
    level[7] = 0;
    level[6] = 0;
    level[5] = 0;
	// Bits reserved
	level[7] = 0;
	level[6] = 0;
	level[5] = 0;

#ifndef NDEBUG
    cout << "DEBUG setLock(): ";
    if (level[4])
    {
        cout << "communication locked";
    }
    else
    {
        cout << "communication unlocked";
    }
    cout << ", ";
    if (level[3])
    {
        cout << "settings locked";
    }
    else
    {
        cout << "settings unlocked";
    }
    cout << ", ";
    if (level[2])
    {
        cout << "filesystem locked";
    }
    else
    {
        cout << "filesystem unlocked";
    }
    cout << ", ";
    if (level[1])
    {
        cout << "command locked";
    }
    else
    {
        cout << "command unlocked";
    }
    cout << ", ";
    if (level[0])
    {
        cout << "display locked";
    }
    else
    {
        cout << "display unlocked";
    }
    cout << endl;
	cout << "DEBUG setLock(): ";
	if (level[4])
	{
		cout << "communication locked";
	}
	else
	{
		cout << "communication unlocked";
	}
	cout << ", ";
	if (level[3])
	{
		cout << "settings locked";
	}
	else
	{
		cout << "settings unlocked";
	}
	cout << ", ";
	if (level[2])
	{
		cout << "filesystem locked";
	}
	else
	{
		cout << "filesystem unlocked";
	}
	cout << ", ";
	if (level[1])
	{
		cout << "command locked";
	}
	else
	{
		cout << "command unlocked";
	}
	cout << ", ";
	if (level[0])
	{
		cout << "display locked";
	}
	else
	{
		cout << "display unlocked";
	}
	cout << endl;
#endif /* #ifndef NDEBUG */

    int message[] = {CMD_INIT,
                     CMD_LOCK_LEVEL,
                     level.to_ulong(),
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_LOCK_LEVEL,
	                 level.to_ulong(),
	                 EOF};
	send(&message[0]);

} /* setLock() */

//TODO: test!
void Moglk::setDefaultLock(bitset<8> level)
{
    // Bits reserved
    level[7] = 0;
    level[6] = 0;
    level[5] = 0;
	// Bits reserved
	level[7] = 0;
	level[6] = 0;
	level[5] = 0;

#ifndef NDEBUG
    cout << "DEBUG setDefaultLock(): ";
    if (level[4])
    {
        cout << "communication locked";
    }
    else
    {
        cout << "communication unlocked";
    }
    cout << ", ";
    if (level[3])
    {
        cout << "settings locked";
    }
    else
    {
        cout << "settings unlocked";
    }
    cout << ", ";
    if (level[2])
    {
        cout << "filesystem locked";
    }
    else
    {
        cout << "filesystem unlocked";
    }
    cout << ", ";
    if (level[1])
    {
        cout << "command locked";
    }
    else
    {
        cout << "command unlocked";
    }
    cout << ", ";
    if (level[0])
    {
        cout << "display locked";
    }
    else
    {
        cout << "display unlocked";
    }
    cout << endl;
	cout << "DEBUG setDefaultLock(): ";
	if (level[4])
	{
		cout << "communication locked";
	}
	else
	{
		cout << "communication unlocked";
	}
	cout << ", ";
	if (level[3])
	{
		cout << "settings locked";
	}
	else
	{
		cout << "settings unlocked";
	}
	cout << ", ";
	if (level[2])
	{
		cout << "filesystem locked";
	}
	else
	{
		cout << "filesystem unlocked";
	}
	cout << ", ";
	if (level[1])
	{
		cout << "command locked";
	}
	else
	{
		cout << "command unlocked";
	}
	cout << ", ";
	if (level[0])
	{
		cout << "display locked";
	}
	else
	{
		cout << "display unlocked";
	}
	cout << endl;
#endif /* #ifndef NDEBUG */

    int message[] = {CMD_INIT,
                     CMD_DEFAULT_LOCK_LEVEL,
                     level.to_ulong(),
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_DEFAULT_LOCK_LEVEL,
	                 level.to_ulong(),
	                 EOF};
	send(&message[0]);

} /* setDefaultLock() */

unsigned char Moglk::pollKey(void)
{
#ifndef NDEBUG
    cout << "DEBUG pollKey()" << endl;
	cout << "DEBUG pollKey()" << endl;
#endif /* #ifndef NDEBUG */

    int message[] = {CMD_INIT,
                     CMD_POLL_KEY,
                     EOF};
    unsigned char key[10] = {0,
                             0,
                             0,
                             0,
                             0,
                             0,
                             0,
                             0,
                             0,
                             0};
	int message[] = {CMD_INIT,
	                 CMD_POLL_KEY,
	                 EOF};
	unsigned char key[10] = {0,
	                         0,
	                         0,
	                         0,
	                         0,
	                         0,
	                         0,
	                         0,
	                         0,
	                         0};

    bitset<8> more = 0x80;
    unsigned int n = 0;
    while (more[7])
    {
        send(&message[0]);
        receive(&key[n]);
        //Get more_key_presses_availables flag
        more = key[n];
        // Reset more_key_presses_availables flag to have a pure key descriptor
        if (more[7])
        {
            key[n] = key[n] - 0x80;
        }
        n++;
    }
	bitset<8> more = 0x80;
	unsigned int n = 0;
	while (more[7])
	{
		send(&message[0]);
		receive(&key[n]);
		//Get more_key_presses_availables flag
		more = key[n];
		// Reset more_key_presses_availables flag to have a pure key descriptor
		if (more[7])
		{
			key[n] = key[n] - 0x80;
		}
		n++;
	}

#ifndef NDEBUG
    unsigned int i = 0;
    while (i < n)
    {
        cout << "DEBUG pollKey(): ";
        switch (key[i])
        {
            case RET_UP:
            {
                cout << "up button pressed" << endl;
                break;
            }
	unsigned int i = 0;
	while (i < n)
	{
		cout << "DEBUG pollKey(): ";
		switch (key[i])
		{
			case RET_UP:
			{
				cout << "up button pressed" << endl;
				break;
			}

            case RET_DOWN:
            {
                cout << "down button pressed" << endl;
                break;
            }
			case RET_DOWN:
			{
				cout << "down button pressed" << endl;
				break;
			}

            case RET_LEFT:
            {
                cout << "left button pressed" << endl;
                break;
            }
			case RET_LEFT:
			{
				cout << "left button pressed" << endl;
				break;
			}

            case RET_RIGHT:
            {
                cout << "right button pressed" << endl;
                break;
            }
			case RET_RIGHT:
			{
				cout << "right button pressed" << endl;
				break;
			}

            case RET_CENTER:
            {
                cout << "center button pressed" << endl;
                break;
            }
			case RET_CENTER:
			{
				cout << "center button pressed" << endl;
				break;
			}

            case RET_TOP:
            {
                cout << "top button pressed" << endl;
                break;
            }
			case RET_TOP:
			{
				cout << "top button pressed" << endl;
				break;
			}

            case RET_BOTTOM:
            {
                cout << "bottom button pressed" << endl;
                break;
            }
			case RET_BOTTOM:
			{
				cout << "bottom button pressed" << endl;
				break;
			}

            case RET_RELEASE_UP:
            {
                cout << "up button released" << endl;
                break;
            }
			case RET_RELEASE_UP:
			{
				cout << "up button released" << endl;
				break;
			}

            case RET_RELEASE_DOWN:
            {
                cout << "down button released" << endl;
                break;
            }
			case RET_RELEASE_DOWN:
			{
				cout << "down button released" << endl;
				break;
			}

            case RET_RELEASE_LEFT:
            {
                cout << "left button released" << endl;
                break;
            }
			case RET_RELEASE_LEFT:
			{
				cout << "left button released" << endl;
				break;
			}

            case RET_RELEASE_RIGHT:
            {
                cout << "right button released" << endl;
                break;
            }
			case RET_RELEASE_RIGHT:
			{
				cout << "right button released" << endl;
				break;
			}

            case RET_RELEASE_CENTER:
            {
                cout << "center button released" << endl;
                break;
            }
			case RET_RELEASE_CENTER:
			{
				cout << "center button released" << endl;
				break;
			}

            case RET_RELEASE_TOP:
            {
                cout << "top button released" << endl;
                break;
            }
			case RET_RELEASE_TOP:
			{
				cout << "top button released" << endl;
				break;
			}

            case RET_RELEASE_BOTTOM:
            {
                cout << "bottom button released" << endl;
                break;
            }
			case RET_RELEASE_BOTTOM:
			{
				cout << "bottom button released" << endl;
				break;
			}

            case RET_NO_KEY:
            {
                cout << "no key pressed" << endl;
                break;
            }
        } /* switch(key) */
        i++;
    };
			case RET_NO_KEY:
			{
				cout << "no key pressed" << endl;
				break;
			}
		} /* switch(key) */
		i++;
	};
#endif /* #ifndef NDEBUG */

    return key[0];
	return key[0];

} /* pollKey() */

                              unsigned char kdown_down)
{
#ifndef NDEBUG
    cout << "DEBUG setCustomKeyCodes(): button top key up message " << hex << (int)kup_top << endl;
    cout << "DEBUG setCustomKeyCodes(): button up key up message " << hex << (int)kup_up << endl;
    cout << "DEBUG setCustomKeyCodes(): button right key up message " << hex << (int)kup_right << endl;
    cout << "DEBUG setCustomKeyCodes(): button left key up message " << hex << (int)kup_left << endl;
    cout << "DEBUG setCustomKeyCodes(): button center key up message " << hex << (int)kup_center << endl;
    cout << "DEBUG setCustomKeyCodes(): button bottom key up message " << hex << (int)kup_bottom << endl;
    cout << "DEBUG setCustomKeyCodes(): button down key up message " << hex << (int)kup_down << endl;
    cout << "DEBUG setCustomKeyCodes(): button top key down message " << hex << (int)kdown_top << endl;
    cout << "DEBUG setCustomKeyCodes(): button up key down message " << hex << (int)kdown_up << endl;
    cout << "DEBUG setCustomKeyCodes(): button right key down message " << hex << (int)kdown_right << endl;
    cout << "DEBUG setCustomKeyCodes(): button left key down message " << hex << (int)kdown_left << endl;
    cout << "DEBUG setCustomKeyCodes(): button center key down message " << hex << (int)kdown_center << endl;
    cout << "DEBUG setCustomKeyCodes(): button bottom key down message " << hex << (int)kdown_bottom << endl;
    cout << "DEBUG setCustomKeyCodes(): button down key down message " << hex << (int)kdown_down << endl;
	cout << "DEBUG setCustomKeyCodes(): button top key up message " << hex <<
		(int)kup_top << endl;
	cout << "DEBUG setCustomKeyCodes(): button up key up message " << hex <<
		(int)kup_up << endl;
	cout << "DEBUG setCustomKeyCodes(): button right key up message " << hex <<
		(int)kup_right << endl;
	cout << "DEBUG setCustomKeyCodes(): button left key up message " << hex <<
		(int)kup_left << endl;
	cout << "DEBUG setCustomKeyCodes(): button center key up message " << hex <<
		(int)kup_center << endl;
	cout << "DEBUG setCustomKeyCodes(): button bottom key up message " << hex <<
		(int)kup_bottom << endl;
	cout << "DEBUG setCustomKeyCodes(): button down key up message " << hex <<
		(int)kup_down << endl;
	cout << "DEBUG setCustomKeyCodes(): button top key down message " << hex <<
		(int)kdown_top << endl;
	cout << "DEBUG setCustomKeyCodes(): button up key down message " << hex <<
		(int)kdown_up << endl;
	cout << "DEBUG setCustomKeyCodes(): button right key down message " <<
		hex << (int)kdown_right << endl;
	cout << "DEBUG setCustomKeyCodes(): button left key down message " << hex <<
		(int)kdown_left << endl;
	cout << "DEBUG setCustomKeyCodes(): button center key down message " <<
		hex << (int)kdown_center << endl;
	cout << "DEBUG setCustomKeyCodes(): button bottom key down message " <<
		hex << (int)kdown_bottom << endl;
	cout << "DEBUG setCustomKeyCodes(): button down key down message " << hex <<
		(int)kdown_down << endl;
#endif /* #ifndef NDEBUG */

    int message[] = {CMD_INIT,
                     CMD_CUSTOM_KEYPAD_CODES,
                     kup_top,
                     kup_up,
                     kup_right,
                     kup_left,
                     kup_center,
                     0,
                     kup_bottom,
                     kup_down,
                     0,
                     kdown_top,
                     kdown_up,
                     kdown_right,
                     kdown_left,
                     kdown_center,
                     0,
                     kdown_bottom,
                     kdown_down,
                     0,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_CUSTOM_KEYPAD_CODES,
	                 kup_top,
	                 kup_up,
	                 kup_right,
	                 kup_left,
	                 kup_center,
	                 0,
	                 kup_bottom,
	                 kup_down,
	                 0,
	                 kdown_top,
	                 kdown_up,
	                 kdown_right,
	                 kdown_left,
	                 kdown_center,
	                 0,
	                 kdown_bottom,
	                 kdown_down,
	                 0,
	                 EOF};
	send(&message[0]);

} /* setCustomKeyCodes() */

int * Moglk::dumpFs(int * file_ptr)
{
    int message[] = {CMD_INIT,
                     CMD_DUMP_FS,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_DUMP_FS,
	                 EOF};
	send(&message[0]);

    receiveFile(file_ptr);
	receiveFile(file_ptr);

    return file_ptr;
	return file_ptr;

} /* dumpFs() */

int * Moglk::dumpSettings(int * file_ptr)
{
    int message[] = {CMD_INIT,
                     CMD_DUMP_SETTINGS,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_DUMP_SETTINGS,
	                 EOF};
	send(&message[0]);

    unsigned int file_size = 466;
	unsigned int file_size = 466;

    int file[file_size + 1];
    file_ptr = &file[0];
	int file[file_size + 1];
	file_ptr = &file[0];

    unsigned long int i = 0;
    while (i < (file_size + 1))
    {
	unsigned long int i = 0;
	while (i < (file_size + 1))
	{
#ifndef NDEBUG
        cout << "DEBUG receiveFile(): byte #" << dec << i << " : ";
		cout &lt;< "DEBUG receiveFile(): byte #" << dec << i << " : ";
#endif /* #ifndef NDEBUG */
        unsigned char * byte_ptr;
        receive(byte_ptr);
        file[i] = *byte_ptr;
        i++;
    }
    file[i] = EOF;
		unsigned char * byte_ptr;
		receive(byte_ptr);
		file[i] = *byte_ptr;
		i++;
	}
	file[i] = EOF;

#ifndef NDEBUG
    cout << "DEBUG receiveFile(): received file data = ";
    unsigned long int j = 0;
    while (file[j] != EOF)
    {
        cout << hex << (int)file[j];
        j++;
    }
    cout << endl;
    cout << "DEBUG receiveFile(): " << dec << j - 1 << "B" << endl;
	cout << "DEBUG receiveFile(): received file data = ";
	unsigned long int j = 0;
	while (file[j] != EOF)
	{
		cout << hex << (int)file[j];
		j++;
	}
	cout << endl;
	cout << "DEBUG receiveFile(): " << dec << j - 1 << "B" << endl;
#endif /* #ifndef NDEBUG */

    return file_ptr;
	return file_ptr;

} /* dumpSettings() */

void Moglk::drawBmp(unsigned char x, unsigned char y, unsigned char width, unsigned char height, int * data_ptr)
void Moglk::drawBmp(unsigned char x,
                    unsigned char y,
                    unsigned char width,
                    unsigned char height,
                    int * data_ptr)
{
#ifndef NDEBUG
    cout << "DEBUG drawBmp(): " << "X=" << dec << (int)x << "px, Y=" << (int)y << "px, " << (int)width << "x" << (int)height << "px" << endl;
	cout << "DEBUG drawBmp(): " << "X=" << dec << (int)x << "px, Y=" <<
		(int)y << "px, " << (int)width << "x" << (int)height << "px" << endl;
#endif /* #ifndef NDEBUG */

    int message[] = {CMD_INIT,
                     CMD_DRAW_BMP,
                     x,
                     y,
                     width,
                     height,
                     EOF};
    send(&message[0]);
    unsigned int n = 0;
    int value = *(data_ptr + n);
    while (value != EOF)
    {
	int message[] = {CMD_INIT,
	                 CMD_DRAW_BMP,
	                 x,
	                 y,
	                 width,
	                 height,
	                 EOF};
	send(&message[0]);
	unsigned int n = 0;
	int value = *(data_ptr + n);
	while (value != EOF)
	{
	int data_message[] = {value,
                              EOF};
        send(data_message);
        n++;
        value = *(data_ptr + n);
    }
	                      EOF};
	send(data_message);
	n++;
	value = *(data_ptr + n);
	}

} /* drawBmp() */

bool Moglk::upload(char * data_ptr)
{
#ifndef NDEBUG
    cout << "DEBUG upload()"<< endl;
	cout << "DEBUG upload()"<< endl;
#endif /* #ifndef NDEBUG */

  unsigned char reply;
  int c_message[] = {CMD_CONFIRM,
                     EOF};
  int d_message[] = {CMD_DECLINE,
                     EOF};
	unsigned char reply;
	int c_message[] = {CMD_CONFIRM,
	                   EOF};
	int d_message[] = {CMD_DECLINE,
	                   EOF};

//Upload code goes here

                       unsigned int size,
                       char * data_ptr)
{
    int message[] = {CMD_INIT,
                     CMD_UPLOAD_FONT,
                     id,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_UPLOAD_FONT,
	                 id,
	                 EOF};
	send(&message[0]);

    upload(data_ptr);
	upload(data_ptr);

} /* uploadFont */

                      char * data_ptr)
{

    int message[] = {CMD_INIT,
                     CMD_UPLOAD_BMP,
                     id,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_UPLOAD_BMP,
	                 id,
	                 EOF};
	send(&message[0]);

    upload(data_ptr);
	upload(data_ptr);

} /* uploadBmp */

                     char * data_ptr)
{

    int message[] = {CMD_INIT,
                     CMD_UPLOAD_FS,
                     EOF};
    send(&message[0]);
	int message[] = {CMD_INIT,
	                 CMD_UPLOAD_FS,
	                 EOF};
	send(&message[0]);

    upload(data_ptr);
	upload(data_ptr);

} /* uploadFs */


Old	New	Code
16	16
17	17	You should have received a copy of the GNU General Public License
18	18	along with libmoglk. If not, see <http://www.gnu.org/licenses/>.
19		*/
	19	*/
20	20
21	21	// C headers
22	22	#include <termios.h> // POSIX Terminal IOs
23		#include <fcntl.h> // POSIX File Control Operations
	23	#include <fcntl.h> // POSIX File Control Operations
24	24
25	25	// C++ headers
26		#include <cstring> // ISO C99 String handling
27		#include <cstdio> // C++ standard IO
28		#include <iostream> // C++ input output stream
29		#include <sstream> // C++ string stream
	26	#include <cstring> // ISO C99 String handling
	27	#include <cstdio> // C++ standard IO
	28	#include <iostream> // C++ input output stream
	29	#include <sstream> // C++ string stream
30	30
31	31	// libmoglk header
32	32	#include "moglk.h"
33	33
34	34	//#define NDEBUG
35	35
36		//Namespaces
	36	// Namespaces
37	37	using namespace std;
38	38
39	39	int serial_port;
44	44
45	45	Moglk::~Moglk()
46	46	{
47		close(serial_port);
	47	close(serial_port);
48	48	}
49	49
50	50	//TODO: Autodetect device
53	53	unsigned long int baud_rate)
54	54	{
55	55
56		if (!baud_rate)
57		{
58		baud_rate = autodetectBaudRate(device_ptr);
59		}
	56	if (!baud_rate)
	57	{
	58	baud_rate = autodetectBaudRate(device_ptr);
	59	}
60	60
61		if(!openPort(device_ptr))
62		{
63		configurePort();
64		setPortBaudRate(baud_rate);
	61	if(!openPort(device_ptr))
	62	{
	63	configurePort();
	64	setPortBaudRate(baud_rate);
65	65	/*
66		setFlowControl(1,
67		8,
68		119);
	66	setFlowControl(1,
	67	8,
	68	119);
69	69	*/
70	70
71	71	#ifndef NDEBUG
72		cout << "DEBUG init(): libmoglk initialized!" << endl;
	72	cout << "DEBUG init(): libmoglk initialized!" << endl;
73	73	#endif /* #ifndef NDEBUG */
74	74
75		return false;
76		}
	75	return false;
	76	}
77	77
78		return true;
	78	return true;
79	79
80	80	} /* init() */
81	81
82	82	unsigned long int Moglk::autodetectBaudRate(char * device_ptr)
83	83	{
84	84
85		unsigned long int detected_baud_rate = 0;
86		unsigned char module_type;
87		long int baud_rate[] = {B9600,
88		B19200,
89		B38400,
90		B115200,
91		EOF};
	85	unsigned long int detected_baud_rate = 0;
	86	unsigned char module_type;
	87	long int baud_rate[] = {B9600,
	88	B19200,
	89	B38400,
	90	B115200,
	91	EOF};
92	92
93		for (unsigned char n = 0;baud_rate[n] != EOF;n++)
94		{
95		init(device_ptr,
96		baud_rate[n]);
97		module_type = getModuleType();
98		if (module_type)
99		{
100		detected_baud_rate = baud_rate[n];
101		}
102		}
	93	for (unsigned char n = 0;baud_rate[n] != EOF;n++)
	94	{
	95	init(device_ptr,
	96	baud_rate[n]);
	97	module_type = getModuleType();
	98	if (module_type)
	99	{
	100	detected_baud_rate = baud_rate[n];
	101	}
	102	}
103	103
104	104	#ifndef NDEBUG
105		cout << "DEBUG autodetectBaudRate() : detectedBaudrate = " << dec << detected_baud_rate << endl;
	105	cout << "DEBUG autodetectBaudRate() : detectedBaudrate = " << dec <<
	106	detected_baud_rate << endl;
106	107	#endif /* #ifndef NDEBUG */
107	108
108		return detected_baud_rate;
	109	return detected_baud_rate;
109	110
110	111	} /* autodetectBaudRate */
111	112
112	113	bool Moglk::openPort(char * device_ptr)
113	114	{
114		// Open serial port:
	115	// Open serial port:
115	116	// read/write, no control terminal
116	117	serial_port = open(device_ptr,
117		O_RDWR \| O_NOCTTY);
	118	O_RDWR \| O_NOCTTY);
118	119
119		// Handle errors
	120	// Handle errors
120	121	if (serial_port < 0)
121	122	{
122		cerr << "ERROR openPort(): can't open serial port on " << device_ptr << endl;
	123	cerr << "ERROR openPort(): can't open serial port on " << device_ptr <<
	124	endl;
123	125	return true;
124	126	}
125		else
126		{
	127	else
	128	{
127	129	#ifndef NDEBUG
128		cout << "DEBUG openPort(): sucessfully opened serial port on " << device_ptr << endl;
	130	cout << "DEBUG openPort(): sucessfully opened serial port on " <<
	131	device_ptr << endl;
129	132	#endif /* #ifndef NDEBUG */
130		return false;
131		}
	133	return false;
	134	}
132	135
133		return true;
	136	return true;
134	137
135	138	} /* openPort() */
136	139
137	140	void Moglk::configurePort(void)
138	141	{
139		// Port options
	142	// Port options
140	143	struct termios options;
141	144
142	145	// Get current port options
143	146	tcgetattr(serial_port,
144		&options);
	147	&options);
145	148
146	149	// Control options:
147	150	// 8 data bits, no parity, 1 stopbit, local line, enable receiver
155	158	// Raw output
156	159	options.c_oflag &= ~OPOST;
157	160
158		// Character control options:
159		// Timeout after X*0.1 sec
160		options.c_cc[VTIME] = 1;
161		// No minimum number of bytes received
162		options.c_cc[VMIN] = 0;
	161	// Character control options:
	162	// Timeout after X*0.1 sec
	163	options.c_cc[VTIME] = 1;
	164	// No minimum number of bytes received
	165	options.c_cc[VMIN] = 0;
163	166
164	167	// Flush line
165	168	tcflush(serial_port,
166		TCIFLUSH);
	169	TCIFLUSH);
167	170
168	171	// Set port options
169	172	tcsetattr(serial_port,
170		TCSANOW,
171		&options);
	173	TCSANOW,
	174	&options);
172	175
173	176	#ifndef NDEBUG
174		cout << "DEBUG configurePort()" << endl;
	177	cout << "DEBUG configurePort()" << endl;
175	178	#endif /* #ifndef NDEBUG */
176	179
177	180	} /* configurePort() */
178	181
179	182	void Moglk::setPortBaudRate(unsigned long int baud_rate)
180	183	{
181		// Port rate flag
	184	// Port rate flag
182	185	tcflag_t port_rate;
183	186
184	187	// baudrate to rate flag
215	218	}
216	219	} /* switch(baud_rate) */
217	220
218		// Port options
	221	// Port options
219	222	struct termios options;
220	223
221	224	// Get current port options
222	225	tcgetattr(serial_port,
223		&options);
	226	&options);
224	227
225	228	// Control options:
226	229	// global baud rate
227	230	options.c_cflag \|= (port_rate);
228	231
229		// Set input baud rate
	232	// Set input baud rate
230	233	cfsetispeed(&options,
231		port_rate);
	234	port_rate);
232	235
233	236	// Set output baud rate
234	237	cfsetospeed(&options,
235		port_rate);
	238	port_rate);
236	239
237	240	// Flush line
238	241	tcflush(serial_port,
239		TCIFLUSH);
	242	TCIFLUSH);
240	243
241	244	// Set port options
242	245	tcsetattr(serial_port,
243		TCSANOW,
244		&options);
	246	TCSANOW,
	247	&options);
245	248
246	249	#ifndef NDEBUG
247		cout << "DEBUG setPortBaudRate(): " << dec << baud_rate << " bauds" << endl;
	250	cout << "DEBUG setPortBaudRate(): " << dec << baud_rate << " bauds" <<
	251	endl;
248	252	#endif /* #ifndef NDEBUG */
249	253
250	254	} /* setPortBaudRate() */
251	255
252	256	void Moglk::setPortFlowControl(bool state)
253	257	{
254		// Port options
	258	// Port options
255	259	struct termios options;
256	260
257	261	// Get current port options
258	262	tcgetattr(serial_port,
259		&options);
	263	&options);
260	264
261	265	if (state)
262	266	{
263		// Input options:
264		// enable flow control
265		options.c_iflag \|= (IXON \| IXOFF);
	267	// Input options:
	268	// enable flow control
	269	options.c_iflag \|= (IXON \| IXOFF);
266	270
267		// Control characters for flow control
268		options.c_cc[VSTART] = RET_ALMOST_EMPTY; // XON
269		options.c_cc[VSTOP] = RET_ALMOST_FULL; // XOFF
	271	// Control characters for flow control
	272	options.c_cc[VSTART] = RET_ALMOST_EMPTY; // XON
	273	options.c_cc[VSTOP] = RET_ALMOST_FULL; // XOFF
270	274
271	275	#ifndef NDEBUG
272		cout << "DEBUG setPortFlowControl(): enabled" << endl;
	276	cout << "DEBUG setPortFlowControl(): enabled" << endl;
273	277	#endif /* #ifndef NDEBUG */
274	278
275	279	}
277	281	{
278	282	// Input options:
279	283	// disable flow control
280		options.c_iflag &= ~(IXON \| IXOFF \| IXANY);
	284	options.c_iflag &= ~(IXON \| IXOFF \| IXANY);
281	285
282	286	#ifndef NDEBUG
283		cout << "DEBUG setPortFlowControl(): disabled" << endl;
	287	cout << "DEBUG setPortFlowControl(): disabled" << endl;
284	288	#endif /* #ifndef NDEBUG */
285	289
286	290	}
287	291
288		// Flush line
	292	// Flush line
289	293	tcflush(serial_port,
290		TCIFLUSH);
	294	TCIFLUSH);
291	295
292	296	// Set port options
293	297	tcsetattr(serial_port,
294		TCSANOW,
295		&options);
	298	TCSANOW,
	299	&options);
296	300
297	301	} /* setPortFlowControl() */
298	302
299	303	void Moglk::transmit(int * data_ptr)
300	304	{
301		ssize_t retval = 0;
	305	ssize_t retval = 0;
302	306
303		// Write data to the serial port
	307	// Write data to the serial port
304	308	while (retval <= 0)
305	309	{
306		retval = write(serial_port,
307		data_ptr,
308		1);
	310	retval = write(serial_port,
	311	data_ptr,
	312	1);
309	313	}
310	314
311	315	#ifndef NDEBUG
312		cout << "DEBUG transmit(): transmited 0x" << hex << (int)*data_ptr << endl;
	316	cout << "DEBUG transmit(): transmited 0x" << hex << (int)*data_ptr <<
	317	endl;
313	318	#endif /* #ifndef NDEBUG */
314	319
315	320	} /* transmit() */
316	321
317	322	bool Moglk::receive(unsigned char * data_ptr)
318	323	{
319		unsigned char byte;
	324	unsigned char byte;
320	325
321		ssize_t retval = -1;
	326	ssize_t retval = -1;
322	327
323		retval = read(serial_port,
324		&byte,
325		1);
	328	retval = read(serial_port,
	329	&byte,
	330	1);
326	331
327	332
328		if (!retval)
329		{
330		clog << "WARNING receive(): read timed out" << endl;
331		return true;
332		}
	333	if (!retval)
	334	{
	335	clog << "WARNING receive(): read timed out" << endl;
	336	return true;
	337	}
333	338	else
334		{
	339	{
335	340	#ifndef NDEBUG
336		cout << "DEBUG receive(): received 0x" << hex << (int)byte << endl;
	341	cout << "DEBUG receive(): received 0x" << hex << (int)byte << endl;
337	342	#endif /* #ifndef NDEBUG */
338		*data_ptr = byte;
339		return false;
340		}
	343	*data_ptr = byte;
	344	return false;
	345	}
341	346
342		return true;
	347	return true;
343	348
344	349	} /* receive() */
345	350
346	351	void Moglk::send(int * message_ptr)
347	352	{
348		unsigned int n = 0;
	353	unsigned int n = 0;
349	354	int value = *(message_ptr + n);
350	355
351	356	while (value != EOF)
352	357	{
353		int * data_ptr;
354		data_ptr = &value;
355		transmit(data_ptr);
356		n++;
357		value = *(message_ptr + n);
	358	int * data_ptr;
	359	data_ptr = &value;
	360	transmit(data_ptr);
	361	n++;
	362	value = *(message_ptr + n);
358	363	}
359	364
360	365	#ifndef NDEBUG
365	370
366	371	bool Moglk::receiveFile(int * file_ptr)
367	372	{
368		unsigned char size[3];
	373	unsigned char size[3];
369	374
370		unsigned int n = 0;
371		while (n < 4)
372		{
373		receive(&size[n]);
374		n++;
375		}
	375	unsigned int n = 0;
	376	while (n < 4)
	377	{
	378	receive(&size[n]);
	379	n++;
	380	}
376	381
377		unsigned int file_size = size[0] + size[1] * 256 + size[2] * 65536 + size[3] * 16777216;
	382	unsigned int file_size = size[0] + size[1] * 256 + size[2] * 65536 +
	383	size[3] * 16777216;
378	384
379	385	#ifndef NDEBUG
380		cout << "DEBUG receiveFile(): file size = " << dec << file_size << "B" << endl;
	386	cout << "DEBUG receiveFile(): file size = " << dec << file_size << "B" <<
	387	endl;
381	388	#endif /* #ifndef NDEBUG */
382	389
383		if (file_size)
384		{
385		int file[file_size + 1];
	390	if (file_size)
	391	{
	392	int file[file_size + 1];
386	393
387		file_ptr = &file[0];
	394	file_ptr = &file[0];
388	395
389		unsigned long int i = 0;
390		while (i < (file_size + 1))
391		{
	396	unsigned long int i = 0;
	397	while (i < (file_size + 1))
	398	{
392	399	#ifndef NDEBUG
393		cout << "DEBUG receiveFile(): receiving byte #" << dec << i << " : ";
	400	cout << "DEBUG receiveFile(): receiving byte #" << dec << i <<
	401	" : ";
394	402	#endif /* #ifndef NDEBUG */
395	403
396		unsigned char * byte_ptr;
397		receive(byte_ptr);
398		file[i] = *byte_ptr;
399		i++;
400		}
401		file[i] = EOF;
	404	unsigned char * byte_ptr;
	405	receive(byte_ptr);
	406	file[i] = *byte_ptr;
	407	i++;
	408	}
	409	file[i] = EOF;
402	410
403	411	#ifndef NDEBUG
404		cout << "DEBUG receiveFile(): received file data = ";
405		unsigned long int k = 0;
406		while (file[k] != EOF)
407		{
408		cout << hex << (int)file[k];
409		k++;
410		}
411		cout << endl;
412		cout << "DEBUG receiveFile(): received " << dec << k - 1 << "B" << endl;
	412	cout << "DEBUG receiveFile(): received file data = ";
	413	unsigned long int k = 0;
	414	while (file[k] != EOF)
	415	{




// COMMUNICATION
#define CMD_INIT					0xFE //Done
#define CMD_INIT						0xFE							//Done
// (Must be issued before any command)
#define CMD_FLOW_CONTROL_ON				0x3A //Done
#define CMD_FLOW_CONTROL_ON				0x3A							//Done
//										full[0-128]
//										(Number of bytes before almost full
//										 0: full)
//										(Number of bytes before almost empty
//										 128: empty)

#define RET_ALMOST_FULL					0xFE //Done
#define RET_ALMOST_EMPTY				0xFF //Done
#define RET_ALMOST_FULL					0xFE							//Done
#define RET_ALMOST_EMPTY				0xFF							//Done

#define CMD_FLOW_CONTROL_OFF			        0x3B //Done
#define CMD_FLOW_CONTROL_OFF			0x3B							//Done

#define CMD_BAUD_RATE					0x39 //Done
#define CMD_BAUD_RATE					0x39							//Done
//										speed[See table below]

#define BAUD_RATE_9600					0xCF //Done
#define BAUD_RATE_14400					0x8A //Done
#define BAUD_RATE_19200					0x67 //Done
#define BAUD_RATE_28800					0x44 //Done
#define BAUD_RATE_38400					0x33 //Done
#define BAUD_RATE_57600					0x22 //Done
#define BAUD_RATE_76800					0x19 //Done
#define BAUD_RATE_115200					0x10 //Done
#define BAUD_RATE_9600					0xCF							//Done
#define BAUD_RATE_14400					0x8A							//Done
#define BAUD_RATE_19200					0x67							//Done
#define BAUD_RATE_28800					0x44							//Done
#define BAUD_RATE_38400					0x33							//Done
#define BAUD_RATE_57600					0x22							//Done
#define BAUD_RATE_76800					0x19							//Done
#define BAUD_RATE_115200				0x10							//Done

#define BAUD_RATE_DEFAULT				BAUD_RATE_19200 //Done
#define BAUD_RATE_DEFAULT				BAUD_RATE_19200					//Done

#define CMD_NON_STANDARD_BAUD_RATE		        0xA4 //Done
#define CMD_NON_STANDARD_BAUD_RATE		0xA4							//Done
//										speed[12-2047]
//										(2 bytes,
//										LSB then MSB,
//										to communicate)
/*
										Formula :
												 CrystalSpeed (16MHz)
										         CrystalSpeed (16MHz)
										speed = ---------------------  -  1
												  8 x DesiredBaud
										          8 x DesiredBaud
*/

// FONTS
*/
//TODO: implement font file format

#define CMD_UPLOAD_FONT					0x24 //
#define CMD_UPLOAD_FONT					0x24							//
//										fontid
//										lsbsize
//                                      msbsize
//										msbsize
//										fontfile
// (Don't forget to set the new font metrics,
//  see FILESYSTEM file transfer protocol)
#define CMD_USE_FONT					0x31 //Done
#define CMD_USE_FONT					0x31							//Done
//										fontid
#define CMD_FONT_METRICS				0x32 //Done
#define CMD_FONT_METRICS				0x32							//Done
//										lm
//										(Left Margin: Location in pixels)
//										tm
//										srow
//										(Scroll Row:
//										Y location of last row in pixels)
#define CMD_BOX_SPACE_MODE				0xAC //Done
#define CMD_BOX_SPACE_MODE				0xAC							//Done
//										value[0-1]
//										(0: Off,
//										 1: On)

// TEXT
#define CMD_HOME					0x48 //Done
#define CMD_CURSOR_POSITION				0x47 //Done
#define CMD_HOME						0x48							//Done
#define CMD_CURSOR_POSITION				0x47							//Done
//										col
//										row
//										(Derived from current font base size)
#define CMD_CURSOR_COORDINATE			        0x79 //Done
#define CMD_CURSOR_COORDINATE			0x79							//Done
//										x
//										y
#define CMD_AUTO_SCROLL_ON				0x51 //Done
#define CMD_AUTO_SCROLL_OFF				0x52 //Done
#define CMD_AUTO_SCROLL_ON				0x51							//Done
#define CMD_AUTO_SCROLL_OFF				0x52							//Done

// BITMAPS
/*
	The bitmap is encoded into bytes horizontally
*/

#define CMD_UPLOAD_BMP					0x5E //Done
#define CMD_UPLOAD_BMP					0x5E							//Done
//										bitmapid
//										lsbsize
//                                      msbsize
//										msbsize
//										bitmapfile
// (see FILESYSTEM file transfer protocol)
#define CMD_DRAW_MEMORY_BMP				0x62 //Done
#define CMD_DRAW_MEMORY_BMP				0x62							//Done
//										bitmapid
//										x
//										y
#define CMD_DRAW_BMP					0x64 //Done
#define CMD_DRAW_BMP					0x64							//Done
//										x
//										y
//										width
//										data

// BAR GRAPHS & DRAWING
#define CMD_DRAWING_COLOR				0x63 //Done
#define CMD_DRAWING_COLOR				0x63							//Done
//										color[0-255]
//										(0: 	White,
//										(0:     White,
//										 1-255: Black)
#define CMD_DRAW_PIXEL					0x70 //Done
#define CMD_DRAW_PIXEL					0x70							//Done
//										x
//										y
#define CMD_DRAW_LINE					0x6C //Done
#define CMD_DRAW_LINE					0x6C							//Done
//										x1
//										y1
//										x2
//										y2
// (Lines may interpolate differently Left to Right and Right to Left)
#define CMD_CONTINUE_LINE				0x65 //Done
#define CMD_CONTINUE_LINE				0x65							//Done
//										x
//										y
#define CMD_DRAW_RECTANGLE				0x72 //Done
#define CMD_DRAW_RECTANGLE				0x72							//Done
//										color[0-255]
//										(0: 	White,
//										(0:     White,
//										 1-255: Black)
//										x1
//										y1
//										x2
//										y2
#define CMD_DRAW_SOLID_RECTANGLE		        0x78 //Done
#define CMD_DRAW_SOLID_RECTANGLE		0x78							//Done
//										color[0-255]
//										(0: 	White,
//										(0:     White,
//										 1-255: Black)
//										x1
//										y1
//										x2
//										y2
#define CMD_INITIALIZE_BAR_GRAPH		        0x67 //Done
#define CMD_INITIALIZE_BAR_GRAPH		0x67							//Done
//										bgid[0-15]
//										type[0-3]
//										(0: Vertical from bottom,
//										y2
//										(y1<y2)
// (Beware of overlapping bar graphs)
#define CMD_DRAW_BAR_GRAPH				0x69 //Done
#define CMD_DRAW_BAR_GRAPH				0x69							//Done
//										bgid[0-15]
//										value
//										(In pixels)
#define CMD_INITIALIZE_STRIP_CHART		        0x6A //Done
#define CMD_INITIALIZE_STRIP_CHART		0x6A							//Done
//										scid[0-6]
//										x1
//										y1
//										(x1<x2)
//										y2
//										(y1<y2)
#define CMD_SHIFT_STRIP_CHART			        0x6B //Done
#define CMD_SHIFT_STRIP_CHART			0x6B							//Done
//										ref
//										(LSB: scid,
//										 MSB: direction
// (Hardwired to 3 tricolor LEDs)
/*
  LEDS LAYOUT
		LED 1 - Top	GPO 2	GPO 1
		LED 2 - Middle	GPO 4	GPO 3
		LED 3 - Bottom	GPO 6	GPO 5
		Yellow		0	0
		Green		0	1
		Red		1	0
		Off		1	1
		LED 1 - Top     GPO 2   GPO 1
		LED 2 - Middle  GPO 4   GPO 3
		LED 3 - Bottom  GPO 6   GPO 5
		Yellow          0   0
		Green           0   1
		Red             1   0
		Off             1   1
*/
#define CMD_GPO_OFF					0x56 //Done
#define CMD_GPO_OFF						0x56							//Done
//										num[1-6]
#define CMD_GPO_ON					0x57 //Done
#define CMD_GPO_ON						0x57							//Done
//										num[1-6]
#define CMD_STARTUP_GPO_STATE                           0xC3 //Done
#define CMD_STARTUP_GPO_STATE			0xC3							//Done
//										num[1-6]
//										state[0-1]
//										(0: Off,

// KEYPAD
// Default layout:
#define RET_UP						0x42 //Done
#define RET_DOWN					0x48 //Done
#define RET_LEFT					0x44 //Done
#define RET_RIGHT					0x43 //Done
#define RET_CENTER					0x45 //Done
#define RET_TOP						0x41 //Done
#define RET_BOTTOM					0x47 //Done
#define RET_RELEASE_UP					0x62 //Done
#define RET_RELEASE_DOWN				0x68 //Done
#define RET_RELEASE_LEFT				0x64 //Done
#define RET_RELEASE_RIGHT				0x63 //Done
#define RET_RELEASE_CENTER				0x65 //Done
#define RET_RELEASE_TOP					0x61 //Done
#define RET_RELEASE_BOTTOM				0x67 //Done
#define RET_UP							0x42							//Done
#define RET_DOWN						0x48							//Done
#define RET_LEFT						0x44							//Done
#define RET_RIGHT						0x43							//Done
#define RET_CENTER						0x45							//Done
#define RET_TOP							0x41							//Done
#define RET_BOTTOM						0x47							//Done
#define RET_RELEASE_UP					0x62							//Done
#define RET_RELEASE_DOWN				0x68							//Done
#define RET_RELEASE_LEFT				0x64							//Done
#define RET_RELEASE_RIGHT				0x63							//Done
#define RET_RELEASE_CENTER				0x65							//Done
#define RET_RELEASE_TOP					0x61							//Done
#define RET_RELEASE_BOTTOM				0x67							//Done

#define CMD_AUTO_TRANSMIT_KEY_ON		        0x41 //Done
#define CMD_AUTO_TRANSMIT_KEY_OFF		        0x4F //Done
#define CMD_AUTO_TRANSMIT_KEY_ON		0x41							//Done
#define CMD_AUTO_TRANSMIT_KEY_OFF		0x4F							//Done
// (The keypad buffer is reset after 10 key presses)
#define CMD_POLL_KEY					0x26 //Done
#define CMD_POLL_KEY					0x26							//Done
// (Returned code MSB flags 'more than one key press in buffer')

#define RET_NO_KEY					0x00 //Done
#define RET_NO_KEY						0x00							//Done

#define CMD_CLEAR_KEY_BUFFER			        0x45 //Done
#define CMD_DEBOUNCE_TIME				0x55 //Done
#define CMD_CLEAR_KEY_BUFFER			0x45							//Done
#define CMD_DEBOUNCE_TIME				0x55							//Done
//										time[0-255]
//										(6.554ms increments,
//										 Default: 8)
#define CMD_AUTO_REPEAT_MODE			        0x7E //Done
#define CMD_AUTO_REPEAT_MODE			0x7E							//Done
//										mode[0-1]
//										(0: Resend Key,
//										 1: Key Up/Down)
#define CMD_AUTO_REPEAT_OFF				0x60 //Done
#define CMD_CUSTOM_KEYPAD_CODES			        0xD5 //Done
#define CMD_AUTO_REPEAT_OFF				0x60							//Done
#define CMD_CUSTOM_KEYPAD_CODES			0xD5							//Done
//										kdown[See table bellow]
//										(9 bytes)
//										kup[See table bellow]
//FIXME: Report it missing from codes list

// DISPLAY
#define CMD_CLEAR_SCREEN				0x58 //Done
#define CMD_DISPLAY_ON					0x42 //Done
#define CMD_CLEAR_SCREEN				0x58							//Done
#define CMD_DISPLAY_ON					0x42							//Done
//										min[0-90]
#define CMD_DISPLAY_OFF					0x46 //Done
#define CMD_BRIGHTNESS					0x99 //Done
#define CMD_DISPLAY_OFF					0x46							//Done
#define CMD_BRIGHTNESS					0x99							//Done
//										brightness[0-255]
//										(Default: 255)
#define CMD_DEFAULT_BRIGHTNESS			        0x98 //Done
#define CMD_DEFAULT_BRIGHTNESS			0x98							//Done
//										brightness[0-255]
//										(Default: 255)
#define CMD_CONTRAST					0x50 //Done
#define CMD_CONTRAST					0x50							//Done
//										contrast[0-255]
//										(Default: 128)
#define CMD_DEFAULT_CONTRAST			        0x91 //Done
#define CMD_DEFAULT_CONTRAST			0x91							//Done
//										contrast[0-255]
//										(Default: 128)

	CMD_INIT
	CMD_UPLOAD(_FS | _FONT | _BMP)
	(parameters)
                                            (RET_CONFIRM | RET_DECLINE)
	(RET_CONFIRM | RET_DECLINE)
	CMD_CONFIRM
	-------------------Loop Here----------------------------
	NEXT_BYTE
											NEXT_BYTE
	NEXT_BYTE
	(CMD_CONFIRM | CMD_DECLINE)
	-------------------End Loop-----------------------------
*/
//TODO: Implement file transfer protocol

#define RET_CONFIRM					0x01    //
#define RET_DECLINE					0x08    //
#define RET_CONFIRM						0x01							//
#define RET_DECLINE						0x08							//

#define CMD_CONFIRM					0x01    //
#define CMD_DECLINE					0x08    //
#define CMD_CONFIRM						0x01							//
#define CMD_DECLINE						0x08							//

#define CMD_WIPE_FILESYSTEM				0x21,0x59,0x21 //Done
#define CMD_WIPE_FILESYSTEM				0x21,0x59,0x21					//Done
// (Be carefull with this one!)
#define CMD_DELETE_FILE					0xAD //Done
#define CMD_DELETE_FILE					0xAD							//Done
//										type[0-1]
//										(0: Font,
//										 1: Bitmap)
//										 fontid or bitmapid
#define CMD_FREE_SPACE					0xAF //Done
#define CMD_FREE_SPACE					0xAF							//Done

/*
  FREE SPACE RETURN FORMAT
	Free space size (4 bytes LSB to MSB)
*/

#define CMD_DIRECTORY					0xB3 //WIP
#define CMD_DIRECTORY					0xB3							//WIP

/*
  DIRECTORY RETURN FORMAT
		File size MSB (1 byte)
*/

#define CMD_UPLOAD_FS					0xB0 //
#define CMD_UPLOAD_FS					0xB0							//
//										fsimagefile
//										(Must be 16KB)
#define CMD_DOWNLOAD_FILE				0xB2 //WIP
#define CMD_DOWNLOAD_FILE				0xB2							//WIP
//										type[0-1]
//										(0: Font,
//										 1: Bitmap)
//										fontid or bitmapid

#define CMD_MOVE_FILE					0xB4 //Done
#define CMD_MOVE_FILE					0xB4							//Done
//										oldtype[0-1]
//										(0: Font,
//										 1: Bitmap)
//										(0: Font,
//										 1: Bitmap)
//										newid
#define CMD_DUMP_FS					0x30 //WIP
#define CMD_DUMP_FS						0x30							//WIP

/*
  DOWNLOAD_FILE AND DUMP_FS RETURN FORMAT
*/

// Undocumented command! Seems to dump the settings.
#define CMD_DUMP_SETTINGS                               0xD0 //WIP
#define CMD_DUMP_SETTINGS				0xD0							//WIP

// SECURITY
#define CMD_REMEMBER					0x93 //Done
#define CMD_REMEMBER					0x93							//Done
//										value[0-1]
//										(0: Do not remember,
//										 1: Remember)
#define CMD_LOCK_LEVEL					0xCA,0xF5,0xA0 //Done
#define CMD_LOCK_LEVEL					0xCA,0xF5,0xA0					//Done
//										level
//										(Lock bits:
//										 0-2: 	Reserved leave 0,
//										 3: 	Communication speed,
//										 4: 	Settings,
//										 5: 	Filesystem,
//										 6: 	Command,
//										 7: 	Display)
#define CMD_DEFAULT_LOCK_LEVEL			        0xCB,0xF5,0xA0 //Done
//										 0-2:	Reserved leave 0,
//										 3:		Communication speed,
//										 4:		Settings,
//										 5:		Filesystem,
//										 6:		Command,
//										 7:		Display)
#define CMD_DEFAULT_LOCK_LEVEL			0xCB,0xF5,0xA0					//Done
//										level
//										(Lock bits:
//										 0-2: 	Reserved leave 0,
//										 3: 	Communication speed,
//										 4: 	Settings,
//										 5: 	Filesystem,
//										 6: 	Command,
//										 7: 	Display)
//										 0-2:	Reserved leave 0,
//										 3:		Communication speed,
//										 4:		Settings,
//										 5:		Filesystem,
//										 6:		Command,
//										 7:		Display)
//FIXME: Report it missing from codes list
#define CMD_WRITE_CUSTOMER_DATA			        0x34 //Done
#define CMD_WRITE_CUSTOMER_DATA			0x34							//Done
//										data
//										(16B are accessible)
#define CMD_READ_CUSTOMER_DATA			        0x35 //Done
#define CMD_READ_CUSTOMER_DATA			0x35							//Done

/*
  READ_CUSTOMER_DATA RETURN FORMAT
*/

// MISC
#define CMD_VERSION_NUMBER				0x36 //Done
#define CMD_VERSION_NUMBER				0x36							//Done

/*
  VERSION_NUMBER RETURN FORMAT
	Version (1 byte)
	(Represents the version number
	 Hex    Version
	 0x19   1.9
	 0x57   5.7)
	 Hex	Version
	 0x19	1.9
	 0x57	5.7)
*/

#define CMD_MODULE_TYPE					0x37 //Done
#define CMD_MODULE_TYPE					0x37							//Done

/*
  MODULE_TYPE RETURN FORMAT
    Type (1 byte)
	Type (1 byte)
	(One of the following return codes)
*/
#define RET_LCD0821					0x01 //Done
#define RET_LCD2021					0x02 //Done
#define RET_LCD2041					0x05 //Done
#define RET_LCD4021					0x06 //Done
#define RET_LCD4041					0x07 //Done
#define RET_LK202_25					0x08 //Done
#define RET_LK204_25					0x09 //Done
#define RET_LK404_55					0x0A //Done
#define RET_VFD2021					0x0B //Done
#define RET_VFD2041					0x0C //Done
#define RET_VFD4021					0x0D //Done
#define RET_VK202_25					0x0E //Done
#define RET_VK204_25					0x0F //Done
#define RET_GLC12232					0x10 //Done
#define RET_GLC24064					0x13 //Done
#define RET_GLK24064_25					0x15 //Done
#define RET_GLK12232_25					0x22 //Done
#define RET_GLK12232_25_SM				0x24 //Done
#define RET_GLK24064_16_1U_USB			        0x25 //Done
#define RET_GLK24064_16_1U				0x26 //Done
#define RET_GLK19264_7T_1U_USB		        	0x27 //Done
#define RET_GLK12236_16					0x28 //Done
#define RET_GLK12232_16_SM				0x29 //Done
#define RET_GLK19264_7T_1U				0x2A //Done
#define RET_LK204_7T_1U					0x2B //Done
#define RET_LK204_7T_1U_USB				0x2C //Done
#define RET_LK404_AT					0x31 //Done
#define RET_MOS_AV_162A					0x32 //Done
#define RET_LK402_12					0x33 //Done
#define RET_LK162_12					0x34 //Done
#define RET_LK204_25PC					0x35 //Done
#define RET_LK202_24_USB				0x36 //Done
#define RET_VK202_24_USB				0x37 //Done
#define RET_LK204_24_USB				0x38 //Done
#define RET_VK204_24_USB				0x39 //Done
#define RET_PK162_12					0x3A //Done
#define RET_VK162_12					0x3B //Done
#define RET_MOS_AP_162A					0x3C //Done
#define RET_PK202_25					0x3D //Done
#define RET_MOS_AL_162A					0x3E //Done
#define RET_MOS_AL_202A					0x3F //Done
#define RET_MOS_AV_202A					0x40 //Done
#define RET_MOS_AP_202A					0x41 //Done
#define RET_PK202_24_USB				0x42 //Done
#define RET_MOS_AL_082					0x43 //Done
#define RET_MOS_AL_204					0x44 //Done
#define RET_MOS_AV_204					0x45 //Done
#define RET_MOS_AL_402					0x46 //Done
#define RET_MOS_AV_402					0x47 //Done
#define RET_LK082_12					0x48 //Done
#define RET_VK402_12					0x49 //Done
#define RET_VK404_55					0x4A //Done
#define RET_LK402_25					0x4B //Done
#define RET_VK402_25					0x4C //Done
#define RET_PK204_25					0x4D //Done
#define RET_MOS						0x4F //Done
#define RET_MOI						0x50 //Done
#define RET_XBOARD_S					0x51 //Done
#define RET_XBOARD_I					0x52 //Done
#define RET_MOU						0x53 //Done
#define RET_XBOARD_U					0x54 //Done
#define RET_LK202_25_USB				0x55 //Done
#define RET_VK202_25_USB				0x56 //Done
#define RET_LK204_25_USB				0x57 //Done
#define RET_VK204_25_USB				0x58 //Done
#define RET_LK162_12_TC					0x5B //Done
#define RET_GLK240128_25				0x72 //Done
#define RET_LK404_25					0x73 //Done
#define RET_VK404_25					0x74 //Done
#define RET_LCD0821						0x01							//Done
#define RET_LCD2021						0x02							//Done
#define RET_LCD2041						0x05							//Done
#define RET_LCD4021						0x06							//Done
#define RET_LCD4041						0x07							//Done
#define RET_LK202_25					0x08							//Done
#define RET_LK204_25					0x09							//Done
#define RET_LK404_55					0x0A							//Done
#define RET_VFD2021						0x0B							//Done
#define RET_VFD2041						0x0C							//Done
#define RET_VFD4021						0x0D							//Done
#define RET_VK202_25					0x0E							//Done
#define RET_VK204_25					0x0F							//Done
#define RET_GLC12232					0x10							//Done
#define RET_GLC24064					0x13							//Done
#define RET_GLK24064_25					0x15							//Done
#define RET_GLK12232_25					0x22							//Done
#define RET_GLK12232_25_SM				0x24							//Done
#define RET_GLK24064_16_1U_USB			0x25							//Done
#define RET_GLK24064_16_1U				0x26							//Done
#define RET_GLK19264_7T_1U_USB			0x27							//Done
#define RET_GLK12236_16					0x28							//Done
#define RET_GLK12232_16_SM				0x29							//Done
#define RET_GLK19264_7T_1U				0x2A							//Done
#define RET_LK204_7T_1U					0x2B							//Done
#define RET_LK204_7T_1U_USB				0x2C							//Done
#define RET_LK404_AT					0x31							//Done
#define RET_MOS_AV_162A					0x32							//Done
#define RET_LK402_12					0x33							//Done
#define RET_LK162_12					0x34							//Done
#define RET_LK204_25PC					0x35							//Done
#define RET_LK202_24_USB				0x36							//Done
#define RET_VK202_24_USB				0x37							//Done
#define RET_LK204_24_USB				0x38							//Done
#define RET_VK204_24_USB				0x39							//Done
#define RET_PK162_12					0x3A							//Done
#define RET_VK162_12					0x3B							//Done
#define RET_MOS_AP_162A					0x3C							//Done
#define RET_PK202_25					0x3D							//Done
#define RET_MOS_AL_162A					0x3E							//Done
#define RET_MOS_AL_202A					0x3F							//Done
#define RET_MOS_AV_202A					0x40							//Done
#define RET_MOS_AP_202A					0x41							//Done
#define RET_PK202_24_USB				0x42							//Done
#define RET_MOS_AL_082					0x43							//Done
#define RET_MOS_AL_204					0x44							//Done
#define RET_MOS_AV_204					0x45							//Done
#define RET_MOS_AL_402					0x46							//Done
#define RET_MOS_AV_402					0x47							//Done
#define RET_LK082_12					0x48							//Done
#define RET_VK402_12					0x49							//Done
#define RET_VK404_55					0x4A							//Done
#define RET_LK402_25					0x4B							//Done
#define RET_VK402_25					0x4C							//Done
#define RET_PK204_25					0x4D							//Done
#define RET_MOS							0x4F							//Done
#define RET_MOI							0x50							//Done
#define RET_XBOARD_S					0x51							//Done
#define RET_XBOARD_I					0x52							//Done
#define RET_MOU							0x53							//Done
#define RET_XBOARD_U					0x54							//Done
#define RET_LK202_25_USB				0x55							//Done
#define RET_VK202_25_USB				0x56							//Done
#define RET_LK204_25_USB				0x57							//Done
#define RET_VK204_25_USB				0x58							//Done
#define RET_LK162_12_TC					0x5B							//Done
#define RET_GLK240128_25				0x72							//Done
#define RET_LK404_25					0x73							//Done
#define RET_VK404_25					0x74							//Done

//Includes
#include <bitset>       // C++ bit structure
//#include <cc++/common.h>//GNU Common C++
#include <bitset>	// C++ bit structure
//#include <cc++/common.h>	//GNU Common C++

//Namespaces
#ifdef	CCXX_NAMESPACES
#ifdef CCXX_NAMESPACES
using namespace std;
using namespace ost;
#endif
class Moglk
{
	private:
        bool openPort(char * device_ptr = "/dev/ttyS0");
        void configurePort(void);
        void setPortBaudRate(unsigned long int baud_rate);
        void setPortFlowControl(bool state);
		bool openPort(char * device_ptr = "/dev/ttyS0");
		void configurePort(void);
		void setPortBaudRate(unsigned long int baud_rate);
		void setPortFlowControl(bool state);

        void transmit(int * data_ptr);
        bool receive(unsigned char * data_ptr);
        bool receiveFile(int * file_ptr);
		void transmit(int * data_ptr);
		bool receive(unsigned char * data_ptr);
		bool receiveFile(int * file_ptr);

        bool upload(char * data_ptr);
		bool upload(char * data_ptr);

	void send(int * message_ptr);
		void send(int * message_ptr);

	public:
        Moglk();
        ~Moglk();
		Moglk();
		~Moglk();

        bool init(char * device_ptr = "/dev/ttyS0",
                  unsigned long int baud_rate = 0);
		bool init(char * device_ptr = "/dev/ttyS0",
		          unsigned long int baud_rate = 0);

        //int autodetect(void);
		//int autodetect(void);

        //int autodetectPort(void);
		//int autodetectPort(void);

        unsigned long int autodetectBaudRate(char * device_ptr = "/dev/ttyS0");
		unsigned long int autodetectBaudRate(char * device_ptr = "/dev/ttyS0");

        bool setBaudRate(unsigned long int baud_rate = 19200);
		bool setBaudRate(unsigned long int baud_rate = 19200);

        void setFlowControl(bool state = 0,
                            unsigned char full = 0,
                            unsigned char empty = 0);
		void setFlowControl(bool state	= 0,
		                    unsigned char full	= 0,
		                    unsigned char empty	= 0);

        void display(const char text[],
                     unsigned char font = 0,
                     unsigned char x = 255,
                     unsigned char y = 255);
		void display(const char text[],
		             unsigned char font = 0,
		             unsigned char x = 255,
		             unsigned char y = 255);

        void goHome(void);
		void goHome(void);

        void setFont(unsigned char id = 1,
                     unsigned char lm = 0,
                     unsigned char tm = 0,
                     unsigned char csp = 0,
                     unsigned char lsp = 1,
                     unsigned char srow = 64);
		void setFont(unsigned char id = 1,
		             unsigned char lm = 0,
		             unsigned char tm = 0,
		             unsigned char csp = 0,
		             unsigned char lsp = 1,
		             unsigned char srow = 64);

        void setFontMetrics(unsigned char lm = 0,
                            unsigned char tm = 0,
                            unsigned char csp = 0,
                            unsigned char lsp = 1,
                            unsigned char srow = 64);
		void setFontMetrics(unsigned char lm = 0,
		                    unsigned char tm = 0,
		                    unsigned char csp = 0,
		                    unsigned char lsp = 1,
		                    unsigned char srow = 64);

        void setBoxSpace(bool mode = 1);
		void setBoxSpace(bool mode = 1);

        void setAutoScroll(bool mode = 1);
		void setAutoScroll(bool mode = 1);

        void setCursor(unsigned char x,
                       unsigned char y,
                       bool mode = 0);
		void setCursor(unsigned char x,
		               unsigned char y,
		               bool mode = 0);

        void drawMemBmp(unsigned char id = 1,
                        unsigned char x = 0,
                        unsigned char y = 0);
		void drawMemBmp(unsigned char id = 1,
		                unsigned char x = 0,
		                unsigned char y = 0);

        void setDrawingColor(bool color = 1);
		void setDrawingColor(bool color = 1);

        void drawPixel(unsigned char x,
                       unsigned char y,
                       bool color = 1);
		void drawPixel(unsigned char x,
		               unsigned char y,
		               bool color = 1);

        bool drawLine(unsigned char x1,
                      unsigned char y1,
                      unsigned char x2 = 255,
                      unsigned char y2 = 255,
                      bool color = 1);
		bool drawLine(unsigned char x1,
		              unsigned char y1,
		              unsigned char x2 = 255,
		              unsigned char y2 = 255,
		              bool color = 1);

        void drawRectangle(unsigned char x1,
                           unsigned char y1,
                           unsigned char x2,
                           unsigned char y2,
                           bool mode = 0,
                           bool color = 1);
		void drawRectangle(unsigned char x1,
		                   unsigned char y1,
		                   unsigned char x2,
		                   unsigned char y2,
		                   bool mode = 0,
		                   bool color = 1);

        bool initBarGraph(unsigned char x1,
                          unsigned char y1,
                          unsigned char x2,
                          unsigned char y2,
                          unsigned char type = 0,
                          unsigned char id = 0);
		bool initBarGraph(unsigned char x1,
		                  unsigned char y1,
		                  unsigned char x2,
		                  unsigned char y2,
		                  unsigned char type = 0,
		                  unsigned char id = 0);

        bool drawBarGraph(unsigned char value,
                          unsigned char id = 0);
		bool drawBarGraph(unsigned char value,
		                  unsigned char id = 0);

        bool initStripChart(unsigned char x1,
                            unsigned char y1,
                            unsigned char x2,
                            unsigned char y2,
                            unsigned char id = 0);
		bool initStripChart(unsigned char x1,
		                    unsigned char y1,
		                    unsigned char x2,
		                    unsigned char y2,
		                    unsigned char id = 0);

        bool shiftStripChart(bool direction = 0,
                             unsigned char id =0);
		bool shiftStripChart(bool direction = 0,
		                     unsigned char id =0);

        bool setGpo(unsigned char id,
                    bool state);
		bool setGpo(unsigned char id,
		            bool state);

        bool setLed(unsigned char id,
                    unsigned char state);
		bool setLed(unsigned char id,
		            unsigned char state);

        bool ledYellow(unsigned char id);
		bool ledYellow(unsigned char id);

        bool ledGreen(unsigned char id);
		bool ledGreen(unsigned char id);

        bool ledRed(unsigned char id);
		bool ledRed(unsigned char id);

        bool ledOff(unsigned char id);
		bool ledOff(unsigned char id);

        bool startupGpo(unsigned char id,
                        bool state);
		bool startupGpo(unsigned char id,
		                 bool state);

        void setAutoTxKey(bool state);
		void setAutoTxKey(bool state);

        void clearKeyBuffer(void);
		void clearKeyBuffer(void);

        void setDebounce(unsigned char time);
		void setDebounce(unsigned char time);

        void setAutoRepeat(bool mode);
		void setAutoRepeat(bool mode);

        void autoRepeatOff(void);
		void autoRepeatOff(void);

        void clearScreen(void);
		void clearScreen(void);

        bool setBacklight(bool state = 1,
                          unsigned char time = 0);
		bool setBacklight(bool state = 1,
		                  unsigned char time = 0);

        void setBrightness(unsigned char value = 255);
		void setBrightness(unsigned char value = 255);

        void setDefaultBrightness(unsigned char value = 255);
		void setDefaultBrightness(unsigned char value = 255);

        void setContrast(unsigned char value = 128);
		void setContrast(unsigned char value = 128);

        void setDefaultContrast(unsigned char value = 128);
		void setDefaultContrast(unsigned char value = 128);

        void wipeFs(void);
		void wipeFs(void);

        unsigned short int getFreeSpace(void);
		unsigned short int getFreeSpace(void);

        void setRemember(bool mode = 1);
		void setRemember(bool mode = 1);

        void setCustomerData(const char * data);
		void setCustomerData(const char * data);

        void getCustomerData(unsigned char * data);
		void getCustomerData(unsigned char * data);

        unsigned char getVersion(void);
		unsigned char getVersion(void);

        unsigned char getModuleType(void);
		unsigned char getModuleType(void);

        void getDirectory(void);
		void getDirectory(void);

        void deleteFile(bool type,
                        unsigned char id);
		void deleteFile(bool type,
		                unsigned char id);

        int * downloadFile(bool type,
                           unsigned char id,
                           int * file_ptr);
		int * downloadFile(bool type,
		                   unsigned char id,
		                   int * file_ptr);

        int * dumpFs(int * file_ptr);
		int * dumpFs(int * file_ptr);

        int * dumpSettings(int * file_ptr);
		int * dumpSettings(int * file_ptr);

        void moveFile(bool old_type,
                      unsigned char old_id,
                      bool new_type,
                      unsigned char new_id);
		void moveFile(bool old_type,
		              unsigned char old_id,
		              bool new_type,
		              unsigned char new_id);

        void setLock(std::bitset<8> level);
		void setLock(std::bitset<8> level);

        void setDefaultLock(std::bitset<8> level);
		void setDefaultLock(std::bitset<8> level);

        unsigned char pollKey(void);
		unsigned char pollKey(void);

        void setCustomKeyCodes(unsigned char kup_top,
                               unsigned char kup_up,
                               unsigned char kup_right,
                               unsigned char kup_left,
                               unsigned char kup_center,
                               unsigned char kup_bottom,
                               unsigned char kup_down,
                               unsigned char kdown_top,
                               unsigned char kdown_up,
                               unsigned char kdown_right,
                               unsigned char kdown_left,
                               unsigned char kdown_center,
                               unsigned char kdown_bottom,
                               unsigned char kdown_down);
		void setCustomKeyCodes(unsigned char kup_top,
		                       unsigned char kup_up,
		                       unsigned char kup_right,
		                       unsigned char kup_left,
		                       unsigned char kup_center,
		                       unsigned char kup_bottom,
		                       unsigned char kup_down,
		                       unsigned char kdown_top,
		                       unsigned char kdown_up,
		                       unsigned char kdown_right,
		                       unsigned char kdown_left,
		                       unsigned char kdown_center,
		                       unsigned char kdown_bottom,
		                       unsigned char kdown_down);

        void drawBmp(unsigned char x,
                     unsigned char y,
                     unsigned char width,
                     unsigned char height,
                     int * data);
		void drawBmp(unsigned char x,
		             unsigned char y,
		             unsigned char width,
		             unsigned char height,
		             int * data);

        void uploadFont(unsigned char id,
                        unsigned int size,
                        char * data_ptr);
		void uploadFont(unsigned char id,
		                unsigned int size,
		                char * data_ptr);

        void uploadBmp(unsigned char id,
                       unsigned int size,
                       char * data_ptr);
		void uploadBmp(unsigned char id,
		               unsigned int size,
		               char * data_ptr);

        void uploadFs(unsigned int size,
                      char * data_ptr);
		void uploadFs(unsigned int size,
		              char * data_ptr);

}; /* Moglk */
} /* Moglk */

#endif /* #ifndef _MOGLK_H */


Old	New	Code
62	62
63	63
64	64	// COMMUNICATION
65		#define CMD_INIT 0xFE //Done
	65	#define CMD_INIT 0xFE //Done
66	66	// (Must be issued before any command)
67		#define CMD_FLOW_CONTROL_ON 0x3A //Done
	67	#define CMD_FLOW_CONTROL_ON 0x3A //Done
68	68	// full[0-128]
69	69	// (Number of bytes before almost full
70	70	// 0: full)
72	72	// (Number of bytes before almost empty
73	73	// 128: empty)
74	74
75		#define RET_ALMOST_FULL 0xFE //Done
76		#define RET_ALMOST_EMPTY 0xFF //Done
	75	#define RET_ALMOST_FULL 0xFE //Done
	76	#define RET_ALMOST_EMPTY 0xFF //Done
77	77
78		#define CMD_FLOW_CONTROL_OFF 0x3B //Done
	78	#define CMD_FLOW_CONTROL_OFF 0x3B //Done
79	79
80		#define CMD_BAUD_RATE 0x39 //Done
	80	#define CMD_BAUD_RATE 0x39 //Done
81	81	// speed[See table below]
82	82
83		#define BAUD_RATE_9600 0xCF //Done
84		#define BAUD_RATE_14400 0x8A //Done
85		#define BAUD_RATE_19200 0x67 //Done
86		#define BAUD_RATE_28800 0x44 //Done
87		#define BAUD_RATE_38400 0x33 //Done
88		#define BAUD_RATE_57600 0x22 //Done
89		#define BAUD_RATE_76800 0x19 //Done
90		#define BAUD_RATE_115200 0x10 //Done
	83	#define BAUD_RATE_9600 0xCF //Done
	84	#define BAUD_RATE_14400 0x8A //Done
	85	#define BAUD_RATE_19200 0x67 //Done
	86	#define BAUD_RATE_28800 0x44 //Done
	87	#define BAUD_RATE_38400 0x33 //Done
	88	#define BAUD_RATE_57600 0x22 //Done
	89	#define BAUD_RATE_76800 0x19 //Done
	90	#define BAUD_RATE_115200 0x10 //Done
91	91
92		#define BAUD_RATE_DEFAULT BAUD_RATE_19200 //Done
	92	#define BAUD_RATE_DEFAULT BAUD_RATE_19200 //Done
93	93
94		#define CMD_NON_STANDARD_BAUD_RATE 0xA4 //Done
	94	#define CMD_NON_STANDARD_BAUD_RATE 0xA4 //Done
95	95	// speed[12-2047]
96	96	// (2 bytes,
97	97	// LSB then MSB,
101	101	// to communicate)
102	102	/*
103	103	Formula :
104		CrystalSpeed (16MHz)
	104	CrystalSpeed (16MHz)
105	105	speed = --------------------- - 1
106		8 x DesiredBaud
	106	8 x DesiredBaud
107	107	*/
108	108
109	109	// FONTS
124	124	*/
125	125	//TODO: implement font file format
126	126
127		#define CMD_UPLOAD_FONT 0x24 //
	127	#define CMD_UPLOAD_FONT 0x24 //
128	128	// fontid
129	129	// lsbsize
130		// msbsize
	130	// msbsize
131	131	// fontfile
132	132	// (Don't forget to set the new font metrics,
133	133	// see FILESYSTEM file transfer protocol)
134		#define CMD_USE_FONT 0x31 //Done
	134	#define CMD_USE_FONT 0x31 //Done
135	135	// fontid
136		#define CMD_FONT_METRICS 0x32 //Done
	136	#define CMD_FONT_METRICS 0x32 //Done
137	137	// lm
138	138	// (Left Margin: Location in pixels)
139	139	// tm
145	145	// srow
146	146	// (Scroll Row:
147	147	// Y location of last row in pixels)
148		#define CMD_BOX_SPACE_MODE 0xAC //Done
	148	#define CMD_BOX_SPACE_MODE 0xAC //Done
149	149	// value[0-1]
150	150	// (0: Off,
151	151	// 1: On)
152	152
153	153	// TEXT
154		#define CMD_HOME 0x48 //Done
155		#define CMD_CURSOR_POSITION 0x47 //Done
	154	#define CMD_HOME 0x48 //Done
	155	#define CMD_CURSOR_POSITION 0x47 //Done
156	156	// col
157	157	// row
158	158	// (Derived from current font base size)
159		#define CMD_CURSOR_COORDINATE 0x79 //Done
	159	#define CMD_CURSOR_COORDINATE 0x79 //Done
160	160	// x
161	161	// y
162		#define CMD_AUTO_SCROLL_ON 0x51 //Done
163		#define CMD_AUTO_SCROLL_OFF 0x52 //Done
	162	#define CMD_AUTO_SCROLL_ON 0x51 //Done
	163	#define CMD_AUTO_SCROLL_OFF 0x52 //Done
164	164
165	165	// BITMAPS
166	166	/*
168	168	The bitmap is encoded into bytes horizontally
169	169	*/
170	170
171		#define CMD_UPLOAD_BMP 0x5E //Done
	171	#define CMD_UPLOAD_BMP 0x5E //Done
172	172	// bitmapid
173	173	// lsbsize
174		// msbsize
	174	// msbsize
175	175	// bitmapfile
176	176	// (see FILESYSTEM file transfer protocol)
177		#define CMD_DRAW_MEMORY_BMP 0x62 //Done
	177	#define CMD_DRAW_MEMORY_BMP 0x62 //Done
178	178	// bitmapid
179	179	// x
180	180	// y
181		#define CMD_DRAW_BMP 0x64 //Done
	181	#define CMD_DRAW_BMP 0x64 //Done
182	182	// x
183	183	// y
184	184	// width
186	186	// data
187	187
188	188	// BAR GRAPHS & DRAWING
189		#define CMD_DRAWING_COLOR 0x63 //Done
	189	#define CMD_DRAWING_COLOR 0x63 //Done
190	190	// color[0-255]
191		// (0: White,
	191	// (0: White,
192	192	// 1-255: Black)
193		#define CMD_DRAW_PIXEL 0x70 //Done
	193	#define CMD_DRAW_PIXEL 0x70 //Done
194	194	// x
195	195	// y
196		#define CMD_DRAW_LINE 0x6C //Done
	196	#define CMD_DRAW_LINE 0x6C //Done
197	197	// x1
198	198	// y1
199	199	// x2
200	200	// y2
201	201	// (Lines may interpolate differently Left to Right and Right to Left)
202		#define CMD_CONTINUE_LINE 0x65 //Done
	202	#define CMD_CONTINUE_LINE 0x65 //Done
203	203	// x
204	204	// y
205		#define CMD_DRAW_RECTANGLE 0x72 //Done
	205	#define CMD_DRAW_RECTANGLE 0x72 //Done
206	206	// color[0-255]
207		// (0: White,
	207	// (0: White,
208	208	// 1-255: Black)
209	209	// x1
210	210	// y1
211	211	// x2
212	212	// y2
213		#define CMD_DRAW_SOLID_RECTANGLE 0x78 //Done
	213	#define CMD_DRAW_SOLID_RECTANGLE 0x78 //Done
214	214	// color[0-255]
215		// (0: White,
	215	// (0: White,
216	216	// 1-255: Black)
217	217	// x1
218	218	// y1
219	219	// x2
220	220	// y2
221		#define CMD_INITIALIZE_BAR_GRAPH 0x67 //Done
	221	#define CMD_INITIALIZE_BAR_GRAPH 0x67 //Done
222	222	// bgid[0-15]
223	223	// type[0-3]
224	224	// (0: Vertical from bottom,
232	232	// y2
233	233	// (y1<y2)
234	234	// (Beware of overlapping bar graphs)
235		#define CMD_DRAW_BAR_GRAPH 0x69 //Done
	235	#define CMD_DRAW_BAR_GRAPH 0x69 //Done
236	236	// bgid[0-15]
237	237	// value
238	238	// (In pixels)
239		#define CMD_INITIALIZE_STRIP_CHART 0x6A //Done
	239	#define CMD_INITIALIZE_STRIP_CHART 0x6A //Done
240	240	// scid[0-6]
241	241	// x1
242	242	// y1
244	244	// (x1<x2)
245	245	// y2
246	246	// (y1<y2)
247		#define CMD_SHIFT_STRIP_CHART 0x6B //Done
	247	#define CMD_SHIFT_STRIP_CHART 0x6B //Done
248	248	// ref
249	249	// (LSB: scid,
250	250	// MSB: direction
255	255	// (Hardwired to 3 tricolor LEDs)
256	256	/*
257	257	LEDS LAYOUT
258		LED 1 - Top GPO 2 GPO 1
259		LED 2 - Middle GPO 4 GPO 3
260		LED 3 - Bottom GPO 6 GPO 5
261		Yellow 0 0
262		Green 0 1
263		Red 1 0
264		Off 1 1
	258	LED 1 - Top GPO 2 GPO 1
	259	LED 2 - Middle GPO 4 GPO 3
	260	LED 3 - Bottom GPO 6 GPO 5
	261	Yellow 0 0
	262	Green 0 1
	263	Red 1 0
	264	Off 1 1
265	265	*/
266		#define CMD_GPO_OFF 0x56 //Done
	266	#define CMD_GPO_OFF 0x56 //Done
267	267	// num[1-6]
268		#define CMD_GPO_ON 0x57 //Done
	268	#define CMD_GPO_ON 0x57 //Done
269	269	// num[1-6]
270		#define CMD_STARTUP_GPO_STATE 0xC3 //Done
	270	#define CMD_STARTUP_GPO_STATE 0xC3 //Done
271	271	// num[1-6]
272	272	// state[0-1]
273	273	// (0: Off,
276	276
277	277	// KEYPAD
278	278	// Default layout:
279		#define RET_UP 0x42 //Done
280		#define RET_DOWN 0x48 //Done
281		#define RET_LEFT 0x44 //Done
282		#define RET_RIGHT 0x43 //Done
283		#define RET_CENTER 0x45 //Done
284		#define RET_TOP 0x41 //Done
285		#define RET_BOTTOM 0x47 //Done
286		#define RET_RELEASE_UP 0x62 //Done
287		#define RET_RELEASE_DOWN 0x68 //Done
288		#define RET_RELEASE_LEFT 0x64 //Done
289		#define RET_RELEASE_RIGHT 0x63 //Done
290		#define RET_RELEASE_CENTER 0x65 //Done
291		#define RET_RELEASE_TOP 0x61 //Done
292		#define RET_RELEASE_BOTTOM 0x67 //Done
	279	#define RET_UP 0x42 //Done
	280	#define RET_DOWN 0x48 //Done
	281	#define RET_LEFT 0x44 //Done
	282	#define RET_RIGHT 0x43 //Done
	283	#define RET_CENTER 0x45 //Done
	284	#define RET_TOP 0x41 //Done
	285	#define RET_BOTTOM 0x47 //Done
	286	#define RET_RELEASE_UP 0x62 //Done
	287	#define RET_RELEASE_DOWN 0x68 //Done
	288	#define RET_RELEASE_LEFT 0x64 //Done
	289	#define RET_RELEASE_RIGHT 0x63 //Done
	290	#define RET_RELEASE_CENTER 0x65 //Done
	291	#define RET_RELEASE_TOP 0x61 //Done
	292	#define RET_RELEASE_BOTTOM 0x67 //Done
293	293
294		#define CMD_AUTO_TRANSMIT_KEY_ON 0x41 //Done
295		#define CMD_AUTO_TRANSMIT_KEY_OFF 0x4F //Done
	294	#define CMD_AUTO_TRANSMIT_KEY_ON 0x41 //Done
	295	#define CMD_AUTO_TRANSMIT_KEY_OFF 0x4F //Done
296	296	// (The keypad buffer is reset after 10 key presses)
297		#define CMD_POLL_KEY 0x26 //Done
	297	#define CMD_POLL_KEY 0x26 //Done
298	298	// (Returned code MSB flags 'more than one key press in buffer')
299	299
300		#define RET_NO_KEY 0x00 //Done
	300	#define RET_NO_KEY 0x00 //Done
301	301
302		#define CMD_CLEAR_KEY_BUFFER 0x45 //Done
303		#define CMD_DEBOUNCE_TIME 0x55 //Done
	302	#define CMD_CLEAR_KEY_BUFFER 0x45 //Done
	303	#define CMD_DEBOUNCE_TIME 0x55 //Done
304	304	// time[0-255]
305	305	// (6.554ms increments,
306	306	// Default: 8)
307		#define CMD_AUTO_REPEAT_MODE 0x7E //Done
	307	#define CMD_AUTO_REPEAT_MODE 0x7E //Done
308	308	// mode[0-1]
309	309	// (0: Resend Key,
310	310	// 1: Key Up/Down)
311		#define CMD_AUTO_REPEAT_OFF 0x60 //Done
312		#define CMD_CUSTOM_KEYPAD_CODES 0xD5 //Done
	311	#define CMD_AUTO_REPEAT_OFF 0x60 //Done
	312	#define CMD_CUSTOM_KEYPAD_CODES 0xD5 //Done
313	313	// kdown[See table bellow]
314	314	// (9 bytes)
315	315	// kup[See table bellow]
329	329	//FIXME: Report it missing from codes list
330	330
331	331	// DISPLAY
332		#define CMD_CLEAR_SCREEN 0x58 //Done
333		#define CMD_DISPLAY_ON 0x42 //Done
	332	#define CMD_CLEAR_SCREEN 0x58 //Done
	333	#define CMD_DISPLAY_ON 0x42 //Done
334	334	// min[0-90]
335		#define CMD_DISPLAY_OFF 0x46 //Done
336		#define CMD_BRIGHTNESS 0x99 //Done
	335	#define CMD_DISPLAY_OFF 0x46 //Done
	336	#define CMD_BRIGHTNESS 0x99 //Done
337	337	// brightness[0-255]
338	338	// (Default: 255)
339		#define CMD_DEFAULT_BRIGHTNESS 0x98 //Done
	339	#define CMD_DEFAULT_BRIGHTNESS 0x98 //Done
340	340	// brightness[0-255]
341	341	// (Default: 255)
342		#define CMD_CONTRAST 0x50 //Done
	342	#define CMD_CONTRAST 0x50 //Done
343	343	// contrast[0-255]
344	344	// (Default: 128)
345		#define CMD_DEFAULT_CONTRAST 0x91 //Done
	345	#define CMD_DEFAULT_CONTRAST 0x91 //Done
346	346	// contrast[0-255]
347	347	// (Default: 128)
348	348
353	353	CMD_INIT
354	354	CMD_UPLOAD(_FS \| _FONT \| _BMP)
355	355	(parameters)
356		(RET_CONFIRM \| RET_DECLINE)
	356	(RET_CONFIRM \| RET_DECLINE)
357	357	CMD_CONFIRM
358	358	-------------------Loop Here----------------------------
359	359	NEXT_BYTE
360		NEXT_BYTE
	360	NEXT_BYTE
361	361	(CMD_CONFIRM \| CMD_DECLINE)
362	362	-------------------End Loop-----------------------------
363	363	*/
364	364	//TODO: Implement file transfer protocol
365	365
366		#define RET_CONFIRM 0x01 //
367		#define RET_DECLINE 0x08 //
	366	#define RET_CONFIRM 0x01 //
	367	#define RET_DECLINE 0x08 //
368	368
369		#define CMD_CONFIRM 0x01 //
370		#define CMD_DECLINE 0x08 //
	369	#define CMD_CONFIRM 0x01 //
	370	#define CMD_DECLINE 0x08 //
371	371
372		#define CMD_WIPE_FILESYSTEM 0x21,0x59,0x21 //Done
	372	#define CMD_WIPE_FILESYSTEM 0x21,0x59,0x21 //Done
373	373	// (Be carefull with this one!)
374		#define CMD_DELETE_FILE 0xAD //Done
	374	#define CMD_DELETE_FILE 0xAD //Done
375	375	// type[0-1]
376	376	// (0: Font,
377	377	// 1: Bitmap)
378	378	// fontid or bitmapid
379		#define CMD_FREE_SPACE 0xAF //Done
	379	#define CMD_FREE_SPACE 0xAF //Done
380	380
381	381	/*
382	382	FREE SPACE RETURN FORMAT
383	383	Free space size (4 bytes LSB to MSB)
384	384	*/
385	385
386		#define CMD_DIRECTORY 0xB3 //WIP
	386	#define CMD_DIRECTORY 0xB3 //WIP
387	387
388	388	/*
389	389	DIRECTORY RETURN FORMAT
400	400	File size MSB (1 byte)
401	401	*/
402	402
403		#define CMD_UPLOAD_FS 0xB0 //
	403	#define CMD_UPLOAD_FS 0xB0 //
404	404	// fsimagefile
405	405	// (Must be 16KB)
406		#define CMD_DOWNLOAD_FILE 0xB2 //WIP
	406	#define CMD_DOWNLOAD_FILE 0xB2 //WIP
407	407	// type[0-1]
408	408	// (0: Font,
409	409	// 1: Bitmap)
410	410	// fontid or bitmapid
411	411
412		#define CMD_MOVE_FILE 0xB4 //Done
	412	#define CMD_MOVE_FILE 0xB4 //Done
413	413	// oldtype[0-1]
414	414	// (0: Font,
415	415	// 1: Bitmap)
418	418	// (0: Font,
419	419	// 1: Bitmap)
420	420	// newid
421		#define CMD_DUMP_FS 0x30 //WIP
	421	#define CMD_DUMP_FS 0x30 //WIP
422	422
423	423	/*
424	424	DOWNLOAD_FILE AND DUMP_FS RETURN FORMAT
428	428	*/
429	429
430	430	// Undocumented command! Seems to dump the settings.
431		#define CMD_DUMP_SETTINGS 0xD0 //WIP
	431	#define CMD_DUMP_SETTINGS 0xD0 //WIP
432	432
433	433	// SECURITY
434		#define CMD_REMEMBER 0x93 //Done
	434	#define CMD_REMEMBER 0x93 //Done
435	435	// value[0-1]
436	436	// (0: Do not remember,
437	437	// 1: Remember)
438		#define CMD_LOCK_LEVEL 0xCA,0xF5,0xA0 //Done
	438	#define CMD_LOCK_LEVEL 0xCA,0xF5,0xA0 //Done
439	439	// level
440	440	// (Lock bits:
441		// 0-2: Reserved leave 0,
442		// 3: Communication speed,
443		// 4: Settings,
444		// 5: Filesystem,
445		// 6: Command,
446		// 7: Display)
447		#define CMD_DEFAULT_LOCK_LEVEL 0xCB,0xF5,0xA0 //Done
	441	// 0-2: Reserved leave 0,
	442	// 3: Communication speed,
	443	// 4: Settings,
	444	// 5: Filesystem,
	445	// 6: Command,
	446	// 7: Display)
	447	#define CMD_DEFAULT_LOCK_LEVEL 0xCB,0xF5,0xA0 //Done
448	448	// level
449	449	// (Lock bits:
450		// 0-2: Reserved leave 0,
451		// 3: Communication speed,
452		// 4: Settings,
453		// 5: Filesystem,
454		// 6: Command,
455		// 7: Display)
	450	// 0-2: Reserved leave 0,
	451	// 3: Communication speed,
	452	// 4: Settings,
	453	// 5: Filesystem,
	454	// 6: Command,
	455	// 7: Display)
456	456	//FIXME: Report it missing from codes list
457		#define CMD_WRITE_CUSTOMER_DATA 0x34 //Done
	457	#define CMD_WRITE_CUSTOMER_DATA 0x34 //Done
458	458	// data
459	459	// (16B are accessible)
460		#define CMD_READ_CUSTOMER_DATA 0x35 //Done
	460	#define CMD_READ_CUSTOMER_DATA 0x35 //Done
461	461
462	462	/*
463	463	READ_CUSTOMER_DATA RETURN FORMAT
465	465	*/
466	466
467	467	// MISC
468		#define CMD_VERSION_NUMBER 0x36 //Done
	468	#define CMD_VERSION_NUMBER 0x36 //Done
469	469
470	470	/*
471	471	VERSION_NUMBER RETURN FORMAT
472	472	Version (1 byte)
473	473	(Represents the version number
474		Hex Version
475		0x19 1.9
476		0x57 5.7)
	474	Hex Version
	475	0x19 1.9
	476	0x57 5.7)
477	477	*/
478	478
479		#define CMD_MODULE_TYPE 0x37 //Done
	479	#define CMD_MODULE_TYPE 0x37 //Done
480	480
481	481	/*
482	482	MODULE_TYPE RETURN FORMAT
483		Type (1 byte)
	483	Type (1 byte)
484	484	(One of the following return codes)
485	485	*/
486		#define RET_LCD0821 0x01 //Done
487		#define RET_LCD2021 0x02 //Done
488		#define RET_LCD2041 0x05 //Done
489		#define RET_LCD4021 0x06 //Done
490		#define RET_LCD4041 0x07 //Done
491		#define RET_LK202_25 0x08 //Done
492		#define RET_LK204_25 0x09 //Done
493		#define RET_LK404_55 0x0A //Done
494		#define RET_VFD2021 0x0B //Done
495		#define RET_VFD2041 0x0C //Done
496		#define RET_VFD4021 0x0D //Done
497		#define RET_VK202_25 0x0E //Done
498		#define RET_VK204_25 0x0F //Done
499		#define RET_GLC12232 0x10 //Done
500		#define RET_GLC24064 0x13 //Done
501		#define RET_GLK24064_25 0x15 //Done
502		#define RET_GLK12232_25 0x22 //Done
503		#define RET_GLK12232_25_SM 0x24 //Done
504		#define RET_GLK24064_16_1U_USB 0x25 //Done
505		#define RET_GLK24064_16_1U 0x26 //Done
506		#define RET_GLK19264_7T_1U_USB 0x27 //Done
507		#define RET_GLK12236_16 0x28 //Done
508		#define RET_GLK12232_16_SM 0x29 //Done
509		#define RET_GLK19264_7T_1U 0x2A //Done
510		#define RET_LK204_7T_1U 0x2B //Done

Événement, Multimédia, Audiovisuel et Technologies

Browse the code