eDosStation/EpdBaseClr/EpdBaseClr.cpp

#include "stdafx.h"
#include "EpdBaseClr.h"
#pragma managed
#include "../EpdBase3/Epd3Base.h"   // or "Epd3Base.h" if on include path
#include <filesystem>
#include <fstream>
#include <msclr/marshal_cppstd.h>
typedef void (*ProgressCallback)(int percentage, const char* message);

void EpdBaseClr::Epd2::OnCancelRequested()
{
	if (epd3 != nullptr) epd3->CancelAll();
	if (epd != nullptr) epd->CancelAll();

}

bool EpdBaseClr::Epd2::HasStepError()
{
	return (bool)epd3->HasStepError;
}

int EpdBaseClr::Epd2::SetEndNotifyAlarm(UInt16 NotifyAlarm, UINT16 NotifyAlarmDuration)
{
	if (epd3) {
		epd3->EndNotifyAlarm = NotifyAlarm;
		epd3->EndNotifyAlarmDuration = NotifyAlarmDuration;
	}
	return 0;
}




//#include <filesystem>
//#include <fstream>
//#include <msclr/marshal_cppstd.h> // Required for String^ to std::string conversion

int EpdBaseClr::Epd2::SetDebugLog(System::String^ path)
{
	namespace fs = std::filesystem;

	// Convert managed System::String^ to standard std::string
	std::string nativePath;
	if (!System::String::IsNullOrEmpty(path)) {
		nativePath = msclr::interop::marshal_as<std::string>(path);
	}

	bool hasPath = !nativePath.empty();
	fs::path logDir = nativePath;

	// Main logFile
	if (hasPath) {
		if (logFile) {
			delete logFile;
		}
		logFile = new std::ofstream(logDir / "epdclr.log", std::ios::out | std::ios::app);
		LogMessage("Epd2 log open");
	}
	else {
		if (logFile) {
			delete logFile;
			logFile = nullptr;
		}
	}

	// epd3 log file
	if (epd3) {
		if (hasPath) {
			epd3->logFile.open(logDir / "epdbase3.log", std::ios::out | std::ios::app);
		}
		else if (epd3->logFile.is_open()) {
			epd3->logFile.close();
		}
	}

	// epd2 log file
	if (epd) {
		if (hasPath) {
			epd->logFile.open(logDir / "epdbase.log", std::ios::out | std::ios::app);
		}
		else if (epd->logFile.is_open()) {
			epd->logFile.close();
		}
	}



	return 0;
}
/// <summary>
/// 
/// </summary>
/// <param name="ResponseTimeout">Standaard dll rsponse timeout</param>
/// <param name="DiscoveryCacheTimeout">Standard dll discovery cache timeout</param>
/// <param name="SleepAfterClear">After Clear dose, clear peak wait ms</param>
/// <param name="SleepBeforeReconnect">Before a failed reconnect, wait ms</param>
/// <param name="SleepAfterDisconnect">After final disconnect wait before stopping interface </param>
/// <param name="DoDisconnectAfterClear">After clear dose, peaks do a disconnect</param>
/// <param name="DoDisconnectBeforeReconnect">Before a reconnect, do a disconnect</param>
/// <returns></returns>
int EpdBaseClr::Epd2::OtherParam(int ResponseTimeout, int DiscoveryCacheTimeout,int ReconnectRetries, int SleepAfterClear, int SleepBeforeReconnect, int SleepAfterDisconnect, bool  DoDisconnectAfterClear, bool  DoDisconnectBeforeReconnect, bool DoProtectSession, bool DoUserprofile)
{
	if (epd3) {
		epd3->ResponseTimeout = ResponseTimeout;
		epd3->DiscoveryCacheTimeout = DiscoveryCacheTimeout;
		epd3->ReconnectRetries = ReconnectRetries;

		epd3->SleepAfterClear = SleepAfterClear;
		epd3->SleepBeforeReconnect = SleepBeforeReconnect;
		epd3->SleepAfterDisconnect = SleepAfterDisconnect	;
		epd3->DoDisconnectAfterClear = DoDisconnectAfterClear;
		epd3->DoDisconnectBeforeReconnect = DoDisconnectBeforeReconnect;

		epd3->DoProtectSession = DoProtectSession;
		epd3->DoUserProfile = DoUserprofile;
	}
	return 0;
}

