eDosStation/EpdBase/EpdBase.cpp

#include "stdafx.h"
#pragma unmanaged
#include "EpdBase.h"
#include "TimeFunctions.h"
#define DiscoveryTimeslotPeriod 500
#define DiscoveryExpirationPeriod  6000
#define RxRetryCount 5
#define TxRetryCount 5
#pragma unmanaged

void EpdBase::Epd2U::CancelAll()
{
	SetEvent(hCancel);
	//Cancel(epdComsHandle);
}
void EpdBase::Epd2U::test()
{
	const char* msg = "Processing step test...";
	if (progressCallback) {
		progressCallback(StepTest, EPDStepResult); // Triggers the callback
	}
}

EpdBase::Epd2U::Epd2U(int comport)
{
	port = comport;
	CommsInitialized = 0; 
	isBG = isNG = VersionOK = hasAlarm = false;
	maxDiscoverTime = 10000;
	hWaitTimer = CreateWaitableTimer(NULL, TRUE, NULL);
	hCancel = CreateWaitableTimer(NULL, TRUE, NULL);
	if (port == 0) return;
	SetAutoCommit(0);
	Error = 123;
	//SetTimeouts(port, 20, 1000, 1000);
}
WORD EpdBase::Epd2U::WriteConfig()
{
	if (port == 0 ) return 1;
	return WriteDisplayConfig(00,2,40,10, 2,displayConfig, 56);
}
DWORD EpdBase::Epd2U::StartCom()
{
	DWORD rv;
	ErrorReason = 0;
	ErrorSource = 0;
	int mx = 10;
	if (port == 0) {
		CommsInitialized = 1;
		return 1;
	}
	if (CommsInitialized == 0)
		do {
			mx--;
			InitRv = InitComms(port, 9600, 8, 0, 0);  //1=success
			if (InitRv == 0) {
				rv = GetErrorDetails(&ErrorSource, &ErrorReason, &ErrorData);
				Sleep(400); //DeinitComms(port);
			}
			else {
				SetRetryCounts(RxRetryCount, TxRetryCount);
				SetDiscoveryTimeslotPeriod(port, DiscoveryTimeslotPeriod);
				SetDiscoveryTimeslotCount(port, 1);
				SetDiscoveryExpirationPeriod(port, DiscoveryExpirationPeriod);
			}
		} while (InitRv == 0 && mx > 0);

		if (InitRv == 0) { ErrorReason = 1; CommsInitialized = 0; }
		else { ErrorReason = 0; CommsInitialized = 1; }
		isBG = isNG = VersionOK = hasAlarm = false;
		return ErrorReason;
}
void EpdBase::Epd2U::EndCom()
{
	if (port > 0 && CommsInitialized == 1) {
		DeinitComms(port);
		
		Sleep(300);
	}
	CommsInitialized = 0;
}
EpdBase::Epd2U::~Epd2U()
{
	EndCom();
}

bool EpdBase::Epd2U::isCancelled()
{
	return WaitForSingleObject(hCancel, 0) == WAIT_OBJECT_0;
}


