PhysicalDevice/Generator/SDC/DIOS.Dev.Generator.SDC/DIOS.Dev.Generator.SDC.cpp

// CCOS.Dev.GEN.DEMO.cpp : 定义 DLL 应用程序的导出函数。
//

/*
settechmode：没有专门的指令来设置。所以只要field不为零，就认为是AEC模式。
*/
#include "stdafx.h"

#include <assert.h>
#include "Base64.h"
#include <functional>
using namespace std::placeholders;

//#include "ResDataObject.h"

//#include "logger.temp.h"

#include "CCOS.Dev.Generator.SDC.h"
#include "Helper.JSON.hpp"

using namespace CCOS::Dev::Detail::Generator;
namespace nsGEN = CCOS::Dev::Detail::Generator;

#pragma warning (disable:4244)  // warning C4244: “初始化”: 从“double”转换到“float”，可能丢失数据
#pragma warning (disable:4305)  // warning C4305: “参数”: 从“double”到“float”截断
#pragma warning (disable:4267)  // warning C4267 : “初始化”: 从“size_t”转换到“int”，可能丢失数据


static const int msTimeOut_Lock = 500;


#ifdef _WIN64
#ifdef _DEBUG
static const auto COM_SCFDllName = "Ccos.Dev.SerialSCFX64D.dll";
#else
static const auto COM_SCFDllName = "Ccos.Dev.SerialSCFX64.dll";
#endif
#endif

#ifdef _WIN64
#ifdef _DEBUG
static const auto TCP_SCFDllName = "Ccos.Dev.TcpipSCFX64D.dll";
#else
static const auto TCP_SCFDllName = "Ccos.Dev.TcpipSCFX64.dll";
#endif
#endif

#define SpecialCMDAR   "AR"
#define SpecialCMDHU   "HU"
#define SpecialCMDIT   "IT"
#define SpecialCMDST   "ST"
#define SpecialCMDRX   "RX"
#define SpecialCMDRX1  "RX1"
#define SpecialCMDRX0  "RX0"
#define SpecialCMDXR1  "XR1"
#define SpecialCMDXR0  "XR0"
#define SpecialCMDPC   "PC"
#define SpecialCMDDO   "DO?"
#define SpecialCMDDOR  "DOR"
#define SpecialCMDFOS  "FOS"
#define SpecialCMDRF   "RF"
#define SpecialCMDBT   "BT"
#define SpecialCMDSA   "SA"
#define SpecialCMDDS   "DS"
#define SpecialCMDSX   "SX"
#define SpecialCMDDE   "DE"

#define WaitForNothing 0
#define WaitForSelf    1
#define WaitForACK     10
#define WaitForCP      100
#define WaitForCPSELF  101
#define WaitForACKCP   110
#define WaitForALL     111

std::vector <string> g_SpecialCMD_List = { "AR","XR1","RX","ST","HU","WS","SA","SX","DS","DE"};
std::vector <string> g_WaitSELF_List = { "AR","SA","SX","DS","XR1","RX0","RX1","ST","HU"};
std::vector <string> g_WaitAKCMD_List = { "SA","SX","WS","MM","PH","PC","FI","FN","EC9","AR","MD","PC","TM","URSSHST",
"XR1","RX0","RX1","URSSHSS","URSSHIA","URSSHIR","URSSHCA","URSSHEI","URSLK","URSSD","URSPO","URSPN","URSPR","URSRV","URSCF","URSFK","URSST","URSFI","URSOF","URSCA","URSPP","URSTI","URSYD","URSLI","URSLD","URSCL"};
std::vector <string> g_WaitCPCMD_List = { "SA","SX","KV","MA","MS","MX","WS","MM","PH","PC","FI","FN","EC9","AR","MD","PC","TM","URSSHST",
"XR1","RX0","RX1","HU","ST","DS","FOS","RF","BT"};

//-----------------------------------------------------------------------------
//		ProcessCmd
//-----------------------------------------------------------------------------
struct tFrameMapping
{
	static const int MaxLen = 5;		//	前缀不能超超过 5 个字符 !
	using cbFun = std::function <void(const char*, int)>;

	char strHead[MaxLen]{0};
	int NbOfCharOfHead{0};
	cbFun fun{NULL};

	tFrameMapping(char* str, int len, cbFun f)
	{
		assert(len < MaxLen);
		for (int i = 0; i < len; i++)
			strHead[i] = str[i];
		NbOfCharOfHead = len;
		fun = f;
	}
};
static std::list <tFrameMapping> arFrame;
static bool DecodeFrame(const char* strFrame, int length);

//暂无取固定值的使用要求
std::vector <float> g_MA_List  = { 8, 10, 12.5, 16, 20, 25, 32, 40, 50, 64, 80, 100, 125, 160, 200, 250, 320, 400, 500, 640 };
std::vector <float> g_MAS_List = { 1, 1.25, 1.6, 2, 2.5, 3.2, 4, 5, 6.4, 8, 10, 12.5, 16, 20, 25, 32, 40, 50, 64, 80, 100, 125, 160, 200, 250, 320, 400, 500, 640, 800, 1000 };
std::vector <float> g_MS_List  = { 1, 2, 3, 4, 5, 6, 8, 10, 12, 16, 20, 25, 32, 40, 50, 64, 80, 100, 125, 160, 200, 250, 320, 400, 500, 640, 800, 1000, 1250, 1600, 2000, 2500, 3200, 4000, 5000, 6400, 8000, 10000 };
int g_AECFIELD_List [] = { 1, 10, 100, 11, 101, 110, 111 };
bool RapidChangeValue(float& value, std::vector <float>& list,bool isIncAct)
{

	auto item = std::find(list.begin(), list.end(), value);
	if (isIncAct)
	{
		if (item == list.end())
			value += 5;
		else
		{
			int index = distance(list.begin(), item)+1;
			if (index + 3 >= list.size())
				value = *(list.end() - 1);
			else
				value = *(item + 3);
		}
	}
	else
	{
		if (item == list.end())
			value -= 5;
		else if (item == list.end() - 1)
			return false;
		else
		{
			int index = distance(list.begin(), item);
			if (index - 3 <= 0)
				value = *(list.begin());
			else
				value = *(item - 3);
		}
	}
	return true;
}
template<typename T>
int FindPositon (T *pList, int nListSize, T& value)
{
	if (pList == NULL || nListSize == 0) return -1;

	if (value <= pList [0])
	{
		value = pList [0];
		return 0;
	}
	if (value >= pList [nListSize - 1])
	{
		value = pList [nListSize - 1];
		return nListSize - 1;
	}
	for (int i = 0; i < nListSize - 1; i++)
	{
		if (value >= pList [i] && value <= pList [i + 1])
		{
			int npos = 0;
			if (abs (value - pList [i]) >= abs (value - pList [i + 1]))
			{
				value = pList [i + 1];
				npos = i + 1;
			}
			else
			{
				value = pList [i];
				npos = i;
			}
			return npos;
		}
	}
	return -1;
}

//-----------------------------------------------------------------------------
//		SDCDevice
//-----------------------------------------------------------------------------

nsGEN::SDCDevice::SDCDevice(std::shared_ptr <IOEventCenter> center, nsSCF::SCF SCF,std::string configPath) : super(center, SCF)
{
	assert(EventCenter);
	//CreateLogger("SDCSHRF");
	//load config XML
	m_strConfigPath = configPath;
	ResDataObject temp;
	temp.loadFile(m_strConfigPath.c_str());
	m_GenConfig = temp["CONFIGURATION"];
	TransJsonText(m_GenConfig);
	string version;
	if (GetVersion(version, hMyModule))
		FDEBUG("\n===============log begin : version:{$} ===================", version.c_str());
	else
		FDEBUG("===============log begin : version:0.0.0.0 ===================\n");

	m_DoseUnit.m_KV.reset(new KVMould(0.0, 40.0, 150.0, 1.0));
	m_DoseUnit.m_MA.reset(new MAMould(500, 8.0, 1000.0, 0.1));
	m_DoseUnit.m_MS.reset(new MSMould(0.0, 1.0, 10000.0, 0.01));
	m_DoseUnit.m_MAS.reset(new MASMould(0.0, 0.5, 1000.0, 0.01));
	m_DoseUnit.m_Techmode.reset(new TECHMODEMould(0, 0, 2, 1));
	m_DoseUnit.m_WS.reset(new WORKSTATIONMould(1, 1, 8, 1));
	m_DoseUnit.m_Focus.reset(new FOCUSMould(1, 0, 1, 1));
	m_DoseUnit.m_AECField.reset(new AECFIELDMould(0, 0, 111, 1));
	m_DoseUnit.m_AECFilm.reset(new AECFILMMould(0, 0, 2, 1));
	m_DoseUnit.m_AECDensity.reset(new AECDENSITYMould(0, -4, 4, 1));
	m_DoseUnit.m_HE.reset(new TUBEHEATMould(0, 0, 100, 1));
	m_DoseUnit.m_PostKV.reset(new POSTKVMould(0.0, 40.0, 150.0, 1.0));
	m_DoseUnit.m_PostMA.reset(new POSTMAMould(0.0, 8.0, 1000.0, 0.1));
	m_DoseUnit.m_PostMS.reset(new POSTMSMould(0.0, 1.0, 10000.0, 0.01));
	m_DoseUnit.m_PostMAS.reset(new POSTMASMould(0.0, 0.5, 1000.0, 0.01));

	m_DoseUnit.m_GenSynState.reset(new GENSYNSTATEMould(0, AttrKey::GENERATOR_SYNC_ERR, AttrKey::GENERATOR_RAD_XRAYOFF, 1));
	m_DoseUnit.m_GenState.reset(new GENSTATEMould(4, AttrKey::GENERATOR_STATUS_SHUTDOWN, AttrKey::GENERATOR_STATUS_MAX, 1));
	m_DoseUnit.m_GenTotalExpNumber.reset(new TOTALEXPNUMMould(0, 0, 9999, 1));
	m_DoseUnit.m_GenTotalAcqTimes.reset(new TOTALACQTIMESMould(0, 0, 9999, 1));
	m_DoseUnit.m_GenTubeCoolWaitTimes.reset(new TUBECOOLTIMEMould(0, 0, 9999, 1));
	m_DoseUnit.m_GenTubeOverLoadNumber.reset(new TUBEOVERLOADNUMMould(0, 0, 9999, 1));
	m_DoseUnit.m_GenCurrentExpNumber.reset(new CUREXPNUMMould(0, 0, 9999, 1));
	m_MSGUnit.reset(new nsDetail::MSGUnit(center, GeneratorUnitType));
	m_DAP.reset(new DevDAP::DOSEMould(0.0, 0.0, 1000.0, 0.01));
	m_hGenPostEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
	m_hSendingThreadToggleEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
	m_hGenCPEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
	m_hGenACKEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
	m_hGenSELFEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

	//m_nDeviceType = (int)(m_GenConfig["GenType"]);//默认设置为2. 带有coll的。
	InitializeCriticalSection(&m_iCriticalSection);
	m_bSendingCommandsThreadExit = false;
	m_TimeoutReset = 0;
	m_bExpoEnable = false;
	m_bExpoFlag = false;
	m_sendEnable = true;
	m_arrWSMap.clear();
	//add by wxx for demand574
	if (m_GenConfig.GetKeyCount(ConfKey::CcosTubeInfo) > 0)
	{
		string tempValue = m_GenConfig[ConfKey::CcosTubeInfo];
		m_DoseUnit.m_TubeInfo.reset(new TUBEINFOMould(tempValue));
	}
	if (m_GenConfig.GetKeyCount(ConfKey::CcosFocusSmall) > 0)
	{
		float tempValue = (float)m_GenConfig[ConfKey::CcosFocusSmall];
		m_DoseUnit.m_FocusSmall = tempValue;
	}
	if (m_GenConfig.GetKeyCount(ConfKey::CcosFocusLarge) > 0)
	{
		float tempValue = (float)m_GenConfig[ConfKey::CcosFocusLarge];
		m_DoseUnit.m_FocusLarge = tempValue;
	}
	//同步模式
	if (m_GenConfig.GetKeyCount("WSTable") > 0)
	{
		int WSNamber = (int)m_GenConfig["WSTable"];
		EnSYNMode WSSYN = (EnSYNMode)((int)m_GenConfig["SYNTable"]);
		m_arrWSMap[cfgWorkStationKey("Table", AttrKey::TABLE)] = cfgWorkStationData("Table", WSNamber, WSSYN);
		FDEBUG("cfg Table WS[{$}],SYN[{$}]", WSNamber, (int)WSSYN);
	}
	if (m_GenConfig.GetKeyCount("WSWall") > 0)
	{
		int WSNamber = (int)m_GenConfig["WSWall"];
		EnSYNMode WSSYN = (EnSYNMode)((int)m_GenConfig["SYNWall"]);
		m_arrWSMap[cfgWorkStationKey("Wall", AttrKey::WALL)] = cfgWorkStationData("Wall", WSNamber, WSSYN);
		FDEBUG("cfg Wall WS[{$}],SYN[{$}]", WSNamber, (int)WSSYN);
	}
	if (m_GenConfig.GetKeyCount("WSFree") > 0)
	{
		int WSNamber = (int)m_GenConfig["WSFree"];
		EnSYNMode WSSYN = (EnSYNMode)((int)m_GenConfig["SYNFree"]);
		m_arrWSMap[cfgWorkStationKey("Free", AttrKey::MOBILE)] = cfgWorkStationData("Free", WSNamber, WSSYN);
		FDEBUG("cfg Free WS[{$}],SYN[{$}]", WSNamber, (int)WSSYN);
	}
	if (m_GenConfig.GetKeyCount("WSTomo") > 0)
	{
		int WSNamber = (int)m_GenConfig["WSTomo"];
		EnSYNMode WSSYN = (EnSYNMode)((int)m_GenConfig["SYNTomo"]);
		m_arrWSMap[cfgWorkStationKey("Tomo", AttrKey::TOMO)] = cfgWorkStationData("Tomo", WSNamber, WSSYN);
		FDEBUG("cfg Tomo WS[{$}],SYN[{$}]", WSNamber, (int)WSSYN);
	}
	if (m_GenConfig.GetKeyCount("WSConventional") > 0)
	{
		int WSNamber = (int)m_GenConfig["WSConventional"];
		EnSYNMode WSSYN = (EnSYNMode)((int)m_GenConfig["SYNConventional"]);
		m_arrWSMap[cfgWorkStationKey("Direct", AttrKey::CONVENTIONAL)] = cfgWorkStationData("Direct", WSNamber, WSSYN);
		FDEBUG("cfg Conventional WS[{$}],SYN[{$}]", WSNamber, (int)WSSYN);
	}

	OnCallBack();
	Register();
	StartSendingCommandsThread();
	RefreshData();
}