int EpdBaseClr::Epd2::SetReleaseLogging(bool doLog  )
{
	if (epd3) {
		epd3->SetReleaseLogging( doLog);
	
	}
	return 0;
}
int EpdBaseClr::Epd2::GetSteps()
{
	int nsteps = (int)epd3->CurrentStep + 1;
	StepMaxTime = 0;
	if (nsteps>0) {
		StepReturnValues = gcnew System::Collections::Generic::List<cStepValues^>(nsteps);
		cStepValues^ x;
		for (int i = 0; i<nsteps; i++)
		{
			x = gcnew cStepValues();
			x->func = (Int32)epd3->StepReturnValues[i][0];
			x->commitrv = epd3->StepReturnValues[i][1];
			x->endrv = epd3->StepReturnValues[i][2];
			x->commitms = epd3->StepReturnValues[i][4];
			x->endms = epd3->StepReturnValues[i][5];
			x->commitcode = (Int16)epd3->StepReturnValues[i][6];
			x->endcode = epd3->StepReturnValues[i][7]; 
			x->retry = epd3->StepReturnValues[i][8]; 
			StepReturnValues->Add(x);
		}
		int tm;  
		if (nsteps>0) {
			tm = epd3->StepReturnValues[nsteps - 1][5];
			if (tm && StepMaxTime < tm) StepMaxTime = tm;
			tm = epd3->StepReturnValues[nsteps - 1][4];
			if (tm && StepMaxTime < tm) StepMaxTime = tm;
		}
	}
	else {
		if (StepReturnValues != nullptr) StepReturnValues->Clear();
		StepMaxTime = 0;
	}
	return nsteps;
}
int EpdBaseClr::Epd2::GetErrors()
{
	if (epd3->errorm009 > 0 || epd3->errorm007 > 0 || epd3->errorm102 > 0 || epd3->errorm200 > 0 || epd3->errorm202 > 0 || epd3->error_other > 0) {
		ErrorReturnValues = gcnew System::Collections::Generic::Dictionary<int, int>(5);
		ErrorReturnValues->Add(-9, epd3->errorm009);
		ErrorReturnValues->Add(-7, epd3->errorm007);
		ErrorReturnValues->Add(-102, epd3->errorm102);
		ErrorReturnValues->Add(-200, epd3->errorm200);
		ErrorReturnValues->Add(-202, epd3->errorm202);
		ErrorReturnValues->Add(-999, epd3->error_other);
	}
	else if (ErrorReturnValues != nullptr) ErrorReturnValues->Clear();

	return 1;
}
void EpdBaseClr::Epd2::OnProgress(EpdSteps step, EpdStepResults result)
{
	// Handle the progress info here (e.g., print or log it)
	System::Console::WriteLine("Step: " + ((int)step).ToString() + ", Result: " + ((int)result).ToString());
	if (_EpdProgress) {
		_EpdProgress(this, step, result);
		Sleep(100);
	}
}
EpdBaseClr::Epd2::Epd2(int port, bool OnlyMK2)
{
	EpdID = 0;
	isMK3 = EPDIssued = isBG = 0;
	onlyMK2 = OnlyMK2;
	epd = new EpdBase::Epd2U(port);
	if (!OnlyMK2) {
		epd3 = new Epd3Base::Epd3U(port);
		if (epd3) epd3->WriteConfig32 = 0;
	}
	else epd3 = nullptr;
	
	this->InitRV = epd->InitRv;
	Hp10Name = gcnew String(tHp10);
	Hp07Name = gcnew String(tHp07);
	isTitleNG = false;
	SelftestMinutes = 0;
	BatNoLoad_mV = BatLoad_mV = Cpu_mV = MaxBaud= 0;
	progressDelegate = gcnew ProgressCallbackDelegate(this,&Epd2::OnProgress);	
	 IntPtr ip = System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(progressDelegate);
	/* epd3->postgre
	 epd3->ProgressCallback = static_cast<ProgressCallback>(ip.ToPointer());
	 epd3.prog*/
	 if (epd3 != nullptr) {
		 epd3->progressCallback = static_cast<Epd3Base::Epd3U::ProgressCallback>(ip.ToPointer());
		 epd3->test();
	 }
	 if (epd != nullptr) {
		 epd->progressCallback = static_cast<EpdBase::Epd2U::ProgressCallback>(ip.ToPointer());
		 epd->test();
	 }
	 StepMaxTime = 0;
}

EpdBaseClr::Epd2::~Epd2()
{
	if (epd != nullptr) {
		epd->EndCom();
		delete epd; 
		epd = nullptr;
	}
	if (epd3 != nullptr) {
		epd3->EndCom(true);
		delete epd3;
		epd3 = nullptr;
	}
	this->!Epd2();
	if (logFile) {
		if (logFile->is_open()) {
			logFile->close();
		}
		delete logFile;
		logFile = nullptr;
	}
}

EpdBaseClr::Epd2::!Epd2()
{
}

