#include "pch.h"
#include "pch.h"
#include "pch.h"
#pragma unmanaged
#include <chrono>
#include <format>

#include "Epd3Base.h"
#include "TimeFunctions.h"

#pragma unmanaged
#define noDeissueWithClear
#define ProtectSession

//#if _DEBUG
//#define DebugWrite(f,...) snprintf(current->DiagnosticsWrite, DiagnosticsWriteSize, f ,__VA_ARGS__); OutputDebugStringA(current->DiagnosticsWrite); 
//#else
//#define DebugWrite(f,...) ; 
//#endif






bool g_EnableReleaseLogging;
Epd3Base::Epd3U* current;




void Epd3Base::Epd3U::resetErrors()
{
	errorm009 = errorm007 = errorm102 = errorm200=  errorm202 = error_other = 0;
}

void Epd3Base::Epd3U::incrementError(int rv)
{
	switch (rv) {
		case 0: break;
		case -7: errorm007++; break;
		case -9: errorm009++; break;
		case -102: errorm102++; break;
		case -200: errorm200++;; break;
		case -202: errorm202++; break;
		case -999: error_other++; break;
		default: error_other++; break;
	}
}
void Epd3Base::Epd3U::ResetStepReturnValues()
{
	CurrentStep = -1;
	HasStepError = 0;
	for (int i = MaxSteps - 1; i >= 0; --i) {
		StepReturnValues[i][static_cast<size_t>(EpdStepColumns::function)] = 0;
		StepReturnValues[i][static_cast<size_t>(EpdStepColumns::retry)] = 0;
		StepReturnValues[i][static_cast<size_t>(EpdStepColumns::commitRV)] = -998;
		StepReturnValues[i][static_cast<size_t>(EpdStepColumns::endRV)] = -1;
		StepReturnValues[i][static_cast<size_t>(EpdStepColumns::canIgnorore)] = 0;
		StepReturnValues[i][static_cast<size_t>(EpdStepColumns::commitMS)] = -1;
		StepReturnValues[i][static_cast<size_t>(EpdStepColumns::endMS)] = -1;
		StepReturnValues[i][static_cast<size_t>(EpdStepColumns::endCode)] = 0;
		StepReturnValues[i][static_cast<size_t>(EpdStepColumns::commitCode)] = 0;
	}
	resetErrors();
}

int Epd3Base::Epd3U::SetFunctionReturnValue(enum eFunctions f, BYTE CanIgnore, int retry)
{
	if (CurrentStep < -1) CurrentStep = -1;
	if (CurrentStep < MaxSteps - 1)  {
		++CurrentStep;
		if (CurrentStep == 0) HasStepError = 0;
		StepReturnValues[CurrentStep][static_cast<size_t>(EpdStepColumns::function)] = f;
		StepReturnValues[CurrentStep][static_cast<size_t>(EpdStepColumns::retry)] = retry;
		StepReturnValues[CurrentStep][static_cast<size_t>(EpdStepColumns::commitRV)] = -998;
		StepReturnValues[CurrentStep][static_cast<size_t>(EpdStepColumns::endRV)] = -1;
		StepReturnValues[CurrentStep][static_cast<size_t>(EpdStepColumns::canIgnorore)] = CanIgnore;
		StepReturnValues[CurrentStep][static_cast<size_t>(EpdStepColumns::commitMS)] = -1;
		StepReturnValues[CurrentStep][static_cast<size_t>(EpdStepColumns::endMS)] = -1;
		StepReturnValues[CurrentStep][static_cast<size_t>(EpdStepColumns::commitCode)] = 0;
		StepReturnValues[CurrentStep][static_cast<size_t>(EpdStepColumns::endCode)] = 0;
	}
	return CurrentStep;
}

void Epd3Base::Epd3U::SetCommitReturnValue(int step, int32_t rv)
{
	if (CurrentStep >= 0 && CurrentStep < MaxSteps) {
		StepReturnValues[step][static_cast<size_t>(EpdStepColumns::commitRV)] = rv;
		auto endTime = std::chrono::steady_clock::now();
		auto duration = std::chrono::duration_cast<std::chrono::duration<int32_t, std::milli>>(endTime - sessionStart);
		StepReturnValues[step][static_cast<size_t>(EpdStepColumns::commitMS)] = duration.count();
		if (rv) {
			StepReturnValues[step][static_cast<size_t>(EpdStepColumns::commitCode)] = GetErrorCode();
			StepReturnValues[CurrentStep][static_cast<size_t>(EpdStepColumns::endCode)] = rv;
			StepReturnValues[step][static_cast<size_t>(EpdStepColumns::endMS)] = StepReturnValues[step][static_cast<size_t>(EpdStepColumns::commitMS)];
		}
		else
			StepReturnValues[step][static_cast<size_t>(EpdStepColumns::commitCode)] = 0;
	}
}

void Epd3Base::Epd3U::SetCommitReturnValue(int32_t rv)
{
	SetCommitReturnValue(CurrentStep, rv);
}

uint32_t Epd3Base::Epd3U::SetEndReturnValue(int step, int32_t rv)
{
	if (rv) incrementError(rv);
	if (step >= 0 && step < MaxSteps) {
		StepReturnValues[step][static_cast<size_t>(EpdStepColumns::endRV)] = rv;
		auto endTime = std::chrono::steady_clock::now();
		auto duration = std::chrono::duration_cast<std::chrono::duration<int32_t, std::milli>>(endTime - sessionStart);
		StepReturnValues[step][static_cast<size_t>(EpdStepColumns::endMS)] = duration.count();
		
		if (rv != 0) {
			HasStepError = 1;
			if (StepReturnValues[step][static_cast<size_t>(EpdStepColumns::canIgnorore)])  rv = 0; //if canIgnore set this return rv ok
			Error = GetErrorCode();
			StepReturnValues[step][static_cast<size_t>(EpdStepColumns::endCode)] = Error;
		} else
			StepReturnValues[step][static_cast<size_t>(EpdStepColumns::endCode)] = 0;
	}
	return rv;
}

uint32_t Epd3Base::Epd3U::SetEndReturnValue(int32_t rv) 
{
	return SetEndReturnValue(CurrentStep, rv);
}

int32_t Epd3Base::Epd3U::CommitAndSetRV()
{
	int32_t r = Commit3(epdComsHandle); 
	SetCommitReturnValue(r);
	return r;
}

//int32_t Epd3Base::Epd3U::CommitAndSetRV(int idx[], int len)
//{
//	int32_t r = Commit3(epdComsHandle);
//	for(int i = 0; i < len ;++i)
//		SetCommitReturnValue(idx[i],r);
//	return r;
//}

//int32_t Epd3Base::Epd3U::CommitAndEnd2RV(int32_t  (WINAPI *endFunction2)(CommsHandle hComms, CompletionToken token), CompletionToken token, int waitTime)
//{
//	int32_t r = Commit3(epdComsHandle);
//	SetCommitReturnValue(r);
//	if (waitTime) Sleep(waitTime);
//	if (!r) r = (*endFunction2)(epdComsHandle, token);
//	r= SetEndReturnValue(r);
//	return r;
//}

int32_t Epd3Base::Epd3U::End2RV(int step, int32_t(WINAPI* endFunction2)(CommsHandle hComms, CompletionToken token), CompletionToken token)
{
	int32_t r = (*endFunction2)(epdComsHandle, token);
	r = SetEndReturnValue(step,r);
	return r;
}

void WINAPI completion(CommsHandle hComms, CompletionToken token)
{

	SetEvent(current->hCompletion);
}

void WINAPI discovery(CommsHandle hComms, DiscoveryId const discovered[], int32_t count)
{
	if (count > 0 && discovered != nullptr)
	{
		memcpy(&current->Epd, &discovered[0], sizeof(DiscoveryId));
		current->Epd.MaxBaud = 9600;
		current->DeviceCount = count;
		current->isMK3 = (current->Epd.Gen == EpdGeneration::Mk3);
	}
	else {
		current->isMK3 = true;
		current->DeviceCount = 0;
		memset(&current->Epd, 0, sizeof(DiscoveryId));
	}
	SetEvent(current->hCompletion);
}

void WINAPI connectcallback(CommsHandle hComms, DiscoveryId ID)
{
	DebugWrite("****    Connectcallback    {} baud {}****\n", ID.Id, ID.MaxBaud);
	if (current) {
		current->isConnected = 1;
		current->DeviceCount = 1;
		memcpy(&current->Epd, &ID, sizeof(DiscoveryId));
		current->Epd.MaxBaud = 9600;
	}
}

void WINAPI disconnectcallback(CommsHandle hComms, DiscoveryId ID)
{
	OutputDebugStringA("****    Disconnectcallback    ****\n");
	if (current) {
		current->isConnected = 0;
		SetEvent(current->hCompletion);
	}
}

int WINAPI Connect33(CommsHandle  hComms, DiscoveryId epd, bool wait = false)
{
	if (epd.Id == 0 || epd.MaxBaud == 0) {
		OutputDebugStringA("****    Connect33: Invalid DiscoveryId    ****\n");
		return -1;
	}
	else {
		DebugWrite("****    Connect33: ID {} baud {} ****\n", epd.Id, epd.MaxBaud);
	}
	return Connect3(hComms, epd, wait);
}

Epd3Base::Epd3U::Epd3U(int _comport)
{

	port = _comport;
	comPort[3] = 48 + _comport;
	CommsInitialized = 0;
	epdComsHandle = nullptr;
	isBG = isNG = VersionOK = 0;
	Error = 123;
	current = this;
	SelfTestMinutes = 0;
	DeviceCount = 0;
	BaseCountsClock = 0;
	countsRead = 0; utc = 0; seconds = 0;
	memset(WearerID, 0, WearerIDLength + 1);
	memset(WearerName, 0, WearerNameLength + 1);
	Error = 0;
	EpdType = EpdTypes::Mk2BetaGamma;
	isBG = 1; isNG = 0; VersionOK = 1;
	isMK3 = true;
	FunctionFlags = 0x000;
	Epd.Gen = EpdGeneration::None;
	Epd.MaxBaud = 0;
	Epd.Id = 0;

	OperatingStatus = (OpStatusFlags)0U;
	AlarmStatus = (AlarmStatusFlags)0U;
	ErrorStatus = (FaultStatusFlags)0;
	IssueCount = OtherAlarms = EEPROMBadSectors = 0;
	RealTime = EpdClock = OffTime =  0; //epdid=0
	EPDFaulty = false;
	EPDTimeFault = 0;
	EPDDetectorTestRequested = false;
	EPDDetectorTestPassed = false;

	hasAlarm = hasFault = 0;
	ErrorSource = ErrorReason = ErrorData = 0;
	HardVersion = HardVersionMinor = HardVersionBuild = HardVersionRevision = SoftVersion = SoftVersionMinor = SoftVersionBuild = SoftVersionPatch = FunctionFlags = 0;

	K1 = K2 = K3 = K4 = K4 = K6 = 0.0F;
	HG = SG = BC = FB = 0;
	D1 = D2 = D3 = D4 = 0;
	Hp10Total = Hp07Total = 0;
	Hp10Dose = Hp07Dose = 0;
	Hp10Peak = Hp07Peak = 0;
	Hp10Time = Hp07Time = 0;
	Hp10FTime = Hp07FTime = 0;

	Hp07THDose = 0; Hp07RateOn = 0; Hp07RateOff = 0;
	Hp07THDoseA = 0; Hp07RateAOn = 0; Hp07RateAOff = 0;
	Hp10THDose1 = 0; Hp10Rate1On = 0; Hp10Rate1Off = 0;
	Hp10THDose2 = 0; Hp10Rate2On = 0; Hp10Rate2Off = 0;

	//EndNotifyAlarm = 0b1001110011000111;
	EndNotifyAlarm = 0b1001110010000100;
	EndNotifyAlarmDuration = 10;
	g_EnableReleaseLogging = 0;

	ResponseTimeout = 500;
	DiscoveryCacheTimeout = 20000; //15000; //ms
	SleepAfterClear = 5000; //?6000
	SleepBeforeReconnect = 500;
	SleepAfterDisconnect = 1000;
	DoDisconnectAfterClear = false;
	DoDisconnectBeforeReconnect = false;
	ReconnectRetries = 5;

	vbat0 = vbat1 = vcpu = 0; 
	memset(&Epd, 0, sizeof(DiscoveryId));
	
	if (_comport == 0) return;
	if (hCompletion == 0) hCompletion = CreateEvent(NULL, TRUE, FALSE, NULL);
	if (hCancel == 0) hCancel	 = CreateEvent(NULL, TRUE, FALSE, NULL);

	s_pInstance = this;
	m_activeToken = nullptr;
}

Epd3Base::Epd3U::~Epd3U()
{
	EndCom(isConnected);

	if (hCompletion != 0) { CloseHandle(hCompletion);  hCompletion = 0; }
	if (hCancel != 0) { CloseHandle(hCancel);  hCancel = 0; }
	if (logFile.is_open()) {
		logFile << "--- DLL Shutting down ---\n";
		logFile.close();
	}
}

int Epd3Base::Epd3U::DisconnectAndConnect()
{
	int rv = 0;

	if (DoDisconnectBeforeReconnect) {
		SetFunctionReturnValue(fDisconnect, 1, 0);
		rv = Disconnect(epdComsHandle);
		SetEndReturnValue(rv);
		Sleep(10);
	}

	int  retry=0; rv = 1;
	while (rv && retry++< ReconnectRetries) {
		Sleep(SleepBeforeReconnect);
		SetFunctionReturnValue(fConnect, 1,retry);
		rv = Connect33(epdComsHandle, Epd, true);
		SetEndReturnValue(rv);
		DebugWrite("****    DisconnectAndConnect rv={} retry {} ****\n", rv, retry);
	}
	if (!rv) isConnected = true;

	return rv;
}