nsGEN::SDCDevice::~SDCDevice ()
{
	CloseHandle(m_hGenPostEvent);
	StopSendingCommandsThread();
	DeleteCriticalSection(&m_iCriticalSection);
}
std::string nsGEN::SDCDevice::GetGUID() const
{
	printf("\n===============GetGUID : %s ===================\n", GeneratorUnitType);
	return GeneratorUnitType;
}
void nsGEN::SDCDevice::Register()
{
	auto Disp = &Dispatch;

	superGen::Register (Disp);
	superGen::RegisterRAD (Disp);
	superGen::RegisterAEC (Disp);
	superGen::RegisterExpEnable (Disp);
	superGen::RegisterGeneratortoSyncStatus(Disp);

	Disp->Get.Push(m_MSGUnit->GetKey().c_str(), [this](std::string& out) { out = m_MSGUnit->JSGet(); return RET_STATUS::RET_SUCCEED; });

	auto fun_Clear_DAP = [this](auto a, auto&)
	{
		return Clear_DAP();
	};
	Disp->Action.Push ("Clear_DAP", fun_Clear_DAP);
	auto fun_GetValue_DAP = [this](auto a, auto& b)
	{
		float value = 0;
		RET_STATUS ret = GetValue_DAP(value);
		b = ToJSON(value);
		return ret;
	};
	Disp->Action.Push("GetValue_DAP", fun_GetValue_DAP);
}