int EpdBaseClr::Epd2::SetFeedbackSound(byte sound, UINT16 sound3)
{
	epd->EndSessionControl = sound;
	if (epd3!=nullptr) epd3->EndSessionControl = sound3;
	return 0;
}
/// <summary>
/// find Epd
/// </summary>
/// <param name="reinit"></param>
/// <returns>0 = success </returns>
int EpdBaseClr::Epd2::Connect(bool reinit, int EPDTimeout)
{
	int rv = 1;
	ConnectError = 0;
	EpdID= 0;
	DeviceCount = 0;
	DiscRV = 0;
	if (epd != nullptr) {
		if (epd->CommsInitialized == 0) epd->StartCom();
		if (epd->CommsInitialized == 1) {
			DiscRV = epd->StartDiscover(EPDTimeout);
			if (DiscRV == 1)
			{
				DeviceCount = epd->DeviceCount;
				if (epd->DeviceCount > 0) {
					EpdID = epd->DeviceIDs[0]; rv = 0;
				}
				else rv = 1; //Nothing discoverd
			}
			else {
				rv = 2; //discover failed
				ConnectError = epd->Error;
			}
		}
		else {
			rv = 3; //start com failed.
			ConnectError = epd->Error;
		}
	}
	return rv;
}
int EpdBaseClr::Epd2::Close()
{
	//EpdID= 0;
	if (epd != nullptr) 	epd->EndCom();
	if (epd3 != nullptr)	epd3->EndCom(true);
	return 0;
}
int EpdBaseClr::Epd2::DecodeStatus(Epd3Base::Epd3U* epd)
{
	epd->DecodeStatus(); // set hasAlarm
	//OperatingStatus
	DetectorsOn = epd->DetectorsOn;
	EPDIssued = epd->EPDIssued;
	EPDLocked = epd->EPDLocked;
	EPDTesting = epd->EPDTesting;
	EPDProcSec = epd->EPDProcSec;
	EPDFaulty = epd->EPDFaulty;
	EPDTimeFault = epd->EPDTimeFault;
	EPDDetectorTestRequested = epd->EPDDetectorTestRequested;
	EPDDetectorTestPassed = epd->EPDDetectorTestPassed;	

	EPDNewFault = epd->EPDNewFault;
	EPDComFault = epd->EPDComFault;
	EPDCalFault = epd->EPDCalFault;
	EPDDetFault = epd->EPDDetFault;
	EPDEprFault = epd->EPDEprFault;
	EPDTrhFault = epd->EPDTrhFault;
	EPDOthFault = epd->EPDOthFault;

	AlarmDoseHP101G = epd->AlarmDoseHP101G;
	AlarmDoseHP102G = epd->AlarmDoseHP102G;
	AlarmDoseHP07N = epd->AlarmDoseHP07N;
	AlarmRateHP101G = epd->AlarmRateHP101G;
	AlarmRateHP102G = epd->AlarmRateHP102G;
	AlarmRateHP07N = epd->AlarmRateHP07N;

	OtherAlarmRateHp101G = epd->OtherAlarmRateHp101G;
	OtherAlarmRateHp102G = epd->OtherAlarmRateHp102G;
	OtherAlarmRateHp07N = epd->OtherAlarmRateHp07N;
	OtherAlarmReturn = epd->OtherAlarmReturn;
	OtherAlarmBatLow = epd->OtherAlarmBatLow;
	OtherAlarmCarrier = epd->OtherAlarmCarrier;
	OtherAlarmBatVolt = epd->OtherAlarmBatVolt;

	return 1;
}
int EpdBaseClr::Epd2::DecodeStatus(EpdBase::Epd2U* epd)
{
	epd->DecodeStatus();
	//OperatingStatus
	DetectorsOn = epd->DetectorsOn;
	EPDIssued = epd->EPDIssued;
	EPDLocked = epd->EPDLocked;
	EPDTesting = epd->EPDTesting;
	EPDProcSec = epd->EPDProcSec;
	EPDFaulty = epd->EPDFaulty;
	EPDTimeFault = 0;
	EPDDetectorTestRequested = 0;

	EPDNewFault = epd->EPDNewFault;
	EPDComFault = epd->EPDComFault;
	EPDCalFault = epd->EPDCalFault;
	EPDDetFault = epd->EPDDetFault;
	EPDEprFault = epd->EPDEprFault;
	EPDTrhFault = epd->EPDTrhFault;
	EPDOthFault = epd->EPDOthFault;

	AlarmDoseHP101G = epd->AlarmDoseHP101G;
	AlarmDoseHP102G = epd->AlarmDoseHP102G;
	AlarmDoseHP07N = epd->AlarmDoseHP07N;
	AlarmRateHP101G = epd->AlarmRateHP101G;
	AlarmRateHP102G = epd->AlarmRateHP102G;
	AlarmRateHP07N = epd->AlarmRateHP07N;

	OtherAlarmRateHp101G = epd->OtherAlarmRateHp101G;
	OtherAlarmRateHp102G = epd->OtherAlarmRateHp102G;
	OtherAlarmRateHp07N = epd->OtherAlarmRateHp07N;
	OtherAlarmReturn = epd->OtherAlarmReturn;
	OtherAlarmBatLow = epd->OtherAlarmBatLow;
	OtherAlarmCarrier = epd->OtherAlarmCarrier;
	OtherAlarmBatVolt = epd->OtherAlarmBatVolt;

	return 1;
}
/// <summary>
/// 
/// </summary>
/// <returns>0=success</returns>
int EpdBaseClr::Epd2::GetStatus()
{
	int rv = 1;
	StatusRV = epd->ReadStatus();
	if (StatusRV != 1) GetStatusError = epd->Error; else GetStatusError= rv = 0;
	AfterGetStatus(epd);
	return rv;
}
int EpdBaseClr::Epd2::AfterGetStatus(EpdBase::Epd2U *epd)
{
	isMK3 = false;
	EPDIssued = epd->EPDIssued;
	WearerID = gcnew String((char*)epd->WearerID);
	WearerName = gcnew String((char*)epd->WearerName);
	isOn = (epd->DetectorsOn != 0);
	epdType = epd->EpdType;
	isBG = epd->isBG;
	isNG = epd->isNG;
	VersionOK = epd->VersionOK ;
	//isBG = (epd->EpdType == 0 || epd->EpdType == 4);  //MK2 BG=0 or MK3 BG=4    3=MK2 Neuruon 7=MK3 neutron
	alarmStatus = epd->AlarmStatus;
	otherAlarms = epd->OtherAlarms;
	errorStatus = epd->ErrorStatus;
	operatingStatus = epd->OperatingStatus;
	EPDDetectorTestRequested = 0;
	//hasAlarm	= epd->hasAlarm; //?1
	eDoshasAlarm = epd->hasAlarm;
	eDosHasFault = epd->hasFault;
	
	//EpdID = epd->EpdID;
	//EpdID = epd3->Epd.Id; no!
	HardVersion = epd->HardVersion / 100; 
	HardVersionMinor = epd->HardVersion % 100;
	SoftVersion = epd->SoftVersion;
	int VersionMajor = 1;
	int VersionMinor = 5;

	// Formats as "1.5"
	HardwareVersion = String::Format("{0}.{0}", HardVersion, HardVersionMinor);
	FirmwareVersion = String::Format("{0}", epd->SoftVersion);
	FunctionFlags = epd->FunctionFlags;
	CountsClock = epd->EpdClock;
	DecodeStatus(epd); 
	return 0;
}