void Epd3Base::Epd3U::CancelAll()
{
	SetEvent(current->hCancel);
	//Cancel(epdComsHandle);
}

void Epd3Base::Epd3U::test()
{
	if (progressCallback)
	progressCallback( EpdSteps::StepTest, EPDStepResult); // Triggers the callback

}
DWORD Epd3Base::Epd3U::StartCom()
{
	ErrorReason = 0;
	ConnectRetries = 0;
	OpenRetries = 0;
	int step = 1;
	int mx = 10;
	EPDStep = EpdSteps::StepStartCom;
	EPDStepResult = EpdStepResults::Started;
	epdComsHandle = nullptr;
	if (port == 0) {
		CommsInitialized = 1;
		return 1;
	}

	if (CommsInitialized == 0 || epdComsHandle == nullptr) {
		step = 2;
		SetFunctionReturnValue(fCreateReaderInterface, 0,0);
		epdComsHandle = CreateReaderInterface();
		if (!epdComsHandle) step = 3;
		while (epdComsHandle == nullptr && ++ConnectRetries < 4) {
			Sleep(100);
			epdComsHandle = CreateReaderInterface(); //try again;
		}
		if (epdComsHandle) {
			SetEndReturnValue(0);
		}
		else {
			EPDStepResult = EpdStepResults::Error;
			SetEndReturnValue(-1);
		}

		if (epdComsHandle != nullptr) {
			Dll3RV = SetConnectCallback(epdComsHandle, connectcallback);
			Dll3RV = SetDisconnectCallback(epdComsHandle, disconnectcallback);
			Dll3RV = SetMultipleDiscoveryMode(epdComsHandle, false);
			Dll3RV= SetDiscoveryTimeslots(epdComsHandle, 1);
			Dll3RV = SetResponseTimeout(epdComsHandle, ResponseTimeout); //initial
			Dll3RV = SetDiscoveryCacheTimeout(epdComsHandle, DiscoveryCacheTimeout);	
#if !_DEBUG
			Dll3RV = SetRetryCount(epdComsHandle, 20);
#else
			Dll3RV = SetRetryCount(epdComsHandle, 1);
#endif

			step = 4;
			SetFunctionReturnValue(fOpenReader, 0,0);
			Dll3RV = OpenReader(epdComsHandle, comPort);  //-6 = r_OperationFailed
			SetEndReturnValue(Dll3RV);
			if (Dll3RV) step = 5;
			while (Dll3RV && ++OpenRetries < 4) { //retry
				Sleep(200);
				SetFunctionReturnValue(fOpenReader, 0, OpenRetries);
				Dll3RV = OpenReader(epdComsHandle, comPort);
				SetEndReturnValue(Dll3RV); 
			}
			if (Dll3RV == 0)
			{
				step = 7;
				CommsInitialized = 1;
				EPDStepResult = EpdStepResults::OK;
			}
		}
		else {
			Dll3RV = r_FunctionFail;
		}
	}
	progressCallback(EPDStep, EPDStepResult); // Triggers the callback
	if (Dll3RV) goto error;
	return 0;
error:
	ErrorStep = step;
	Error = Dll3RV;
	return Dll3RV;
}

void Epd3Base::Epd3U::EndCom(bool doDiscon)
{
	int rv;
	if (CommsInitialized == 1 || isConnected != 0) {
		if (CommsInitialized == 1) {
			DebugWrite("****    EndCom({})  is Connected={}    ****\n", doDiscon, isConnected);
			if (epdComsHandle != nullptr) {
				if (doDiscon && isConnected) { DisCon(0); }
				SetFunctionReturnValue(eFunctions::fDestroyReaderInterface,0);
				Dll3RV = DestroyReaderInterface(epdComsHandle);
				SetEndReturnValue(Dll3RV);
				if (Dll3RV) rv = 1;
			}
		}
		Epd.Id = 0;
	
		//CurrentDeviceID = 0;
		memset(&Epd, 0, sizeof(DiscoveryId));
		CommsInitialized = 0;
		epdComsHandle = nullptr;
	}
}

bool Epd3Base::Epd3U::isCancelled() {
	return WaitForSingleObject(hCancel, 0) == WAIT_OBJECT_0;
}


/// <summary>
/// 
/// </summary>
/// <param name="tokentimeout"></param>
/// <returns>rv=1 ,ook bij timeout <>1 voor error</returns>
int Epd3Base::Epd3U::StartDiscover(int tokentimeout)
{
	ResetEvent(current->hCancel);
	EPDStep =EpdSteps::StepDiscovering;
	DiscoverStep = 0;
	DiscoverError = DiscoverErrorNone;
	int32_t rv = 1;
	int32_t rv2 = 0;
	Error = 0;
	if (port == 0) {
		DeviceCount = 1;
		isBG = 1;
		DeviceIDs[0] = 768;
		return 0;
	}
	current = this;
	DeviceCount = 0;
	ResetEvent(hCompletion);
	ConnectTimerFired = 0;
	isConnected = 0;
	
	DiscoverStep = 1;
	Dll3RV = SetResponseTimeout(epdComsHandle, ResponseTimeout); //initial
	Dll3RV = StartDiscovery(epdComsHandle, discovery);
	if (Dll3RV == 0) {
		HANDLE handles[2];
		handles[0] = hCompletion; // Index 0: Completion event
		handles[1] = hCancel;

		Dll3RV = WaitForMultipleObjects(2, handles, false	, tokentimeout);
		if (Dll3RV == WAIT_OBJECT_0) {
			DiscoverError = DiscoverErrorNone;
			LogMessage("Discovery completed successfully Epd{}.", Epd.Id);
			rv = 1; //ok was set
		}
		else if (Dll3RV == WAIT_OBJECT_0+1) {
			DiscoverError = DiscoverErrorCancel;
			LogMessage("Discovery cancel");
			rv = 1; //cancel
			rv2 = StopDiscovery(epdComsHandle);
		}
		else if (Dll3RV == WAIT_TIMEOUT) {
			rv = 1;
			ConnectTimerFired = 1;
			LogMessage("Discovery timeout");
			DiscoverError = DiscoverErrorTimeout;
			rv2 = StopDiscovery(epdComsHandle);
		}
		else {
			LogMessage("Discovery failed with error {}.", Dll3RV);
			rv = 2;

			DiscoverError = DiscoverErrorOther;
			rv2 = StopDiscovery(epdComsHandle);
		}
	}
	

	if (DiscoverError == DiscoverErrorNone && DeviceCount > 0 && Epd.Id >0) {
		if (isMK3)
			Dll3RV = SetResponseTimeout(epdComsHandle, static_cast<uint32_t>(ResponseTimeout * 1.5)); //initial
		Dll3RV = Connect33(epdComsHandle, Epd, true);
		if (Dll3RV != 0) {
			DiscoverError = DiscoverErrorConnecting;
			EPDStepResult = EpdStepResults::Error;
			rv = 2;
		}
		else {
			EPDStepResult = EpdStepResults::OK;
		}
	}
	return rv;
}

int Epd3Base::Epd3U::OpenDev(DiscoveryId DeviceID)
{
	//CurrentDeviceID = DeviceID.Id;
	if (epdComsHandle != nullptr)
	{
		Dll3RV = Connect33(epdComsHandle, DeviceID, true);
		
		OutputDebugStringA("****    Connect EPD  ****\n");
	}
	else { 
		Dll3RV = r_InvalidCommsHandle; 
		OutputDebugStringA("****    Connect EPD  Error ****\n");
	}
	return Dll3RV;
}

int Epd3Base::Epd3U::ReConnect()
{
	if (epdComsHandle != nullptr)
	{
		Sleep(10);
		SetFunctionReturnValue(fConnect, 0);
		Dll3RV = Connect33(epdComsHandle, Epd, true);
		SetEndReturnValue(Dll3RV);
		DebugWrite("****    ReConnect rv {} ****\n", Dll3RV); // r_operationtimeout 
		if (Dll3RV) {
			//r_OperationTimeout == -9
			incrementError(Dll3RV);
			DebugWrite("****    Connect3 rv {} ****\n", Dll3RV); // r_operationtimeout 
			Dll3RV = DisconnectAndConnect();
		}
		if (!Dll3RV) isConnected = 1;
		DebugWrite("****    ReConnect rv {} v {}.{}.{}.{} ****\n", Dll3RV, HardVersion, HardVersionMinor, HardVersionBuild, HardVersionRevision	);
	}
	else {
		OutputDebugStringA("****    ReOpen no  epdComsHandle ****\n");
		Dll3RV = r_InvalidCommsHandle;
	}  
	if (Dll3RV) {
		incrementError(Dll3RV);
	}
	
	return Dll3RV;
}

//

int Epd3Base::Epd3U::DisCon(UINT16 alarm)
{
	//                      5432109876543210
//#ifdef SILENT
//	constexpr UINT16 ca = 0;
//#else
//	constexpr UINT16 ca = 0b1001110011000111;
//#endif // SILENT

	
	int rv = 0;
	int step = 0;
	DebugWrite( "****    Discon({})    ****\n", alarm);
	
	if (Epd.Id!= 0) {
		ResetEvent(hCompletion);
		current = this;
		step = 1;
		if (alarm) {
			DebugWrite("****    DisconnectAndNotify({})    HardVersionMinor:{}  {} {} {}****\n", EndNotifyAlarm, HardVersion, HardVersionMinor,HardVersionBuild,HardVersionRevision);


			// permission error anyway on new epd
		/*	if (HardVersionMinor > 0) {
				SetFunctionReturnValue(TestVibe, 0);
				token = BeginTestLed_R3(epdComsHandle, 1.0 , nullptr);
				rv = CommitAndEnd2RV(EndTestLed_R3, token);
				
			}*/ 
			Sleep(200);
			SetFunctionReturnValue(fDisconnectAndNotify,0,0);
			Dll3RV = DisconnectAndNotify(epdComsHandle, EndNotifyAlarm, EndNotifyAlarmDuration); //1.0 secon
			SetEndReturnValue(Dll3RV);
			if (Dll3RV) {
				if (Dll3RV == r_ErrorNotConnected) ReConnect();
				
					SetFunctionReturnValue(fDisconnectAndNotify, 0, 1);
					Dll3RV = DisconnectAndNotify(epdComsHandle, EndNotifyAlarm, EndNotifyAlarmDuration); //1.0 secon
					SetEndReturnValue(Dll3RV);
				
			}
			DebugWrite("****    DisconnectAndNotify Timeout rv={}    ****\n", Dll3RV);
	
		} else {
			SetFunctionReturnValue(fDisconnect,0,0);
			Dll3RV = Disconnect(epdComsHandle);
			SetEndReturnValue(Dll3RV);
			if (Dll3RV) {
				if (!Dll3RV && Dll3RV!= r_ErrorNotConnected) {
					SetFunctionReturnValue(fDisconnect, 0, 1);
					Dll3RV = Disconnect(epdComsHandle);
					SetEndReturnValue(Dll3RV);
				}
			}
		}
		if (Dll3RV) { rv = Dll3RV; SetEvent(hCompletion); goto error; }
		Sleep(SleepAfterDisconnect);
		

		//step = 2;  Disconnectcallback set hcompletion
		Dll3RV = WaitForSingleObject(hCompletion, 1000);
				switch (Dll3RV) {
				case WAIT_OBJECT_0:
					rv = 0; break;
				case WAIT_TIMEOUT:
					rv = 0;
					isConnected = 0;
					//current->CurrentDeviceID = 0; // when rv=0, this was set
					//current->DeviceCount = 0;
					break;
				default: rv = 3; break;
				}
	}
	return rv;
error:
	return rv;
}

void Epd3Base::Epd3U::CloseDev(bool CloseAll)
{
	if (epdComsHandle != nullptr) {
		DisCon(0);
		if (CloseAll) {
			//CloseReader(epdComsHandle);
			SetFunctionReturnValue(fDestroyReaderInterface, 0);
			int Dll3RV = DestroyReaderInterface(epdComsHandle);
			SetEndReturnValue(Dll3RV);
			epdComsHandle = nullptr;
		}
	}
}

BYTE checkStatus(OpStatusFlags status, OpStatusFlags flag)
{
	if (((uint32_t)status & (uint32_t)flag) == (uint32_t)flag) return 1; else return 0;
}

BYTE checkStatus(FaultStatusFlags status, FaultStatusFlags flag)
{
	if (((uint32_t)status & (uint32_t)flag) == (uint32_t)flag) return 1; else return 0;
}

BYTE checkStatus(AlarmStatusFlags status, AlarmStatusFlags flag)
{
	uint32_t ustatus = (uint32_t)status;
	uint32_t uflag = (uint32_t)flag;
	if ((ustatus & uflag) == uflag) return 1; else return 0;
}

BYTE checkStatus(DoseAlarmFlags status, DoseAlarmFlags flag)
{
	if (((uint32_t)status & (uint32_t)flag) == (uint32_t)flag) return 1; else return 0;
}