int EpdBase::Epd2U::StartDiscover( int EpdTimeoutms)
{
	ResetEvent(hCancel);
	EPDStep = StepDiscovering;

	maxDiscoverTime = EpdTimeoutms;
	if (port == 0) {
		DeviceCount = 1;
		DeviceIDs[0] = 768;
		return 1;
	} 
	DiscRV = 0;
	ConnectTries = 0; ConnectTimerFired = 0;
	if (CommsInitialized == 1 && hWaitTimer != nullptr) {
		FlushDiscoveryCache(port);
		FlushBuffers(port);
		
		Error = 0; 
		int maxtries = 100; DeviceCount = 0; DiscRV = 1; DWORD wo = 1;  // ongeveer 43 tries in 10 seconden
		CancelWaitableTimer(hWaitTimer);
		LARGE_INTEGER wt; //100 nanoseconds *10000 = millisec
		//union { LARGE_INTEGER li; FILETIME ft; LONGLONG ll; } t1, t2;
		//wt.QuadPart = -300000000LL;
		INT64 t = maxDiscoverTime; t *= (INT64)-10000;
		wt.QuadPart = t; // Int32x32To64(maxDiscoverTime, -10000); //15 seconden proberen
		SetWaitableTimer(hWaitTimer, &wt, 0, NULL, NULL, 0);
		while (DeviceCount == 0 && wo != 0 && !isCancelled()) //tries-- > 0 && 
		{
			ConnectTries++;
			DiscRV = Discover(port, DeviceIDs, MaxDevices, &DeviceCount);
			if (DiscRV == 0) {
				Error = GetErrorDetails(&ErrorSource, &ErrorReason, &ErrorData);
			}
			else {
				HANDLE handles[2];
				handles[0] = hWaitTimer;
				handles[1] = hCancel;

				wo = WaitForMultipleObjects(2, handles, false, 100);
				if (wo == 0) { ConnectTimerFired = 1; DiscRV = 1; EPDStepResult = EpdStepResults::OK; }
				else if (wo == 1) { //Cancelled
					DiscRV = 0; EPDStepResult = EpdStepResults::Error; }
				else {
					DiscRV = 0; EPDStepResult = EpdStepResults::Error;
				}
			}
		}
		CancelWaitableTimer(hWaitTimer);
		
	}
	if (progressCallback) progressCallback(EPDStep, EPDStepResult);
	return DiscRV;
}

/// <summary>
/// 
/// </summary>
/// <param name="DeviceID"></param>
/// <returns>0 OK</returns>
int EpdBase::Epd2U::Open(DWORD DeviceID)
{
	int rv = 0;
	CurrentDeviceID = DeviceID;
	if (port > 0 && CommsInitialized==1) {
		ConRV = Connect(DeviceID);
		if (ConRV == 0) Error = GetErrorDetails(&ErrorSource, &ErrorReason, &ErrorData);
		else {
			OpenRV = OpenDevice(port, CurrentDeviceID);
			if (OpenRV == 0) rv=Error = GetErrorDetails(&ErrorSource, &ErrorReason, &ErrorData);
		}
	}
	else { OpenRV = ConRV = 1; rv = 0; }
	return rv;
}
void EpdBase::Epd2U::Close(WORD doEndCom)
{
	if (port > 0 && CurrentDeviceID>0) CloseDevice();
	CurrentDeviceID = 0;
	FlushBuffers(port);
	if (doEndCom) EndCom();
}
int  EpdBase::Epd2U::CloseAndSignal(WORD EndSessionControl, WORD duration, WORD doEndCom)
{
	int rv = 0;
	WORD r;
	Sleep(250);
	r = EndSession(EndSessionControl, duration);
	if (r == 1) rv = 0;  else rv = 1;
	Close( doEndCom);
	return rv;
}
void EpdBase::Epd2U::DecodeFunctionFlags()
{
	EpdType = (FunctionFlags & 0x1F00) >> 8;
	//0=BG 3=Neutron  4=BG Mk3 7=Neutron Mk4
}
void EpdBase::Epd2U::DecodeStatus()
{
	hasAlarm = hasFault = false;
	DetectorsOn = (OperatingStatus & 1) != 0;
	EPDIssued  = (OperatingStatus & 4) != 0;
	EPDLocked = (OperatingStatus & 0x10)!=0;
	EPDTesting = (OperatingStatus & 0x20) != 0;
	EPDProcSec = (OperatingStatus & 0x40) != 0;
	EPDFaulty = (OperatingStatus & 0x80) != 0;

	EPDNewFault = (ErrorStatus & 1) != 0;
	EPDComFault = (ErrorStatus & 2) != 0;
	EPDCalFault = (ErrorStatus & 4) != 0;
	EPDDetFault = (ErrorStatus & 8) != 0;
	EPDEprFault = (ErrorStatus & 0x10) != 0;
	EPDTrhFault = (ErrorStatus & 0x20) != 0;
	EPDOthFault = (ErrorStatus & 0x80) != 0;

	AlarmDoseHP101G = (AlarmStatus & 1) != 0;
	AlarmDoseHP102G = (AlarmStatus & 2) != 0;
	AlarmDoseHP07N = (AlarmStatus & 4) != 0;
	AlarmRateHP101G = (AlarmStatus & 8) != 0;;
	AlarmRateHP102G = (AlarmStatus & 0x10) != 0;
	AlarmRateHP07N = (AlarmStatus & 0x20) != 0;

	//OtherAlarm
	OtherAlarmRateHp101G = (OtherAlarms & 1) != 0;
	OtherAlarmRateHp102G = (OtherAlarms & 2) != 0;
	OtherAlarmRateHp07N = (OtherAlarms & 4) != 0;
	OtherAlarmReturn = (OtherAlarms & 8) != 0;
	OtherAlarmBatLow =  (OtherAlarms & 0x10) != 0;
	OtherAlarmCarrier = (OtherAlarms & 0x20) != 0;
	OtherAlarmBatVolt = (OtherAlarms & 0x40) != 0;

	//New fields
	eDosDose07Alarm = AlarmDoseHP07N;
	eDosDose07Warning = eDosDose07Alarm;
	eDosDose10Warning = AlarmDoseHP101G;
	eDosDose10Alarm = AlarmRateHP102G;
	eDosRate07Alarm = OtherAlarmRateHp07N || AlarmRateHP07N;
	eDosRate07Warning = eDosRate07Alarm;
	eDosRate10Warning = OtherAlarmRateHp101G || AlarmRateHP101G;
	eDosRate10Alarm = OtherAlarmRateHp102G || AlarmRateHP102G;
	eDosBatteryWarning = OtherAlarmBatLow || OtherAlarmBatVolt;

	if (!VersionOK) OtherAlarms &= 0x7f;
	
	eDosDoseAlarm = eDosDose07Alarm || eDosDose10Alarm;
	eDosRateAlarm = eDosRate07Alarm || eDosRate10Alarm;

	hasAlarm = (eDosRateAlarm || eDosDoseAlarm);
	hasFault = ((OtherAlarms & 0xf8) != 0) || ((OperatingStatus & 0x80) != 0) || (ErrorStatus != 0);

	StatusDecoded = true;
}