int EpdBaseClr::Epd2::AfterGetStatus(Epd3Base::Epd3U* epd)
{
	EPDIssued= epd->EPDIssued;
	WearerID = gcnew String((char*)epd->WearerID);
	WearerName = gcnew String((char*)epd->WearerName);
	isOn = (epd->DetectorsOn != 0);
	epdType = (int)epd->EpdType;
	isBG = (epd->EpdType == EpdTypes::Mk2BetaGamma || epd->EpdType == EpdTypes::Mk3BetaGamma);  //MK2 BG=0 or MK3 BG=4    3=MK2 Neuruon 7=MK3 neutron
	isNG = epd->isNG;
	VersionOK = epd->VersionOK;
	isMK3 = epd->isMK3;
	alarmStatus = (int)epd->AlarmStatus;
	otherAlarms = (int)epd->OtherAlarms;
	errorStatus = (int)epd->ErrorStatus;
	operatingStatus = (int)epd->OperatingStatus;
	EPDDetectorTestRequested = epd->EPDDetectorTestRequested;

	eDoshasAlarm = epd->hasAlarm;
	eDosHasFault = epd->hasFault;
	EpdID = epd->Epd.Id;
	HardVersion = epd->HardVersion;
	HardVersionMinor = epd->HardVersionMinor;
	SoftVersion = epd->SoftVersion;
	FunctionFlags = epd->FunctionFlags;
	CountsClock = epd->EpdClock;
	//hier nodig ?
	HardwareVersion = String::Format("{0}.{1}", epd->HardVersion, epd->HardVersionMinor);
	FirmwareVersion = String::Format("{0}.{1}.{2}.{3}", epd->SoftVersion, epd->SoftVersionMinor,epd->SoftVersionPatch,epd->SoftVersionBuild);
	DecodeStatus( epd); // zet hasAlarm
	return 0;
}
int EpdBaseClr::Epd2::AfterGetStatus()
{
	int rv = 0;
	if (isMK3)  rv=AfterGetStatus(epd3);
	else rv=AfterGetStatus(epd);
	return rv;
}
/// <summary>
/// 
/// </summary>
/// <returns>0 OK</returns>
int EpdBaseClr::Epd2::GetDoses() 
{
	int rv = 0;
	if (isMK3) 
		rv = GetDoses(epd3);
	else 
		rv = GetDoses(epd);
	return rv;
}
int EpdBaseClr::Epd2::GetDoses(EpdBase::Epd2U* epd)
{
	int rv = 1;
	Hp10 = Hp07 = 0.0;
	ReadDosesRV = epd->ReadDoses();
	if (ReadDosesRV == 1) {
		rv = AfterGetDoses(epd);
	}
	else {
		rv = 1;
		GetDosesError = epd->Error;
	}
	return rv;
}
int EpdBaseClr::Epd2::AfterGetDoses(Epd3Base::Epd3U* epd)
{
	eDoshasAlarm = eDosHasFault = false;
	int rv = 0;
	rv = 0;
	GetDosesError = 0;
	Hp10 = (double)epd->Hp10Dose;
	Hp07 = (double)epd->Hp07Dose;
	Hp07Peak = (double)epd->Hp07Peak;
	Hp10Peak = (double)epd->Hp10Peak;

	Hp07Total = epd->Hp07Total;
	Hp10Total = epd->Hp10Total;

	if (epd->Hp10FTime != 0) {
		//seconds since 2000 ?
		//double x = (epd->EpdClock - epd->Hp10Time) * -1.0;
		Hp10PeakTime = System::DateTime::FromFileTime(epd->Hp10FTime);
		//Hp10PeakTime =  Jan2000->AddSeconds(epd->Hp10Time);
	}
	else
		Hp10PeakTime = System::Nullable<System::DateTime>();;

	if (epd->Hp07FTime != 0) {
		//double x = (epd->EpdClock - epd->Hp07Time) * -1.0;
		Hp07PeakTime = System::DateTime::FromFileTime(epd->Hp07FTime);
		//Hp07PeakTime = Jan2000->AddSeconds(epd->Hp07Time);
	}
	else
		Hp07PeakTime = System::Nullable<System::DateTime>();

	QualityData = epd->QualityData;
	K1 = (int)epd->K1;
	K2 = (int)epd->K2;
	K3 = (int)epd->K3;
	K4 = (int)epd->K4;
	K5 = (int)epd->K5;
	K6 = (int)epd->K6;
	SG = (int)epd->SG;
	BC = epd->SG;
	FB = epd->FB;
	HG = epd->HG;
	//NGgain = K3;
	NGgain = epd->GainAn;

	eDosDose07Warning = epd->eDosDose07Warning;
	eDosDose07Alarm= epd->eDosDose07Alarm;
	eDosDose10Warning = epd->eDosDose10Warning;
	eDosDose10Alarm = epd->eDosDose10Alarm;
	eDosRate07Warning = epd->eDosRate07Warning;
	eDosRate07Alarm = epd->eDosRate07Alarm;
	eDosRate10Warning = epd->eDosRate10Warning;
	eDosRate10Alarm = epd->eDosRate10Alarm;
	eDosBatteryWarning = epd->eDosBatteryWarning;

	eDoshasAlarm = epd->hasAlarm;
	eDosHasFault = epd->hasFault;

	return rv;
}
/// <summary>
/// 
/// </summary>
/// <param name="epd"></param>
/// <returns>0 OK</returns>
int EpdBaseClr::Epd2::GetDoses(Epd3Base::Epd3U* epd)
{
	int rv = 1;
	Hp10 = Hp07 = 0.0;
	int ReadDosesRV = epd->ReadDoses(); //0 = succes
	
	if (ReadDosesRV == 0) {
		rv = AfterGetDoses(epd3);
	} 
	else {
		rv = 1;
		GetDosesError = epd->Error;
	}
	return rv;
}
int EpdBaseClr::Epd2::ClearAlarms()
{
	int rv = 0;
	if (isMK3) rv = epd3->ClearAlarms();
	else rv = epd->ClearAlarms();
	return rv;
}
/// <summary>
/// 
/// </summary>
/// <returns>0 OK</returns>
//int EpdBaseClr::Epd2::SetDeIssued()
//{
//	int rv = 0;
//	ErrorStep = 0; ErrorRV = 0;
//	if (isMK3) {
//		rv = epd3->DeIssue();
//		ErrorStep = epd3->ErrorStep;
//		ErrorRV = epd3->Error;
//	}
//	else rv = epd->DeIssue();
//	return rv;
//}

//int EpdBaseClr::Epd2::PrepareForIssue()
//{
//	int rv = 0;
//	PrepareForIssueError = 0;
//	ErrorStep = 0; ErrorRV = 0;
//	if (isMK3) {
//		rv = epd3->PrepareForIssue();
//		ErrorStep = epd3->ErrorStep;
//		ErrorRV = epd3->Error;
//	}
//	else rv= epd->PrepareForIssue();
//	if (rv != 0) PrepareForIssueError = epd->Error;
//	return rv;
//}
/// <summary>
/// should not be used
/// </summary>
/// <returns>0 OK</returns>
//int EpdBaseClr::Epd2::SetIssued()
//{
//	int rv = 0;
//	ErrorStep = 0; ErrorRV = 0;
//	if (isMK3) {
//		rv=SetIssued(epd3); 
//		ErrorStep = epd3->ErrorStep;
//		ErrorRV = epd3->Error;
//	}
//	else rv=SetIssued(epd);
//	return rv;
//}