void Epd3Base::Epd3U::DecodeStatus()
{

	if (StatusDecoded) {
		return;
	}
	eDosDose07Warning = eDosDose07Alarm = eDosDose10Warning = eDosDose10Alarm = eDosRate07Warning = eDosRate07Alarm = eDosRate10Warning = eDosRate10Alarm = eDosBatteryWarning = eDosDoseAlarm = eDosRateAlarm = 0;
	AlarmDoseHP07N = AlarmRateHP07N = AlarmDoseHP101G = AlarmDoseHP102G = AlarmRateHP101G = AlarmRateHP102G= 0;
	hasAlarm = hasFault = false;

	
	DetectorsOn = checkStatus(epd3status.OperatingStatus, OpStatusFlags::EpdOn);
	EPDIssued = checkStatus(epd3status.OperatingStatus, OpStatusFlags::EpdIssued);
	EPDLocked = checkStatus(epd3status.OperatingStatus, OpStatusFlags::GainAdjustable);
	EPDTesting = checkStatus(epd3status.OperatingStatus, OpStatusFlags::DetectorTestRequested);

	EPDDetectorTestRequested = checkStatus(epd3status.OperatingStatus, OpStatusFlags::DetectorTestRequested);
	EPDDetectorTestPassed = checkStatus(epd3status.OperatingStatus, OpStatusFlags::DetectorTestPassed);
	EPDFaulty = checkStatus(epd3status.FaultStatus, FaultStatusFlags::EpdFaulty);
	EPDNewFault = checkStatus(epd3status.FaultStatus, FaultStatusFlags::ErrorLogged);
	EPDComFault = checkStatus(epd3status.FaultStatus, FaultStatusFlags::EarlyCommsTermination);
	EPDCalFault = checkStatus(epd3status.FaultStatus, FaultStatusFlags::NotCalibrated);
	EPDDetFault = checkStatus(epd3status.FaultStatus, FaultStatusFlags::DetectorTestFail);
	EPDEprFault = checkStatus(epd3status.FaultStatus, FaultStatusFlags::EepromFailure);
	EPDTrhFault = checkStatus(epd3status.FaultStatus, FaultStatusFlags::BadThreshold);
	EPDTimeFault = checkStatus(epd3status.FaultStatus, FaultStatusFlags::TimeInvalid);

	for (int ix = 0; ix < 4; ix++)
	{
		DoseAlarmFlags status = epd3status.DoseAlarms[ix].Status;
		switch ((MeasurementId)epd3status.DoseAlarms[ix].Id)
		{
		case MeasurementId::Meas_Hp07:
		case MeasurementId::Meas_Hp10N:
			eDosDose07Warning = checkStatus(status, DoseAlarmFlags::DoseWarning);
			eDosDose07Alarm = checkStatus(status, DoseAlarmFlags::DoseAlarm);
			eDosRate07Warning = checkStatus(status, DoseAlarmFlags::RateWarning);// | checkStatus(status, DoseAlarmFlags::LatchedRateWarning);
			eDosRate07Alarm = checkStatus(status, DoseAlarmFlags::RateAlarm) ; // checkStatus(status, DoseAlarmFlags::LatchedRateAlarm)
			AlarmDoseHP07N = checkStatus(status, DoseAlarmFlags::DoseAlarm);
			AlarmRateHP07N = checkStatus(status, DoseAlarmFlags::RateAlarm);; // | checkStatus(status, DoseAlarmFlags::LatchedRateAlarm);
			break;
		case MeasurementId::Meas_Hp10:
		case MeasurementId::Meas_Hp10G:
			eDosDose10Warning = checkStatus(status, DoseAlarmFlags::DoseWarning);
			eDosDose10Alarm = checkStatus(status, DoseAlarmFlags::DoseAlarm);
			eDosRate10Warning = checkStatus(status, DoseAlarmFlags::LatchedRateWarning) | checkStatus(status, DoseAlarmFlags::RateWarning);
			eDosRate10Alarm = checkStatus(status, DoseAlarmFlags::LatchedRateAlarm) | checkStatus(status, DoseAlarmFlags::RateAlarm);
			AlarmDoseHP101G = checkStatus(status, DoseAlarmFlags::DoseAlarm);
			AlarmDoseHP102G = AlarmDoseHP101G;
			AlarmRateHP101G = checkStatus(status, DoseAlarmFlags::RateAlarm) | checkStatus(status, DoseAlarmFlags::LatchedRateAlarm);
			AlarmRateHP102G = AlarmRateHP101G;
			break;
		}
	}

	OtherAlarmReturn = checkStatus(epd3status.AlarmStatus, AlarmStatusFlags::ReturnForRead);
	OtherAlarmBatLow = checkStatus(epd3status.AlarmStatus, AlarmStatusFlags::LowBattery);
	OtherAlarmCarrier = checkStatus(epd3status.AlarmStatus, AlarmStatusFlags::TelemetryAlert);
	OtherAlarmBatVolt = checkStatus(epd3status.AlarmStatus, AlarmStatusFlags::LowBattery);

	eDosDoseAlarm = (eDosDose10Alarm || eDosDose07Alarm) & checkStatus(epd3status.AlarmStatus, AlarmStatusFlags::DoseAlarm);
	eDosRateAlarm = (eDosRate07Alarm || eDosRate10Alarm) & checkStatus(epd3status.AlarmStatus, AlarmStatusFlags::RateAlarm);

	hasAlarm = eDosDoseAlarm || eDosRateAlarm;
	hasFault = ((uint32_t)epd3status.FaultStatus & ~(uint32_t)FaultStatusFlags::ErrorLogged) != 0;
	eDosBatteryWarning = OtherAlarmBatLow | OtherAlarmBatVolt;

	StatusDecoded = true;
}

int  Epd3Base::Epd3U::SetTime() //Only R3
{
	int r = 0;
	if (Epd.Gen == EpdGeneration::Mk3)
	{
		
		utc = TimeFunctions::NowToEpd3Time();
		r = RunComsTransaction(WriteRTC_R3, 1,
			[&](auto cb) {
				return BeginWriteRTC_R3(epdComsHandle, utc, cb);
			},
			[&](auto token) {
				return EndWriteRTC_R3(epdComsHandle, token);
			}, 10
		);
		
	}
	return r;
}

int Epd3Base::Epd3U::ReadStatusOnly()
{
	EPDStep = EpdSteps::StepReadStatus;
	int rv=0;

	current->StatusDecoded = false;
	if (!isConnected) rv = ReConnect();
	if (rv) 
		return rv;

	RunComsTransaction(eFunctions::ReadStatusOnly, 0,
		[&](auto cb) {
			return BeginReadStatus(epdComsHandle, cb);
		},
		[&](auto token) {
			return EndReadStatus(epdComsHandle, token, &epd3status);
		}, 10
	);

	
	if (rv) {
		EPDStepResult = EpdStepResults::Error;
		current->StatusDecoded = false;
	}
	else {
		current->StatusDecoded = true;
		current->IssueCount = current->epd3status.IssueCount;
		current->OperatingStatus = current->epd3status.OperatingStatus;
		current->AlarmStatus = current->epd3status.AlarmStatus;
		current->ErrorStatus = current->epd3status.FaultStatus;
		current->OtherAlarms = current->epd3status.OtherBits;
		current->DecodeStatus();	//Alarm status...
	}
	return rv;
}
/// <summary>
/// 
/// </summary>
/// <returns>0 = ok</returns>
int Epd3Base::Epd3U::ReadStatus(bool onlyStatus)
{
	int rv; //0=ok
	//constexpr int maxbatch = 2;
	//int batchstep;
	//int s[maxbatch];
	//int r[maxbatch];
	int step = 0;
	uint8_t 	length = 0;
	EPDStep = EpdSteps::StepReadStatus;
	countsRead = 0; utc = 0; seconds = 0;
	memset(WearerID, 0, WearerIDLength + 1);
	memset(WearerName, 0, WearerNameLength + 1);
	
	Error = 0;
	if (port == 0) {
		Epd.Gen = EpdGeneration::Mk3;
		Epd.Id =4567;
		EpdType = EpdTypes::Mk2BetaGamma;
		isBG = 1; isNG = 0; VersionOK = 1;
		isMK3 = true;
		FunctionFlags = 0x000;
		Epd.Gen = EpdGeneration::None;
		Epd.MaxBaud = 0;
		
		return 0;
	}

	isMK3 = Epd.Gen == EpdGeneration::Mk3;
	
	OperatingStatus = (OpStatusFlags)0U;
	AlarmStatus = (AlarmStatusFlags)0U;
	ErrorStatus = (FaultStatusFlags)0;
	IssueCount = OtherAlarms = EEPROMBadSectors = 0;
	RealTime = EpdClock = OffTime =   0; //EpdID
	ErrorSource = ErrorReason = ErrorData = 0;
	HardVersion = HardVersionMinor = HardVersionBuild = HardVersionRevision = SoftVersion =SoftVersionMinor = SoftVersionBuild = SoftVersionPatch =	FunctionFlags = 0;
	
	memset(&epd3status, 0, sizeof(StatusData_t));
	

	if (!isConnected) {
		rv = ReConnect();
		if (rv != 0) {
			EPDStepResult = EpdStepResults::Error;
			goto error;
		}
	}
	
	step = 2;

	rv = RunComsTransaction(eFunctions::ReadStatus, 0,
		[&](auto cb) {
			return BeginReadStatus(epdComsHandle, cb);
		},
		[&](auto token) {
			return  EndReadStatus(epdComsHandle, token, &epd3status);
		}, 10
	);

	

	current->StatusDecoded = false;
	if (rv) {
		EPDStepResult = EpdStepResults::Error;
		goto error;
	}


	step = 3;
	// millivolt vbat0	off load battery voltage  vbat1	on load battery voltage vcpu CPU supply voltage, in millivolts

	rv = RunComsTransaction(eFunctions::ReadVoltages, 0,
		[&](auto cb) {
			return BeginReadVoltages(epdComsHandle, cb);
		},
		[&](auto token) {
			return  EndReadVoltages(epdComsHandle, token, &vbat0, &vbat1, &vcpu);
		}, 10
	);

	
	
	if (progressCallback) progressCallback(EPDStep, EPDStepResult);

	IssueCount = epd3status.IssueCount;
	OperatingStatus = epd3status.OperatingStatus;
	AlarmStatus = epd3status.AlarmStatus;
	ErrorStatus = epd3status.FaultStatus;
	OtherAlarms = epd3status.OtherBits;
	DecodeStatus();	//Alarm status...

	if (onlyStatus) goto exitroutine;

	uint32_t EpdID32 ;
	uint32_t capabilities;
	MarkNumber_t MarkNumber; 
	VersionNumber_t VersionNumber;

	step = 3;
	EPDStep = EpdSteps::StepReadIdentities;
	
	EpdID32 = 0;
	MarkNumber.Major = 0;
	MarkNumber.Minor=0;
	VersionNumber.Major = 0;


	EPDStepResult = EpdStepResults::Started;

	rv = RunComsTransaction(eFunctions::ReadEpdIdentities, 0,
		[&](auto cb) {
			return BeginReadEpdIdentities(epdComsHandle, cb);
		},
		[&](auto token) {
			return  EndReadEpdIdentities(epdComsHandle, token, &EpdID32, reinterpret_cast<EpdTypes*>(&EpdType), &capabilities, &MarkNumber, &VersionNumber, nullptr, 0);
		}, 20
	);

	

	if (rv != 0) {
		EPDStepResult = EpdStepResults::Error;
		goto error;
	} else EPDStepResult = EpdStepResults::OK;
	if (progressCallback) progressCallback(EPDStep, EPDStepResult);

	
	isBG = (EpdType == EpdTypes::Mk2BetaGamma) || (EpdType == EpdTypes::Mk3BetaGamma);
	isNG = (EpdType == EpdTypes::Mk2Neutron) || (EpdType == EpdTypes::Mk3Neutron);
	HardVersion = MarkNumber.Major;
	HardVersionMinor = MarkNumber.Minor;
	HardVersionBuild = MarkNumber.Build;
	HardVersionRevision = MarkNumber.Revision;

	SoftVersion = VersionNumber.Major;
	SoftVersionMinor = VersionNumber.Minor;
	SoftVersionPatch = VersionNumber.Patch ;
	SoftVersionBuild = VersionNumber.Build;
	VersionOK = true;

	step = 4;
	EPDStep = EpdSteps::StepReadCounts;
	rv = RunComsTransaction(eFunctions::ReadCounts, 0,
		[&](auto cb) {
			return BeginReadCounts(epdComsHandle, nullptr,0,cb);
		},
		[&](auto token) {
			return  EndReadCounts(epdComsHandle, token, Counts, MaxCounts, &countsRead, &utc, &seconds);
		}, 10
	);


	if (rv) {
	
		EPDStepResult = EpdStepResults::Error;
		goto error;
	}
		
	decodeCounters(countsRead); //HG,SG ..

	//Times
	//1601-01-01T00:00:00Z.
	//MK2 .. some utc... but no real time clock
	step = 6;
	//batchstep = 3;
	if (utc == 0) {
		EPDStep = EpdSteps::StepReadRTC;
		rv = RunComsTransaction(eFunctions::ReadRTC, 0,
			[&](auto cb) {
				return BeginReadRTC(epdComsHandle, cb);
			},
			[&](auto token) {
				return  EndReadRTC(epdComsHandle, token, &utc);
			}, 10
		);

		
		if (rv) {
			EPDStepResult = EpdStepResults::Error;
			goto error;
		}
			
		EpdClock = utc;
		utc = TimeFunctions::NowToEpd3Time();
	}
	else {
		EpdClock = utc;
	}

	FILETIME fUTC;
	TimeFunctions::Epd3TimeToFileTime(utc, &fUTC);
	FileTimeToSystemTime(&fUTC, &tRealTime);

	step = 5;
	if (EPDIssued) {
		IdString_t mk3WearerID;
		mk3WearerID.Length = 0;
		//Mk2 EPDs only support Name and Primary ID

		if (!isConnected) ReConnect();

		EPDStep = EpdSteps::StepReadWearerId;
		//batchstep = 0;
		rv = RunComsTransaction(eFunctions::ReadWearerId, 0,
			[&](auto cb) {
				return BeginReadWearerId(epdComsHandle, static_cast<uint16_t>(WearerIdType::WearerId_Name), cb);
			},
			[&](auto token) {
				return  EndReadWearerId(epdComsHandle, token, &mk3WearerID);
			}, 10
		);


		if (rv != 0) {
			EPDStepResult = EpdStepResults::Error;
			goto error;
		}

		if (mk3WearerID.Length > WearerNameLength) mk3WearerID.Length = WearerNameLength;
		memcpy(WearerName, mk3WearerID.Utf8String, mk3WearerID.Length); WearerName[mk3WearerID.Length] = 0;

		step = 5;
		//batchstep = 1;

		rv = RunComsTransaction(eFunctions::ReadWearerId, 0,
			[&](auto cb) {
				return BeginReadWearerId(epdComsHandle, static_cast<uint16_t>(WearerIdType::WearerId_Primary), cb);
			},
			[&](auto token) {
				return  EndReadWearerId(epdComsHandle, token, &mk3WearerID);
			}, 10
		);


		if (rv != 0) {
			EPDStepResult = EpdStepResults::Error;
			goto error;
		}

		if (mk3WearerID.Length > WearerIDLength) mk3WearerID.Length = WearerIDLength;
		memcpy(this->WearerID, mk3WearerID.Utf8String, mk3WearerID.Length); WearerName[mk3WearerID.Length] = 0;
		for (int i = 0; i < mk3WearerID.Length; i++)
			if (WearerID[i] == 0xb) WearerID[i] = '0'; else  WearerID[i] |= 0x30;
	}
	EPDStepResult = EpdStepResults::OK;
	

exitroutine:
	if (progressCallback) progressCallback(EPDStep, EPDStepResult);
	return rv;

error:
	if (progressCallback) progressCallback(EPDStep, EPDStepResult);
	Error = rv;
	ErrorStep = step;
	return rv;

}
/// <summary>
/// discover, connect and read status
/// </summary>
/// <param name="tokenSourceTimeout"></param>
/// <returns>0=success 1=connect error,  2 =  time out , no devices, 3= error reading status</returns>
int Epd3Base::Epd3U::ConnectAndStatus(int tokenSourceTimeout)
{
	WORD dllStatus;
	int rv = 1;
	
	Error = 0; ErrorStep = 0; hasAlarm = hasFault = 0;
	ResetStepReturnValues();
	sessionStart = std::chrono::steady_clock::now();
	if (CommsInitialized == 0) StartCom();
	if (CommsInitialized) {

		SetFunctionReturnValue(fStartDiscover,0);
		EPDStep = EpdSteps::StepDiscovering;
		dllStatus = StartDiscover(tokenSourceTimeout);
		SetCommitReturnValue(0); 
		if (dllStatus == 1) {
			SetEndReturnValue(0); 
		}
		else SetEndReturnValue(dllStatus);

		if (dllStatus != 1) {
			rv = 1; //Connect error
			EPDStepResult = EpdStepResults::Error;
		}
		else if (DeviceCount < 1) {
			rv = 2;
			Error = r_OperationTimeout; //65527
			EPDStepResult = EpdStepResults::Error;
		}
		else if (isMK3) {
			if (ReadStatus(false) != 0) {
				rv = 3; //Read Error
				EPDStepResult = EpdStepResults::Error;
			}
			else
				EPDStepResult = EpdStepResults::OK;
			rv = 0;
		}
		else rv = 0; //MK2
	}
	else rv = 1;

	if (progressCallback) progressCallback(EPDStep, EPDStepResult);
	return rv;
}
/// <summary>
/// K1 = K2 = K3 = K4 = K4 = K6 (*100000 )
/// </summary>
/// <param name="count"></param>