/// <summary>
/// 
/// </summary>
/// <returns>0 = ok</returns>
WORD EpdBase::Epd2U::ReadStatus()
{
	int  rv = 0;
	EPDStep = StepReadStatus;
	EPDStepResult = EpdStepResults::Started;
	Error = 0; ReadStatusRV = 0;
	memset(WearerID, 0, WearerIDLength + 1);
	memset(WearerName, 0, WearerNameLength + 1);

	IssueCount = OperatingStatus = ErrorStatus = AlarmStatus = OtherAlarms = EEPROMBadSectors = 0;
	RealTime = EpdClock = OffTime = EpdID = 0;
	ErrorSource = ErrorReason = ErrorData = 0;
	HardVersion = HardVersionMinor= SoftVersion = FunctionFlags = 0;

	if (port == 0) {
		EpdID = 4567;
		EpdType = 0;
		FunctionFlags = 0x000;
		return 0;
	}

	RealTime = UnixTimeNow();
	CommitRV = ReadEpdStatus(&EpdClock, &RealTime, &IssueCount, &OffTime, &OperatingStatus, &ErrorStatus, &AlarmStatus, &OtherAlarms, &EEPROMBadSectors);
	StatusDecoded = false;
	if (port == 0) {
		EpdClock = 123; ErrorStatus = 0;
	};
	ErrorStatus &= 0xff;
	OperatingStatus &= 0xff;
	//RealTime The number of seconds since January 1st, 1970 according to	your system time
	if (CommitRV == 1) CommitRV = Commit();

	if (CommitRV == 1) CommitRV = ReadEpdID(
		&EpdID,
		&HardVersion,
		&SoftVersion,
		&FunctionFlags);
	if (CommitRV == 1) CommitRV = Commit();
	if (CommitRV == 0) {
		Error = GetErrorDetails(&ErrorSource, &ErrorReason, &ErrorData);
		ReadStatusRV = ErrorReason;
		rv = ErrorReason;
		EPDStepResult = EpdStepResults::Error;
		return rv;
	}
	else {
		EPDStepResult = EpdStepResults::OK;
		CurrentDeviceID = EpdID;
		time_t t = RealTime;
		TimeFunctions::UnixTimeToSystemTime(t, &tRealTime);
		DecodeStatus();
		DecodeFunctionFlags();
	}

	byte ff = (FunctionFlags >> 8) & 0x0f;
	isBG = ff == 0;
	isNG = ff == 3;
	VersionOK = (isBG && SoftVersion >= 11) || (isNG && SoftVersion >= 3);

	if (CommitRV == 1) {
		if (EPDIssued == 1) {
			CommitRV = ReadWearer(
				WearerID,
				WearerIDLength,
				WearerName,
				WearerNameLength);
			if (CommitRV == 1) CommitRV = Commit();

			if (CommitRV == 0) {
				Error = GetErrorDetails(&ErrorSource, &ErrorReason, &ErrorData);
				rv = ReadStatusRV = ErrorReason;
				return rv;
			}
		}
		else memset(WearerID, 0xb, WearerIDLength);
		rv = 0;
		for (int i = 0; i < WearerIDLength; i++)
			if (WearerID[i] == 0xb) WearerID[i] = '0'; else  WearerID[i] |= 0x30;
	 }
	if (progressCallback) progressCallback(EPDStep,	 EPDStepResult);
	return rv;
}
/// <summary>
/// 
/// </summary>
/// <returns>0 ok</returns>
WORD EpdBase::Epd2U::EPDReadExtraStatus()
{
	int rv = 0;
	if (port == 0) return 1;

	byBatADC = bySupplyADC = 0;
	/*CommitRV = ReadA2ConfigStatus(
		&byBatADC,
		&bySupplyADC,
		&byStatus3,
		&byStatus4);
	if (CommitRV == 1) CommitRV = Commit();*/
	if (CommitRV == 1) CommitRV = ReadCounts(&D1, &D2, &D3, &D4, &CountsClock);
	if (CommitRV == 1) CommitRV = Commit();
	if (CommitRV == 1) CommitRV = ReadBaseCounts(&BaseD1, &BaseD2, &BaseD3, &BaseD4, &BaseCountsClock);
	if (CommitRV == 1) CommitRV = Commit();
	if (CommitRV == 1) rv = 0;
	else {
		Error = GetErrorDetails(&ErrorSource, &ErrorReason, &ErrorData);
		rv = ErrorReason;
	}
	return rv;
}
WORD EpdBase::Epd2U::EPDReadConfig()
{
	if (port == 0) return 1;

	ReadConfigRV = ReadConfig(
		&CountDownTime,
		&ReturnTime,
		&ChirpRate,
		&TeleBaudSetting,
		&SelfTestInterval,
		&BatteryLoadTestInt,
		&GeneralControl,
		&CommsTimeout,
		&InhibitTimeout,
		&MinTxInterval,
		&MaxTxIntervals,
		&RandomiseWindow,
		&DoseIncThresh);
	if (ReadConfigRV == 0) Error = GetErrorDetails(&ErrorSource, &ErrorReason, &ErrorData);
	CommitRV = Commit();
	if (CommitRV == 0) Error = GetErrorDetails(&ErrorSource, &ErrorReason, &ErrorData);
	return CommitRV;
}