/// <summary>
/// BeforeSetIssued : geen interactie met epd, maar zet varibaleln
/// </summary>
/// <param name="epd"></param>
/// <returns></returns>
int EpdBaseClr::Epd2::BeforeSetIssued(Epd3Base::Epd3U* epd)
{
	int rv = 0;
	SetIssuedError = 0;
	epd->Hp07THDose = (float)Hp07THDose;
	epd->Hp10THDose1 = (float)Hp10THDose1;
	epd->Hp10THDose2 = (float)Hp10THDose2;

	epd->Hp10Rate1On = (float)Hp10Rate1On;
	epd->Hp10Rate2On = (float)Hp10Rate2On;
	epd->Hp07RateOn = (float)Hp07RateOn;
	epd->Hp10Rate1Off = (float)Hp10Rate1Off;
	epd->Hp10Rate2Off = (float)Hp10Rate2Off;
	epd->Hp07RateOff = (float)Hp07RateOff;

	memset(epd->WearerID, ' ', WearerIDLength); epd->WearerID[WearerIDLength] = 0;
	char* str1 = (char*)(void*)Runtime::InteropServices::Marshal::StringToHGlobalAnsi(WearerID);
	int l = strlen(str1);
	if (l > WearerIDLength) l = WearerIDLength;
	_memccpy(epd->WearerID + WearerIDLength - l, str1, l, WearerIDLength);
	Runtime::InteropServices::Marshal::FreeHGlobal((IntPtr)str1);

	memset(epd->WearerName, 0, WearerNameLength + 1);
	char* str2 = (char*)(void*)Runtime::InteropServices::Marshal::StringToHGlobalAnsi(WearerName);
	l = strlen(str2);
	if (l > WearerNameLength) l = WearerNameLength;
	_memccpy(epd->WearerName, str2, l, WearerNameLength);
	Runtime::InteropServices::Marshal::FreeHGlobal((IntPtr)str2);

	return 0;
}
/// <summary>
/// 
/// </summary>
/// <param name="epd"></param>
/// <returns>0 success</returns>
//int EpdBaseClr::Epd2::SetIssued(Epd3Base::Epd3U* epd)
//{
//	int rv = 0;
//	rv =  BeforeSetIssued(epd);
//	rv = epd->Issue(false);
//	if (rv != 0) SetIssuedError = epd->Error;
//	return rv;
//}
int EpdBaseClr::Epd2::BeforeSetIssued(EpdBase::Epd2U* epd)
{
	int rv = 0;
	SetIssuedError = 0;
	epd->Hp07THDose = (DWORD)(Hp07THDose * 64.0);
	epd->Hp10THDose1 = (DWORD)(Hp10THDose1 * 64.0);
	epd->Hp10THDose2 = (DWORD)(Hp10THDose2 * 64.0);

	epd->Hp10Rate1On = (DWORD)(Hp10Rate1On);
	epd->Hp10Rate2On = (DWORD)(Hp10Rate2On);
	epd->Hp07RateOn = (DWORD)(Hp07RateOn);

	epd->Hp10Rate1Off = (DWORD)(Hp10Rate1Off);
	epd->Hp10Rate2Off = (DWORD)(Hp10Rate2Off);
	epd->Hp07RateOff = (DWORD)(Hp07RateOff);

	memset(epd->WearerID, ' ', WearerIDLength); epd->WearerID[WearerIDLength] = 0;
	char* str1 = (char*)(void*)Runtime::InteropServices::Marshal::StringToHGlobalAnsi(WearerID);
	int l = strlen(str1);
	if (l > WearerIDLength) l = WearerIDLength;
	_memccpy(epd->WearerID + WearerIDLength - l, str1, l, WearerIDLength);
	Runtime::InteropServices::Marshal::FreeHGlobal((IntPtr)str1);

	memset(epd->WearerName, 0, WearerNameLength + 1);
	char* str2 = (char*)(void*)Runtime::InteropServices::Marshal::StringToHGlobalAnsi(WearerName);
	l = strlen(str2);
	if (l > WearerNameLength) l = WearerNameLength;
	_memccpy(epd->WearerName, str2, l, WearerNameLength);
	Runtime::InteropServices::Marshal::FreeHGlobal((IntPtr)str2);

	
	return 0;
}
//int EpdBaseClr::Epd2::SetIssued(EpdBase::Epd2U* epd)
//{
//	int rv = 0;
//	BeforeSetIssued(epd);
//	rv = epd->Issue();
//	if (rv != 0) SetIssuedError = epd->Error;
//	return rv;
//}
int EpdBaseClr::Epd2::WriteCalibration()
{
	int rv = 0;
	if (isMK3) rv = WriteCalibration(epd3);
	else rv = WriteCalibration(epd);
	return rv;
}
int EpdBaseClr::Epd2::WriteCalibration(EpdBase::Epd2U* epd)
{
	epd->K1 = K1;
	epd->K2 = K2;

	epd->K3 = K3;
	epd->K4 = K4;

	epd->K5 = K5;
	epd->K6 = K6;

	//epd->K1 = 903;
	//epd->K2 = 613;
	//epd->K5 = 13100;
	//epd->K6 = 1310;

	int rv = epd->WriteCal();
	return rv;

}
int EpdBaseClr::Epd2::WriteCalibration(Epd3Base::Epd3U* epd)
{
	epd->K1 = (float)K1;
	epd->K2 = (float)K2;

	epd->K3 = (float)K3;
	epd->K4 = (float)K4;

	epd->K5 = (float)K5;
	epd->K6 = (float)K6;

	//epd->K1 = 903;
	//epd->K2 = 613;
	//epd->K5 = 13100;
	//epd->K6 = 1310;

	int rv = epd->WriteCal();
	return rv;

}
/// <summary>
/// 
/// </summary>
/// <returns>0=success</returns>
int EpdBaseClr::Epd2::ReadTresholds()
{
	int rv = 0;
	if (isMK3)
		rv = ReadTresholds(epd3);
	else
		rv = ReadTresholds(epd);
	return rv;
}
int EpdBaseClr::Epd2::AfterReadTresholds(EpdBase::Epd2U* epd)
{
	int rv = 0;
	Hp10THDose1 = (double)epd->Hp10THDose1 / 64.0;
	Hp10THDose2 = (double)epd->Hp10THDose2 / 64.0;
	Hp07THDose = (double)epd->Hp07THDose / 64.0;

	Hp10Rate1On = (double)epd->Hp10Rate1On;
	Hp10Rate2On = (double)epd->Hp10Rate2On;
	Hp07RateOn = (double)epd->Hp07RateOn;

	Hp10Rate1Off = (double)epd->Hp10Rate1Off;
	Hp10Rate2Off = (double)epd->Hp10Rate2Off;
	Hp07RateOff = (double)epd->Hp07RateOff;

	K1 = epd->K1;
	K2 = epd->K2;
	K3 = epd->K3;
	K4 = epd->K4;
	K5 = epd->K5;
	K6 = epd->K6;
	SG = epd->SG;
	BC = epd->BC;
	FB = epd->FB;
	HG = epd->HG;

	NGgain =  K3; //EPD2

	return rv;

}
/// <summary>
/// 
/// </summary>
/// <param name="epd"></param>
/// <returns>0 = Success</returns>
int EpdBaseClr::Epd2::ReadTresholds(EpdBase::Epd2U* epd)
{
	ReadTresholdsError = 0;
	int rv = epd->ReadTresHolds();
	if (rv != 0) ReadTresholdsError = epd->Error;
	rv = AfterReadTresholds(epd);
	return rv;
}
int EpdBaseClr::Epd2::AfterReadTresholds(Epd3Base::Epd3U* epd)
{
	int rv = 0;
	Hp10THDose1 = (double)epd->Hp10THDose1;
	Hp10THDose2 = (double)epd->Hp10THDose2;
	Hp07THDose = (double)epd->Hp07THDose;
	
	Hp10Rate1On = (double)epd->Hp10Rate1On;
	Hp10Rate2On = (double)epd->Hp10Rate2On;
	Hp07RateOn = (double)epd->Hp07RateOn;
	Hp10Rate1Off = (double)epd->Hp10Rate1Off;
	Hp10Rate2Off = (double)epd->Hp10Rate2Off;
	Hp07RateOff = (double)epd->Hp07RateOff;

	Hp10Total = (double)epd->Hp10Total;
	Hp07Total = (double)epd->Hp07Total;

	K1 = (int)epd->K1;
	K2 = (int)epd->K2;
	K3 = (int)epd->K3;
	K4 = (int)epd->K4;
	K5 = (int)epd->K5;
	K6 = (int)epd->K6;
	SG = epd->SG;
	BC = epd->BC;
	FB = epd->FB;
	HG = epd->HG;

	NGgain = epd->GainAn; //K3 vroeger
	return rv;
}
/// <summary>
/// 
/// </summary>
/// <param name="epd"></param>
/// <returns>0 Success</returns>
int EpdBaseClr::Epd2::ReadTresholds(Epd3Base::Epd3U* epd)
{
	int rv = 0;
	ReadTresholdsError = 0;
	rv= epd->ReadAlarmTresholds();
	rv = epd->ReadSensitivitiesAndTresholds();
	if (rv != 0) ReadTresholdsError = epd->Error;
	rv = AfterReadTresholds(epd);
	return rv;
}
/// <summary>
/// 
/// </summary>
/// <returns>0=Success</returns>
int EpdBaseClr::Epd2::ReadExtraStatus()
{
	int rv = 0;
	if (isMK3) rv = ReadExtraStatus(epd3);
	else rv = ReadExtraStatus(epd);
	return rv;
}
int EpdBaseClr::Epd2::ReadExtraStatus(EpdBase::Epd2U* epd)
{
	int rv = epd->EPDReadExtraStatus();
	BatADC = epd->byBatADC;
	SupplyADC = epd->bySupplyADC;

	D1 = epd->D1 - epd->BaseD1;
	D2 = epd->D2 - epd->BaseD2;
	D3 = epd->D3 - epd->BaseD3;
	D4 = epd->D4 - epd->BaseD4;
	CountsClock = epd->CountsClock;
	CountsClockBase = epd->BaseCountsClock;

	return rv;
}
int EpdBaseClr::Epd2::ReadExtraStatus(Epd3Base::Epd3U* epd)
{
	int rv = epd->EPDReadExtraStatus();
	BatADC = 0;  //epd->byBatADC;
	SupplyADC = 0; // epd->bySupplyADC;

	D1 = epd->D1 - epd->BaseD1;
	D2 = epd->D2 - epd->BaseD2;
	D3 = epd->D3 - epd->BaseD3;
	D4 = epd->D4 - epd->BaseD4;
	CountsClock = epd->CountsClock;
	CountsClockBase = epd->BaseCountsClock;

	return rv;
}
int EpdBaseClr::Epd2::AfterGetDoses(EpdBase::Epd2U* epd)
{
	eDoshasAlarm = eDosHasFault = false;
	int rv = 0;
	GetDosesError = 0;
	Hp10 = (double)epd->Hp10Dose / 64.0;
	Hp07 = (double)epd->Hp07Dose / 64.0;

	Hp07Peak = (double)epd->Hp07Peak; // / niet delen door 64 !!!
	Hp10Peak = (double)epd->Hp10Peak; // / niet delen door 64 !!!

	Hp07Total = epd->Hp07Total / 64.0;
	Hp10Total = epd->Hp10Total / 64.0;

	if (epd->Hp10FTime != 0) {
		try {
			Hp10PeakTime = System::DateTime::FromFileTime(epd->Hp10FTime);
		}
		catch (System::Exception^ ex) {
			Hp10PeakTime = System::Nullable<System::DateTime>();
		}
		//double x = (epd->EpdClock - epd->Hp10Time) * -1.0;
		//Hp10PeakTime = System::DateTime::Now.AddSeconds(x);
	}
	else
		Hp10PeakTime = System::Nullable<System::DateTime>();
	if (epd->Hp07FTime != 0) {
		try {
			Hp07PeakTime = System::DateTime::FromFileTime(epd->Hp07FTime);
		}
		catch (System::Exception^ ex) {
			Hp10PeakTime = System::Nullable<System::DateTime>();
		}
		//double x = (epd->EpdClock - epd->Hp07Time) * -1.0;
		//Hp07PeakTime = System::DateTime::Now.AddSeconds(x);
	}
	else
		Hp10PeakTime = System::Nullable<System::DateTime>();

	QualityData = epd->QualityData;
	K1 = epd->K1;
	K2 = epd->K2;
	K3 = epd->K3;
	K4 = epd->K4;
	K5 = epd->K5;
	K6 = epd->K6;
	SG = epd->SG;
	BC = epd->SG;
	FB = epd->FB;
	HG = epd->HG;

	NGgain = K3;

	eDosDose07Warning = epd->eDosDose07Warning;
	eDosDose07Alarm = epd->eDosDose07Alarm;
	eDosDose10Warning = epd->eDosDose10Warning;
	eDosDose10Alarm = epd->eDosDose10Alarm;
	eDosRate07Warning = epd->eDosRate07Warning;
	eDosRate07Alarm = epd->eDosRate07Alarm;
	eDosRate10Warning = epd->eDosRate10Warning;
	eDosRate10Alarm = epd->eDosRate10Alarm;
	eDosBatteryWarning = epd->eDosBatteryWarning;
	eDoshasAlarm = epd->hasAlarm;
	eDosHasFault = epd->hasFault;
	return rv;
}