void Epd3Base::Epd3U::decodeSensitivities(int count) {

	//	 Neutron
	//  An1Sens10N = 14,
	//	Fn1Sens10N = 15,
	//	Fn2Sens10N = 16,
	//float Kx = 0;
	K1 = K2 = K3 = K4 = K4 = K6 = 0.0F;
	//SensitivityId sid = SensitivityId::Hg1Sens10G;
	for (int ix = count - 1; ix >= 0; ix--) {
		switch ((SensitivityId)sensitivities[ix].id)
		{
		case SensitivityId::Hg1Sens10G: K1 = sensitivities[ix].value * 100000; break;
		case SensitivityId::Sg1Sens10G: K2 = sensitivities[ix].value * 100000; break;
		case SensitivityId::Hg1Sens07G: 
				K3 = sensitivities[ix].value * 100000; break; //Neutr=FN
		case SensitivityId::Sg1Sens07G: 
				K4 = sensitivities[ix].value * 100000; break; //Neutr=AN
		case SensitivityId::Fb1Sens07B: K5 = sensitivities[ix].value * 100000; break;
		case SensitivityId::Sg2Sens07B: K6 = sensitivities[ix].value * 100000; break;
			
		case SensitivityId::An1Sens10N: 	
			K4 = sensitivities[ix].value * 100000; break;
		case SensitivityId::Fn1Sens10N:
			K3 = sensitivities[ix].value * 100000; break;
		default: 
		//	sid = (SensitivityId)sensitivities[ix].id;
			//Kx = sensitivities[ix].value * 100000;
			break;
		}
	}
}

void Epd3Base::Epd3U::decodeGains(int count) {

	//	 Neutron
	//  An1Sens10N = 14,
	//	Fn1Sens10N = 15,
	//	Fn2Sens10N = 16,
	//float Kx = 0;
	GainAn = GainFn = 0.0F;
	//SensitivityId sid = SensitivityId::Hg1Sens10G;
	for (int ix = count - 1; ix >= 0; ix--) {
		switch ((SensitivityId)gains[ix].id)
		{
		case SensitivityId::An1Sens10N:
			GainAn = gains[ix].value ; break;
		case SensitivityId::Fn1Sens10N:
			GainFn = gains[ix].value ; break;
		default:
			break;
		}
	}
}

void Epd3Base::Epd3U::decodetotDoses(int count)
{
	//doses
	Hp10Total = Hp07Total = 0;
	for (int ix = 0; ix < count; ix++)
	{
		switch ((MeasurementId)doses[ix].id) {
		case MeasurementId::Meas_Hp07: Hp07Total = doses[ix].value; break;
		case MeasurementId::Meas_Hp10: Hp10Total = doses[ix].value; break;
		case MeasurementId::Meas_Hp10N: Hp07Total = doses[ix].value; break;
		case MeasurementId::Meas_Hp10G: Hp10Total = doses[ix].value; break;
		}
	}
}
void Epd3Base::Epd3U::decodeDoses(int count)
{
	//doses
	Hp10Dose = Hp07Dose = 0;
	for (int ix = 0; ix < count; ix++)
	{
		switch ((MeasurementId)doses[ix].id) {
		case MeasurementId::Meas_Hp07: Hp07Dose = doses[ix].value; break;
		case MeasurementId::Meas_Hp10: Hp10Dose = doses[ix].value; break;
		case MeasurementId::Meas_Hp10N: Hp07Dose = doses[ix].value; break;
		case MeasurementId::Meas_Hp10G: Hp10Dose = doses[ix].value; break;
		}
	}
}
void Epd3Base::Epd3U::decodePeakRates(int count)
{
	//Rates
	Hp10Peak = Hp07Peak = 0;
	Hp10Time = Hp07Time = 0;

	/*SYSTEMTIME st07,st10;*/
	for (int ix = 0; ix < count; ix++)
	{
		switch ((MeasurementId)peakRates[ix].id) {
		case MeasurementId::Meas_Hp07:
		case MeasurementId::Meas_Hp10N:
			Hp07Peak = peakRates[ix].value;
			Hp07Time = peakRates[ix].timestamp;
			TimeFunctions::Epd3TimeToFileTime(Hp07Time, (LPFILETIME)&Hp07FTime);
			//FileTimeToSystemTime(&Hp07FTime, &st07);
			break;
		case MeasurementId::Meas_Hp10:
		case MeasurementId::Meas_Hp10G:
			Hp10Peak = peakRates[ix].value;
			Hp10Time = peakRates[ix].timestamp;
			TimeFunctions::Epd3TimeToFileTime(Hp10Time, (LPFILETIME)&Hp10FTime);
			//FileTimeToSystemTime(&Hp10FTime, &st10);
			break;
		}
	}
}
void Epd3Base::Epd3U::SetReleaseLogging(bool doLog)
{
	g_EnableReleaseLogging = doLog;
}

void Epd3Base::Epd3U::decodeCounters(int count)
{
	HG = SG = BC = FB = 0;
	for (int ix = 0; ix < count; ix++)
	{
		switch ((CounterType)Counts[ix].type) {
		case CounterType::Counter_Hg1: HG = Counts[ix].value; break;
		case CounterType::Counter_Sg1: SG = Counts[ix].value; break;
		case CounterType::Counter_Sg2: BC = Counts[ix].value; break;
		case CounterType::Counter_Fb1: FB = Counts[ix].value; break;
		}
	}
}
void Epd3Base::Epd3U::decodeBaseCounters(int count)
{
	D1 = D2 = D3 = D4 = 0;
	for (int ix = 0; ix < count; ix++)
	{
		switch ((CounterType)Counts[ix].type) {
		case CounterType::Counter_Hg1: D1 = Counts[ix].value; break;
		case CounterType::Counter_Sg1: D2 = Counts[ix].value; break;
		case CounterType::Counter_Sg2: D3 = Counts[ix].value; break;
		case CounterType::Counter_Fb1: D4 = Counts[ix].value; break;
		}
	}
}
void Epd3Base::Epd3U::decodeTreshold(Mk3AlarmThresholds_t* th)
{
	float* pThDose = nullptr, * pThRate = nullptr, * pTHDoseWarning = nullptr, * pTHRateWarning = nullptr;
	switch ((MeasurementId)th->MeasId)
	{
	case MeasurementId::Meas_Hp07:
	case MeasurementId::Meas_Hp10N:
		Hp07THDose = 0; Hp07RateOn = 0; Hp07RateOff = 0;
		pThDose = &Hp07THDose;
		pThRate = &Hp07RateOn;
		pTHDoseWarning = &Hp07THDoseA;
		pTHRateWarning = &Hp07RateAOn;
		break;
	case MeasurementId::Meas_Hp10:
		Hp10THDose1 = 0; Hp10THDose2 = 0;
		Hp10Rate1On = Hp10Rate2On = Hp10Rate1Off = Hp10Rate2Off = 0;
		pThDose = &Hp10THDose2;
		pThRate = &Hp10Rate2On;
		pTHDoseWarning = &Hp10THDose1;
		pTHRateWarning = &Hp10Rate1Off;
		break;
	}

	for (int ix = 0; ix < th->NumberThresholds; ix++)
	{
		switch ((ThresholdId)th->Thresholds[ix].Id) {
		case ThresholdId::Thres_DoseAlarm: if (pThDose != nullptr) *pThDose = th->Thresholds[ix].Value; break;
		case ThresholdId::Thres_DoseWarning:  if (pTHDoseWarning != nullptr) *pTHDoseWarning = th->Thresholds[ix].Value; break;
		case ThresholdId::Thres_RateAlarm: if (pThRate != nullptr) *pThRate = th->Thresholds[ix].Value; break;
		case ThresholdId::Thres_RateWarning:  if (pTHRateWarning != nullptr) *pTHRateWarning = th->Thresholds[ix].Value; break;
		}
	}
}
void Epd3Base::Epd3U::encodeTreshold(Mk3AlarmThresholds_t* th)
{
	//th.MeasId
	float* pThDose, * pThRate, * pTHDoseWarning, * pTHRateWarning;
	//Voorlopig
	Hp07THDoseA = Hp07THDose * 0.8F;
	Hp07RateAOn = Hp07RateOn * 0.8F;
	// einde voorlopig
	th->NumberThresholds = 4;
	switch ((MeasurementId)th->MeasId) {
	case MeasurementId::Meas_Hp07:
	case MeasurementId::Meas_Hp10N:
		pThDose = &Hp07THDose;
		pTHDoseWarning = &Hp07THDoseA;
		pThRate = &Hp07RateOn;
		pTHRateWarning = &Hp07RateAOn;
		RatePct[0].MeasId = th->MeasId;
		RatePct[0].Value = 85; // (int)(Hp07RateOff * 100.0 / Hp07RateOn);
		break;
	case MeasurementId::Meas_Hp10:
	case MeasurementId::Meas_Hp10G:
		pThDose = &Hp10THDose2;
		pThRate = &Hp10Rate2On;
		pTHDoseWarning = &Hp10THDose1;
		pTHRateWarning = &Hp10Rate1On;
		RatePct[1].MeasId = th->MeasId;
		RatePct[1].Value = 85; // (int)(Hp10Rate2Off * 100.0 / Hp10Rate2On);
		break;
	default:
		pThDose = &Hp07THDose;
		pTHDoseWarning = &Hp07THDoseA;
		pThRate = &Hp07RateOn;
		pTHRateWarning = &Hp07RateAOn;
	}

	th->Thresholds[0].Id = (uint16_t)ThresholdId::Thres_DoseAlarm;
	th->Thresholds[0].Value = *pThDose;
	th->Thresholds[1].Id = (uint16_t)ThresholdId::Thres_RateAlarm;
	th->Thresholds[1].Value = *pThRate;
	th->Thresholds[2].Id = (uint16_t)ThresholdId::Thres_DoseWarning;
	th->Thresholds[2].Value = *pTHDoseWarning;
	th->Thresholds[3].Id = (uint16_t)ThresholdId::Thres_RateWarning;
	th->Thresholds[3].Value = *pTHRateWarning;
}
/// <summary>
/// HG, SG, BC, FB, BC, FB
/// </summary>
/// <param name="numdTresholds"></param>
void Epd3Base::Epd3U::decodedTresholds(int numdTresholds)
{
	for (int ix = 0; ix < numdTresholds; ix++) {
		switch ((CounterType)dTresholds[ix].type) {
		case CounterType::Counter_Hg1: HG = dTresholds[ix].value; break;
		case CounterType::Counter_Sg1: SG = dTresholds[ix].value; break;
		case CounterType::Counter_Sg2: BC = dTresholds[ix].value; break;
		case CounterType::Counter_Fb1: FB = dTresholds[ix].value; break;
		case CounterType::Counter_An1: BC = dTresholds[ix].value; break; //AN-> BC
		case CounterType::Counter_Fn2: FB = dTresholds[ix].value; break; //FN->FB
		default:
			break;
		}
	}
}

