// ====================================================================
//	MODULE:			CYak.cpp
//
//	DESCRIPTION:	comm port communication for X-Rite DTP
//
//	HISTORY:	17Oct97 code start				< 5:00p- 6:00p> 1hr. CTY
//				21Oct97 12 functions added		< 1:00p- 4:00p> 3hr. CTY
//				26Oct97 all functions			< 3:00p- 6:00p> 3hr. CTY
// ====================================================================

#include <stdio.h>					// for sprintf
#include <windows.h>				// for comm port
#include <iostream.h>				// for cin&cout
#include "CYak.h"						

// --------------------------------------------------------
//		Construction / Destructor
// --------------------------------------------------------
CYak::CYak()
{
	// Change the ReadIntervalTimeout so that
	// ReadFile will return immediately. 
	timeouts.ReadIntervalTimeout =			1000;
	timeouts.ReadTotalTimeoutMultiplier =	0;
	timeouts.ReadTotalTimeoutConstant =		0;
	timeouts.WriteTotalTimeoutMultiplier =  0;
	timeouts.WriteTotalTimeoutConstant =	0;

	// strip definition 

	// Parse information
	Pars = new char[21];

	// strip definition initial

}

CYak::~CYak()
{ 
	// Clear the DTR line
	EscapeCommFunction(comHandle, CLRDTR);
	CloseHandle(comHandle);

	delete Pars;
}

// --------------------------------------------------------
//		Comm port Initialization
// --------------------------------------------------------
int CYak::ComInit(int channel)
{
	ierr = 0;
	char *port;
	port = new char[4];

	if (channel == 1)
		strcpy(port, "COM1");
	else
		strcpy(port, "COM2");

		comHandle = CreateFile(port, GENERIC_READ|GENERIC_WRITE, 
										0, 0, OPEN_EXISTING,
										FILE_ATTRIBUTE_NORMAL, 0);
  
	
	if (comHandle == INVALID_HANDLE_VALUE)
	{
		ierr	= -3;
		return ierr;
	}
	
	success = GetCommState(comHandle, &dcb);			// Get current settings of COMM port 
	BaudSet();
	success = SetCommState(comHandle, &dcb);			// Apply the new COMM port settings

 	if (!success)
	{
		ierr	= -4; 
		return ierr;
	}
	success = SetCommTimeouts (comHandle, &timeouts);
	EscapeCommFunction(comHandle, SETDTR);				// Set the Data Terminal Ready line

	
	// Sent return to DTP 
	str = new char[100];
	strcpy(str, "1BP\r");
	
	ierr = SentCmd();
	
	delete str;
	return ierr;
}



///////////////////////////////////////////////////////////
//////////////// DTP CALLS ////////////////////////////////
///////////////////////////////////////////////////////////


// --------------------------------------------------------
//		2. 1 ddAD			A/D Conversion rate
// --------------------------------------------------------
int CYak::ConvRte(char dd[])
{
	return PileCmd(dd, "AD");
}

// --------------------------------------------------------
//		2.2  bBC			Bar Codes
// --------------------------------------------------------
int CYak::BarCode(int cho)
{
	return PileCmd(cho, "BC");
}

// --------------------------------------------------------
//		2.3  bBP			Beep
// --------------------------------------------------------
int CYak::Beep(int loud)
{
	return PileCmd(loud, "BP");
}

// --------------------------------------------------------
//		2.4  ddBR			Baud Rate
// --------------------------------------------------------
int CYak::BaudRte(char baud[])
{
	return PileCmd(baud, "BR");
}

// --------------------------------------------------------
//		2.5 ddCC			Calibration check tolerance
// --------------------------------------------------------
int CYak::CalbChk(char dd[])
{
	return PileCmd(dd, "CC");
}

// --------------------------------------------------------
//		2.6 CE				Clear Errors
// --------------------------------------------------------
int CYak::CleaErr()
{
	return PileCmd("CE");
}

// --------------------------------------------------------
//		2.7 CF				Configuration
// --------------------------------------------------------
int CYak::Config(char dd[], char aa[])
{
	return PileCmd(dd, aa, "CF");
}

// --------------------------------------------------------
//		2.8 CO				Compensation (DTP51/52 only)
// --------------------------------------------------------
int CYak::Cmpnstn(int a)
{
	return PileCmd(a, "CO");
}

// --------------------------------------------------------
//		2.9 CR				Calibrate Reflection
// --------------------------------------------------------
int CYak::CalRefl()
{
	return PileCmd("CR");
}