RET_STATUS nsGEN::SDCDevice::IncKV ()
{
	if (!m_DoseUnit.m_KV->CanInc ())  return RET_STATUS::RET_SUCCEED;
	ProcessCommand("KV+");
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SDCDevice::DecKV ()
{
	if (!m_DoseUnit.m_KV->CanDec ())  return RET_STATUS::RET_SUCCEED;
	ProcessCommand("KV-");
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SDCDevice::SetKV (float value)
{
	if (! m_DoseUnit.m_KV->Verify (value))  return RET_STATUS::RET_SUCCEED;

	char temp [50] = { 0 };
	sprintf_s (temp, "KV%03d", (int)value);
	ProcessCommand(temp);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SDCDevice::IncKVL()
{
	float tempKV = m_DoseUnit.m_KV->Get();
	tempKV += 5;
	if (!m_DoseUnit.m_KV->Verify(tempKV))  return RET_STATUS::RET_SUCCEED;
	ProcessCommand("KV++");
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SDCDevice::DecKVL()
{
	float tempKV = m_DoseUnit.m_KV->Get();
	tempKV -= 5;
	if (!m_DoseUnit.m_KV->Verify(tempKV))  return RET_STATUS::RET_SUCCEED;
	ProcessCommand("KV--");
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SDCDevice::IncMA ()
{
#if 0
	IncMAL();
#else
	if (!m_DoseUnit.m_MA->CanInc ())  return RET_STATUS::RET_SUCCEED;

	if (m_DoseUnit.m_Techmode->Get () == AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		printf ("\n Techmode is MAS, can't set MA");
		return RET_STATUS::RET_FAILED;
	}
	ProcessCommand("MA+");
#endif
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SDCDevice::DecMA ()
{
#if 0
	DecMAL();
#else
	if (!m_DoseUnit.m_MA->CanDec ())  return RET_STATUS::RET_SUCCEED;

	if (m_DoseUnit.m_Techmode->Get () == AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		printf ("\n Techmode is MAS, can't set MA");
		return RET_STATUS::RET_FAILED;
	}
	ProcessCommand("MA-");
#endif
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SDCDevice::SetMA (float value)
{
	if (! m_DoseUnit.m_MA->Verify (value))  return RET_STATUS::RET_SUCCEED;

	if (m_DoseUnit.m_Techmode->Get () == AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		printf ("\n Techmode is MAS, can't set MA");
		return RET_STATUS::RET_FAILED;
	}

	char temp [50] = { 0 };
	sprintf_s (temp, "MA%05d", (int)(value*10));
	ProcessCommand(temp);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SDCDevice::IncMAL()
{
#if 1
	IncMA();
#else
	float tempMA = m_DoseUnit.m_MA->Get(); 
	if (!RapidChangeValue(tempMA, g_MA_List, true))
	{
		return IncMA();
	}

	if (!m_DoseUnit.m_MA->Verify(tempMA))  return RET_STATUS::RET_SUCCEED;
	if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		printf("\n Techmode is MAS, can't set MA");
		return RET_STATUS::RET_FAILED;
	}

	char temp[50] = { 0 };
	sprintf_s(temp, "MA%05d", (int)(tempMA * 10));
	ProcessCommand(temp);
#endif
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SDCDevice::DecMAL()
{
#if 1
	DecMA();
#else
	float tempMA = m_DoseUnit.m_MA->Get();
	if (!RapidChangeValue(tempMA, g_MA_List, false))
	{
		return DecMA();
	}

	if (!m_DoseUnit.m_MA->Verify(tempMA))  return RET_STATUS::RET_SUCCEED;
	if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		printf("\n Techmode is MAS, can't set MA");
		return RET_STATUS::RET_FAILED;
	}

	char temp[50] = { 0 };
	sprintf_s(temp, "MA%05d", (int)(tempMA * 10));
	ProcessCommand(temp);
#endif
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SDCDevice::IncMS ()
{
	if (!m_DoseUnit.m_MS->CanInc ())  return RET_STATUS::RET_SUCCEED;

	if (m_DoseUnit.m_Techmode->Get () == AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		printf ("\n Techmode is MAS, can't set MS");
		return RET_STATUS::RET_FAILED;
	}

	ProcessCommand("MS+");
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SDCDevice::DecMS ()
{
	if (!m_DoseUnit.m_MS->CanDec ())  return RET_STATUS::RET_SUCCEED;

	if (m_DoseUnit.m_Techmode->Get () == AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		printf ("\n Techmode is MAS, can't set MS");
		return RET_STATUS::RET_FAILED;
	}

	ProcessCommand("MS-");
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SDCDevice::SetMS (float value)
{
	if (! m_DoseUnit.m_MS->Verify (value))  return RET_STATUS::RET_SUCCEED;

	if (m_DoseUnit.m_Techmode->Get () == AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		printf ("\n Techmode is MAS, can't set MS");
		return RET_STATUS::RET_FAILED;
	}
	char temp [50] = { 0 };
	sprintf_s (temp, "MS%05d", (int)(value));
	ProcessCommand(temp);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SDCDevice::IncMSL()
{
#if 1
	IncMS();
#else
	float tempMS = m_DoseUnit.m_MS->Get();
	if (!RapidChangeValue(tempMS, g_MS_List, true))
	{
		return IncMS();
	}

	if (!m_DoseUnit.m_MS->Verify(tempMS))  return RET_STATUS::RET_SUCCEED;
	if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		printf("\n Techmode is MAS, can't set MS");
		return RET_STATUS::RET_FAILED;
	}
	char temp[50] = { 0 };
	sprintf_s(temp, "MS%05d", (int)(tempMS));
	ProcessCommand(temp);
#endif
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SDCDevice::DecMSL()
{
#if 1
	DecMS();
#else
	float tempMS = m_DoseUnit.m_MS->Get();
	if (!RapidChangeValue(tempMS, g_MS_List, false))
	{
		return DecMS();
	}

	if (!m_DoseUnit.m_MS->Verify(tempMS))  return RET_STATUS::RET_SUCCEED;
	if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		printf("\n Techmode is MAS, can't set MS");
		return RET_STATUS::RET_FAILED;
	}
	char temp[50] = { 0 };
	sprintf_s(temp, "MS%05d", (int)(tempMS));
	ProcessCommand(temp);
#endif
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SDCDevice::IncMAS ()
{
	if (!m_DoseUnit.m_MAS->CanInc ())  return RET_STATUS::RET_SUCCEED;

	if (m_DoseUnit.m_Techmode->Get () != AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		printf ("\n Techmode is not MAS, can't set MAS");
		return RET_STATUS::RET_FAILED;
	}
	ProcessCommand("MX+");
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SDCDevice::DecMAS ()
{
	if (!m_DoseUnit.m_MAS->CanDec ())  return RET_STATUS::RET_SUCCEED;

	if (m_DoseUnit.m_Techmode->Get () != AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		printf ("\n Techmode is not MAS, can't set MAS");
		return RET_STATUS::RET_FAILED;
	}
	ProcessCommand("MX-");
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SDCDevice::SetMAS (float value)
{
	if (! m_DoseUnit.m_MAS->Verify (value))  return RET_STATUS::RET_SUCCEED;
	if (m_DoseUnit.m_Techmode->Get () != AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		printf ("\n Techmode is not MAS, can't set MAS");
		return RET_STATUS::RET_FAILED;
	}
	char temp [50] = { 0 };
	sprintf_s (temp, "MX%06d", (int)(value * 1000));
	ProcessCommand(temp);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SDCDevice::IncMASL()
{
#if 1
	IncMAS();
#else
	float tempMAS = m_DoseUnit.m_MAS->Get();
	if (!RapidChangeValue(tempMAS, g_MAS_List, true))
	{
		return IncMAS();
	}

	if (!m_DoseUnit.m_MAS->Verify(tempMAS))  return RET_STATUS::RET_SUCCEED;
	if (m_DoseUnit.m_Techmode->Get() != AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		printf("\n Techmode is not MAS, can't set MAS");
		return RET_STATUS::RET_FAILED;
	}
	char temp[50] = { 0 };
	sprintf_s(temp, "MX%06d", (int)(tempMAS * 1000));
	ProcessCommand(temp);
#endif
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SDCDevice::DecMASL()
{
#if 1
	DecMAS();
#else
	float tempMAS = m_DoseUnit.m_MAS->Get();
	if (!RapidChangeValue(tempMAS, g_MAS_List, false))
	{
		return DecMAS();
	}

	if (!m_DoseUnit.m_MAS->Verify(tempMAS))  return RET_STATUS::RET_SUCCEED;
	if (m_DoseUnit.m_Techmode->Get() != AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		printf("\n Techmode is not MAS, can't set MAS");
		return RET_STATUS::RET_FAILED;
	}
	char temp[50] = { 0 };
	sprintf_s(temp, "MX%06d", (int)(tempMAS * 1000));
	ProcessCommand(temp);
#endif
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SDCDevice::SetTechmode (int value)
{
	if (!m_DoseUnit.m_Techmode->Verify (value))  return RET_STATUS::RET_SUCCEED;

#if 0
	char temp [50] = { 0 };
	if (value == AttrKey::TECHMODE_V2TYPE::ET_MAS)
		sprintf_s(temp, "TM%01d", 2);
	else
		sprintf_s(temp, "TM%01d", 3);
	
	ProcessCommand(temp);
#else
	//实际发送长数据
	char strcmd[250] = { 0 };
	if (value == AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		//SetMAS(m_sPreAPRvalue.fMAS);
		sprintf_s(strcmd, "SXWS%1dFO%1dFI%03dFS1FN%1dKV%03dMX%06d",m_DoseUnit.m_WS->Get(), m_DoseUnit.m_Focus->Get(), m_sPreAPRvalue.nAECField, m_sPreAPRvalue.nAECDensity + 4, (int)m_sPreAPRvalue.fKV, (int)(m_sPreAPRvalue.fMAS * 1000));
		//sprintf_s(strcmd, "SA2P%1d%1d%03d%06d", m_DoseUnit.m_WS->Get(), m_DoseUnit.m_Focus->Get(), (int)m_sPreAPRvalue.fKV, (int)(m_sPreAPRvalue.fMAS * 1000));
	}
	else
	{
		//SetMA(m_sPreAPRvalue.fMA);
		//SetMS(m_sPreAPRvalue.fMS);
		sprintf_s(strcmd, "SAWS%1dFO%1dET%1dFI%03dFS1FN%1dKV%03dMA%05dMS%05d",m_DoseUnit.m_WS->Get(), m_DoseUnit.m_Focus->Get(), value, m_sPreAPRvalue.nAECField, m_sPreAPRvalue.nAECDensity + 4, (int)m_sPreAPRvalue.fKV, (int)(m_sPreAPRvalue.fMA * 10), (int)m_sPreAPRvalue.fMS);
		//sprintf_s(strcmd, "SA3P%1d%1d%03d%05d%05d", m_DoseUnit.m_WS->Get(), m_DoseUnit.m_Focus->Get(), (int)m_sPreAPRvalue.fKV, (int)(m_sPreAPRvalue.fMA * 10), (int)m_sPreAPRvalue.fMS);
	}
	ProcessCommand(strcmd);
#endif

	FDEBUG("Enter SetTechmode = {$}", value);
	assert(value);
	bool rc = false;
	int ntechmode = value;
	if (ntechmode == AttrKey::TECHMODE_V2TYPE::ET_AEC)
	{
		rc = m_DoseUnit.m_Techmode->Update(AttrKey::TECHMODE_V2TYPE::ET_AEC);
		if (m_DoseUnit.m_AECField == 0)
		{
			m_DoseUnit.m_AECField->Update(10);
			FireNotify(AttrKey::AECFIELD, m_DoseUnit.m_AECField->JSGet());
		}
	}
	else if (ntechmode == AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		rc = m_DoseUnit.m_Techmode->Update(AttrKey::TECHMODE_V2TYPE::ET_MAS);
	}
	else if (ntechmode == AttrKey::TECHMODE_V2TYPE::ET_TIME)
	{
		rc = m_DoseUnit.m_Techmode->Update(AttrKey::TECHMODE_V2TYPE::ET_TIME);

	}
	if (rc)
	{
		FireNotify(AttrKey::TECHMODE, m_DoseUnit.m_Techmode->JSGet());
	}

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SDCDevice::SetFocus (int value)
{
	if (!m_DoseUnit.m_Focus->Verify (value)) return RET_STATUS::RET_SUCCEED;

	char temp [50] = { 0 };
	sprintf_s (temp, "FOS%01d", (int)value+1);
	ProcessCommand(temp);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SDCDevice::SetAECDensity (int value)
{
	FDEBUG("Enter SetAECDensity = {$}", value);
	if (!m_DoseUnit.m_AECDensity->Verify (value))  return RET_STATUS::RET_SUCCEED;
	if (m_DoseUnit.m_Techmode->Get () != AttrKey::TECHMODE_V2TYPE::ET_AEC)
		return RET_STATUS::RET_FAILED;
	FDEBUG("2 Enter SetAECDensity = {$}", value);
	if (m_DoseUnit.m_AECDensity->Get() != value)
	{
		char temp[50] = { 0 };
		int realData = ((int)value + 4);
		sprintf_s(temp, "FN%01d", realData);
		ProcessCommand(temp);
		FDEBUG("3 Enter SetAECDensity = {$}", value);
	}

	FDEBUG("4 Enter SetAECDensity = {$}", value);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SDCDevice::SetAECField (int value)
{
	FDEBUG("Enter SetAECField = {$}", value);
	if (!m_DoseUnit.m_AECField->Verify (value))  return RET_STATUS::RET_SUCCEED;
	if (m_DoseUnit.m_Techmode->Get () == AttrKey::TECHMODE_V2TYPE::ET_MAS)
		return RET_STATUS::RET_FAILED;

	char temp [50] = { 0 };

	int leftValue = value / 100;
	int midValue = (value % 100) / 10;
	int rightValue = value % 10;


	sprintf_s (temp, "FI0%01d", leftValue);
	ProcessCommand(temp);

	sprintf_s(temp, "FI1%01d", midValue);
	ProcessCommand(temp);

	sprintf_s(temp, "FI2%01d", rightValue);
	ProcessCommand(temp);
	FDEBUG("Leave SetAECField = {$}", value);

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SDCDevice::SetAECFilm (int value)
{
	if (!m_DoseUnit.m_AECFilm->Verify (value))  return RET_STATUS::RET_SUCCEED;

	if (m_DoseUnit.m_Techmode->Get () == AttrKey::TECHMODE_V2TYPE::ET_MAS)
		return RET_STATUS::RET_FAILED;

	char temp [50] = { 0 };
	sprintf_s (temp, "FS%01d", (int)value);
	ProcessCommand(temp);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS  nsGEN::SDCDevice::SetWS (const string value)
{
	FDEBUG("Enter SetWS {$}", value);
	int tempws = 1;
	string strWS = "";
	cfgWorkStationKey trWS = cfgWorkStationKey(value.c_str());
	if (m_arrWSMap.find(trWS) != m_arrWSMap.end())
	{
		m_strCurrentWSName = trWS;
		tempws = m_arrWSMap[m_strCurrentWSName].nWSNamber;
		strWS = m_arrWSMap[m_strCurrentWSName].strWSNAme;
		FDEBUG("Set WS number [{$}][{$}]", strWS.c_str(), tempws);
	}
	else
	{
		FDEBUG("Set WS number default 1");
		m_strCurrentWSName = cfgWorkStationKey(1);
	}

	char temp[50] = { 0 };
	sprintf_s(temp, "WS%01d", tempws);
	ProcessCommand(temp);
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsGEN::SDCDevice::SetAPR (const _tAPRArgs& t)
{
	char strcmd[256];
	FDEBUG("Enter SETAPR t.nWS={$},t.fKV={$},t.fMA={$},t.fMAS={$},t.fMS={$},t.nAECDensity={$},t.nAECField={$},t.nAECFilm={$},t.nFocus={$},t.nTechmode={$} \n",
				t.nWS, t.fKV, t.fMA, t.fMAS, t.fMS, t.nAECDensity, t.nAECField, t.nAECFilm, t.nFocus, t.nTechmode);
	FDEBUG("[SynMode:{$},SynValue:{$},WS:{$}],currentMode[{$}]",
				m_SyncMode.strSyncMode.c_str(), m_SyncMode.strSyncValue.c_str(), m_SyncMode.strWS.c_str(), m_DoseUnit.m_ExpMode->JSGet().c_str());
	int tempws = atoi(m_SyncMode.strSyncValue.c_str());

	//if (m_arrWSMap.find(cfgWorkStationKey(t.nWS)) != m_arrWSMap.end())
	//{
	//	m_strCurrentWSName = cfgWorkStationKey(t.nWS);
	//	tempws = m_arrWSMap[m_strCurrentWSName].nWSNamber;
	//	FDEBUG("Set WS number {$}", tempws);
	//}
	//else
	//{
	//	FDEBUG("Set WS number default 1");
	//	m_strCurrentWSName = cfgWorkStationKey(t.nWS);
	//	tempws = t.nWS;
	//}

	//add by wxx for bug6097 20230919
	FDEBUG("save APR value");
	m_sPreAPRvalue = t;
	if (m_DoseUnit.m_Techmode->Verify(t.nTechmode))
		m_DoseUnit.m_Techmode->Update(t.nTechmode);
		FireNotify(m_DoseUnit.m_Techmode->GetKey(), m_DoseUnit.m_Techmode->JSGet());

	if (t.nTechmode == AttrKey::TECHMODE_V2TYPE::ET_MAS)
	{
		sprintf_s(strcmd, "SXWS%1dFO%1dFI%03dFS1FN%1dKV%03dMX%06d", tempws, t.nFocus, t.nAECField, t.nAECDensity + 4, (int)t.fKV, (int)(t.fMAS * 1000));
	}
	else
	{
		//sprintf_s(strcmd, "SAWS%1dFO%1dE0FI%03dFS1FN%1dKV%03dMA%05dMS%05d", m_DoseUnit.m_WS->Get(), t.nFocus, t.nAECField, t.nAECDensity + 4, (int)t.fKV, (int)(t.fMA * 10), (int)t.fMS); 
		sprintf_s(strcmd, "SAWS%1dFO%1dET%1dFI%03dFS1FN%1dKV%03dMA%05dMS%05d", tempws, t.nFocus, 0, t.nAECField, t.nAECDensity + 4, (int)t.fKV, (int)(t.fMA * 10), (int)t.fMS);
	}
	ProcessCommand(strcmd);
	FDEBUG("Leave SETAPR = {$}", strcmd);

	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SDCDevice::QueryHE(int& value)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SDCDevice::QueryPostKV(float& value)
{
	if (WAIT_OBJECT_0 == WaitForSingleObject(m_hGenPostEvent, 100))
	{
		value = m_DoseUnit.m_PostKV->Get();
		return RET_STATUS::RET_SUCCEED;
	}
	else
	{
		value = 0.0;
		return RET_STATUS::RET_SUCCEED;
	}
	
	
}

RET_STATUS nsGEN::SDCDevice::QueryPostMA(float& value)
{
	if (WAIT_OBJECT_0 == WaitForSingleObject(m_hGenPostEvent, 100))
	{
		value = m_DoseUnit.m_PostMA->Get();
		return RET_STATUS::RET_SUCCEED;
	}
	else
	{
		value = 0.0;
		return RET_STATUS::RET_SUCCEED;
	}
}

RET_STATUS nsGEN::SDCDevice::QueryPostMS(float& value)
{
	if (WAIT_OBJECT_0 == WaitForSingleObject(m_hGenPostEvent, 100))
	{
		value = m_DoseUnit.m_PostMS->Get();
		return RET_STATUS::RET_SUCCEED;
	}
	else
	{
		value = 0.0;
		return RET_STATUS::RET_SUCCEED;
	}
}

RET_STATUS nsGEN::SDCDevice::QueryPostMAS(float& value)
{
	if (WAIT_OBJECT_0 == WaitForSingleObject(m_hGenPostEvent, 100))
	{
		value = m_DoseUnit.m_PostMAS->Get();
		return RET_STATUS::RET_SUCCEED;
	}
	else
	{
		value = 0.0;
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS nsGEN::SDCDevice::Clear_DAP()
{
	ProcessCommand("DOR", WaitForNothing);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SDCDevice::GetValue_DAP(float& value)
{
	if (WAIT_OBJECT_0 == WaitForSingleObject(m_hGenPostEvent, 100))
	{
		value = m_DAP->Get();
		return RET_STATUS::RET_SUCCEED;
	}
	else
	{
		value = 0.0;
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS nsGEN::SDCDevice::ActiveSyncMode(_tSyncModeArgs value)
{
	FDEBUG("Enter ActiveSyncMode:[SynMode:{$},SynValue:{$},WS:{$}],currentMode[{$}]",
				value.strSyncMode.c_str(), value.strSyncValue.c_str(), value.strWS.c_str(), m_DoseUnit.m_ExpMode->JSGet().c_str());
	m_SyncMode = value;
	int tempSynNUm = atoi(value.strSyncValue.c_str());
	if (tempSynNUm == m_DoseUnit.m_WS->Get())
	{
		char temp[50] = { 0 };
		sprintf_s(temp, "WS%01d", tempSynNUm);
		if (value.strSyncMode == AttrKey::SYNC_TYPE::SYNC_HWS)
		{
			ProcessCommand(temp);
		}
		else if (value.strSyncMode == AttrKey::SYNC_TYPE::SYNC_CMD)
		{
			ProcessCommand(temp);
		}
		else if (value.strSyncMode == AttrKey::SYNC_TYPE::SYNC_FRE)
		{
			ProcessCommand(temp);
		}
		else if (value.strSyncMode == AttrKey::SYNC_TYPE::SYNC_DEMO)
		{
		}
		FDEBUG("ActiveSyncMode:not support [{$}:{$}] in [{$}]", value.strSyncMode.c_str(), value.strSyncValue.c_str(), m_DoseUnit.m_ExpMode->JSGet().c_str());
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SDCDevice::SetGenSynState(int value)
{
	FDEBUG("SetGenSynState:[{$}]", value);

	if (value == 3 && m_DoseUnit.m_GenSynState->Get() == nsGEN::AttrKey::GENERATOR_RAD_READY)
	{
		if (m_SyncMode.strSyncMode == AttrKey::SYNC_TYPE::SYNC_CMD)
		{
			
			//if (m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_XRAYON))
			//	FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
			FDEBUG("SetGenSynState: in softSYN,turn to RAD_XRAYON and send XR1");
			ProcessCommand(SpecialCMDXR1, -1, true);
		}
		else
		{
			FDEBUG("SetGenSynState:SyncMode[{$}] not CMD", m_SyncMode.strSyncMode.c_str());
		}
	}
	else
	{
		FDEBUG("SetGenSynState: generator is not in ready status, can't send XR1 command");
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SDCDevice::SetGenState(int value)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SDCDevice::RefreshData ()
{
	if(m_DoseUnit.m_GenState->Update(nsGEN::AttrKey::GENERATOR_STATUS_INIT))
		m_DoseUnit.m_GenState->Update(nsGEN::AttrKey::GENERATOR_STATUS_INIT);
	FDEBUG("RefreshData:gen state is GENERATOR_STATUS_INIT");
	ProcessCommand(SpecialCMDAR);
	ProcessCommand(SpecialCMDRF);
	ProcessCommand(SpecialCMDST);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SDCDevice::SetExpEnable()
{
	ProcessCommand(SpecialCMDRX1);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SDCDevice::SetExpDisable()
{
	ProcessCommand(SpecialCMDRX0);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SDCDevice::Reset()
{
	ProcessCommand(SpecialCMDAR);
	if (m_bExpoEnable.load() == false)
	{
		ProcessCommand(SpecialCMDRX1);
	}
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SDCDevice::SetExpMode(std::string value)
{
	FireNotify(AttrKey::GENSTATE, m_DoseUnit.m_GenState->JSGet());
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SDCDevice::SetFLFMode(std::string value)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SDCDevice::SetEXAMMode(std::string value)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SDCDevice::SetFrameRate(FLOAT frameRate)
{
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SDCDevice::HWSend (char* strCommand, int iWaitType , int nTimeOut)
{
	int nWhileNumber = 0;
	if (!m_SCF)
	{
		FERROR("HWSend: m_SCF is null");
		return RET_STATUS::RET_FAILED;
	}
	else if (!m_sendEnable &&
			 !(strncmp(strCommand, SpecialCMDAR,2) == 0 || strncmp(strCommand, SpecialCMDST, 2) == 0))//如果发生器处于错误状态，并且发送的不是AR或者ST命令，通通不发
	{
		FDEBUG("HWSend: Don`t Send Command: [{$}]", strCommand);
		StopWait();
		return RET_STATUS::RET_FAILED;
	}
	
	ResetEvent(m_hGenCPEvent);
	ResetEvent(m_hGenACKEvent);
	ResetEvent(m_hGenSELFEvent);
	
	if(!m_bExpoFlag || 
	   (m_bExpoFlag && (strncmp(strCommand, SpecialCMDXR1, 3) == 0 || 
						strncmp(strCommand, SpecialCMDXR0, 3) == 0 ||
						strncmp(strCommand, SpecialCMDPC, 2) == 0)))
	{
		char strSendCommand[100] = { 0 };
		int len = strlen(strCommand);
		if (len < 100)
		{
			::memcpy(strSendCommand, strCommand, len);
		}
		strSendCommand[len] = 0x0d;
		strSendCommand[len + 1] = 0x0a;
		strSendCommand[len + 2] = 0x03;
		//strSendCommand [len + 3] = 0x00;
		FDEBUG("==OUT==:[{$}]", strSendCommand);
		int ret = 0;
		m_SCF.Lock(msTimeOut_Lock)
			.SendPacket(strSendCommand, strlen(strSendCommand), nTimeOut, ret);
		//Sleep(nTimeOut);
	}
	else
	{
		StopWait();
	}
	return RET_STATUS::RET_SUCCEED;
}
void nsGEN::SDCDevice::WaitforSELF(const char* cmd, int lengh)
{
	if (m_strCurrentCommand.strCommand.compare(0, lengh, cmd, 0, lengh) != 0)
	{
		return;
	}
	if (m_strCurrentCommand.nCommmandType % 10 > 0)
	{
		m_strCurrentCommand.nCommmandType -= 1;
	}
	FDEBUG("WaitforSELF:get cmd[{$}]type[{$}] self", m_strCurrentCommand.strCommand.c_str(), m_strCurrentCommand.nCommmandType.load());
	SetEvent(m_hGenSELFEvent);
}
void nsGEN::SDCDevice::WaitforACK()
{
	if (m_strCurrentCommand.nCommmandType % 100 >= 10)
	{
		m_strCurrentCommand.nCommmandType -= 10;
	}
	FDEBUG("WaitforACK:get cmd[{$}]type[{$}] ACK", m_strCurrentCommand.strCommand.c_str(), m_strCurrentCommand.nCommmandType.load());
	SetEvent(m_hGenACKEvent);
}
void nsGEN::SDCDevice::WaitforCP()
{
	if (m_strCurrentCommand.nCommmandType >= 100)
	{
		m_strCurrentCommand.nCommmandType -= 100;
	}
	FDEBUG("WaitforCP:get cmd[{$}]type[{$}] cp", m_strCurrentCommand.strCommand.c_str(), m_strCurrentCommand.nCommmandType.load());
	SetEvent(m_hGenCPEvent);
}
void nsGEN::SDCDevice::StopWait()
{
	if (!m_strCurrentCommand.strCommand.empty())
	{
		FDEBUG("StopWait:cmd[{$}]type[{$}] not wait", m_strCurrentCommand.strCommand.c_str(), m_strCurrentCommand.nCommmandType.load());
		m_strCurrentCommand.nCommmandType = 0;
	}
}

void nsGEN::SDCDevice::FireNotify (std::string key, std::string content)
{
	EventCenter->OnNotify (1, key, content);
}
bool nsGEN::SDCDevice::ProcessCommand(std::string strCommand, int nType, bool isFirstSend)
{
	tagCommandStruct TempSDCCommand;
	TempSDCCommand.strCommand = strCommand;
	if (nType == -1)
	{
		TempSDCCommand.nCommmandType = 0;
		if (std::find_if(g_WaitSELF_List.begin(), g_WaitSELF_List.end(), [strCommand](const string& Item)
						 {
							 if (strCommand.compare(0, Item.length(), Item, 0, Item.length()) == 0)
							 {
								 return true;
							 }
							 return false;
						 }) != g_WaitSELF_List.end())
		{
			TempSDCCommand.nCommmandType += 1;
		}
		if (std::find_if(g_WaitAKCMD_List.begin(), g_WaitAKCMD_List.end(), [strCommand](const string& Item)
						{
							if (strCommand.compare(0, Item.length(), Item, 0, Item.length()) == 0)
							{
								return true;
							}
							return false;
						}) != g_WaitAKCMD_List.end())
		{
			TempSDCCommand.nCommmandType += 10;
		}
		if (std::find_if(g_WaitCPCMD_List.begin(), g_WaitCPCMD_List.end(), [strCommand](const string& Item)
						{
							if (strCommand.compare(0, Item.length(), Item, 0, Item.length()) == 0)
							{
								return true;
							}
							return false;
						}) != g_WaitCPCMD_List.end())
		{
			TempSDCCommand.nCommmandType += 100;
		}
	}
	else
		TempSDCCommand.nCommmandType = nType;

	bool firstOldCMD = true;
	EnterCriticalSection(&m_iCriticalSection);
	//当发送ST,HU,SA,SX,DS,RX命令前，清空待发送命令vector中的其他同类型命令，提高发送效率，减少发送错误
	auto found = std::find_if(g_SpecialCMD_List.begin(), g_SpecialCMD_List.end(), [strCommand](const string& Item)
							  {
								  if (strCommand.compare(0, Item.length(), Item, 0, Item.length()) == 0)
								  {
									  return true;
								  }
								  return false;
							  });
	if (found != g_SpecialCMD_List.end())
	{
		if ((strCommand.compare(SpecialCMDAR) == 0) || (strCommand.compare(SpecialCMDXR1) == 0))
		{
			//if (m_DoseUnit.m_GenState->Get() == nsGEN::AttrKey::GENERATOR_STATUS_STANDBY)
			//{
				m_SdcCommondvector.clear();
				FDEBUG("ProcessCommand:clear the whole vector when get[{$}] ", strCommand.c_str());
			//}
			//else
			//{
			//	FWARN("ProcessCommand:isn`t GENERATOR_STATUS_STANDBY not clear");
			//}
		}
		else
		{
			//if (m_DoseUnit.m_GenState->Get() == nsGEN::AttrKey::GENERATOR_STATUS_STANDBY)
			//{
				for (int i = 0; i < m_SdcCommondvector.size(); i++)
				{
					if (m_SdcCommondvector[i].strCommand.compare(0, strCommand.length(),strCommand, 0, strCommand.length()) == 0)
					{
						if(firstOldCMD)
						{
							firstOldCMD = false;
							m_SdcCommondvector[i] = TempSDCCommand;
							FDEBUG("ProcessCommand:replace first same command[{$}] in vector ", strCommand.c_str());
						}
						else
						{
							m_SdcCommondvector.erase(m_SdcCommondvector.begin() + i);
							i--;
							FDEBUG("ProcessCommand:Clear other same command[{$}] in vector ", strCommand.c_str());
						}
					}
				}
			//}
			//else
			//{
			//	FWARN("ProcessCommand:isn`t GENERATOR_STATUS_STANDBY not replace");
			//}
		}
	}
	if(firstOldCMD)
	{
		
		if(TempSDCCommand.strCommand.compare(SpecialCMDRX1) == 0)
		{ 
			TempSDCCommand.nWaitTime = 10000;
		}
		if (isFirstSend)
		{
			FDEBUG("ProcessCommand:add cmd[{$}][{$}] in vector begin",
						TempSDCCommand.strCommand.c_str(), TempSDCCommand.nCommmandType.load());
			m_SdcCommondvector.push_front(TempSDCCommand);
		}
		else
		{
			FDEBUG("ProcessCommand:add cmd[{$}][{$}] in vector end", 
						TempSDCCommand.strCommand.c_str(), TempSDCCommand.nCommmandType.load());
			m_SdcCommondvector.push_back(TempSDCCommand);
		}
	}
	LeaveCriticalSection(&m_iCriticalSection);

	return true;
}
bool nsGEN::SDCDevice::ReProcessCommand(std::string strCommand, int nType)
{
	tagCommandStruct TempSDCCommand;
	TempSDCCommand.strCommand = strCommand;
	if (nType == -1)
	{
		TempSDCCommand.nCommmandType = 0;
		if (std::find_if(g_WaitSELF_List.begin(), g_WaitSELF_List.end(), [strCommand](const string& Item)
						 {
							 if (strCommand.compare(0, Item.length(), Item, 0, Item.length()) == 0)
							 {
								 return true;
							 }
							 return false;
						 }) != g_WaitSELF_List.end())
		{
			TempSDCCommand.nCommmandType += 1;
		}
		if (std::find_if(g_WaitAKCMD_List.begin(), g_WaitAKCMD_List.end(), [strCommand](const string& Item)
							  {
								  if (strCommand.compare(0, Item.length(), Item, 0, Item.length()) == 0)
								  {
									  return true;
								  }
								  return false;
							  }) != g_WaitAKCMD_List.end())
		{
			TempSDCCommand.nCommmandType += 10;
		}
		if (std::find_if(g_WaitCPCMD_List.begin(), g_WaitCPCMD_List.end(), [strCommand](const string& Item)
							  {
								  if (strCommand.compare(0, Item.length(), Item, 0, Item.length()) == 0)
								  {
									  return true;
								  }
								  return false;
							  }) != g_WaitCPCMD_List.end())
		{
			TempSDCCommand.nCommmandType += 100;
		}
	}
	else
		TempSDCCommand.nCommmandType = nType;

	EnterCriticalSection(&m_iCriticalSection);
	m_SdcCommondvector.push_front(TempSDCCommand);
	LeaveCriticalSection(&m_iCriticalSection);
	return true;
}

DWORD SDCDevice::SedecalSendingCommandsThread(LPVOID pParam)
{
	FDEBUG("Enter SedecalSendingCommandsThread");
	SDCDevice* pCurrentGen = (SDCDevice*)pParam;
	if (pCurrentGen == NULL)
	{
		FERROR("SendingCommandsThread is null");
		return 0;
	}
	//indicating start thread success;
	SetEvent(pCurrentGen->m_hSendingThreadToggleEvent);

	//perform sending sedecal commands
	while (!pCurrentGen->m_bSendingCommandsThreadExit)
	{
		//query the command from the vector
		if (pCurrentGen->m_SdcCommondvector.size() > 0)
		{
			EnterCriticalSection(&(pCurrentGen->m_iCriticalSection));
			pCurrentGen->m_strCurrentCommand = pCurrentGen->m_SdcCommondvector[0];
			pCurrentGen->m_SdcCommondvector.pop_front();//erase the first command
			FDEBUG("SendingCommandsThread:get cmd[{$}]type[{$}] from vector", 
						pCurrentGen->m_strCurrentCommand.strCommand.c_str(), pCurrentGen->m_strCurrentCommand.nCommmandType.load());
			LeaveCriticalSection(&(pCurrentGen->m_iCriticalSection));

			if (pCurrentGen->m_strCurrentCommand.strCommand != "" && pCurrentGen->m_strCurrentCommand.nCommmandType.load() >= 0)// with commnad
			{
				//if (pCurrentGen->m_strCurrentCommand.strCommand.compare(0, 2, SpecialCMDHU) == 0 || pCurrentGen->m_strCurrentCommand.strCommand.compare(0, 2, SpecialCMDIT) == 0) //not wait command
				//{
				//	pCurrentGen->m_strCurrentCommand.nCommmandType = 0;
				//	pCurrentGen->HWSend((char*)pCurrentGen->m_strCurrentCommand.strCommand.c_str(), 0);
				//}else 
				if (pCurrentGen->m_strCurrentCommand.strCommand.compare(0, 2, SpecialCMDSA) == 0 ||
						 pCurrentGen->m_strCurrentCommand.strCommand.compare(0, 2, SpecialCMDSX) == 0)//APR command, dual energy command
				{
					pCurrentGen->HWSend((char*)pCurrentGen->m_strCurrentCommand.strCommand.c_str(), pCurrentGen->m_strCurrentCommand.nCommmandType, 3000);
				}
				else if (pCurrentGen->m_strCurrentCommand.strCommand.compare(0,3, SpecialCMDFOS) == 0) //FO command
				{
					pCurrentGen->HWSend((char*)pCurrentGen->m_strCurrentCommand.strCommand.c_str(), pCurrentGen->m_strCurrentCommand.nCommmandType, 1000);
				}
				else
				{
					pCurrentGen->HWSend((char*)pCurrentGen->m_strCurrentCommand.strCommand.c_str(), pCurrentGen->m_strCurrentCommand.nCommmandType);
				}
				//等待
				if (pCurrentGen->m_strCurrentCommand.nCommmandType > 0)
				{
					int waitType = pCurrentGen->m_strCurrentCommand.nCommmandType.load();
					int arrayNum = 0;
					bool cmdOver = false;
					HANDLE hEventArray[3];
					if (waitType % 10 > 0)
					{
						hEventArray[arrayNum] = pCurrentGen->m_hGenSELFEvent;
						arrayNum++;
					}
					if (waitType % 100 >= 10)
					{
						hEventArray[arrayNum] = pCurrentGen->m_hGenACKEvent;
						arrayNum++;
					}
					if (waitType >= 100)
					{
						hEventArray[arrayNum] = pCurrentGen->m_hGenCPEvent;
						arrayNum++;
					}
					FDEBUG("SendingCommandsThread:wait cmd[{$}]type[{$}][{$}]waitTime[{$}]",
								pCurrentGen->m_strCurrentCommand.strCommand.c_str(), pCurrentGen->m_strCurrentCommand.nCommmandType.load(), arrayNum, pCurrentGen->m_strCurrentCommand.nWaitTime);
					int waitTime = pCurrentGen->m_strCurrentCommand.nWaitTime;
					DWORD dwResult = WaitForMultipleObjects(arrayNum, hEventArray, TRUE, waitTime);
					switch (dwResult)
					{
						case WAIT_OBJECT_0:
							FDEBUG("SendingCommandsThread:cmd[{$}]type[{$}] is over",
										pCurrentGen->m_strCurrentCommand.strCommand.c_str(), pCurrentGen->m_strCurrentCommand.nCommmandType.load());
							cmdOver = true;
							pCurrentGen->m_TimeoutReset = 0;
							break;
						case WAIT_TIMEOUT:
							FDEBUG("SendingCommandsThread:cmd[{$}]type[{$}] is timeout",
										pCurrentGen->m_strCurrentCommand.strCommand.c_str(), pCurrentGen->m_strCurrentCommand.nCommmandType.load());
							if (pCurrentGen->m_strCurrentCommand.nCommmandType.load() == 0)
							{
								cmdOver = true;
								pCurrentGen->m_TimeoutReset = 0;
							}
							break;
						case WAIT_FAILED:
							FDEBUG("SendingCommandsThread:cmd[{$}]type[{$}] is failed",
										pCurrentGen->m_strCurrentCommand.strCommand.c_str(), pCurrentGen->m_strCurrentCommand.nCommmandType.load());
							break;
					}
					if (!cmdOver)
					{
						if (pCurrentGen->m_TimeoutReset <= 3)
						{
							pCurrentGen->m_TimeoutReset++;
							pCurrentGen->ReProcessCommand(pCurrentGen->m_strCurrentCommand.strCommand);
						}
						else
						{
							pCurrentGen->m_TimeoutReset = 0;
							FWARN("SendingCommandsThread:cmd[{$}]type[{$}] Exceeded attempts",
									   pCurrentGen->m_strCurrentCommand.strCommand.c_str(), pCurrentGen->m_strCurrentCommand.nCommmandType.load());
						}
					}
					else
					{
						Sleep(30);//no commnad to send, so sleep 10 ms
					}
				}
			}
			else
			{
				Sleep(30);//no commnad to send, so sleep 10 ms
			}
		}
		else
		{
			Sleep(10);//no commnad to send, so sleep 10 ms
		}
		// send command
		if (!(pCurrentGen->m_bExpoFlag)) //add by wxx for bug6038 20230919
		{
			DWORD tmNowTime = GetTickCount();
			if (tmNowTime > 15000)
			{
				long runTime = tmNowTime - pCurrentGen->m_tmSysTime;
				if (runTime > 15000)
				{
					pCurrentGen->m_tmSysTime = tmNowTime;
					//pCurrentGen->ProcessCommand(SpecialCMDHU, WaitForCPSELF);
					//pCurrentGen->ProcessCommand(SpecialCMDIT, WaitForNothing);
				}
			}
			else
			{
				pCurrentGen->m_tmSysTime = GetTickCount();
			}
		}
	}
	FDEBUG("End SendingCommandsThread!!");
	//indicating the end of thread;
	SetEvent(pCurrentGen->m_hSendingThreadToggleEvent);

	return 0;
}

//start timer to do offset calibration periodically;
bool SDCDevice::StartSendingCommandsThread()
{
	//create thread;
	DWORD m_HardwareStatusID;
	m_SendingCommandsThread = CreateThread(0, 0, SedecalSendingCommandsThread, this, 0, &m_HardwareStatusID);
	FDEBUG("Enter StartSendingCommandsThread beion");

	if (NULL == m_SendingCommandsThread)
	{
		FDEBUG("StartSendingCommandsThread failed \n");
		return false;
	}
	//wait till thread create successful;
	if (WaitForSingleObject(m_hSendingThreadToggleEvent, 5000) == WAIT_OBJECT_0)
	{
		FDEBUG("detected the start of sending commands thread!");
		ResetEvent(m_hSendingThreadToggleEvent);
	}
	FDEBUG("StartSendingCommandsThread end \n");
	m_nSendingCommandsThreadId = m_HardwareStatusID;

	return true;
}

bool SDCDevice::SetAcquireSatus()
{
	ProcessCommand("RFW");
	return true;
}

//stop sending commands thread periodically;
void SDCDevice::StopSendingCommandsThread()
{
	FDEBUG("sending commands thread exiting...");

	if (NULL != m_SendingCommandsThread)
	{
		m_bSendingCommandsThreadExit = true;
		if (::WaitForSingleObject(m_hSendingThreadToggleEvent, 5000) == WAIT_OBJECT_0)
		{
			FDEBUG("detected the exit of sending commands thread!");
			ResetEvent(m_hSendingThreadToggleEvent);
		}
		else
		{
			DWORD exitCode = 0;
			//Retrieves the termination status of the specified thread;
			if (!GetExitCodeThread(m_SendingCommandsThread, &exitCode))
			{
				DWORD nError = ::GetLastError();
				FDEBUG("GetExitCodeThread() error, error No is [{$}]", nError);
			}
			TerminateThread(m_SendingCommandsThread, exitCode);
		}
		m_SendingCommandsThread = NULL;
	}
}
//	收到硬件的通知, 有包到达
//	按照设计, 仅当数据有变化时, 才发通知到上层, 因此里面有大量的 if (..) FireNotify (..)
void nsGEN::SDCDevice::OnCallBack ()
{
	auto HWNotProcess = [] (const char * value, int length) -> void
	{
		printf ("\n This commands didn't need to process!\n");
	};

	auto HWKV = [this] (const char * value, int length) -> void
	{
		assert (value);
		FDEBUG("Recv KV={$}", value);
		if (m_DoseUnit.m_KV->Verify(atof(value)))
		{
			m_DoseUnit.m_KV->Update(atof(value));
			FireNotify(AttrKey::KV, value);
			m_sPreAPRvalue.fKV = atof(value);
		}
	};

	auto HWMAS = [this] (const char * value, int length)
	{
		assert (value);
		FDEBUG("Recv MAS={$}", value);
		if (m_DoseUnit.m_MAS->Verify(atof(value)))
		{
			m_DoseUnit.m_MAS->Update(atof(value));
			FireNotify(AttrKey::MAS, value);
			if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_V2TYPE::ET_MAS)
				m_sPreAPRvalue.fMAS = atof(value);
		}
	};

	auto HWMA = [this] (const char * value, int length)
	{
		assert (value);
		FDEBUG("Recv MA={$}", value);
		if (m_DoseUnit.m_MA->Verify(atof(value)))
		{
			m_DoseUnit.m_MA->Update(atof(value));
			FireNotify(AttrKey::MA, value);
			if (m_DoseUnit.m_Techmode->Get() != AttrKey::TECHMODE_V2TYPE::ET_MAS)
				m_sPreAPRvalue.fMA = atof(value);
		}
	};

	auto HWMS = [this] (const char * value, int length)
	{
		assert (value);
		FDEBUG("Recv MS={$}", value);
		if (m_DoseUnit.m_MS->Verify(atof(value)))
		{
			m_DoseUnit.m_MS->Update(atof(value));
			FireNotify(AttrKey::MS, value);
			if (m_DoseUnit.m_Techmode->Get() != AttrKey::TECHMODE_V2TYPE::ET_MAS)
				m_sPreAPRvalue.fMS = atof(value);
		}
	};
	auto HWFocus = [this] (const char * value, int length)
	{
		assert (value);
		FDEBUG("Recv FO={$}", value);
		string strval = value;
		if (strval.find("11") != string::npos || strval.find("20") != string::npos)
		{
			m_DoseUnit.m_Focus->Update(0);
		}
		else if (strval.find("10") != string::npos || strval.find("21") != string::npos)
		{
			m_DoseUnit.m_Focus->Update(1);
		}
		
		FireNotify (AttrKey::FOCUS, m_DoseUnit.m_Focus->JSGet());

		if (m_DoseUnit.m_Focus->Get() == AttrKey::FOCUS_SMALL) //add by wxx for demand574
			FireNotify(AttrKey::FOCUSSIZE, std::to_string(m_DoseUnit.m_FocusSmall));
		else
			FireNotify(AttrKey::FOCUSSIZE, std::to_string(m_DoseUnit.m_FocusLarge));
	};
	auto HWTechmode = [this] (const char * value, int length)
	{
		assert(value);
		//实际发送长数据
		//bool rc = false;
		//int ntechmode = atoi (value);
		//if (ntechmode == 2)
		//{
		//	rc = m_DoseUnit.m_Techmode->Update(GENPARAM::ET_MAS);
		//}
		//else
		//{
		//	if (m_DoseUnit.m_AECField->Get () == 0)
		//		rc = m_DoseUnit.m_Techmode->Update(GENPARAM::ET_TIME);
		//	else
		//		rc = m_DoseUnit.m_Techmode->Update(GENPARAM::ET_AEC);
		//}
		//if (rc)
		//	FireNotify (AttrKey::TECHMODE, m_DoseUnit.m_Techmode->JSGet());
		//		printf ("\r\n%s : %f\n", m_DoseUnit.m_Techmode->Key.c_str (), m_DoseUnit.m_Techmode->m_Val);
	};

	auto HWAECField = [this] (const char * value, int length)
	{
		int nvalue = atoi (value);
		auto nToValue = m_DoseUnit.m_AECField->Get ();
		switch (nvalue / 10)
		{
		case 0:
			if (nvalue % 10 == 0)
				nToValue = nToValue & 110;
			else
				nToValue = nToValue | 001;
			break;
		case 1:
			if (nvalue % 10 == 0)
				nToValue = nToValue & 101;
			else
				nToValue = nToValue | 010;
			break;
		case 2:
			if (nvalue % 10 == 0)
				nToValue = nToValue & 11;
			else
				nToValue = nToValue | 100;
			break;
		default:
			break;
		}
		if (m_DoseUnit.m_AECField->Update (nToValue))
		{
			FireNotify(AttrKey::AECFIELD, value);
			if(m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_V2TYPE::ET_AEC)
				m_sPreAPRvalue.nAECField = nToValue;
		}
	};
	auto HWAECFilm = [this] (const char * value, int length)
	{
		assert (value);
		if (m_DoseUnit.m_AECFilm->Update(atoi (value)))
		{
			FireNotify(AttrKey::AECFILM, value);
			if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_V2TYPE::ET_AEC)
				m_sPreAPRvalue.nAECField = atoi(value);
		}
	};
	auto HWAECDensity = [this] (const char * value, int length)
	{
		assert (value);
		if (atoi(value) % 10 != 0)
		{
			if (m_DoseUnit.m_AECDensity->Update(atoi(value) / 10 - 4))
			{
				FireNotify(AttrKey::AECDENSITY, m_DoseUnit.m_AECDensity->JSGet());
				if (m_DoseUnit.m_Techmode->Get() == AttrKey::TECHMODE_V2TYPE::ET_AEC)
					m_sPreAPRvalue.nAECField = atoi(value) / 10 - 4;
			}
		}
	};
	auto HWWS = [this](const char* value, int length)
	{
		assert(value);
		int nValue = atoi(value);
		if (m_DoseUnit.m_WS->Update(nValue))
		{
			FireNotify(m_DoseUnit.m_WS->GetKey(), m_DoseUnit.m_WS->JSGet());
		}
		
	};
	auto HWPR = [this](const char* value, int length)
	{
		assert(value);
		int nValue = atoi(value);
		if (nValue == 1)
		{
			m_bExpoFlag = true;
			ResetEvent(m_hGenPostEvent);
			if (m_DoseUnit.m_GenSynState->Get() == nsGEN::AttrKey::GENERATOR_RAD_PREPARE ||
				m_DoseUnit.m_GenSynState->Get() == nsGEN::AttrKey::GENERATOR_RAD_READY ||
				m_DoseUnit.m_GenSynState->Get() == nsGEN::AttrKey::GENERATOR_RAD_XRAYON)
			{
				FDEBUG("HWPR:GEN is already in Prep state(PR1)");
			}
			else if (m_DoseUnit.m_GenSynState->Get() == nsGEN::AttrKey::GENERATOR_RAD_OFF)
			{
				FDEBUG("HWPR:RAD_OFF(PR0) -> RAD_PREPARE(PR1)");
				if (m_DoseUnit.m_GenSynState->Update(nsGEN::AttrKey::GENERATOR_RAD_PREPARE))
					FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
			}
			else
			{
				FWARN("HWPR:Wrong state change:{$} -> RAD_PREPARE(PR1)", m_DoseUnit.m_GenSynState->Get());
				if (m_DoseUnit.m_GenSynState->Update(nsGEN::AttrKey::GENERATOR_RAD_PREPARE))
					FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
			}
			m_nSoftSynPR1Flag = true;
		}
		else if (nValue == 2)
		{
			if (m_DoseUnit.m_GenSynState->Get() == nsGEN::AttrKey::GENERATOR_RAD_READY ||
				m_DoseUnit.m_GenSynState->Get() == nsGEN::AttrKey::GENERATOR_RAD_XRAYON ||
				m_DoseUnit.m_GenSynState->Get() == nsGEN::AttrKey::GENERATOR_RAD_XRAYOFF)
			{
				FDEBUG("HWPR:GEN is already to make X-Rays(PR2)");
			}
			else if (m_DoseUnit.m_GenSynState->Get() == nsGEN::AttrKey::GENERATOR_RAD_PREPARE)
			{
				FDEBUG("HWPR:PREPARE or XRAYOFF(PR1 or XR0) -> RAD_READY(PR2)");
				if (m_DoseUnit.m_GenSynState->Update(nsGEN::AttrKey::GENERATOR_RAD_READY))
					FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
			}
			else
			{
				FWARN("HWPR:Wrong state change:{$} -> RAD_READY(PR2)", m_DoseUnit.m_GenSynState->Get());
				if (m_DoseUnit.m_GenSynState->Update(nsGEN::AttrKey::GENERATOR_RAD_READY))
					FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
			}
		}
		else
		{
			m_bExpoFlag = false;
			FDEBUG("HWPR:GEN exit Prep state(PR0)");
			if (m_DoseUnit.m_GenSynState->Update(nsGEN::AttrKey::GENERATOR_RAD_OFF))
				FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
			m_nSoftSynPR1Flag = false;
		}
	};
	auto HWXR = [this](const char* value, int length)
	{
		assert(value);
		int nValue = atoi(value);
		if (nValue == 1)
		{
			WaitforSELF("XR",2);
			if(m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_XRAYON)) //add by wxx for bug6079 20230915
				FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
		}
		else
		{
			m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_XRAYOFF);
			ProcessCommand(SpecialCMDPC); //add by wxx
			//ProcessCommand("PD?",WaitForACK); //add by wxx:Not working
			//ProcessCommand("PDN?",WaitForACK); //add by wxx:Not working
			
			FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
		}
	};
	auto HWXS = [this](const char* value, int length)
	{
		assert(value);
		int nValue = atoi(value);
		if (nValue == 1)
		{
			if (m_nSoftSynPR1Flag)
			{
				if (m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_READY))
					FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
			}
			else
			{
				FWARN("HWXS:not recv PR1,need to wait PR1 to RAD_READY");
				if (m_DoseUnit.m_GenSynState->Get() == nsGEN::AttrKey::GENERATOR_RAD_READY ||
					m_DoseUnit.m_GenSynState->Get() == nsGEN::AttrKey::GENERATOR_RAD_XRAYON ||
					m_DoseUnit.m_GenSynState->Get() == nsGEN::AttrKey::GENERATOR_RAD_XRAYOFF)
				{
					FDEBUG("HWPR:GEN is already to make X-Rays(PR2)");
				}
				else if (m_DoseUnit.m_GenSynState->Get() == nsGEN::AttrKey::GENERATOR_RAD_PREPARE)
				{
					FDEBUG("HWPR:PREPARE or XRAYOFF(PR1 or XR0) -> RAD_READY(PR2)");
					if (m_DoseUnit.m_GenSynState->Update(nsGEN::AttrKey::GENERATOR_RAD_READY))
						FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
				}
				else
				{
					FWARN("HWPR:Wrong state change:{$} -> RAD_READY(PR2)", m_DoseUnit.m_GenSynState->Get());
					if (m_DoseUnit.m_GenSynState->Update(nsGEN::AttrKey::GENERATOR_RAD_READY))
						FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
				}
			}
		}
		else
		{
			//if(m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_XRAYOFF))
			//	FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
			//ProcessCommand(SpecialCMDPC); //add by wxx
			//ProcessCommand("PD?",WaitForACK); //add by wxx:Not working
			//ProcessCommand("PDN?",WaitForACK); //add by wxx:Not working

			//FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
		}
	};
	auto HWRX = [this](const char* value, int length) -> void
	{
		assert(value);
		int nValue = atoi(value);
		if (nValue == 1)
		{
			FDEBUG("HWRX:[{$}],exp enable", nValue);
			m_bExpoEnable = true;
		}
		else
		{
			FDEBUG("HWRX:[{$}],exp disable", nValue);
			m_bExpoEnable = false;
		}
		WaitforSELF(SpecialCMDRX,2);
	};
	auto HWDOSE = [this](const char* value, int length) //PC:<mA> <mAs> <ms> <dose>
	{
		assert(value);
		string strval = value;
		if (length >= 13)
		{
			//解析Post值 aaaa bbbb ccccc  aaaa postma, ccccc postms
			m_DoseUnit.m_PostKV->Update(m_DoseUnit.m_KV->Get());
			FireNotify(m_DoseUnit.m_PostKV->GetKey(), m_DoseUnit.m_PostKV->JSGet());

			m_DoseUnit.m_PostMA->Update(atof(strval.substr(0,4).c_str()));
			FireNotify(m_DoseUnit.m_PostMA->GetKey(), m_DoseUnit.m_PostMA->JSGet());

			m_DoseUnit.m_PostMS->Update(atof(strval.substr(8, 5).c_str()));
			FireNotify(m_DoseUnit.m_PostMS->GetKey(), m_DoseUnit.m_PostMS->JSGet());

			m_DoseUnit.m_PostMAS->Update(m_DoseUnit.m_PostMA->Get()* m_DoseUnit.m_PostMS->Get() / 1000.0);
			FireNotify(m_DoseUnit.m_PostMAS->GetKey(), m_DoseUnit.m_PostMAS->JSGet());
			SetEvent(m_hGenPostEvent);
		}
		if (length == 19)
		{
			//解析DAP值 后六位ddd eff  ddd*10^eff mGycm2, mGycm2/100=dGycm2
		}
	};
	auto HWPD = [this](const char* value, int length)//add by wxx:PD:<mA> <mAs> <ms>
	{
		assert(value);
		string strval = value;
		if (length >= 13)
		{
			//解析Post值 aaaa bbbb ccccc  aaaa postma, ccccc postms
			m_DoseUnit.m_PostKV->Update(m_DoseUnit.m_KV->Get());
			FireNotify(m_DoseUnit.m_PostKV->GetKey(), m_DoseUnit.m_PostKV->JSGet());

			m_DoseUnit.m_PostMA->Update(atof(strval.substr(0, 4).c_str()));
			FireNotify(m_DoseUnit.m_PostMA->GetKey(), m_DoseUnit.m_PostMA->JSGet());

			m_DoseUnit.m_PostMS->Update(atof(strval.substr(8, 5).c_str()));
			FireNotify(m_DoseUnit.m_PostMS->GetKey(), m_DoseUnit.m_PostMS->JSGet());

			m_DoseUnit.m_PostMAS->Update(m_DoseUnit.m_PostMA->Get() * m_DoseUnit.m_PostMS->Get() / 1000.0);
			FireNotify(m_DoseUnit.m_PostMAS->GetKey(), m_DoseUnit.m_PostMAS->JSGet());
			SetEvent(m_hGenPostEvent);
		}
	};
	auto HWERROR = [this](const char* value, int length)
	{
		assert(value);
		int nValue = atoi(value);
		if (nValue != 0)
		{
			if (99 == nValue)
			{
				char WarnCode[100]{ "" };
				sprintf_s(WarnCode, "SDC_WARN_%d", nValue);
				int level = 1;
				m_MSGUnit->AddWarnMessage(WarnCode, level, "");
				FDEBUG("HWERROR: recv ER099,try to ReSet");
				ProcessCommand(SpecialCMDAR);
				ProcessCommand(SpecialCMDRF);
				ProcessCommand(SpecialCMDST);
				ProcessCommand(SpecialCMDRX1);
			}
			else
			{
				char ErrorCode[100]{ "" };
				sprintf_s(ErrorCode, "SDC_ERR_%d", nValue);
				int level = 1;
				m_MSGUnit->AddErrorMessage(ErrorCode, level, "");

				m_sendEnable = false;//error 阶段，禁止发送指令
				FDEBUG("HWERROR: [{$}] -> STATUS_ERROR", m_DoseUnit.m_GenState->Get());
				if (m_DoseUnit.m_GenState->Update(nsGEN::AttrKey::GENERATOR_STATUS_ERROR))
					FireNotify(AttrKey::GENSTATE, m_DoseUnit.m_GenState->JSGet());
			}
		}
		else
		{
			if (99 == nValue)
			{
				int level = 1;
				char ErrorCode[100]{ "" };
				m_MSGUnit->DelWarnMessage(ErrorCode, level, "");
			}
			else
			{
				int level = 1;
				char ErrorCode[100]{ "" };
				m_MSGUnit->DelErrorMessage(ErrorCode, level, "");

				m_sendEnable = true;
				FDEBUG("HWERROR: [{$}] -> STATUS_STANDBY", m_DoseUnit.m_GenState->Get());
				if (m_DoseUnit.m_GenState->Update(nsGEN::AttrKey::GENERATOR_STATUS_STANDBY))
					FireNotify(AttrKey::GENSTATE, m_DoseUnit.m_GenState->JSGet());
			}
		}
	};
	auto HWAR = [this](const char* value, int length)
	{
		WaitforSELF(SpecialCMDAR, 2);
		assert(value);
		int nValue = atoi(value);
		if (nValue != 0)
		{
			Reset();
		}
	};
	auto HWHE = [this](const char* value, int length) -> void
	{
		WaitforSELF(SpecialCMDHU, 2);
		assert(value);
		FDEBUG("Recv HE={$}", value);
		if (m_DoseUnit.m_HE->Update(atoi(value)))
			FireNotify(AttrKey::TUBEHEAT, value);
	};
	auto HWIT = [this](const char* value, int length) -> void
	{
		assert(value);
		FDEBUG("Recv IT={$}", value);
		if (m_DoseUnit.m_KV->Update(atoi(value)))
			FireNotify(AttrKey::DENHEAT, value);
	};
	auto HWSA = [this](const char* value, int length) -> void
	{
		WaitforSELF(SpecialCMDSA,2);
	};
	auto HWSX = [this](const char* value, int length) -> void
	{
		WaitforSELF(SpecialCMDSX, 2);
	};
	auto HWDS = [this](const char* value, int length) -> void
	{
		WaitforSELF(SpecialCMDDS, 2);
	};
	auto HWST = [this](const char* value, int length) -> void
	{
		FDEBUG("HWST:[{$}]", value);
		WaitforSELF(SpecialCMDST, 2);
		assert(value);
		switch (atoi(value))
		{
			case 1: //1. - Initialization phase
			{
				FDEBUG("HWST:Initialization Phase");
				if (m_DoseUnit.m_GenState->Get() < nsGEN::AttrKey::GENERATOR_STATUS_INIT)
				{
					FDEBUG("HWST:GENSTATE {$} -> STATUS_INIT", m_DoseUnit.m_GenState->JSGet());
					m_DoseUnit.m_GenState->Update(nsGEN::AttrKey::GENERATOR_STATUS_INIT);
					FireNotify(AttrKey::GENSTATE, m_DoseUnit.m_GenState->JSGet());
				}
			}
			break;
			case 2: //2. - Standby
			{
				FDEBUG("HWST:Standby");
				if (m_DoseUnit.m_GenState->Get() != nsGEN::AttrKey::GENERATOR_STATUS_STANDBY)
				{
					FDEBUG("HWST:GENSTATE {$} -> STATUS_STANDBY", m_DoseUnit.m_GenState->JSGet());
					m_DoseUnit.m_GenState->Update(nsGEN::AttrKey::GENERATOR_STATUS_STANDBY);
					FireNotify(AttrKey::GENSTATE, m_DoseUnit.m_GenState->JSGet());
				}
			}
			break;
			case 3: //3. - Preparation
			{
				FDEBUG("HWST:Preparation");
				if (m_DoseUnit.m_GenSynState->Get() == nsGEN::AttrKey::GENERATOR_RAD_OFF)
				{
					FDEBUG("get Gen Status_3:RAD_OFF(PR0) -> RAD_PREPARE(PR1)");
					if (m_DoseUnit.m_GenSynState->Update(nsGEN::AttrKey::GENERATOR_RAD_PREPARE))
						FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
				}
			}
			break;
			case 4: //4. - Exposure
			{
				FDEBUG("HWST:Exposure");
				//更新发生器状态并上报，否则会影响工作流 FrameEnable -> FrameReady 的转变
				FDEBUG("HWST:GENSTATE {$} -> STATUS_EXP", m_DoseUnit.m_GenState->JSGet());
				m_DoseUnit.m_GenState->Update(nsGEN::AttrKey::GENERATOR_STATUS_EXP);
				FireNotify(AttrKey::GENSTATE, m_DoseUnit.m_GenState->JSGet());

				if (m_DoseUnit.m_GenSynState->Get() == nsGEN::AttrKey::GENERATOR_RAD_PREPARE)
				{
					FDEBUG("get Gen Status_4:PREPARE(PR1) -> RAD_READY(PR2)");
					if (m_DoseUnit.m_GenSynState->Update(nsGEN::AttrKey::GENERATOR_RAD_READY))
						FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
				}
			}
			break;
			case 5: //5.- Fluoro
			{
				FDEBUG("HWST:Fluoro");
			}
			break;
			case 6: //6. - Filament Current Calibration
			{
				FDEBUG("HWST:Filament Current Calibration");
			}
			break;
			case 7: //7. - Unrecoverable Error
			{
				FDEBUG("HWST:Unrecoverable Error");
				FDEBUG("get Gen Status_7:GENSTATE {$} -> STATUS_ERROR", m_DoseUnit.m_GenState->JSGet());
				if(m_DoseUnit.m_GenState->Update(nsGEN::AttrKey::GENERATOR_STATUS_ERROR))
					FireNotify(AttrKey::GENSTATE, m_DoseUnit.m_GenState->JSGet());
			}
			break;
			case 8: //8. - Configuration
			{
				FDEBUG("HWST:Configuration");
			}
			break;
			case 9: //9. - AutoCalibration
			{
				FDEBUG("HWST:AutoCalibration");
			}
			break;
			case 10: //10. - Parameters Calibration
			{
				FDEBUG("HWST:Parameters Calibration");
			}
			break;
			case 11: //11. - Recoverable Error
			{
				FDEBUG("HWST:Recoverable Error");
				FDEBUG("get Gen Status_11:GENSTATE {$} -> STATUS_ERROR", m_DoseUnit.m_GenState->JSGet());
				if(m_DoseUnit.m_GenState->Update(nsGEN::AttrKey::GENERATOR_STATUS_ERROR))
					FireNotify(AttrKey::GENSTATE, m_DoseUnit.m_GenState->JSGet());
			}
			break;
			default:
				FDEBUG("get Gen Status:[{$}] unknown", atoi(value));
				break;
		}
	};
	auto HWAK = [this](const char* value, int length) -> void
	{
		WaitforACK(); 
	};
	auto HWZCP = [this](const char* value, int length) -> void
	{
		WaitforCP();
	};
	auto HWCP = [this](const char* value, int length) -> void
	{
		WaitforCP();
	};
//	有部分前缀是包含关系, 长的包含短的, 例如 KVS 包含了 KV.
//	因此长的在前面, 短的在后面
//	!!! Device 是个短寿命对象, 而 arFrame 是静态变量 !!!
//	!!! 因此, 在添加到 arFrame 之前, 务必先清零 !!!
	arFrame.clear ();

	arFrame.push_back (tFrameMapping ("AK",  2, HWAK));
	arFrame.push_back (tFrameMapping ("ZCP", 3, HWZCP));
	arFrame.push_back (tFrameMapping ("CP",  2, HWCP));
	arFrame.push_back (tFrameMapping ("KV+", 3, HWNotProcess));
	arFrame.push_back (tFrameMapping ("KV-", 3, HWNotProcess));
	arFrame.push_back (tFrameMapping ("MA+", 3, HWNotProcess));
	arFrame.push_back (tFrameMapping ("MA-", 3, HWNotProcess));
	arFrame.push_back (tFrameMapping ("MS+", 3, HWNotProcess));
	arFrame.push_back (tFrameMapping ("MS-", 3, HWNotProcess));
	arFrame.push_back (tFrameMapping ("MX+", 3, HWNotProcess));
	arFrame.push_back (tFrameMapping ("MX-", 3, HWNotProcess));
	arFrame.push_back (tFrameMapping ("KVS", 3, HWKV));
	arFrame.push_back (tFrameMapping ("MXS", 3, HWMAS));
	arFrame.push_back (tFrameMapping ("MAS", 3, HWMA));
	arFrame.push_back (tFrameMapping ("MSS", 3, HWMS));
	arFrame.push_back (tFrameMapping ("KV",  2, HWKV));
	arFrame.push_back (tFrameMapping ("MX",  2, HWMAS));
	arFrame.push_back (tFrameMapping ("MA",  2, HWMA));
	arFrame.push_back (tFrameMapping ("MS",  2, HWMS));
	arFrame.push_back (tFrameMapping ("TM",  2, HWTechmode));
	arFrame.push_back (tFrameMapping ("FO",  2, HWFocus));
	arFrame.push_back (tFrameMapping ("FI",  2, HWAECField));
	arFrame.push_back (tFrameMapping ("FS",  2, HWAECFilm));
	arFrame.push_back (tFrameMapping ("FN",  2, HWAECDensity));
	arFrame.push_back (tFrameMapping ("WS",  2, HWWS));
	arFrame.push_back (tFrameMapping ("PR",  2, HWPR));
	arFrame.push_back (tFrameMapping ("XR",  2, HWXR));
	arFrame.push_back (tFrameMapping ("XS",  2, HWXS));
	arFrame.push_back (tFrameMapping ("RX",  2, HWRX));
	arFrame.push_back (tFrameMapping ("PC",  2, HWDOSE));
	arFrame.push_back (tFrameMapping ("PD",  2, HWPD));
	arFrame.push_back (tFrameMapping ("ER",  2, HWERROR));
	arFrame.push_back (tFrameMapping ("AR",  2, HWAR));
	arFrame.push_back (tFrameMapping ("HE",  2, HWHE));
	arFrame.push_back (tFrameMapping ("IT",  2, HWIT));
	arFrame.push_back (tFrameMapping ("SA",  2, HWSA));
	arFrame.push_back (tFrameMapping ("SX",  2, HWSX));
	arFrame.push_back (tFrameMapping ("DS",  2, HWDS));
	arFrame.push_back (tFrameMapping ("ST",  2, HWST));
}

//-----------------------------------------------------------------------------
//		SDCDriver
//-----------------------------------------------------------------------------

nsGEN::SDCDriver::SDCDriver ()
{
	m_pAttribute.reset(new ResDataObject());
	m_pDescription.reset(new ResDataObject());
}

nsGEN::SDCDriver::~SDCDriver ()
{
}

auto nsGEN::SDCDriver::CreateDevice (int index) -> std::unique_ptr <IODevice>
{
	if (!m_SCF.isConnected())
		return nullptr;
	auto dev = std::unique_ptr <IODevice>(new IODevice(new SDCDevice(EventCenter, m_SCF,m_ConfigFileName)));
	return dev;
}

void nsGEN::SDCDriver::FireNotify (int code, std::string key, std::string content)
{
	EventCenter->OnNotify (code, key, content);
}

Log4CPP::Logger* gLogger = nullptr;
void nsGEN::SDCDriver::Prepare ()
{
	string strLogPath = GetProcessDirectory() + R"(\OEMDrivers\Generator\Conf\Log4CPP.Config.GEN.xml)";
	Log4CPP::GlobalContext::Map::Set(ECOM::Utility::Hash("LogFileName"), "GEN.SDC");
	auto rc = Log4CPP::LogManager::LoadConfigFile(strLogPath.c_str());
	gLogger = Log4CPP::LogManager::GetLogger("GEN.SDC");

	m_SCFDllName = GetConnectDLL(m_ConfigFileName);
	super::Prepare ();
}

bool  nsGEN::SDCDriver::Connect ()
{
	ResDataObject Connection = GetConnectParam(m_ConfigFileName);
	FINFO("connections:{$} \n", Connection.encode());
	auto erCode = m_SCF.Connect(Connection.encode(), &nsGEN::SDCDriver::callbackPackageProcess, SCF_PACKET_TRANSFER, 3000);
	if (erCode != SCF_ERR::SCF_SUCCEED)
		return false; // erCode;

	auto rc = super::Connect();
	if (!rc)
		return false;
	//return (erCode == SCF_ERR::SCF_SUCCEED);
	return true; // SCF_ERR::SCF_SUCCEED;
}


void nsGEN::SDCDriver::Disconnect()
{
	super::Disconnect();
	m_SCF.Disconnect();
}

bool nsGEN::SDCDriver::isConnected() const
{
	return super::isConnected();
}

std::string nsGEN::SDCDriver::DriverProbe ()
{
	ResDataObject r_config, HardwareInfo;
	if (r_config.loadFile (m_ConfigFileName.c_str ()))
	{
		HardwareInfo.add ("MajorID", r_config ["CONFIGURATION"] ["MajorID"]);
		HardwareInfo.add ("MinorID", r_config ["CONFIGURATION"] ["MinorID"]);
		HardwareInfo.add ("VendorID", r_config ["CONFIGURATION"] ["VendorID"]);
		HardwareInfo.add ("ProductID", r_config ["CONFIGURATION"] ["ProductID"]);
		HardwareInfo.add ("SerialID", r_config ["CONFIGURATION"] ["SerialID"]);
	}
	else
	{
		HardwareInfo.add ("MajorID", "Generator");
		HardwareInfo.add ("MinorID", "Dr");
		HardwareInfo.add ("VendorID", "SDC");
		HardwareInfo.add ("ProductID", "HF");
		HardwareInfo.add ("SerialID", "Drv");
	}
	string ret = HardwareInfo.encode ();
	return ret;
}

bool nsGEN::SDCDriver::GetDeviceConfig(std::string& Cfg)
{
	Cfg = m_DeviceConfigSend.encode();

	printf("GetDeviceConfig over , %s",Cfg.c_str());

	return true;
}

bool nsGEN::SDCDriver::SetDeviceConfig(std::string Cfg)
{
	FDEBUG("--Func-- SetDeviceConfig {$}\n", Cfg.c_str());

	printf("\n--Func-- SetDeviceConfig %s\n", Cfg.c_str());

	ResDataObject DeviceConfig;
	DeviceConfig.decode(Cfg.c_str());

	ResDataObject DescriptionTempEx;
	DescriptionTempEx = DeviceConfig["DeviceConfig"]["Attribute"];
	FDEBUG("Attribute:{$}", DescriptionTempEx.encode());

	bool bSaveFile = false; //true:重新保存配置文件
	string strAccess = "";
	for (int i = 0; i < DescriptionTempEx.size(); i++)
	{
		string strKey = DescriptionTempEx.GetKey(i);
		FDEBUG("{$}", strKey.c_str());
		printf("%s\n", strKey.c_str());
		try
		{
			if (m_pAttribute->GetFirstOf(strKey.c_str()) >= 0)
			{
				strAccess = (string)(*m_pDescription)[strKey.c_str()]["Access"];
				if ("RW" == strAccess)
				{
					//修改对应配置，在其他单元的配置项要同时调用其修改函数修改真实值
					//1. 修改内存中的值，用于给上层发消息
					(*m_pAttribute)[strKey.c_str()] = DescriptionTempEx[i];
					//2. 拿到Innerkey
					int nConfigInfoCount = (int)m_Configurations["ConfigToolInfo"].GetKeyCount("AttributeInfo");
					FDEBUG("nConfigInfoCount {$}", nConfigInfoCount);
					string strTemp = ""; //存储AttributeKey
					for (int nInfoIndex = 0; nInfoIndex < nConfigInfoCount; nInfoIndex++)
					{
						strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeKey"];
						if (strTemp == strKey)
						{
							strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["InnerKey"];
							break;
						}
					}
					//3. 修改配置文件中的值
					if (SetDeviceConfigValue(m_Configurations, strTemp.c_str(), 1, DescriptionTempEx[i]))
					{
						FDEBUG("SetDeviceConfigValue over");
						bSaveFile = true;
					}
				}
				else
				{
					FDEBUG("{$} is not a RW configuration item", strKey.c_str());
				}
			}
			else
			{
				FDEBUG("without this attribute {$}", strKey.c_str());
			}
		}
		catch (ResDataObjectExption& e)
		{
			printf("\nSetDriverConfig crashed: %s\n", e.what());
			FERROR("SetDriverConfig crashed: {$}", e.what());
			return false;
		}
	}

	if (bSaveFile)
	{
		//3. 重新保存配置文件
		SaveConfigFile(true);
	}
	return true;
}

bool nsGEN::SDCDriver::SaveConfigFile(bool bSendNotify)
{
	m_ConfigAll["CONFIGURATION"] = m_Configurations;

	bool bRt = m_ConfigAll.SaveFile(m_ConfigFileName.c_str());
	FDEBUG("SaveConfigFile over {$}", bRt);
	return true;
}

bool nsGEN::SDCDriver::GetDeviceConfigValue(ResDataObject config, const char* pInnerKey, int nPathID, string& strValue)
{
	strValue = "";
	string strTemp = pInnerKey;
	if (1 == nPathID) //从DriverConfig路径下每个DPC自己的配置文件读取
	{
		int pos = 0;
		ResDataObject resTemp = config;
		while ((pos = strTemp.find_first_of(',')) != string::npos)
		{
			string Key = strTemp.substr(0, pos);
			string TempValue = resTemp[Key.c_str()].encode();

		//	printf("-TempValue=== %s", TempValue.c_str());

			resTemp.clear();
			resTemp.decode(TempValue.c_str());
			strTemp = strTemp.substr(pos + 1, strTemp.length() - pos - 1);

			//printf("-************--%s", strTemp.c_str());

		}
		if (strTemp != "")
		{
			strValue = (string)resTemp[strTemp.c_str()];
		}
		else
		{
			strValue = (string)resTemp;
		}
	}

	//printf("------------%s", strValue.c_str());

	return true;
}

bool nsGEN::SDCDriver::SetDeviceConfigValue(ResDataObject& config, const char* pInnerKey, int nPathID, const char* szValue)
{
	string strTemp = pInnerKey;
	FDEBUG("Begin to change {$} item value to {$}", pInnerKey, szValue);
	printf("bBegin to change {%s} item value to {%s}", pInnerKey, szValue);
	if (1 == nPathID) //从DriverConfig路径下每个DPC自己的配置文件读取
	{
		try {
			int pos = 0;
			ResDataObject* resTemp = &config;
			while ((pos = strTemp.find_first_of(',')) != string::npos)
			{
				string Key = strTemp.substr(0, pos);
				resTemp = &(*resTemp)[Key.c_str()];
				strTemp = strTemp.substr(pos + 1, strTemp.length() - pos - 1);
			}
			if (strTemp != "")
			{
				//if ((strTemp.compare("WSTable") == 0) ||
				//	(strTemp.compare("WSWall") == 0) ||
				//	(strTemp.compare("WSFree") == 0) ||
				//	(strTemp.compare("WSTomo") == 0) ||
				//	(strTemp.compare("WSConventional") == 0)
				//	)
				//{
				//	int sum = (*szValue) + 1;
				//	(*resTemp)[strTemp.c_str()] = (char*)(&sum);

				//}
				//else
				//	(*resTemp)[strTemp.c_str()] = szValue;

				(*resTemp)[strTemp.c_str()] = szValue;
			}
			else
			{
				*resTemp = szValue;
			}
		}
		catch (ResDataObjectExption& e)
		{
			FERROR("SetDriverConfigvalue crashed: {$}", e.what());
			return false;
		}
	}
	return true;
}

std::string nsGEN::SDCDriver::GetResource()
{
	ResDataObject r_config, temp;
	if (!temp.loadFile(m_ConfigFileName.c_str()))
	{
		return "";
	}

	m_ConfigAll = temp;

	r_config = temp["CONFIGURATION"];
	m_Configurations = r_config;

	ResDataObject DescriptionTemp;
	ResDataObject DescriptionSend;
	ResDataObject m_DescriptionSend;
	ResDataObject ListTemp;
	string strTemp = "";			//用于读取字符串配置信息
	string strIndex = "";			//用于读取配置信息中的List项
	int nTemp = -1;					//用于读取整型配置信息
	char sstream[10] = { 0 };		//用于转换值
	string strValue = "";			//用于存储配置的值
	string strType = "";			//用于存储配置的类型 int/float/string...

	/***
	* 1. 通过循环，将所有配置项写到pDeviceConfig
	* 2. 记录配置项的内部key以及配置类型，类型对应了不同配置文件路径，用于读写真实值
	***/
	try
	{
		//便利ConfigToolInfo 中 所有的AttributeInfo 属性段
		int nConfigInfoCount = (int)m_Configurations["ConfigToolInfo"].GetKeyCount("AttributeInfo");
		m_pAttribute->clear();
		m_pDescription->clear();
		for (int nInfoIndex = 0; nInfoIndex < nConfigInfoCount; nInfoIndex++)
		{
			DescriptionTemp.clear();
			DescriptionSend.clear();
			ListTemp.clear();

			//AttributeType
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["Type"];
			DescriptionTemp.add(ConfKey::CcosType, strTemp.c_str());//CcosGeneratorAttribute
			DescriptionSend.add(ConfKey::CcosType, strTemp.c_str());//CcosGeneratorAttribute

			strType = strTemp; //记录配置项的类型

			//AttributeKey
			//1. 根据AttributeType，内部key和配置路径，拿到当前的真实值
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["InnerKey"];
			nTemp = (int)m_Configurations["ConfigToolInfo"][nInfoIndex]["PathID"];
			GetDeviceConfigValue(r_config, strTemp.c_str(), nTemp, strValue);	//得到strValue的值

			//printf("********************************innerkey=%s --strValue = %s\n", strTemp.c_str(), strValue.c_str());

			//2. 赋值
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeKey"];


			if ("int" == strType)
			{
				(*m_pAttribute).add(strTemp.c_str(), atoi(strValue.c_str()));
			}
			else if ("float" == strType)
			{
				(*m_pAttribute).add(strTemp.c_str(), atoi(strValue.c_str()));
			}
			else //其它先按string类型处理
			{
				(*m_pAttribute).add(strTemp.c_str(), strValue.c_str());
			}

			//printf("********************************outkey =%s --strValue = %s\n", strTemp.c_str(), strValue.c_str());

			//AttributeAccess
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["Access"];
			DescriptionTemp.add(ConfKey::CcosAccess, strTemp.c_str());
			DescriptionSend.add(ConfKey::CcosAccess, strTemp.c_str());


			/*
			//AttributeRangeMin
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["RangeMin"];
			if (strTemp != "") //不需要的配置项为空
			{
				DescriptionTemp.add(ConfKey::CcosRangeMin, strTemp.c_str());
			}

			//AttributeRangeMax
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["RangeMax"];
			if (strTemp != "") //不需要的配置项为空
			{
				DescriptionTemp.add(ConfKey::CcosRangeMax, strTemp.c_str());
			}
			*/

			//AttributeList
			nTemp = m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["ListNum"];
			if (nTemp > 0) //ListNum不大于0时说明不需要list配置
			{
				for (int nListIndex = 0; nListIndex < nTemp; nListIndex++)
				{
					strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["ListInfo"][nListIndex];
					auto temKey = std::to_string(nListIndex);
					ListTemp.add(temKey.c_str(), strTemp.c_str());
				}
				DescriptionTemp.add(ConfKey::CcosList, ListTemp);
				DescriptionSend.add(ConfKey::CcosList, ListTemp.encode());
			}

			//AttributeRequired
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["Required"];
			DescriptionTemp.add(ConfKey::CcosRequired, strTemp.c_str());
			DescriptionSend.add(ConfKey::CcosRequired, strTemp.c_str());

			//AttributeDefaultValue
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["DefaultValue"];
			if (strTemp != "") //不需要的配置项为空
			{
				DescriptionTemp.add(ConfKey::CcosDefaultValue, strTemp.c_str());
				DescriptionSend.add(ConfKey::CcosDefaultValue, strTemp.c_str());
			}

			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeKey"];
			(*m_pDescription).add(strTemp.c_str(), DescriptionTemp);
			m_DescriptionSend.add(strTemp.c_str(), DescriptionSend.encode());
		}
	}
	catch (ResDataObjectExption& e)
	{
		FERROR("Get config error: {$}", e.what());
		return "";
	}

	ResDataObject resDeviceResource;
	resDeviceResource.add(ConfKey::CcosGeneratorAttribute, (*m_pAttribute));
	resDeviceResource.add(ConfKey::CcosGeneratorDescription, (*m_pDescription));

	ResDataObject DescriptionTempEx;
	DescriptionTempEx.add(ConfKey::CcosGeneratorConfig, resDeviceResource);
	m_DeviceConfig.clear();
	m_DeviceConfig = DescriptionTempEx;

	FDEBUG("local ************* get resource over {$}", DescriptionTempEx.encode());
	printf("local ************* get resource over %s \n", DescriptionTempEx.encode());


	resDeviceResource.clear();

	resDeviceResource.add(ConfKey::CcosGeneratorAttribute, (*m_pAttribute));
	resDeviceResource.add(ConfKey::CcosGeneratorDescription, m_DescriptionSend);
	DescriptionTempEx.clear();
	DescriptionTempEx.add(ConfKey::CcosGeneratorConfig, resDeviceResource);

	m_DeviceConfigSend.clear();

	m_DeviceConfigSend = DescriptionTempEx;

	string res = m_DeviceConfigSend.encode();

	//printf("%s", res.c_str());

	FDEBUG("get resource over {$}", DescriptionTempEx.encode());
	printf("************* get resource over %s \n", DescriptionTempEx.encode());

	return res;
}

std::string nsGEN::SDCDriver::DeviceProbe ()
{
	ResDataObject r_config, HardwareInfo;
	if (r_config.loadFile (m_ConfigFileName.c_str ()))
	{
		HardwareInfo.add ("MajorID", r_config ["CONFIGURATION"] ["MajorID"]);
		HardwareInfo.add ("MinorID", r_config ["CONFIGURATION"] ["MinorID"]);
		HardwareInfo.add ("VendorID", r_config ["CONFIGURATION"] ["VendorID"]);
		HardwareInfo.add ("ProductID", r_config ["CONFIGURATION"] ["ProductID"]);
		HardwareInfo.add ("SerialID", r_config ["CONFIGURATION"] ["SerialID"]);
	}
	else
	{
		HardwareInfo.add ("MajorID", "Generator");
		HardwareInfo.add ("MinorID", "Dr");
		HardwareInfo.add ("VendorID", "SDC");
		HardwareInfo.add ("ProductID", "HF");
		HardwareInfo.add ("SerialID", "1234");
	}
	string ret = HardwareInfo.encode ();
	return ret;
}

void nsGEN::SDCDriver::Dequeue (const char * Packet, DWORD Length)
{
	FDEBUG("Dequeue:Get MSG");
	DecodeFrame (Packet, Length);
}

PACKET_RET nsGEN::SDCDriver::callbackPackageProcess (const char * RecData, DWORD nLength, DWORD& PacketLength)
{
	//判断是否是整包
	/*
	这个是回调函数，我收到的数据会需要这个回调函数帮我判断是否是整个的包;
	如果有整个的包，返回值为true，在PacketLength处返回给我整个包的长度，我再截取后放入缓存供上层使用;
	如果缓存中的数据没有整个的数据包，那么返回false
	*/
	if (nLength < 1)
	{
		printf ("nLength < 1, nLength==%d \n", nLength);
		return PACKET_USELESS;
	}
	for (DWORD i = 0; i < nLength - 1; i++)
	{
		if (RecData [i] == 0x0d && RecData [i + 1] == 0x0a)
		{
			PacketLength = i + 2;
			char strtemp [100] = { 0 };
			::memcpy(strtemp, RecData, i);
			strtemp [PacketLength + 1] = 0;
			//printf ("==IN ==:%s\n", strtemp);
			FDEBUG("==IN==:[{$}]", strtemp);
			//printf("==IN(Hex) ==:");
			//for (int j = 0; j < i; j++)
			//{
			//	printf("%02X ", RecData[j]);
			//}
			//printf("\n");
			return PACKET_ISPACKET;
		}
		else if (RecData [i] == 0x03)
		{
			printf ("(Hex)0x03 ,len=%d \n", i);
			PacketLength = i + 1;
			return PACKET_USELESS;
		}
	}

	return PACKET_NOPACKET;
}

//-----------------------------------------------------------------------------
//		DecodeFrame
//-----------------------------------------------------------------------------
static bool DecodeFrame (const char* strFrame, int length)
{
	auto pr = [ strFrame, length ] (const tFrameMapping& Item)
	{
		for (int i = 0; i < Item.NbOfCharOfHead; i++)
		{
			if (strFrame [i] != Item.strHead [i])
			{
				return false;
			}
		}
		return true;
	};
	auto found = std::find_if (arFrame.begin (), arFrame.end (), pr);
	if (found == arFrame.end ())
	{
		return false;
	}
	const auto& Item = *found;
	auto pc = strFrame;
	pc += Item.NbOfCharOfHead;
	Item.fun (pc, length - Item.NbOfCharOfHead);
	return true;
}


//-----------------------------------------------------------------------------
//		GetIODriver & CreateIODriver
//-----------------------------------------------------------------------------

static nsGEN::SDCDriver  gIODriver;

extern "C"  CCOS::Dev::IODriver * __cdecl GetIODriver ()		// 返回静态对象的引用, 调用者不能删除 !
{
	return &gIODriver;
}

extern "C"  CCOS::Dev::IODriver * __cdecl CreateIODriver ()  // 返回新对象, 调用者必须自行删除此对象 !
{
	return new nsGEN::SDCDriver ();
}