/// <summary>
/// Get Doses and tresholds, and close if requested
/// </summary>
/// <param name="close"></param>
/// <returns></returns>
int EpdBaseClr::Epd2::GetAll(bool close)
{
	int rv = 0;
	if (!isMK3) {
		if (epd) {
			rv = epd->GetAll(close);
			rv = AfterGetDoses(epd);
			rv = AfterReadTresholds(epd);
		}
		else rv = -1;
	}
	else
	{
		if (epd3) {
			rv = epd3->GetAll(close);
			rv = AfterGetDoses(epd3);
			rv = AfterReadTresholds(epd3);
		}
		else rv = -1;
	}
	return rv;
}

// Main entry point for exit
int EpdBaseClr::Epd2::GetAllDeissue(bool reconnect)
{
	ErrorRV = ErrorStep = 0;
	int rv = 0;
	if (!isMK3) {
		if (epd) {
			rv = epd->GetAllDeissue();
			rv = AfterGetDoses(epd);
			rv = AfterReadTresholds(epd);
		}
		else rv = -1;
	}
	else
	{
		if (epd3) {
			rv = epd3->GetAllDeissue(reconnect);
			ErrorRV = epd3->Error;
			ErrorStep = epd3->ErrorStep;
			rv = AfterGetDoses(epd3);
			rv = AfterReadTresholds(epd3);
		}
		else rv = -1;
		
	}
	return rv;
}
/// <summary>
/// Clear Doses, for Neutron : get and check K, Issue
/// </summary>
/// <param name="gain"></param>
/// <returns></returns>
int EpdBaseClr::Epd2::IssueAndCheck(float gain, float ChirpRate, bool WriteConfig)
{
	int rv = 0;
	if (!isMK3) {
		LogMessage("IssueAndCheck: !isMK3 BeforeSetIssued");
		BeforeSetIssued(epd);
		
		rv = epd->IssueAndCheck(gain);
		LogMessage("IssueAndCheck: !isMK3 rv={}",rv);
	}
	else {
		LogMessage("IssueAndCheck: isMK3 BeforeSetIssued");
		epd3->WriteConfig32 = WriteConfig;
		BeforeSetIssued(epd3); //geen interactie met epd
		rv = epd3->IssueAndCheck(gain, ChirpRate);  // set step,error
		EPDIssued = epd3->EPDIssued;
		LogMessage("IssueAndCheck: isMK3 rv={}", rv);
	}
	return rv;
}
int EpdBaseClr::Epd2::SwitchCon()
{
	int rv = 0;
	if (isMK3) {
		if (epd3->epdComsHandle != INVALID_HANDLE_VALUE) {
			if (epd) epd->EndCom();
			Sleep(500);
			rv=epd3->StartCom();
			LogMessage("SwitchCon: StartCom returned {}" , rv);
		}
	}
	else {
		int i = 0;
		if (epd->CommsInitialized == 0) {
			if (epd3) 
				epd3->EndCom(epd3->isConnected);
			Sleep(500);
			rv = epd->StartCom(); //0=ok
			
			LogMessage("SwitchCon: StartCom returned {}", rv);

			if (!rv) rv = epd->Open(EpdID); 

			LogMessage("SwitchCon: Open returned {}", rv);

			if (!rv) rv = epd->ReadStatus(); 
	

			LogMessage("SwitchCon: ReadStatus returned {}", rv);
		}
	}
	return rv;
}
void EpdBaseClr::Epd2::InitData()
{
	ConnectError = 0;
	EpdID = 0;
	DeviceCount = 0;
	GetStatusError = 0;  StatusRV = 0; EPDIssued = false;
	WearerID = String::Empty;
	WearerName = String::Empty;
	isOn = 0;
	epdType = 0;
	isBG = 0;
	alarmStatus = 0;
	otherAlarms = 0;
	errorStatus = 0;
	operatingStatus = 0;
	HardVersion = 0; HardVersionMinor = 0;
	SoftVersion = 0;
	FunctionFlags = 0;
	CountsClock = 0;

	ErrorStep = ErrorRV = 0;
	ConnectError = 0; eDoshasAlarm = eDosHasFault = false;
	ErrorEPD = EpdErrorCodes::EpdErrorNone;
		
}