// --------------------------------------------------------
//		2.10 CT				Calibrate Transmission
// --------------------------------------------------------
int CYak::CalTran()
{
	return PileCmd("CT");
}

// --------------------------------------------------------
//		2.11 CW				Comparison Window
// --------------------------------------------------------
int CYak::ComWind(int a)
{
	return PileCmd(a, "CW");
}

// --------------------------------------------------------
//		2.12 DL				Disable LCD display
// --------------------------------------------------------
int CYak::KillLCD()
{
	return PileCmd("DL");
}

// --------------------------------------------------------
//		2.13 DP				Define Parse
// --------------------------------------------------------
int CYak::DefPars(char aa[])
{
// set DTP ready for Parse information
	str = new char [10];
	int j = 0;

	j += sprintf(str, aa);
	j += sprintf(str+j, "DP\r");
	ierr = SentCmd();

// are we in sych??
	int eol	= strlen(str);
	int a		= 0;
	int hit	= 0;

	while(a < eol && hit == 0)
	{
		if (str[a] =='*')
			hit = 1;
		a ++;
	}
	delete str;

// sent parse information
	int len = strlen(Pars);
	str = new char[len];

	if (hit == 1)
	{
		strcpy(str, Pars);
		ierr = SentCmd();
	}
	delete str;
	return 0;
}

// --------------------------------------------------------
//		2.14 nnaaDS			Define Strip
// --------------------------------------------------------
int CYak::DefStrp(char nn[], char aa[])
{
// set DTP ready for Strip
	str = new char [10];
	int j = 0;

	j += sprintf(str, nn);
	j += sprintf(str, aa);
	j += sprintf(str+j, "DS\r");
	ierr = SentCmd();

// are we in sych??
	int eol	= strlen(str);
	int a		= 0;
	int hit	= 0;

	while(a < eol && hit == 0)
	{
		if (str[a] =='*')
			hit = 1;
		a ++;
	}
	delete str;

// sent  strip definition
	int len = strlen(StpDef);
	str = new char[len];

	if (hit == 1)
	{
		strcpy(str, StpDef);
		ierr = SentCmd();
	}
	delete str;
	return 0;
}

// --------------------------------------------------------
//		2.15 EL				Enable LCD display
// --------------------------------------------------------
int CYak::AbleLCD()
{
	return PileCmd("EL");
}

// --------------------------------------------------------
//		2.16 bEC			Echo Character
// --------------------------------------------------------
int CYak::EchoChr(int b)
{
	return PileCmd(b, "EC");
}

// --------------------------------------------------------
//		2.17 GG				Gas Gauge
// --------------------------------------------------------
int CYak::GasGage()
{
	return PileCmd("GG");
}

// --------------------------------------------------------
//		2.18 HL				Gas Gauge
// --------------------------------------------------------
int CYak::HueLimt(char rr[], char ll[])
{
	return PileCmd(rr, ll, "HL");
}

// --------------------------------------------------------
//		2.19 JB				Jump to Bit menu
// --------------------------------------------------------
int CYak::BitMenu()
{
	return PileCmd("JB");
}

// --------------------------------------------------------
//		2.20 bIK			Input Keys
// --------------------------------------------------------
int CYak::InptKey(int a)
{
	return PileCmd(a, "IK");
}

// --------------------------------------------------------
//		2.21 ddKR			Keyboard Rate
// --------------------------------------------------------
int CYak::KeybdRt(char dd[])
{
	return PileCmd(dd, "KR");
}

// --------------------------------------------------------
//		2.22 ddKR			Keyboard Rate
// --------------------------------------------------------
int CYak::NxtPtch(char ss[], char pp[])
{
	return PileCmd(ss, pp, "NP");
}

// --------------------------------------------------------
//		2.23 NT				N-factor, Transmission
// --------------------------------------------------------
int CYak::NfctTrn()
{
	return PileCmd("NT");
}

// --------------------------------------------------------
//		2.24 bOK			Output Keys
// --------------------------------------------------------
int CYak::OutpKey(int b)
{
	return PileCmd(b, "OK");
}

// --------------------------------------------------------
//		2.25 dPK			Press Key
// --------------------------------------------------------
int CYak::PresKey(int d)
{
	return PileCmd(d, "PK");
}

// --------------------------------------------------------
//		2.26 dPR			Power-up Reset
// --------------------------------------------------------
int CYak::PowRset(int d)
{
	return PileCmd(d, "PR");
}