/// <summary>
/// 
/// </summary>
/// <returns>0=ok</returns>
WORD EpdBase::Epd2U::WriteCal()
{
	int rv = 1;
	CommitRV = 0;
	if (port == 0 ) return 0;
	if (isBG) return 1;
	if (K6 > 2000) return 1;
	Password = 9;
	//((BYTE *)&Password)[0] = 9;
	
	CommitRV = MFRLogin(Password);
	if (CommitRV == 1) CommitRV = Commit();
	if (CommitRV == 1) CommitRV = MFRWriteCalFactors(K1, K2, K3, K4, K5, K6);
	if (CommitRV == 1) CommitRV = Commit();
	if (CommitRV == 0) Error = GetErrorDetails(&ErrorSource, &ErrorReason, &ErrorData);
	else rv = 0; //ok
	return rv;
}

WORD EpdBase::Epd2U::ReadCal()
{
	ReadCalibrationDataRV = ReadCalibrationData(
		&K1,
		&K2,
		&K3,
		&K4,
		&K5,
		&K6,
		&SG,
		&BC,
		&FB,
		&HG);
	CommitRV = Commit();
	if (CommitRV == 0) Error = GetErrorDetails(&ErrorSource, &ErrorReason, &ErrorData);
	if (CommitRV == 1) return 0; else return 123;
}
/// <summary>
/// 
/// </summary>
/// <returns>0 Success</returns>
WORD EpdBase::Epd2U::ReadTresHolds()
{
	int rv =0;
	if (port == 0) {
		Hp10THDose1 = Hp10THDose2 = Hp10THDose2 = 123;
		Hp10Rate1On = Hp10Rate2On = Hp07RateOn = Hp10Rate1Off = Hp10Rate2Off = Hp07RateOff = 124;
		return 1;
	}
	Hp10THDose1 = Hp10THDose2 = Hp07THDose = 0;
	ReadDoseTresholdRV = ReadAlarmDoseThresholds(&Hp10THDose1, &Hp10THDose2, &Hp07THDose);
	CommitRV = Commit();
	if (CommitRV == 0) rv = Error = GetErrorDetails(&ErrorSource, &ErrorReason, &ErrorData);

	if (rv == 0) {
		ReadAlarmRateThresholdsRV = ReadAlarmRateThresholds(
			&Hp10Rate1On,
			&Hp10Rate2On,
			&Hp07RateOn,
			&Hp10Rate1Off,
			&Hp10Rate2Off,
			&Hp07RateOff);
		CommitRV = Commit();
		if (CommitRV == 0) rv = Error = GetErrorDetails(&ErrorSource, &ErrorReason, &ErrorData);
	}
	if (rv==0)	rv = ReadCal();
	return rv;
}