//void EpdBaseClr::Epd2::OnCancelRequested()
//{
//	if (cancelEvent != nullptr)
//	{
//		cancelEvent->Set();
//	}
//}

/// <summary>
/// connect to Epd and read status
/// </summary>
/// <returns>0=success 1=Connect error 2=TO 3=StatusReadError</returns>
int EpdBaseClr::Epd2::ConnectAndStatus()
{
	//0 = ok, 2=TO , anders error
	int rv = 1;
	int step = 0;
	ErrorStep = ErrorRV = 0; 
	ConnectError = 0; eDoshasAlarm = eDosHasFault = false;
	ErrorEPD = EpdErrorCodes::EpdErrorNone;
	if (!onlyMK2) epd->EndCom(); //indien Mk2
	
	try
	{

		InitData();
		Sleep(100);
		step = 1;
		if (onlyMK2 || !epd3)
			rv = epd->ConnectAndStatus(tokenSourceTimeout);
		else
		{
			rv = epd3->ConnectAndStatus(tokenSourceTimeout);
			
			ErrorStep = (int)epd3->EPDStep;
			ErrorRV = (int)epd3->Error;
			switch (epd3->DiscoverError) {
			case Epd3Base::Epd3U::DiscoverErrorCodes::DiscoverErrorNone:
				ErrorEPD = EpdErrorCodes::EpdErrorNone;	break;
			case Epd3Base::Epd3U::DiscoverErrorCodes::DiscoverErrorCancel:
				ErrorEPD = EpdErrorCodes::EpdErrorCancel;
				break;
			case Epd3Base::Epd3U::DiscoverErrorCodes::DiscoverErrorTimeout:
				ErrorEPD = EpdErrorCodes::EpdErrorTimeout;
				break;
			case Epd3Base::Epd3U::DiscoverErrorCodes::DiscoverErrorOther:
				ErrorEPD = EpdErrorCodes::EpdErrorOther;
				break;
			case Epd3Base::Epd3U::DiscoverErrorCodes::DiscoverErrorConnecting:
				ErrorEPD = EpdErrorCodes::EpdErrorConnecting;
				break;
			}
			LogMessage("ConnectAndStatus: rv {} ErrorEPD {}", rv, (int)ErrorEPD);
		}
	}
	catch (System::Exception^ e) {
		std::string errorMsg = msclr::interop::marshal_as<std::string>(e->Message);
		LogMessage("ConnectAndStatus: Exception occurred {}", errorMsg);
	}
	finally
	{
	}

	if (rv==0) {
		if (onlyMK2) {
			DeviceCount = epd->DeviceCount;
			EpdID = epd->EpdID;
			if (epd3 != nullptr) epd3->Epd.Id = EpdID;
			isMK3 = 0;
			isBG = epd->isBG;
			isNG = epd->isNG;
		}
		else {
			DeviceCount = epd3->DeviceCount;
			EpdID = epd3->Epd.Id;
			isMK3 = epd3->isMK3;
			isBG = epd3->isBG;
			isNG = epd3->isNG;
			epd->EpdID = epd3->Epd.Id;
			
		}
		if (isMK3) {
			AfterGetStatus(epd3);
		}
		else {

			if (!onlyMK2) rv = SwitchCon(); 
			else rv= epd->ReadStatus();
			AfterGetStatus(epd);
		}
		if (isTitleNG != isNG) {
			if (isNG) {
				Hp10Name = gcnew String(tHp10G); Hp07Name = gcnew String(tHp07N);  
			}
			else { 
				Hp10Name = gcnew String(tHp10); Hp07Name = gcnew String(tHp07);  
			}
			isTitleNG = isNG;
		}
	}
	else {
		if (epd3 == nullptr) ConnectError = 99;
		else ConnectError = epd3->Error;
		rv = ConnectError;
		goto error;
	}
	return rv;

error:
	ErrorStep = step;
	ErrorRV = rv;
	LogMessage("ConnectAndStatus: Error occurred step {} rv {} ErrorEPD {}", step, rv, (int)ErrorEPD);
	return rv;
}