/// <summary>
/// Read  K1 = K2 = K3 = K4 = K4 = K6 
/// </summary>
/// <returns></returns>
WORD Epd3Base::Epd3U::ReadCal()
{
	int r = 0, r2 = 0;
	Error = 0;
	r = RunComsTransaction(eFunctions::ReadSensitivities, 0,
		[&](auto cb) {
			return BeginReadSensitivities(epdComsHandle, nullptr, 0, cb);
		},
		[&](auto token) {
			return  EndReadSensitivities(epdComsHandle, token, sensitivities, MaxSensitivities, &numSensitivities);
		}, 10
	);

	//SetFunctionReturnValue(ReadSensitivities, 0, 0);
	//token = BeginReadSensitivities(epdComsHandle, nullptr, 0, nullptr);
	//r = CommitAndSetRV();
	//if (!r) {
	//	r = EndReadSensitivities(epdComsHandle, token, sensitivities, MaxSensitivities, &numSensitivities);
	//	r = SetEndReturnValue(r);
	//}
	//if (r) {
	//	if (r == r_ErrorNotConnected) r=ReConnect();
	//	
	//		SetFunctionReturnValue(ReadSensitivities, 0, 1);
	//		token = BeginReadSensitivities(epdComsHandle, nullptr, 0, nullptr);
	//		r = CommitAndSetRV();
	//		if (!r) {
	//			r = EndReadSensitivities(epdComsHandle, token, sensitivities, MaxSensitivities, &numSensitivities);
	//			r = SetEndReturnValue(r);
	//		}
	//}

	if (r != 0) {
		SetEvent(hCancel);
		goto error;
	}

	decodeSensitivities(numSensitivities);


	r = RunComsTransaction(eFunctions::ReadGains, 0,
		[&](auto cb) {
			return BeginReadGains(epdComsHandle, nullptr, 0, cb);
		},
		[&](auto token) {
			return  EndReadGains(epdComsHandle, token, gains, MaxGains, &numGains);
		}, 10
	);

	/*SetFunctionReturnValue(ReadGains, 0, 0);
	token = BeginReadGains(epdComsHandle, nullptr, 0, nullptr);
	r = CommitAndSetRV();
	if (!r) {
		r = EndReadGains(epdComsHandle, token, gains, MaxGains, &numGains);
		r = SetEndReturnValue(r);
	}

	if (r) {
		if (r == r_ErrorNotConnected) r=ReConnect();
	
			SetFunctionReturnValue(ReadGains, 0, 1);
			token = BeginReadGains(epdComsHandle, nullptr, 0, nullptr);
			r = CommitAndSetRV();
			if (!r) {
				r = EndReadGains(epdComsHandle, token, gains, MaxGains, &numGains);
				r = SetEndReturnValue(r);
			}
	}*/

	if (r != 0) {
		SetEvent(hCancel);
		goto error;
	}
	decodeGains(numGains); //GainAn en GainFn

	return r;

error:
	Error = r;
	return r;
}
/// <summary>
/// K1 .. K6, SG , BC ,FB , HG
/// </summary>
/// <returns>0 OK</returns>
WORD Epd3Base::Epd3U::ReadSensitivitiesAndTresholds()
{
	int32_t r = 0;
	if (Epd.Gen == EpdGeneration::Mk2) {
		uint16_t HGSens10;
		uint16_t SGSens10;
		uint16_t HGSens07;
		uint16_t SGSens07;
		uint16_t FBSens07;
		uint16_t BCSens07;
		uint16_t SGthresh;
		uint16_t BCthresh;
		uint16_t FBthresh;
		uint16_t HGthresh;

		CompletionToken token = BeginReadCalibrationData_R2(epdComsHandle, nullptr);
		r = Commit3(epdComsHandle);
		r = EndReadCalibrationData_R2(epdComsHandle, token,
			&HGSens10,
			&SGSens10,
			&HGSens07,
			&SGSens07,
			&FBSens07,
			&BCSens07,
			&SGthresh,
			&BCthresh,
			&FBthresh,
			&HGthresh
		);


		K1 = HGSens10;
		K2 = SGSens10;
		K3 = HGSens07;
		K4 = SGSens07;
		K5 = FBSens07;
		K6 = BCSens07;
		SG = SGthresh;
		BC = BCthresh;
		FB = FBthresh;
		HG = HGthresh;
	}
	else {
		r = RunComsTransaction(eFunctions::ReadDetectorThresholds, 0,
			[&](auto cb) {
				return BeginReadDetectorThresholds_R3(epdComsHandle, nullptr, 0, cb);
			},
			[&](auto token) {
				return  EndReadDetectorThresholds_R3(epdComsHandle, token, dTresholds, MaxTresholds, &numTresholds);
			}, 10
		);

		/*SetFunctionReturnValue(ReadDetectorThresholds, 0,	0);
		token = BeginReadDetectorThresholds_R3(epdComsHandle, nullptr, 0, nullptr);
		r = Commit3(epdComsHandle);
		SetCommitReturnValue(r);
		r = EndReadDetectorThresholds_R3(epdComsHandle, token, dTresholds, MaxTresholds, &numTresholds);
		r = SetEndReturnValue(r);
		if (r != 0) {
			if (r == r_ErrorNotConnected) r = ReConnect();
			SetFunctionReturnValue(ReadDetectorThresholds, 0, 1);
			token = BeginReadDetectorThresholds_R3(epdComsHandle, nullptr, 0, nullptr);
			r = CommitAndSetRV();
			if (!r) r = EndReadDetectorThresholds_R3(epdComsHandle, token, dTresholds, MaxTresholds, &numTresholds);
			r = SetEndReturnValue(r);
		}*/

		if (r != 0) {
			SetEvent(hCancel);
			goto error;
		}

		decodedTresholds(numTresholds); // HG, SG, BC, FB, BC, FB
		r = ReadCal();// K1 = K2 = K3 = K4 = K4 = K6 
	}
	return r;
error:
	return r;
}

/// <summary>
/// Doses, totDoses, Knocks + Resets ,  PeakRates, SensitivitiesAndTresholds: K1 .. K6, SG , BC ,FB , HG
/// </summary>
/// <returns>0 OK</returns>
WORD Epd3Base::Epd3U::ReadDoses()
{
	int32_t r = 1;
	eDosDose07Warning = eDosDose07Alarm = eDosDose10Warning = eDosDose10Alarm = eDosRate07Warning = eDosRate07Alarm = eDosRate10Warning = eDosRate10Alarm = eDosBatteryWarning = 0;

	if (port == 0) {
		Hp10Dose = Hp07Dose = Hp10Total = Hp07Total = 0.0;
		Knocks = Resets = QualityData = 21;
		Hp10Peak = Hp07Peak = 0.0;
		Hp10Time = Hp07Time = 1000;
		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 r_OK;
	}

	numDoses = 0; utc = 0;

	r = RunComsTransaction(eFunctions::fReadDoses, 0,
		[&](auto cb) {
			return BeginReadDoses(epdComsHandle, nullptr, 0, cb);
		},
		[&](auto token) {
			return   EndReadDoses(epdComsHandle, token, doses, MaxDoses, &numDoses, &utc);
		}, 10
	);

	/*SetFunctionReturnValue(eFunctions::fReadDoses,0);
	token = BeginReadDoses(epdComsHandle, nullptr, 0, nullptr);
	r = Commit3(epdComsHandle);
	SetCommitReturnValue(r);
	if (!r) r = EndReadDoses(epdComsHandle, token, doses, MaxDoses, &numDoses, &utc);
	r = SetEndReturnValue(r);
	if (r) {
		SetFunctionReturnValue(eFunctions::fReadDoses, 0,1);
		token = BeginReadDoses(epdComsHandle, nullptr, 0, nullptr);
		r = Commit3(epdComsHandle);
		SetCommitReturnValue(r);
		if (!r) r = EndReadDoses(epdComsHandle, token, doses, MaxDoses, &numDoses, &utc);
		r = SetEndReturnValue(r);
		}*/
	if (r != 0)
		goto error;

	decodeDoses(numDoses);

	r = RunComsTransaction(eFunctions::ReadTotalDoses, 0,
		[&](auto cb) {
			return BeginReadTotalDoses(epdComsHandle, nullptr, 0, cb);
		},
		[&](auto token) {
			return   EndReadTotalDoses(epdComsHandle, token, totdoses, MaxDoses, &numtotDoses, &utc);
		}, 10
	);

	//SetFunctionReturnValue(eFunctions::ReadTotalDoses,0);
	//token = BeginReadTotalDoses(epdComsHandle, nullptr, 0, nullptr);
	//r = Commit3(epdComsHandle);
	//SetCommitReturnValue(r);
	//if (!r) r = EndReadTotalDoses(epdComsHandle, token, totdoses, MaxDoses, &numtotDoses, &utc);
	//r = SetEndReturnValue(r);
	//if (r) {
	//	SetFunctionReturnValue(eFunctions::ReadTotalDoses, 0, 1);
	//	token = BeginReadTotalDoses(epdComsHandle, nullptr, 0, nullptr);
	//	r = Commit3(epdComsHandle);
	//	SetCommitReturnValue(r);
	//	if (!r) r = EndReadTotalDoses(epdComsHandle, token, totdoses, MaxDoses, &numtotDoses, &utc);
	//	r = SetEndReturnValue(r);
	//}
	if (r != 0)
		goto error;
	
	decodetotDoses(numtotDoses);

	r = RunComsTransaction(eFunctions::ReadQualityData, 0,
		[&](auto cb) {
			return BeginReadQualityData(epdComsHandle, cb);
		},
		[&](auto token) {
			return   EndReadQualityData(epdComsHandle, token, &quality);
		}, 10
	);

	//SetFunctionReturnValue(eFunctions::ReadQualityData,0);
	//token = BeginReadQualityData(epdComsHandle, nullptr);
	//r = Commit3(epdComsHandle);
	//SetCommitReturnValue(r);
	//if (!r) r = EndReadQualityData(epdComsHandle, token, &quality);
	//r = SetEndReturnValue(r);

	if (r != 0)
		goto error;

	Knocks = quality.Knocks;
	Resets = quality.PowerCycles;

	r = RunComsTransaction(eFunctions::ReadPeakRates, 0,
		[&](auto cb) {
			return BeginReadPeakRates(epdComsHandle, nullptr, 0, cb);
		},
		[&](auto token) {
			return   EndReadPeakRates(epdComsHandle, token, peakRates, MaxPeakRates, &numRates);
		}, 10
	);
	
	//SetFunctionReturnValue(eFunctions::ReadPeakRates,0);
	//token = BeginReadPeakRates(epdComsHandle, nullptr, 0, nullptr);
	//r = Commit3(epdComsHandle);
	//SetCommitReturnValue(r);
	//if (!r) r = EndReadPeakRates(epdComsHandle, token, peakRates, MaxPeakRates, &numRates);
	//r= SetEndReturnValue(r);

	if (r != 0)
		goto error;


	decodePeakRates(numRates);

	
	r = ReadSensitivitiesAndTresholds(); //K1 .. K6, SG , BC ,FB , HG
	if (r != 0)
		goto error;

	return r;

error:
	Error = r;
	return r;
}
/// <summary>
/// 
/// </summary>
/// <returns>0 success</returns>
int  Epd3Base::Epd3U::ClearDoses()
{
	int rv;
	rv = RunComsTransaction(eFunctions::ClearTotalDose, 0,
		[&](auto cb) {
			return BeginClearTotalDose(epdComsHandle, cb);
		},
		[&](auto token) {
			return   EndClearTotalDose(epdComsHandle, token);
		}, 10
	);

	/*SetFunctionReturnValue(eFunctions::ClearTotalDose,0);
	token = BeginClearTotalDose(epdComsHandle, nullptr);
	rv = CommitAndEnd2RV(EndClearTotalDose, token);
	if (rv) {
			rv = ReConnect();
			SetFunctionReturnValue(eFunctions::ClearTotalDose, 0,1);
			token = BeginClearTotalDose(epdComsHandle, nullptr);
			rv = CommitAndEnd2RV(EndClearTotalDose, token,100);
	}*/
	if (rv) goto error;

	rv = RunComsTransaction(eFunctions::ClearDose, 0,
		[&](auto cb) {
			return BeginClearDose(epdComsHandle, cb);
		},
		[&](auto token) {
			return   EndClearDose(epdComsHandle, token);
		}, 10
	);

	//SetFunctionReturnValue(eFunctions::ClearDose,0);
	//token= BeginClearDose(epdComsHandle, nullptr);
	//rv = CommitAndEnd2RV(EndClearDose, token);
	//if (rv) {
	//	rv = ReConnect();
	//	SetFunctionReturnValue(eFunctions::ClearDose, 0, 1);
	//	token = BeginClearDose(epdComsHandle, nullptr);
	//	rv = CommitAndEnd2RV(EndClearDose, token);
	//}

	if (rv) goto error;

	rv = RunComsTransaction(eFunctions::ClearPeakRates, 0,
		[&](auto cb) {
			return BeginClearPeakRates(epdComsHandle, cb);
		},
		[&](auto token) {
			return   EndClearPeakRates(epdComsHandle, token);
		}, 10
	);

	//SetFunctionReturnValue(eFunctions::ClearPeakRates,0);
	//token= BeginClearPeakRates(epdComsHandle, nullptr);
	//rv = CommitAndEnd2RV(EndClearPeakRates, token);
	//if (rv) {
	//	rv = ReConnect();
	//	SetFunctionReturnValue(eFunctions::ClearPeakRates, 0, 1);
	//	token = BeginClearPeakRates(epdComsHandle, nullptr);
	//	rv = CommitAndEnd2RV(EndClearPeakRates, token);
	//}
	if (rv) goto error;


	error:
		Error = rv;

	return rv;
}