// --------------------------------------------------------
//		2.27 ppddPS			Photo Strip (DTP 36 only)
// --------------------------------------------------------
int CYak::PhtoStp(char pp[], char dd[])
{
	return PileCmd(pp, dd, "PS");
}

// --------------------------------------------------------
//		2.28 ddaaRL			Read LCD display
// --------------------------------------------------------
int CYak::ReadLCD(char dd[], char aa[])
{
	return PileCmd(dd, aa, "RL");
}

// --------------------------------------------------------
//		2.29 aaRN			Read Non-volatile memory
// --------------------------------------------------------
int CYak::RedNMem(char aa[])
{
	return PileCmd(aa, "RN");
}

// --------------------------------------------------------
//		2.30 aaRR			Read Register
// --------------------------------------------------------
int CYak::ReadReg(char aa[])
{
	return PileCmd(aa, "RR");
}

// --------------------------------------------------------
//		2.31 bRS			Read Status
// --------------------------------------------------------
int CYak::ReadStt(int b)
{
	return PileCmd(b, "RS");
}

// --------------------------------------------------------
//		2.33 aaSD			Send strip definition
// --------------------------------------------------------
int CYak::SndStpD(char aa[])
{
	return PileCmd(aa, "SD");
}

// --------------------------------------------------------
//		2.34 bSM			Strip Measurement
// --------------------------------------------------------
int CYak::StrpMea(int b)
{
	return PileCmd(b, "SM");
}

// --------------------------------------------------------
//		2.35 aaSP			Send parse information
// --------------------------------------------------------
int CYak::SndParI(char dd[])
{
	return PileCmd(dd, "SP");
}

// --------------------------------------------------------
//		2.36 SV				Software Version
// --------------------------------------------------------
int CYak::SoftVer()
{
	return PileCmd("SV");
}

// --------------------------------------------------------
//		2.37 dSW			Step Wedge
// --------------------------------------------------------
int CYak::StpWedg(int d)
{
	return PileCmd(d, "SW");
}

// --------------------------------------------------------
//		2.38 TS				Transmit Strip
// --------------------------------------------------------
int CYak::TranStp()
{
	return PileCmd("TS");
}

// --------------------------------------------------------
//		2.39 aaWL			Write LCD display
// --------------------------------------------------------
int CYak::WrteLCD(char aa[], char data[])
{
// set DTP ready Write LCD
	str = new char [10];
	int j = 0;

	j += sprintf(str, aa);
	j += sprintf(str+j, "WL\r");
	ierr = SentCmd();

// are we in sych??
	int eol	= strlen(str);
	int a		= 0;
	int hit	= 0;

	while(a < eol && hit == 0)
	{
		if (str[a] =='*')
			hit = 1;
		a ++;
	}
	delete str;

// sent information
	int len = strlen(data);
	str = new char[len];

	if (hit == 1)
	{
		strcpy(str, data);
		ierr = SentCmd();
	}
	delete str;
	return 0;
}

// --------------------------------------------------------
//		2.40 ddddaaWN		Write Non-volatile memory
// --------------------------------------------------------
int CYak::WrtNMem(char dddd[], char aa[])
{
	return PileCmd(dddd, aa, "WN");
}

// --------------------------------------------------------
//		2.41 ddaaWR			Write Register
// --------------------------------------------------------
int CYak::WrteReg(char dd[], char aa[])
{
	return PileCmd(dd, aa, "WR");
}

// --------------------------------------------------------
//		2.42 aaaaWS			Write String (to external RAM)
// --------------------------------------------------------
int CYak::WrteStr(char aaaa[])
{
// set DTP ready 
	str = new char [10];
	int j = 0;

	j += sprintf(str, aaaa);
	j += sprintf(str+j, "WS\r");
	ierr = SentCmd();

// are we in sych??
	int eol	= strlen(str);
	int a		= 0;
	int hit	= 0;

	while(a < eol && hit == 0)
	{
		if (str[a] =='*')
			hit = 1;
		a ++;
	}
	delete str;

// sent information
	int len = strlen(data);
	str = new char[len];

	if (hit == 1)
	{
		strcpy(str, data);
		ierr = SentCmd();
	}
	delete str;
	return 0;
}

// --------------------------------------------------------
//		2.44 dXE			Transmit Errors
// --------------------------------------------------------
int CYak::TranErr(int d)
{
	return PileCmd(d, "XE");
}

// --------------------------------------------------------
//		2.45 XL				Transmit LCD display
// --------------------------------------------------------
int CYak::TranLCD()
{
	return PileCmd("XL");
}