void EpdBaseClr::Epd2::WaitEpd()
{
	int rv = 0; //start
	int retriesLeft = readRetries;
	
	do {
		rv = ConnectAndStatus();
		retriesLeft--;
	} while (rv == 1);
	
	if (rv == 0) {
		if (_EpdRead != nullptr)
			_EpdRead(this, gcnew EpdEventArgs(EpdID, EPDIssued, isBG, isMK3, retriesLeft));
	}
	else if (rv == 2 && _EpdTO != nullptr) {
		_EpdTO(this, gcnew  EpdTOEventArgs(0, 0)); // epd3->ConnectTries, epd3->ConnectTimerFired));
	}
	else if (rv > 0 && _EpdError != nullptr) {
		
		_EpdError(this, gcnew EpdErrorEventArgs(rv, ErrorEPD, ErrorStep));
	}
	return;
}

System::Threading::Tasks::Task^ EpdBaseClr::Epd2::Wait(int timeout, int Retries)
{
	if (waitTask == nullptr)
	{
		tokenSourceTimeout = timeout;
		//tokenSource = gcnew System::Threading::CancellationTokenSource(tokenSourceTimeout+500);
		readRetries = Retries;
		waitTask = System::Threading::Tasks::Task::Run(gcnew Action(this, &Epd2::WaitEpd)); // System::Threading::Tasks::Task::Factory->cre(gcnew Action(this, &CCard::WaitBadge), tokenSource->Token);
	}
	else {
		//tokenSource = gcnew System::Threading::CancellationTokenSource(tokenSourceTimeout +500);
	}
	return waitTask;
}


void EpdBaseClr::Epd2::WaitEnd()
{
	if (waitTask != nullptr)
	{
		waitTask->Wait(1000);
		int tries = 5;
		while (tries-->0 && waitTask->Status == System::Threading::Tasks::TaskStatus::Running) {
			
			if (epd3) epd3->CancelAll(); 
			if (epd) epd->CancelAll();
			waitTask->Wait(1000);
		}
		if (
			waitTask->Status == System::Threading::Tasks::TaskStatus::RanToCompletion
			|| waitTask->Status == System::Threading::Tasks::TaskStatus::Canceled
			|| waitTask->Status == System::Threading::Tasks::TaskStatus::Faulted
			) {
			delete waitTask;
			waitTask = nullptr;
		}
		Close();
	}
}

int  EpdBaseClr::Epd2::GetSelfTestData() {

	if (epd3)	return epd3->GetSelfTestData();
	else {
		SelftestMinutes = 0;
		return SelftestMinutes;
	}
}

int  EpdBaseClr::Epd2::DoSelfTest() {

	int rv = -1;
	if (epd3) {
		GetSelfTestData();
		rv = epd3->DoSelfTest();
		EPDDetectorTestRequested = epd3->EPDDetectorTestRequested;
		EPDDetectorTestPassed = epd3->EPDDetectorTestPassed;
		EpdID = epd3->Epd.Id;
		HardwareVersion = String::Format("{0}.{1}", epd3->HardVersion, epd3->HardVersionMinor);
		FirmwareVersion = String::Format("{0}.{1}.{2}.{3}", epd3->SoftVersion, epd3->SoftVersionMinor, epd3->SoftVersionPatch, epd3->SoftVersionBuild);
		return rv;
	}
	else {
		return 0;
	}
}

int  EpdBaseClr::Epd2::GetExtraEPDData() {

	if (epd3) {
		BatLoad_mV = epd3->vbat0;
		BatNoLoad_mV = epd3->vbat1;
		Cpu_mV = epd3->vcpu;
		MaxBaud = epd3->Epd.MaxBaud;
	}
	else
	{
		BatLoad_mV = BatNoLoad_mV = Cpu_mV = 0;
		MaxBaud = 0;
	}
	return 0;
}