int Epd3Base::Epd3U::ClearAlarms()
{
	int rv;
	
	rv = RunComsTransaction(eFunctions::ClearFaultStatus, 0,
		[&](auto cb) {
			return BeginClearFaultStatus(epdComsHandle, cb);
		},
		[&](auto token) {
			return   EndClearFaultStatus(epdComsHandle, token);
		}, 10
	);

	//SetFunctionReturnValue(eFunctions::ClearFaultStatus,0);
	//token= BeginClearFaultStatus(epdComsHandle, nullptr);
	//rv = CommitAndEnd2RV(EndClearFaultStatus, token,100);

	//if (rv) {
	//		rv = ReConnect();
	//		SetFunctionReturnValue(eFunctions::ClearFaultStatus, 0,1);
	//		token = BeginClearFaultStatus(epdComsHandle, nullptr);
	//		rv = CommitAndEnd2RV(EndClearFaultStatus, token,100);
	//}

	rv = RunComsTransaction(eFunctions::ClearLatchedAlarms, 0,
		[&](auto cb) {
			return BeginClearLatchedAlarms(epdComsHandle, cb);
		},
		[&](auto token) {
			return   EndClearLatchedAlarms(epdComsHandle, token);
		}, 10
	);

	//SetFunctionReturnValue(eFunctions::ClearLatchedAlarms, 0);
	//token	= BeginClearLatchedAlarms(epdComsHandle, nullptr);
	//rv = CommitAndEnd2RV(EndClearLatchedAlarms, token,100);
	//if (rv) {
	//		rv = ReConnect();
	//		SetFunctionReturnValue(eFunctions::ClearLatchedAlarms, 0,1);
	//		token = BeginClearLatchedAlarms(epdComsHandle, nullptr);
	//		rv = CommitAndEnd2RV(EndClearLatchedAlarms, token,100);
	//}
	
	return rv;
}


WORD Epd3Base::Epd3U::SetCalDueDate() {
	UINT32 utc = TimeFunctions::NewCalDueTime();
	int rv = RunComsTransaction(eFunctions::fSetCalDueDate, 0,
		[&](auto cb) {
			return BeginWriteCalDueDate_R3(epdComsHandle, utc, cb);
		},
		[&](auto token) {
			return   EndWriteCalDueDate_R3(epdComsHandle, token);
		}, 10
	);

	//SetFunctionReturnValue(eFunctions::fSetCalDueDate, 0);
	//uint32_t rv;
	//token = BeginWriteCalDueDate_R3(epdComsHandle, utc, nullptr);
	//rv = CommitAndEnd2RV(EndWriteCalDueDate_R3, token);
	return rv;

}

WORD Epd3Base::Epd3U::PrepareForIssue()
{
	int rv = 0;

	if (port == 0) return 0;

	EPDStep = EpdSteps::StepPrepareIssue;
	EPDStepResult = EpdStepResults::Started;
	EPDSubStep = 1;
	if (WriteConfig32) {
		rv = WriteConfig();
	}
	EPDSubStep = 2;

	if (!DetectorsOn) {
		rv = SetEpdON();

		/*SetFunctionReturnValue(eFunctions::EpdOn, 0,0);
		token = BeginEpdOnOff(epdComsHandle, 1, nullptr);
		rv = CommitAndEnd2RV(EndEpdOnOff, token,10);
		if (rv) {
			Sleep(100);
			rv = ReConnect();
			SetFunctionReturnValue(eFunctions::EpdOn, 0, 1);
			token = BeginEpdOnOff(epdComsHandle, 1, nullptr);
			rv = CommitAndEnd2RV(EndEpdOnOff, token,10);
		}*/
		if (!rv)	 DetectorsOn = 1;
		Sleep(200);
	}
	if (rv != 0)
	{
		EPDStepResult = EpdStepResults::Error;
		goto error;
	}

	EPDSubStep = 3;
	rv = ClearAlarms();
	if (rv != 0) {
		EPDStepResult = EpdStepResults::Error;
		goto error;
	}

	EPDSubStep = 4;
	rv = ClearDoses();
	if (rv != 0)
	{
		EPDStepResult = EpdStepResults::Error;
		goto error;
	}

	EPDSubStep = 5;
	EPDStepResult = EpdStepResults::Sleeping;
	
	if (progressCallback) {
		progressCallback(EpdSteps::StepSleep, EpdStepResults::OK);
		DebugWrite("****    After sleep callback\n");
	}


	switch (WaitForSingleObject(hCancel, SleepAfterClear)) 
	{
		case WAIT_OBJECT_0:
			DebugWrite("****    After sleep callback, cancel event set\n");
			rv = r_ErrorUserCancelled;
			goto error;
		case WAIT_TIMEOUT:
			rv = r_OK;
			break;
		default: 
			rv = r_OperationFailed; // WAIT_ABANDONED
			break;
	}

	if (DoDisconnectAfterClear) {
		if (isConnected && epdComsHandle) {
			SetFunctionReturnValue(fDisconnect, 1,0);
			rv = Disconnect(epdComsHandle);
			rv = SetEndReturnValue(rv);
		}
		isConnected = false;
	}


	EPDStepResult = EpdStepResults::OK;
	if (progressCallback) { 
		progressCallback(EPDStep, EPDStepResult); 
	}

	return rv;

error:
	DebugWrite("****    After clear step {} error {} ****\n", EPDSubStep, rv);
	ErrorStep = EPDSubStep;
	Error = rv;
	if (progressCallback) progressCallback(EPDStep, EPDStepResult);
	SetEvent(hCancel);
	return rv;
}


WORD Epd3Base::Epd3U::ReadAlarmConfig() {
	//Alleen MK3 ? leeg bij MK2
	numAlarm = 0;
	int r = RunComsTransaction(eFunctions::ReadAlarmConfiguration, 0,
		[&](auto cb) {
			return BeginReadAlarmConfiguration(epdComsHandle, nullptr, 0, cb);
		},
		[&](auto token) {
			return  EndReadAlarmConfiguration(epdComsHandle, token, alarmConfig, MaxAlarmConfig, &numAlarm);
		}, 10
	);

	/*SetFunctionReturnValue(eFunctions::ReadAlarmConfiguration,0);
	token = BeginReadAlarmConfiguration(epdComsHandle, nullptr, 0, nullptr);
	int32_t r = CommitAndSetRV();
	if (!r)  r = EndReadAlarmConfiguration(epdComsHandle, token, alarmConfig, MaxAlarmConfig, &numAlarm);	
	SetEndReturnValue(r); */
	return numAlarm;
}
WORD Epd3Base::Epd3U::ReadAlarmTresholds() {
	//Alleen MK3 ? leeg bij MK2
	bool isNeutron = (EpdType == EpdTypes::Mk2Neutron || EpdType == EpdTypes::Mk3Neutron);
	uint8_t measID;
	int32_t r;

	if (isNeutron) measID = (uint8_t)MeasurementId::Meas_Hp10N; else measID = (uint8_t)MeasurementId::Meas_Hp07;
	hp07tresholds.MeasId = measID;
	r = RunComsTransaction(eFunctions::ReadAlarmThresholds, 0,
		[&](auto cb) {
			return BeginReadAlarmThresholds(epdComsHandle, (uint8_t)hp07tresholds.MeasId, nullptr, 0, cb);
		},
		[&](auto token) {
			return  EndReadAlarmThresholds(epdComsHandle, token, &hp07tresholds);
		}, 10
	);

	/*SetFunctionReturnValue(eFunctions::ReadAlarmThresholds,0);
	token = BeginReadAlarmThresholds(epdComsHandle, (uint8_t)hp07tresholds.MeasId, nullptr, 0, nullptr);
	r = CommitAndSetRV();
	if (!r)  r = EndReadAlarmThresholds(epdComsHandle, token, &hp07tresholds);	
	r = SetEndReturnValue(r); 
	if (r) {
		 r = ReConnect();
		SetFunctionReturnValue(eFunctions::ReadAlarmThresholds, 0, 1);
		token = BeginReadAlarmThresholds(epdComsHandle, (uint8_t)hp07tresholds.MeasId, nullptr, 0, nullptr);
		r = CommitAndSetRV();
		if (!r)  r = EndReadAlarmThresholds(epdComsHandle, token, &hp07tresholds);
		r = SetEndReturnValue(r);
	}*/
	if (!r)
	decodeTreshold(&hp07tresholds);

	if (isNeutron) measID = (uint8_t)MeasurementId::Meas_Hp10G; else measID = (uint8_t)MeasurementId::Meas_Hp10;
	hp10tresholds.MeasId = measID;
	r = RunComsTransaction(eFunctions::ReadAlarmThresholds, 0,
		[&](auto cb) {
			return BeginReadAlarmThresholds(epdComsHandle, (uint8_t)hp10tresholds.MeasId, nullptr, 0, cb);
		},
		[&](auto token) {
			return  EndReadAlarmThresholds(epdComsHandle, token, &hp10tresholds);
		}, 10
	);


	return r;
}

WORD Epd3Base::Epd3U::WriteAlarmTresholds() {
	//Alleen MK3 ? leeg bij MK2
	uint32_t r;

	bool isNeutron = (EpdType == EpdTypes::Mk2Neutron || EpdType == EpdTypes::Mk3Neutron);
	uint8_t measID;

	if (isNeutron) measID = (uint8_t)MeasurementId::Meas_Hp10G; else measID = (uint8_t)MeasurementId::Meas_Hp10;
	hp10tresholds.MeasId = measID;
	encodeTreshold(&hp10tresholds);

	r = RunComsTransaction(eFunctions::WriteAlarmThresholdsHP10, 0,
		[&](auto cb) {
			return BeginWriteAlarmThresholds(epdComsHandle, (uint8_t)hp10tresholds.MeasId, (uint8_t)hp10tresholds.NumberThresholds, hp10tresholds.Thresholds, cb);
		},
		[&](auto token) {
			return  EndWriteAlarmThresholds(epdComsHandle, token);
		}, 10
	);


	if (r != 0)
		goto error;


	if (isNeutron) measID = (uint8_t)MeasurementId::Meas_Hp10N; else measID = (uint8_t)MeasurementId::Meas_Hp07;
	hp07tresholds.MeasId = measID;
	encodeTreshold(&hp07tresholds);
	hp07tresholds.NumberThresholds = 4;

	r = RunComsTransaction(eFunctions::WriteAlarmThresholdsHP07, 0,
		[&](auto cb) {
			return BeginWriteAlarmThresholds(epdComsHandle, (uint8_t)hp07tresholds.MeasId, (uint8_t)hp07tresholds.NumberThresholds, hp07tresholds.Thresholds, cb);
		},
		[&](auto token) {
			return  EndWriteAlarmThresholds(epdComsHandle, token);
		}, 10
	);

	
	if (r != 0)		
		goto error;

	r = RunComsTransaction(eFunctions::WriteRateOffPercentage, 0,
		[&](auto cb) {
			return BeginWriteRateOffPercentage(epdComsHandle, RatePct, 2, cb);
		},
		[&](auto token) {
			return  EndWriteRateOffPercentage(epdComsHandle, token);
		}, 10
	);

	//SetFunctionReturnValue(eFunctions::WriteRateOffPercentage,0,0);
	//token = BeginWriteRateOffPercentage(epdComsHandle, RatePct, 2, nullptr);
	//r = CommitAndEnd2RV(EndWriteRateOffPercentage, token);
	//if (r) {
	//	r = ReConnect();
	//	SetFunctionReturnValue(eFunctions::WriteRateOffPercentage, 0, 1);
	//	token = BeginWriteRateOffPercentage(epdComsHandle, RatePct, 2, nullptr);
	//	r = CommitAndEnd2RV(EndWriteRateOffPercentage, token);
	//}

error:
	return r;

}

WORD Epd3Base::Epd3U::DeIssue()
{
	int r =01;
	EPDStep = EpdSteps::StepDeIssue;
	EPDStepResult = EpdStepResults::Started;

	if (port == 0) return 0;
	if (Epd.Id== 0) return 0;
	
	if (EPDIssued)
	{
		if (!isConnected)  r = ReConnect(); 
#if DeissueWithClear
		ErrorStep = 2;
		r = ClearDoses();
		ErrorStep = 1;
		r = ClearAlarms();
		//needed after clear alarms
		Sleep(2000);
#endif

		r = RunComsTransaction(eFunctions::DeissueEPD, 0,
			[&](auto cb) {
				return BeginDeissueEPD(epdComsHandle, cb);
			},
			[&](auto token) {
				return  EndDeissueEPD(epdComsHandle, token);
			}, 20
		);

		if (r == 0)
			EPDStepResult = EpdStepResults::OK; 
		else 	
			EPDStepResult = EpdStepResults::Error;
		Sleep(50);
	}
	progressCallback(EPDStep, EPDStepResult);


	Sleep(100);
	r = SetEpdOFF();
	
	
	
	if (r) goto error;
	return r;

error:
	
	Error = r;
	return r;
}