WORD EpdBase::Epd2U::ClearAlarms()
{
	int rv = 0;
	if (port == 0) return 0;
	if (CommitRV) CommitRV = ClearFaultFlags();
	if (CommitRV) CommitRV = ClearLatchedAlarms();
	if (CommitRV) rv = 0; else rv = 1;
	return rv;
}

/// <summary>
/// 
/// </summary>
/// <returns>0 OK</returns>
WORD EpdBase::Epd2U::ReadDoses()
{
	Hp10FTime = Hp07FTime = 0UL;
	if (port == 0) {
		Hp10Dose = Hp07Dose = Hp10Total = Hp07Total = Knocks = Resets = QualityData = 21;
		Hp10Peak = Hp07Peak = Hp10Time = Hp07Time = 1000;
		eDosDose07Warning = eDosDose07Alarm = eDosDose10Warning = eDosDose10Alarm = eDosRate07Warning = eDosRate07Alarm = eDosRate10Warning = eDosRate10Alarm = eDosBatteryWarning = eDosDoseAlarm = eDosRateAlarm   = 0;
		ErrorSource = ErrorReason = ErrorData = 0;
		K1 = 1; K2 = 2; K3 = 3; K4 = 4; K5 = 5;  K6 = 6;
		SG = 7; BC = 8; FB = 9; HG = 10;
		return 1;
	}
	ReadDosesQualityRV = ReadPeaksRV = CommitRV = 0;
	ReadDosesQualityRV = ReadDosesQuality(
			&Hp10Dose, 
			&Hp07Dose,
			&Hp10Total, 
			&Hp07Total,
			&Knocks, 
			&Resets,
			&QualityData);

	if (ReadDosesQualityRV == 0) {
		Error = GetErrorDetails(&ErrorSource, &ErrorReason, &ErrorData);
		return 0;
	}

	QualityData &= 0x7f;

	ReadPeaksRV = ReadPeaks(
		&Hp10Peak,
		&Hp07Peak,
		&Hp10Time, //EpdClock of Occurence
		&Hp07Time);
	if (ReadPeaksRV == 0) {
		Error = GetErrorDetails(&ErrorSource, &ErrorReason, &ErrorData);
		return 0;
	}
	CommitRV = Commit();
	if (CommitRV == 0) Error = GetErrorDetails(&ErrorSource, &ErrorReason, &ErrorData);

	TimeFunctions::EPD2PeakTimeToFiletime(EpdClock, Hp10Time, (LPFILETIME)&Hp10FTime);
	TimeFunctions::EPD2PeakTimeToFiletime(EpdClock, Hp07Time, (LPFILETIME)&Hp07FTime);

	ReadCalibrationData(
		&K1,
		&K2,
		&K3,
		&K4,
		&K5,
		&K6,
		&SG,
		&BC,
		&FB,
		&HG);
	CommitRV = Commit();
	if (CommitRV == 0) Error = GetErrorDetails(&ErrorSource, &ErrorReason, &ErrorData);
	return CommitRV==1 ? 0 : 1;
}
WORD EpdBase::Epd2U::PrepareForIssue() 
{
	int rv = 0;
	if (port == 0) return 0;
	
	EPDStep = StepPrepareIssue;
	EPDStepResult = EpdStepResults::Started;

	CommitRV = WriteConfig();
	CommitRV = 0;
	ClearAlarms();
	Commit();
	//if (CommitRV) CommitRV = Commit();
	if (CommitRV) CommitRV = ClearDose();
	if (CommitRV) CommitRV = ClearTotalDose();
	if (CommitRV) CommitRV = ClearPeakRates();
	if (CommitRV) CommitRV = Commit();
	if (CommitRV) rv = 0; else rv = 1;
	EPDStepResult = EpdStepResults::OK;
	if (progressCallback) {
		progressCallback(EPDStep, EPDStepResult);
	}
	return rv;
}
/// <summary>
/// DeIssue and close
/// </summary>
/// <returns></returns>
WORD EpdBase::Epd2U::DeIssue(WORD doEndCom)
{
	int rv = 0;
	ClearDoseRV = ClearTotalDoseRV = ClearPeakRatesRV = DeIssueEpdRV = 0;
	if (port == 0) return 1;
	if (CommitRV) CommitRV = ClearDose();
	if (CommitRV) CommitRV = ClearTotalDose();
	if (CommitRV) CommitRV = ClearPeakRates();
	if (CommitRV) CommitRV = Commit();
	if (CommitRV) CommitRV = ClearFaultFlags();
	if (CommitRV) CommitRV = ClearLatchedAlarms();//Hp10Rate1; Hp10Rate2; Hp07Rate; ReturnForRead
	if (CommitRV) CommitRV = Commit();
	CommitRV = ClearFailFlag();
	if (CommitRV && EPDIssued) {
		CommitRV = DeIssueEpd();
		if (CommitRV) CommitRV = Commit();
	}
	if (CommitRV && DetectorsOn ) {
		CommitRV = EpdOff();  
		CommitRV= Commit(); 
		if (!VersionOK) Sleep(1000);// Versie < .. Commit & Sleep
	}
	
	if (CommitRV ) {
		CloseAndSignal(EndSessionControl, 12, doEndCom);
		rv = 0;
	}
	else
	{
		FlushBuffers(port);
		Error = GetErrorDetails(&ErrorSource, &ErrorReason, &ErrorData); 
		CloseAndSignal(EndSessionControl, 40,doEndCom);
		rv = ErrorReason;
	}
	return rv;
}
/// <summary>
/// 
/// </summary>
/// <returns>O = OK</returns>
WORD EpdBase::Epd2U::Issue(WORD doEndCom)
{
	int rv=0;
	IssueEpdRV = WriteAlarmDoseThresholdsRV = WriteAlarmRateThresholdsRV = WriteWearerNameRV = OnRV = CommitRV = 0;
	if (port == 0) return 0;
	WORD OKRV = SetFailFlag(); // all actions have been completed
	if (OKRV) OKRV = Commit();
	if (OKRV) OKRV = BaseLineCounts();
	if (OKRV) OKRV = WriteAlarmDoseThresholds(Hp10THDose1, Hp10THDose2, Hp07THDose);
	if (OKRV) OKRV = WriteAlarmRateThresholds(Hp10Rate1On, Hp10Rate2On, Hp07RateOn, Hp10Rate1Off, Hp10Rate2Off, Hp07RateOff);
	if (OKRV) OKRV = Commit();
	if (OKRV) OKRV = IssueEpd(WearerID, WearerIDLength);
	if (OKRV) OKRV = Commit();
	if (OKRV) OKRV = WriteWearerName(WearerName,(WORD)strlen((char *)WearerName));
	if (OKRV) OKRV = Commit();
	
	if (OKRV == 0)
	{
		Error = GetErrorDetails(&ErrorSource, &ErrorReason, &ErrorData);
		rv = 1;
	}
	else 
		EPDIssued = 1;
	ClearFailFlag(); // all actions have been completed

	
	if (OKRV) 
	{
		if (!DetectorsOn) {
			OKRV = EpdOn();
			OKRV = Commit();
			if (!VersionOK) Sleep(1500);
		}
		CloseAndSignal(EndSessionControl, 12, doEndCom);
		rv = 0;
	}
	else 
	{ 
		FlushBuffers(port);
		Error = GetErrorDetails(&ErrorSource, &ErrorReason, &ErrorData); 
		CloseAndSignal(EndSessionControl, 40, doEndCom);
		rv = 1;
	}
	return rv;
}