///////////////////////////////////////////////////////////
//////////////// INTERNAL CALLS ///////////////////////////
///////////////////////////////////////////////////////////


// --------------------------------------------------------
//		Pile commands in buffer and call SentCmd()
// --------------------------------------------------------
int CYak::PileCmd(char cmd[])
{
 	int j = 0;

	str = new char [100];
	j += sprintf(str, cmd);
	j += sprintf(str+j, "\r");

	ierr = SentCmd();
	
	delete str;
	return ierr;
}

int CYak::PileCmd(int a, char cmd[])
{
 	int j = 0;

	str = new char [100];
	j += sprintf(str, "%d", a);
	j += sprintf(str+j, cmd);
	j += sprintf(str+j, "\r");

	ierr = SentCmd();
	
	delete str;
	return ierr;
}

int CYak::PileCmd(char aa[], char cmd[])
{
 	int j = 0;

	str = new char [100];
	j += sprintf(str, aa);
	j += sprintf(str+j, cmd);
	j += sprintf(str+j, "\r");

	ierr = SentCmd();
	
	delete str;
	return ierr;
}

int CYak::PileCmd(char aa[], char dd[], char cmd[])
{
 	int j = 0;

	str = new char [100];
	j += sprintf(str, aa);
	j += sprintf(str+j, dd);
	j += sprintf(str+j, cmd);
	j += sprintf(str+j, "\r");

	ierr = SentCmd();
	
	delete str;
	return ierr;
}

// --------------------------------------------------------
//		Read and Write data to buffer
// --------------------------------------------------------
int CYak::SentCmd()
{
	success = WriteFile(comHandle, str, strlen(str), &numWrite, 0);

	if (success)
	{
		Sleep(2000);

		success = ReadFile(comHandle, str, strlen(str), &numRead, 0);
		
		if (success)
		{
			ErrChk();
			PrntOut();
			return 0;
		}
		else
			return -2;
	}
	else
		return -1;
}
/*int CYak::SentCmd()
{
	success = WriteFile(comHandle, str, strlen(str), &numWrite, 0);

	if (success)
	{
		char *buffer;
		int j = 0;
		numRead = 0;
		buffer = new char[100];


		while(buffer[numRead-1] != 62)		// carriage return
		{
			ReadFile(comHandle, buffer, 100, &numRead, 0);		
			for (int a = j; a < j+(int)numRead; a ++)
				str[a] = buffer[a-j];

			j+=numRead;				
		}
		delete buffer;
		numRead = j;

		PrntOut();
	} 
	else										
		return -1;

	return 0;
}*/

// --------------------------------------------------------
//		Check error returned by DTP
// --------------------------------------------------------
void CYak::ErrChk()
{
/*
	int cnt = 0;
	for (int a = 0; a < strlen(str); a ++)				// find # of return errors
	{
		if (str[a] == '>')
			cnt ++;
	}

	char *errlst;
	errlst = new char[cnt * 2];							// record the list of errors

	for (a = 0; a < strlen(str); a ++)
	{
		if (str[a] == '>')
		{
			errlst[b] = str[a-2];
			errlst[b+1] = str[a-1];
			b += 2;
		}
	}

	for (a = 0; a < strlen(errlst); a +=2)
	{
*/
}

// --------------------------------------------------------
//		Print buffer to screen
// --------------------------------------------------------
void CYak::PrntOut()
{
	// Print the string received
	cout	<< "number of chars read:\t" <<numRead << endl;
	str[numRead] = '\0';
	cout	<< "reply from DTP:\t\t" << str << endl;
	cout	<< "\n";
}

// --------------------------------------------------------
//		Modify baud rate and strip definition
// --------------------------------------------------------
void CYak::BaudSet()
{
	// Modify the baud rate, etc.
	dcb.BaudRate =		19200;
	dcb.ByteSize =		8;
	dcb.Parity =		NOPARITY;
	dcb.StopBits =		ONESTOPBIT;
}

// --------------------------------------------------------
//		Strip definition
// --------------------------------------------------------
void CYak::StrpDef()
{
	int j = 0;
/*
	j += sprintf(str, aaaaaaa);
	j += sprintf(str+j, "%d", b);
	j += sprintf(str+j, ccc);
	j += sprintf(str+j, dd);
	j += sprintf(str+j, "%d", e);
	j += sprintf(str+j, "%d", f);
	j += sprintf(str+j, gg);
	j += sprintf(str+j, hhh);
	j += sprintf(str+j, "%d", i);
	j += sprintf(str+j, "\r");
*/
}