WORD Epd3Base::Epd3U::WriteWearer() {

	int32_t r = 0;
	int step = 0;

	r = RunComsTransaction(eFunctions::SetBaselineCounters, 0,
		[&](auto cb) {
			return BeginSetBaselineCounters(epdComsHandle, cb);
		},
		[&](auto token) {
			return  EndSetBaselineCounters(epdComsHandle, token);
		}, 10
	);

	
	
	if (r != 0)
		goto error;

	IdString_t mk3WearerID;
	//Mk2 EPDs only support Name and Primary ID

	mk3WearerID.IdType = (uint16_t)WearerIdType::WearerId_Name;
	mk3WearerID.Length = 23;
	memcpy(mk3WearerID.Utf8String, WearerName, 23);

	r = RunComsTransaction(eFunctions::WriteWearerIdName, 0,
		[&](auto cb) {
			return BeginWriteWearerId(epdComsHandle, mk3WearerID, cb);
		},
		[&](auto token) {
			return  EndWriteWearerId(epdComsHandle, token);
		}, 10
	);

	
	if (r != 0)
		goto error;

	mk3WearerID.IdType = (uint16_t)WearerIdType::WearerId_Primary;
	mk3WearerID.Length = 13;
	memcpy(mk3WearerID.Utf8String, WearerID, 13);

	r = RunComsTransaction(eFunctions::WriteWearerIdPrimary, 0,
		[&](auto cb) {
			return BeginWriteWearerId(epdComsHandle, mk3WearerID, cb);
		},
		[&](auto token) {
			return  EndWriteWearerId(epdComsHandle, token);
		}, 10
	);

	
	if (r != 0)
		goto error;

	return r;

error:
	
	Error = r;
	return r;
}
/// <summary>
/// 
/// </summary>
/// <returns>0 Success</returns>

WORD Epd3Base::Epd3U::Issue(bool PrepareDone)  //normaal is preparedone=tru
{
	int r = 0;
	int step = 0;
	int tries = 0;
	UINT16 Control = 0;
	if (port == 0) return r;

	r = 0;
	if (!PrepareDone) {
		r = PrepareForIssue(); 
		if (r) 
			EPDStepResult = EpdStepResults::Error;
			goto error;
	}
	EPDStep = EpdSteps::StepIssue;
	EPDStepResult = EpdStepResults::Started;

	step = 1;
	if (!isConnected) r = ReConnect(); else r = 0;
	if (r) {
		EPDStepResult = EpdStepResults::Error;
		goto error;
	}



	step = 4;

	
#ifdef ProtectSession 
	if (isMK3) {
		Control = 1; // EndSessionControl;
		DoProtectSession = false;
		if (DoProtectSession) {
			r = RunComsTransaction(eFunctions::EnableProtectedSession, 0,
				[&](auto cb) {
					return BeginEnableProtectedSession(epdComsHandle, 1, cb);
				},
				[&](auto token) {
					return  EndIssueEPD(EndEnableProtectedSession, token);
				}, 10
			);
		}
	}
#else
	Control = 0;
#endif


	step = 2;
	r = WriteAlarmTresholds();
	if (r != 0)
	{
		EPDStepResult = EpdStepResults::Error;
		goto error;
	}

	step = 3;
	if (!isConnected)
		r=ReConnect();
	if (r != 0)
	{
		EPDStepResult = EpdStepResults::Error;
		goto error;
	}

	step = 4;
	r = WriteWearer();
	if (r != 0)
	{
		EPDStepResult = EpdStepResults::Error;
		goto error;
	}

	tries = 1;
	r = RunComsTransaction(eFunctions::IssueEPD, 0,
		[&](auto cb) {
			return BeginIssueEPD(epdComsHandle, cb);
		},
		[&](auto token) {
			return  EndIssueEPD(epdComsHandle, token);
		}, 400
	);

	/*SetFunctionReturnValue(eFunctions::IssueEPD,0,0);
	token = BeginIssueEPD(epdComsHandle, nullptr);
	r = CommitAndEnd2RV(EndIssueEPD, token, 500);
	if (r) {
		Sleep(200);
		tries++;
		r = ReConnect();
		SetFunctionReturnValue(eFunctions::IssueEPD,0,tries);
		token = BeginIssueEPD(epdComsHandle, nullptr);
		r = CommitAndEnd2RV(EndIssueEPD, token, 500);
	}*/
	if (r)
	{
		EPDStepResult = EpdStepResults::Error;
		goto error;
	}
	EPDIssued = 1;
	EPDStepResult = EpdStepResults::OK;
	
	Sleep(200);

	if (DoProtectSession) {
		r = RunComsTransaction(eFunctions::DisableProtectedSession, 0,
			[&](auto cb) {
				return BeginEnableProtectedSession(epdComsHandle, 0, cb);
			},
			[&](auto token) {
				return  EndIssueEPD(EndEnableProtectedSession, token);
			}, 10
		);
	}

	step = 6;
	if (isMK3) {
		r = DisCon(Control); //stops protected session if control is EndSessionCOntrol
	}

	step = 7;
	if (progressCallback) progressCallback(EPDStep, EPDStepResult);
	return r;

error:
	ErrorStep = step;
	Error = r;
	if (progressCallback) progressCallback(EPDStep, EPDStepResult);
	SetEvent(hCancel);
	return r;
}

WORD Epd3Base::Epd3U::EPDReadExtraStatus()
{
	if (port == 0) return 1;
	uint32_t r;

	r = RunComsTransaction(eFunctions::ReadBaselineCounts, 0,
		[&](auto cb) {
			return BeginReadBaselineCounts(epdComsHandle, cb);
		},
		[&](auto token) {
			return EndReadBaselineCounts(epdComsHandle, token, Counts, 10, &utc, &countsRead);
		}, 10
	);

	//SetFunctionReturnValue(eFunctions::ReadBaselineCounts,0);
	//token = BeginReadBaselineCounts(epdComsHandle, nullptr);
	//r = CommitAndSetRV();//  Commit3(epdComsHandle); SetCommitReturnValue(r);
	//if (!r) 
	//	r = EndReadBaselineCounts(epdComsHandle, token, Counts, 10, &utc, &countsRead);
	//r = SetEndReturnValue(r);
	
	if (!r) decodeBaseCounters(countsRead);

	return r;
}

WORD Epd3Base::Epd3U::WriteCal()
{
	uint32_t r = 0;
	if (port == 0) return 0;

	/*if (K6 > 2000)
	{
		r = 0;
		return 0;
	}*/

	if (EpdType == EpdTypes::Mk2Neutron)
	{
		Password = 9;

		r = RunComsTransaction(eFunctions::MfrLogin_R2, 0,
			[&](auto cb) {
				return BeginMfrLogin_R2(epdComsHandle, Password, cb);
			},
			[&](auto token) {
				return EndMfrLogin_R2(epdComsHandle, token);
			}, 10
		);

	/*	SetFunctionReturnValue(eFunctions::MfrLogin_R2,0);
		token = BeginMfrLogin_R2(epdComsHandle, Password, nullptr);
		uint32_t r = CommitAndEnd2RV(EndMfrLogin_R2,token,100);*/
		if (r != 0)
			goto error;

		r = RunComsTransaction(eFunctions::WriteSensitivities_R2, 0,
			[&](auto cb) {
				return BeginWriteSensitivities_R2(epdComsHandle, cb, (uint16_t)K1, (uint16_t)K2, (uint16_t)K3, (uint16_t)K4, (uint16_t)K5, (uint16_t)K6);
			},
			[&](auto token) {
				return EndWriteSensitivities_R2(epdComsHandle, token);
			}, 10
		);


		if (r != 0)
			goto error;
	} else 
		if (EpdType == EpdTypes::Mk3Neutron)
	{
		//Password = 9;


		//SetFunctionReturnValue(eFunctions::MfrLogin_R2, 0);
		//token = BeginMfrLogin_R2(epdComsHandle, Password, nullptr);
		//uint32_t r = CommitAndEnd2RV(EndMfrLogin_R2, token);
		////Commit3(epdComsHandle); SetCommitReturnValue(r);		if (!r ) r = EndMfrLogin_R2(epdComsHandle, token); SetEndReturnValue(r);
		//if (r != 0)
		//	goto error;

			r = RunComsTransaction(eFunctions::WriteAccessLevelAdmin, 0,
				[&](auto cb) {
					return BeginWriteAccessLevel(epdComsHandle, AccessLevel_t::Admin, EC, ECLen,cb);
				},
				[&](auto token) {
					return EndWriteAccessLevel(epdComsHandle, token);
				}, 10
			);

		//SetFunctionReturnValue(eFunctions::WriteAccessLevelAdmin, 0);
		//token = BeginWriteAccessLevel(epdComsHandle, AccessLevel_t::Admin, EC, ECLen, nullptr);
		//r = CommitAndEnd2RV(EndWriteAccessLevel, token);
		//if (r) {
		//	ReConnect();
		//	SetFunctionReturnValue(eFunctions::WriteAccessLevelAdmin, 1);
		//	token = BeginWriteAccessLevel(epdComsHandle, AccessLevel_t::Admin, EC, ECLen, nullptr);
		//	r = CommitAndEnd2RV(EndWriteAccessLevel, token);
		//}
		if (r != 0) 			goto error;

		
		numGains = 2;
		gains[0].id = (uint16_t) SensitivityId::An1Sens10N; //K4
		gains[0].value = GainAn;
		gains[1].id = (uint16_t)SensitivityId::Fn1Sens10N; //K3
		gains[1].value = GainFn;
		r = RunComsTransaction(eFunctions::WriteGains_R3, 0,
			[&](auto cb) {
				return BeginWriteGains(epdComsHandle, gains, numGains, cb);
			},
			[&](auto token) {
				return EndWriteGains(epdComsHandle, token);
			}, 10
		);
		//SetFunctionReturnValue(eFunctions::WriteGains_R3, 0);
		//token = BeginWriteGains(epdComsHandle, gains, numGains, nullptr);
		//r = CommitAndEnd2RV(EndWriteGains, token);
		if (r != 0)
			goto error;
	}
	return r;
error:
	return r;
}

//main get dose function
//close com at end
int Epd3Base::Epd3U::GetAll(bool Closeconnection)
{
	int rv = 0, step = 1;
	rv = ReadDoses();
	step=2;
	if (!rv) rv = ReadAlarmTresholds();
	if (Closeconnection) EndCom(isConnected );
	return rv;
}

// Main entry point deissue for MK3
// close com at then
int Epd3Base::Epd3U::GetAllDeissue(bool reconnect)
{
	int rv = 0;
	int step = 0;
	
	ResetStepReturnValues();

	step = 1;
	rv = ReadDoses();	  //0 = success
	if (rv) goto error;
	//rv = ReadAlarmTresholds(); //0 = success

	step = 2;
	rv = EPDReadExtraStatus();
	if (rv) goto error;

	step = 3;
	rv = DeIssue(); 
	
	EndCom(isConnected);
	if (rv) goto error;

	return rv;

error:
	Error = rv;
	ErrorStep = step;
	return rv;
}

// main issue routine
// cloise com at end
int Epd3Base::Epd3U::IssueAndCheck(float gain, float ChirpRate)
{
	int rv = 0;
	int step = 0;
	DWORD wrv = 0;
	int rv1 = -1, rv2 = -1;
	EPDStep = EpdSteps::StepIssue;
	EPDStepResult = EpdStepResults::Started;
	OutputDebugStringW(L"****    IssueAndCheck start ****\n");

	ResetStepReturnValues();

	rv = 0;
	if (!isConnected) rv = ReConnect();
	if (rv) 
		goto error;

	step = 1;

	//todo: Set off 

	//if (DetectorsOn) {
	rv = SetEpdOFF();
	Sleep(10);
	if (!isConnected) rv = ReConnect();
	DetectorsOn = 0;
	if (rv)
		goto error;

	OutputDebugStringW(L"****    IssueAndCheck step 1 settime ****\n");
	rv = SetTime();
	//synctime

	//Todo :: Set ON
	OutputDebugStringW(L"****    Prepare  IssueAndCheck   ****\n");
	step = 2;
	rv = PrepareForIssue(); //Set epd on, clear doses and alarms
	if (rv) 
		goto error;
	
	if (!isConnected) 
		rv = ReConnect();

	if (!rv) 
		rv = ReadStatusOnly();

	if (rv) { 
		SetEvent(hCancel); 
		goto error; 
	}


	step = 3;
	if (isNG) {
		step = 1;
		float kx = gain/100;
		rv = ReadCal();
		if (rv != 0 ) { //K6 test op 1310 || K6 != 1310 ??
				rv = 1; 
				EPDStepResult = EpdStepResults::Error;
				SetEvent(hCancel);
				goto error;
			
		}
		//K3 = Fn1Sens10N  K4 = An1Sens10N
		if (GainAn != kx || GainFn!= kx)
		{
			step = 2;
			GainAn=GainFn = kx;
			rv = WriteCal();
			if (rv != 0) 
			{
				EPDStepResult = EpdStepResults::Error;
				goto error;
			}
		}
	}

	step = 3;
	if (!isConnected) rv = ReConnect(); 

	if (!rv) rv = SetChirp(ChirpRate);

	if (rv) {
		EPDStepResult = EpdStepResults::Error;
		goto error;
	}

	OutputDebugStringW(L"****    step 5 issue ****\n");
	step = 5;
	rv = Issue(true); // data already loaded
	
	EndCom(isConnected);
	if (rv) {
		EPDStepResult = EpdStepResults::Error;
		goto error;
	}
	EPDStepResult = EpdStepResults::OK;
	progressCallback(EPDStep, EPDStepResult);
	return rv;

error:
	progressCallback(EPDStep, EPDStepResult);
	Error = rv;
	ErrorStep = step;
	return rv;
}