//main exit function
//does endcom at end
int EpdBase::Epd2U::GetAllDeissue()
{
	int rv = 0;
	rv = ReadDoses();	  //0 = success
	//rv = ReadTresHolds(); //tresholds not needed, only doses
	rv = EPDReadExtraStatus();
	rv = DeIssue(true); //does close
	return rv;
}


//main get dos function
//does endcom at end
int EpdBase::Epd2U::GetAll(bool Closeconnection)
{
	int rv = 0;
	rv = ReadDoses();	  //0 = success
	rv = ReadTresHolds(); //0 = success Tresholds needed
	if (Closeconnection) Close(1);
	return rv;
}

/// <summary>
/// discover, connect and read status
/// </summary>
/// <param name="tokenSourceTimeout"></param>
/// <returns>0=success 1=connect error,  2 = no devices, 3= error reading status</returns>
int EpdBase::Epd2U::ConnectAndStatus(int tokenSourceTimeoutms)
{
	WORD dllStatus;
	int rv = 1;
	if (CommsInitialized == 0) StartCom();
	if (CommsInitialized == 0) rv = 1;
	else {
		dllStatus = StartDiscover(tokenSourceTimeoutms);
		if (dllStatus != 1) rv = 1; //Connect error
		else if (DeviceCount < 1) rv = 2;  //TO
		else if (ReadStatus() != 0) rv = 1; //Read Error
		else rv = 0;
	}

	return rv;
}

// main EPD-issue function
// does endcom at the end
int EpdBase::Epd2U::IssueAndCheck(float gain)
{
	//chirp not supported
	int rv = 0;
	if (isNG) {
		int kx = (int)gain;
		rv = ReadCal();
		if (rv != 0 || K6 != 1310) { rv = 1; goto error; }
		if (K3 != kx || K4 != kx)
		{
			K3 = K4 = kx;
			rv = WriteCal();
			if (rv != 0) goto error;
		}
	}
	rv = PrepareForIssue();
	rv = Issue(true); // data already loaded
	return rv;
error:
	return rv;
}