int Epd3Base::Epd3U::WriteConfig(void)
{
	bool isAdmin = false;
	if (port == 0 || WriteConfig32 == 0) return 1;
	int32_t r = 0;
	ECLen = 32;

	DebugWrite("****    WriteCfg v {}.{} {} {} ****\n", HardVersion, HardVersionMinor, HardVersionBuild, HardVersionRevision);
	if (!isConnected)	r = ReConnect(); 
	// Become admin
	if (!r) {
		r = RunComsTransaction(eFunctions::WriteAccessLevelAdmin, 0,
			[&](auto cb) {
				return  BeginWriteAccessLevel(epdComsHandle, AccessLevel_t::Admin, EC, ECLen, cb);
			},
			[&](auto token) {
				return EndWriteAccessLevel(epdComsHandle, token);
			}, 10
		);

		/*SetFunctionReturnValue(eFunctions::WriteAccessLevelAdmin, 0);
		token = BeginWriteAccessLevel(epdComsHandle, AccessLevel_t::Admin, EC, ECLen, nullptr);
		r = CommitAndEnd2RV(EndWriteAccessLevel, token);*/
		if (!r) { //ok
			isAdmin = true;
			std::vector<QuickAccessDisplay_t> vdisplayIds =
			{
				{ 0,0x0021 },
				{ 1,0x0022 },
				{ 2,0x0031 },
				{ 3,0x0032 },
				{ 4,0x0051 },
				{ 5,0x0062 }
			};
			r = RunComsTransaction(eFunctions::WriteQuickAccessDisplays_R3, 0,
				[&](auto cb) {
					return   BeginWriteQuickAccessDisplays_R3(epdComsHandle, vdisplayIds.data(), static_cast<uint8_t>(vdisplayIds.size()), cb);
				},
				[&](auto token) {
					return EndWriteQuickAccessDisplays_R3(epdComsHandle, token);
				}, 10
			);

			//SetFunctionReturnValue(eFunctions::WriteQuickAccessDisplays_R3, 1);
			//token = BeginWriteQuickAccessDisplays_R3(epdComsHandle, vdisplayIds.data(), static_cast<uint8_t>(vdisplayIds.size()), nullptr);
			//r = CommitAndEnd2RV(EndWriteQuickAccessDisplays_R3, token);
			
		}
	}
	if (r != 0)
		Error = r;
	if (!r && isAdmin) {

		if (SoftVersion >= 2) {
			r = RunComsTransaction(eFunctions::EnableTestSound, 0,
				[&](auto cb) {
					return BeginEnableTestSound_R3(epdComsHandle, 1, cb);
				},
				[&](auto token) {
					return EndEnableTestSound_R3(epdComsHandle, token);
				}, 100
			);
		}
	}
	
	if (!r && isAdmin) {

		r = RunComsTransaction(eFunctions::WriteDoseProfileInterval, 0,
			[&](auto cb) {
				return   BeginWriteDoseProfileInterval(epdComsHandle, 0, cb);
			},
			[&](auto token) {
				return EndWriteDoseProfileInterval(epdComsHandle, token);
			}, 10
		);

		/*SetFunctionReturnValue(eFunctions::WriteDoseProfileInterval, 1);
		token = BeginWriteDoseProfileInterval(epdComsHandle, 0, nullptr);
		r = CommitAndEnd2RV(EndWriteDoseProfileInterval, token, 100	);*/

	}
	if (!r && isAdmin) {
		//Unmanaged%20HtmlFiles/_display_ids.html
		//numItems = 5;
		//if (HardVersionMinor > 0) {
		//	enables = new DisplayAttributeMap_t[9]{
		//	//{ 0,0x3FFF,0xFFFF },
		//	{ 1,0x3FFF,0xFF01 },   //{ 1,0x0FFF,0xFFE1 }
		//	{ 2,0x3FFF,0xFE0F },
		//	{ 3,0x3FFF,0xFE0F },
		//	{ 4,0x3FFF,0xFE01 },
		//	{ 5,0x3FFF,0xFF0B },
		//	{ 6,0x3FFF,0xFFF9 },
		//	{ 7,0x3FFF,0xFFD3 },
		//	{ 8,0x3FFF,0xFFFF }
		//	};
		//}
		//else {
		std::vector<DisplayAttributeMap_t> venables =
		{
			//{ 0,0x0FFF,0xFFFF },
			{ 1,0x0001,0xFF01 }, //Operation Menu Back
			{ 2,0x000F,0xFE0F }, //Measurand1 Back Dose Rate DoseAlarm
			{ 3,0x000F,0xFE0F },
			//{ 4,0x0001,0xFE01 },
			{ 5,0x00CF,0xFF89 },
			{ 6,0x0003,0xFF03 },
			{ 7,0x000F,0xFF0B },
			//{ 8,0x00FF,0xFFFF }
			};
		//}

		// 0x1 Operation Menu Back 		/0x2 On / Off  0x4 Clear Dose 0x8 Toggle Telemtry 0x10 Responder Trigger
		//         1                     0             0              0                   0

		r = RunComsTransaction(eFunctions::WriteDisplayEnables_R3, 1,
			[&](auto cb) {
				return   BeginWriteDisplayEnables_R3(epdComsHandle, venables.data(), static_cast<uint8_t>(venables.size()), cb);
			},
			[&](auto token) {
				return EndWriteDisplayEnables_R3(epdComsHandle, token);
			}, 10
		);

		/*SetFunctionReturnValue(eFunctions::WriteDisplayEnables_R3,1);
		token = BeginWriteDisplayEnables_R3(epdComsHandle, venables.data(), static_cast<uint8_t>(venables.size()), nullptr);
		r = CommitAndEnd2RV(EndWriteDisplayEnables_R3, token);*/
		if (r != 0)
			Error = r;
	}
	/*if (!r) {
		std::vector<uint16_t> vpermissions= {

		0x0000 ,
		0x0016 ,
		0x0000 ,
		0x0000 ,
		0x0000 ,
		0x0000 ,
		0x0000 ,
		0x0004 ,
		0x0000
		};

		SetFunctionReturnValue(eFunctions::WriteDisplayEnablePermissions_R3,1);
		token = BeginWriteDisplayEnablePermissions_R3(epdComsHandle, AccessLevel_t::Admin, vpermissions.data(),static_cast<uint8_t>( vpermissions.size()), nullptr);
		r = CommitAndEnd2RV(EndWriteDisplayEnablePermissions_R3, token);

		if (r != 0)
			Error = r;
	}*/

	if (!r) {
		//AlarmConfiguration	
		if (isBG) {
			std::vector<AlarmConfig_t> valarmConfigIds={
		/*	const uint8_t alarmConfigLen = 10;
			alarmConfigIds = new AlarmConfig_t[alarmConfigLen]{*/
			{ (AlarmIds)0,0,0x0000,0x9CC1,60 },
			{ (AlarmIds)1,0,0x0000,0x1884,60 },
			{ (AlarmIds)2,0,0x0000,0x9CC7,60 },
			{ (AlarmIds)3,0,0x0000,0x1885,60 },
			{ (AlarmIds)4,0,0x0000,0x9CC7,60 },
			{ (AlarmIds)5,0,0x0000,0x9CA4,60 },
			{ (AlarmIds)6,0,0x0000,0x1884,60 },
			{ (AlarmIds)7,0,0x0000,0x1884,60 },
			{ (AlarmIds)8,0,0x0000,0x9884,60 },
			{ (AlarmIds)9,0,0x0000,0x9CA5,60 }			
			};
			r = RunComsTransaction(eFunctions::WriteAlarmConfiguration_R3, 1,
				[&](auto cb) {
					return   BeginWriteAlarmConfiguration_R3(epdComsHandle, valarmConfigIds.data(), static_cast<uint16_t>(valarmConfigIds.size()), cb);
				},
				[&](auto token) {
					return EndWriteAlarmConfiguration_R3(epdComsHandle, token);
				}, 10
			);

			//SetFunctionReturnValue(eFunctions::WriteAlarmConfiguration_R3, 1);
			//token = BeginWriteAlarmConfiguration_R3(epdComsHandle, valarmConfigIds.data(), static_cast<uint16_t>(valarmConfigIds.size()), nullptr);
			//r = CommitAndEnd2RV(EndWriteAlarmConfiguration_R3, token,100);
		}
	}

	//constexpr int maxbatch= 2;
	//int s[maxbatch];
	//int rv[maxbatch];
	//int batchstep;
	
	if (!r && isAdmin) {
		//OffModeDisplay
		// 
		// 
		r = SetCalDueDate();
		//can give privilege issues
		dutyCycle = (OffModeDutyCycle)0;
		offModeDispId = (OffModeDisplayId_t)1;

		r = RunComsTransaction(eFunctions::WriteOffModeDisplay_R3, 1,
			[&](auto cb) {
				return   BeginWriteOffModeDisplay_R3(epdComsHandle, dutyCycle, offModeDispId, cb);
			},
			[&](auto token) {
				return EndWriteOffModeDisplay_R3(epdComsHandle, token);
			}, 10
		);

		//SetFunctionReturnValue(eFunctions::WriteOffModeDisplay_R3,1);
		//token = BeginWriteOffModeDisplay_R3(epdComsHandle, dutyCycle, offModeDispId, nullptr);
		//r = CommitAndEnd2RV(EndWriteOffModeDisplay_R3, token,100);

	/*	//Does not seem to work on new epd
	if (r != 0)
			Error = r;
		else {
			uint8_t OnOfenabled = 0;
			SetFunctionReturnValue(eFunctions::WriteSwitchOnFromButton_R3, 0);
			token = BeginWriteSwitchOnFromButton_R3(epdComsHandle, OnOfenabled, nullptr);
			r = CommitAndEnd2RV(EndWriteSwitchOnFromButton_R3, token);
			if (r != 0)
				Error = r;
		}*/

		r = RunComsTransaction(eFunctions::WriteAccessLevelOpen, 0	,
			[&](auto cb) {
				return  BeginWriteAccessLevel(epdComsHandle, AccessLevel_t::Open, nullptr, 0, cb);
			},
			[&](auto token) {
				return EndWriteAccessLevel(epdComsHandle, token);
			}, 10
		);
		
			//SetFunctionReturnValue(eFunctions::WriteAccessLevelOpen, 0);
			//token = BeginWriteAccessLevel(epdComsHandle, AccessLevel_t::Open, nullptr, 0, nullptr);
			//r = CommitAndEnd2RV(EndWriteAccessLevel, token,200);
			//if (r != 0) {
			//	r = ReConnect();
			//	SetFunctionReturnValue(eFunctions::WriteAccessLevelOpen, 0,1);
			//	token = BeginWriteAccessLevel(epdComsHandle, AccessLevel_t::Open, nullptr, 0, nullptr);
			//	r = CommitAndEnd2RV(EndWriteAccessLevel, token, 100);
			//}

			if (r != 0)
				Error = r;
		
			Sleep(200);
		if (r != 0)
			Error = r;
	}
	else
		Error = r;
	
	return r;
}

int Epd3Base::Epd3U::SetChirp(float Sensitivity)
{
	uint32_t r = 1;
	uint8_t enable = 0;

	if (Sensitivity > 0.001F) {
		enable = 1;
		r = RunComsTransaction(eFunctions::WriteChirpSensitivity, 0,
			[&](auto cb) {
				return  BeginWriteChirpSensitivity(epdComsHandle, Sensitivity, cb);
			},
			[&](auto token) {
				return EndWriteChirpSensitivity(epdComsHandle, token);
			}, 10
		);
	}
	if (r) goto error;

	if (!r) {
		r = RunComsTransaction(eFunctions::WriteChirpEnable_R3, 0,
			[&](auto cb) {
				return  BeginWriteChirpEnable_R3(epdComsHandle, enable, cb);	
			},
			[&](auto token) {
				return EndWriteChirpEnable_R3(epdComsHandle, token);
			}, 10
		);

	
	}
	if (r) goto error;

	return r;
error:
	return r;
}

int Epd3Base::Epd3U::GetSelfTestData()
{
	int  r = 1;
	r = RunComsTransaction(eFunctions::fReadSelfTestInterval, 0,
		[&](auto cb) {
			return  BeginReadSelfTestInterval(epdComsHandle, cb);
		},
		[&](auto token) {
			return  EndReadSelfTestInterval(epdComsHandle, token, &SelfTestMinutes);
		}, 10
	);

	//SetFunctionReturnValue(eFunctions::fReadSelfTestInterval, 0);
	//token = BeginReadSelfTestInterval(epdComsHandle, nullptr);
	//r = CommitAndSetRV();
	//if (!r) r = EndReadSelfTestInterval(epdComsHandle, token, &SelfTestMinutes);
	//r = SetEndReturnValue(r);
	return r;

}

int Epd3Base::Epd3U::DoSelfTest()
{
	bool StopInterface = false;
	int16_t r = 1;
	if (!epdComsHandle) { 
		r= ConnectAndStatus(2000); 
		DebugWrite("****    ConnectAndStatus rv={} ****\n", r);
		StopInterface = true;
	}
	GetSelfTestData();

	DebugWrite("****    StartDetectorTest .... ****\n");
	SetFunctionReturnValue(eFunctions::fDoSelfTest, 0);
	if (epdComsHandle) {
		r = SetEpdON();
		
		r = RunComsTransaction(eFunctions::fDoSelfTest, 0,
			[&](auto cb) {
				return  BeginStartDetectorTest(epdComsHandle, cb);
			},
			[&](auto token) {
				return  EndStartDetectorTest(epdComsHandle, token);
			}, 5000
		);

	


		if (r) current->StatusDecoded = false;
		else r = ReadStatusOnly();

		Sleep(1000);
		r= SetEpdOFF();


	

	
		if (StopInterface) {
			SetFunctionReturnValue(eFunctions::fDestroyReaderInterface, 0);
			Dll3RV = DestroyReaderInterface(epdComsHandle);
			SetEndReturnValue(Dll3RV);
			epdComsHandle = nullptr;
		};
	}
	return r;
}