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

#include "stdafx.h"

#include <assert.h>

#include <functional>
using namespace std::placeholders;

//#include "ResDataObject.h"

#include "CCOS.Dev.Generator.Salmon.h"
#include "logger.temp.h"
#include "Helper.JSON.hpp"
//#include <SimpleLog.hpp>

//extern SimpleLog* g_SLogger;
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;
const char* EXPOSUREEVENT = "Global\\ExpoureEvent";


#ifdef WIN_64BIT
#ifdef _DEBUG
#pragma comment (lib,"lib_64\\libaxnclientif.lib")
#else
#pragma comment (lib,"lib_64\\libaxnclientif.lib")
#endif
#else
#ifdef _DEBUG
#pragma comment (lib,"lib_32\\libaxnclientif.lib")
#else
#pragma comment (lib,"lib_32\\libaxnclientif.lib")
#endif
#endif


//-----------------------------------------------------------------------------
//		SMZDevice
//-----------------------------------------------------------------------------

nsGEN::SMZDevice::SMZDevice (std::shared_ptr <IOEventCenter> center,string ConfigPath)
	: super (center)
	,	m_bExited(false)
	, m_bReGetTurnOn(false)
	, m_nLastErrorCount(0)
	, m_nGenSTMode(-1)
	, m_bGenService(false)
	, m_bExposureStatus(false)
	, m_nDAPUnit(0)
	, m_bSelectORG(false)
	, m_nSelectOGPWaitingTime(50)
	, m_nAPRCommandSynFlag(0)
	, m_nTUICOMMANDSENDWAITTIME(200)
	, m_bInExam(false)
	, m_nFDCLostConnectNumber(0)
	, m_nLostConnectNumber(0)
	, m_nSettingWS(0)
	, m_bCalibMode(false)
	, m_bSetAPR(false)
	, m_bGetIGENANZ(false)
	, m_bSetEnable(false)
	, m_nExposureIndex(0)
	, m_nBackup_Restre_Identifier(17)
	, m_tmDetectorStart(0)
	, m_nXwindowTime(100)
	, m_hEventExposure(NULL)
	, m_bAlreadyExposure(false)
	, m_nIdfrstatus(0)
{
	assert (EventCenter);
	//CreateLogger("Salmon");
	m_strConfigPath = ConfigPath;

	m_DoseUnit.m_KV.reset(new KVMould(0.0, 40.0, 150.0, 1.0));
	m_DoseUnit.m_MA.reset(new MAMould(0.0, 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.0, 1000.0, 0.01));
	m_DoseUnit.m_Techmode.reset(new TECHMODEMould(1, 0, 2, 1));
	m_DoseUnit.m_WS.reset(new WORKSTATIONMould(1, 0, 5, 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, 0.0, 150.0, 1.0));
	m_DoseUnit.m_PostMA.reset(new POSTMAMould(0.0, 0.0, 1000.0, 0.1));
	m_DoseUnit.m_PostMS.reset(new POSTMSMould(0.0, 0.0, 10000.0, 0.01));
	m_DoseUnit.m_PostMAS.reset(new POSTMASMould(0.0, 0.0, 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(0, 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, 99999999, 1));

	m_DoseUnit.m_BatteryChargeState.reset(new BATTERYCHARGSTATEMould(-1,0,5,1));
	m_DoseUnit.m_ReferenceAirKerma.reset(new REFERENCEAIRKERMAMould(0.0,0.0,999999.0,0.01));
	m_DoseUnit.m_KVList.reset(new KVLISTMould(""));
	m_DoseUnit.m_mAsList.reset(new MASLISTMould(""));

	m_UIClientUnit.m_ERA.reset(new DevUIClient::ERAMould(-1,0,9999999,1));
	m_UIClientUnit.m_RSI.reset(new DevUIClient::RSIMould(-1, 0, 30000, 1));
	m_UIClientUnit.m_RMV.reset(new DevUIClient::RMVMould(-1, 0, 10, 1));
	m_UIClientUnit.m_CFM.reset(new DevUIClient::CFMMould(-1, 0, 10, 1));
	m_UIClientUnit.m_BRM.reset(new DevUIClient::BRMMould(-1, 0, 10, 1));
	m_UIClientUnit.m_PLS.reset(new DevUIClient::PLSMould(-1, 0, 2, 1));
	m_UIClientUnit.m_UDO.reset(new DevUIClient::UDOMould(-1, 0, 2, 1));
	m_UIClientUnit.m_SHS.reset(new DevUIClient::SHSMould(-1, 0, 2, 1));
	m_UIClientUnit.m_STM.reset(new DevUIClient::STMMould(-1, 0, 2, 1));
	m_UIClientUnit.m_SDF.reset(new DevUIClient::SDFMould(-1, 0, 10, 1));
	m_UIClientUnit.m_SOP.reset(new DevUIClient::SOPMould(""));
	m_UIClientUnit.m_SCREENLOCK.reset(new DevUIClient::SCREENLOCKMould(-1, 0, 5, 1));
	m_UIClientUnit.m_SDN.reset(new DevUIClient::SDNMould(""));
	m_UIClientUnit.m_AutoConfig.reset(new DevUIClient::AUTOCONFIGMould(-1, 0, 5, 1));
	m_UIClientUnit.m_WS2FD.reset(new DevUIClient::WS2FDMould(-1, 0, 10, 1));
	m_UIClientUnit.m_AuditMessage.reset(new DevUIClient::AUDITMSGMould(""));

	m_CollimatorUnit.m_XSize.reset(new DevCollimator::XSIZEMould(0, 0, 4300, 1));
	m_CollimatorUnit.m_YSize.reset(new DevCollimator::YSIZEMould(0, 0, 4300, 1));
	m_CollimatorUnit.m_Filter.reset(new DevCollimator::FILTERMould(0, 0, 10, 1));
	m_CollimatorUnit.m_SID.reset(new DevCollimator::SIDMould(0, 0, 18000, 1));
	m_CollimatorUnit.m_Angle.reset(new DevCollimator::ANGLEMould(0, 0, 360.0, 0.1));
	m_CollimatorUnit.m_Mode.reset(new DevCollimator::MODEMould(0, 0, 6, 1));
	m_CollimatorUnit.m_Light.reset(new DevCollimator::LIGHTMould(0, 0, 1, 1));
	

	m_MSGUnit.reset(new nsDetail::MSGUnit(center, GeneratorUnitType));
	m_DAP.reset(new DevDAP::DOSEMould(0, 0, 999999.0, 0.01));
	m_FPDGUnit.reset(new DevFPDClient::CFPDCommunicateWithOtherDevice());
	m_FPDGUnit->SetEventCenter(center);

	m_pAxnClient = NULL;
	m_pFDCAxnClient = NULL;
	m_hXCUDataEvent = NULL;
	m_hFDCDataEvent = NULL;

	m_hGenPostEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
	m_hGenPostDAPEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
	m_hFDCDataEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hXCUDataEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hGenSelectOGPEvent = CreateEvent(NULL, false, false, NULL);
	m_hDUMMYEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hWaitForDapEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
	m_hEventExposure = CreateEvent(NULL, FALSE, FALSE, EXPOSUREEVENT);

	m_hXCUDataThread = NULL;
	m_hXCUDataRevThread = NULL;
	m_hFDCDataDealThread = NULL;
	m_hFDCDataRevThread = NULL;
	m_hOGPWorkThread = NULL;
	m_hWaitForDummyThread = NULL;

	m_pBuffer = new axn_byte[MAX_LEN_ACS_OBJ];
	m_pFDCBuffer = new axn_byte[MAX_LEN_ACS_OBJ];

	InitializeCriticalSection(&m_csXCUData);
	InitializeCriticalSection(&m_csFDCData);
	InitializeCriticalSection(&m_csStatus);

	g_KV_List = { 400, 405, 410, 415, 420, 430, 440, 450, 460, 470, 480, 490, 500, 510, 520, 535, 550, 560, 570, 585, 600, 615, 630, 645, 660, 680, 700, 715, 730, 750, 770, 790, 810, 830, 850, 875, 900, 930, 960, 1000, 1020, 1050, 1090, 1130, 1170, 1210, 1250, 1290, 1330, 1370, 1410, 1450, 1500 };//<!--KV * 10--> 

	g_MAS_List = { 500, 560, 630, 710, 800, 900, 1000, 1100, 1250, 1400, 1600, 1800, 2000, 2200, 2500, 2800, 3200, 3600, 4000, 4500, 5000, 5600, 6300, 7100, 8000, 9000, 10000, 11000, 12500, 14000, 16000, 18000, 20000, 22000, 25000, 28000, 32000,
	36000, 40000, 45000, 50000, 56000, 63000, 71000, 80000, 90000, 100000, 110000, 125000, 140000, 160000, 180000, 200000, 220000, 250000, 280000, 320000, 360000, 400000, 450000, 500000, 560000, 630000, 710000, 800000, 900000, 1000000 }; // <MAS * 1000-->

	g_MS_List = { 20000, 22000, 25000, 28000, 32000, 36000, 40000, 45000, 50000, 56000, 63000, 71000, 80000, 90000, 100000, 110000, 125000, 140000, 160000, 180000, 200000, 220000, 250000, 280000, 320000, 360000, 400000, 450000,
	500000, 560000, 630000, 710000, 800000, 900000, 1000000, 1100000, 1250000, 1400000, 1600000, 1800000, 2000000, 2200000, 2500000, 2800000, 3200000, 3600000, 4000000, 4500000, 5000000 };//<!--ms * 1000-->
	g_AECDensity_List = { -20, -15, -10, -5, 0, 5, 10, 15, 20 };// <!--density * 10-->
	g_AECDOSE_List = { 89, 125, 179, 250, 357, 500, 714 }; //<!--AECDose * 100-->
	g_AECFILM_List = { 200, 400, 800 }; //<!--AECFILM-->
	g_FILTER_List = { 0, 1, 2, 3 }; //FILTER * 10

	AprParamBackup.nWS = WS_TABLE;
	AprParamBackup.nFocus = FOCUS_LARGE;
	AprParamBackup.nTechmode = TECHMODE_NOAEC_3P;
	AprParamBackup.nAECField = FIELD_CENTER;
	AprParamBackup.nAECFilm = GEN_AECFILM_U;
	AprParamBackup.nAECDensity = 0;
	AprParamBackup.fKV = 70.0f;
	AprParamBackup.fMA = 10.0f;
	AprParamBackup.fMS = 100.0f;
	AprParamBackup.fMAS = 1.0f;
	m_bAutoHandSwitch = false;
	m_wHeaderLength = 2 * sizeof(ACS_WORD) + 4 * sizeof(ACS_BYTE);
	Register ();

	ResDataObject temp;
	temp.loadFile(m_strConfigPath.c_str());
	m_GenConfig = temp["CONFIGURATION"];
	TransJsonText(m_GenConfig);
}

nsGEN::SMZDevice::~SMZDevice ()
{
	m_bExited = true;
	if (m_hGenSelectOGPEvent != NULL)
	{
		CloseHandle(m_hGenSelectOGPEvent);
		m_hGenSelectOGPEvent = NULL;
	}

	if (m_hXCUDataEvent != NULL)
	{
		CloseHandle(m_hXCUDataEvent);
		m_hXCUDataEvent = NULL;
	}

	if (m_hFDCDataEvent != NULL)
	{
		CloseHandle(m_hFDCDataEvent);
		m_hFDCDataEvent = NULL;
	}

	if (m_hDUMMYEvent != NULL)
	{
		CloseHandle(m_hDUMMYEvent);
		m_hDUMMYEvent = NULL;
	}

	if (m_pFDCBuffer != NULL)
	{
		delete[] m_pFDCBuffer;
		m_pFDCBuffer = NULL;
	}

	if (m_pBuffer != NULL)
	{
		delete[] m_pBuffer;
		m_pBuffer = NULL;
	}

	m_hXCUDataThread = NULL;
	m_hFDCDataDealThread = NULL;
	m_hFDCDataRevThread = NULL;
	m_hOGPWorkThread = NULL;
	m_hWaitForDummyThread = NULL;
	m_hWaitForDapThread = NULL;
	//ReleaseLogger();
	CloseHandle(m_hGenPostEvent);
	CloseHandle(m_hGenPostDAPEvent);
	CloseHandle(m_hWaitForDapEvent);
}

std::string nsGEN::SMZDevice::GetGUID() const
{
	printf("\n===============GetGUID : %s ===================\n", GeneratorUnitType);
	return GeneratorUnitType;
}
void nsGEN::SMZDevice::Register()
{
	auto Disp = &Dispatch;

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

	superUIClient::Register(Disp);
	superCollimatorClient::Register(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);

	Disp->Get.Push("DAP", [this](std::string& out) { out = m_DAP->JSGet(); return RET_STATUS::RET_SUCCEED; });
	
	Disp->Get.Push("GetAPRms", m_FPDGUnit.get(), &DevFPDClient::CFPDCommunicateWithOtherDevice::JSGetAPRms);
	Disp->Get.Push("XrayStatus", m_FPDGUnit.get(), &DevFPDClient::CFPDCommunicateWithOtherDevice::JSXrayStatus);
	Disp->Action.Push("SetLTEthreshold", m_FPDGUnit.get(), &DevFPDClient::CFPDCommunicateWithOtherDevice::JSSetLTEthreshold);
	Disp->Action.Push("SetFPDCalibrationStatus", this, &nsGEN::SMZDevice::JSSetFPDCalibrationStatus);
	Disp->Action.Push("SetPanelSN", this, &nsGEN::SMZDevice::JSSetPanelSN);
	Disp->Action.Push("SendFPDError", this, &nsGEN::SMZDevice::JSSendFPDError);
	Disp->Action.Push("ClearFPDError", this, &nsGEN::SMZDevice::JSClearFPDError);
	Disp->Action.Push("SendFPDWarn", this, &nsGEN::SMZDevice::JSSendFPDWarn);
	Disp->Action.Push("FPDSTATUS", this, &nsGEN::SMZDevice::JSSendFPDStatus);
	Disp->Action.Push("FPDXWINDOWOPEN", this, &nsGEN::SMZDevice::JSFPDXWindowOpen);
}


bool nsGEN::SMZDevice::Prepare()
{
	SerialPortOpen();
	m_hEventExitExposureThread = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hExposureEventArray[0] = m_hEventExitExposureThread;
	m_hExposureEventArray[1] = m_hEventExposure;
	m_hExposureThread = CreateThread(0, 0, ExposureThread, this, 0, &m_ExposureThreadID);
	if (m_hExposureThread == NULL)
	{
		PRINTA_DEBUG("Start Exposure Thread Failed!\n");
	}
	else
	{
		PRINTA_DEBUG("Start Exposure Thread End\n");
	}
	return true;
}

DWORD WINAPI SMZDevice::ExposureThread(LPVOID pParam)
{
	SMZDevice* pCurMoniOpr = (SMZDevice*)pParam;

	BOOL bExit = false;
	DWORD dwResult;

	PRINTA_DEBUG("ExposureThread Start!!!!\n");

	DWORD curThreadPri = GetThreadPriority(GetCurrentThread());
	if (curThreadPri != THREAD_PRIORITY_TIME_CRITICAL)
	{
		if (!SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL))
		{
			PRINTA_DEBUG("Failed to enter timecritical priority.lasterror (%d)\n", GetLastError());
		}
		PRINTA_DEBUG("Set timecritical priority.ok\n");
	}

	while (!bExit)
	{
		dwResult = WaitForMultipleObjects(2, pCurMoniOpr->m_hExposureEventArray, FALSE, INFINITE);
		switch (dwResult)
		{
		case WAIT_OBJECT_0: // m_hEventExitExposureThread 
			bExit = true;
			PRINTA_DEBUG("Start to Exit Exposure Thread");
			break;
		case WAIT_OBJECT_0 + 1: // m_hEventExposure 
			PRINTA_DEBUG("Get Exposure Event");
			{
				pCurMoniOpr->DoExposure();
				ResetEvent(pCurMoniOpr->m_hEventExposure);
			}
			break;

		default:
			DWORD nErrorCode;
			nErrorCode = GetLastError();
			PRINTA_DEBUG("Exposure Thread unknown Exit Mercu event! error code: %d \n", nErrorCode);
			bExit = true;
			break;
		}

	}
	PRINTA_DEBUG("ExposureThread Exit!!!!");
	return 0;
}

/*********************************************************************************
函数名称：SerialPortOpen
功能描述：建立通讯

修改记录:
2015-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SerialPortOpen()
{
	//与AXIM节点建立通讯 及接收线程启动
	m_sCallbackData.clear();

	DWORD dwThreadId;
	if (NULL == m_hXCUDataThread)
		m_hXCUDataThread = CreateThread(NULL, 0, XCUDataThread, this, 0, &dwThreadId);
	if (m_hXCUDataThread == NULL)
	{
		PRINTA_DEBUG("Open XCUDataThread Failed\n");
		return false;
	}//ENDIF	

	if (ConnectXCS())
	{
		PRINTA_DEBUG("Init Siemens XCS(F3) generator: connected\n");
		printf("Init XCU(F3): connect success\n");
		//接收线程
		if (NULL == m_hXCUDataRevThread)
			m_hXCUDataRevThread = CreateThread(NULL, 0, ReveiveXCUData, this, 0, &dwThreadId);
		if (m_hXCUDataRevThread == NULL)
		{
			PRINTA_DEBUG("Open XCUDataThread Failed");
			return false;
		}//ENDIF

		if (NULL == m_hWaitForDummyThread)
			m_hWaitForDummyThread = CreateThread(NULL, 0, WaitForDummyThread, this, 0, &dwThreadId);
		if (m_hWaitForDummyThread == NULL)
		{
			PRINTA_DEBUG("Open WaitForDummyThread Failed\n");
			return false;
		}//ENDIF
	}
	else
	{
		printf("Init XCU(F3): connect failed");
		return false;
	}
	// end

	//与FDC节点建立通讯 及接收线程启动
	m_sFDCCallbackData.clear();
	if (NULL == m_hFDCDataDealThread)
		m_hFDCDataDealThread = CreateThread(NULL, 0, FDCDataThread, this, 0, &dwThreadId);
	if (m_hFDCDataDealThread == NULL)
	{
		PRINTA_DEBUG("Open XCUDataThread Failed");
		return false;
	}//ENDIF
	if (FDCConnectXCS())
	{
		PRINTA_DEBUG(  "Init FDC(F4): connected");
		printf("Init FDC(F4): connect success\n");
		if (NULL == m_hFDCDataRevThread)
			m_hFDCDataRevThread = CreateThread(NULL, 0, ReveiveFDCData, this, 0, &dwThreadId);
		if (m_hFDCDataRevThread == NULL)
		{
			PRINTA_DEBUG("Open XCUDataThread Failed\n");
			return false;
		}//ENDIF
	}
	else
	{
		printf("Init FDC(F4): connect failed\n");
		return false;
	}
	// 完成与AXIM FDC F4节点建立通讯连接

	Sleep(1000);
	printf("connect success\n");
	//Sleep(20000);
	return true;
}
/*********************************************************************************
函数名称：SerialPortClose
功能描述：关闭通讯

修改记录:
2015-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SerialPortClose()   //在哪调用？
{
	m_bExited = true;
	//关闭FDC通讯
	TurnOffFDCRequest();

	DisconnectFDCAxn();

	Sleep(1000);

	////关闭XCU通讯
	TurnOffRequest();

	DisconnectAxn();

	Sleep(100);

	if (m_pFDCAxnClient != NULL)
	{
		m_pFDCAxnClient = NULL;
	}

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient = NULL;
	}

	PRINTA_DEBUG(  "SerialPortClose End\n");
	return true;
}

/*********************************************************************************
函数名称：ConnectXCS
功能描述：连接XCS服务器

修改记录:
2015-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::ConnectXCS(void)
{
	axn_word wtimeout = 10;   //默认值 该值会影响recvobject（）函数的返回时间，现场使用的时间为该值*200（程序放大值）*3（经验值）；针对turn off时间由5秒延迟到10s，与SSME周超保持一致
	axn_status status;

	if (m_pAxnClient)
	{
		CAxnClientIFCreator::deleteAxnClientIF(m_pAxnClient);
		m_pAxnClient = NULL;
		PRINTA_INFO("ConnectXCS,deleteAxnClientIF\n");
	}

	m_pAxnClient = CAxnClientIFCreator::newAxnClientIF();

	if (m_pAxnClient == NULL)
	{
		PRINTA_INFO("newAxnClientIF fail\n");
		return false;
	}//ENDIF
	Sleep(100);
	int nConnectTime = 0; //初始化0
	PRINTA_INFO(  "== SEND == : connectToServer AxnClient\n");
	while ((status = m_pAxnClient->connectToServer(Clientsender, wtimeout)) != ACS_AXN_OK)
	{
		PRINTA_WARN("Connect Time: %d\n", nConnectTime);
		printf("F3 Connect Time: %d\n", nConnectTime);
		if (nConnectTime >= 20)
		{
			break;
		}
		else
		{
			nConnectTime++;
			Sleep(1000);
		}
	}

	if (nConnectTime >= 20)
	{
		PRINTA_ERROR("Tried %d times, still failed to connect XCS, return\n", nConnectTime);
		string code = "ConnectError";
		string info = "Can't connect to Axim, Please reboot the system.";
		int level = CONNECTIONERROR;
		m_MSGUnit->AddErrorMessage(code.c_str(), level, info.c_str(),0xF3);
		return false;
	}
	else
	{
		string code = "ConnectError";
		string info = "";
		int level = CONNECTIONERROR;
		m_MSGUnit->DelErrorMessage(code.c_str(), level, info.c_str());
		return true;
	}
}
void nsGEN::SMZDevice::DisconnectAxn()
{
	if (m_pAxnClient)
	{
		CAxnClientIFCreator::deleteAxnClientIF(m_pAxnClient);
		m_pAxnClient = NULL;

		EnterCriticalSection(&m_csStatus);
		m_bIdentStatus = false;
		m_bReGetTurnOn = true;
		PRINTA_INFO("callback: DisconnectAxn, m_bIdentStatus = false，m_bReGetTurnOn = true\n");
		LeaveCriticalSection(&m_csStatus);
		PRINTA_INFO(  "deleteAxnClientIF\n");
	}
}

DWORD nsGEN::SMZDevice::ReveiveXCUData(LPVOID pParam)
{
	nsGEN::SMZDevice* pCurOpr = (nsGEN::SMZDevice*)pParam;
	while (1)
	{
		if (pCurOpr->m_pAxnClient == NULL)
		{
			return 1;
		}
		try {
			axn_status status;
			::ZeroMemory(pCurOpr->m_pBuffer, MAX_LEN_ACS_OBJ * sizeof(axn_byte));
			status = pCurOpr->m_pAxnClient->recvObject((ACS_BYTE*)pCurOpr->m_pBuffer);

			if (status == ACS_AXN_NOK)
			{
				PRINTA_ERROR("XCU Some Error when AxnClient recvObject\n");
				Sleep(2 * AXN_DUMMYTIME_BASE_RATE_IN_MS * 1);
				if (pCurOpr->m_nLostConnectNumber >= 5)
				{
					string code = "ReceiveError";
					string info = "Can't receive the command from generator,Please reboot the system.";
					int level = CONNECTIONERROR;
					pCurOpr->m_MSGUnit->AddErrorMessage(code.c_str(), level, info.c_str(), 0xF3);
				}
				else
				{
					pCurOpr->m_nLostConnectNumber++;
				}
				PRINTA_ERROR("XCU communication fail\n");
				printf("XCU communication fail!!!!!!!! \n");
				pCurOpr->DisconnectAxn();
				Sleep(2000);
				pCurOpr->ConnectXCS();
			}
			else if (status == ACS_AXN_TIMEOUT)
			{
				PRINTA_ERROR("XCU receive communication Timeout\n");
			}
			else
			{
				if (pCurOpr->m_nLostConnectNumber > 0)
				{
					pCurOpr->m_nLostConnectNumber = 0;
				}
				if (pCurOpr->m_pBuffer != NULL)
				{
					acs_obj_header_t* tel_hdr_p;
					tel_hdr_p = (acs_obj_header_t*)pCurOpr->m_pBuffer;
					try {
						if (tel_hdr_p->length <= MAX_LEN_ACS_OBJ)
						{
							SetEvent(pCurOpr->m_hDUMMYEvent);
							//PRINTA_DEBUG("ReveiveXCUData: recvObject id: 0x%x,Sender: 0x%x,,Target:0x%x", tel_hdr_p->id,tel_hdr_p->sender,tel_hdr_p->target); //just for test

							if (tel_hdr_p->id != DUMMY_MSG)
							{
								PRINTA_DEBUG("ReveiveXCUData: recvObject id: %x", tel_hdr_p->id);
								axn_byte* pBuffer;
								pBuffer = new axn_byte[MAX_LEN_ACS_OBJ];
								::ZeroMemory(pBuffer, MAX_LEN_ACS_OBJ * sizeof(axn_byte));
								::memcpy(pBuffer, pCurOpr->m_pBuffer, MAX_LEN_ACS_OBJ * sizeof(axn_byte));

								EnterCriticalSection(&pCurOpr->m_csXCUData);
								pCurOpr->m_sCallbackData.push_back(pBuffer);
								LeaveCriticalSection(&pCurOpr->m_csXCUData);
								SetEvent(pCurOpr->m_hXCUDataEvent);
							}
							else
							{
								//ACS_DUMMY Dummy1 = (*(ACS_DUMMY*)(pCurOpr->m_pBuffer + sizeof(acs_obj_header_t)));
								//ACS_DUMMY Dummy2 = (*(ACS_DUMMY*)(pCurOpr->m_pBuffer + sizeof(acs_obj_header_t) + sizeof(ACS_DUMMY)));
								//ACS_DUMMY Dummy3 = (*(ACS_DUMMY*)(pCurOpr->m_pBuffer + sizeof(acs_obj_header_t) + 2 * sizeof(ACS_DUMMY)));
								//ACS_DUMMY Dummy4 = (*(ACS_DUMMY*)(pCurOpr->m_pBuffer + sizeof(acs_obj_header_t) + 3 * sizeof(ACS_DUMMY)));

								//PRINTA_DEBUG("ReveiveXCUData: recvObject DUMMY id: 0x%x,Sender: 0x%x,,Target:0x%x,Length: %d,group_index:%d,mode: %d,Dummy1:0x%x,Dummy2:0x%x,Dummy3:0x%x,Dummy4:0x%x", 
									//tel_hdr_p->id, tel_hdr_p->sender, tel_hdr_p->target, tel_hdr_p->length, tel_hdr_p->group_index,tel_hdr_p->mode,Dummy1, Dummy2, Dummy3, Dummy4); //just for test
							}

							if (pCurOpr->m_nTimeoutCount != 0)
							{
								pCurOpr->m_nTimeoutCount = 0;
								PRINTA_INFO("ReceiveCommand get command, then set TimeoutCount to 0\n");
							}
						}
						else
						{
							PRINTA_ERROR("Get a error command: > max_len_acs_obj\n");
						}
					}
					catch (...)
					{
						PRINTA_ERROR("Crash log 1, other error\n");
					}
				}
				else
				{
					PRINTA_ERROR("m_pBuffer = NULL\n");
				}
			}
		}
		catch (...)
		{
			PRINTA_ERROR("Crash log 2, other error\n");
		}

		if (pCurOpr->m_bExited)
		{
			break;
		}
	}
	
	return 0;
}

DWORD nsGEN::SMZDevice::XCUDataThread(LPVOID pParam)
{
	nsGEN::SMZDevice* pCurOpr = (nsGEN::SMZDevice*)pParam;
	while (true)
	{
		axn_byte* dd;
		bool bGetData = false;
		EnterCriticalSection(&pCurOpr->m_csXCUData);
		if (!pCurOpr->m_sCallbackData.empty())
		{
			bGetData = true;
			dd = pCurOpr->m_sCallbackData.front();
			pCurOpr->m_sCallbackData.pop_front();
			LeaveCriticalSection(&pCurOpr->m_csXCUData);
			//PRINTA_DEBUG("Callback XCUData push the data\n");
		}
		else
		{
			LeaveCriticalSection(&pCurOpr->m_csXCUData);
			WaitForSingleObject(pCurOpr->m_hXCUDataEvent, 50);
		}
		if (bGetData)
		{
			pCurOpr->CallbackXCU((acs_obj_header_t*)dd);
			if (dd != NULL)
			{
				delete[] dd;
				dd = NULL;
			}
		}//ENDIF

		if (pCurOpr->m_bExited)
		{
			break;
		}
	}
	return 0;
}

bool nsGEN::SMZDevice::CallbackXCU(const acs_obj_header_t* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Callback: Get command is Null\n");
		return false;
	}//ENDIF
	printf("== IN == XCU Telegram ID: %x \n", pCommand->id);
	try
	{
		switch (pCommand->id)
		{
		case UINT16(INIT_MSG):
			PRINTA_DEBUG("== IN == : INIT_MSG\n");
			SendList();
			SendTelegramLog("INIT_MSG");
			break;
		case UINT16(TURN_ON):
			PRINTA_DEBUG("== IN == : TURN_ON\n");
			CallbackTurnOn((ACS_BYTE*)pCommand);
			break;
		case UINT16(TURN_OFF):
			PRINTA_DEBUG("== IN == : TURN_OFF\n");
			CallBackTurnOff((ACS_BYTE*)pCommand);
			break;
		case UINT16(INETZAUFNAHME):
			PRINTA_DEBUG("== IN == : INETZAUFNAHME\n");
			SendTelegramLog("INETZAUFNAHME");
			m_bIdentStatus = true;
			SendDate();
			Sleep(50);
			SendIfeStatus(WARTEND);
			break;
		case UINT16(SAPPLIKATION):
			PRINTA_DEBUG("== IN == : SAPPLIKATION\n");
			SendTelegramLog("SAPPLIKATION");
			SendIfeStatus(BETRIEBSBEREIT);
			SendErrorLog();
			break;
		case UINT16(AISTWERTE):  //xcu wait
			PRINTA_DEBUG("== IN == : AISTWERTE\n");
			SendiISTWERTE();
			SendTelegramLog("AISTWERTE");
			break;
		case UINT16(SINIT):
			PRINTA_DEBUG("== IN == : SINIT\n");
			SendTelegramLog("SINIT");
			sinit_t1_tag* sinit_p;
			sinit_p = (sinit_t1_tag*)pCommand;
			if (sinit_p->initkennung == 0)
			{
				SendIfeStatus(BETRIEBSBEREIT);
			}
			break;
		case UINT16(AKENNDATEN):
			PRINTA_DEBUG("== IN == : AKENNDATEN\n");
			SendTelegramLog("AKENNDATEN");
			Sleep(50);
			QueryExposureNumber(); //20200604 增加曝光查询次数
			break;
		case UINT16(IPASSWORT):
			break;
		case UINT16(IORGANANZ2):   //get organanz  for paramlist, orgdate
			PRINTA_DEBUG("== IN == : IORGANANZ2\n");
			break;
		case UINT16(SAUSLBED):
			PRINTA_DEBUG("== IN == : SAUSLBED\n");//TODO
			//CallbackSauslBed((ACS_BYTE*)pCommand);
			break;

		case UINT16(IGENANZ):
			PRINTA_DEBUG("== IN == : IGENANZ\n");
			CallbackGenParam((ACS_BYTE*)pCommand);
			break;

		//case UINT16(ISTRMANANZ):
		//	PRINTA_DEBUG("== IN == : ISTRMANANZ\n");
		//	//CallbackstrmananzParam((istrmananz_t1_tag*)pCommand); 不需要实现
		//	break;

		case UINT16(IFILTERANZ):
			PRINTA_DEBUG("== IN == : IFILTERANZ\n");
			CallbackIFILTERANZParam((ACS_BYTE*)pCommand);
			break;
		case UINT16(IFILTER):
			PRINTA_DEBUG("== IN == : IFILTER\n");
			//CallbackIFILTERParam((ACS_BYTE*)pCommand);  不需要实现
			break;
		case UINT16(IDFPANZ2):
			PRINTA_DEBUG("== IN == : IDFPANZ2\n");
			//CallbackDAPParam((ACS_BYTE *)pCommand); //本报文原用于获取DAP，但目前已经不起作用，可以不予解析；2018/9/26
			break;
		case UINT16(IERRORLOG2):   //Error message set to log file
			PRINTA_DEBUG("== IN == : IERRORLOG2\n");
			CallbackErrorParam((ACS_BYTE*)pCommand);
			break;

		case UINT16(ERROR_MSG):
			PRINTA_DEBUG("== IN == : ERROR_MSG\n");
			SendTelegramLog("ERROR_MSG");
			break;

		case UINT16(IFEHLER):     //error type; 
			PRINTA_DEBUG("== IN == : IFEHLER\n");
			SendTelegramLog("IFEHLER");
			break;

		case UINT16(ISYSTEMANZ):
			PRINTA_DEBUG("== IN == : ISYSTEMANZ\n");
			CallbackWorkstationFromXCU((ACS_BYTE*)pCommand);
			break;

		case UINT16(SAUFNAUSL):
			PRINTA_DEBUG("== IN == : SAUFNAUSL\n");
			CallbackAufnAusl((ACS_BYTE*)pCommand);
			break;

		//case UINT16(SBILD):
		//	PRINTA_DEBUG("== IN == : SBILD\n");
		//	CallbackSBILD((ACS_BYTE*)pCommand);
		//	break;

		case UINT16(SORGANSELECT): //set finish the view value
			PRINTA_DEBUG("== IN == : SORGANSELECT\n");
			CallbackSORGANSELECT((ACS_BYTE*)pCommand);
			break;
		case UINT16(SH_LIST):
			PRINTA_DEBUG("== IN == : SH_LIST\n");
			CallBackShowList((ACS_BYTE*)pCommand);
			break;

		case UINT16(DUMMY_MSG):
			break;

		case UINT16(IIONANZ):
			PRINTA_DEBUG("== IN == : IIONANZ\n");
			CallbackGetField((ACS_BYTE*)pCommand);
			break;

		case UINT16(INACHANZ):  //post exposure parameters
			PRINTA_DEBUG("== IN == : INACHANZ\n");
			CallbackPostGenParam((ACS_BYTE*)pCommand);
			break;

		case UINT16(IAUFNDATEN):
			PRINTA_DEBUG("== IN == : IAUFNDATEN\n");
			SendTelegramLog("IAUFNDATEN");
			break;

		case UINT16(IDAPVALUE):  //dap not in using
			PRINTA_DEBUG("== IN == : IDAPVALUE\n");
			SendTelegramLog("IDAPVALUE");
			break;

		case UINT16(IDFRALLGANZ2):
			PRINTA_DEBUG("== IN == : IDFRALLGANZ2\n");
			CallBackIdrallganz2((ACS_BYTE*)pCommand);
			break;

		case UINT16(IFEHLERANZ2):  //dispaly the message to UI
			PRINTA_DEBUG("== IN == : IFEHLERANZ2\n");
			CallBackIfehleranz2((ACS_BYTE*)pCommand);
			break;
		//case UINT16(IINFOCOMP):
		//	PRINTA_DEBUG("== IN == : IINFOCOMP\n");
		//	CallBackIINFOCOMP((ACS_BYTE*)pCommand);
		//	break;
		case UINT16(SDETEKTORSTART):
			PRINTA_DEBUG("== IN == : SDETEKTORSTART\n");	//二级手闸信号；
			m_bAlreadyExposure = false;
			m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_READY);
			FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
			PRINTA_INFO("<GEN EXP>the generator ready \n");
			SendTelegramLog("SDETEKTORSTART","", pCommand->sender);
			break;
		case UINT16(STESTCMD):
			PRINTA_DEBUG("== IN == : STESTCMD\n");
			SendTelegramLog("STESTCMD");
			break;
		case UINT16(ST_MODE):
			PRINTA_DEBUG("== IN == : ST_MODE\n");
			CallBackST_MODE((ACS_BYTE*)pCommand);
			break;
		case UINT16(SDFRNAHBED2):
			PRINTA_DEBUG("== IN == : SDFRNAHBED2\n");
			CallBackSDFRNAHBED2((ACS_BYTE*)pCommand);
			break;
		case UINT16(ST_ORGAN_PROG):
			PRINTA_DEBUG("== IN == : ST_ORGAN_PROG\n");
			CallBackST_ORGAN_PROG((ACS_BYTE*)pCommand);
			break;
		case UINT16(SRESETFEHLER):
			PRINTA_DEBUG("== IN == : SRESETFEHLER\n");
			CallBackSRESETFEHLER((ACS_BYTE*)pCommand);
			SendTelegramLog("SRESETFEHLER");
			break;
		case UINT16(IFFA):  //get SID
			PRINTA_DEBUG("== IN == : IFFA(SID)\n");
			CallBackSID((ACS_BYTE*)pCommand);
			break;
		//case UINT16(SBEDSYS): // Get Workstation   //from TUI select
		//	PRINTA_DEBUG("== IN == : SBEDSYS(WorkStation)\n");
		//	CallBackWorkStationFromTUI((ACS_BYTE*)pCommand);
		//	break;
		case UINT16(IBLENDEANZ): //(Collimator)
			PRINTA_DEBUG("== IN == : IBLENDEANZ(Collimator)\n");
			CallBackCollimator((ACS_BYTE*)pCommand);
			break;
		case UINT16(IRASTERANZ): //(Grid)
			PRINTA_DEBUG("== IN == : IRASTERANZ(Grid)\n");
			CallBackGrid((ACS_BYTE*)pCommand);
			break;
		case UINT16(RQ_FDR_DATA): //(Request FPD Data)
			PRINTA_DEBUG("== IN == : RQ_FDR_DATA\n");
			CallBackRQ_FDR_DATA((ACS_BYTE*)pCommand);
			break;
		case UINT16(ST_ADJUST):
			PRINTA_DEBUG("== IN == : ST_ADJUST\n");
			CallBackAdjust((ACS_BYTE*)pCommand);
			break;
		case UINT16(IGGANZ2):
			PRINTA_DEBUG("== IN == : IGGANZ2\n");
			//GeneratorDriver::SetGeneratorStatus(GENERATOR_STATUS_STANDBY); //202110 待完善
			m_DoseUnit.m_GenState->Update(AttrKey::GENERATOR_STATUS_STANDBY);
			CallBackIGGANZ2((ACS_BYTE*)pCommand);
			break;
		case UINT16(IROEANZ):
			PRINTA_DEBUG("== IN == : IROEANZ\n");
			CallBackTubeHeat((ACS_BYTE*)pCommand);
			break;
		case UINT16(ST_DIAG):
			PRINTA_DEBUG( "== IN == : PMS ST_DIAG, request system status information\n");
			CallBackSTDIAG((ACS_BYTE*)pCommand);
			break;
		case UINT16(RQ_OBJECT):
			PRINTA_DEBUG("== IN == : PMS RQ_OBJECT, request system Version information\n");
			CallBackRQOBJECT((ACS_BYTE*)pCommand);
			break;
		case UINT16(IALLGANZ):
			PRINTA_DEBUG("== IN == : IALLGANZ\n");
			CallBackDoorStatus((ACS_BYTE*)pCommand);
			break;
		case UINT16(ST_CONFIG):
			PRINTA_DEBUG("== IN == : PMS ST_CONFIG\n");
			CallBackSTCONFIG((ACS_BYTE*)pCommand);
			break;
		case UINT16(ST_DATA_TRANS):
			PRINTA_DEBUG("== IN == : PMS ST_DATA_TRANS\n");
			CallBackST_DATA_TRANS((ACS_BYTE*)pCommand);
			break;
		case UINT16(ST_SYSTEM_STATE):
			PRINTA_DEBUG("== IN == : PMS ST_SYSTEM_STATE\n");
			CallBackPMSSystemStatus((ACS_BYTE*)pCommand);
			break;
		case UINT16(SFANZLOESCHEN):
			PRINTA_DEBUG("== IN == : PMS SFANZLOESCHEN\n");
			CallBackSFANZLOESCHEN((ACS_BYTE*)pCommand);
			break;
		case UINT16(ISERVBETRIEB):
			PRINTA_DEBUG("== IN == : ISERVBETRIEB\n");
			CallbackExposureNumber((ACS_BYTE*)pCommand);
			break;
		case UINT16(IWATERVALACQ):
			PRINTA_DEBUG("== IN == : IWATERVALACQ\n");
			CallbackIWATERVALACQ((ACS_BYTE*)pCommand);
			break;
		case UINT16(ISOD):
			PRINTA_DEBUG("== IN == : ISOD\n");
			CallBackSOD((ACS_BYTE*)pCommand);
			break;
		case UINT16(IACSS):
			PRINTA_DEBUG("== IN == : IACSS\n");
			CallbackIACSS((ACS_BYTE*)pCommand);
			break;
		case UINT16(IXRAY):
			PRINTA_DEBUG("== IN == : IXRAY\n");
			CallbackIXRAY((ACS_BYTE*)pCommand);
			break;
		case UINT16(IPRINTAUFN):
			PRINTA_DEBUG("== IN == : IPRINTAUFN\n");
			break;
		case UINT16(IERWALLGANZ):
			PRINTA_DEBUG("== IN == : IERWALLGANZ\n");
			CallbackIERWALLGANZ((ACS_BYTE*)pCommand);
			break;
		case UINT16(SORTHO):
			PRINTA_DEBUG("== IN == : SORTHO\n");
			CallbackSORTHO((ACS_BYTE*)pCommand);
			break;
		case UINT16(SORTHOACTSIZE):
			PRINTA_DEBUG("== IN == : SORTHOACTSIZE\n");
			//CallbackSORTHOACTSIZE((ACS_BYTE*)pCommand); //2021-04：不需要实现
			break;
		case UINT16(SH_STPAR_RFP):
			PRINTA_DEBUG("== IN == : SH_STPAR_RFP\n");
			CallbackSH_STPAR_RFP((ACS_BYTE*)pCommand);
			break;
		case UINT16(ST_PWR_OFF):
			PRINTA_DEBUG("== IN == : ST_PWR_OFF\n");
			CallbackST_PWR_OFF((ACS_BYTE*)pCommand);
			break;
		case UINT16(IANLBEREIT):
			PRINTA_INFO("== IN == : IANLBEREIT\n");
			CallBackIANLBEREIT((ACS_BYTE*)pCommand);
			break;
		default:
			break;
		}
	}
	catch (...)
	{
		PRINTA_ERROR("Callback Deal XCU data Crash: id:%x\n", pCommand->id);
		printf("Callback Deal XCU data Crash: id:%x\n", pCommand->id);
	}
	return true;
}

/*********************************************************************************
函数名称：SendList
功能描述：设置DROC端需要从SCU端接收的报文清单

修改记录:
2015-04-20 创建
2017-03-04 增加DAP报文
*******************************************************************************/
bool nsGEN::SMZDevice::SendList(void)
{
	ACS_WORD szID[XCS_MESSAGE_NUM] = { INETZAUFNAHME,
			SAPPLIKATION,
			SINIT,
			AKENNDATEN,
			IPASSWORT,
			TURN_OFF,
			DUMMY_MSG,
			IGENANZ,
			TURN_ON,
			IORGANANZ2,
			//ISTRMANANZ,
			IFILTERANZ,
			IDFPANZ2,
			IERRORLOG2,
			ERROR_MSG,
			IFEHLER,
			IFEHLER2,
			ISYSTEMANZ,
			SAUFNAUSL,
			//SBILD,
			SORGANSELECT,
			IIONANZ,
			AISTWERTE,
			IFEHLERANZ2,
			IDFRALLGANZ2,
			SH_LIST,
			INACHANZ,
			IDAPVALUE,
			//IINFOCOMP,
			SDETEKTORSTART,
			SAUSLBED,
			STESTCMD,
			ST_MODE,
			SDFRNAHBED2,
			ST_ORGAN_PROG,
			SRESETFEHLER,
			IFILTER,
			IANLBEREIT,
			IFFA,
			IBLENDEANZ,
			IRASTERANZ,
			RQ_FDR_DATA,
			ST_ADJUST,
			IGGANZ2,
			IROEANZ,
			ST_DIAG,
			SH_VERSION,
			RQ_OBJECT,
			SH_CONFIG,
			ST_DATA_TRANS,
			IALLGANZ,
			ST_SYSTEM_STATE,
			SFANZLOESCHEN,
			ISERVBETRIEB,
			IWATERVALACQ,
			ISOD,
			IACSS,
			IXRAY,
			IPRINTAUFN,
			IERWALLGANZ,
			IBETRIEBSART,
			ST_PWR_OFF,
			IANLBEREIT
	};
	inlist_enh_t1_tag szSendGen = {};
	m_stGenCommand.id = INLIST_ENH;
	m_stGenCommand.sender = Clientsender;
	m_stGenCommand.mode = 0;
	m_stGenCommand.target = 0;
	m_stGenCommand.group_index = Clientgroup_index;
	m_stGenCommand.length = m_wHeaderLength + (XCS_MESSAGE_NUM + 1) * sizeof(ACS_WORD);
	szSendGen.no_objects = XCS_MESSAGE_NUM;
	szSendGen.header = m_stGenCommand;

	ACS_BYTE* p_ID = new ACS_BYTE[m_stGenCommand.length * 2];
	::memset(p_ID, 0, m_stGenCommand.length * sizeof(ACS_BYTE) * 2);
	::memcpy((ACS_BYTE*)p_ID, (ACS_BYTE*)(&szSendGen), m_wHeaderLength + sizeof(ACS_WORD));
	::memcpy((ACS_BYTE*)(p_ID + m_wHeaderLength + sizeof(ACS_WORD)),
		(ACS_BYTE*)(&szID), XCS_MESSAGE_NUM * sizeof(ACS_WORD));

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)p_ID);
		SendTelegramLog("INLIST_ENH", "", m_stGenCommand.sender,0);
	}//ENDIF
	delete[]p_ID;
	p_ID = NULL;

	PRINTA_DEBUG("== SEND == : INLIST_ENH( LIST)\n");
	return true;
}

/*********************************************************************************
函数名称：SendiISTWERTE
功能描述：设置组件状态

修改记录:
2021-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SendiISTWERTE(void)
{
	iistwertequit_t1 szSendGen = {};
	m_stGenCommand.id = IISTWERTEQUIT;
	m_stGenCommand.length = m_wHeaderLength;
	szSendGen.header = m_stGenCommand;
	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)&szSendGen);
		PRINTA_DEBUG("== SEND == : IISTWERTEQUIT\n");
		SendTelegramLog("IISTWERTEQUIT", "", m_stGenCommand.sender);
	}//ENDIF
	return true;
}

/*********************************************************************************
函数名称：SendIdent
功能描述：设置与XCU交互的第一条报文

修改记录:
2015-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SendIdent(void)
{
	iident_t1 szSendGen = {};
	m_stGenCommand.id = IIDENT;
	m_stGenCommand.length = m_wHeaderLength + 3 * sizeof(ACS_BYTE) + 10 * sizeof(ACS_STRING_8) + 3 * sizeof(ACS_DUMMY);
	m_stGenCommand.mode = Clientmode;
	m_stGenCommand.sender = Clientsender;
	m_stGenCommand.group_index = Clientgroup_index;
	m_stGenCommand.target = Clienttarget;
	szSendGen.fetyp = BILDVERARBEITUNG;
	szSendGen.knotenid = Clientsender;
	szSendGen.apid = Clientsender;

	ACS_STRING_8 temp[10] = "FLSP_COMP";
	::memcpy(szSendGen.kompname, temp, 10);

	szSendGen.header = m_stGenCommand;

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)&szSendGen);
		PRINTA_DEBUG("== SEND == : IIDENT\n");
		SendTelegramLog("IIDENT", "", m_stGenCommand.sender);
	}//ENDIF
	else
	{
		PRINTA_DEBUG("== SEND == : IIDENT is not successful\n");
	}
	return true;
}

/*********************************************************************************
函数名称：SendErrorLog
功能描述：设置当前DROC保存的错误个数到XCU端

修改记录:
2015-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SendErrorLog(void)
{
	ierrorlogsync_t1_tag szSendGen = {};
	m_stGenCommand.id = IERRORLOGSYNC;
	m_stGenCommand.length = m_wHeaderLength + sizeof(ACS_WORD) + 2 * sizeof(ACS_DUMMY);
	szSendGen.errcnt = m_nLastErrorCount; //需要读取配置
	szSendGen.header = m_stGenCommand;

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)&szSendGen);
		PRINTA_DEBUG("IS: errcnt: %lu", szSendGen.errcnt);
		SendTelegramLog("IERRORLOGSYNC", "", m_stGenCommand.sender);
	}//ENDIF
	PRINTA_DEBUG("== SEND == : IERRORLOGSYNC\n");

	return true;
}
/*********************************************************************************
函数名称：SendDate
功能描述：设置当前时间到XCU端，保持时间同步

修改记录:
2015-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SendDate(void)
{
	sdate_t1_tag szSendGen = {};
	SYSTEMTIME SysCurrentTime;
	GetLocalTime(&SysCurrentTime);

	m_stGenCommand.id = SDATE;
	m_stGenCommand.length = m_wHeaderLength + 6 * sizeof(ACS_BYTE) + 2 * sizeof(ACS_DUMMY);

	szSendGen.day = SysCurrentTime.wDay;		  //day 　　
	szSendGen.year = SysCurrentTime.wYear - 2000; //year 　　Siemens要求
	szSendGen.month = SysCurrentTime.wMonth;		  //month
	szSendGen.hour = SysCurrentTime.wHour;		  //hour
	szSendGen.minute = SysCurrentTime.wMinute;	  //minute
	szSendGen.second = SysCurrentTime.wSecond;      //second
	szSendGen.header = m_stGenCommand;

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)&szSendGen);
		SendTelegramLog("SDATE", "", m_stGenCommand.sender);
	}//ENDIF
	PRINTA_DEBUG("== SEND == : SDATE\n");

	//SendErrorLog(); //Siemens要求，在此时间点设置该指令 20210512 符合AXIM流程
	return true;
}

///*********************************************************************************
//函数名称：QueryExposureNumber
//功能描述： 查询当前曝光的次数(ASERVBETRIEB )
//修改记录:
//2021-04-20 创建
//*******************************************************************************/
bool nsGEN::SMZDevice::QueryExposureNumber()   //2021-04  待完善功能：需要客户端根据需要进行调用 
{
	aservbetrieb_t1 QueryExposureNumber = {};
	m_stGenCommand.id = ASERVBETRIEB;
	m_stGenCommand.length = m_wHeaderLength;
	QueryExposureNumber.header = m_stGenCommand;

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)&QueryExposureNumber);
		SendTelegramLog("ASERVBETRIEB", "", m_stGenCommand.sender);
	}//ENDIF

	PRINTA_INFO("QueryExposureNumber\n");
	return true;
}

/*********************************************************************************
函数名称：SendIfeStatus
功能描述：设置组件状态

修改记录:
2021-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SendIfeStatus(int IfeStatusValue)
{
	ifestatus_t1_tag szSendGen = {};
	m_stGenCommand.id = IFESTATUS;
	m_stGenCommand.length = m_wHeaderLength + sizeof(ACS_BYTE) + sizeof(ACS_DUMMY) * 3;
	szSendGen.festatus = IfeStatusValue;
	szSendGen.header = m_stGenCommand;
	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)&szSendGen);
		PRINTA_DEBUG("IS: festatus: %d, Send to 0x%x\n", szSendGen.festatus, szSendGen.header.target);
		SendTelegramLog("IFESTATUS", "", m_stGenCommand.sender);
	}//ENDIF

	szSendGen.header.target = SFServer;
	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)&szSendGen);
		PRINTA_DEBUG("IS: festatus: %d, Send to 0x%x\n", szSendGen.festatus, szSendGen.header.target);
		SendTelegramLog("IFESTATUS", "Send to SFServer", m_stGenCommand.sender);
	}//ENDIF

	PRINTA_INFO("== SEND == : IFESTATUS: %d\n", IfeStatusValue);
	return true;
}

///*********************************************************************************
//函数名称：SetSH_Mode
//功能描述： 返回SH_mode报文，对应ST_mode

//修改记录:
//2021-04-23 创建
//*******************************************************************************/
bool nsGEN::SMZDevice::SetSH_Mode(int nMode)
{
	sh_mode_t1_tag SendSH_Mode = {};
	m_stGenCommand.id = SH_MODE;
	m_stGenCommand.target = ClientPMS;
	m_stGenCommand.length = m_wHeaderLength + sizeof(ACS_ENUM) + 3 * sizeof(ACS_DUMMY);
	SendSH_Mode.header = m_stGenCommand;

	SendSH_Mode.system_mode = (int)nMode;

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)&SendSH_Mode);

		std::ostringstream buffer;
		buffer << "IS: system_mode:" << (int)SendSH_Mode.system_mode;
		string str = buffer.str();
		SendTelegramLog("IFESTATUS", str.c_str(), m_stGenCommand.sender, 0);
	}//ENDIF

	m_stGenCommand.target = Clienttarget;

	PRINTA_INFO("== SEND == : SetSH_Mode: SendSH_Mode.system_mode: %d\n", SendSH_Mode.system_mode);
	return true;
}

/*********************************************************************************
函数名称：SendIdfrnahbed
功能描述：对iDfrBed报文的确认

修改记录:
2021-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SendIdfrnahbed(int nCode, int nData)  //2021-04  待完善功能：需要客户端设置 设置TOD参数
{
	idfrnahbed_t1_tag szSendGen = {};

	m_stGenCommand.id = IDFRNAHBED;
	m_stGenCommand.length = m_wHeaderLength + sizeof(ACS_COUNT) + 2 * sizeof(ACS_INT) + 3 * sizeof(ACS_DUMMY);
	szSendGen.header = m_stGenCommand;
	szSendGen.aktanzahl = 1;

	ACS_BYTE* p_ID = new ACS_BYTE[m_stGenCommand.length * 2];
	memset(p_ID, 0, m_stGenCommand.length * sizeof(ACS_BYTE) * 2);
	memcpy((ACS_BYTE*)p_ID, (ACS_BYTE*)(&szSendGen), m_wHeaderLength + sizeof(ACS_COUNT) + 3 * sizeof(ACS_DUMMY));

	idfrnahbed_t2_tag szSendGen2 = {};
	szSendGen2.aktcode = nCode; //MARK_R_POSITION;
	szSendGen2.aktdata = nData; //0;     //Siemens 要求
	memcpy((ACS_BYTE*)(p_ID + m_wHeaderLength + sizeof(ACS_COUNT) + 3 * sizeof(ACS_DUMMY)), (ACS_BYTE*)(&szSendGen2),
		2 * sizeof(ACS_INT));

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)p_ID);

		std::ostringstream buffer;
		buffer << "IS: F3 aktcode:" << (int)szSendGen2.aktcode << ",aktdata: " << (int)szSendGen2.aktdata;
		string str = buffer.str();
		SendTelegramLog("IDFRNAHBED", str.c_str(), m_stGenCommand.sender,0);
	}//ENDIF

	delete[] p_ID;
	p_ID = NULL;

	PRINTA_INFO("== SEND == : IDFRNAHBED\n");
	return true;
}

/*********************************************************************************
函数名称：SendAdjust
功能描述：发送AP的读写结果到PMS

修改记录:
2021-04-23 创建
2021-06-01 已经不使用了
*******************************************************************************/
bool nsGEN::SMZDevice::SendAdjust(int nResult)
{
	return true;
	sh_adjust_t1_tag shAdjustData = {};
	m_stGenCommand.id = SH_ADJUST;
	m_stGenCommand.target = ClientPMS;

	int nAdjustLength = m_wHeaderLength + sizeof(ACS_ENUM) + 3 * sizeof(ACS_DUMMY) + 3 * sizeof(ACS_INT) + sizeof(ACS_DCOUNT);
	int nAdjust2Length = 0;

	string strPath = "";
	if (ACS_ADJ_FILETRANS_OK == nResult) //6
	{
		nAdjust2Length = strlen(strPath.c_str()) * sizeof(ACS_BYTE);
		shAdjustData.adj_status = ACS_ADJ_FILETRANS_OK;  //6  
	}
	else if (ACS_ADJ_FILETRANS_NOK == nResult)  //7
	{
		shAdjustData.adj_status = ACS_ADJ_FILETRANS_NOK;//7
	}
	else if (ACS_ADJ_RUNNING == nResult) //1
	{
		shAdjustData.adj_status = ACS_ADJ_RUNNING;// 1
	}
	else if (ACS_ADJ_FILETRANS_NODATA == nResult)
	{
		shAdjustData.adj_status = ACS_ADJ_FILETRANS_NODATA;// 9
	}//ENDIF
	shAdjustData.identifier = ACS_ADJUST_ID_FD_WLAN; //22

	m_stGenCommand.length = nAdjustLength + nAdjust2Length;
	shAdjustData.header = m_stGenCommand;
	shAdjustData.no_adj_data = nAdjust2Length;

	ACS_BYTE* pCommand = new ACS_BYTE[m_stGenCommand.length * 2];
	memset(pCommand, 0, m_stGenCommand.length * sizeof(ACS_BYTE) * 2);
	memcpy((ACS_BYTE*)pCommand, (ACS_BYTE*)(&shAdjustData), nAdjustLength);

	if (ACS_ADJ_FILETRANS_OK == nResult)
	{
		PRINTA_INFO("Copy ScalanceWlanAccesspoint.xml\n");

		sh_adjust_t2_tag shAdjustData2 = {};
		for (int i = 0; i < sizeof(strPath); i++)
		{
			shAdjustData2.adj_data = (ACS_BYTE)(strPath[i]);
			memcpy((ACS_BYTE*)(pCommand + nAdjustLength + i * sizeof(ACS_BYTE)), (ACS_BYTE*)(&shAdjustData2), sizeof(ACS_BYTE));
		}
	}//ENDIF

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject(pCommand);//pCommand

		SendTelegramLog("SH_ADJUST", "", m_stGenCommand.sender, 0);
	}//ENDIF;
	PRINTA_INFO("== SEND == : SH_ADJUST Path:%s\n", strPath);
	delete[]pCommand;
	pCommand = NULL;

	m_stGenCommand.target = Clienttarget;
	return true;
}

/*********************************************************************************
函数名称：SetSystemStatusInformation
功能描述：设置当前软件系统的状态信息
参数描述：
nStatusIndex：
VERSIONINFOR_SOFTWARE   (3)
HOSTID				     (4)
SOFTWAREDONGLEID         (5)
FREESPACEOFHARDDISK      (6)
FREESPACEOFMEMORY        (7)
CONFIGFILEISSUE          (8)

修改记录:
2021-04-23 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SetSystemStatusInformation(int nStatusIndex, const char* strInfor, ACS_ENUM nDealStatus) //需要客户端设置 各版本信息 202110 SSI
{
	sh_diag_t1_tag SendSystemStatusInformation = {};
	m_stGenCommand.id = SH_DIAG;
	m_stGenCommand.target = ClientPMS;
	m_stGenCommand.length = m_wHeaderLength + 5 * sizeof(ACS_INT)
		+ sizeof(ACS_ENUM) + 3 * sizeof(ACS_DUMMY) + sizeof(ACS_DCOUNT) + DIAG_STRING_LENGTH * sizeof(ACS_STRING) * strlen(strInfor);
	SendSystemStatusInformation.header = m_stGenCommand;

	int nSH_DIAGLength = m_wHeaderLength + 5 * sizeof(ACS_INT) + sizeof(ACS_ENUM) + 3 * sizeof(ACS_DUMMY) + sizeof(ACS_DCOUNT);

	SendSystemStatusInformation.par_2 = 108;
	SendSystemStatusInformation.obj_count = ACS_ONLY_ONE_OBJECT;
	SendSystemStatusInformation.diag_status = nDealStatus;
	SendSystemStatusInformation.identifier = (ACS_INT)nStatusIndex;
	SendSystemStatusInformation.diag_duration = 0;
	SendSystemStatusInformation.lostr_diag = (int)strlen(strInfor);

	ACS_BYTE* pCommand = new ACS_BYTE[m_stGenCommand.length];
	memset(pCommand, 0, m_stGenCommand.length * sizeof(ACS_BYTE));
	memcpy((ACS_BYTE*)pCommand, (ACS_BYTE*)(&SendSystemStatusInformation), nSH_DIAGLength);

	//int unicodeLen = MultiByteToWideChar(CP_ACP, 0, strInfor, -1, NULL, 0);
	//wchar_t* pUnicode;
	//pUnicode = new wchar_t[(unicodeLen + 1) * 2];
	//memset(pUnicode, 0, (unicodeLen + 1) * sizeof(wchar_t) * 2);

	//size_t nUnicodeLenSize = unicodeLen + 1;
	//mbstowcs_s(&nUnicodeLenSize, pUnicode, 200, strInfor, _TRUNCATE);

	sh_diag_t2_tag strDiagInfor = {};
	for (int i = 0; i < (int)strlen(strInfor); i++)
	{
		memset(strDiagInfor.diag_string, 0, DIAG_STRING_LENGTH * sizeof(ACS_STRING));
		strDiagInfor.diag_string[0] = strInfor[i];
		memcpy((ACS_BYTE*)(pCommand + (nSH_DIAGLength + i * sizeof(sh_diag_t2_tag))),
			(ACS_BYTE*)(&strDiagInfor), sizeof(sh_diag_t2_tag));
	}

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)pCommand);
	}//ENDIF

	delete[]pCommand;
	pCommand = NULL;

	//delete[] pUnicode;
	//pUnicode = NULL;

	m_stGenCommand.target = Clienttarget;

	PRINTA_INFO("== SEND == : SH_DIAG: fOrgStatus: %d, strInfor:%s,Length: %d,diag_status:%d\n",
		nStatusIndex, strInfor, m_stGenCommand.length, SendSystemStatusInformation.diag_status);

	std::ostringstream buffer;
	buffer << "nStatusIndex:" << nStatusIndex << "strInfor:" << strInfor <<"diag_status:"<< SendSystemStatusInformation.diag_status;
	string str = buffer.str();
	SendTelegramLog("SH_DIAG", str.c_str(), m_stGenCommand.sender);
	return true;
}

/*********************************************************************************
函数名称：SendIdfrStatus
功能描述：设置当前系统曝光状态到XCU端

修改记录:
2021-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SendIdfrStatus(int nDRStatus, int nRFStatus, int bSaveParm) //2021-04  待完善功能：需要客户端设置 客户端或子系统会根据不同的界面及系统状态进行设置  //202110 STA
{
	if (bSaveParm == 1)
	{
		m_nIdfrstatus = nDRStatus;
	}

	if (m_nScreenSaver >= 1)
	{
		PRINTA_DEBUG("SCreenSave: return IDFRSTATUS(dfraufnbereit: %d, dfrdlbereit:%d)\n", nDRStatus, nRFStatus);
		return true;
	}
	idfrstatus_t1_tag szSendGen = {};
	m_stGenCommand.id = IDFRSTATUS;
	m_stGenCommand.length = m_wHeaderLength + 2 * sizeof(ACS_BYTE);
	szSendGen.dfraufnbereit = nDRStatus;
	szSendGen.dfrdlbereit = nRFStatus;

	if (nDRStatus == 27) //DROC_IQAP_RECEIVED 
	{
		m_stGenCommand.target = ClientPMS;
	}
	else
	{
		//m_stGenCommand.mode = ACS_MODE_DIRECT; //normal
	}

	szSendGen.header = m_stGenCommand;
	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)&szSendGen);
	}//ENDIF

	PRINTA_DEBUG("== SEND == : IDFRSTATUS(dfraufnbereit: %d, dfrdlbereit:%d),mode: %d,target:%x \n", nDRStatus, nRFStatus, m_stGenCommand.mode, m_stGenCommand.target);

	m_stGenCommand.target = Clienttarget;

	std::ostringstream buffer;
	buffer << "dfraufnbereit:" << nDRStatus << "dfrdlbereit:" << nRFStatus;
	string str = buffer.str();
	SendTelegramLog("IDFRSTATUS", str.c_str(), m_stGenCommand.sender);
	return true;
}

/*********************************************************************************
函数名称：SelectORG
功能描述：设置当前UI端选中的view到UI端

修改记录:
2021-04-22 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SelectORG(int nCode, int nParam, int nNeedOGP)  //2021-4-22  待完善功能：需要客户端设置
{
	m_stGenCommand.id = SBEDORG;
	m_stGenCommand.length = m_wHeaderLength + 2 * sizeof(ACS_ENUM) + 2 * sizeof(ACS_INT) + 2 * sizeof(ACS_DUMMY);

	sbedorg_t1_tag szSendGen = {};
	szSendGen.bedeinh = DFR_BEDIENUNG;
	szSendGen.fktscodeorg = (ACS_INT)nCode;
	szSendGen.bedienobj = SELEKTIONSTASTEN;
	szSendGen.param = (ACS_INT)nParam;

	ACS_BYTE* p_ID = new ACS_BYTE[m_stGenCommand.length * 2];
	memset(p_ID, 0, m_stGenCommand.length * sizeof(ACS_BYTE) * 2);
	memcpy(p_ID, &m_stGenCommand, 8);
	memcpy(p_ID + 8, &szSendGen.bedeinh, 1);
	memcpy(p_ID + 9, &szSendGen.bedienobj, 1);
	memcpy(p_ID + 10, &szSendGen.fktscodeorg, 2);
	memcpy(p_ID + 12, &szSendGen.param, 2);

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)p_ID);

		std::ostringstream buffer;
		buffer << "IS: fktscodeorg(code):" << (int)szSendGen.fktscodeorg << ",param:" << (int)szSendGen.param;
		string str = buffer.str();
		SendTelegramLog("SBEDORG", str.c_str(), m_stGenCommand.sender, 0);

	}//ENDIF

	delete[] p_ID;
	p_ID = NULL;

	PRINTA_INFO("== SEND == : SBEDORG | SelectORG(code:%d,param:%d) \n", nCode, nParam /*m_nAPRCommandSynFlag*/);

	m_nSetViewNumber = nParam;
	if (nCode == 451)                    //Siemens要求 设置OGP选择
	{
		if (nNeedOGP == 0)
		{
			PRINTA_INFO("== SelectORG == : Send ORT, don't need back OGP\n");
			return true;
		}
		else if (nNeedOGP == 2)
		{
			/*m_data.m_gen.m_nmSelectOGP = nParam;*/   //待完善功能：需要设置到UI端
			PRINTA_INFO("== SelectORG == : Send ORG,need back OGP,but don't need SelectOGP\n");
			return true;
		}

		if (m_bCalibMode)
		{
			PRINTA_INFO("AutoCalibration mode, No Send No OGP Selected\n");
		}
		else
		{
			SendIdfrStatus(NO_OGP_SELECTED, NO_OGP_SELECTED);
			PRINTA_INFO("No AutoCalibration mode,Send No OGP Selected\n");
		}
		DWORD dwThreadId;
		if (NULL == m_hXCUDataThread)
			m_hOGPWorkThread = CreateThread(NULL, 0, OGPWorkThread, this, 0, &dwThreadId);
		if (m_hOGPWorkThread == NULL)
		{
			PRINTA_DEBUG("Open XCUDataThread Failed\n");
			return false;
		}//ENDIF	
	}

	if ((m_nAPRCommandSynFlag == 0) || (m_nAPRCommandSynFlag == 2))       //Siemens 要求 
	{
		EnterCriticalSection(&m_csStatus);
		m_nAPRCommandSynFlag = 1; //清除当前的变量标识，重新统计
		LeaveCriticalSection(&m_csStatus);

		PRINTA_INFO("SelectORG:: m_nAPRCommandSynFlag++,m_nAPRCommandSynFlag = %d\n", m_nAPRCommandSynFlag);
	}//ENDIF
	return true;
}

/*********************************************************************************
函数名称：OGPWorkThread
功能描述： 等待OGP（VIEW)确认返回线程

修改记录:
2021-04-20 创建
*******************************************************************************/
DWORD nsGEN::SMZDevice::OGPWorkThread(LPVOID pParam)
{
	nsGEN::SMZDevice* pCurOpr = (nsGEN::SMZDevice*)pParam;
	pCurOpr->m_bSelectORG = true;
	if (WaitForSingleObject(pCurOpr->m_hGenSelectOGPEvent, pCurOpr->m_nSelectOGPWaitingTime) == WAIT_OBJECT_0)
	{
		//pCurOpr->m_pGenSiemensSalmon_Mech->Mech::UpdateViewID(pCurOpr->m_nTargetViewNumber); //202110 
		PRINTA_INFO("Get OGP view back, TargetView: %d\n", pCurOpr->m_nTargetViewNumber);

	}
	else
	{
		//pCurOpr->m_pGenSiemensSalmon_Mech->Mech::UpdateViewID(pCurOpr->m_nSetViewNumber + 1); //202110 
		PRINTA_INFO("can't Get OGP view back,direct send view number\n");
	}
	pCurOpr->m_bSelectORG = false;
	return true;
}

/*********************************************************************************
函数名称：WaitForDummyThread
功能描述： 等待Dummy message

修改记录:
2021-04-20 创建
*******************************************************************************/
DWORD nsGEN::SMZDevice::WaitForDummyThread(LPVOID pParam)
{
	nsGEN::SMZDevice* pCurOpr = (nsGEN::SMZDevice*)pParam;
	while (1)
	{
		if (WaitForSingleObject(pCurOpr->m_hDUMMYEvent, 2500/*pCurOpr->m_nSelectOGPWaitingTime*/) == WAIT_OBJECT_0) //20220328 dission with SSME, use the 2500ms for dummy message timeout
		{
			//According to the SSME's message,the dummy message will be send from Axim every 600ms Normally;
			//if (!pCurOpr->m_bIdentStatus)
			{
				//EnterCriticalSection(&pCurOpr->m_csStatus);
				//pCurOpr->m_bIdentStatus = true;
				//pCurOpr->m_bReGetTurnOn = false;
				//LeaveCriticalSection(&pCurOpr->m_csStatus);
				//string code = "0";
				//string info = "";
				//int level = CONNECTIONERROR;
				//pCurOpr->m_MSGUnit->DelErrorMessage(code.c_str(), level, info.c_str());
			}
		}
		else
		{
			PRINTA_ERROR("Get Dummy message timeout\n");
			//if (pCurOpr->m_bIdentStatus)
			{
				//EnterCriticalSection(&pCurOpr->m_csStatus);
				//pCurOpr->m_bIdentStatus = false;
				//pCurOpr->m_bReGetTurnOn = true;
				//LeaveCriticalSection(&pCurOpr->m_csStatus);
				//PRINTA_INFO("WaitForDummyThread: m_bIdentStatus = false，m_bReGetTurnOn = true\n");

				//string code = "LostDummyMessage";
				//string info = "Lost communication to generator,Please reboot the system.";
				//int level = CONNECTIONERROR;
				//pCurOpr->m_MSGUnit->AddErrorMessage(code.c_str(), level, info.c_str());
			}//ENDIF
		}

		if (pCurOpr->m_bExited)
		{
			break;
		}
	}
	return true;
}

/*********************************************************************************
函数名称：WaitForDapThread
功能描述： 等待Dap message

修改记录:
2022-10-11 创建
*******************************************************************************/
DWORD nsGEN::SMZDevice::WaitForDapThread(LPVOID pParam)
{
	nsGEN::SMZDevice* pCurOpr = (nsGEN::SMZDevice*)pParam;
	
	int nWaitForDap = 5000;
	try 
	{
		nWaitForDap = (int)(pCurOpr->m_GenConfig["DAPTimeOut"]);
	}
	catch (...)
	{
		PRINTA_ERROR("Can't get the DAPTimeOut value,default = 5000ms\n");
	}
	if (WaitForSingleObject(pCurOpr->m_hWaitForDapEvent, nWaitForDap) == WAIT_OBJECT_0)
	{
		PRINTA_INFO("WaitForDapThread: Get DAP value");
	}
	else
	{
		PRINTA_ERROR("WaitForDapThread: Get Dap value timeout\n");
		string code = "DapTimeOut";
		string info = "DAP display impaired. Turn off / on system. If error still persists, contact service.";
		int level = MESSAGEBOX_CLEARERROR;
		pCurOpr->m_MSGUnit->AddWarnMessage(code.c_str(), level, info.c_str(), 0xF0);
	}
	return true;
}

RET_STATUS nsGEN::SMZDevice::EnterExam() //202110 对外接口
{
	if (!SelectORG(450, 20))  //must send it to Generator, otherwise, can't enable exposure
	{
		PRINTA_ERROR("Select OGP (450,20) fail\n");
		return RET_STATUS::RET_FAILED;
	}//ENDIF

	if (!m_bInExam)
	{
		SendTUIButtonStatus(BTN_RESTORE_OGP, NORMAL);
	}
	m_bInExam = true;
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SMZDevice::ExitExam() //202110 对外接口
{
	if (m_bInExam)
	{
		SendTUIButtonStatus(BTN_RESTORE_OGP, DIMMED);
		Sleep(200);
		SetPatientStatus(ACS_PAT_CLOSED);
	}
	m_bInExam = false;
	return RET_STATUS::RET_SUCCEED;
}

/*********************************************************************************
函数名称：SendTUIButton
功能描述：设置TUI上Button按钮状态

修改记录:
2021-04-25 创建 （设置病人体型、设置TuiUndo信息）
*******************************************************************************/
bool nsGEN::SMZDevice::SendTUIButtonStatus(int nButtonType, int nStatus)   ////2021-04  待完善功能：需要客户端设置 设置TUI Undo功能
{
	stuibuttons_2_t1_tag PatientSize = {};
	m_stGenCommand.id = STUIBUTTONS_2;
	m_stGenCommand.target = TUI_IFtarget;
	m_stGenCommand.length = m_wHeaderLength + sizeof(ACS_DCOUNT) + 2 * sizeof(ACS_DUMMY) + sizeof(ACS_INT) + sizeof(ACS_ENUM) + sizeof(ACS_BYTE);
	PatientSize.header = m_stGenCommand;
	PatientSize.dummy1 = 0;
	PatientSize.dummy2 = 0;
	PatientSize.no_func = 1;

	ACS_BYTE* p_ID = new ACS_BYTE[m_stGenCommand.length * 2];
	memset(p_ID, 0, m_stGenCommand.length * sizeof(ACS_BYTE) * 2);
	memcpy((ACS_BYTE*)p_ID, (ACS_BYTE*)(&PatientSize), m_wHeaderLength + sizeof(ACS_DCOUNT) + 2 * sizeof(ACS_DUMMY));

	stuibuttons_2_t2_tag TUIButton2 = {};
	TUIButton2.tui_item = nButtonType;
	TUIButton2.item_state = nStatus;

	memcpy((ACS_BYTE*)(p_ID + m_wHeaderLength + sizeof(ACS_DCOUNT) + 2 * sizeof(ACS_DUMMY)),
		(ACS_BYTE*)(&TUIButton2), sizeof(ACS_INT) + sizeof(ACS_ENUM) + sizeof(ACS_BYTE));

	if (m_pAxnClient != NULL)
	{
		Sleep(m_nTUICOMMANDSENDWAITTIME);
		m_pAxnClient->sendObject((ACS_BYTE*)p_ID);

		SendTelegramLog("STUIBUTTONS_2", "", m_stGenCommand.sender);
	}//ENDIF

	m_stGenCommand.target = Clienttarget;

	delete[] p_ID;
	p_ID = NULL;

	PRINTA_INFO("== SEND == : SendTUIButtonStatus: ECOM ButtonType: %d,status: %d\n", nButtonType, nStatus);
	return true;
}

/*********************************************************************************
函数名称：SetPatientStatus
功能描述：进入检查时通知XCU进入检查；退出时，通知XCU退出检查；

修改记录:
2021-04-25 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SetPatientStatus(int nPatientStatus)  //2021-04  待完善功能：需要客户端设置 
{
	sdfrpatwechsel_t1_tag szSendGen = {};
	m_stGenCommand.id = SDFRPATWECHSEL;
	m_stGenCommand.length = m_wHeaderLength + sizeof(ACS_ENUM) + 3 * sizeof(ACS_DUMMY);
	m_stGenCommand.mode = Clientmode;
	m_stGenCommand.sender = Clientsender;
	m_stGenCommand.group_index = Clientgroup_index;
	m_stGenCommand.target = Clienttarget;
	szSendGen.header = m_stGenCommand;
	szSendGen.pat_action = nPatientStatus;

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)&szSendGen);

		std::ostringstream buffer;
		buffer << "IS: pat_action: " << (int)szSendGen.pat_action;
		string str = buffer.str();
		SendTelegramLog("SDFRPATWECHSEL", str.c_str(), m_stGenCommand.sender, 0);
	}

	PRINTA_INFO("== SEND == : SetPatientStatus: PatientStatus:%d\n", nPatientStatus);
	return true;
}

/*********************************************************************************
函数名称：SetVersionInfor
功能描述：设置版本信息
参数描述：
nModuleIndex：
VERSIONINFOR_VISUALIZOR (1)
VERSIONINFOR_PIXRAD	    (2)
VERSIONINFOR_SOFTWARE   (3)

修改记录:
2021-04-25 创建
需要获得报文后继续完善
*******************************************************************************/
bool nsGEN::SMZDevice::SetVersionInfor(const char* strModuleName, const char* strVersionInfor) // 设置版本信息 //202110 SMV
{
	sh_version_check_t1_tag SendVersionInfor = {};
	m_stGenCommand.id = SH_VERSION_CHECK;
	m_stGenCommand.target = ClientPMS;
	m_stGenCommand.length = m_wHeaderLength + sizeof(ACS_ENUM) + 3 * sizeof(ACS_DUMMY) + sizeof(ACS_INT) + sizeof(ACS_BYTE) + sizeof(ACS_DCOUNT)
		+ sizeof(ACS_ENUM) + 3 * sizeof(ACS_DUMMY) + UNIT_ID_LONG_LENGTH * sizeof(ACS_STRING) + VERSION_LONG_LENGTH * sizeof(ACS_STRING);
	SendVersionInfor.header = m_stGenCommand;

	SendVersionInfor.obj_count = -1; //Simenes 要求
	SendVersionInfor.no_versions_long = 1;

	ACS_BYTE* pCommand = new ACS_BYTE[m_stGenCommand.length * 2];
	memset(pCommand, 0, m_stGenCommand.length * sizeof(ACS_BYTE) * 2);
	memcpy((ACS_BYTE*)pCommand, (ACS_BYTE*)(&SendVersionInfor),
		(m_wHeaderLength + 3 * sizeof(ACS_DUMMY) + sizeof(ACS_INT) + sizeof(ACS_BYTE) + sizeof(ACS_DCOUNT)));

	//打包状态信息
	sh_version_check_t2_tag strDiagInfor = {};
	string strTemp = strModuleName;
	int nstrNameLength = (int)strlen(strModuleName);

	//Function code
	if (strTemp.find("_FW") != string::npos) //更改命名规则 20191024
	{
		strDiagInfor.vers_type = ACS_FIRMWARE;
		nstrNameLength = nstrNameLength - 3;
	}
	else
	{
		strDiagInfor.vers_type = ACS_SOFTWARE;
	}
	
	if (nstrNameLength >= UNIT_ID_LONG_LENGTH)
	{
		nstrNameLength = UNIT_ID_LONG_LENGTH;
	}

	memset(strDiagInfor.unit_id_long, 0, UNIT_ID_LONG_LENGTH * sizeof(ACS_STRING));
	for (int j = 0; j < nstrNameLength; j++)
	{
		strDiagInfor.unit_id_long[j] = strModuleName[j];
	}

	memset(strDiagInfor.version_long, 0, VERSION_LONG_LENGTH * sizeof(ACS_STRING));
	int nstrVersionInforLength = (int)strlen(strVersionInfor);

	if (nstrVersionInforLength >= VERSION_LONG_LENGTH)
	{
		nstrVersionInforLength = VERSION_LONG_LENGTH;
	}

	for (int j = 0; j < nstrVersionInforLength; j++)
	{
		strDiagInfor.version_long[j] = strVersionInfor[j];
	}

	memcpy((ACS_BYTE*)(pCommand + (m_wHeaderLength + 3 * sizeof(ACS_DUMMY) + sizeof(ACS_INT) + sizeof(ACS_BYTE) + sizeof(ACS_DCOUNT))),
		(ACS_BYTE*)(&strDiagInfor), sizeof(ACS_ENUM) + 3 * sizeof(ACS_DUMMY) + UNIT_ID_LONG_LENGTH * sizeof(ACS_STRING) + VERSION_LONG_LENGTH * sizeof(ACS_STRING));


	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)pCommand);

		std::ostringstream buffer;
		buffer << "IS: SetVersionInfor: ModuleName: " << strModuleName << ", strDiagInfor.vers_type:" << strDiagInfor.vers_type << ", strDiagInfor.version_long:" << strVersionInfor;
		string str = buffer.str();
		SendTelegramLog("SH_VERSION_CHECK", str.c_str(), m_stGenCommand.sender, 0);
	}//ENDIF

	delete[]pCommand;
	pCommand = NULL;
	m_stGenCommand.target = Clienttarget;

	PRINTA_INFO("== SEND == : SetVersionInfor: ModuleName: %s, NameLength:%d,Vers_type:%d,strVersionInfor:%s,VersionInforLength:%d\n", strModuleName, nstrNameLength, strDiagInfor.vers_type, strVersionInfor, nstrVersionInforLength);
	return true;
}

///*********************************************************************************
//函数名称：SetSH_DATA_TRANS
//功能描述：设置配置文件Backup/Resort状态

//修改记录:Backup
//2021-04-25 创建
//*******************************************************************************/
bool nsGEN::SMZDevice::SetSH_DATA_TRANS(float fResult, int nIdent)   //2021-04  待完善功能：需要客户端设置 //202110 BRM
{
	sh_data_trans_t1_tag SendSH_DATA_TRANS = {};
	m_stGenCommand.id = SH_DATA_TRANS;
	m_stGenCommand.target = ClientPMS;
	m_stGenCommand.length = m_wHeaderLength + 2 * sizeof(ACS_ENUM) + 3 * sizeof(ACS_DUMMY) + sizeof(ACS_DCOUNT) + sizeof(ACS_BYTE);
	SendSH_DATA_TRANS.header = m_stGenCommand;

	SendSH_DATA_TRANS.data_ack = (int)fResult;
	SendSH_DATA_TRANS.data_ident = nIdent;

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)&SendSH_DATA_TRANS);

		std::ostringstream buffer;
		buffer << "IS: SendSH_DATA_TRANS.data_ack: " << SendSH_DATA_TRANS.data_ack << ", SendSH_DATA_TRANS.data_ident:" << SendSH_DATA_TRANS.data_ident;
		string str = buffer.str();
		SendTelegramLog("SH_DATA_TRANS", str.c_str(), m_stGenCommand.sender, 0);
	}//ENDIF

	m_stGenCommand.target = Clienttarget;

	PRINTA_INFO("== SEND == : SetSH_DATA_TRANS: SendSH_DATA_TRANS.data_ack: %d, SendSH_DATA_TRANS.data_ident: %d\n",
		SendSH_DATA_TRANS.data_ack, SendSH_DATA_TRANS.data_ident);
	return true;
}

/*********************************************************************************
函数名称：SetSatetySwitch
功能描述：设置当前工作模式（主要设置到自动校正）

修改记录:
2021-04-22 改进代码风格
*******************************************************************************/
bool nsGEN::SMZDevice::SetSatetySwitch()//TODO: AutoCalibration //202110 校正接口  FPD
{
	st_ss_t1_tag szSendGen = {};
	m_stGenCommandFDC.id = ST_SS;
	m_stGenCommandFDC.length = m_wHeaderLength + 3 * sizeof(ACS_ENUM) + sizeof(ACS_BYTE);
	m_stGenCommandFDC.mode = Clientmode;
	m_stGenCommandFDC.sender = FDC_Controlsender;
	m_stGenCommandFDC.group_index = Clientgroup_index;
	m_stGenCommandFDC.target = Gentarget;
	szSendGen.header = m_stGenCommandFDC;

	szSendGen.sttype = ACS_CHANGE_IMMEDIATELY;
	szSendGen.idx = NULL;
	szSendGen.sw_switch = ACS_ON;
	szSendGen.xray_man_enable = ACS_ENABLE_XRAY;

	ACS_BYTE* sCommmand = new ACS_BYTE[m_stGenCommandFDC.length * 2];
	memset(sCommmand, 0, m_stGenCommandFDC.length * sizeof(ACS_BYTE) * 2);
	memcpy(sCommmand, &m_stGenCommandFDC, 8);
	memcpy(sCommmand + 8, &szSendGen.sttype, sizeof(ACS_ENUM));
	memcpy(sCommmand + 9, &szSendGen.idx, sizeof(ACS_BYTE));
	memcpy(sCommmand + 10, &szSendGen.sw_switch, sizeof(ACS_ENUM));
	memcpy(sCommmand + 11, &szSendGen.xray_man_enable, sizeof(ACS_ENUM));

	if (m_pFDCAxnClient != NULL)
	{
		m_pFDCAxnClient->sendObject(sCommmand);
		std::ostringstream buffer;
		buffer << "IS: szSendGen.sttype: " << szSendGen.sttype << ", szSendGen.sw_switch:" << szSendGen.sw_switch;
		string str = buffer.str();
		SendTelegramLog("ST_SS", str.c_str(), m_stGenCommand.sender, 0);
	}//ENDIF

	delete[] sCommmand;
	sCommmand = NULL;

	PRINTA_INFO("== SEND == : ST_SS,SetSatetySwitch\n");
	return true;
}

/*********************************************************************************
函数名称：SendIDFRABSCHALTUNG
功能描述：通知SCU当前view结束

修改记录:
2021-04-22 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SendIDFRABSCHALTUNG()//TODO: 一张view结束; //202110 for校正接口  FPD
{
	idfrabschaltung_t1_tag szSendGen = {};
	m_stGenCommand.id = IDFRABSCHALTUNG;
	m_stGenCommand.length = m_wHeaderLength + sizeof(ACS_ENUM) + 3 * sizeof(ACS_DUMMY);

	szSendGen.header = m_stGenCommand;
	szSendGen.abschgrund = 1; //Siemens要求

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)&szSendGen);

		SendTelegramLog("IDFRABSCHALTUNG", "", m_stGenCommand.sender, 0);

	}//ENDIF
	PRINTA_INFO("== SEND == : IDFRABSCHALTUNG\n");
	return true;
}

/*********************************************************************************
函数名称：GetSwitchState
功能描述：获取当前工作模式

修改记录:
2021-04-22 创建
*******************************************************************************/
bool nsGEN::SMZDevice::GetSwitchState()//TODO: AutoCalibration 202110 for CAM FPD
{
	rq_object_t1_tag szSendGen = {};
	m_stGenCommandFDC.id = RQ_OBJECT;
	m_stGenCommandFDC.length = m_wHeaderLength + sizeof(ACS_WORD) + sizeof(ACS_DUMMY) + 2 * sizeof(ACS_ENUM) + 3 * sizeof(ACS_BYTE);
	m_stGenCommandFDC.mode = Clientmode;//??
	m_stGenCommandFDC.sender = FDC_Controlsender;
	m_stGenCommandFDC.group_index = Clientgroup_index;//??
	m_stGenCommandFDC.target = Gentarget;

	szSendGen.header = m_stGenCommandFDC;

	szSendGen.object_id = SH_SS;
	szSendGen.send_rj = ACS_NO;
	szSendGen.address_mode = 0;  //Siemens提供默认值
	szSendGen.ap_id = 0xFF;
	szSendGen.version_rqobject = ACS_V_RQOBJECT;
	szSendGen.procedure_id = 0; //Siemens提供默认值
	szSendGen.dummy1 = 0;       //Siemens提供默认值

	ACS_BYTE* sCommmand = new ACS_BYTE[(m_stGenCommandFDC.length + 1) * 2];
	memset(sCommmand, 0, (m_stGenCommandFDC.length + 1) * sizeof(ACS_BYTE) * 2);
	memcpy(sCommmand, &m_stGenCommandFDC, 8);
	memcpy(sCommmand + 8, &szSendGen.object_id, sizeof(ACS_WORD));
	memcpy(sCommmand + 10, &szSendGen.send_rj, sizeof(ACS_ENUM));
	memcpy(sCommmand + 11, &szSendGen.address_mode, sizeof(ACS_ENUM));
	memcpy(sCommmand + 12, &szSendGen.ap_id, sizeof(ACS_BYTE));
	memcpy(sCommmand + 13, &szSendGen.version_rqobject, sizeof(ACS_BYTE));
	memcpy(sCommmand + 14, &szSendGen.procedure_id, sizeof(ACS_BYTE));
	memcpy(sCommmand + 15, &szSendGen.dummy1, sizeof(ACS_DUMMY));

	if (m_pFDCAxnClient != NULL)
	{
		m_pFDCAxnClient->sendObject(sCommmand);

		std::ostringstream buffer;
		buffer << "IS: szSendGen.object_id: " << szSendGen.object_id << ", szSendGen.send_rj:" << szSendGen.send_rj << ", szSendGen.address_mode:"  << szSendGen.address_mode;
		string str = buffer.str();
		SendTelegramLog("RQ_OBJECT", str.c_str(), m_stGenCommand.sender, 0);
	}//ENDIF

	delete[] sCommmand;
	sCommmand = NULL;
	PRINTA_INFO("== SEND == : RQ_OBJECT,GetSwitchState Over\n");
	return true;
}

/*********************************************************************************
函数名称：SetFDErrorCode
功能描述：设置SetFDErrorCode

修改记录:
2021-04-25 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SetFDErrorCode(int nErrorCode, int nErrorType, string& strSN)  //202110 for FPD接口
{
	PRINTA_INFO("SetFDErrorCode\n");

	ifehler2_t1_tag szSendGen = {};
	m_stGenCommand.id = IFEHLER2;
	m_stGenCommand.length = m_wHeaderLength + sizeof(ACS_WORD) + sizeof(ACS_BYTE) + sizeof(ACS_ENUM) + STRARG_LENGTH * sizeof(ACS_STRING) + sizeof(ACS_DUMMY) * 2 + sizeof(ACS_DCOUNT);

	m_stGenCommand.mode = Clientmode;
	m_stGenCommand.sender = Clientsender;
	m_stGenCommand.group_index = Clientgroup_index;
	m_stGenCommand.target = Clienttarget;

	szSendGen.header = m_stGenCommand;
	szSendGen.fehlernummer = nErrorCode;
	szSendGen.category = nErrorType;  //Siemens 要求 WARNUNG  0x01 warning, BEHEB_FEHLER 0x02   error
	szSendGen.no_args = 0; //siemens 要求 20191120

	string strTempSN = strSN.substr(0, min(sizeof(strSN), STRARG_LENGTH));

	for (int j = 0; j < sizeof(strTempSN); j++)
	{
		szSendGen.strarg[j] = strTempSN[j];
	}


	PRINTA_INFO("== SEND == : IFEHLER2 ErrorCode: %d ErrorCategory: %d,SN:%s\n", szSendGen.fehlernummer, szSendGen.category, strTempSN);

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)&szSendGen);

		std::ostringstream buffer;
		buffer << "IS:fehlernummer:" << (int)szSendGen.fehlernummer << ",category:" << (int)szSendGen.category
			<< ", strarg: " << szSendGen.strarg;
		string str = buffer.str();
		SendTelegramLog("IFEHLER2", str.c_str(), m_stGenCommand.sender, 0);
		return true;
	}
	else
	{
		return false;
	}
}

/*********************************************************************************
函数名称：SendPatientSize
功能描述： 设置病人体型到XCU

修改记录:
2021-04-25 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SendPatientSize(int nPatientSize)   //2021-04  待完善功能：需要客户端设置 设置给TUI端 202110 SetStudyInfo
{
	stuibuttons_2_t1_tag PatientSize = {};
	m_stGenCommand.id = STUIBUTTONS_2;
	m_stGenCommand.target = TUI_IFtarget;
	m_stGenCommand.length = m_wHeaderLength + sizeof(ACS_DCOUNT) + 2 * sizeof(ACS_DUMMY) + sizeof(ACS_INT) + sizeof(ACS_ENUM) + sizeof(ACS_BYTE);
	PatientSize.header = m_stGenCommand;
	PatientSize.dummy1 = 0;
	PatientSize.dummy2 = 0;
	PatientSize.no_func = 1;       //默认设置1组病人信息

	ACS_BYTE* p_ID = new ACS_BYTE[m_stGenCommand.length * 2];
	memset(p_ID, 0, m_stGenCommand.length * sizeof(ACS_BYTE) * 2);
	memcpy((ACS_BYTE*)p_ID, (ACS_BYTE*)(&PatientSize), m_wHeaderLength + sizeof(ACS_DCOUNT) + 2 * sizeof(ACS_DUMMY));

	stuibuttons_2_t2_tag PatientSize2 = {};
	PatientSize2.tui_item = BTN_PATIENT_SIZE; //PAT_SIZE_SELECTION;
	PatientSize2.item_state = NORMAL;           // This TUI Button should be normally visible. 
	switch (nPatientSize) //备用 用于转换参数
	{
	case PATIENT_BODYSIZE_CUSTOM:
		PatientSize2.param_8 = PATIENT_FLC_SIZE_CUSTOM;
		break;
	case PATIENT_BODYSIZE_LARGE:
		PatientSize2.param_8 = PATIENT_FLC_SIZE_BIG;
		break;
	case PATIENT_BODYSIZE_MEDIUM:
		PatientSize2.param_8 = PATIENT_FLC_SIZE_MEDIUM;
		break;
	case PATIENT_BODYSIZE_SMALL:
		PatientSize2.param_8 = PATIENT_FLC_SIZE_SMALL;
		break;
	default:
		PatientSize2.param_8 = PATIENT_FLC_SIZE_MEDIUM;
		break;
	}
	memcpy((ACS_BYTE*)(p_ID + m_wHeaderLength + sizeof(ACS_DCOUNT) + 2 * sizeof(ACS_DUMMY)),
		(ACS_BYTE*)(&PatientSize2), sizeof(ACS_INT) + sizeof(ACS_ENUM) + sizeof(ACS_BYTE));

	if (m_pAxnClient != NULL)
	{
		Sleep(m_nTUICOMMANDSENDWAITTIME);
		m_pAxnClient->sendObject((ACS_BYTE*)p_ID);

		std::ostringstream buffer;
		buffer << "IS: PatientSize.no_func: " << PatientSize.no_func << ", PatientSize2.param_8:" << PatientSize2.param_8;
		string str = buffer.str();
		SendTelegramLog("STUIBUTTONS_2", str.c_str(), m_stGenCommand.sender, 0);
	}//ENDIF

	m_stGenCommand.target = Clienttarget;

	delete[] p_ID;
	p_ID = NULL;

	PRINTA_INFO("== SEND == : SendPatientSize: ECOM patientsize: %d,PatientType: %d(150), Patient Size:%d\n", nPatientSize, PatientSize2.tui_item, PatientSize2.param_8);
	return true;
}

/*********************************************************************************
函数名称：SendPatientInfor
功能描述： 设置病人名及病人ID

修改记录:
2021-04-25 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SendPatientInfor(wstring& wstrPatientName, wstring& wstrPatientID) //set Patient Information to XCU //2021-04  待完善功能：需要客户端设置 设置病人名及ID号 202110 SetStudyInfo
{
	int PatientInfoPart1Length = m_wHeaderLength + 3 * sizeof(ACS_DUMMY) + sizeof(ACS_INT) + sizeof(ACS_DCOUNT) + sizeof(ACS_BYTE);
	int PatientInfoPart2Length = sizeof(ACS_ENUM) + sizeof(ACS_DUMMY) + sizeof(ACS_WORD) + DISP_VALUE_LONG_LENGTH * sizeof(ACS_STRING);

	PRINTA_INFO("PatientInfoPart1: %d,PatientInfoPart2:%d\n", PatientInfoPart1Length, PatientInfoPart2Length);

	sh_disp_long_t1 PatientInfoDisplayPart1 = {};
	m_stGenCommand.id = SH_DISP_LONG;
	m_stGenCommand.target = TUItarget;
	m_stGenCommand.mode = 0;
	m_stGenCommand.length = PatientInfoPart1Length + PatientInfoPart2Length * 2;
	PatientInfoDisplayPart1.header = m_stGenCommand;
	PatientInfoDisplayPart1.no_disp_long = 2;//default

	ACS_BYTE* p_ID = new ACS_BYTE[m_stGenCommand.length * 2];
	memset(p_ID, 0, m_stGenCommand.length * sizeof(ACS_BYTE) * 2);
	memcpy((ACS_BYTE*)p_ID, (ACS_BYTE*)(&PatientInfoDisplayPart1),
		PatientInfoPart1Length);

	PRINTA_INFO("Start PatientNameDisplayPart2\n");

	sh_disp_long_t2 PatientInfoDisplayPart2_Name = {};
	PatientInfoDisplayPart2_Name.disp_func = AXCS_DISP_PATIENT_DATA1; //Name
	memset(PatientInfoDisplayPart2_Name.disp_value_long, 0, DISP_VALUE_LONG_LENGTH * sizeof(ACS_STRING));

	int nPatientNameLength = (int)(wstrPatientName.size());
	if (nPatientNameLength > DISP_VALUE_LONG_LENGTH)
	{
		nPatientNameLength = DISP_VALUE_LONG_LENGTH;
	}

	for (int j = 0; j < nPatientNameLength; j++)
	{
		PatientInfoDisplayPart2_Name.disp_value_long[j] = wstrPatientName[j];
	}

	memcpy((ACS_BYTE*)(p_ID + PatientInfoPart1Length),
		(ACS_BYTE*)(&PatientInfoDisplayPart2_Name), PatientInfoPart2Length);
	PRINTA_INFO("end PatientInfoDisplayPart2_Name\n");

	sh_disp_long_t2 PatientInfoDisplayPart2_ID = {};
	PatientInfoDisplayPart2_ID.disp_func = AXCS_DISP_PATIENT_DATA2; //ID
	memset(PatientInfoDisplayPart2_ID.disp_value_long, 0, DISP_VALUE_LONG_LENGTH * sizeof(ACS_STRING));

	int nPatientIDLength = (int)(wstrPatientID.size());
	if (nPatientIDLength > DISP_VALUE_LONG_LENGTH)
	{
		nPatientIDLength = DISP_VALUE_LONG_LENGTH;
	}
	for (int j = 0; j < nPatientIDLength; j++)
	{
		PatientInfoDisplayPart2_ID.disp_value_long[j] = wstrPatientID[j];
	}

	memcpy((ACS_BYTE*)(p_ID + PatientInfoPart1Length + PatientInfoPart2Length),
		(ACS_BYTE*)(&PatientInfoDisplayPart2_ID), PatientInfoPart2Length);

	PRINTA_INFO("end PatientInfoDisplayPart2_ID\n");

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)p_ID);
	}//ENDIF

	m_stGenCommand.target = Clienttarget;
	m_stGenCommand.mode = Clientmode;
	delete[] p_ID;
	p_ID = NULL;
	return true;
}

/*********************************************************************************
函数名称：SendPositionImageName
功能描述： 设置当前选中的View的缩略图名称到TUI

修改记录:
2021-04-25 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SendPositionImageName(string& strPatientPositionImageName)   //2021-04  待完善功能：需要客户端设置
{
	int PatientInfoPart1Length = m_wHeaderLength + 3 * sizeof(ACS_DUMMY) + sizeof(ACS_INT) + sizeof(ACS_DCOUNT) + sizeof(ACS_BYTE);
	int PatientInfoPart2Length = sizeof(ACS_ENUM) + sizeof(ACS_DUMMY) + sizeof(ACS_WORD) + DISP_VALUE_LONG_LENGTH * sizeof(ACS_STRING);

	PRINTA_INFO("PatientInfoPart1: %d,PatientInfoPart2:%d\n", PatientInfoPart1Length, PatientInfoPart2Length);

	sh_disp_long_t1 PatientInfoDisplayPart1 = {};
	m_stGenCommand.id = SH_DISP_LONG;
	m_stGenCommand.target = TUItarget;
	m_stGenCommand.mode = 0;
	m_stGenCommand.length = PatientInfoPart1Length + PatientInfoPart2Length * 2;
	PatientInfoDisplayPart1.header = m_stGenCommand;
	PatientInfoDisplayPart1.no_disp_long = 1;//default

	ACS_BYTE* p_ID = new ACS_BYTE[m_stGenCommand.length * 2];
	memset(p_ID, 0, m_stGenCommand.length * sizeof(ACS_BYTE) * 2);
	memcpy((ACS_BYTE*)p_ID, (ACS_BYTE*)(&PatientInfoDisplayPart1),
		PatientInfoPart1Length);

	//Patient Name
	sh_disp_long_t2 PatientInfoDisplayPart2_Name = {};
	//Function code
	PatientInfoDisplayPart2_Name.disp_func = AXCS_DISP_PATIENT_POS1; //Name
	memset(PatientInfoDisplayPart2_Name.disp_value_long, 0, DISP_VALUE_LONG_LENGTH * sizeof(ACS_STRING));
	int nstrPatientInfoLength = (int)sizeof(strPatientPositionImageName);
	for (int j = 0; j < nstrPatientInfoLength; j++)
	{
		PatientInfoDisplayPart2_Name.disp_value_long[j] = strPatientPositionImageName[j];
	}

	memcpy((ACS_BYTE*)(p_ID + PatientInfoPart1Length),
		(ACS_BYTE*)(&PatientInfoDisplayPart2_Name), PatientInfoPart2Length);

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)p_ID);
		SendTelegramLog("SH_DISP_LONG", "", m_stGenCommand.sender, 0);
	}//ENDIF
	m_stGenCommand.target = Clienttarget;
	m_stGenCommand.mode = Clientmode;

	delete[] p_ID;
	p_ID = NULL;

	PRINTA_INFO("== SEND == : SendPatient Position: name: %s\n", strPatientPositionImageName);
	return true;
}

/*********************************************************************************
函数名称：SendFPDSerialNumber
功能描述： 设置探测器序列号到PMS端

修改记录:
2015-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SendFPDSerialNumber(int nFPDType, const char* strFPDNumber)
{
	int nSiemensWS = -1;
	switch (nFPDType)
	{
	case WS_PARAM_TABLE_ECOM:
		nSiemensWS = ACS_FD_TABLE;
		break;
	case WS_PARAM_WALL_ECOM:
		nSiemensWS = ACS_FD_WALL;
		break;
	case WS_PARAM_FREE_ECOM:
		nSiemensWS = ACS_FD_PORTABLE;
		break;
	case WS_PARAM_FREE1_LARGE_ECOM:
		nSiemensWS = ACS_FD_PORTABLE;
		break;
	case WS_PARAM_FREE2_SMALL_ECOM:
		nSiemensWS = ACS_FD_SMALL_PORTABLE;
		break;
	default:
		nSiemensWS = nFPDType;
		break;
	}

	sh_fdr_data_t1_tag FPDSerialNumber = {};
	m_stGenCommand.id = SH_FDR_DATA;
	m_stGenCommand.target = ClientPMS;
	m_stGenCommand.length = m_wHeaderLength + sizeof(ACS_DCOUNT) + 2 * sizeof(ACS_DUMMY) + sizeof(ACS_INT) + 3 * sizeof(ACS_ENUM) + sizeof(ACS_BYTE) + FDR_PARAM_LENGTH * sizeof(ACS_STRING_8);
	FPDSerialNumber.header = m_stGenCommand;
	FPDSerialNumber.obj_count = -1;       //siemens要求
	if (strFPDNumber == "")
	{
		FPDSerialNumber.fdr_ack = ACS_NOK;
	}
	else
	{
		FPDSerialNumber.fdr_ack = ACS_OK;
	}

	FPDSerialNumber.fdr_rq_index = 1;    //siemens要求
	FPDSerialNumber.detector_plane = nSiemensWS; //VE61X
	FPDSerialNumber.no_fdr_data = 1;    //siemens要求

	ACS_BYTE* pCommand = new ACS_BYTE[m_stGenCommand.length * 2];
	memset(pCommand, 0, m_stGenCommand.length * sizeof(ACS_BYTE) * 2);
	memcpy((ACS_BYTE*)pCommand, (ACS_BYTE*)(&FPDSerialNumber), m_wHeaderLength + sizeof(ACS_DCOUNT) + sizeof(ACS_DUMMY) + sizeof(ACS_INT) + 2 * sizeof(ACS_ENUM) + sizeof(ACS_BYTE));

	if (strFPDNumber != "")
	{
		sh_fdr_data_t2_tag FPDSerialNumber2 = {};
		FPDSerialNumber2.fdr_param_tag = ACS_FDR_SERNUM; // Serial Number VE61X Siemens 确认过
		FPDSerialNumber2.dummy2 = 0; //Serial Number
		memset(FPDSerialNumber2.fdr_param, 0, FDR_PARAM_LENGTH * sizeof(ACS_STRING_8));
		int nstrFPDSerialNumberLength = (int)strlen(strFPDNumber);
		for (int j = 0; j < nstrFPDSerialNumberLength; j++)
		{
			FPDSerialNumber2.fdr_param[j] = strFPDNumber[j];
		}
		memcpy((ACS_BYTE*)(pCommand + m_wHeaderLength + sizeof(ACS_DCOUNT) + sizeof(ACS_DUMMY) + sizeof(ACS_INT) + 2 * sizeof(ACS_ENUM) + sizeof(ACS_BYTE)),
			(ACS_BYTE*)(&FPDSerialNumber2), FDR_PARAM_LENGTH * sizeof(ACS_STRING_8) + sizeof(ACS_ENUM) + sizeof(ACS_DUMMY));
	}
	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)pCommand);

		std::ostringstream buffer;
		buffer << "IS:detector_plane:" << (int)nFPDType << ", FPDSerialNumber:" << strFPDNumber;
		string str = buffer.str();
		SendTelegramLog("SH_FDR_DATA", str.c_str(), m_stGenCommand.sender, 0);
	}//ENDIF
	m_stGenCommand.target = Clienttarget;

	delete[] pCommand;
	pCommand = NULL;

	PRINTA_INFO("== SEND == : SendFPDSerialNumber: Detect Type: %d,SiemensWS: %d,FPDSerialNumber: %s\n", nFPDType, nSiemensWS, strFPDNumber);
	return true;
}

/*********************************************************************************
函数名称：TubeHeatTest
功能描述： 模拟测试球管热容量
对应需求：IS_display_heatunits_test(VERSION_RAD3-VA10)

修改记录:
2021-04-25 创建
*******************************************************************************/
bool nsGEN::SMZDevice::TubeHeatTest(void)
{
	sservtestcmd_t1 szSendGen = {};
	m_stGenCommand.id = SSERVTESTCMD;
	m_stGenCommand.length = m_wHeaderLength + 4 * sizeof(ACS_BYTE) + sizeof(ACS_DUMMY) + sizeof(ACS_DCOUNT);
	m_stGenCommand.mode = Clientmode;
	m_stGenCommand.sender = Clientsender;
	m_stGenCommand.group_index = Clientgroup_index;
	m_stGenCommand.target = Clienttarget;
	szSendGen.header = m_stGenCommand;
	szSendGen.apid = Clienttarget;
	szSendGen.cmdkennung = 5;           //Siemens要求
	szSendGen.anzahldaten = 1;          //Siemens要求

	ACS_BYTE* p_ID = new ACS_BYTE[m_stGenCommand.length * 2];
	memset(p_ID, 0, m_stGenCommand.length * sizeof(ACS_BYTE) * 2);
	memcpy((ACS_BYTE*)p_ID, (ACS_BYTE*)(&szSendGen),
		m_stGenCommand.length - sizeof(ACS_BYTE));

	sservtestcmd_t2 szSendGen2 = {};
	szSendGen2.daten = 0;                           //默认要求

	memcpy((ACS_BYTE*)p_ID + (m_stGenCommand.length - sizeof(ACS_BYTE)), (ACS_BYTE*)(&szSendGen2),
		sizeof(ACS_BYTE));

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)&szSendGen);

		SendTelegramLog("SSERVTESTCMD", "", m_stGenCommand.sender, 0);
	}

	delete[] p_ID;
	p_ID = NULL;

	PRINTA_INFO("== SEND == : TubeHeatTest\n");
	return true;
}

///*********************************************************************************
//函数名称：SetSHCONFIG
//功能描述： 配置文件结果处理,对应ST_CONFIG

//修改记录:
//2021-04-25 创建
//*******************************************************************************/
bool nsGEN::SMZDevice::SetSHCONFIG(float fResult)                                         //2021-04  待完善功能：需要客户端设置 
{
	sh_config_t1_tag SendSHConfig = {};
	m_stGenCommand.id = SH_CONFIG;
	m_stGenCommand.target = ClientPMS;
	m_stGenCommand.length = m_wHeaderLength + sizeof(ACS_ENUM) + 5 * sizeof(ACS_DUMMY) + sizeof(ACS_DCOUNT);
	SendSHConfig.header = m_stGenCommand;


	/* Parameter: cfg_ack (Defines) --------------------------------------------------------------------------------------*/
	/*   ACS_OK      1   the operation is accepted                                                                        */
	/*   ACS_NOK     2   the operation is not accepted                                                                    */
	/*   ACS_NODATA  3   no data available                                                                                */
	/*                                                                                                                    */
	/*####################################################################################################################*/
	SendSHConfig.cfg_ack = (int)fResult;

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)&SendSHConfig);

		std::ostringstream buffer;
		buffer << "IS: SendSHConfig.cfg_ack:" << (int)SendSHConfig.cfg_ack;
		string str = buffer.str();
		SendTelegramLog("SH_CONFIG", str.c_str(), m_stGenCommand.sender, 0);
	}//ENDIF

	m_stGenCommand.target = Clienttarget;

	PRINTA_INFO("== SEND == : SetSHCONFIG: fResult: %f, SendSHConfig.cfg_ack: %d\n", fResult, SendSHConfig.cfg_ack);
	return true;
}

/*********************************************************************************
函数名称：SetPanelRotate
功能描述：设置探测器旋转方向

修改记录:
2021-04-25 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SetPanelRotate(int nPanelRotate) //2021-04  待完善功能：需要客户端设置 
{
	PRINTA_INFO("Set PanelRotate: %d\n", nPanelRotate);

	ibewegung2_t1_tag szSendGen = {};
	m_stGenCommand.id = IBEWEGUNG2;
	m_stGenCommand.length = m_wHeaderLength + sizeof(ACS_DUMMY) * 3 + sizeof(ACS_COUNT) + sizeof(ACS_INT) + sizeof(ACS_BYTE) + sizeof(ACS_ENUM);

	m_stGenCommand.mode = Clientmode;
	m_stGenCommand.sender = Clientsender;
	m_stGenCommand.group_index = Clientgroup_index;
	m_stGenCommand.target = Clienttarget;

	szSendGen.header = m_stGenCommand;
	szSendGen.aktanzahl = 1;

	ibewegung2_t2_tag szSendGen2 = {};
	szSendGen2.antrieb = ACS_DETECTOR_ORIENTATION;
	szSendGen2.antriebstatus = STOP_MIT_ZIELPOSITION;
	szSendGen2.physposition = nPanelRotate;

	ACS_BYTE* p_ID = new ACS_BYTE[m_stGenCommand.length * 2];
	memset(p_ID, 0, m_stGenCommand.length * sizeof(ACS_BYTE) * 2);
	memcpy((ACS_BYTE*)p_ID, (ACS_BYTE*)(&szSendGen), m_wHeaderLength + sizeof(ACS_DUMMY) * 3 + sizeof(ACS_COUNT)); //指令默认长度

	memcpy((ACS_BYTE*)(p_ID + m_wHeaderLength + sizeof(ACS_DUMMY) * 3 + sizeof(ACS_COUNT)), (ACS_BYTE*)(&szSendGen2), sizeof(ACS_INT) + sizeof(ACS_BYTE) + sizeof(ACS_ENUM)); //默认指令长度

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)p_ID);

		std::ostringstream buffer;
		buffer << "IS:aktanzahl: " << (int)szSendGen.aktanzahl << ",physposition: " << (int)szSendGen2.physposition;
		string str = buffer.str();
		SendTelegramLog("IBEWEGUNG2", str.c_str(), m_stGenCommand.sender, 0);
	}
	else
	{
		PRINTA_INFO("IBEWEGUNG2 : m_pAxnClient = null\n");
	}

	delete[] p_ID;
	p_ID = NULL;

	PRINTA_INFO("== SEND == : IBEWEGUNG2\n");
	return TRUE;
}

/*********************************************************************************
函数名称：SetScreenSaver
功能描述：控制锁屏功能（1：锁屏启动；0：锁屏关闭）
对应需求：

修改记录:
2021-4-25 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SetScreenSaver(int nScreenSaver)     //2021-04  待完善功能：需要客户端设置 
{
	if (nScreenSaver >= 1)
	{
		SendIdfrStatus(0, 0, 0);
	}

	m_stGenCommand.id = SBEDALLG;
	m_stGenCommand.length = m_wHeaderLength + 2 * sizeof(ACS_ENUM) + 2 * sizeof(ACS_INT) + 2 * sizeof(ACS_DUMMY);
	m_stGenCommand.mode = Clientmode;
	m_stGenCommand.sender = Clientsender;
	m_stGenCommand.group_index = Clientgroup_index;
	m_stGenCommand.target = Clienttarget;

	sbedallg_t1_tag szSendGen = {};
	szSendGen.bedeinh = GERAETENAHBEDIENUNG;
	szSendGen.bedienobj = EIN_AUS_TASTE;
	szSendGen.fktscodeallg = SCREENSAVER_ON_OFF;

	if (nScreenSaver >= 1)
	{
		szSendGen.param = DRUCKORIENTIERTE_TASTE;
	}
	else
	{
		szSendGen.param = ACS_NO_INFORMATION;
	}
	szSendGen.dummy1 = 0;
	szSendGen.dummy2 = 0;

	szSendGen.header = m_stGenCommand;

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)&szSendGen);

		std::ostringstream buffer;
		buffer << "IS:ScreenSaver param: " << (int)szSendGen.param;
		string str = buffer.str();
		SendTelegramLog("SBEDALLG", str.c_str(), m_stGenCommand.sender, 0);
	}//ENDIF

	PRINTA_INFO("== SEND == : SBEDALLG nScreenSaver: %d,szSendGen.param: %d\n", nScreenSaver,(int)szSendGen.param);

	m_nScreenSaver = nScreenSaver;

	if (nScreenSaver == 0)
	{
		SendIdfrStatus(m_nIdfrstatus, m_nIdfrstatus);
	}

	return true;
}

///*********************************************************************************
//函数名称：GetLastErrorAmount
//功能描述：获取当前的错误数量
//对应需求：

//修改记录:
//2021-4-25 创建
//*******************************************************************************/
bool nsGEN::SMZDevice::GetLastErrorAmount()
{
	m_GenConfig["LastErrorCount"] = m_nErrorCount; 
	m_UIClientUnit.m_ERA->Update(m_nErrorCount);
	FireNotify(m_UIClientUnit.m_ERA->GetKey(), m_UIClientUnit.m_ERA->JSGet());

	ResDataObject config, writecontent;
	writecontent.add("CONFIGURATION", m_GenConfig); 
	writecontent.SaveFile(m_strConfigPath.c_str()); 
	PRINTA_INFO("GetLastErrorAmount: Write the error number: %d,bResult:%d\n", m_nErrorCount);
	return true;
}

///*********************************************************************************
//函数名称：SetST_SYSTEM_STATE
//功能描述：设置ST_SYSTEM_STATE报文

//修改记录:
//2021-07-21 创建
//*******************************************************************************/
bool nsGEN::SMZDevice::SetST_SYSTEM_STATE(int nStatus)  //202110 for 校正时调用 设置系统状态
{
	st_system_state_t1_tag szSendGen = {};
	m_stGenCommand.id = ST_SYSTEM_STATE;
	m_stGenCommand.length = m_wHeaderLength + sizeof(ACS_SET) + sizeof(ACS_ENUM) + sizeof(ACS_BYTE);

	szSendGen.header = m_stGenCommand;
	szSendGen.system_state = nStatus; //Siemens要求

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)&szSendGen);

		std::ostringstream buffer;
		buffer << "IS: szSendGen.system_state:" << (int)szSendGen.system_state;
		string str = buffer.str();
		SendTelegramLog("ST_SYSTEM_STATE", str.c_str(), m_stGenCommand.sender, 0);

	}//ENDIF
	PRINTA_INFO("== SEND == : ST_SYSTEM_STATE: %d\n", nStatus);
	return true;
}

/*********************************************************************************
函数名称：SendOrthoLocalParam
功能描述：设置拼接协议，包括曝光参数及位置信息

修改记录:
2021-4-21 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SendOrthoLocalParam(int nWS, float fKV, float fMA, float fMS, float fMAS, int nFO, int nET, int nAECFieldSel, int nAECFilmSel,
	float fAECDensity, ACS_BYTE nTarget, float fCollimatorWidth, float fCollimatorHeight, float fAECDose, int nFilter,
	int nTubeLoad, int nGridType, int nOrthoType, float fRelativePosition, float fSID, float fBeamAngle, int nOrthoDir, int nPartialCP,
	int nPatientSize, int nOperationMode, int nAlignmentMode, int nTracking, int nSidTracking)
{
	PRINTA_INFO("SendOrthoLocalParam IS:nWS:%d, nFO:%d, nET:%d, fKV:%f, fMA:%f, fMS:%f, fMAS:%f\n",
		nWS, nFO, nET, fKV, fMA, fMS, fMAS);

	st_cp_data_t1_tag szSendGen;
	m_stGenCommand.id = ST_CP_DATA;
	m_stGenCommand.target = nTarget;
	m_stGenCommand.length = m_wHeaderLength + 9 * sizeof(ACS_INT)
		+ 12 * sizeof(ACS_ENUM) + 10 * sizeof(ACS_BYTE) + 2 * sizeof(ACS_LINT) + 2 * sizeof(ACS_WORD) + 2 * sizeof(ACS_DUMMY);
	szSendGen.header = m_stGenCommand;

	//WorkStation
	int nGenWS = 0;
	OrthoWSUI2Gen(nWS, nGenWS); //for ortho, table:0; wall:1

	szSendGen.exp_target = nGenWS;
	szSendGen.strahler = 1; //siemens

	szSendGen.relative_cp_pos_usage = ACS_USE_REL_POS; //Siemens 要求

	szSendGen.partial_cp = nPartialCP;

	//Tech Mode
	nET = TECHMODE_NOAEC_2P; //临时代码 待完善
	switch (nET)
	{
	case TECHMODE_AEC_1P:
		m_DoseUnit.m_Techmode->Update(TECHMODE_AEC_1P);
		szSendGen.technik = _1_PUNKT_TECHNIK;
		break;
	case TECHMODE_AEC_3P:
		m_DoseUnit.m_Techmode->Update(TECHMODE_AEC_3P);
		szSendGen.technik = _1_PUNKT_TECHNIK;
		break;
	case TECHMODE_AEC_1P_REDUCEMA:
		m_DoseUnit.m_Techmode->Update(TECHMODE_AEC_1P_REDUCEMA);
		szSendGen.technik = _1_PUNKT_TECHNIK_RED_STROM;
		break;
	case TECHMODE_NOAEC_2P:
		m_DoseUnit.m_Techmode->Update(TECHMODE_NOAEC_2P);
		szSendGen.technik = _2_PUNKT_TECHNIK;
		break;
	case TECHMODE_NOAEC_3P:
		m_DoseUnit.m_Techmode->Update(TECHMODE_NOAEC_3P);
		szSendGen.technik = _3_PUNKT_TECHNIK;
		break;
	default:
		break;
	}

	FireNotify(AttrKey::TECHMODE, m_DoseUnit.m_Techmode->JSGet());
	int nOperationModeBK = nOperationMode;
	//if ((int)m_SiemensSalmon_Element[CMD_ELEMENT_OPERATIONMODE].fSetValue == OPM_NORMAL)
	{
		if (nWS == WS_CONVENTIONAL)
		{
			nOperationMode = OPM_CASSETTE;
		}
		else
		{
			nOperationMode = OPM_NORMAL;
		}
	}
	//else if ((int)m_SiemensSalmon_Element[CMD_ELEMENT_OPERATIONMODE].fSetValue == OPM_ORTHO)
	//{
	//	nOperationMode = OPM_ORTHO;
	//}
	//else
	//{
	//	nOperationMode = OPM_NORMAL;
	//}

	szSendGen.operation_mode = nOperationMode;
	PRINTA_INFO("SendOrthoLocalParam: WS: %d, Operation mode : %d,Original Operation mode: %d\n", nWS, nOperationMode, nOperationModeBK);
	//return true;

	//kv
	//int nKV = (int)(fKV * 10);
	//int nKvPos = GetFacKvValue(nKV);
	//szSendGen.kv = g_KV_List[nKvPos];
	szSendGen.kv = (int)(fKV * 10);

	//mas
	//int nMAS = (int)(fMAS * 1000);
	//int nMasPos = GetFacmAsValue(nMAS);
	//szSendGen.mas = (int)(g_MAS_List[nMasPos] / 10); //取整
	szSendGen.mas = (int)(fMAS * 100);

	//MS
	if (nET == TECHMODE_NOAEC_3P)
	{
		int nms = (int)(fMS * 1000);
		int nPos = GetFacmSValue(nms);

		PRINTA_INFO("nPos: %d\n", nPos);

		if (nPos < (int)(sizeof(g_MS_List) / sizeof(int)))
		{
			nms = g_MS_List[nPos] / 100;
		}
		else
		{
			nPos = (int)(sizeof(g_MS_List) / sizeof(int)) - 1;
			nms = g_MS_List[nPos] / 100;
		}
		PRINTA_INFO("Set ARP ms: %d\n", nms);
		szSendGen.ms = nms;
	}
	else
	{
		szSendGen.ms = (ACS_LINT)(m_DoseUnit.m_MS->Get() * 10);

	}

	//dose
	int nAECDose = (int)(fAECDose * 100);
	int nAECDosePos = 0;
	nAECDosePos = GetFacAECDoseValue(nAECDose); //for salmon

	if (nWS == WS_CONVENTIONAL)
	{
		switch (nAECFilmSel)
		{
		case GEN_AECFILM_H:
			szSendGen.dosis = GEN_AECFILM_H; //siemens 要求
			break;
		case GEN_AECFILM_U:
			szSendGen.dosis = GEN_AECFILM_U; //siemens 要求
			break;
		case GEN_AECFILM_D:
			szSendGen.dosis = GEN_AECFILM_D; //siemens 要求
			break;
		default:
			szSendGen.dosis = GEN_AECFILM_U; //siemens 要求
			break;
		}
	}
	else
	{
		szSendGen.dosis = g_AECDOSE_List[nAECDosePos] * 10;
	}


	//kv dr
	szSendGen.kvdr = 0; //siemens 要求

	//blackening correction
	szSendGen.schwaerzkorr = (ACS_INT)(fAECDensity * 4);  //density

	//size
	szSendGen.szeit = 1; //siemens 要求

	//曝光曲线
	szSendGen.kennl = 1; //siemens 要求

	//焦点
	if (nFO == FOCUS_SMALL)
	{
		nFO = KLEINER_FOKUS;
	}
	else if (nFO == FOCUS_LARGE)
	{
		nFO = GROSSER_FOKUS;
	}
	else
	{
		nFO = _3_FOKUS;
	}
	szSendGen.fokus = nFO;

	//szSendGen.proz = 80; // tube Load
	szSendGen.proz = nTubeLoad; // tube Load

	//regstop
	szSendGen.regstop = 0; //siemens 要求

	//filteraufn
	switch (nFilter)
	{
	case GEN_FILTER_CU_0:
		szSendGen.filteraufn = Cu_00mm;
		break;
	case GEN_FILTER_CU_1:
		szSendGen.filteraufn = Cu_01mm;
		break;
	case GEN_FILTER_CU_2:
		szSendGen.filteraufn = Cu_02mm;
		break;
	case GEN_FILTER_CU_3:
		szSendGen.filteraufn = Cu_03mm;
		break;
	default:
		szSendGen.filteraufn = Cu_00mm;
		break;
	}

	//Grid number
	szSendGen.grid_requested = SwitchGridFocusECOM2SIEMENSORTHO(nWS, nGridType); //Ortho下 Grid 类型需要进一步提供

	szSendGen.ortho_range_def_method = nOrthoType; //20200410

	if (m_bCalibMode)
	{
		szSendGen.cp_category = CP_FD_CALIB;
	}
	else
	{
		szSendGen.cp_category = CP_NORMAL;
	}


	//height of collimation
	szSendGen.coll_height = (ACS_INT)(fCollimatorHeight * 100); // 0.1mm

	//width of collimation
	szSendGen.coll_width = (ACS_INT)(fCollimatorWidth * 100);  //0.1mm

	szSendGen.auto_zoom = ACS_NO_INFORMATION; //siemens

	//add 映射
	switch (nPatientSize)
	{
	case PATIENT_BODYSIZE_LARGE:
		szSendGen.pat_bmi = PAT_THN_L;
		break;
	case PATIENT_BODYSIZE_MEDIUM:
		szSendGen.pat_bmi = PAT_THN_M;
		break;
	case PATIENT_BODYSIZE_SMALL:
		szSendGen.pat_bmi = PAT_THN_S;
		break;
	case PATIENT_BODYSIZE_CUSTOM:
	default:
		szSendGen.pat_bmi = PAT_THN_M;
		break;
	}

	szSendGen.position_cp = fRelativePosition;

	szSendGen.sid = (int)fSID;

	szSendGen.oblique_beam_angle = fBeamAngle * 100;

	szSendGen.alignment_mode = nAlignmentMode; //siemens
	szSendGen.tracking = nTracking; //siemens
	szSendGen.sid_tracking = nSidTracking; //siemens
	szSendGen.ortho_dir = nOrthoDir;

	int nAECField2Gen = 0;
	switch (nAECFieldSel)
	{
	case FIELD_RIGHT:
		nAECField2Gen = RECHTS;
		break;
	case FIELD_CENTER:
		nAECField2Gen = MITTE;
		break;
	case FIELD_RIGHT_CENTER:
		nAECField2Gen = MITTE_RECHTS;
		break;
	case FIELD_LEFT:
		nAECField2Gen = LINKS;
		break;
	case FIELD_LEFT_RIGHT:
		nAECField2Gen = LINKS_RECHTS;
		break;
	case FIELD_CENTER_LEFT:
		nAECField2Gen = LINKS_MITTE;
		break;
	case FIELD_LEFT_CENTER_RIGHT:
		nAECField2Gen = LINKS_MITTE_RECHTS;
		break;
	default:
		break;
	}

	szSendGen.frate = 0;  //siemens要求 VE61X
	szSendGen.gewmessf = nAECField2Gen;

	szSendGen.xrpt_flrad = 500;
	if ((nET == TECHMODE_NOAEC_3P) && (szSendGen.ms > 500))
	{
		szSendGen.xrpt_flrad = 3200;
	}

	ACS_BYTE* p_ID = new ACS_BYTE[m_stGenCommand.length * 2];
	::memset(p_ID, 0, m_stGenCommand.length * sizeof(ACS_BYTE) * 2);
	::memcpy((ACS_BYTE*)p_ID, (ACS_BYTE*)(&szSendGen), m_stGenCommand.length); //指令默认长度

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)p_ID);
	}
	else
	{
		PRINTA_INFO("== SEND == : m_pAxnClient = NULL");
	}

	delete[] p_ID;
	p_ID = NULL;

	PRINTA_INFO("== SEND == : ST_CP_DATA IS:exp_target: %d,fokus:%d,technik:%d,kv:%d, mas: %d,ms:%d,\
				  	position_cp: %d,alignment_mode: %d, szSendGen.operation_mode: %d,szSendGen.cp_category: %d\n",
		szSendGen.exp_target, szSendGen.fokus, szSendGen.technik, szSendGen.kv, szSendGen.mas, szSendGen.ms,
		szSendGen.position_cp,szSendGen.alignment_mode, szSendGen.operation_mode,szSendGen.cp_category);

	if (nTarget == ClientPMS)
	{
		m_stGenCommand.target = Clienttarget;
	}

	std::ostringstream buffer;
	buffer << "IS:exp_target:" << (int)szSendGen.exp_target << ", fokus:" << (int)szSendGen.fokus
		<< ", technik :" << (int)szSendGen.technik << ", gewmessf(AECFieldSel) : " << (int)szSendGen.gewmessf
		<< ", schwaerzkorr(AECDensity):" << (int)szSendGen.schwaerzkorr << ",kv:" << (int)szSendGen.kv
		<< ",mas:" << (int)szSendGen.mas << ", ms : " << (int)szSendGen.ms << ",filteraufn(Filter):"
		<< (int)szSendGen.filteraufn << ",dosis:" << (int)szSendGen.dosis << ",proz(TubeLoad):" << (int)szSendGen.proz
		<< ", coll_height :" << (int)szSendGen.coll_height << ",coll_width :" << (int)szSendGen.coll_width
		<< ", grid_requested(GridType) :" << (int)szSendGen.grid_requested << ",ortho_range_def_method:" << (int)szSendGen.ortho_range_def_method << ", position_cp: " << szSendGen.position_cp
		<< ", SID :" << (int)szSendGen.sid << ", oblique_beam_angle :" << (int)szSendGen.oblique_beam_angle
		<< ", ortho_dir :" << (int)szSendGen.ortho_dir << ",alignment_mode :" << (int)szSendGen.alignment_mode
		<< ", szSendGen.operation_mode : " << (int)szSendGen.operation_mode << ",pat_bmi:" << (int)szSendGen.pat_bmi
		<< ", tracking:" << (int)szSendGen.tracking << ", sid_tracking:" << (int)szSendGen.sid_tracking
		<< ", sid :" << (int)szSendGen.sid << ", szSendGen.xrpt_flrad :" << (int)szSendGen.xrpt_flrad;
	string str = buffer.str();
	SendTelegramLog("ST_CP_DATA", str.c_str(), m_stGenCommand.sender);
	return true;
}

/*********************************************************************************
函数名称：SendGenData
功能描述：调节参数指令（增加或减少）
对应需求：IS_buttons_kv_mAs_ms(VERSION_RAD3-VA10)

修改记录:
2021-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SendGenData(int interfaceType, int AdjustMode, int nFunctionID, int nGenData, int nUnitChange)  //adjust parameter
{
	sbedgen_t1 szSendGen;
	m_stGenCommand.id = SBEDGEN;
	m_stGenCommand.length = m_wHeaderLength + 2 * sizeof(ACS_ENUM) + 2 * sizeof(ACS_INT) + 2 * sizeof(ACS_DUMMY);
	szSendGen.bedeinh = interfaceType;
	szSendGen.bedienobj = AdjustMode;
	szSendGen.fktscodegen = nFunctionID;
	//szSendGen.param = (ACS_INT)nGenData;

	if (nUnitChange == 1)
	{
		szSendGen.param = (ACS_INT)nGenData / 10;
	}
	else
	{
		szSendGen.param = (ACS_INT)nGenData;
	}

	szSendGen.header = m_stGenCommand;

	ACS_BYTE* sCommmand = new ACS_BYTE[(m_stGenCommand.length + 1) * 2];
	::memset(sCommmand, 0, (m_stGenCommand.length + 1) * sizeof(ACS_BYTE) * 2);
	::memcpy(sCommmand, &m_stGenCommand, 8);
	::memcpy(sCommmand + 8, &szSendGen.bedeinh, 1);
	::memcpy(sCommmand + 9, &szSendGen.bedienobj, 1);
	::memcpy(sCommmand + 10, &szSendGen.fktscodegen, 2);
	::memcpy(sCommmand + 12, &szSendGen.param, 2);

	szSendGen.header = m_stGenCommand;
	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject(sCommmand);

		//std::ostringstream buffer;
		//buffer << "IS: szSendGen.bedeinh:" << (int)szSendGen.bedeinh << ", szSendGen.bedienobj:" << szSendGen.bedienobj << ", szSendGen.fktscodegen" << szSendGen.fktscodegen << ", szSendGen.param:" << szSendGen.param;
		//string str = buffer.str();
		//SendTelegramLog("SBEDGEN", str.c_str(), m_stGenCommand.sender, 0);
	}//ENDIF

	PRINTA_INFO("=== Send GenData == fktscodegen:%d,param:%d\n", nFunctionID, nGenData);

	delete[] sCommmand;
	sCommmand = NULL;

	//==============================================================SBEDGEN2=============================================
	//send SBEDGEN2报文
	sbedgen2_t1 szSendGen2;
	m_stGenCommand.id = SBEDGEN2;
	m_stGenCommand.length = m_wHeaderLength + 2 * sizeof(ACS_ENUM) + sizeof(ACS_INT) + sizeof(ACS_LINT);
	szSendGen2.bedeinh = interfaceType;
	szSendGen2.bedienobj = AdjustMode;
	szSendGen2.fktscodegen = nFunctionID;
	szSendGen2.param_32 = (ACS_LINT)nGenData;
	szSendGen2.header = m_stGenCommand;

	ACS_BYTE* sCommmand2 = new ACS_BYTE[m_stGenCommand.length];
	::memset(sCommmand2, 0, m_stGenCommand.length * sizeof(ACS_BYTE));
	::memcpy(sCommmand2, &m_stGenCommand, 8);
	::memcpy(sCommmand2 + 8, &szSendGen2.bedeinh, 1);
	::memcpy(sCommmand2 + 9, &szSendGen2.bedienobj, 1);
	::memcpy(sCommmand2 + 10, &szSendGen2.fktscodegen, 2);

	szSendGen2.param_32 = (ACS_LINT)nGenData;

	::memcpy(sCommmand2 + 12, &szSendGen2.param_32, sizeof(ACS_LINT));

	szSendGen2.header = m_stGenCommand;
	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject(sCommmand2);
		std::ostringstream buffer;
		buffer << "IS: szSendGen.bedeinh:" << (int)szSendGen2.bedeinh << ", szSendGen.bedienobj:" << szSendGen2.bedienobj << ", szSendGen.fktscodegen" << szSendGen2.fktscodegen << ", szSendGen.param_32:" << szSendGen2.param_32;
		string str = buffer.str();
		SendTelegramLog("SBEDGEN2", str.c_str(), m_stGenCommand.sender, 0);
	}//ENDIF

	PRINTA_INFO("=== Send GenData2 == fktscodegen:%d,param:%d\n", nFunctionID, nGenData);

	delete[] sCommmand2;
	sCommmand2 = NULL;

	return true;
}

/*********************************************************************************
函数名称：SendsBEDSP
功能描述：调节参数指令（对应Dose）
对应需求：IS_buttons_DOSE(VERSION_RAD3-VA10)

修改记录:
2021-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SendsBEDSP(int interfaceType, int AdjustMode, int nFunctionID, int nGenData)  //adjust parameter
{
	sbedsp_t1 szSendGen;
	m_stGenCommand.id = SBEDSP;
	m_stGenCommand.length = m_wHeaderLength + 2 * sizeof(ACS_ENUM) + 2 * sizeof(ACS_INT) + 2 * sizeof(ACS_DUMMY);
	szSendGen.bedeinh = interfaceType;
	szSendGen.bedienobj = AdjustMode;
	szSendGen.fktscodesp = nFunctionID;
	szSendGen.param = (ACS_INT)nGenData;
	szSendGen.header = m_stGenCommand;

	ACS_BYTE* sCommmand = new ACS_BYTE[(m_stGenCommand.length + 1) * 2];
	::memset(sCommmand, 0, (m_stGenCommand.length + 1) * sizeof(ACS_BYTE) * 2);
	::memcpy(sCommmand, &m_stGenCommand, 8);
	::memcpy(sCommmand + 8, &szSendGen.bedeinh, 1);
	::memcpy(sCommmand + 9, &szSendGen.bedienobj, 1);
	::memcpy(sCommmand + 10, &szSendGen.fktscodesp, 2);
	::memcpy(sCommmand + 12, &szSendGen.param, 2);

	szSendGen.header = m_stGenCommand;
	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject(sCommmand);

		std::ostringstream buffer;
		buffer << "IS: szSendGen.bedeinh:" << (int)szSendGen.bedeinh << ", szSendGen.bedienobj:" << szSendGen.bedienobj << ", szSendGen.fktscodesp" << szSendGen.fktscodesp << ", szSendGen.param:" << szSendGen.param;
		string str = buffer.str();
		SendTelegramLog("SBEDSP", str.c_str(), m_stGenCommand.sender, 0);
	}//ENDIF

	PRINTA_INFO("=== Send GenData == fktscodegen:%d,param:%d\n", nFunctionID, nGenData);
	delete[] sCommmand;
	sCommmand = NULL;

	return true;
}

/*********************************************************************************
函数名称：SetFilter
功能描述：设置Filter参数

修改记录:
2021-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SetFilter(int nFilterType)
{
	GetFacFilterValue(nFilterType);

	m_stGenCommand.id = SBEDSTRM;
	m_stGenCommand.length = m_wHeaderLength + 2 * sizeof(ACS_ENUM) + 2 * sizeof(ACS_INT) + 2 * sizeof(ACS_DUMMY);
	m_stGenCommand.mode = Clientmode;
	m_stGenCommand.sender = Clientsender;
	m_stGenCommand.group_index = Clientgroup_index;
	m_stGenCommand.target = Clienttarget;

	sbedstrm_t1_tag szSendGen = {};
	szSendGen.bedeinh = DFR_BEDIENUNG;
	szSendGen.bedienobj = SELEKTIONSTASTEN;

	szSendGen.fktscodestrm = FILTER_EINFAHREN;
	switch (nFilterType)
	{
	case GEN_FILTER_CU_0:
		szSendGen.param = 0; // Cu_00mm;
		break;
	case GEN_FILTER_CU_1:
		szSendGen.param = 1;// Cu_01mm;
		break;
	case GEN_FILTER_CU_2:
		szSendGen.param = 2;// Cu_02mm;
		break;
	case GEN_FILTER_CU_3:
		szSendGen.param = 3;// Cu_03mm;
		break;
	default:
		szSendGen.param = 0;// Cu_00mm;
		break;
	}
	szSendGen.dummy1 = 0;
	szSendGen.dummy2 = 0;

	szSendGen.header = m_stGenCommand;
	//CString strLog = "";
	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)&szSendGen);
		PRINTA_INFO("IS: Filter param: %d\n", szSendGen.param);

		std::ostringstream buffer;
		buffer << "IS: Filter param:" << (int)szSendGen.param;
		string str = buffer.str();
		SendTelegramLog("SBEDSTRM", str.c_str(), m_stGenCommand.sender);
	}//ENDIF
	return true;
}

/*********************************************************************************
函数名称：SetTubeLoad
功能描述：设置TubeLoad参数
对应需求：IS_rad_button_tube_load

修改记录:
2021-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SetTubeLoad(int nTubeLoad)
{
	return SendGenData(DFR_BEDIENUNG, SELEKTIONSTASTEN, ROEHRENAUSLASTUNG, nTubeLoad);
}

/*********************************************************************************
函数名称：GetFacKvValue
功能描述：将设置的KV值映射到当前KV参数列表的位置

修改记录:
2021-04-21 创建
*******************************************************************************/
int nsGEN::SMZDevice::GetFacKvValue(int& nkv)
{
	if (nkv <= 0)
	{
		nkv = g_KV_List[0];
		return 0;
	}//ENDIF
	int nlength = static_cast <int>(g_KV_List.size());
	int nPos = 0;
	int nValue = 0;

	if (nkv <= g_KV_List[0])
	{
		nPos = 0;
	}
	else if (nkv >= g_KV_List[nlength - 1])
	{
		nPos = nlength - 1;
	}//endif
	else
	{
		for (int i = 0; i < nlength; i++)
		{
			if (i == nlength - 1)
			{
				nPos = i;
				break;
			}
			else
			{
				if ((nkv >= g_KV_List[i]) && (nkv < g_KV_List[i + 1]))
				{
					nPos = i;
					break;
				}//ENDIF
			}
		}
	}
	nkv = g_KV_List[nPos];
	return nPos;
}

/*********************************************************************************
函数名称：GetFacmSValue
功能描述：将设置的MS值映射到当前MS参数列表的位置

修改记录:
2021-04-20 创建
*******************************************************************************/
int nsGEN::SMZDevice::GetFacmSValue(int& nms)
{
	if (nms <= 0)
	{
		nms = g_MS_List[0];
		return 0;
	}//ENDIF
	int nlength = static_cast<int> (g_MS_List.size());
	int nPos = 0;
	int nValue = 0;

	if (nms <= g_MS_List[0])
	{
		nPos = 0;
	}
	else if (nms >= g_MS_List[nlength - 1])
	{
		nPos = nlength - 1;
	}
	else
	{
		for (int i = 0; i < nlength; i++)
		{
			if (i == nlength - 1)
			{
				nPos = i;
				break;
			}
			else
			{
				if ((nms >= g_MS_List[i]) && (nms < g_MS_List[i + 1]))
				{
					nPos = i;
					break;
				}//ENDIF
			}//ENDIF
		}
	}

	nms = g_MS_List[nPos];
	return nPos;
}

/*********************************************************************************
函数名称：GetFacmASValue
功能描述：将设置的MAS值映射到当前MAS参数列表的位置

修改记录:
2021-04-20 创建
*******************************************************************************/
int nsGEN::SMZDevice::GetFacmAsValue(int& nmAs)
{
	if (nmAs <= 0)
	{
		nmAs = g_MAS_List[0];
		return 0;
	}//ENDIF
	int nlength = static_cast<int> (g_MAS_List.size());
	int nPos = 0;
	int nValue = 0;

	if (nmAs <= g_MAS_List[0])
	{
		nPos = 0;
	}
	else if (nmAs >= g_MAS_List[nlength - 1])
	{
		nPos = nlength - 1;
	}
	else
	{
		for (int i = 0; i < nlength; i++)
		{
			if (i == nlength - 1)
			{
				nPos = i;
				break;
			}
			else
			{
				if ((nmAs >= g_MAS_List[i]) && (nmAs < g_MAS_List[i + 1]))
				{
					int nmAsMed = (g_MAS_List[i] + g_MAS_List[i + 1]) / 2;
					if (nmAs >= nmAsMed)
					{
						nPos = i + 1;
					}
					else
					{
						nPos = i;
					}
					break;
				}//ENDIF
			}//ENDIF	
		}
	}
	nmAs = g_MAS_List[nPos];
	PRINTA_INFO("Set GetFacmAsValue: nlength: %d, nPos:%d,nmas: %d\n", nlength, nPos, nmAs);
	return nPos;
}

/*********************************************************************************
函数名称：GetFacDensityValue
功能描述：将设置的AECDensity值映射到当前AECDensity参数列表的位置

修改记录:
2021-04-20 创建
*******************************************************************************/
int nsGEN::SMZDevice::GetFacDensityValue(int& nDensity)
{
	int nlength = static_cast<int> (g_AECDensity_List.size());
	int nPos = 0;
	int nValue = 0;

	if (nDensity <= g_AECDensity_List[0])
	{
		nPos = 0;
	}
	else if (nDensity >= g_AECDensity_List[nlength - 1])
	{
		nPos = nlength - 1;
	}
	else
	{
		for (int i = 0; i < nlength; i++)
		{
			if (i == nlength - 1)
			{
				nPos = i;
				break;
			}
			else
			{
				if ((nDensity >= g_AECDensity_List[i]) && (nDensity < g_AECDensity_List[i + 1]))
				{
					nPos = i;
					break;
				}//ENDIF
			}//ENDIF
		}
	}

	nDensity = g_AECDensity_List[nPos];
	return nPos;
}


/*********************************************************************************
函数名称：GetFacAECDoseValue
功能描述：将设置的AECDOSE值映射到当前AECDOSE参数列表的位置
参数内容：实际值*100
修改记录:
2021-04-20 创建
*******************************************************************************/
int nsGEN::SMZDevice::GetFacAECDoseValue(int& nAECDose)
{
	int nlength = static_cast<int> (g_AECDOSE_List.size());
	int nPos = 0;
	int nValue = 0;

	if (nAECDose <= g_AECDOSE_List[0])
	{
		nPos = 0;
	}
	else if (nAECDose >= g_AECDOSE_List[nlength - 1])
	{
		nPos = nlength - 1;
	}
	else
	{
		for (int i = 0; i < nlength; i++)
		{
			if (i == nlength - 1)
			{
				nPos = i;
				break;
			}
			else
			{
				if ((nAECDose >= g_AECDOSE_List[i]) && (nAECDose < g_AECDOSE_List[i + 1]))
				{
					nPos = i;
					break;
				}
			}//ENDIF
		}
	}

	nAECDose = g_AECDOSE_List[nPos];
	return nPos;
}

/*********************************************************************************
函数名称：GetFacFilterValue
功能描述：将设置的Filter值映射到当前Filter参数列表的位置
参数内容：实际值*10
修改记录:
2021-04-20 创建
*******************************************************************************/
int nsGEN::SMZDevice::GetFacFilterValue(int& nFilter)
{
	int nlength = static_cast<int> (g_FILTER_List.size());
	int nPos = 0;
	int nValue = 0;


	if (nFilter <= g_FILTER_List[0])
	{
		nPos = 0;
	}
	else if (nFilter >= g_FILTER_List[nlength - 1])
	{
		nPos = nlength - 1;
	}
	else
	{
		for (int i = 0; i < nlength; i++)
		{
			if (i == nlength - 1)
			{
				nPos = i;
				break;
			}
			else
			{
				if ((nFilter <= g_FILTER_List[i]) && (nFilter < g_FILTER_List[i + 1]))
				{
					nPos = i;
					break;
				}//endif
			}

		}//ENDIF
	}

	nFilter = g_FILTER_List[nPos];
	return nPos;
}

/*********************************************************************************
函数名称：OrthoWSUI2Gen
功能描述：切换workstations从UI到XCU，用于映射对应的workstation值

修改记录:
2021-04-21 创建
*******************************************************************************/
void nsGEN::SMZDevice::OrthoWSUI2Gen(int nUIWS, int& nGenWS)
{
	try
	{
		if (nUIWS == WS_TABLE) //lying: cross mode
		{
			nGenWS = (int)(m_GenConfig["WorkStation"]["OrthoTable"]);
		}
		else if (nUIWS == WS_WALL) //standing mode
		{
			nGenWS = (int)(m_GenConfig["WorkStation"]["OrthoWall"]);
		}
		else if (nUIWS == WS_FREE) //mobile mode
		{
			nGenWS = (int)(m_GenConfig["WorkStation"]["OrthoFree"]);
		}
		else if (nUIWS == WS_TOMO) //tomo mode
		{
			nGenWS = (int)(m_GenConfig["WorkStation"]["OrthoFree"]);
		}
		else if (nUIWS == WS_CONVENTIONAL) //Conventional table
		{
			nGenWS = (int)(m_GenConfig["WorkStation"]["OrthoConventional"]);
		}
		else
		{
			nGenWS = (int)(m_GenConfig["WorkStation"]["OrthoFree"]);
		}
	}
	catch (ResDataObjectExption& exp)
	{
		PRINTA_ERROR("Get configuration failed, %s\n", exp.what());
	}

	PRINTA_INFO("Ortho Set WS: %d,Generator workstaion: %d\n", nUIWS, nGenWS);
}

/*********************************************************************************
函数名称：SwitchGridFocusECOM2SIEMENSORTHO
功能描述：切换workstations从UI到XCU，用于映射对应的workstation值

修改记录:
2021-04-21 创建
*******************************************************************************/
int nsGEN::SMZDevice::SwitchGridFocusECOM2SIEMENSORTHO(int nWS, int nECOMGridType)
{
	int nSiemensGridType = GRID_FOCUS_NOGRID;
	switch (nECOMGridType)
	{
	case GRID_FOCUS_UNIVERSAL:
	{
		if (nWS == WS_TABLE)
		{
			nSiemensGridType = ORTHO_GRID_FOCUS_UNIVERSAL_TABLE_SIEMSN;
		}
		else if (nWS == WS_WALL)
		{
			nSiemensGridType = ORTHO_GRID_FOCUS_UNIVERSAL_WALL_SIEMENS;
		}
		break;
	}
	case GRID_FOCUS_1800:
		if (nWS == WS_TABLE)
		{
			nSiemensGridType = ORTHO_GRID_FOCUS_1800;
		}
		else if (nWS == WS_WALL)
		{
			nSiemensGridType = ORTHO_GRID_FOCUS_1800_WALL_SIEMENS;
		}
		break;
	default:
		nSiemensGridType = nECOMGridType;
		break;
	}

	if ((nWS != WS_TABLE) && (nWS != WS_WALL))
	{
		nSiemensGridType = GRID_FOCUS_NOGRID;            //Siemens要求：在free和casste模式下，不设置Gridtype；
	}
	return nSiemensGridType;
}

/*********************************************************************************
函数名称：TurnOffFDCRequest
功能描述： 确认探测器Turnoff请求

修改记录:
2021-04-25 创建
*******************************************************************************/
void nsGEN::SMZDevice::TurnOffFDCRequest()
{
	if (m_pFDCAxnClient)
	{
		inlist_red_t1 inlistRedObj = {};
		int no_objects_p = 0;
		inlist_red_t2* pinlist_red_t2_p = NULL;

		unsigned int iObjectSize = sizeof(*pinlist_red_t2_p) * no_objects_p;

		inlistRedObj.header.length = (int)(sizeof(inlistRedObj)) + iObjectSize;
		inlistRedObj.header.mode = ACS_MODE_FUNCTIONAL;
		inlistRedObj.header.target = ACS_NO_TARGET;
		inlistRedObj.header.group_index = 0x01;
		inlistRedObj.header.sender = FDC_Controlsender;
		inlistRedObj.header.id = INLIST_RED;

		inlistRedObj.no_objects = (ACS_DCOUNT)no_objects_p;

		// Allocate memory for the data to be sent.
		ACS_BYTE* pDataForSending = new ACS_BYTE[inlistRedObj.header.length * 2];
		if (pDataForSending == NULL)
		{
			//DO NOTHING
		}//ENDIF

		// Copy all objects together in a continous section of memory.
		ACS_BYTE* pCh = pDataForSending;
		memcpy(pCh, &inlistRedObj, sizeof(inlistRedObj));
		pCh += sizeof(inlistRedObj);
		memcpy(pCh, pinlist_red_t2_p, iObjectSize);

		// Send the resulting memory section.
		ACS_ENUM axnResult = CAxnClientIF::sendObjectToServer(pDataForSending);

		// Release memory.
		delete[] pDataForSending;
		pDataForSending = NULL;
		pCh = NULL;

		if (axnResult != ACS_AXN_OK)
		{
			// Error while sending.
		}//ENDIF

		PRINTA_INFO("Turnoff FDC request\n");
	}//ENDIF
}

/*********************************************************************************
函数名称：SendIasuStatus
功能描述：设置当前系统状态到XCU端

修改记录:
2021-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SendIasuStatus(int nDRStatus, int nRFStatus)
{
	iasustatus_t1_tag szSendGen = {};
	m_stGenCommand.id = IASUSTATUS;
	m_stGenCommand.length = m_wHeaderLength + 2 * sizeof(ACS_BYTE) + 2 * sizeof(ACS_DUMMY);
	szSendGen.dfraufnbereit = nDRStatus;
	szSendGen.dfrdlbereit = nDRStatus;
	szSendGen.header = m_stGenCommand;

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)&szSendGen);

		std::ostringstream buffer;
		buffer << "IS: dfraufnbereit: " << (int)szSendGen.dfraufnbereit << ",dfrdlbereit: " << (int)szSendGen.dfrdlbereit;
		string str = buffer.str();
		SendTelegramLog("IASUSTATUS", str.c_str(), m_stGenCommand.sender,0);

	}//ENDIF

	PRINTA_INFO("== SEND == : IASUSTATUS dfraufnbereit: %d, dfrdlbereit:%d\n", nDRStatus, nRFStatus);

	return true;
}

RET_STATUS nsGEN::SMZDevice::SetExpEnable() //202110 对外接口
{
	PRINTA_INFO("SetExpEnable\n");
	if (m_bCalibMode)
	{
		if (m_bGetIGENANZ)
		{
			EnableExposure(1);
			m_bGetIGENANZ = false;
			PRINTA_INFO("SetExpEnable: Set EnableExposure");
		}
		else
		{
			m_bSetEnable = true;
		}
	}
	else
	{
		EnableExposure(1);
	}
	PRINTA_INFO("SetExpEnable: m_bCalibMode: %d, m_bSetEnable: %d, m_bGetIGENANZ: %d\n",(int)m_bCalibMode,(int)m_bSetEnable,(int)m_bGetIGENANZ);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::SetExpDisable() //202110 对外接口
{
	PRINTA_INFO("SetExpDisable\n");
	m_bSetEnable = false;
	if (((int)m_DoseUnit.m_GenState->Get() != (int)AttrKey::GENERATOR_STATUS_ERROR))
	{
		EnableExposure(0);
	}
	else
	{
		PRINTA_INFO("SetExpDisable,the same disable status from Axim,don't send disable status to Axim\n");
	}
	return RET_STATUS::RET_SUCCEED;
}

/*********************************************************************************
函数名称：SendSAUSLBED
功能描述：设置当前工作模式（主要设置到自动校正），手闸按下
对应需求：IS_Service_xrayrelease

修改记录:
2015-04-20 创建
2017-01-04 改进代码风格
*******************************************************************************/
bool nsGEN::SMZDevice::SendSAUSLBED(bool bEnable) //202110 对外接口
{
	if (bEnable)
	{
		PRINTA_INFO("SAUSLBED 0,1,1\n");
	}
	else
	{
		PRINTA_INFO("SAUSLBED 0,0,0\n");
	}
	sauslbed_t1_tag szSendGen = {};
	m_stGenCommandFDC.id = SAUSLBED;
	m_stGenCommandFDC.length = m_wHeaderLength + 3 * sizeof(ACS_ENUM) + sizeof(ACS_BYTE);
	m_stGenCommandFDC.mode = Clientmode;
	m_stGenCommandFDC.sender = FDC_Controlsender;
	m_stGenCommandFDC.group_index = Clientgroup_index;
	m_stGenCommandFDC.target = Clienttarget;
	szSendGen.header = m_stGenCommandFDC;

	szSendGen.bedeinh = SERVICEPC;
	if (bEnable)
	{
		szSendGen.dl = AUS;
		szSendGen.vorbereitung = EIN;//一档
		szSendGen.hk = EIN;//二档
	}
	else
	{
		szSendGen.dl = AUS;
		szSendGen.vorbereitung = AUS;//一档
		szSendGen.hk = AUS;//二档
	}

	ACS_BYTE* sCommmand = new ACS_BYTE[m_stGenCommandFDC.length * 2];
	memset(sCommmand, 0, m_stGenCommandFDC.length * sizeof(ACS_BYTE) * 2);
	memcpy(sCommmand, &m_stGenCommandFDC, 8);
	memcpy(sCommmand + 8, &szSendGen.bedeinh, sizeof(ACS_ENUM));
	memcpy(sCommmand + 9, &szSendGen.dl, sizeof(ACS_BYTE));
	memcpy(sCommmand + 10, &szSendGen.vorbereitung, sizeof(ACS_BYTE));
	memcpy(sCommmand + 11, &szSendGen.hk, sizeof(ACS_BYTE));

	if (m_pFDCAxnClient != NULL)
	{
		m_pFDCAxnClient->sendObject(sCommmand);

		std::ostringstream buffer;
		buffer << "IS:sender: " << (int)m_stGenCommandFDC.sender << ",dl: " << (int)szSendGen.dl
			<< ", vorbereitung: " << (int)szSendGen.vorbereitung << ", hk: " << (int)szSendGen.hk;
		string str = buffer.str();
		SendTelegramLog("SAUSLBED", str.c_str(), m_stGenCommand.sender,0);

	}//ENDIF
	delete[] sCommmand;
	sCommmand = NULL;
	PRINTA_INFO("== SEND == : SAUSLBED in SendSAUSLBED()\n");

	return true;
}

/*********************************************************************************
函数名称：SendIDETEKTORSTATUS
功能描述： 设置探测器Ready状态到XCU

修改记录:
2021-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SendIDETEKTORSTATUS(int nDetectorStatus) //202110 对外接口 开窗
{
	idetektorstatus_t1 szSendGen = {};
	m_stGenCommand.id = IDETEKTORSTATUS;
	m_stGenCommand.length = m_wHeaderLength + sizeof(ACS_BYTE) + 3 * sizeof(ACS_DUMMY);
	m_stGenCommand.mode = Clientmode;
	m_stGenCommand.sender = Clientsender;
	m_stGenCommand.group_index = Clientgroup_index;
	m_stGenCommand.target = Clienttarget;
	szSendGen.detstatus = DET_AUFNAHMEBEREIT;

	szSendGen.header = m_stGenCommand;
	m_FPDGUnit->OnXrayStatus(false);
	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)&szSendGen);
		SendTelegramLog("IDETEKTORSTATUS","", m_stGenCommand.sender);
	}//ENDIF
	PRINTA_INFO("== SEND == : IDETEKTORSTATUS\n");
	return true;
}

/*********************************************************************************
函数名称：SetProgramList
功能描述：设置view到XCU端

修改记录:
2021-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SetProgramList(int nCount, int nOrganIndex, string& OrginName, int nDefaultWS) //202110 对外接口
{
	sprogramlist_t1_tag szSendGen = {};
	m_stGenCommand.id = SPROGRAMLIST;
	m_stGenCommand.length = m_wHeaderLength + sizeof(ACS_INT) + 4 * sizeof(ACS_ENUM) + 2 * sizeof(ACS_WORD) + sizeof(ACS_DCOUNT) + PROGRAM_NAME_LENGTH * sizeof(ACS_STRING); //send one by one
	szSendGen.header = m_stGenCommand;
	szSendGen.obj_count = nOrganIndex; //2015.5.6
	szSendGen.exam_index = EXAM_SET_NRF;
	szSendGen.prog_name_usage = EXAM_SET;
	szSendGen.update_last_selection = ACS_NO_INFORMATION;
	szSendGen.no_prog_name = 1/*nCount*/;//view name

	ACS_BYTE* p_ID = new ACS_BYTE[m_stGenCommand.length * 2];
	memset(p_ID, 0, m_stGenCommand.length * sizeof(ACS_BYTE) * 2);
	memcpy((ACS_BYTE*)p_ID,
		(ACS_BYTE*)(&szSendGen),
		m_wHeaderLength + sizeof(ACS_INT) + 2 * sizeof(ACS_ENUM) + sizeof(ACS_WORD) + sizeof(ACS_DCOUNT));

	int nDefaultWS2TUI = nDefaultWS;
	WSUI2TUI(nDefaultWS, nDefaultWS2TUI);
	sprogramlist_t2_tag szSendGen2 = {};
	szSendGen2.prog_info = nDefaultWS2TUI;
	szSendGen2.prog_executed = ACS_NO;
	szSendGen2.organ_index = abs(nOrganIndex);
	memset(szSendGen2.program_name, 0, PROGRAM_NAME_LENGTH * sizeof(ACS_STRING));
	int nOrginNameLength = (int)sizeof(OrginName);

	wstring wstrOrginName = mb2wc(OrginName.c_str());

	if (nOrginNameLength > PROGRAM_NAME_LENGTH)
	{
		nOrginNameLength = PROGRAM_NAME_LENGTH;
	}

	for (int j = 0; j < nOrginNameLength; j++)
	{
		szSendGen2.program_name[j] = wstrOrginName[j];
	}
	memcpy((ACS_BYTE*)(p_ID + m_wHeaderLength + sizeof(ACS_INT) + 2 * sizeof(ACS_ENUM) + sizeof(ACS_WORD) + sizeof(ACS_DCOUNT)),
		(ACS_BYTE*)(&szSendGen2),
		(2 * sizeof(ACS_ENUM) + sizeof(ACS_WORD) + PROGRAM_NAME_LENGTH * sizeof(ACS_STRING)));

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)p_ID);

		std::ostringstream buffer;
		buffer << "IS:obj_count: " << (int)szSendGen.obj_count << ",prog_info: " << szSendGen2.prog_info
			<< ", organ_index: " << (int)szSendGen2.organ_index << ", OrginName: " << OrginName;
		string str = buffer.str();
		SendTelegramLog("SPROGRAMLIST", str.c_str(), m_stGenCommand.sender,0);
	}//ENDIF
	delete[] p_ID;
	p_ID = NULL;


	PRINTA_INFO("== SEND == : SPROGRAMLIST(count:%d,organ_index:%d,prog_info: %d)\n", nCount, nOrganIndex, nDefaultWS2TUI);

	return true;
}

/*********************************************************************************
函数名称：SetOrgNameStatus
功能描述：设置OrgName状态
对应需求：IS_acim_x_ray_ready_all(VERSION_RAD3-VA10)

修改记录:
2021-04-22 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SetOrgNameStatus(float fOrgStatus) //202110 对外接口 SHO
{
	sh_organ_prog_t1_tag SendOrgNameStatus = {};
	m_stGenCommand.id = SH_ORGAN_PROG;
	m_stGenCommand.target = ClientPMS;
	m_stGenCommand.length = m_wHeaderLength + sizeof(ACS_ENUM) + 3 * sizeof(ACS_DUMMY);
	SendOrgNameStatus.header = m_stGenCommand;
	switch ((int)fOrgStatus)
	{
	case STATUS_NOREADY:
		SendOrgNameStatus.acknowledge = ACS_NOK;
		break;
	case STATUS_READY:
		SendOrgNameStatus.acknowledge = ACS_OK;
		break;
	default:
		break;
	}

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)&SendOrgNameStatus);

		std::ostringstream buffer;
		buffer << "IS: SendOrgNameStatus.acknowledge:" << (int)SendOrgNameStatus.acknowledge;
		string str = buffer.str();
		SendTelegramLog("SH_ORGAN_PROG", str.c_str(), m_stGenCommand.sender, 0);

	}//ENDIF
	m_stGenCommand.target = Clienttarget;
	PRINTA_INFO("== SEND == : SetOrgNameStatus: fOrgStatus: %d, acknowledge:%d\n", (int)fOrgStatus, SendOrgNameStatus.acknowledge);
	return true;
}

/*********************************************************************************
函数名称：EnableExposure
功能描述：接收到DROC允许曝光消息，通知XCU
对应需求：IS_Examination_StopConditions

修改记录:
2021-04-23 创建
*******************************************************************************/
bool nsGEN::SMZDevice::EnableExposure(int nEnable)
{
	PRINTA_INFO("EnableExposureNotice XCU:%d\n", nEnable);
	SendIasuStatus(nEnable, nEnable);
	Sleep(50);
	SendIdfrStatus(nEnable, nEnable);

	//if (nEnable == STATUS_READY)
	//{
	//	SendIasuStatus(JA, JA);
	//	Sleep(50);
	//	SendIdfrStatus(JA, JA);
	//}//ENDIF
	//else
	//{
	//	SendIasuStatus(NEIN, NEIN);
	//	Sleep(50);
	//	SendIdfrStatus(NEIN, NEIN);
	//}
	return true;
}

/*********************************************************************************
函数名称：CallbackTurnOn
功能描述：对TurnOn消息进行反馈处理

修改记录:
2021-4-21 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallbackTurnOn(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null\n");
		return false;
	}//ENDIF

	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	PRINTA_DEBUG("callback Turn on : object_id: %x\n", object_id);

	std::ostringstream buffer;
	buffer << "object_id:" << (int)object_id;
	string str = buffer.str();
	SendTelegramLog("TURN_ON", str.c_str(), object_id);

	//if ((object_id == Clientsender) || (object_id == Clienttarget) || (object_id == FDC_Controlsender))
	//{

	//}

	if (object_id == Clienttarget)
	{
		SendIdent();
		string code = "TurnOff";
		string info = "";
		int level = CONNECTIONERROR;
		m_MSGUnit->DelErrorMessage(code.c_str(), level, info.c_str());
	}//ENDIF

	return true;
}
/*********************************************************************************
函数名称：CallBackTurnOff
功能描述： 解析当前关闭状态信息（turn off message）

修改记录:
2021-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallBackTurnOff(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null\n");
		return false;
	}//ENDIF
	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	PRINTA_DEBUG("callback Trun Off : object_id: %x\n", object_id);

	std::ostringstream buffer;
	buffer << "object_id:" << std::hex << (int)object_id << "h";
	string str = buffer.str();
	SendTelegramLog("TURN_OFF", str.c_str(), object_id);

	string code = "";
	string info = "";
	int level = 0;

	if (object_id == Clienttarget)//XCU
	{
		if (m_bIdentStatus)
		{
			TimeOutWaring();
			EnterCriticalSection(&m_csStatus);
			m_bIdentStatus = false;
			m_bReGetTurnOn = true;
			LeaveCriticalSection(&m_csStatus);
			PRINTA_INFO("callback: Get Client sender, m_bIdentStatus = false，m_bReGetTurnOn = true\n");

			code = "TurnOff";
			info = "Lost communication to generator, Please reboot the system.";
			level = CONNECTIONERROR;
			m_MSGUnit->AddErrorMessage(code.c_str(), level, info.c_str(), 0xF3);
		}//ENDIF
	}//ENDIF
	return true;
}

/*********************************************************************************
函数名称：CallbackGenParam
功能描述： 解析当前系统的曝光参数

修改记录:
2021-04-20 创建
*******************************************************************************/
int nsGEN::SMZDevice::CallbackGenParam(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null\n");
		return 0;
	}//ENDIF

	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_BYTE nET = (ACS_BYTE)(*(stmpBuffer + 8));

	ACS_BYTE nNumberexposurecurve = (ACS_BYTE)(*(stmpBuffer + 9));

	unsigned short* temp;
	temp = (unsigned short*)(stmpBuffer + 10);

	unsigned short wKV = *temp;

	ACS_LINT wMAS = *((ACS_LINT*)(stmpBuffer + 12));
	ACS_LINT wMS = *((ACS_LINT*)(stmpBuffer + 16));
	ACS_BYTE wFO = (ACS_BYTE)(*(stmpBuffer + 20));
	ACS_BYTE wTubeLoad = (ACS_BYTE)(*(stmpBuffer + 21));

	PRINTA_INFO("Received APR Param:kv:%d, MAS:%d,MS:%d,FO:%d,ET:%d,TubeLoad:%d,Numberexposurecurve:%d\n",
		(int)wKV, (int)wMAS, (int)wMS, (int)wFO, (int)nET, (int)wTubeLoad, (int)nNumberexposurecurve);

	std::ostringstream buffer;
	buffer << "Received APR Param:kv:" << (int)wKV << ",MAS :" << (int)wMAS << ",MS:" << (int)wMS << ",FO:" << (int)wFO << ",ET:" << (int)nET << ",TubeLoad:" << (int)wTubeLoad
		<< ",Numberexposurecurve:" << (int)nNumberexposurecurve;
	string str = buffer.str();
	SendTelegramLog("IGENANZ", str.c_str(), object_id);

	//KV 
	m_DoseUnit.m_KV->Update((float)((wKV) / 10.0));
	//FOCUS
	switch (wFO)
	{
	case KLEINER_FOKUS:
		m_DoseUnit.m_Focus->Update(FOCUS_SMALL);
		break;

	case GROSSER_FOKUS:
		m_DoseUnit.m_Focus->Update(FOCUS_LARGE);
		break;

	case _3_FOKUS:
		m_DoseUnit.m_Focus->Update(FOCUS_SMALL);
		break;

	case AUTOFOCUS:
		m_DoseUnit.m_Focus->Update(FOCUS_SMALL);
		break;

	default:
		break;
	}

	//Tech Mode
	switch (nET)
	{
	case _0_PUNKT_TECHNIK:
		break;

	case _1_PUNKT_TECHNIK:
		m_DoseUnit.m_Techmode->Update(TECHMODE_AEC_1P);
		break;

	case _1_PUNKT_TECHNIK_RED_STROM:
		m_DoseUnit.m_Techmode->Update(TECHMODE_AEC_1P_REDUCEMA);
		break;

	case _2_PUNKT_TECHNIK:
		m_DoseUnit.m_Techmode->Update(TECHMODE_NOAEC_2P);
		break;

	case _3_PUNKT_TECHNIK:
		m_DoseUnit.m_Techmode->Update(TECHMODE_NOAEC_3P);
		break;

	case _3_PUNKT_T_MIT_IONT:
		break;

	default:
		break;
	}

	m_DoseUnit.m_MAS->Update((float)((wMAS) / 100.0f));
	m_DoseUnit.m_MS->Update((float)((wMS) / 10.0f));

	if (m_DoseUnit.m_MS->Get() > 0)
	{
		int nMA = (int)((m_DoseUnit.m_MAS->Get() * 1000) / m_DoseUnit.m_MS->Get());
		m_DoseUnit.m_MA->Update((float)nMA);
	}
	else
	{
		m_DoseUnit.m_MA->Update(0);
		m_DoseUnit.m_MS->Update(0);
		PRINTA_INFO("CallbackGenParam: Get MS is not illegality\n");
	}

	FireNotify(m_DoseUnit.m_KV->GetKey(), m_DoseUnit.m_KV->JSGet());
	FireNotify(m_DoseUnit.m_Focus->GetKey(), m_DoseUnit.m_Focus->JSGet());
	FireNotify(m_DoseUnit.m_Techmode->GetKey(), m_DoseUnit.m_Techmode->JSGet());
	FireNotify(m_DoseUnit.m_MAS->GetKey(), m_DoseUnit.m_MAS->JSGet());
	FireNotify(m_DoseUnit.m_MS->GetKey(), m_DoseUnit.m_MS->JSGet());

	m_FPDGUnit->OnAPRms(m_DoseUnit.m_MS->Get());

	if (m_bSetAPR)
	{
		m_bSetAPR = false;
		if (m_bCalibMode)
		{
			if (m_bSetEnable)
			{
				EnableExposure(1);
				m_bSetEnable = false;
				PRINTA_INFO("CallbackIGENANZ: Set EnableExposure");
			}
			else
			{
				m_bGetIGENANZ = true;
			}
		}	
	}
	PRINTA_INFO("IGENANZ: m_bSetAPR:%d,m_bCalibMode: %d, m_bSetEnable: %d, m_bGetIGENANZ: %d\n",
		(int)m_bSetAPR, (int)m_bCalibMode, (int)m_bSetEnable, (int)m_bGetIGENANZ);
	PRINTA_INFO("Processed APR Param m_fKV:%f,m_fMAS: %f, m_fMS: %f, m_nFo: %d,m_nET:%d,wTubeLoad:%d\n",
		m_DoseUnit.m_KV->Get(), m_DoseUnit.m_MAS->Get(), m_DoseUnit.m_MS->Get(),(int)m_DoseUnit.m_Focus->Get(),(int)m_DoseUnit.m_Techmode->Get());
	return 1;

}
/*********************************************************************************
函数名称：CallbackIFILTERANZParam
功能描述： 解析现场的Filter信息

修改记录:
2021-04-21 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallbackIFILTERANZParam(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null\n");
		return false;
	}//ENDIF
	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_BYTE nFilter = (ACS_BYTE)(*(stmpBuffer + 9));
	ACS_BYTE nFilterStatus = (ACS_BYTE)(*(stmpBuffer + 10));

	std::ostringstream buffer;
	buffer << "nFilter:" << (int)nFilter << ",nFilterStatus:" << (int)nFilterStatus;
	string str = buffer.str();
	SendTelegramLog("IFILTERANZ", str.c_str(), object_id);
	return true;
}

/*********************************************************************************
函数名称：CallbackErrorParam
功能描述： 解析错误信息，目前仅用作记录

修改记录:
2021-04-23 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallbackErrorParam(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null\n");
		return false;
	}//ENDIF

	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_BYTE nYear = (*(ACS_BYTE*)(stmpBuffer + 8));
	ACS_BYTE nMonth = (*(ACS_BYTE*)(stmpBuffer + 9));
	ACS_BYTE nDay = (*(ACS_BYTE*)(stmpBuffer + 10));
	ACS_BYTE nHour = (*(ACS_BYTE*)(stmpBuffer + 11));
	ACS_BYTE nMinute = (*(ACS_BYTE*)(stmpBuffer + 12));
	ACS_BYTE nSecond = (*(ACS_BYTE*)(stmpBuffer + 13));
	ACS_BYTE nCentisecond = (*(ACS_BYTE*)(stmpBuffer + 14));
	ACS_DWORD nErrorCode = (*(ACS_DWORD*)(stmpBuffer + 16));
	ACS_BYTE nPID = (*(ACS_BYTE*)(stmpBuffer + 20));
	ACS_ENUM nErrorType = (*(ACS_ENUM*)(stmpBuffer + 21));

	ACS_BYTE nSender = (*(ACS_BYTE*)(stmpBuffer + sizeof(ACS_WORD) + 3 * sizeof(ACS_BYTE)));

	//Error count
	ACS_WORD errcnt = (*(ACS_WORD*)(stmpBuffer + 22 + (FEHLERTEXT2_LENGTH + ADDTEXT2_LENGTH) * sizeof(ACS_STRING)));
	if ((m_nLastErrorCount > errcnt) && (nSender == Clienttarget))
	{
		PRINTA_WARN("Current XCS Error is small than software Error number: LastErrorCount: %d,errcnt:%d\n", m_nLastErrorCount, errcnt);

		if (errcnt == 0)
		{
			m_nLastErrorCount = 0;
		}
		return true;
	}//ENDIF

	if (nSender == Clienttarget)
	{
		m_nErrorCount = errcnt;
	}

	//fehlertext2
	ACS_STRING* tempfehlertext2 = (ACS_STRING*)(pCommand + 22);
	ACS_STRING* strfehlertext2 = new ACS_STRING[(FEHLERTEXT2_LENGTH + 1) * 2];
	memset(strfehlertext2, 0, (FEHLERTEXT2_LENGTH + 1) * sizeof(ACS_STRING) * 2);

	ACS_STRING* tempStrfehlertext2 = strfehlertext2;
	for (int i = 0; i < FEHLERTEXT2_LENGTH; i++, tempStrfehlertext2++, tempfehlertext2++)
	{
		*tempStrfehlertext2 = *(ACS_STRING*)(tempfehlertext2);
	}
	strfehlertext2[FEHLERTEXT2_LENGTH] = '\0';
	string strfehlertext2FromT = wc2mb((const wchar_t*)strfehlertext2);

	//addtext2
	ACS_STRING* tempaddtext2 = (ACS_STRING*)(pCommand + 22 + FEHLERTEXT2_LENGTH * sizeof(ACS_STRING));

	ACS_STRING* straddtext2 = new ACS_STRING[(ADDTEXT2_LENGTH + 1) * 2];
	memset(straddtext2, 0, (ADDTEXT2_LENGTH + 1) * sizeof(ACS_STRING) * 2);

	ACS_STRING* tempStraddtext2 = straddtext2;
	for (int i = 0; i < (ADDTEXT2_LENGTH); i++, tempStraddtext2++, tempaddtext2++)
	{
		*tempStraddtext2 = *(ACS_STRING*)(tempaddtext2);
	}

	straddtext2[ADDTEXT2_LENGTH] = '\0';
	string straddtext2FromT = wc2mb((const wchar_t*)straddtext2);

	PRINTA_WARN("fehlertext2:%s,addtext2:%s\n", strfehlertext2FromT.c_str(), straddtext2FromT.c_str());


	delete[] strfehlertext2;
	strfehlertext2 = NULL;
	tempStrfehlertext2 = NULL;

	delete[] straddtext2;
	straddtext2 = NULL;
	tempStraddtext2 = NULL;

	//string strLogType;
	//strLogType = SwitchCategory2Str(nErrorType);

	//int nLogType;
	//nLogType = SwitchCategory2ECOM(nErrorType);
	int nPosition = string::npos;
	nPosition = strfehlertext2FromT.find("[AUDIT]", 0);
	if ((ClientPMS == nSender)&&(nErrorType == BEDIENEVENT) && (nPosition == 0))
	{
		char strTime[20] = "";
		sprintf_s(strTime, "20%02d%02d%02d%02d%02d%02d%03d", (int)nYear,(int)nMonth,(int)nDay,(int)nHour,(int)nMinute, (int)nSecond, (int)nCentisecond*10);
		AuditMessage(strTime, strfehlertext2FromT.c_str());
	}

	std::ostringstream buffer;
	buffer << "fehlernummer_long:"<< (unsigned long)nErrorCode<<", apid:"<< std::hex << (int)nPID <<"h, category:"<< (int)nErrorType <<"h, fehlertext2:" << strfehlertext2FromT.c_str() << ", addtext2:" << straddtext2FromT.c_str()<<";";
	string str = buffer.str();

	char strErrorCode[20] = "";
	sprintf_s(strErrorCode, "%lu", nErrorCode);

	SendTelegramLog("IERRORLOG2", str.c_str(), nPID,1, SwitchCategory2ECOM(nErrorType), strErrorCode);
	return true;
}

/*********************************************************************************
函数名称：CallbackAufnAusl
功能描述： 解析当前的手闸状态信息

修改记录:
2021-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallbackAufnAusl(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//ENDIF

	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_BYTE vorbereitung = (ACS_BYTE)(*(stmpBuffer + 8));
	ACS_BYTE hauptkontakt = (ACS_BYTE)(*(stmpBuffer + 9));
	ACS_BYTE strahlgbereit = (ACS_BYTE)(*(stmpBuffer + 10));

	ACS_DWORD acq_index = (*(ACS_DWORD*)(pCommand + 12));

	PRINTA_INFO("pre-contact:%d,main-contact:%d,readyExposure:%d, index: %lu\n", vorbereitung, hauptkontakt, strahlgbereit, acq_index);

	std::ostringstream buffer;
	buffer << "pre-contact:" << (int)vorbereitung << ", main-contact:" << (int)hauptkontakt << ", readyExposure:"
		<< (int)strahlgbereit << ",index:" << (int)acq_index;
	string str = buffer.str();
	SendTelegramLog("SAUFNAUSL", str.c_str(), object_id);

	if (vorbereitung == EIN)  //one switch
	{
		if (strahlgbereit == AUS)
		{
			if (m_bExposureStatus)
			{
				PRINTA_INFO("Current status is exposure, omit this command\n");
			}
			else
			{
				//if (m_DoseUnit.m_WS->Get() != WS_CONVENTIONAL)
				{
					m_bExposureStatus = true;
					m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_PREPARE);
					FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
					PRINTA_INFO("<GEN EXP>pre-contact ,prep ok, set GENERATOR_RAD_PREPARE\n");  //one switch
				}
			}
		}
		else if (strahlgbereit == EIN)
		{
			if (hauptkontakt == AUS)
			{
				PRINTA_INFO("<GEN EXP> No main-contact ,prep ok,the generator ready \n");
			}
			else if (hauptkontakt == EIN)
			{
				//if (m_DoseUnit.m_WS->Get() == WS_CONVENTIONAL)
				//{
				//	m_bExposureStatus = true;
				//	m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_PREPARE);
				//	FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
				//	PRINTA_INFO("<GEN EXP>main-contact ,casset mode ,set GENERATOR_RAD_PREPARE\n");  //one switch
				//}
				PRINTA_INFO("<GEN EXP> main-contact,prep ok,the generator ready \n");
			}
		}
		return true;
	}//ENDIF

	if ((hauptkontakt == AUS) && (vorbereitung == AUS) && (strahlgbereit == AUS))  // two switch release
	{
		m_bExposureStatus = false;
		m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_OFF);
		FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
		PRINTA_INFO("<GEN EXP>the generator handswitch release\n");
	}//ENDIF
	return true;

}

/*********************************************************************************
函数名称：CallbackSBILD
功能描述： image display on imaging system, sent from XCU to DFR or camera

修改记录:
2021-04-23 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallbackSBILD(ACS_BYTE* pCommand) //remove this telegram at VE62P
{
	//if (pCommand == NULL)
	//{
	//	PRINTA_INFO("Get command is Null\n");
	//	return false;
	//}//ENDIF
	//ACS_BYTE* stmpBuffer = pCommand;
	//ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	//ACS_ENUM avr_request = (ACS_ENUM)(*(stmpBuffer + 10));
	//if (avr_request == FESTVERSTAERKUNG_1)
	//{
	//	PRINTA_INFO("CallbackSBILD:set patient success\n");
	//}//ENDIF

	//ACS_ENUM nZoom = (ACS_ENUM)(*(stmpBuffer + 11)); 
	//PRINTA_INFO("CallbackSBILD:Format:%d\n", nZoom);

	//std::ostringstream buffer;
	//buffer << "CallbackSBILD:Format:" << (int)nZoom;
	//string str = buffer.str();
	//SendTelegramLog("SBILD", str.c_str(), object_id);

	return true;

}

/*********************************************************************************
函数名称：CallbackSORGANSELECT
功能描述： 解析当前SORGANSELECT报文，当前选中view

修改记录:
2021-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallbackSORGANSELECT(ACS_BYTE* pCommand) 	//20220326 don't get the telegram
{
	sorganselect_t1_tag* SelectCurrentOrg;
	SelectCurrentOrg = (sorganselect_t1_tag*)pCommand;
	m_nCurrentViewNumber = SelectCurrentOrg->alt_index;
	m_nTargetViewNumber = SelectCurrentOrg->organ_index;
	PRINTA_DEBUG("CurrentView:%d,TargetView:%d\n", m_nCurrentViewNumber, m_nTargetViewNumber);
	SendTelegramLog("SORGANSELECT");

	if (m_nTargetViewNumber == 0) //0 means No information
	{
		PRINTA_WARN("Get organ_index = 0, mean No information, return\n");
		return true;
	}
	if (m_bSelectORG)
	{
		Sleep(10); //等待OGPWorkThread线程起来
		SetEvent(m_hGenSelectOGPEvent); //select OGP success; 20160721

		PRINTA_INFO("SORGANSELECT:: m_nAPRCommandSynFlag = %d\n", m_nAPRCommandSynFlag);

		if (m_nAPRCommandSynFlag == 2)
		{
			//202110
			SendOrthoLocalParam(AprParamBackup.nWS,
				AprParamBackup.fKV,
				AprParamBackup.fMA,
				AprParamBackup.fMS,
				AprParamBackup.fMAS,
				AprParamBackup.nFocus,
				AprParamBackup.nTechmode,
				AprParamBackup.nAECField,
				AprParamBackup.nAECFilm,
				AprParamBackup.nAECDensity);

			if (m_bGenService)
			{

				Sleep(50);
				//202110
				SendOrthoLocalParam(AprParamBackup.nWS,
					AprParamBackup.fKV,
					AprParamBackup.fMA,
					AprParamBackup.fMS,
					AprParamBackup.fMAS,
					AprParamBackup.nFocus,
					AprParamBackup.nTechmode,
					AprParamBackup.nAECField,
					AprParamBackup.nAECFilm,
					AprParamBackup.nAECDensity,ClientPMS);
			}//ENDIF

			EnterCriticalSection(&m_csStatus);
			m_nAPRCommandSynFlag = 0;//reset
			LeaveCriticalSection(&m_csStatus);

			PRINTA_INFO("Callback SORGANSELECT,SetAPR,m_nAPRCommandSynFlag = %d\n", m_nAPRCommandSynFlag);
		}
		else if (m_nAPRCommandSynFlag == 1)
		{
			EnterCriticalSection(&m_csStatus);
			m_nAPRCommandSynFlag++;//reset
			LeaveCriticalSection(&m_csStatus);

			PRINTA_INFO("IN SORGANSELECT:: m_nAPRCommandSynFlag++, m_nAPRCommandSynFlag = %d\n", m_nAPRCommandSynFlag);
		}
	}
	else
	{
		PRINTA_INFO("Get select per view command from TUI\n");
	}
	return true;
}

//typedef struct sh_list_t1_tag
//{
//acs_obj_header_t  header;             /* Object-Header */
//ACS_INT           obj_count;          /* number of objects, 1..(n-1), -n (minus = last one) */
//ACS_WORD          ref_object_id;      /* ID of the object to that this list refers (e.g. SH_UI_BSR or SH_UI_XCU) */
//ACS_WORD          sel_func;			/* function to be selected;  all values are defined in an additional include file */
//ACS_WORD          min_list_index;     /* Index (0,...) in the list of the minimum selectable value */
//ACS_WORD          max_list_index;     /* Index (0,...) in the list of the maximum selectable value */
/*********************************************************************************
函数名称：CallBackShowList
功能描述： 解析当前的参数范围信息

修改记录:
2021-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallBackShowList(const ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null\n");
		return false;
	}//ENDIF


	ACS_INT obj_count = 0;
	ACS_WORD temp = 0;

	int nFuncID = 0;
	int ref_object_id = 0xFFFF;
	int nMinPos = 0;
	int nMaxPos = 0;
	int nstrListNumber = 0;
	ACS_BYTE object_id = (*(ACS_BYTE*)(pCommand + 5)); //sender
	obj_count = *(ACS_INT*)(pCommand + 8);

	temp = *(ACS_WORD*)(pCommand + 10);
	ref_object_id = temp;

	temp = *(ACS_WORD*)(pCommand + 12);
	nFuncID = temp;

	temp = *(ACS_WORD*)(pCommand + 14);
	nMinPos = temp;

	temp = *(ACS_WORD*)(pCommand + 16);
	nMaxPos = temp;

	nstrListNumber = *(ACS_DCOUNT*)(pCommand + 16 + sizeof(ACS_WORD) + sizeof(ACS_DUMMY) * 8);

	try {
		PRINTA_INFO("obj_count:%d, ref_object_id:%x, FuncID:%d, MinPos:%d, MaxPos:%d\n", obj_count, ref_object_id, nFuncID, nMinPos, nMaxPos);

		std::ostringstream buffer;
		buffer << "obj_count:" << obj_count << ", ref_object_id :" << ref_object_id << ", FuncID :" << nFuncID << ", MinPos :" << nMinPos << ", MaxPos :" << nMaxPos;
		string str = buffer.str();
		SendTelegramLog("SH_LIST", str.c_str(), object_id);

		//以下单位转换来源于实际报文定义
		switch (nFuncID)
		{
		case AXCS_ACQ_KV:
		{
			if (ref_object_id == 0xFFFF)
			{
				if (g_KV_List.size() < nMinPos)
				{
					m_fKVmin = ((float)(g_KV_List[g_KV_List.size() - 1])) / 10.0f;
					
				}
				else
				{
					m_fKVmin = ((float)(g_KV_List[nMinPos - 1])) / 10.0f;
				}

				if (g_KV_List.size() < nMaxPos)
				{
					m_fKVmax = ((float)(g_KV_List[g_KV_List.size() - 1])) / 10.0f;
				}
				else
				{
					m_fKVmax = ((float)(g_KV_List[nMaxPos - 1])) / 10.0f;
				}

				float* fKV_List = new float[g_KV_List.size() + 1];
				int nLength = 0;
				for (int i = 0; i <= nMaxPos - nMinPos; i++)
				{
					fKV_List[i] = (float)g_KV_List[i + nMinPos-1] / 10.0f;
					nLength++;
				}
				RefreshParameterList("KVList", fKV_List, nLength, m_fKVmax, m_fKVmin);
				delete[] fKV_List;
				PRINTA_INFO("AXCS_ACQ_KV:m_fKVmin:%f,nMinPos:%d,m_fKVmax:%f,nMaxPos:%d,KVvector size:%d\n",m_fKVmin, nMinPos, m_fKVmax, nMaxPos, g_KV_List.size());
			}
			else
			{
				if (abs(obj_count) == 1)
				{
					g_KV_List.clear();
				}
				char* strInfo = new char[(STRING_FIX_LENGTH + 1)];
				for (int i = 0; i < nstrListNumber; i++)
				{
					memset(strInfo, 0, (STRING_FIX_LENGTH + 1) * sizeof(char));

					ACS_STRING* strtemp = (ACS_STRING*)(pCommand + sizeof(sh_list_t1_tag) + i * sizeof(sh_list_t2_tag) + sizeof(ACS_WORD));
					for (int j = 0; j < (STRING_FIX_LENGTH); j++)
					{
						strInfo[j] = strtemp[j];
					}
					float fTemp = atof(strInfo);
					g_KV_List.push_back(fTemp * 10);
				}
				delete[] strInfo;
				strInfo = NULL;

				if (obj_count <= 0)
				{
					m_fKVmax = (float)g_KV_List[nMaxPos - 1] / 10.0f;
					m_fKVmin = (float)g_KV_List[nMinPos - 1] / 10.0f;
					//for (int i = 0; i < nMaxPos; i++)
					//	PRINTA_DEBUG("g_KV_List:%d,sizeof:%d,i: %d\n", g_KV_List[i], g_KV_List.size(), i);

					float* fKV_List = new float[g_KV_List.size() + 1];
					int nLength = 0;
					for (int i = 0; i <= nMaxPos - nMinPos; i++)
					{
						fKV_List[i] = (float)g_KV_List[i] / 10.0f;
						nLength++;
					}
					RefreshParameterList("KVList", fKV_List, nLength, m_fKVmax, m_fKVmin);

					/*for (int i = 0; i < nLength; i++)
					{
						PRINTA_DEBUG("fKV_List:%f,i:%d\n", fKV_List[i], nLength);
					}*/
						

					delete[] fKV_List;
				}
			}
			break;
		}
		case AXCS_ACQ_MAS:
		{
			if (ref_object_id == 0xFFFF)
			{
				if (g_MAS_List.size() < nMinPos)
				{
					m_fMASmin = ((float)(g_MAS_List[g_MAS_List.size() - 1])) / 1000.0f;
				}
				else
				{
					m_fMASmin = ((float)(g_MAS_List[nMinPos - 1])) / 1000.0f;
				}

				if (g_MAS_List.size() < nMaxPos)
				{
					m_fMASmax = ((float)(g_MAS_List[g_MAS_List.size() - 1])) / 1000.0f;
				}
				else
				{
					m_fMASmax = ((float)(g_MAS_List[nMaxPos - 1])) / 1000.0f;
				}

				float* fMAS_List = new float[g_MAS_List.size() + 1];
				int nLength = 0;
				for (int i = 0; i <= nMaxPos - nMinPos; i++)
				{
					fMAS_List[i] = (float)g_MAS_List[i+ nMinPos-1] / 1000.0f;
					nLength++;
				}
				RefreshParameterList("MASList", fMAS_List, nLength, m_fMASmax, m_fMASmin);
				delete[] fMAS_List;
				PRINTA_INFO("AXCS_ACQ_MAS: m_fmAsmin:%f,nMinPos:%d,m_fmAsmax:%f,nMaxPos:%d,MASVector size:%d\n",m_fMASmin, nMinPos, m_fMASmax, nMaxPos, g_MAS_List.size());
			}
			else
			{
				if (abs(obj_count) == 1)
				{
					g_MAS_List.clear();
				}
				char* strInfo = new char[(STRING_FIX_LENGTH + 1)];
				for (int i = 0; i < nstrListNumber; i++)
				{
					memset(strInfo, 0, (STRING_FIX_LENGTH + 1) * sizeof(char));

					ACS_STRING* strtemp = (ACS_STRING*)(pCommand + sizeof(sh_list_t1_tag) + i * sizeof(sh_list_t2_tag) + sizeof(ACS_WORD));
					for (int j = 0; j < (STRING_FIX_LENGTH); j++)
					{
						strInfo[j] = strtemp[j];
					}
					float fTemp = atof(strInfo);
					g_MAS_List.push_back(fTemp * 1000);
				}
				delete[] strInfo;
				strInfo = NULL;

				if (obj_count <= 0)
				{
					m_fMASmax = (float)g_MAS_List[nMaxPos - 1] / 1000.0f;
					m_fMASmin = (float)g_MAS_List[nMinPos - 1] / 1000.0f;
					//for (int i = 0; i < nMaxPos; i++)
					//	PRINTA_DEBUG("g_MAS_List:%d,sizeof:%d,i:%d\n", g_MAS_List[i], g_MAS_List.size(), i);

					float* fMAS_List = new float[g_MAS_List.size() + 1];
					int nLength = 0;
					for (int i = 0; i <= nMaxPos - nMinPos; i++)
					{
						fMAS_List[i] = (float)g_MAS_List[i] / 1000.0f;
						nLength++;
					}

					RefreshParameterList("MASList", fMAS_List, nLength, m_fMASmax, m_fMASmin);

					/*for (int i = 0; i < nLength; i++)
					{
						PRINTA_DEBUG("fMAS_List:%f,i:%d\n", fMAS_List[i], nLength);
					}*/

					delete[] fMAS_List;
				}
			}
			break;
		}
		case AXCS_ACQ_MS:
		{
			if (ref_object_id == 0xFFFF)
			{
				if (g_MS_List.size() < nMinPos)
				{
					m_fMSmin = ((float)(g_MS_List[g_MS_List.size() - 1])) / 1000.0f;
				}
				else
				{
					m_fMSmin = ((float)(g_MS_List[nMinPos - 1])) / 1000.0f;
				}

				if (g_MS_List.size() < nMaxPos)
				{
					m_fMSmax = ((float)(g_MS_List[g_MS_List.size() - 1])) / 1000.0f;
				}
				else
				{
					m_fMSmax = ((float)(g_MS_List[nMaxPos - 1])) / 1000.0f;
				}
				PRINTA_INFO("AXCS_ACQ_MS: m_fmsmin:%f,nMinPos:%d,m_fmsmax:%f,nMaxPos:%d, MsVector size:%d\n",m_fMSmin, nMinPos, m_fMSmax, nMaxPos, g_MS_List.size());
			}
			else
			{
				if (abs(obj_count) == 1)
				{
					g_MS_List.clear();
				}
				char* strInfo = new char[(STRING_FIX_LENGTH + 1)];
				for (int i = 0; i < nstrListNumber; i++)
				{
					memset(strInfo, 0, (STRING_FIX_LENGTH + 1) * sizeof(char));

					ACS_STRING* strtemp = (ACS_STRING*)(pCommand + sizeof(sh_list_t1_tag) + i * sizeof(sh_list_t2_tag) + sizeof(ACS_WORD));
					for (int j = 0; j < (STRING_FIX_LENGTH); j++)
					{
						strInfo[j] = strtemp[j];
					}
					float fTemp = atof(strInfo);
					g_MS_List.push_back(fTemp * 1000);
				}
				delete[] strInfo;
				strInfo = NULL;

				/*if (obj_count <= 0)
				{
					for (int i = 0; i < nMaxPos; i++)
						PRINTA_DEBUG("g_MS_List:%d,sizeof:%d,i:%d\n", g_MS_List[i], g_MS_List.size(), i);
				}*/
			}
			break;
		}
		default:
			PRINTA_INFO("obj_count: %d,nFuncID :%d,nMinPos:%d,nMaxPos:%d\n",
				obj_count, nFuncID, nMinPos, nMaxPos);
			break;
		}
	}
	catch (...)
	{
		PRINTA_ERROR("Crash CallBackShowList log\n");
	}
	return true;
}

//Description: this function presents how to get the AEC field and film from telegrams.
/*********************************************************************************
函数名称：CallbackGetField
功能描述： 解析AEC Field信息

修改记录:
2021-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallbackGetField(const ACS_BYTE* pCommand)
{
	return true;
}

//Description: this function presents how to get the post exposure parameters from telegrams.
//ACS_INT          kvist;                   /* Actual voltage of fluoroscopy or exposure, told by generator */
//ACS_LINT         masist;                  /* mAs value of last exposure */
//ACS_LINT         msist;                   /* duration of last exposure */
/*********************************************************************************
函数名称：CallbackPostGenParam
功能描述： 解析曝光Post参数

修改记录:
2021-04-20 创建
*******************************************************************************/
int nsGEN::SMZDevice::CallbackPostGenParam(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return 0;
	}//ENDIF
	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	int nTempMAS = (*(long*)(stmpBuffer + 8));
	int nTempMS = (*(long*)(stmpBuffer + 12));
	int nTempKV = (*(short*)(stmpBuffer + 16));

	ACS_DWORD acq_index = (*(ACS_DWORD*)(pCommand + 8 + sizeof(ACS_LINT) * 2 + 3 * sizeof(ACS_DUMMY) + sizeof(ACS_INT) + 3 * sizeof(ACS_BYTE)));

	PRINTA_INFO("== IN ==: CallbackPostGenParam begin kv:%d,wMAS: %d, wMS: %d\n", nTempKV, nTempMAS, nTempMS);

	//KV
	m_DoseUnit.m_PostKV->Update((float)((nTempKV) / 10.0));
	FireNotify(m_DoseUnit.m_PostKV->GetKey(), m_DoseUnit.m_PostKV->JSGet());

	//MAS
	m_DoseUnit.m_PostMAS->Update((float)((nTempMAS) / 100.0));
	FireNotify(m_DoseUnit.m_PostMAS->GetKey(), m_DoseUnit.m_PostMAS->JSGet());

	//MS
	m_DoseUnit.m_PostMS->Update((float)((nTempMS) / 10.0));
	FireNotify(m_DoseUnit.m_PostMS->GetKey(), m_DoseUnit.m_PostMS->JSGet());

	//MA
	if (m_DoseUnit.m_PostMS->Get() > 0)
	{
		m_DoseUnit.m_PostMA->Update(m_DoseUnit.m_PostMAS->Get() * 1000.0/m_DoseUnit.m_PostMS->Get());
		FireNotify(m_DoseUnit.m_PostMA->GetKey(), m_DoseUnit.m_PostMA->JSGet());
	}
	else
	{
		m_DoseUnit.m_PostMA->Update(0);
		FireNotify(m_DoseUnit.m_PostMA->GetKey(), m_DoseUnit.m_PostMA->JSGet());

		m_DoseUnit.m_PostMS->Update(0);
		FireNotify(m_DoseUnit.m_PostMS->GetKey(), m_DoseUnit.m_PostMS->JSGet());
		PRINTA_INFO("Get PostMS is less than 0\n");
	}


	PRINTA_INFO("== IN ==: CallbackPostGenParam PostKV:%f,PostMAS: %f, PostMS: %f, PostMA: %f\n", m_DoseUnit.m_PostKV->Get(), m_DoseUnit.m_PostMAS->Get(), m_DoseUnit.m_PostMS->Get(), m_DoseUnit.m_PostMA->Get());

	std::ostringstream buffer;
	buffer << "kv:" << nTempKV << ",MAS:" << nTempMAS << ",MS:"
		<< nTempMS << ",index:" << (int)acq_index;
	string str = buffer.str();
	SendTelegramLog("INACHANZ", str.c_str(), object_id);
	return 1;
}

//Description: this function presents how to get the information message from telegrams.
/*********************************************************************************
函数名称：CallBackIdrallganz2
功能描述： 解析错误信息，并发给UI进行显示 无CodeID，只有内容

修改记录:
2021-04-23 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallBackIdrallganz2(const ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//ENDIF
	ACS_BYTE object_id = (*(ACS_BYTE*)(pCommand + 5)); //sender
	ACS_ENUM nFunction = (ACS_ENUM)(*(pCommand + 8));
	ACS_BYTE nCommand = *((ACS_BYTE*)(pCommand + 9));
	ACS_BYTE ndisp_style = *((ACS_BYTE*)(pCommand + 12));

	ACS_STRING* temp = (ACS_STRING*)(pCommand + 16);

	ACS_STRING* strInfo = new ACS_STRING[(TEXT_LENGTH + 1) * 2];  //记录日志信息
	if (strInfo != NULL)
	{
		memset(strInfo, 0, (TEXT_LENGTH + 1) * sizeof(ACS_STRING) * 2);
	}
	else
	{
		return false;
	}


	ACS_STRING* tempStr = strInfo;
	for (int i = 0; i < TEXT_LENGTH; i++, tempStr++, temp++)
	{
		*tempStr = *(ACS_STRING*)(temp);
	}

	strInfo[TEXT_LENGTH] = '\0';
	string strInfoDisplayFromT = wc2mb((const wchar_t*)strInfo);

	PRINTA_INFO("CallBackIDFRALLGANZ2: %s\n", strInfoDisplayFromT.c_str());

	string code = "Info";
	int level = AUTOCLEARERROR;
	if (nCommand == ACS_SET_DISPLAY)
	{
		m_MSGUnit->AddWarnMessage(code.c_str(), level, strInfoDisplayFromT.c_str(), object_id); //将消息显示到界面
	}
	else if (nCommand == ACS_CLEAR_DISPLAY)
	{
		m_MSGUnit->DelWarnMessage(code.c_str(), level, strInfoDisplayFromT.c_str()); //清除界面消息
	}
	
	delete[] strInfo;
	strInfo = NULL;

	std::ostringstream buffer;
	buffer << "FunctionID:" << (int)nFunction << ", nCommand:" << (int)nCommand << ", ndisp_style:"
		<< (int)ndisp_style << ", Content:" << strInfoDisplayFromT.c_str();
	string str = buffer.str();
	SendTelegramLog("IDFRALLGANZ2", str.c_str(), object_id);
	return true;
}

//Description: this function presents how to get the error message from telegrams.
/*********************************************************************************
函数名称：CallBackIfehleranz2
功能描述： 获取当前的错误信息，并发给UI进行显示

修改记录:
2021-04-23 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallBackIfehleranz2(const ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//ENDIF
	ACS_BYTE object_id = (*(ACS_BYTE*)(pCommand + 5)); //sender
	ACS_DWORD nFunction = (*(ACS_DWORD*)(pCommand + 8));
	ACS_BYTE apid = *((ACS_BYTE*)(pCommand + 12));
	ACS_ENUM category = *((ACS_ENUM*)(pCommand + 13)); //属性

	//string strAPid = "";   //2021-04 待完善功能：需要设置到UI端
	char strAPid[50] = "";
	sprintf_s(strAPid, "%d", apid);

	char strSiemensCode[50] = "";
	sprintf_s(strSiemensCode, "%lu", nFunction);

	ACS_STRING* temp = (ACS_STRING*)(pCommand + 14);
	ACS_STRING* strInfo = new ACS_STRING[(FEHLERTEXT2_LENGTH + 1) * 2];
	memset(strInfo, 0, (FEHLERTEXT2_LENGTH + 1) * sizeof(ACS_STRING) * 2);

	ACS_STRING* tempStr = strInfo;
	for (int i = 0; i < FEHLERTEXT2_LENGTH; i++, tempStr++, temp++)
	{
		*tempStr = *(ACS_STRING*)(temp);
	}

	strInfo[FEHLERTEXT2_LENGTH] = '\0';

	const string strDisplayError = wc2mb((const wchar_t*)strInfo);
	//PRINTA_INFO(strDisplayError.c_str());

	//按照SSME要求，增加code和ID码 仅对应0x02\0x03\0x04
	char strTemp[50] = "";
	sprintf_s(strTemp, "%lu/%d: ", nFunction, apid); //Error 为英文 Siemens要求  //2021-04 待完善功能：需要设置到UI端
	string strDisplayErrorTemp = strTemp + strDisplayError;
	//end

	/*string strLogType = "";
	strLogType = SwitchCategory2Str(category);*/

	std::ostringstream buffer;
	buffer << "FunctionID:" << (unsigned long)nFunction << ", apid:" << std::hex << (int)apid << "h, category:"
		<< (int)category << "h, Content:" << strDisplayError.c_str();
	string str = buffer.str();
	/*SendTelegramLog("IFEHLERANZ2", str.c_str(), 1, strLogType.c_str());*/
	SendTelegramLog("IFEHLERANZ2", str.c_str(), object_id,1, SwitchCategory2ECOM(category));

	PRINTA_INFO("CallBackIfehleranz2: %s,category:%x, objectID: %x\n", strDisplayErrorTemp.c_str(), category,object_id);

	if (nFunction == 0)
	{
		if (strDisplayError.empty())
		{
			PRINTA_INFO("CallBackIfehleranz2: Get SiemensCode:%s, and FEHLERTEXT2 is empty, direct return;\n", strSiemensCode);
			delete[] strInfo;
			return true;
		}
		else
		{
			sprintf_s(strSiemensCode, "%s", "FFFFFFFF"); //将code = 0转化为不可能提供的ID，设置到客户端,规避客户端对code为0 时全清错误消息的情况；
			PRINTA_INFO("CallBackIfehleranz2: Get fehlernummer_long: %lu,switch 0 to SiemensCode:%s, and FEHLERTEXT2 is not empty;\n", nFunction,strSiemensCode);
		}

	}

	//string code = "0";
	string info = "";
	int level = 0;

	//#define CONNECTIONERROR 1
	//#define UNCLEARERROR 2
	//#define CLEARERROR 3
	//#define AUTOCLEARERROR 4

	switch (category)
	{
	case MSGBOX_NO_OK_NO_TUI:
	case ORTHOMESSAGE: //Notify
		//level = CLEARERROR;
		//m_MSGUnit->AddWarnMessage(strSiemensCode, level, strDisplayErrorTemp.c_str(), object_id);
		break;
	case USERMESSAGE: //WarnMessage
		level = CLEARERROR;
		m_MSGUnit->AddWarnMessage(strSiemensCode, level, strDisplayErrorTemp.c_str(), apid);
		break;
	case RESET_USERMSG_LEGACY:
	case TELEGRAM:
	case ACS_FLAG_RESET: //InfoMessage
		//level = CLEARERROR;
		//m_MSGUnit->AddWarnMessage(strSiemensCode, level, strDisplayErrorTemp.c_str(), object_id);
		break;
	case WARNUNG: //WarnMessage
		//level = CLEARERROR;
		//m_MSGUnit->AddWarnMessage(strSiemensCode, level, strDisplayErrorTemp.c_str(), object_id);
		break;
	case BEHEB_FEHLER:
		level = MESSAGEBOX_CLEARERROR;
		m_MSGUnit->AddWarnMessage(strSiemensCode, level, strDisplayErrorTemp.c_str(), apid);
		break;
	case NICHT_BEHEB_FEHLER:
		level = NOCLEARERROR;
		m_MSGUnit->AddWarnMessage(strSiemensCode, level, strDisplayErrorTemp.c_str(), apid);
		break;
	case FATALER_FEHLER: //ERROR
		//level = CLEARERROR;
		//m_MSGUnit->AddWarnMessage(strSiemensCode, level, strDisplayErrorTemp.c_str(), object_id);
		break;
	case RESET_WARNING:
	{
		//PRINTA_ERROR("== CallBackIfehleranz2 ==:RESET_WARNING\n");
		//level = CLEARERROR;
		//m_MSGUnit->DelWarnMessage(strSiemensCode, level, info.c_str());
		break;
	}
	case RESET_ERROR: //RESET ERROR
	{
		PRINTA_ERROR("== CallBackIfehleranz2 ==:RESET_ERROR\n");
		level = MESSAGEBOX_CLEARERROR;
		m_MSGUnit->DelWarnMessage(strSiemensCode, level, info.c_str());
		break;
	}
	case RESET_SEVERE:
	{
		PRINTA_ERROR("== CallBackIfehleranz2 ==:RESET_SEVERE\n");
		level = NOCLEARERROR;
		m_MSGUnit->DelWarnMessage(strSiemensCode, level, info.c_str());
		break;
	}
	case RESET_FATAL: //RESET FATAL
	{
		//PRINTA_ERROR("== CallBackIfehleranz2 ==:RESET_FATAL\n");
		//level = CLEARERROR;
		//m_MSGUnit->DelWarnMessage(strSiemensCode, level, info.c_str());
		break;
	}
	case RESET_USERMESSAGE://RESET USEMESSAGE
	{
		PRINTA_ERROR("== CallBackIfehleranz2 ==:RESET_USERMESSAGE\n");
		level = CLEARERROR;
		m_MSGUnit->DelWarnMessage(strSiemensCode, level, info.c_str());
		break;
	}
	case RESET_TELEGRAM:
		break;
	case RESET_MSGBOX:
		break;
	case RESET_ORTHOMSG:
		break;
	case ACS_FLAG_YESNO:
		break;
	default:
		break;
	}
	delete[] strInfo;
	strInfo = NULL;
	tempStr = NULL;
	return true;
}

/*********************************************************************************
函数名称：CallBackIINFOCOMP
功能描述： 收集当前组件的版本信息（collected SW/FW-versions of all components）

修改记录:
2021-04-23 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallBackIINFOCOMP(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//ENDIF
	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_BYTE backup_set = (*(ACS_BYTE*)(stmpBuffer + 8));
	ACS_COUNT apanzahl = (*(ACS_COUNT*)(stmpBuffer + 9));

	for (int i = 0; i <= apanzahl; i++)
	{
		ACS_BYTE APID = (*(ACS_BYTE*)(pCommand + i * 5 + 10));
		ACS_BYTE anzahlkenndaten = (*(ACS_BYTE*)(pCommand + i * 5 + 11));
		ACS_BYTE kenndatum_id = (*(ACS_BYTE*)(pCommand + i * 5 + 12));
		ACS_BYTE anzahlkenneintr = (*(ACS_BYTE*)(pCommand + i * 5 + 13));
		ACS_STRING_8 kenneintrag = (*(ACS_STRING_8*)(pCommand + i * 5 + 14));

		PRINTA_INFO("APID = %d,anzahlkenndaten = %d,kenndatum_id = %d,anzahlkenneintr = %d,kenneintrag = %s\n",
			APID, anzahlkenndaten, kenndatum_id, anzahlkenneintr, kenneintrag);
	}
	SendTelegramLog("IINFOCOMP");
	return true;
}

/*********************************************************************************
函数名称：CallBackST_MODE
功能描述： 解析当前的工作模式（当前仅用service）

修改记录:
2015-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallBackST_MODE(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_INFO("Get command is Null");
		return false;
	}//ENDIF

	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_BYTE System_Mode = (*(ACS_ENUM*)(stmpBuffer + 8)); //System_mode(1-7)
	ACS_DUMMY dummy1 = (*(ACS_DUMMY*)(stmpBuffer + 9)); //System_mode(1-7)

	int nCode = 1;
	if (System_Mode == ACS_SERVICE)
	{
		nCode = 2;
	}//ENDIF

	m_UIClientUnit.m_STM->Update(nCode);
	FireNotify(m_UIClientUnit.m_STM->GetKey(), m_UIClientUnit.m_STM->JSGet());

	SetSH_Mode(System_Mode);

	PRINTA_INFO("callback ST_MODE: %d,dummy1:%d\n", System_Mode, dummy1);

	std::ostringstream buffer;
	buffer << "ST_MODE:" << (int)System_Mode << ",dummy1:" << dummy1;
	string str = buffer.str();
	SendTelegramLog("ST_MODE", str.c_str(), object_id);

	return true;
}

/*********************************************************************************
函数名称：CallBackSDFRNAHBED2
功能描述： 解析SDFRNAHBED2；（1、当前的病人信息（体型）；2、当前DROC界面）

修改记录:
2021-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallBackSDFRNAHBED2(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_INFO("Get command is Null");
		return false;
	}//ENDIF

	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_ENUM reply_req = (*(ACS_ENUM*)(stmpBuffer + 8));
	ACS_INT aktcode = (*(ACS_INT*)(stmpBuffer + 12));
	ACS_INT aktdata = (*(ACS_INT*)(stmpBuffer + 14)); //0=No Action / 1=Pat / 2=Exam / 3=Postproc / 4=Doc

	int nTabCard = 0;
	int nStatus = 0;
	if (aktcode == TABCARD_TOGGLE)
	{
		nTabCard = (int)aktdata;
		m_UIClientUnit.m_SDF->Update(nTabCard);
		FireNotify(m_UIClientUnit.m_SDF->GetKey(), m_UIClientUnit.m_SDF->JSGet());
	}
	else if (aktcode == BTN_PATIENT_SIZE) //callback Patient size
	{
		//1: large; 2: Medium; 3:Small; 4;Custom define APR
		//不处理
		PRINTA_INFO("CallBackSDFRNAHBED2 Patient size: aktcode: %d,aktdata:%d\n", aktcode, aktdata);
	}
	else if (aktcode == REFRESH_ORGAN_PROGRAM/*REDO_ORGAN_PROGRAM*/) //根据siemens要求，更改对应的报文内容
	{
		if ((int)aktdata == 1)
		{
			nStatus = 1;
			//PRINTA_INFO("Undo"); //需要设置消息到界面
		}
		else
		{
			nStatus = 0;
			//PRINTA_INFO("No Undo");
		}
		m_UIClientUnit.m_UDO->Update(nStatus);
		FireNotify(m_UIClientUnit.m_UDO->GetKey(), m_UIClientUnit.m_UDO->JSGet());
	}
	else if (aktcode == TOD)
	{
		SendIdfrnahbed(TOD, (int)aktdata);
	}

	if (m_nGenSTMode == ACS_SERVICE)
	{
		if (nTabCard == 2) //Siemens 要求 表示进入服务模式
		{
			m_bGenService = true;
		}
		else if (nTabCard == 1)//Siemens 要求 表示退出服务模式
		{
			m_bGenService = false;
		}
	}//ENDIF

	PRINTA_INFO("CallBackSDFRNAHBED2: reply_req:%d,aktcode: %d,aktdata:%d,TableCard: %d\n", reply_req, aktcode, aktdata, nTabCard);

	std::ostringstream buffer;
	buffer << "aktcode:" << aktcode << ", aktdata:" << aktdata;
	string str = buffer.str();
	SendTelegramLog("SDFRNAHBED2", str.c_str(), object_id);
	return true;
}

//ST_ORGAN_PROG: tell DROC to which OGP will be used in the next acquisition.
/*********************************************************************************
函数名称：CallBackST_ORGAN_PROG
功能描述： 返回当前使用的view名称

修改记录:
2021-04-23 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallBackST_ORGAN_PROG(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_INFO("Get command is Null");
		return false;
	}//ENDIF

	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_STRING* temp = (ACS_STRING*)(pCommand + 8);
	ACS_STRING* str = new ACS_STRING[(PROG_NAME_LENGTH + 1) * 2];
	memset(str, 0, (PROG_NAME_LENGTH + 1) * sizeof(ACS_STRING) * 2);

	ACS_STRING* tempStr = str;
	for (int i = 0; i < PROG_NAME_LENGTH; i++, tempStr++, temp++)
	{
		*tempStr = *(ACS_STRING*)(temp);
	}

	str[PROG_NAME_LENGTH] = '\0';

	string strDisplayOrganProg = wc2mb((const wchar_t*)str);
	//m_pGenSiemensSalmon_UI->UIClientUnitLogic::GetSOP(strDisplayOrganProg.c_str());  //待完善

	//ResDataObject resdata;
	//resdata.update("SOP", strDisplayOrganProg.c_str());

	m_UIClientUnit.m_SOP->Update(strDisplayOrganProg.c_str());
	FireNotify(m_UIClientUnit.m_SOP->GetKey(), m_UIClientUnit.m_SOP->JSGet());

	delete[] str;
	str = NULL;
	tempStr = NULL;

	PRINTA_INFO("CallBackST_ORGAN_PROG: prog_name : %s\n", strDisplayOrganProg.c_str());//Warn

	std::ostringstream buffer;
	buffer << "prog_name:" << strDisplayOrganProg;
	string strlog = buffer.str();
	SendTelegramLog("ST_ORGAN_PROG", strlog.c_str(), object_id);

	return true;
}

/*********************************************************************************
函数名称：CallBackSRESETFEHLER
功能描述： reset当前DROC错误状态

修改记录:
2021-04-23 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallBackSRESETFEHLER(ACS_BYTE* pCommand)
{
	//add code, send the reset message to UI, then close the error box;
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//ENDIF
	return true;
}

/*********************************************************************************
函数名称：CallBackSID
功能描述： 解析SID信息
对应需求：IS_rad_SID(VERSION_RAD3-VA10)

修改记录:
2021-04-23 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallBackSID(ACS_BYTE* pCommand) //receive SID "IFFA", unit: mm
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("CallBackSID: Get pCommand is NULL");
		return false;
	}//ENDIF
	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_INT nSID = (*(ACS_INT*)(stmpBuffer + 8));

	//m_SiemensSalmon_Element[CMD_ELEMENT_SID].fGetValue = nSID; //202110 待完善
	//m_pCollimatorCommunication->CollimatorLogic::SetCollimatorSID(m_SiemensSalmon_Element[CMD_ELEMENT_SID].fGetValue);

	PRINTA_INFO("CallBackSID: IFFA: %d mm\n", nSID);

	std::ostringstream buffer;
	buffer << "IFFA:" << (int)nSID;
	string str = buffer.str();
	SendTelegramLog("IFFA", str.c_str(), object_id);

	return true;
}

/*********************************************************************************
函数名称：CallBackWorkStation
功能描述：获取当前探测器对应的Workstation信息

修改记录:
2015-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallBackWorkStationFromTUI(ACS_BYTE* pCommand) //receive System workstation SBEDSYS
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("CallBackWorkStation: Get pCommand is NULL");
		return false;
	}//ENDIF
	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_INT nFunctionParam = (*(ACS_INT*)(stmpBuffer + 10));
	ACS_INT nWorkStation = (*(ACS_INT*)(stmpBuffer + 12));
	int nWorkStationEcom;
	switch (nWorkStation)
	{
	case AXCS_MODE_SPOTFILM:
		nWorkStationEcom = WS_TABLE;
		break;
	case AXCS_MODE_BWS:
		nWorkStationEcom = WS_WALL;
		break;
	case AXCS_MODE_BED:
		nWorkStationEcom = WS_FREE;
		break;
	case AXCS_MODE_TOMO:
		nWorkStationEcom = WS_CONVENTIONAL;
		break;
	case AXCS_MODE_NONE:
		//break;
	default:
		nWorkStationEcom = WS_CONVENTIONAL;
		break;
	}
	PRINTA_INFO("CallBackWorkStation (SBEDSYS) from TUI: %d,ECOM: %d, FunctionNumber:%d\n", nWorkStation, nWorkStationEcom, nFunctionParam);

	std::ostringstream buffer;
	buffer << "From TUI fktscodesys: " << nWorkStation;
	string str = buffer.str();
	SendTelegramLog("SBEDSYS", str.c_str(), object_id);
	return true;
}

/*********************************************************************************
函数名称：CallBackCollimator
功能描述： 获取遮光器尺寸信息

修改记录:
2015-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallBackCollimator(ACS_BYTE* pCommand) //receive collimator "IBLENDEANZ"
{
	return true;
	if (pCommand == NULL)
	{
		PRINTA_ERROR("CallBackCollimator: Get pCommand is NULL");
		return false;
	}//ENDIF
	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_ENUM nCollimatorMode = (*(ACS_ENUM*)(stmpBuffer + 10));
	//m_pCollimatorCommunication->CollimatorLogic::SetCollimatorMode(nCollimatorMode); //202110 待完善

	ACS_COUNT nCollimatorNumber = (*(ACS_COUNT*)(stmpBuffer + 11));

	ACS_BYTE blendenauswahl = 0; //Collimator Cross or Length;
	ACS_WORD blendenposition = 0; //Current Position size
	ACS_BYTE blendenstatus = 0;   //Collimator Status: moving or arrive status

	int niblendeanz_t2_tag_Length = sizeof(ACS_BYTE) * 2 + sizeof(ACS_DUMMY) * 2 + sizeof(ACS_WORD) + sizeof(ACS_INT);

	for (int i = 0; i < nCollimatorNumber; i++)
	{
		blendenauswahl = (*(ACS_BYTE*)(stmpBuffer + 12 + i * niblendeanz_t2_tag_Length));
		blendenposition = (*(ACS_WORD*)(stmpBuffer + 14 + i * niblendeanz_t2_tag_Length));
		blendenstatus = (*(ACS_BYTE*)(stmpBuffer + 18 + i * niblendeanz_t2_tag_Length));

		if (blendenauswahl == HOEHENBLENDE)
		{
			//m_SiemensSalmon_Element[CMD_ELEMENT_COLLIMATORHEIGHT].fGetValue = (float)blendenposition / 100.0f; //cm //202110 待完善
		}
		else if (blendenauswahl == BREITENBLENDE)
		{
			//m_SiemensSalmon_Element[CMD_ELEMENT_COLLIMATORWIDTH].fGetValue = (float)blendenposition / 100.0f; //cm //202110 待完善
		}
		else
		{
			PRINTA_INFO("Get Other Collimator value");
		}

		PRINTA_INFO("CallBackCollimator: Number: %d, Collimator Index:%d, Collimator type:%d (1:height;2:Length); Position:%d (mm), Status:%d,Length: %d, CollimatorMode: %d\n",
			nCollimatorNumber, i + 1, blendenauswahl, blendenposition, blendenstatus, niblendeanz_t2_tag_Length, nCollimatorMode);

		std::ostringstream buffer;
		buffer << "blendenauswahl:" << (int)blendenauswahl << ", blendenposition:" << (int)blendenposition
			<< ", blendenstatus:" << (int)blendenstatus << ", CollimatorMode:" << (int)nCollimatorMode;
		string str = buffer.str();
		SendTelegramLog("IBLENDEANZ", str.c_str(), object_id);
	}

	//m_pFPDCommunication->CFPDCommunicateWithOtherDevice::OnCollimatorWidth((float)m_SiemensSalmon_Element[CMD_ELEMENT_COLLIMATORWIDTH].fGetValue); //202110 待完善
	//m_pFPDCommunication->CFPDCommunicateWithOtherDevice::OnCollimatorLen((float)m_SiemensSalmon_Element[CMD_ELEMENT_COLLIMATORHEIGHT].fGetValue); //202110 待完善
	//m_pCollimatorCommunication->CollimatorLogic::SetCollimatorSize((float)m_SiemensSalmon_Element[CMD_ELEMENT_COLLIMATORWIDTH].fGetValue, (float)m_SiemensSalmon_Element[CMD_ELEMENT_COLLIMATORHEIGHT].fGetValue); //202110 待完善

	return true;
}

/*********************************************************************************
函数名称：CallBackGrid
功能描述： 获取滤线栅信息

修改记录:
2021-04-23 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallBackGrid(ACS_BYTE* pCommand)
{
	return true;
}

/*********************************************************************************
函数名称：CallBackRQ_FDR_DATA
功能描述： 获取对应探测器的workstation信息

修改记录:
2015-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallBackRQ_FDR_DATA(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//ENDIF
	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_ENUM nFPDType = (*(ACS_ENUM*)(stmpBuffer + 9));
	ACS_ENUM nFPDTag = (*(ACS_ENUM*)(stmpBuffer + 12));

	switch (nFPDTag)
	{
	case ACS_FDR_SERNUM: //VE61X
		switch (nFPDType)
		{
		case ACS_FD_TABLE:
			//m_pFPDCommunication->CFPDCommunicateWithOtherDevice::OnWorkStation(WS_PARAM_TABLE_ECOM);  //202110 待完善
			break;
		case ACS_FD_WALL:
			//m_pFPDCommunication->CFPDCommunicateWithOtherDevice::OnWorkStation(WS_PARAM_WALL_ECOM); //202110 待完善
			break;
		case ACS_FD_PORTABLE:
			m_UIClientUnit.m_WS2FD->Update(WS_PARAM_FREE1_LARGE_ECOM);
			FireDataNotify(m_UIClientUnit.m_WS2FD->GetKey(), m_UIClientUnit.m_WS2FD->JSGet());
			break;
		case ACS_FD_SMALL_PORTABLE:
			m_UIClientUnit.m_WS2FD->Update(WS_PARAM_FREE2_SMALL_ECOM);
			FireDataNotify(m_UIClientUnit.m_WS2FD->GetKey(), m_UIClientUnit.m_WS2FD->JSGet());
			break;
		case ACS_FD_STAND:
		case ACS_FD_C_ARM:
		case ACS_FD_FLEXIBLE:
		default:
			break;
		}

		break;
	default:
		break;
	}

	PRINTA_INFO("CallbackRQ_FDR_DATA: FPDType:%d,FPDTag: %d\n", (int)nFPDType, (int)nFPDTag);

	std::ostringstream buffer;
	buffer << "nFPDType:" << (int)nFPDType << ",nFPDTag:" << (int)nFPDTag;
	string str = buffer.str();
	SendTelegramLog("RQ_FDR_DATA", str.c_str(), object_id);
	return true;
}

/*********************************************************************************
函数名称：CallBackAdjust
功能描述： PMS请求AP的读取或写入信息

修改记录:
2021-04-23 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallBackAdjust(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//ENDIF
	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_ENUM nAdjustAction = (*(ACS_ENUM*)(stmpBuffer + 8));
	ACS_INT nAdjustIdent = (*(ACS_INT*)(stmpBuffer + 10));

	PRINTA_INFO("Adjsut Action : %d, Identifier : %d, No Action\n", nAdjustAction, nAdjustIdent);
	return true;
	if ((nAdjustAction == ACS_ADJ_SUPPLY_DATA) && (nAdjustIdent == ACS_ADJUST_ID_FD_WLAN))
	{


	}
	else if ((nAdjustAction == ACS_ADJ_STORE_DATA) && (nAdjustIdent == ACS_ADJUST_ID_FD_WLAN))
	{
		//write AP 
		SendAdjust(ACS_ADJ_FILETRANS_RUNNING);
	}//ENDIF


	std::ostringstream buffer;
	buffer << "Adjsut Action:" << (int)nAdjustAction << ", Identifier:" << (int)nAdjustIdent;
	string str = buffer.str();
	SendTelegramLog("ST_ADJUST", str.c_str(), object_id);

	return true;

}

/*********************************************************************************
函数名称：CallBackIGGANZ2
功能描述： 获取遮光器平移和探测器旋转状态
对应需求：IS_rad_stand_collimation_sym_asym_parameter、IS_Rotaion_portableDet_default_rotation(VERSION_RAD3-VA10)

修改记录:
2021-04-23 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallBackIGGANZ2(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//ENDIF
	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_COUNT nNumber = (*(ACS_COUNT*)(stmpBuffer + 11));
	for (int n = 0; n < nNumber; n++)
	{
		ACS_INT anzcode = (*(ACS_INT*)(stmpBuffer + 12 + n * 4));
		ACS_INT param = (*(ACS_INT*)(stmpBuffer + 14 + n * 4));
		switch (anzcode)
		{
		case A_POSSYS:
			//m_pFPDCommunication->CFPDCommunicateWithOtherDevice::OnCollimatorAlign(param); //202110 待完善
			break;
		case A_DETECTOR_ORIENTATION:
			//m_pFPDCommunication->CFPDCommunicateWithOtherDevice::OnPANEL_ROTATE(param); //202110 待完善
			break;
		case A_TIEFENBLENDE_GEDREHT: //遮光器旋转 //与102、17同为ACSS的条件，可以省略；目前先按照现有逻辑设置
			//m_pCollimatorCommunication->CollimatorLogic::SetCollimatorAngle((float)param);
			break;
		case A_TUBE_ROT_HOR: //球管旋转角度
			//m_data.m_gen.m_nmTubeRotHor = param; //球管旋转角度：单位未知  //2021-04-21 待完善功能：需要设置到UI端
			break;
		case A_ORTHO_STEP: //Ortho step
			//m_data.m_gen.m_nmCP_Position_Match = param;  //2021-04-21 待完善功能：需要设置到UI端
			if (param >= 9)
			{
				//清除界面消息
				//m_data.m_gen.m_strsNotifyMessage = "";  //2021-04-21 待完善功能：需要设置到UI端
			}
			break;
		default:
			break;
		}
		PRINTA_INFO("CallBackIGGANZ2:nNumber: %d,n: %d,anzcode: %d,(90:CollimatorAlign; 92:collimator Rotate; 98:detector Orientation;114:Ortho Step; 17: A_TUBE_ROT_HOR); Param:%d\n",
			nNumber, n, anzcode, param);

		std::ostringstream buffer;
		buffer << "Number:" << (int)nNumber << ", n:" << n
			<< ", anzcode:" << anzcode << ", Param:" << param;
		string str = buffer.str();
		SendTelegramLog("IGGANZ2", str.c_str(), object_id);
	}
	return true;
}

/*********************************************************************************
函数名称：CallBackTubeHeat
功能描述： 获取当前设备热容量

修改记录:
2021-04-22 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallBackTubeHeat(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//ENDIF
	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_BYTE nTubeHeat = (*(ACS_BYTE*)(stmpBuffer + 8));
	ACS_WORD nWaitTime = (*(ACS_WORD*)(stmpBuffer + 10));

	m_DoseUnit.m_HE->Update(nTubeHeat);
	FireNotify(m_DoseUnit.m_HE->GetKey(), m_DoseUnit.m_HE->JSGet());

	PRINTA_INFO("CallBackTubeHeat(IROEANZ): TubeHeat: %d, nWaitTime:%d\n", nTubeHeat, nWaitTime);

	std::ostringstream buffer;
	buffer << "TubeHeat:" << (int)nTubeHeat << ", nWaitTime:" << nWaitTime;
	string str = buffer.str();
	SendTelegramLog("IROEANZ", str.c_str(), object_id);
	return true;
}

/*********************************************************************************
函数名称：CallBackSTDIAG
功能描述： 接受当前系统需要查询版本的内容

修改记录:
2021-04-23 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallBackSTDIAG(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//ENDIF
	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	int nidentifier = (*(ACS_INT*)(stmpBuffer + 10));

	//设置当前的状态信息到软件端
	m_UIClientUnit.m_RSI->Update(nidentifier);
	FireNotify(m_UIClientUnit.m_RSI->GetKey(), m_UIClientUnit.m_RSI->JSGet());
	SetSystemStatusInformation(nidentifier, "", ACS_DIAG_RUNNING);

	PRINTA_INFO("CallBackSTDIAG: nidentifier: %d\n", nidentifier);

	std::ostringstream buffer;
	buffer << "nidentifier:" << (int)nidentifier;
	string str = buffer.str();
	SendTelegramLog("ST_DIAG", str.c_str(), object_id);

	return true;
}

/*********************************************************************************
函数名称：CallBackRQOBJECT
功能描述： 接受当前系统需要查询的内容

修改记录:
2021-04-23 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallBackRQOBJECT(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//ENDIF

	//设置当前需要查询的模块版本信息到软件端
	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_WORD wObject_id = (*(ACS_WORD*)(stmpBuffer + 8));
	if (wObject_id == SH_VERSION_CHECK)
	{
		int nCode = 0;
		m_UIClientUnit.m_RMV->Update(nCode);
		FireNotify(m_UIClientUnit.m_RMV->GetKey(), m_UIClientUnit.m_RMV->JSGet());
	}

	std::ostringstream buffer;
	buffer << "Object_id:" << wObject_id;
	string str = buffer.str();
	SendTelegramLog("RQ_OBJECT", str.c_str(), object_id);

	return true;
}

///*********************************************************************************
//函数名称：CallBackDoorStatus
//功能描述： 解析门的开关状态

//修改记录:
//2021-04-23 创建
//*******************************************************************************/
bool nsGEN::SMZDevice::CallBackDoorStatus(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//endif

	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_BYTE nDoorStatus = (*(ACS_BYTE*)(stmpBuffer + 9));

	if (1 == nDoorStatus)
	{
		PRINTA_INFO("Door Close");
	}
	else if (2 == nDoorStatus)
	{
		PRINTA_INFO("Door Open ");
	}
	else
	{
		PRINTA_INFO("Door Status is unknown");
	}

	std::ostringstream buffer;
	buffer << "DoorStatus:" << (int)nDoorStatus;
	string str = buffer.str();
	SendTelegramLog("IALLGANZ", str.c_str(), object_id);

	return true;
}

/*********************************************************************************
函数名称：CallBackSTCONFIG
功能描述： 获取并解析ST_CONFIG报文
参数记录：
/* Parameter: cfg_action (Defines)
/*   ACS_CFG_SUPPLY_DATA  1   copy to the host
/*   ACS_CFG_STORE_DATA   2   copy from the host
/*   ACS_CFG_ABORT_DATA   3   abort
/*   ACS_CFG_COMPARE      4   compare config data
/*修改记录:
2021-04-23 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallBackSTCONFIG(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//ENDIF

	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	int nconfigResult = (*(ACS_ENUM*)(stmpBuffer + sizeof(acs_obj_header_t))); //执行行为
	int nDummy1 = (*(ACS_ENUM*)(stmpBuffer + sizeof(acs_obj_header_t) + sizeof(ACS_DUMMY))); //执行行为

	PRINTA_INFO("CallBackSTCONFIG: nconfigResult: %d,Dummy1: %d\n", nconfigResult, nDummy1);

	if (nDummy1 != 0)
	{
		if (nDummy1 == 1)
		{
			if (nconfigResult == ACS_CFG_STORE_DATA)
			{
				m_UIClientUnit.m_CFM->Update(nDummy1); //1:AutoConfig; 2:Restore
				FireNotify(m_UIClientUnit.m_CFM->GetKey(), m_UIClientUnit.m_CFM->JSGet());//20220406 无法区分configration与backupstore流程
			}
		}
		else
		{
			m_UIClientUnit.m_CFM->Update(nDummy1); //1:AutoConfig; 2:Restore
			FireNotify(m_UIClientUnit.m_CFM->GetKey(), m_UIClientUnit.m_CFM->JSGet());//20220406 无法区分configration与backupstore流程
		}
	}

	std::ostringstream buffer;
	buffer << "cfg_action:" << nconfigResult << "Dummy1:" << nDummy1;
	string str = buffer.str();
	SendTelegramLog("ST_CONFIG", str.c_str(), object_id);

	if ((nconfigResult != ACS_CFG_STORE_DATA)||(nDummy1 != 1))
	//if (nDummy1 != 1)
	{
		SetSHCONFIG(ACS_OK); //20220402 由上层服务端给出配置文件处理结果
	}
	
	return true;
}

/*********************************************************************************
函数名称：CallbackST_PWR_OFF
功能描述：接收到关机报文
参数：Full_image_size、image_size、overlap、Image number

修改记录:
2021-4-21 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallbackST_PWR_OFF(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//ENDIF

	int nECOMShutDown = 0;
	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	int nShutDown = (*(ACS_ENUM*)(stmpBuffer + 8));
	int nDelay = (*(ACS_INT*)(stmpBuffer + 8 + sizeof(ACS_ENUM) + sizeof(ACS_DUMMY)));
	switch (nShutDown)
	{
	case ACS_REQ_PWR_OFF:
		nECOMShutDown = 1;
		break;
	case ACS_SHUTDOWN_APP:
		nECOMShutDown = 2;
		break;
	case ACS_PWR_OFF_CANCEL:
		nECOMShutDown = 0;
		break;
	default:
		break;
	}

	ResDataObject resdata;
	resdata.add("State", nECOMShutDown);
	resdata.add("DelayTime", nDelay);
	//EventCenter->OnNotify(8, "SDN", resdata.encode());

	m_UIClientUnit.m_SDN->Update(resdata.encode());
	FireDataNotify(m_UIClientUnit.m_SDN->GetKey(), m_UIClientUnit.m_SDN->JSGet());

	PRINTA_INFO("CallbackST_PWR_OFF shutdown: ECOM:%d,From AXIM:Shutdown: %d,Delay:%d\n",
		nECOMShutDown, nShutDown, nDelay);

	std::ostringstream buffer;
	buffer << "CallbackST_PWR_OFF shutdown:" << nShutDown << ",Delay Value:" << nDelay;
	string str = buffer.str();
	SendTelegramLog("ST_PWR_OFF", str.c_str(), object_id);
	return true;
}

/*********************************************************************************
函数名称：CallBackPMSSystemStatus
功能描述： 获取当前PMS状态

修改记录:
2021-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallBackPMSSystemStatus(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_INFO("Get command is Null");
		return false;
	}//ENDIF
	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_SET LoginStatus = (*(ACS_SET*)(stmpBuffer + 8));

	int nStatus = 0;
	if ((LoginStatus & ACS_STATE_SERVICE_SESSION) > 0)
	{
		nStatus = 1;
		m_nGenSTMode = ACS_SERVICE;
	}
	else
	{
		nStatus = 0;
		m_nGenSTMode = -1;
	}
	m_UIClientUnit.m_PLS->Update(nStatus);
	FireNotify(m_UIClientUnit.m_PLS->GetKey(), m_UIClientUnit.m_PLS->JSGet());
	PRINTA_INFO("CallBackSystemLoginStatus:LoginStatus: %x\n", LoginStatus);

	int nAutoConfig = -1;
	if (LoginStatus == ACS_STATE_SERVICE_SESSION)
	{
		nAutoConfig = 1;
	}
	else if (LoginStatus == (ACS_STATE_CONF_INCONSISTENT & ACS_STATE_SERVICE_SESSION))
	{
		nAutoConfig = 0;
	}
	m_UIClientUnit.m_AutoConfig->Update(nAutoConfig);
	FireNotify(m_UIClientUnit.m_AutoConfig->GetKey(), m_UIClientUnit.m_AutoConfig->JSGet());

	std::ostringstream buffer;
	buffer << "LoginStatus:" << LoginStatus;
	string str = buffer.str();
	SendTelegramLog("ST_SYSTEM_STATE", str.c_str(), object_id);
	return true;
}
/*********************************************************************************
函数名称：CallbackIXRAY
功能描述：对IXRAY消息进行反馈处理

修改记录:
2021-4-22 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallbackIXRAY(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("CallbackIXRAY: Get command is Null");
		return false;
	}//ENDIF

	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_BYTE xray = (*(ACS_BYTE*)(stmpBuffer + sizeof(acs_obj_header_t)));

	ACS_DWORD acq_index = (*(ACS_DWORD*)(pCommand + sizeof(acs_obj_header_t) + 3 * sizeof(ACS_DUMMY) + sizeof(ACS_BYTE)));
	
	if (xray > 0)
	{
		if ((m_bExposureStatus)||(m_bCalibMode)) //仅在收到手闸信号时，设置XRAYON状态；XRAYOFF不受影响，可以设置
		{
			//if (acq_index != m_nExposureIndex)
			//{
				m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_XRAYON);
				FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
				PRINTA_INFO("CallbackIXRAY: Get Exposure XRAYON,Send the status GENERATOR_RAD_XRAYON\n");
				Clear_DAP();
				ResetEvent(m_hGenPostEvent);
				ResetEvent(m_hGenPostDAPEvent);
				ResetEvent(m_hWaitForDapEvent);
				m_nExposureIndex = acq_index;

				m_FPDGUnit->OnXrayStatus(true);

				DWORD dwThreadId;
				if (NULL == m_hWaitForDapThread)
				{
				}
				else
				{
					m_hWaitForDapThread = NULL;					
				}
				m_hWaitForDapThread = CreateThread(NULL, 0, WaitForDapThread, this, 0, &dwThreadId);
				
				if (m_hWaitForDapThread == NULL)
				{
					PRINTA_DEBUG("Open WaitForDapThread Failed");
				}
			//}
			//else
			//{
			//	PRINTA_ERROR("CallbackIXRAY: get same index for IXRAYON, don't send the XRAYON message to HW \n");
			//}
		}
		else
		{
			PRINTA_ERROR("CallbackIXRAY: can't get handswitch status, don't send the ixray status to HW,ExposureStatus: %d,CalibMode: %d \n", m_bExposureStatus, m_bCalibMode);
		}

	}
	else
	{
		m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_XRAYOFF);
		FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
		m_bExposureStatus = false;
		m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_OFF);
		FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
		PRINTA_INFO("CallbackIXRAY: Get Exposure XRAYOFF,Send the status GENERATOR_RAD_XRAYOFF\n");
	}

	PRINTA_INFO("xray: %d, index:%lu\n", xray, acq_index);

	std::ostringstream buffer;
	buffer << "xray:" << (int)xray << ",index:" << (int)acq_index;
	string str = buffer.str();
	SendTelegramLog("IXRAY", str.c_str(), object_id);

	return true;
}

/*********************************************************************************
函数名称：CallbackIWATERVALACQ
功能描述： 获取当前DAP值

修改记录:
2021-04-22 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallbackIWATERVALACQ(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//ENDIF

	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	int nTempKV = (*(ACS_INT*)(stmpBuffer + 8 + sizeof(ACS_DWORD) + 2 * sizeof(ACS_WORD) + sizeof(ACS_INT)));
	int nTempMA = (*(ACS_INT*)(stmpBuffer + 8 + sizeof(ACS_DWORD) + 2 * sizeof(ACS_WORD) + 2 * sizeof(ACS_INT))); //20220221：按照Siemens要求，虽然解析，但是不使用
	int nTempMAS = (*(ACS_LINT*)(stmpBuffer + 8 + sizeof(ACS_DWORD) + 3 * sizeof(ACS_WORD) + 3 * sizeof(ACS_INT)));
	int nTempMS = (*(ACS_LINT*)(stmpBuffer + 8 + sizeof(ACS_DWORD) + 3 * sizeof(ACS_WORD) + 3 * sizeof(ACS_INT) + sizeof(ACS_LINT)));

	PRINTA_INFO("== IN ==: IWATERVALACQ CallbackPostGenParam begin kv:%d,wMAS: %d, wMS: %d,ma:%d\n", nTempKV, nTempMAS, nTempMS, nTempMA);
	//KV
	m_DoseUnit.m_PostKV->Update((float)((nTempKV) / 10.0f));
	FireNotify(m_DoseUnit.m_PostKV->GetKey(), m_DoseUnit.m_PostKV->JSGet());

	//MAS
	m_DoseUnit.m_PostMAS->Update((float)((nTempMAS) / 100.0f));
	FireNotify(m_DoseUnit.m_PostMAS->GetKey(), m_DoseUnit.m_PostMAS->JSGet());

	//MS
	m_DoseUnit.m_PostMS->Update((float)((nTempMS) / 10.0f));
	FireNotify(m_DoseUnit.m_PostMS->GetKey(), m_DoseUnit.m_PostMS->JSGet());

	//MA
	if (nTempMS > 0)
	{
		m_DoseUnit.m_PostMA->Update(m_DoseUnit.m_PostMAS->Get() * 1000.0 / m_DoseUnit.m_PostMS->Get());
	}
	else
	{
		m_DoseUnit.m_PostMA->Update(0);
	}
	FireNotify(m_DoseUnit.m_PostMA->GetKey(), m_DoseUnit.m_PostMA->JSGet());
	
	PRINTA_INFO("== IN ==: IWATERVALACQ CallbackPostGenParam PostKV:%f,PostMAS: %f, PostMS: %f, nTempMA: %f,PostMA:%f\n",
		(float)((nTempKV) / 10.0f),
		(float)((nTempMAS) / 100.0f),
		(float)((nTempMS) / 10.0f),
		(float)nTempMA,
		(float)m_DoseUnit.m_PostMA->Get());


	ACS_DWORD ndfp = (*(ACS_DWORD*)(stmpBuffer + sizeof(acs_obj_header_t) + sizeof(ACS_DWORD) * 2 + sizeof(ACS_WORD) * 6 + sizeof(ACS_INT) * 3 + sizeof(ACS_LINT) * 3 + sizeof(ACS_BYTE) * 5 + sizeof(ACS_ENUM)));
	ACS_LINT nskdose = (*(ACS_LINT*)(stmpBuffer + sizeof(acs_obj_header_t) + sizeof(ACS_DWORD) * 3 + sizeof(ACS_WORD) * 6 + sizeof(ACS_INT) * 3 + sizeof(ACS_LINT) * 3 + sizeof(ACS_BYTE) * 5 + sizeof(ACS_ENUM)));

	m_DoseUnit.m_ReferenceAirKerma->Update((float)(nskdose * 0.01f));
	FireNotify(m_DoseUnit.m_ReferenceAirKerma->GetKey(), m_DoseUnit.m_ReferenceAirKerma->JSGet());

	ACS_BYTE filter_acq = (*(ACS_BYTE*)(stmpBuffer + sizeof(acs_obj_header_t) + sizeof(ACS_DWORD) * 3 + sizeof(ACS_WORD) * 6 + sizeof(ACS_INT) * 3 + sizeof(ACS_LINT) * 4 + sizeof(ACS_BYTE) * 5 + sizeof(ACS_ENUM)));
	m_CollimatorUnit.m_Filter->Update(filter_acq);
	FireNotify(m_CollimatorUnit.m_Filter->GetKey(), m_CollimatorUnit.m_Filter->JSGet());

	ACS_DWORD acq_index = (*(ACS_DWORD*)(stmpBuffer + sizeof(acs_obj_header_t)));

	m_DoseUnit.m_GenCurrentExpNumber->Update(acq_index);
	FireNotify(m_DoseUnit.m_GenCurrentExpNumber->GetKey(), m_DoseUnit.m_GenCurrentExpNumber->JSGet());

	ACS_WORD nStime = (*(ACS_WORD*)(stmpBuffer + sizeof(acs_obj_header_t) + sizeof(ACS_DWORD) * 3 + sizeof(ACS_WORD) * 6 + sizeof(ACS_INT) * 5 + sizeof(ACS_LINT) * 4 + sizeof(ACS_BYTE) * 7 + sizeof(ACS_ENUM) * 2 + sizeof(ACS_DUMMY)));

	m_DoseUnit.m_GenTotalAcqTimes->Update(acq_index);
	FireNotify(m_DoseUnit.m_GenTotalAcqTimes->GetKey(), m_DoseUnit.m_GenTotalAcqTimes->JSGet());
    
		
	ACS_BYTE nFocus = (*(ACS_BYTE*)(stmpBuffer + sizeof(acs_obj_header_t) + sizeof(ACS_DWORD) * 5 + sizeof(ACS_WORD) * 9 + sizeof(ACS_INT) * 5 + sizeof(ACS_LINT) * 6 + sizeof(ACS_BYTE) * 11 + sizeof(ACS_ENUM) *4 + sizeof(ACS_DUMMY) * 6));

	if (ndfp > 0)
	{
		m_DAP->Update((float)ndfp / 1000.0f);
		FireNotify(m_DAP->GetKey(), m_DAP->JSGet());
		SetEvent(m_hGenPostDAPEvent);
		PRINTA_INFO("CallbackIWATERVALACQ Get DFP: %f,SetDAPEvent", (float)ndfp);
	}
	SetEvent(m_hGenPostEvent);
	if (((nTempKV == 0)&&(nTempMAS == 0)&&(ndfp == 0))
		||((nTempKV != 0) && (nTempMAS != 0) && (ndfp != 0)))
	{
		SetEvent(m_hWaitForDapEvent);
	}
	else
	{
		PRINTA_ERROR("CallbackIWATERVALACQ:Get Post Parameter = 0");
	}
	
	PRINTA_INFO("CallbackIWATERVALACQ ACQIndex: %lu,Stime: %f (0.1s),dfp:%f(dGycm^2),DAPUnit: %d (0:uGym2,1:mGycm2),ReferenceAirKerma:%f(mGy),FOKUS:%d(1:small,2:large),filter_acq:%d\n",
		acq_index, (float)nStime, (float)ndfp / 1000.0f, m_nDAPUnit, (float)(nskdose * 0.01f), (int)nFocus,(int)filter_acq);

	std::ostringstream buffer;
	buffer << "CallbackIWATERVALACQ ACQIndex : " << acq_index << ", Stime : "
		<< (float)nStime << ", dfp :" << (float)ndfp / 1000.0f << "(dGycm ^ 2), ReferenceAirKerma :" << (float)(nskdose * 0.01f) << "(mGy)" 
		<< ",PostKV:"<< (float)m_DoseUnit.m_PostKV->Get()<<", PostMAS:"<< m_DoseUnit.m_PostMAS->Get()
		<< ",PostMS:" << (float)m_DoseUnit.m_PostMS->Get() << ", PostMA:" << m_DoseUnit.m_PostMA->Get() << ",FOKUS:" << (int)nFocus << ",filter_acq:" << (int)filter_acq;

	string str = buffer.str();
	SendTelegramLog("IWATERVALACQ", str.c_str(), object_id);
	return true;
}

//发生器READY，表示可以按手闸曝光了
/*********************************************************************************
函数名称：CallBackIANLBEREIT
功能描述： 解析发生器状态是否ready

修改记录:
2021-04-23 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallBackIANLBEREIT(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//ENDIF
	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_BYTE nANLAUFNBEREIT = (*(ACS_BYTE*)(stmpBuffer + 8));

	if (1 == nANLAUFNBEREIT)
	{
		string code = "0";
		//string code = "Not_Ready";
		string info = "";
		int level = AUTOCLEARERROR;
		m_MSGUnit->DelErrorMessage(code.c_str(), level, info.c_str());
		m_DoseUnit.m_GenState->Update(AttrKey::GENERATOR_STATUS_STANDBY);
		FireNotify(m_DoseUnit.m_GenState->GetKey(), m_DoseUnit.m_GenState->JSGet());
		if (m_bAutoHandSwitch)
		{
			SendSAUSLBED(1);  //自动曝光 按下手闸
			m_bAutoHandSwitch = false;
		}
		PRINTA_INFO("CallBack IANLBEREIT:1 ,Generator Ready\n");
	}
	else
	{
		if (nANLAUFNBEREIT == m_nIdfrstatus)
		{
			PRINTA_WARN("CallBack IANLBEREIT: Generator not Ready from IS, %d\n", nANLAUFNBEREIT);
		}
		else
		{
			PRINTA_WARN("CallBack IANLBEREIT: Generator not Ready from Other, %d\n", nANLAUFNBEREIT);
			if ((int)m_DoseUnit.m_GenState->Get() != (int)AttrKey::GENERATOR_STATUS_ERROR)
			{
				m_DoseUnit.m_GenState->Update(AttrKey::GENERATOR_STATUS_ERROR);
				FireNotify(m_DoseUnit.m_GenState->GetKey(), m_DoseUnit.m_GenState->JSGet());
				PRINTA_DEBUG("CallBack IANLBEREIT: Different status as before,send to subSystem\n");
			}
			else
			{
				PRINTA_DEBUG("CallBack IANLBEREIT: Due to the same status,don't send the status to subsystem.\n");
			}		
		}

	}

	PRINTA_INFO("CallBack IANLBEREIT: %d\n", nANLAUFNBEREIT);

	std::ostringstream buffer;
	buffer << "CallBack IANLBEREIT:" << (int)nANLAUFNBEREIT;
	string str = buffer.str();
	SendTelegramLog("0xF3 IANLBEREIT", str.c_str(), object_id);
	return true;
}

///*********************************************************************************
//函数名称：CallBackST_DATA_TRANS
//功能描述： 获取并解析ST_DATA_TRANS报文

//修改记录:
//2021-04-23 创建
//*******************************************************************************/
bool nsGEN::SMZDevice::CallBackST_DATA_TRANS(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//ENDIF

	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	int ndata_action = (*(ACS_ENUM*)(stmpBuffer + sizeof(acs_obj_header_t))); //执行行为
	int nIdent = (*(ACS_ENUM*)(stmpBuffer + sizeof(acs_obj_header_t) + 2)); //执行行为

	if (ndata_action == 5) //需要进行backup操作
	{
		m_UIClientUnit.m_BRM->Update(ndata_action);
		FireDataNotify(m_UIClientUnit.m_BRM->GetKey(), m_UIClientUnit.m_BRM->JSGet());
		m_nBackup_Restre_Identifier = nIdent;
	}
	else
	{
		SetSH_DATA_TRANS(1,nIdent);
	}

	PRINTA_INFO("CallBackST_DATA_TRANS: nconfigResult = %d,m_nBackup_Restre_Identifier: %d\n",
		ndata_action, m_nBackup_Restre_Identifier);

	std::ostringstream buffer;
	buffer << "data_action:" << ndata_action << "Identifier:" << m_nBackup_Restre_Identifier;
	string str = buffer.str();
	SendTelegramLog("ST_DATA_TRANS", str.c_str(), object_id);
	return true;
}

///*********************************************************************************
//函数名称：CallbackExposureNumber
//功能描述： 解析曝光的次数报文(ISERVBETRIEB)

//修改记录:
//2021-04-23 创建
//*******************************************************************************/
bool nsGEN::SMZDevice::CallbackExposureNumber(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//ENDIF

	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_LINT nSmallFocusNumber = (*(ACS_LINT*)(stmpBuffer + sizeof(iservbetrieb_t1) + 4));
	ACS_LINT nLargeFocusNumber = (*(ACS_LINT*)(stmpBuffer + sizeof(iservbetrieb_t1) + 4 + sizeof(ACS_LINT) + 2 * sizeof(ACS_WORD)));

	m_DoseUnit.m_GenTotalExpNumber->Update(nSmallFocusNumber + nLargeFocusNumber);
	FireNotify(m_DoseUnit.m_GenTotalExpNumber->GetKey(), m_DoseUnit.m_GenTotalExpNumber->JSGet());

	ACS_WORD nWaitTime = (*(ACS_WORD*)(stmpBuffer + sizeof(iservbetrieb_t1) + 4 + sizeof(ACS_LINT)));
	m_DoseUnit.m_GenTubeCoolWaitTimes->Update((int)nWaitTime);
	FireNotify(m_DoseUnit.m_GenTubeCoolWaitTimes->GetKey(), m_DoseUnit.m_GenTubeCoolWaitTimes->JSGet());

	ACS_WORD nOverLoadNumber = (*(ACS_WORD*)(stmpBuffer + sizeof(iservbetrieb_t1) + 4 + sizeof(ACS_LINT) + sizeof(ACS_WORD)));
	m_DoseUnit.m_GenTubeOverLoadNumber->Update((int)nOverLoadNumber);
	FireNotify(m_DoseUnit.m_GenTubeOverLoadNumber->GetKey(), m_DoseUnit.m_GenTubeOverLoadNumber->JSGet());

	int nExposureNumber = nSmallFocusNumber + nLargeFocusNumber;
	PRINTA_INFO("CallbackExposureNumber: ExposureNumber: %d,WaitTime: %d,OverLoadNumber:%d\n",
		nExposureNumber, nWaitTime, nOverLoadNumber);

	std::ostringstream buffer;
	buffer << "SmallFocusNumber:" << nSmallFocusNumber << "LargeFocusNumber:" << nSmallFocusNumber
		<< "WaitTime:" << nWaitTime << "OverLoadNumber:" << nOverLoadNumber;
	string str = buffer.str();
	SendTelegramLog("ISERVBETRIEB", str.c_str(), object_id);
	return true;
}

/*********************************************************************************
函数名称：CallBackSOD
功能描述： 解析SOD信息
对应需求：IS_rad_SOD

修改记录:
2017-10-09 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallBackSOD(ACS_BYTE* pCommand) //receive SOD "ISOD", unit: mm
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("CallBackSOD: Get pCommand is NULL");
		return false;
	}//ENDIF
	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_INT nSOD = (*(ACS_INT*)(stmpBuffer + 8));

	//m_SiemensSalmon_Element[CMD_ELEMENT_SOD].fGetValue = nSOD / 10.0f; //202110 待完善
	//m_pGenSiemensSalmon_Mech->Mech::UpdateSOD(nSOD / 10.0f);

	PRINTA_INFO("Callback ISOD: %d (0.1mm),SOD:%f(mm)\n", nSOD, (float)(nSOD / 10.0f));

	std::ostringstream buffer;
	buffer << "ISOD:" << nSOD << "(0.1mm),SOD::" << (float)(nSOD / 10.0f);
	string str = buffer.str();
	SendTelegramLog("ISOD", str.c_str(), object_id);
	return true;
}

///*********************************************************************************
//函数名称：CallbackIACSS
//功能描述： 解析IACSS报文(硬裁剪条件)

//修改记录:
//2021-04-23 创建
//*******************************************************************************/
bool nsGEN::SMZDevice::CallbackIACSS(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//ENDIF

	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_ENUM acss = (*(ACS_ENUM*)(stmpBuffer + sizeof(acs_obj_header_t)));

	//m_pFPDCommunication->CFPDCommunicateWithOtherDevice::OnHWcrop((int)acss); //202110 待完善

	PRINTA_INFO("CallbackIACSS acss: %d\n", acss);

	std::ostringstream buffer;
	buffer << "acss:" << (int)acss;
	string str = buffer.str();
	SendTelegramLog("IACSS", str.c_str(), object_id);
	return true;
}

/*********************************************************************************
函数名称：CallBackSFANZLOESCHEN
功能描述： 获取SFANZLOESCHEN报文，表示错误被清除

修改记录:
2021-04-23 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallBackSFANZLOESCHEN(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//ENDIF
	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	string code = "0";
	string info = "";
	int level = 0;
	m_MSGUnit->DelErrorMessage(code.c_str(), level, info.c_str());

	PRINTA_INFO("CallBackSFANZLOESCHEN:Get Error Recover\n");

	SendTelegramLog("SFANZLOESCHEN","", object_id);
	return true;
}

///*********************************************************************************
//函数名称：CallbackIERWALLGANZ
//功能描述：对IERWALLGANZ消息进行反馈处理,获取在屏保状态下的按下手闸的状态，用于激活屏保登录框；

//修改记录:
//2021-4-23 创建
//*******************************************************************************/
bool nsGEN::SMZDevice::CallbackIERWALLGANZ(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("CallbackIERWALLGANZ: Get command is Null");
		return false;
	}//ENDIF

	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_BYTE nSS = (*(ACS_BYTE*)(stmpBuffer + sizeof(acs_obj_header_t) + sizeof(ACS_BYTE)));
	ACS_BYTE nScreensave = (*(ACS_BYTE*)(stmpBuffer + sizeof(acs_obj_header_t) + 2 * sizeof(ACS_BYTE)));
	ACS_SET  xray_switch_state = (*(ACS_SET*)(stmpBuffer + sizeof(acs_obj_header_t) + 8 * sizeof(ACS_BYTE)));

	ACS_BYTE  battery_level = (*(ACS_BYTE*)(stmpBuffer + sizeof(acs_obj_header_t) + 7 * sizeof(ACS_BYTE)));

	ACS_ENUM mains_connected = (*(ACS_BYTE*)(stmpBuffer + sizeof(acs_obj_header_t) + 10 * sizeof(ACS_BYTE) + sizeof(ACS_SET) + 3 * sizeof(ACS_ENUM)));

	ACS_ENUM nLockStatus = (*(ACS_BYTE*)(stmpBuffer + sizeof(acs_obj_header_t) + 10 * sizeof(ACS_BYTE) + sizeof(ACS_SET) + 5 * sizeof(ACS_ENUM)));

	int nSaftySwitch = 0;
	int nScreenSaveToClient = -1;
	if (nSS == EIN)
	{
		nSaftySwitch = EIN;
	}

	m_UIClientUnit.m_SHS->Update(nSaftySwitch);
	FireNotify(m_UIClientUnit.m_SHS->GetKey(), m_UIClientUnit.m_SHS->JSGet());

	if (nLockStatus == ACS_YES)
	{
		nScreenSaveToClient = 1;

	}
	else if (nLockStatus == ACS_NO)
	{
		nScreenSaveToClient = 0;
	}
	m_UIClientUnit.m_SCREENLOCK->Update(nScreenSaveToClient);
	FireNotify(m_UIClientUnit.m_SCREENLOCK->GetKey(), m_UIClientUnit.m_SCREENLOCK->JSGet());

	int nBatteryChargeState = 0;

	//string code = "";
	//string info = "";
	//int level = AUTOCLEARERROR;

	int nPlugPowerStatus = 1;

	try {
		nPlugPowerStatus = (int)(m_GenConfig["PowerPlugStatus"]); 
	}
	catch (...)
	{
		PRINTA_ERROR("Can't get the PowerPlugStatus\n");
	}

	if (nPlugPowerStatus == 1)
	{
		if (mains_connected == ACS_YES)
		{
			nBatteryChargeState = POWER_AC;

			//code = "Main_Contact_unplug";
			//info = "";
			//m_MSGUnit->DelErrorMessage(code.c_str(), level, info.c_str()); //调用时会崩溃
			//PRINTA_INFO("CallbackIERWALLGANZ:DelErrorMessage Mains unpluged\n");
		}
		else if (mains_connected == ACS_NO)
		{
			nBatteryChargeState = POWER_DC;
			//code = "Main_Contact_unplug";
			//info = "Mains unpluged";
			//m_MSGUnit->AddErrorMessage(code.c_str(), level, info.c_str());
		}
		else
		{
			nBatteryChargeState = POWER_DC;
			//code = "Main_Contact_unplug";
			//info = "Mains unpluged";
			//m_MSGUnit->AddErrorMessage(code.c_str(), level, info.c_str());
		}
	}
	m_DoseUnit.m_BatteryChargeState->Update(nBatteryChargeState);
	FireNotify(m_DoseUnit.m_BatteryChargeState->GetKey(), m_DoseUnit.m_BatteryChargeState->JSGet());
	PRINTA_INFO("CallbackIERWALLGANZ:nScreensave: %d,xray_switch_state: %d,safety relay:%d,Battery:%d,mains_connected:%d,nScreenSaveToClient: %d\n",
		(int)nScreensave, xray_switch_state, (int)nSS, (int)nBatteryChargeState, (int)mains_connected, nScreenSaveToClient); 

	std::ostringstream buffer;
	buffer << "nScreensave:" << (int)nScreensave << ", xray_switch_state:" << (int)xray_switch_state << ", safety relay:" << (int)nSS << ", mains_connected:" << (int)mains_connected << ", LockStatus:" << (int)nLockStatus;
	string str = buffer.str();
	SendTelegramLog("IERWALLGANZ", str.c_str(), object_id);
	return true;
}

/*********************************************************************************
函数名称：CallbackSORTHO
功能描述：接收到拼接图像信息

修改记录:
2021-04-23 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallbackSORTHO(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//ENDIF
	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_LINT nfull_image_size = (*(ACS_LINT*)(stmpBuffer + 8));
	ACS_COUNT nr_images = (*(ACS_COUNT*)(stmpBuffer + 8 + sizeof(ACS_LINT) + sizeof(ACS_DUMMY)));
	ACS_WORD image_size = (*(ACS_WORD*)(stmpBuffer + 8 + sizeof(ACS_LINT) + sizeof(ACS_DUMMY) + sizeof(ACS_COUNT)));
	ACS_WORD ortho_overlap = (*(ACS_WORD*)(stmpBuffer + 8 + sizeof(ACS_LINT) + sizeof(ACS_DUMMY) + sizeof(ACS_COUNT) + sizeof(ACS_WORD)));

	PRINTA_INFO("nfull_image_size:%d, nr_images: %d,image_size: %d, ortho_overlap:%d\n", nfull_image_size, nr_images, image_size, ortho_overlap);

	std::ostringstream buffer;
	buffer << "nfull_image_size:" << nfull_image_size << ",nr_images:" << nr_images
		<< ",image_size:" << image_size << ",ortho_overlap:" << ortho_overlap;
	string str = buffer.str();
	SendTelegramLog("SORTHO", str.c_str(), object_id);
	return true;
}

/*********************************************************************************
函数名称：CallbackSH_STPAR_RFP
功能描述：接收到拼接图像信息
参数：Full_image_size、image_size、overlap、Image number

修改记录:
2021-04-23 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallbackSH_STPAR_RFP(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//ENDIF
	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_ENUM projection = (*(ACS_ENUM*)(stmpBuffer + 8 + sizeof(ACS_BYTE)));
	ACS_INT tube_rot_hor = (*(ACS_INT*)(stmpBuffer + 8 + sizeof(ACS_BYTE) + 13 * sizeof(ACS_ENUM) + 9 * sizeof(ACS_INT) + 8 * sizeof(ACS_LINT) + 3 * sizeof(ACS_WORD)));
	ACS_ENUM cp_position_match = (*(ACS_ENUM*)(stmpBuffer + 8 + sizeof(ACS_BYTE) + 14 * sizeof(ACS_ENUM) + 16 * sizeof(ACS_INT) + 9 * sizeof(ACS_LINT) + 5 * sizeof(ACS_WORD)));

	PRINTA_INFO("projection: %d, cp_position_match: %d, tube_rot_hor:%d\n", projection, cp_position_match, tube_rot_hor);

	std::ostringstream buffer;
	buffer << "projection:" << (int)projection << ", cp_position_match:" << (int)cp_position_match
		<< ",tube_rot_hor:" << (int)tube_rot_hor;
	string str = buffer.str();
	SendTelegramLog("SH_STPAR_RFP", str.c_str(), object_id);
	return true;
}

/*********************************************************************************
函数名称：TimeOutWaring
功能描述： 连接超时判断

修改记录:
2021-04-23 创建
*******************************************************************************/
bool nsGEN::SMZDevice::TimeOutWaring(void)
{
	m_nTimeoutCount++;
	if (m_nTimeoutCount >= 3)
	{
		PRINTA_DEBUG("m_nTimeoutCount = %d,Can't communicate with generator\n", m_nTimeoutCount);
		m_nTimeoutCount = 0;
	}//ENDIF
	return true;
}

/*********************************************************************************
函数名称：FDCConnectXCS
功能描述： FDC节点连接到XCU节点

修改记录:
2015-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::FDCConnectXCS()
{
	axn_word wtimeout = 10;
	axn_status status;

	if (m_pFDCAxnClient)
	{
		CAxnClientIFCreator::deleteAxnClientIF(m_pFDCAxnClient);
		m_pFDCAxnClient = NULL;
		PRINTA_INFO("FDCConnectXCS,deleteFDCAxnClientIF\n");
	}

	if ((m_pFDCAxnClient = CAxnClientIFCreator::newAxnClientIF()) == NULL)
	{
		PRINTA_ERROR("FDC newAxnClientIF fail");
	}//ENDIF

	int ConnectTime = 0;   //默认重连次数为1
	PRINTA_INFO("== SEND == : connectToServer FDCAxnClient\n");

	while ((m_pFDCAxnClient != NULL) && (status = m_pFDCAxnClient->connectToServer(FDC_Controlsender, wtimeout)) != ACS_AXN_OK)
	{
		PRINTA_INFO(("FDC Connect Time: %d\n"), ConnectTime);
		printf("FDC Connect Time: %d\n", ConnectTime);
		if (ConnectTime >= 20)
		{
			break;
		}
		else
		{
			ConnectTime++;
			Sleep(1000);
			PRINTA_INFO("Call FDC connectToServer again\n");
		}
	}

	if (ConnectTime >= 20)
	{
		PRINTA_ERROR(("FDC Tried %d times, still failed to connect XCS, return\n"), ConnectTime);
		string code = "ConnectError";
		string info = "Can't connect to Axim, Please reboot the system.";
		int level = CONNECTIONERROR;
		m_MSGUnit->AddErrorMessage(code.c_str(), level, info.c_str(),0xF3);
		return false;
	}
	else
	{
		PRINTA_INFO("Call FDC connectToServer success\n");
	}
	return true;
}

/*********************************************************************************
函数名称：DisconnectFDCAxn
功能描述： 断开FDC节点连接

修改记录:
2015-04-20 创建
*******************************************************************************/
void nsGEN::SMZDevice::DisconnectFDCAxn()
{
	//FDC
	if (m_pFDCAxnClient)
	{

		CAxnClientIFCreator::deleteAxnClientIF(m_pFDCAxnClient);
		m_pFDCAxnClient = NULL;

		PRINTA_INFO("deleteFDCAxnClientIF\n");
	}//ENDIF
}

/*********************************************************************************
函数名称：TurnOffRequest
功能描述： 设置FLC关闭请求确认到XCU端

修改记录:
2021-04-20 创建
*******************************************************************************/
void nsGEN::SMZDevice::TurnOffRequest()
{
	if (m_pAxnClient)
	{
		inlist_red_t1 inlistRedObj;
		int no_objects_p = 0;
		inlist_red_t2* pinlist_red_t2_p = NULL;

		unsigned int iObjectSize = sizeof(*pinlist_red_t2_p) * no_objects_p;

		inlistRedObj.header.length = (int)(sizeof(inlistRedObj)) + iObjectSize;
		inlistRedObj.header.mode = ACS_MODE_FUNCTIONAL;
		inlistRedObj.header.target = ACS_NO_TARGET;
		inlistRedObj.header.group_index = 0x01;
		inlistRedObj.header.sender = Clientsender;
		inlistRedObj.header.id = INLIST_RED;

		inlistRedObj.no_objects = (ACS_DCOUNT)no_objects_p;

		// Allocate memory for the data to be sent.
		ACS_BYTE* pDataForSending = new ACS_BYTE[inlistRedObj.header.length * 2];
		if (pDataForSending == NULL)
		{
			//DO NOTHING
		}//ENDIF

		// Copy all objects together in a continous section of memory.
		ACS_BYTE* pCh = pDataForSending;
		::memcpy(pCh, &inlistRedObj, sizeof(inlistRedObj));
		pCh += sizeof(inlistRedObj);
		::memcpy(pCh, pinlist_red_t2_p, iObjectSize);

		// Send the resulting memory section.
		ACS_ENUM axnResult = CAxnClientIF::sendObjectToServer(pDataForSending);

		// Release memory.
		delete[] pDataForSending;
		pDataForSending = NULL;

		if (axnResult != ACS_AXN_OK)
		{
			//DO Nothing
		}//ENDIF

		pCh = NULL;
		PRINTA_DEBUG("Turnoff request\n");

	}//ENDIF
}

/*********************************************************************************
函数名称：ReveiveFDCData
功能描述： 接受探测器报文函数

修改记录:
2020-04-20 创建
*******************************************************************************/
DWORD nsGEN::SMZDevice::ReveiveFDCData(LPVOID pParam)
{
	nsGEN::SMZDevice* pCurOpr = (nsGEN::SMZDevice*)pParam;
	while (true)
	{
		if (pCurOpr->m_pFDCBuffer == NULL)
		{
			return 1;
		}//ENDIF

		axn_status status;
		try {
			::ZeroMemory(pCurOpr->m_pFDCBuffer, MAX_LEN_ACS_OBJ * sizeof(axn_byte));
			try
			{
				status = pCurOpr->m_pFDCAxnClient->recvObject((ACS_BYTE*)pCurOpr->m_pFDCBuffer);
			}
			catch (...)
			{
				PRINTA_ERROR("Crash FDC, m_pFDCAxnClient->recvObject\n");
			}

			if (status == ACS_AXN_NOK)
			{
				PRINTA_INFO("Some Error when AxnClient recvObject\n");
				Sleep(2 * AXN_DUMMYTIME_BASE_RATE_IN_MS * 1);

				if (pCurOpr->m_nFDCLostConnectNumber >= 5)
				{
					//m_data.m_gen.m_strsErrorCodeGet = "01000002"; //communication fail 断线
					string code = "ReceiveError";
					string info = "Can't receive the command from generator,Please reboot the system.";
					int level = CONNECTIONERROR;
					pCurOpr->m_MSGUnit->AddErrorMessage(code.c_str(), level, info.c_str(), 0xF3);
				}
				else
				{
					pCurOpr->m_nFDCLostConnectNumber++;
				}

				PRINTA_ERROR("FDC communication fail\n");
				printf("!!!!!!!!FDC communication fail!!!!!!!! \n");
				pCurOpr->DisconnectFDCAxn();
				Sleep(2000);
				pCurOpr->FDCConnectXCS();
			}
			else if (status == ACS_AXN_TIMEOUT)
			{
				PRINTA_ERROR("FDC receive communication Timeout\n");
			}
			else
			{
				if (pCurOpr->m_nFDCLostConnectNumber > 0)
				{
					pCurOpr->m_nFDCLostConnectNumber = 0;
				}
				if (pCurOpr->m_pFDCBuffer != NULL)
				{
					acs_obj_header_t* tel_hdr_p;
					tel_hdr_p = (acs_obj_header_t*)pCurOpr->m_pFDCBuffer;
					try {
						if (tel_hdr_p->length <= MAX_LEN_ACS_OBJ)
						{
							if (tel_hdr_p->id != DUMMY_MSG)
							{
								axn_byte* pFDCBuffer;
								pFDCBuffer = new axn_byte[MAX_LEN_ACS_OBJ];
								::ZeroMemory(pFDCBuffer, MAX_LEN_ACS_OBJ * sizeof(axn_byte));
								::memcpy(pFDCBuffer, pCurOpr->m_pFDCBuffer, MAX_LEN_ACS_OBJ * sizeof(axn_byte));

								EnterCriticalSection(&pCurOpr->m_csFDCData);
								pCurOpr->m_sFDCCallbackData.push_back(pFDCBuffer);
								LeaveCriticalSection(&pCurOpr->m_csFDCData);
								SetEvent(pCurOpr->m_hFDCDataEvent);
							}

							if (pCurOpr->m_nTimeoutCount != 0)
							{
								pCurOpr->m_nTimeoutCount = 0;
								PRINTA_INFO("ReceiveFDCCommand get command, then set TimeoutCount to 0\n");
							}

						}
						else
						{
							PRINTA_ERROR("Get a error command: > max_len_acs_obj\n");
						}

					}
					catch (...)
					{
						PRINTA_ERROR("Crash log 1, other error\n");
					}
				}
				else
				{
					PRINTA_ERROR("m_pFDCBuffer = NULL\n");
				}
			}
		}
		catch (...)
		{
			PRINTA_ERROR("Crash log 2, other error\n");
		}

		if (pCurOpr->m_bExited)
		{
			break;
		}
	}
	return 1;
}

DWORD  nsGEN::SMZDevice::FDCDataThread(LPVOID pParam)
{
	nsGEN::SMZDevice* pCurOpr = (nsGEN::SMZDevice*)pParam;
	while (true)
	{
		axn_byte* dd;
		bool bGetData = false;
		EnterCriticalSection(&pCurOpr->m_csFDCData);
		if (!pCurOpr->m_sFDCCallbackData.empty())
		{
			bGetData = true;
			dd = pCurOpr->m_sFDCCallbackData.front();
			pCurOpr->m_sFDCCallbackData.pop_front();
			LeaveCriticalSection(&pCurOpr->m_csFDCData);
		}
		else
		{
			LeaveCriticalSection(&pCurOpr->m_csFDCData);
			WaitForSingleObject(pCurOpr->m_hFDCDataEvent, 50);
		}
		if (bGetData)
		{
			pCurOpr->FDCCallback((acs_obj_header_t*)dd);
			if (dd != NULL)
			{
				delete[] dd;
				dd = NULL;
			}
		}//ENDIF

		if (pCurOpr->m_bExited)
		{
			break;
		}
	}
	return 0;
}

/*********************************************************************************
函数名称：FDCCallback
功能描述： 将获取到的与探测器相关的报文对应到相应的解析函数

修改记录:
2015-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::FDCCallback(const acs_obj_header_t* pCommand)
{
	printf("== IN == FDC Telegram ID: %x \n", pCommand->id);
	try
	{
		switch (pCommand->id)
		{
		case UINT16(INIT_MSG):
			PRINTA_INFO("== IN == : FDC INIT_MSG\n");
			SendListFDC();
			SendTelegramLog("0xF4 INIT_MSG");
			break;
		case UINT16(TURN_ON):
			PRINTA_INFO("== IN == : FDC TURN_ON\n");
			CallbackFDCTurnOn((ACS_BYTE*)pCommand);
			break;
		case UINT16(TURN_OFF):
			PRINTA_INFO("== IN == : FDC TURN_OFF\n");
			CallBackFDCTurnOff((ACS_BYTE*)pCommand);
			break;
		case UINT16(SH_SS):
			PRINTA_INFO("== IN == : FDC SH_SS\n");
			CallBackSHSS((ACS_BYTE*)pCommand);
			break;
		case UINT16(SH_RADIATION):
			PRINTA_INFO("== IN == : FDC SH_RADIATION\n");
			CallBackSHRA((ACS_BYTE*)pCommand);
			break;
			//case UINT16(IANLBEREIT):
			//	PRINTA_INFO(m_pLog, _T("== IN == : FDC IANLBEREIT"));
			//	CallBackIANLBEREIT((ACS_BYTE*)pCommand);
			//	break;
		case UINT16(INETZAUFNAHME):
			PRINTA_INFO("== IN == : FDC INETZAUFNAHME\n");
			SendTelegramLog("0xF4 INETZAUFNAHME");
			EnterCriticalSection(&m_csStatus);
			m_bFDCIdentStatus = true;
			LeaveCriticalSection(&m_csStatus);
			break;
		case UINT16(DUMMY_MSG):
			break;
		default:
			break;
		}
	}
	catch (...)
	{
		PRINTA_ERROR("Call FDC Data: Carsh\n");
	}
	return true;
}

/*********************************************************************************
函数名称：SendListFDC
功能描述：设置DROC端需要从PMS端接收的报文清单

修改记录:
2021-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SendListFDC(void)
{
	ACS_WORD szID[FDC_MESSAGE_NUM] = { RQ_OBJECT,
		SH_MODE,
		SH_READY,
		SPATWECHSEL,
		ST_CONFIG,
		ST_DATA_TRANS,
		ST_MODE,
		TURN_ON,
		TURN_OFF,
		SH_SS,
		SH_RADIATION,
		SAUFNAUSL,
		SDETEKTORSTART,
		SAUSLBED,
		IANLBEREIT,
		INETZAUFNAHME,
		DUMMY_MSG
	};

	inlist_enh_t1_tag szSendGen = {};
	m_stGenCommandFDC.id = INLIST_ENH;
	m_stGenCommandFDC.sender = FDC_Controlsender;
	m_stGenCommandFDC.mode = 0;
	m_stGenCommandFDC.target = 0;
	m_stGenCommandFDC.group_index = Clientgroup_index;
	m_stGenCommandFDC.length = m_wHeaderLength + (FDC_MESSAGE_NUM + 1) * sizeof(ACS_WORD);
	szSendGen.no_objects = FDC_MESSAGE_NUM;
	szSendGen.header = m_stGenCommandFDC;

	ACS_BYTE* p_ID = new ACS_BYTE[m_stGenCommandFDC.length * 2];
	::memset(p_ID, 0, m_stGenCommandFDC.length * sizeof(ACS_BYTE) * 2);
	::memcpy((ACS_BYTE*)p_ID, (ACS_BYTE*)(&szSendGen), m_wHeaderLength + sizeof(ACS_WORD));
	::memcpy((ACS_BYTE*)(p_ID + m_wHeaderLength + sizeof(ACS_WORD)),
		(ACS_BYTE*)(&szID), FDC_MESSAGE_NUM * sizeof(ACS_WORD));

	if (m_pFDCAxnClient != NULL)
	{
		m_pFDCAxnClient->sendObject((ACS_BYTE*)p_ID);
		SendTelegramLog("INLIST_ENH", "", m_stGenCommand.sender, 0);

	}//ENDIF

	delete[]p_ID;
	p_ID = NULL;
	PRINTA_DEBUG("== SEND == : INLIST_ENH(FDC LIST)\n");

	return true;
}

/*********************************************************************************
函数名称：SendIdentFDC
功能描述： 设置F4状态到FO端

修改记录:
2021-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::SendIdentFDC(void)
{
	iident_t1 szSendGen = {};
	m_stGenCommandFDC.id = IIDENT;
	m_stGenCommandFDC.length = m_wHeaderLength + 3 * sizeof(ACS_BYTE) + 10 * sizeof(ACS_STRING_8) + 3 * sizeof(ACS_DUMMY);
	m_stGenCommandFDC.mode = Clientmode;
	m_stGenCommandFDC.sender = FDC_Controlsender;
	m_stGenCommandFDC.group_index = Clientgroup_index;
	m_stGenCommandFDC.target = Clienttarget;
	szSendGen.fetyp = BILDVERARBEITUNG;
	szSendGen.knotenid = FDC_Controlsender;
	szSendGen.apid = FDC_Controlsender;

	ACS_STRING_8 temp[10] = "FLSP_COMP";
	::memcpy(szSendGen.kompname, temp, 10);

	szSendGen.header = m_stGenCommandFDC;

	if (m_pFDCAxnClient != NULL)
	{
		m_pFDCAxnClient->sendObject((ACS_BYTE*)&szSendGen);
		PRINTA_DEBUG("== SEND == : IIDENT\n");
		SendTelegramLog("IIDENT", "", m_stGenCommand.sender, 0);
	}//ENDIF
	else
	{
		PRINTA_DEBUG("== SEND == : IIDENT is not successful\n");
	}
	return true;
}

/*********************************************************************************
函数名称：CallbackFDCTurnOn
功能描述：对TurnOn消息进行反馈处理

修改记录:
2017-10-16 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallbackFDCTurnOn(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//ENDIF

	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	PRINTA_DEBUG("callback FDC Turn on : object_id: %x\n", object_id);

	if ((!m_bFDCIdentStatus) && (object_id == Clienttarget))
	{
		SendIdentFDC();
		PRINTA_INFO("callback: m_bFDCIdentStatus = true\n");

		string code = "TurnOff";
		string info = "";
		int level = CONNECTIONERROR;
		m_MSGUnit->DelErrorMessage(code.c_str(), level, info.c_str());
	}//ENDIF

	std::ostringstream buffer;
	buffer << "object_id:" << (int)object_id;
	string str = buffer.str();
	SendTelegramLog("0xF4 TURN_ON", str.c_str(), object_id);

	return true;
}

///*********************************************************************************
//函数名称：CallBackFDCTurnOff
//功能描述： 解析当前F4节点关闭状态信息（turn off message）
//修改记录:
//2021-04-20 创建
//*******************************************************************************/
bool nsGEN::SMZDevice::CallBackFDCTurnOff(ACS_BYTE* Command)
{
	if (Command == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//ENDIF

	ACS_BYTE* stmpBuffer = Command;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	PRINTA_DEBUG("callback F4 Trun Off : object_id: %x\n", object_id);

	std::ostringstream buffer;
	buffer << "object_id:" << std::hex << (int)object_id <<"h";
	string str = buffer.str();
	SendTelegramLog("0xF4 TURN_OFF", str.c_str(), object_id);

	string code = "";
	string info = "";
	int level = 0;

	if (object_id == Clienttarget)
	{
		TimeOutWaring();
		if (m_bFDCIdentStatus)
		{
			m_bFDCIdentStatus = false;
			PRINTA_INFO("callback: Get FDC Client sender,m_bFDCIdentStatus = false\n");
		}//ENDIF
		code = "TurnOff";
		info = "Lost communication to generator, Please reboot the system.";
		level = CONNECTIONERROR;
		m_MSGUnit->AddErrorMessage(code.c_str(), level, info.c_str(), 0xF3);
	}//ENDIF
	return true;
}

/*********************************************************************************
函数名称：CallBackSHSS
功能描述： 用来切换DROC当前是否要处于服务模式；

修改记录:
2015-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallBackSHSS(ACS_BYTE* pCommand)
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//ENDIF
	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_ENUM hw_switch = (*(ACS_ENUM*)(stmpBuffer + 8));
	ACS_ENUM sw_switch = (*(ACS_ENUM*)(stmpBuffer + 9));
	ACS_ENUM serv_rad_switch = (*(ACS_ENUM*)(stmpBuffer + 10));

	PRINTA_INFO("CallBackSHSS: hw_switch=%d, sw_switch=%d, serv_rad_switch=%d\n", hw_switch, sw_switch, serv_rad_switch);

	int nCode = serv_rad_switch;

	m_UIClientUnit.m_SHS->Update(nCode);
	FireNotify(m_UIClientUnit.m_SHS->GetKey(), m_UIClientUnit.m_SHS->JSGet());

	std::ostringstream buffer;
	buffer << "hw_switch:" << (int)hw_switch << ", sw_switch:" << (int)sw_switch << ", serv_rad_switch:" << (int)serv_rad_switch;
	string str = buffer.str();
	SendTelegramLog("0xF4 SH_SS", str.c_str(), object_id);
	return true;
}
/*********************************************************************************
函数名称：CallBackSHRA
功能描述： 记录状态信息，仅为记录（ confirm start/stop of xray,
released by software and hands free movement controlled by software  ）
对应需求：IS_automatic_calibration、IS_hm_UserCalibNoUserOperation(VERSION_RAD3-VA10)、IS_Service_xrayrelease

修改记录:
2021-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallBackSHRA(ACS_BYTE* pCommand)//TODO
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//ENDIF

	if (!m_bCalibMode)
	{
		PRINTA_INFO("Not in AutoCalibration, CallBackSHRA return\n");
		return true;
	}//ENDIF

	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_ENUM rad_ack = (*(ACS_ENUM*)(stmpBuffer + 8));
	ACS_ENUM ecg_sim_ack = (*(ACS_ENUM*)(stmpBuffer + 9));
	ACS_BYTE alive_tag = (*(ACS_ENUM*)(stmpBuffer + 10));
	ACS_ENUM sw_control_status = (*(ACS_ENUM*)(stmpBuffer + 9));

	PRINTA_INFO("CallBackSHRA: rad_ack=%d\n", rad_ack);

	std::ostringstream buffer;
	buffer << "rad_ack:" << (int)rad_ack << ",ecg_sim_ack:" << (int)ecg_sim_ack << ",alive_tag:"
		<< (int)alive_tag << ",sw_control_status:" << (int)sw_control_status;
	string str = buffer.str();
	SendTelegramLog("0xF4 SH_RADIATION", str.c_str(), object_id);
	return true;
}

/*********************************************************************************
函数名称：CallbackSystemParam
功能描述： 解析当前workstation设置状态（是否成功）

修改记录:
2015-04-20 创建
*******************************************************************************/
bool nsGEN::SMZDevice::CallbackWorkstationFromXCU(ACS_BYTE* pCommand)//for system status 
{
	if (pCommand == NULL)
	{
		PRINTA_ERROR("Get command is Null");
		return false;
	}//ENDIF

	ACS_BYTE* stmpBuffer = pCommand;
	ACS_BYTE object_id = (*(ACS_BYTE*)(stmpBuffer + 5)); //sender
	ACS_BYTE nSystemNr = (*(ACS_BYTE*)(stmpBuffer + 8));
	ACS_BYTE nstrahler = (*(ACS_BYTE*)(stmpBuffer + 9));
	ACS_BYTE nsysok = (*(ACS_BYTE*)(stmpBuffer + 10));  //if workstation set ok

	int nWS = 0;
	if (1 == nsysok)
	{
		WSGen2UI(nSystemNr, nWS);
		//m_SiemensSalmon_Element[CMD_ELEMENT_WS].fGetValue = nWS;   //202110 设置工作位到UI端
		//m_pGenDose->GenUnitLogic::SetValue(nWS, Gen_Param_WORKSTATION);
		m_DoseUnit.m_WS->Update(nWS);
		FireNotify(m_DoseUnit.m_WS->GetKey(), m_DoseUnit.m_WS->JSGet());

		if (m_bReGetTurnOn)
		{
			if (m_bCalibMode)
			{
			}
			else
			{
				//202110 设置APR参数
				SendOrthoLocalParam(AprParamBackup.nWS,
					AprParamBackup.fKV,
					AprParamBackup.fMA,
					AprParamBackup.fMS,
					AprParamBackup.fMAS,
					AprParamBackup.nFocus,
					AprParamBackup.nTechmode,
					AprParamBackup.nAECField,
					AprParamBackup.nAECFilm,
					AprParamBackup.nAECDensity);
				PRINTA_INFO("CallBack isystemanz:1 ,ReTurnOn, Resend APR Parameter\n");
			}
			EnterCriticalSection(&m_csStatus);
			m_bReGetTurnOn = false;
			PRINTA_INFO("CallBack isystemanz:m_bReGetTurnOn = false\n");
			LeaveCriticalSection(&m_csStatus);
		}
	}
	//else
	//{
	//	m_data.m_gen.m_nmWorkStation = -2; //show workstation set fail; 20160923  //2021-04-21 待完善功能：需要设置到UI端
	//}

	PRINTA_INFO("== CallbackWorkstationFromXCU == Number of the system : %d, Number of active tube : %d, System is ready : %d, m_nWS : %d\n", nSystemNr, nstrahler, nsysok, nWS);

	std::ostringstream buffer;
	buffer << "Number of the system:" << (int)nSystemNr
		<< ", Number of active tube:" << (int)nstrahler
		<< ", System is ready :" << (int)nsysok
		<< ", nWS:" << (int)nWS;
	string str = buffer.str();
	SendTelegramLog("ISYSTEMANZ", str.c_str(), object_id);
	return true;
}

RET_STATUS nsGEN::SMZDevice::IncKV ()
{
	if (!m_DoseUnit.m_KV->CanInc ())  return RET_STATUS::RET_SUCCEED;
	int nKV = 0;
	int nPos = 0;

	if ((float)m_DoseUnit.m_KV->Get() < (float)m_fKVmin)
	{
		nKV = (int)((float)m_fKVmin * 10);
		nPos = GetFacKvValue(nKV);
	}
	else if ((float)m_DoseUnit.m_KV->Get() >= (float)m_fKVmax)
	{
		nKV = (int)((float)m_fKVmax * 10);
		nPos = GetFacKvValue(nKV);
	}
	else
	{
		nKV = (int)((float)m_DoseUnit.m_KV->Get() * 10);
		nPos = GetFacKvValue(nKV);
		nPos += 1;
	}

	if (nPos >= (int)(g_KV_List.size()))
	{
		nPos = (int)(g_KV_List.size()) - 1;
	}
	else
	{
		//DO NOTHING
	}//ENDIF
	nKV = g_KV_List[nPos];
	SendGenData(DFR_BEDIENUNG, SELEKTIONSTASTEN, KV, nKV);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::DecKV ()
{
	if (!m_DoseUnit.m_KV->CanDec ())  return RET_STATUS::RET_SUCCEED;
	int nKV = 0;
	int nPos = 0;
	if ((float)m_DoseUnit.m_KV->Get() > (float)m_fKVmax)
	{
		nKV = (int)((float)m_fKVmax * 10);
		nPos = GetFacKvValue(nKV);
	}
	else if ((float)m_DoseUnit.m_KV->Get() <= (float)m_fKVmin)
	{
		nKV = (int)((float)m_fKVmin * 10);
		nPos = GetFacKvValue(nKV);
	}
	else
	{
		nKV = (int)((float)m_DoseUnit.m_KV->Get() * 10);
		nPos = GetFacKvValue(nKV);

		if (nPos > 0)
		{
			nPos -= 1;
		}
	}
	//ENDIF
	nKV = g_KV_List[nPos];

	SendGenData(DFR_BEDIENUNG, SELEKTIONSTASTEN, KV, nKV);
	return RET_STATUS::RET_SUCCEED;
}

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

	if (abs(value - (float)m_DoseUnit.m_KV->Get()) < 0.001)
	{
		return RET_STATUS::RET_FAILED;
	}//ENDIF
	int nKV = (int)value * 10;
	int nPos = GetFacKvValue(nKV);
	int ntempKV = g_KV_List[nPos];

	SendGenData(DFR_BEDIENUNG, SELEKTIONSTASTEN, KV, ntempKV);
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsGEN::SMZDevice::IncMA ()
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::DecMA ()
{
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsGEN::SMZDevice::SetMA (float value)
{
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsGEN::SMZDevice::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\n");
		return RET_STATUS::RET_FAILED;
	}

	int nms = 0;
	int nPos = 0;
	if ((float)m_DoseUnit.m_MS->Get() >= (float)m_fMSmax)
	{
		nms = (int)((float)m_fMSmax * 1000);
		nPos = GetFacmSValue(nms);
	}//ENDIF
	else if ((float)m_DoseUnit.m_MS->Get() < (float)m_fMSmin)
	{
		nms = (int)((float)m_fMSmin * 1000);
		nPos = GetFacmSValue(nms);
	}
	else
	{
		nms = (int)((float)m_DoseUnit.m_MS->Get() * 1000);
		nPos = GetFacmSValue(nms);
		nPos += 1;
	}
	if (nPos < (int)g_MS_List.size())
	{
		nms = g_MS_List[nPos] / 10;
	}
	else
	{
		nPos = (int)(g_MS_List.size()) - 1;
		nms = g_MS_List[nPos] / 10;
	}//ENDIF
	if ((int)m_DoseUnit.m_Techmode->Get() != TECHMODE_NOAEC_3P)
	{
		nms = (int)((float)m_fMSmin * 100);
	}//ENDIF

	SendGenData(DFR_BEDIENUNG, SELEKTIONSTASTEN, MS, nms, 1);
	PRINTA_INFO("Set INCMS: %f,To generator:%d\n", (float)m_DoseUnit.m_MS->Get(), nms);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::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;
	}
	int nms = 0;
	int nPos = 0;
	if ((float)m_DoseUnit.m_MS->Get() <= (float)m_fMSmin)
	{
		nms = (int)(m_fMSmin * 1000);
		nPos = GetFacmSValue(nms);
	}//ENDIF
	else if ((float)m_DoseUnit.m_MS->Get() > (float)m_fMSmax)
	{
		nms = (int)((float)m_fMSmax * 1000);
		nPos = GetFacmSValue(nms);
	}
	else
	{
		nms = (int)((float)m_DoseUnit.m_MS->Get() * 1000);
		nPos = GetFacmSValue(nms);

		if (nPos > 0)
		{
			nPos -= 1;
		}
	}

	nms = g_MS_List[nPos] / 10;
	if ((int)m_DoseUnit.m_MS->Get() != TECHMODE_NOAEC_3P)
	{
		nms = (int)(m_fMSmin * 100);
	}//ENDIF

	SendGenData(DFR_BEDIENUNG, SELEKTIONSTASTEN, MS, nms, 1);

	PRINTA_INFO("Set DECMS: %f,To generator:%d\n", (float)m_DoseUnit.m_MS->Get(), nms);
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsGEN::SMZDevice::SetMS (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 MS\n");
		return RET_STATUS::RET_FAILED;
	}

	if (abs(value - (float)m_DoseUnit.m_MS->Get()) < 0.001)
	{
		return RET_STATUS::RET_SUCCEED;
	}//ENDIF

	int nMS = (int)(value * 1000);
	int nPos = GetFacmSValue(nMS);
	int ntempmS = g_MS_List[nPos] / 100;

	PRINTA_INFO("Set SetMS: %f,To generator:%d\n", value, ntempmS);
	SendGenData(DFR_BEDIENUNG, SELEKTIONSTASTEN, MS, ntempmS, 1);
	return RET_STATUS::RET_SUCCEED;
}

//
RET_STATUS nsGEN::SMZDevice::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\n");
		return RET_STATUS::RET_FAILED;
	}
	int nmAs = 0;
	int nPos = 0;
	if ((float)(float)m_DoseUnit.m_MAS->Get() >= m_fMASmax)
	{
		nmAs = (int)((float)m_fMASmax * 1000);
		nPos = GetFacmAsValue(nmAs);
	}//ENDIF
	else if ((float)(float)m_DoseUnit.m_MAS->Get() < (float)m_fMASmin)
	{
		nmAs = (int)((float)m_fMASmin * 1000);
		nPos = GetFacmAsValue(nmAs);
	}
	else
	{
		nmAs = (int)((float)m_DoseUnit.m_MAS->Get() * 1000);
		nPos = GetFacmAsValue(nmAs);
		nPos += 1;
	}

	if (nPos < (int)(g_MAS_List.size()))
	{
		nmAs = g_MAS_List[nPos] / 10;
	}
	else
	{
		nPos = (int)(g_MAS_List.size()) - 1;
		nmAs = g_MAS_List[nPos] / 10;
	}//ENDIF

	SendGenData(DFR_BEDIENUNG, SELEKTIONSTASTEN, MAS, nmAs, 1);

	if (g_MAS_List[nPos] == 560) // Siemens方面特殊要求
	{
		SendGenData(DFR_BEDIENUNG, PLUS_MINUS_TASTEN, MAS, 20, 1); //2为Siemens方面要求 特殊要求取消 20180308
	}//ENDIF

	PRINTA_INFO("Set INCMAS: %f,To generator:%d,nPos:%d\n", (float)(float)m_DoseUnit.m_MAS->Get(), nmAs, nPos);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SMZDevice::DecMAS ()
{
	if (!m_DoseUnit.m_MAS->CanDec ())  return RET_STATUS::RET_SUCCEED;

	int nmAs = 0;
	int nPos = 0;
	if ((float)m_DoseUnit.m_MAS->Get()<= (float)m_fMASmin)
	{
		nmAs = (int)((float)m_fMASmin * 1000);
		nPos = GetFacmAsValue(nmAs);
	}//ENDIF
	else if ((float)m_DoseUnit.m_MAS->Get() > (float)m_fMASmax)
	{
		nmAs = (int)((float)m_fMASmax * 1000);
		nPos = GetFacmAsValue(nmAs);
	}
	else
	{
		nmAs = (int)((float)m_DoseUnit.m_MAS->Get() * 1000);
		nPos = GetFacmAsValue(nmAs);

		if (nPos > 0)
		{
			nPos -= 1;
		}
	}

	nmAs = g_MAS_List[nPos] / 10;

	if (g_MAS_List[nPos] == 560) //Siemens要求
	{
		SendGenData(DFR_BEDIENUNG, SELEKTIONSTASTEN, MAS, 60, 1);
		SendGenData(DFR_BEDIENUNG, PLUS_MINUS_TASTEN, MAS, 40, 1); //siemens要求 特殊要求取消 20180308

	}//ENDIF
	else
	{
		SendGenData(DFR_BEDIENUNG, SELEKTIONSTASTEN, MAS, nmAs, 1);
	}

	PRINTA_INFO("Set DECMAS: %f,To generator:%d,nPos:%d\n", (float)m_DoseUnit.m_MAS->Get(), nmAs, nPos);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SMZDevice::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;
	}
	int nmAs = (int)(value * 1000);
	int nPos = GetFacmAsValue(nmAs);

	if (nPos < (int)(g_MAS_List.size()))
	{
		nmAs = g_MAS_List[nPos] / 10;
	}
	else if (nPos >= (int)g_MAS_List.size())
	{
		nPos = (int)(g_MAS_List.size()) - 1;
		nmAs = g_MAS_List[nPos] / 10;
	}
	else if (nPos <= 0)
	{
		nPos = 0;
		nmAs = g_MAS_List[0] / 10;
	}

	SendGenData(DFR_BEDIENUNG, SELEKTIONSTASTEN, MAS, nmAs, 1);
	return RET_STATUS::RET_SUCCEED;
}

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

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

	if (value == FOCUS_SMALL)
	{
		value = 1; //小焦点
	}
	else if (value == FOCUS_LARGE)
	{
		value = 2; //大焦点
	}
	else
	{
		value = 3; //自动焦点
	}

	PRINTA_INFO("Set FocusSel: %d,To generator:%d\n", nFOSetting, value);

	std::ostringstream buffer;
	buffer << "Focus:" << value << "(1=small; 2=large)";
	string str = buffer.str();
	SendTelegramLog("SBEDGEN", str.c_str(), 0xF3,0);

	SendGenData(DFR_BEDIENUNG, SELEKTIONSTASTEN, FOKUS, value);
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsGEN::SMZDevice::SetAECDensity (int value)
{
	if (!m_DoseUnit.m_AECDensity->Verify (value))  return RET_STATUS::RET_SUCCEED;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::SetAECField (int value)
{
	if (!m_DoseUnit.m_AECField->Verify (value))  return RET_STATUS::RET_SUCCEED;

	int nAECField2Gen = 0;
	switch (value)
	{
	case FIELD_RIGHT:
		nAECField2Gen = RECHTS;
		break;
	case FIELD_CENTER:
		nAECField2Gen = MITTE;
		break;
	case FIELD_RIGHT_CENTER:
		nAECField2Gen = MITTE_RECHTS;
		break;
	case FIELD_LEFT:
		nAECField2Gen = LINKS;
		break;
	case FIELD_LEFT_RIGHT:
		nAECField2Gen = LINKS_RECHTS;
		break;
	case FIELD_CENTER_LEFT:
		nAECField2Gen = LINKS_MITTE;
		break;
	case FIELD_LEFT_CENTER_RIGHT:
		nAECField2Gen = LINKS_MITTE_RECHTS;
		break;
	default:
		nAECField2Gen = 0; //siemens要求 默认为0
		break;
	}

	//若当前在非AEC模式下，设置Techmode以及与AEC相关的参数（Density、Field、Dose，避免参数缺失）
	if (!((int)m_DoseUnit.m_Techmode->Get() == TECHMODE_AEC_3P)
		|| ((int)m_DoseUnit.m_Techmode->Get() == TECHMODE_AEC_2P)
		|| ((int)m_DoseUnit.m_Techmode->Get() == TECHMODE_AEC_1P)
		|| ((int)m_DoseUnit.m_Techmode->Get() == TECHMODE_AEC_1P_REDUCEMA))
	{
		SendsBEDSP(DFR_BEDIENUNG, SELEKTIONSTASTEN, DOSIS_BILD, (int)(m_fAECDensitymin * 1000));
	}
	SendGenData(DFR_BEDIENUNG, SELEKTIONSTASTEN, MESSFELD, nAECField2Gen);
	PRINTA_INFO("Set AECField: %d,To generator:%d\n", value, nAECField2Gen);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::SetAECFilm (int value)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS  nsGEN::SMZDevice::SetWS (const string value)
{
	PRINTA_INFO("Set WorkStation: %s\n", value.c_str());
	printf("Set WorkStation: %s\n", value.c_str());
	int tempws = 0;
	try
	{
		if (value == "Table")  tempws = 0;
		else if (value == "Wall")  tempws = 1;
		else if (value == "Direct")  tempws = 2;
		else if (value == "Free")  tempws = 3;
	}
	catch (const std::exception&)
	{
		printf("SetWS Crash\n");
	}

	m_nSettingWS = tempws;

	AprParamBackup.nWS = tempws; //202110
	//SendOrthoLocalParam(AprParamBackup.nWS,
	//	AprParamBackup.fKV,
	//	AprParamBackup.fMA,
	//	AprParamBackup.fMS,
	//	AprParamBackup.fMAS,
	//	AprParamBackup.nFocus,
	//	AprParamBackup.nTechmode,
	//	AprParamBackup.nAECField,
	//	AprParamBackup.nAECFilm,
	//	AprParamBackup.nAECDensity);
		SendOrthoLocalParam(AprParamBackup.nWS,
			m_DoseUnit.m_KV->Get(),
			m_DoseUnit.m_MA->Get(),
			m_DoseUnit.m_MS->Get(),
			m_DoseUnit.m_MAS->Get(),
			m_DoseUnit.m_Focus->Get(),
			m_DoseUnit.m_Techmode->Get(),
			AprParamBackup.nAECField,     //Salmon环境中没有返回该参数，直接使用APR设置的参数
			AprParamBackup.nAECFilm,
			AprParamBackup.nAECDensity);

	PRINTA_INFO("Set WorkStation: %d,To generator:%d\n", m_nSettingWS, tempws);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::SetAPR (const _tAPRArgs& t)
{
	AprParamBackup.nWS = t.nWS;
	AprParamBackup.nFocus = t.nFocus;
	AprParamBackup.nTechmode = t.nTechmode;
	AprParamBackup.nAECField = t.nAECField;
	AprParamBackup.nAECFilm = t.nAECFilm;
	AprParamBackup.nAECDensity = t.nAECDensity;
	AprParamBackup.fKV = t.fKV;
	AprParamBackup.fMA = t.fMA;
	AprParamBackup.fMS = t.fMS;
	AprParamBackup.fMAS = t.fMAS;

	m_bSetAPR = true;
	SendOrthoLocalParam(AprParamBackup.nWS,
		AprParamBackup.fKV,
		AprParamBackup.fMA,
		AprParamBackup.fMS,
		AprParamBackup.fMAS,
		AprParamBackup.nFocus,
		AprParamBackup.nTechmode,
		AprParamBackup.nAECField,
		AprParamBackup.nAECFilm,
		AprParamBackup.nAECDensity);

	if (m_bGenService) //服务模式需要设置指令到PMS端
	{
		Sleep(50);
		SendOrthoLocalParam(AprParamBackup.nWS,
			AprParamBackup.fKV,
			AprParamBackup.fMA,
			AprParamBackup.fMS,
			AprParamBackup.fMAS,
			AprParamBackup.nFocus,
			AprParamBackup.nTechmode,
			AprParamBackup.nAECField,
			AprParamBackup.nAECFilm,
			AprParamBackup.nAECDensity,
			ClientPMS);
	}
	return RET_STATUS::RET_SUCCEED;
}

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

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

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

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

RET_STATUS nsGEN::SMZDevice::QueryPostMAS(float& value)
{
	if (WAIT_OBJECT_0 == WaitForSingleObject(m_hGenPostEvent, 2000))
	{
		value = m_DoseUnit.m_PostMAS->Get();
		return RET_STATUS::RET_SUCCEED;
	}
	else
	{
		value = 0.0;
		return RET_STATUS::RET_FAILED;
	}
}

RET_STATUS nsGEN::SMZDevice::Clear_DAP()
{
	m_DoseUnit.m_PostKV->Update(0);
	FireNotify(m_DoseUnit.m_PostKV->GetKey(), m_DoseUnit.m_PostKV->JSGet());

	m_DoseUnit.m_PostMA->Update(0);
	FireNotify(m_DoseUnit.m_PostMA->GetKey(), m_DoseUnit.m_PostMA->JSGet());

	m_DoseUnit.m_PostMS->Update(0);
	FireNotify(m_DoseUnit.m_PostMS->GetKey(), m_DoseUnit.m_PostMS->JSGet());

	m_DoseUnit.m_PostMAS->Update(0);
	FireNotify(m_DoseUnit.m_PostMAS->GetKey(), m_DoseUnit.m_PostMAS->JSGet());

	m_DAP->Update(0);
	FireNotify(m_DAP->GetKey(), m_DAP->JSGet());
	PRINTA_INFO("Clear_DAP: Clear Post Parameter(KV,mA,mS,mAs,Dap)");
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsGEN::SMZDevice::GetValue_DAP(float& value)
{
	if (WAIT_OBJECT_0 == WaitForSingleObject(m_hGenPostDAPEvent, 2000))
	{
		value = m_DAP->Get();
		return RET_STATUS::RET_SUCCEED;
	}
	else
	{
		//string strCode = "LostPostParm";
		//string strinfo = "IS can't receive IWATERVALACQ telegram from Axim,please check the DAP setting.";
		//int nlevel = MESSAGEBOX_CLEARERROR;
		//m_MSGUnit->AddWarnMessage(strCode.c_str(), nlevel, strinfo.c_str(), 0xF3);
		value = 0.0;
		return RET_STATUS::RET_FAILED;
	}
}

bool SMZDevice::DoExposure()
{
	PRINTA_INFO("DoExposure");

	if (m_bAlreadyExposure)
	{
		PRINTA_INFO("AlreadyExposure by SetGenSynState");
		return true;
	}

	m_bAlreadyExposure = true;
	SendIDETEKTORSTATUS(1); //打开窗口
	return true;
}

RET_STATUS nsGEN::SMZDevice::SetGenSynState(int value)
{
	PRINTA_INFO("SetGenSynState: %d",value);
	switch (value)
	{
	case AttrKey::GENERATOR_RAD_READY:
		if (m_DoseUnit.m_GenState->Get() == AttrKey::GENERATOR_STATUS_STANDBY)
		{
			SendSAUSLBED(1);  //自动曝光 按下手闸
			m_bAutoHandSwitch = false;
		}
		else
		{
			m_bAutoHandSwitch = true;
		}
		break;
	case AttrKey::GENERATOR_RAD_XRAYON:
	{
		try
		{
			m_nXwindowTime = (int)(m_GenConfig["XWindowOpenTimeout"]);
		}
		catch (...)
		{
			PRINTA_ERROR("Can't get the XWindowOpenTimeout value,default = 100ms\n");
		}

		DWORD tmNowTime = GetTickCount();
		int nSpanTime = tmNowTime - m_tmDetectorStart;

		if (nSpanTime <= 0)
		{
			nSpanTime += 1;
			PRINTA_INFO("Span Time = 0, add 1ms"); //siemens requirement 20230220
		}
		PRINTA_INFO("Span Time:%d,tmNowTime:%d, m_tmDetectorStart:%d,XWindowOpenTimeout:%d", nSpanTime, tmNowTime, m_tmDetectorStart,m_nXwindowTime);

		if (m_bAlreadyExposure)
		{
			PRINTA_INFO("AlreadyExposure by SetGenSynState");
			break;
		}

		if (!m_bCalibMode && (nSpanTime > m_nXwindowTime))
		{
			PRINTA_INFO("Omit Send IDETEKTORSTATUS");
			//int level = MESSAGEBOX_CLEARERROR;
			//const char* strSiemensCode = "60019";
			string strDisplayErrorTemp = "Omit Send IDETEKTORSTATUS,Xray isn't released, please try exposure again";
			//m_MSGUnit->AddWarnMessage(strSiemensCode, level, strDisplayErrorTemp.c_str(), 0xF3);
			SendTelegramLog("IDETEKTORSTATUS", strDisplayErrorTemp.c_str(), 0xF3, 1, SYS_LOG_LEVEL_Error, "60019");
			break;
		}
		else if (m_bCalibMode)
		{
			PRINTA_INFO("Send IDETEKTORSTATUS in calibration");
		}
		SendIDETEKTORSTATUS(1); //打开窗口
		m_bAlreadyExposure = true;
		break;
	}
	case AttrKey::GENERATOR_RAD_OFF:
		if (m_DoseUnit.m_GenSynState->Get() != AttrKey::GENERATOR_RAD_OFF)
		{
			if (m_bCalibMode)
			{
				SendSAUSLBED(0);  //用于FD自动校正 松开手闸
			}
			else
			{
				//此处会影响冻屏功能，对应bug13337，删除此处代码
				//m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_OFF);
				//FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
				//PRINTA_INFO("<GEN EXP>Get GENERATOR_RAD_OFF in normal, Direct set the synstate to RAD_OFF\n");
			}
		}
		else
		{
			PRINTA_INFO("<GEN EXP>already GENERATOR_RAD_OFF, Don't need to change GenSynState value\n");
		}
		
		break;
	default:
		break;
	}
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::SetGenState(int value)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::RefreshData ()
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::Reset()
{
	m_stGenCommand.id = SBEDALLG;
	m_stGenCommand.length = m_wHeaderLength + 2 * sizeof(ACS_ENUM) + 2 * sizeof(ACS_INT) + 2 * sizeof(ACS_DUMMY);
	m_stGenCommand.mode = Clientmode;
	m_stGenCommand.sender = Clientsender;
	m_stGenCommand.group_index = Clientgroup_index;
	m_stGenCommand.target = Clienttarget;

	sbedallg_t1_tag szSendGen = {};
	szSendGen.bedeinh = DFR_BEDIENUNG;
	szSendGen.bedienobj = SELEKTIONSTASTEN;
	szSendGen.fktscodeallg = FEHLER_LOESCHEN;
	szSendGen.param = 1; //Siemens 要求

	ACS_BYTE* sCommmand = new ACS_BYTE[(m_stGenCommand.length + 1) * 2];
	::memset(sCommmand, 0, (m_stGenCommand.length + 1) * sizeof(ACS_BYTE) * 2);
	::memcpy(sCommmand, &m_stGenCommand, 8);
	::memcpy(sCommmand + 8, &szSendGen.bedeinh, 1);
	::memcpy(sCommmand + 9, &szSendGen.bedienobj, 1);
	::memcpy(sCommmand + 10, &szSendGen.fktscodeallg, 2);
	::memcpy(sCommmand + 12, &szSendGen.param, 2);

	szSendGen.header = m_stGenCommand;
	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject(sCommmand);
		PRINTA_DEBUG("SBEDALLG  IS: Reset\n");
		SendTelegramLog("SBEDALLG", "", m_stGenCommand.sender, 0);
	}//ENDIF

	PRINTA_DEBUG("== SEND == : SBEDALLG (Reset)\n");

	delete[] sCommmand;
	sCommmand = NULL;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::SetExpMode(std::string value)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::SetFrameRate(FLOAT frameRate)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::SetFLFMode(std::string value)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::SetEXAMMode(std::string value)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::SetHET() //模拟测试热容量
{
	PRINTA_INFO("SetHET\n");
	TubeHeatTest();
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::SetSHO(bool state)//设置检查名称是否正确
{
	PRINTA_INFO("SetSHO,set the result of view name is %d\n", state);
	SetOrgNameStatus(state);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::SetSTA(int state)//设置软件状态
{
	PRINTA_INFO("SetSTA,set the software status is %d\n", state);
	SendIdfrStatus(state, state);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::SetPIM(const char* viewname)//设置当前view名称到TUI
{
	PRINTA_INFO("SetPIM,set Viewname %s\n", viewname);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::SetSSI(const char* key, const char* value)//设置系统信息
{
	PRINTA_INFO("SetSSI,set SystemStatusInformation key:%s,value:%s\n", key, value);
	string strCode = key;
	int nCode = atoi(strCode.c_str());
	SetSystemStatusInformation(nCode, value, ACS_DIAG_COMPLETED);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::SetSMV(const char* key, const char* value)//设置组件版本信息
{
	PRINTA_INFO("SetSMV,set module versionnumber:key:%s,value:%s\n", key, value);
	SetVersionInfor(key, value);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::SetCFM(const char* key, const char* value)//设置处理配置文件结果
{
	PRINTA_INFO("Set configure file resul key: %s, value: %s\n",key,value);
	string strCode = value;
	int nCode = atoi(strCode.c_str());
	SetSHCONFIG(nCode);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::SetBRM(int state)//设置backup结果
{
	PRINTA_INFO("Set Backup result\n");
	SetSH_DATA_TRANS(state, m_nBackup_Restre_Identifier);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::SetERA(int state)//检查最后错误数目
{
	PRINTA_INFO("check the last Error Number\n");
	GetLastErrorAmount();
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::SetPNS(int state)//病人属性
{
	PRINTA_INFO("check the Patient Status:%d", state);
	SetPatientStatus(state);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::SetScreenLockState(int state)
{
	PRINTA_INFO("Set ScreenLockState: %d\n", state);
	SetScreenSaver(state);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::SetFDSerialNumber(const char* key, const char* value)
{
	PRINTA_INFO("Set SendFPDSerialNumber: %s:%s\n", key, value);
	SendFPDSerialNumber(atoi(key),value);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::SetUIDoing(void)
{
	PRINTA_INFO("Set UIDoing\n");
	m_stGenCommand.id = IBINOK;
	m_stGenCommand.length = m_wHeaderLength + sizeof(ACS_STRING) *(VERSION_XCU_LENGTH + SVN_REVISION_LENGTH + VERSION_AXCS_LENGTH);
	m_stGenCommand.mode = Clientmode;
	m_stGenCommand.sender = Clientsender;
	m_stGenCommand.group_index = Clientgroup_index;
	m_stGenCommand.target = Clienttarget;

	ibinok_t1 szSendGen = {};

	szSendGen.header = m_stGenCommand;

	if (m_pAxnClient != NULL)
	{
		m_pAxnClient->sendObject((ACS_BYTE*)&szSendGen);
		SendTelegramLog("IBINOK", "IBINOK", m_stGenCommand.sender, 0);
	}//ENDIF

	PRINTA_INFO("== SEND == : IBINOK\n");
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::JSSetFPDCalibrationStatus(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	unsigned int nValue = json[0];
	PRINTA_INFO("OnCAL: %d", nValue);

	if (nValue == 1)//开始校正
	{
		//需要先发送ORGDATE，然后GetSwitchState（RQ_OJECT）
		m_bCalibMode = true;
		m_bGetIGENANZ = false;
		m_bSetEnable = false;
		SetST_SYSTEM_STATE(ACS_STATE_FDCALIB_RUNNING);
		PRINTA_INFO("--Func-- SetSatetySwitch \n");
		if (!SetSatetySwitch())//发送RQ_OBJECT,收到SH_SS，发送ST_SS; TODO 002
		{
			return RET_STATUS::RET_SUCCEED;;
		}//ENDIF
	}
	else if (nValue == 2)//接受校正结果;
	{
		if (!SendIDFRABSCHALTUNG())
		{
			return RET_STATUS::RET_SUCCEED;;
		}//ENDIF
	}
	else if (nValue == 3)//拒绝校正结果;
	{
		if(m_DoseUnit.m_GenSynState->Get() != AttrKey::GENERATOR_RAD_OFF)
		{
			m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_OFF);
			FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
			PRINTA_INFO("refuse calibration, clear the exposure status to OFF\n");
		}
		if (!SendIDFRABSCHALTUNG())
		{
			return RET_STATUS::RET_SUCCEED;;
		}//ENDIF
	}
	else if ((nValue == 4)||(nValue == 5))//终止校正 || 完成校正;
	{
		if (m_DoseUnit.m_GenSynState->Get() != AttrKey::GENERATOR_RAD_OFF)
		{
			m_DoseUnit.m_GenSynState->Update(AttrKey::GENERATOR_RAD_OFF);
			FireNotify(m_DoseUnit.m_GenSynState->GetKey(), m_DoseUnit.m_GenSynState->JSGet());
			PRINTA_INFO("Stop calibration, clear the exposure status to OFF\n");
		}
		m_bCalibMode = false;
		m_bGetIGENANZ = false;
		m_bSetEnable = false;
		SetST_SYSTEM_STATE(ACS_STATE_CONSISTENT);
	}
	//else if (nValue == 5)//完成校正;
	//{
	//	m_bCalibMode = false;
	//	m_bGetIGENANZ = false;
	//	m_bSetEnable = false;
	//	SetST_SYSTEM_STATE(ACS_STATE_CONSISTENT);
	//}
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::JSSetPanelSN(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	string strValue = json[0];
	PRINTA_INFO("SetPanelSN: %s", strValue);
	m_strPanelSN = strValue.c_str();
	SendFPDSerialNumber(ACS_FD_PORTABLE, strValue.c_str());
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::JSSendFPDError(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	string strBackCom = (string)json["P0"]["BackCommand"];

	int nValue = atoi(strBackCom.c_str());
	m_strPanelSN = (string)json["P0"]["DetectorSN"];

	PRINTA_INFO("SendFPDError: %d, SN: %s", nValue, m_strPanelSN.c_str());
	//SetFDErrorCode(nValue, BEHEB_FEHLER, m_strPanelSN);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::JSClearFPDError(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());

	string strBackCom = (string)json["P0"]["BackCommand"];

	int nValue = atoi(strBackCom.c_str());

	if (nValue == 0)
	{
		PRINTA_INFO("Clear all FPD Error");
	}
	else
	{
		PRINTA_INFO("ClearFPDError: %d", nValue);
	}

	//SetFDErrorCode(nValue, BEHEB_FEHLER, m_strPanelSN);
	//Reset();
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::JSSendFPDWarn(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	string strBackCom = (string)json["BackCommand"];

	int nValue = atoi(strBackCom.c_str());
	m_strPanelSN = (string)json["DetectorSN"];

	PRINTA_INFO("SendFPDWarn: %d, SN: %s", nValue, m_strPanelSN.c_str());

	//SetFDErrorCode(nValue, WARNUNG, m_strPanelSN);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::JSSendFPDStatus(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	unsigned int nValue = json[0];
	PRINTA_INFO("SendFPDStatus: %d", nValue);

	if (m_DoseUnit.m_WS->Get() != WS_CONVENTIONAL)
	{
		SendIdfrStatus(nValue, nValue);
	}
	else
	{
		PRINTA_INFO("Cassette mode, don't send the Detector status");
	}

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::JSFPDXWindowOpen(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	m_tmDetectorStart = json[0];
	PRINTA_INFO("JSFPDXWindowOpen time: %d", m_tmDetectorStart);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::RefreshParameterList(const char* ParamType, float* List, int ListCount, float maxvalue, float minvalue)
{
	string strtype = ParamType;
	ResDataObject temp;
	temp.update("Max", maxvalue);
	temp.update("Min", minvalue);
	temp.update("List", "");
	for (int i = 0; i < ListCount; i++)
	{
		char chindex[4] = { 0 };
		sprintf_s(chindex, "%d", i);
		temp["List"].add(chindex, List[i]);
	}

	if (strtype == "KVList")
	{
		m_DoseUnit.m_KVList->Update(temp.encode());
		FireNotify(m_DoseUnit.m_KVList->GetKey(),m_DoseUnit.m_KVList->JSGet());
	}
	else if (strtype == "MASList")
	{
		m_DoseUnit.m_mAsList->Update(temp.encode());
		FireNotify(m_DoseUnit.m_mAsList->GetKey(), m_DoseUnit.m_mAsList->JSGet());
		FireNotify(m_DoseUnit.m_KVList->GetKey(), m_DoseUnit.m_KVList->JSGet());
	}
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsGEN::SMZDevice::AuditMessage(const char* strTime, const char* strMessage)
{
	ResDataObject temp;
	temp.update("Time", strTime);
	temp.update("Message", strMessage);

	m_UIClientUnit.m_AuditMessage->Update(temp.encode());
	FireDataNotify(m_UIClientUnit.m_AuditMessage->GetKey(), m_UIClientUnit.m_AuditMessage->JSGet());
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS  nsGEN::SMZDevice::SetCollimatorSize(unsigned short xsize, unsigned short ysize)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS  nsGEN::SMZDevice::SetCollimatorSID(unsigned short sid)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS  nsGEN::SMZDevice::SetCollimatorFilter(unsigned short pParams)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS  nsGEN::SMZDevice::SetCollimatorAngle(float pParams)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS  nsGEN::SMZDevice::SetCollimatorMode(unsigned short pParams)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS  nsGEN::SMZDevice::SetCollimatorLight(unsigned short pParams)
{
	return RET_STATUS::RET_SUCCEED;
}
//-----------------------------------------------------------------------------
//		ProcessCmd
//-----------------------------------------------------------------------------

void nsGEN::SMZDevice::FireNotify (std::string key, std::string content)
{
	EventCenter->OnNotify (1, key, content);
}

void nsGEN::SMZDevice::FireDataNotify(std::string key, std::string content)
{
	EventCenter->OnNotify(ATTRACTION_MSG, key, content);
}

void nsGEN::SMZDevice::SendTelegramLog(const char* strTelegramKey, const char* strTelegramLog, int nSender, int nMode, int nTelegramType,const char* strCode) //已完善 20211029
{
	std::ostringstream buffer;
	buffer << "["<< strTelegramKey << "] " << strTelegramLog;
	string str = buffer.str();
	string strSender = std::to_string(nSender);
	if (nMode == 1) 
	{
		EventCenter->OnSystemLog(nTelegramType, strCode, str, strSender);
	}//Endif
	else
	{
		EventCenter->OnSystemLog(SYS_LOG_LEVEL_Telegram, strCode, str, strSender); //系统日志接口问题
	}
}

/*********************************************************************************
函数名称：WSUI2TUI
功能描述：切换workstations从UI到XCU，用于映射对应的workstation值

修改记录:
2021-4-22 创建

#define ACS_PF_WP_CASS                  (ACS_ENUM)    1                                        work place cassette
#define ACS_PF_WP_FREE                  (ACS_ENUM)    4                                   work place free exposure
#define ACS_PF_WP_TABLE                 (ACS_ENUM)    2                                           work place table
#define ACS_PF_WP_WALL                  (ACS_ENUM)    3                                      work place wall stand
*******************************************************************************/
void nsGEN::SMZDevice::WSUI2TUI(int nUIWS, int& nGenWS)
{
	if (nUIWS == WS_TABLE) //lying: cross mode
	{
		nGenWS = ACS_PF_WP_TABLE;
	}
	else if (nUIWS == WS_WALL) //standing mode
	{
		nGenWS = ACS_PF_WP_WALL;
	}
	else if (nUIWS == WS_FREE) //mobile mode
	{
		nGenWS = ACS_PF_WP_FREE;
	}
	else if (nUIWS == WS_TOMO) //tomo mode
	{
		nGenWS = ACS_PF_WP_TABLE;
	}
	else if (nUIWS == WS_CONVENTIONAL) //Conventional table
	{
		nGenWS = ACS_PF_WP_CASS;
	}
	else
	{
		nGenWS = ACS_PF_WP_CASS;
	}
	PRINTA_INFO("Set default WS: %d,TUI workstaion: %d\n", nUIWS, nGenWS);
}

///*********************************************************************************
//函数名称：mb2wc
//功能描述： 字符转换函数：宽字符转多字节
//修改记录:
//2021-04-20 创建
//*******************************************************************************/
string nsGEN::SMZDevice::wc2mb(const wchar_t* pwcstr)
{
	std::string strVal = "";
	int nSize = WideCharToMultiByte(CP_UTF8, 0, pwcstr, -1, NULL, 0, NULL, NULL);
	char* pszStr = new char[nSize + 1];
	if (pszStr)
	{
		memset(pszStr, 0, nSize * sizeof(char));
		int nRet = WideCharToMultiByte(CP_UTF8, 0, pwcstr, -1, pszStr, nSize, NULL, NULL);
		if (nRet != 0) // MultiByteToWideChar returns 0 if it does not succeed.
		{
			strVal = pszStr;
		}
		delete[] pszStr;
		pszStr = NULL;
	}
	return strVal;
}

///*********************************************************************************
//函数名称：mb2wc
//功能描述： 字符转换函数：多字节转宽字符
//修改记录:
//2021-04-20 创建
//*******************************************************************************/
wstring nsGEN::SMZDevice::mb2wc(const char* pszStr)
{
	std::wstring strVal = L"";
	int nSize = MultiByteToWideChar(CP_UTF8, 0, pszStr, -1, NULL, 0);
	wchar_t* pwcStr = new wchar_t[nSize + 1];
	if (pwcStr)
	{
		memset(pwcStr, 0, nSize * sizeof(wchar_t));
		int nRet = MultiByteToWideChar(CP_UTF8, 0, pszStr, -1, pwcStr, nSize);
		if (nRet != 0) // MultiByteToWideChar returns 0 if it does not succeed.
		{
			pwcStr[nSize] = '\0';
			strVal = pwcStr;
		}
		delete[] pwcStr;
		pwcStr = NULL;
	}
	return strVal;
}

void nsGEN::SMZDevice::DecodeBase64(string strMessageIn, wstring& strMessageOut)
{
	vector<unsigned char> listdata;
	CBase64::Decode(strMessageIn, listdata);
	strMessageOut = GetWString(listdata);
}

wstring nsGEN::SMZDevice::GetWString(vector<unsigned char>& listdata)
{
	wstring strOutData = L"";
	for (size_t i = 1; i < listdata.size(); i += 2)
	{
		wchar_t wchar = L'\000';
		unsigned char mchar[2] = { 0 };
		mchar[0] = listdata[i - 1];
		mchar[1] = listdata[i];
		memcpy(&wchar, mchar, 2);
		strOutData += wchar;
	}
	return strOutData;
}

///*********************************************************************************
//函数名称：SwitchLogLevel
//功能描述：切换日志属性类型
//对应需求：

//修改记录:
//2021-4-23 创建
//*******************************************************************************/
string nsGEN::SMZDevice::SwitchCategory2Str(ACS_ENUM nCatrgoryNumber)
{
	string strCategory = "";
	switch (nCatrgoryNumber)
	{
	case BEDIENEVENT:
		strCategory = A_BEDIENEVENT;
		break;
	case USERMESSAGE:
		strCategory = I_USERMESSAGE;
		break;
	case RESET_USERMSG_LEGACY:
		strCategory = X_RESET_USERMSG_LEGACY;
		break;
	case TELEGRAM:
		strCategory = T_TELEGRAM;
		break;
	case MSGBOX_NO_OK_NO_TUI:
		strCategory = O_MSGBOX_NO_OK_NO_TUI;
		break;
	case ORTHOMESSAGE:
		strCategory = O_ORTHOMESSAGE;
		break;
	case ACS_FLAG_RESET:
		strCategory = A_ACS_FLAG_RESET;
		break;
	case WARNUNG:
		strCategory = W_WARNUNG;
		break;
	case BEHEB_FEHLER:
		strCategory = R_BEHEB_FEHLER;
		break;
	case NICHT_BEHEB_FEHLER:
		strCategory = E_NICHT_BEHEB_FEHLER;
		break;
	case FATALER_FEHLER:
		strCategory = F_FATALER_FEHLER;
		break;
	case RESET_WARNING:
		strCategory = X_RESET_WARNING;
		break;
	case RESET_ERROR:
		strCategory = X_RESET_ERROR;
		break;
	case RESET_SEVERE:
		strCategory = X_RESET_SEVERE;
		break;
	case RESET_FATAL:
		strCategory = X_RESET_FATAL;
		break;
	case RESET_USERMESSAGE:
		strCategory = X_RESET_USERMESSAGE;
		break;
	case RESET_TELEGRAM:
		strCategory = X_RESET_TELEGRAM;
		break;
	case RESET_MSGBOX:
		strCategory = X_RESET_MSGBOX;
		break;
	case RESET_ORTHOMSG:
		strCategory = X_RESET_ORTHOMSG;
		break;
	case ACS_FLAG_YESNO:
		strCategory = T_ACS_FLAG_YESNO;
		break;
	default:
		strCategory = T_ACS_FLAG_YESNO;
		break;
	}
	return strCategory;
}

///*********************************************************************************
//函数名称：SwitchLogLevel
//功能描述：切换日志属性类型
//对应需求：

//修改记录:
//2021-12-20 创建 提供日志属性
//*******************************************************************************/
int nsGEN::SMZDevice::SwitchCategory2ECOM(ACS_ENUM nCatrgoryNumber)
{
	int strCategory = -1;
	switch (nCatrgoryNumber)
	{
	case BEDIENEVENT:
		strCategory = SYS_LOG_LEVEL_Action;
		break;
	case USERMESSAGE:
		strCategory = SYS_LOG_LEVEL_Information;
		break;
	case RESET_USERMSG_LEGACY:
		strCategory = SYS_LOG_LEVEL_RESET;
		break;
	case TELEGRAM:
		strCategory = SYS_LOG_LEVEL_Telegram;
		break;
	case MSGBOX_NO_OK_NO_TUI:
		strCategory = SYS_LOG_LEVEL_Ortho;
		break;
	case ORTHOMESSAGE:
		strCategory = SYS_LOG_LEVEL_Ortho;
		break;
	case ACS_FLAG_RESET:
		strCategory = SYS_LOG_LEVEL_Action;
		break;
	case WARNUNG:
		strCategory = SYS_LOG_LEVEL_Warning;
		break;
	case BEHEB_FEHLER:
		strCategory = SYS_LOG_LEVEL_Recoverable;
		break;
	case NICHT_BEHEB_FEHLER:
		strCategory = SYS_LOG_LEVEL_Error;
		break;
	case FATALER_FEHLER:
		strCategory = SYS_LOG_LEVEL_Fatal;
		break;
	case RESET_WARNING:
		strCategory = SYS_LOG_LEVEL_RESET;
		break;
	case RESET_ERROR:
		strCategory = SYS_LOG_LEVEL_RESET;
		break;
	case RESET_SEVERE:
		strCategory = SYS_LOG_LEVEL_RESET;
		break;
	case RESET_FATAL:
		strCategory = SYS_LOG_LEVEL_RESET;
		break;
	case RESET_USERMESSAGE:
		strCategory = SYS_LOG_LEVEL_RESET;
		break;
	case RESET_TELEGRAM:
		strCategory = SYS_LOG_LEVEL_RESET;
		break;
	case RESET_MSGBOX:
		strCategory = SYS_LOG_LEVEL_RESET;
		break;
	case RESET_ORTHOMSG:
		strCategory = SYS_LOG_LEVEL_RESET;
		break;
	case ACS_FLAG_YESNO:
		strCategory = SYS_LOG_LEVEL_Telegram;
		break;
	default:
		strCategory = SYS_LOG_LEVEL_Telegram;
		break;
	}
	return strCategory;
}
/*********************************************************************************
函数名称：WSGen2UI
功能描述：切换workstations从XCU到UI，用于映射对应的workstation值

修改记录:
2021-04-20 创建
*******************************************************************************/
void nsGEN::SMZDevice::WSGen2UI(int nWSGen, int& nWSUI)
{
	int nWSGenLying = 1;
	int nWSGenStand = 2;
	int nWSGenFree = 3;
	int nWSGenTomo = 0;   //2021-04-21 待完善功能 临时写死  可能不使用
	int nWSGenConventional = 4; //2021-04-21 待完善功能 临时写死
	int nWSGenConventionalTable = 7; //2021-04-21 待完善功能 临时写死 可能不使用
	int nWSGenConventionalWall = 8;  //2021-04-21 待完善功能 临时写死 可能不使用
	int nWSGenOrthoWALL = 5;  //2021-04-21 待完善功能 临时写死
	int nWSGenOrthoTable = 6; //2021-04-21 待完善功能 临时写死
	try
	{

		nWSGenLying = (int)(m_GenConfig["WorkStation"]["Table"]);
		nWSGenStand = (int)(m_GenConfig["WorkStation"]["Wall"]);
		nWSGenFree = (int)(m_GenConfig["WorkStation"]["Free"]);
		nWSGenConventional = (int)(m_GenConfig["WorkStation"]["Conventional"]);
	}
	catch (ResDataObjectExption& exp)
	{
		PRINTA_ERROR("Get configuration failed, %s", exp.what());
	}

#pragma region GEN2UI
	if (nWSGen == nWSGenLying)
	{
		if ((nWSGenLying == nWSGenStand)
			|| (nWSGenLying == nWSGenTomo)
			|| (nWSGenLying == nWSGenFree)
			|| (nWSGenLying == nWSGenConventional)
			|| (nWSGenLying == nWSGenConventionalTable)
			|| (nWSGenLying == nWSGenConventionalWall))
		{
			nWSUI = m_nSettingWS;
		}
		else
		{
			nWSUI = WS_TABLE;
		}
	}
	else if (nWSGen == nWSGenStand)
	{
		if ((nWSGenStand == nWSGenTomo)
			|| (nWSGenStand == nWSGenFree)
			|| (nWSGenStand == nWSGenConventional)
			|| (nWSGenStand == nWSGenConventionalTable)
			|| (nWSGenStand == nWSGenConventionalWall))
		{
			nWSUI = m_nSettingWS;
		}
		else
		{
			nWSUI = WS_WALL;
		}
	}
	else if (nWSGen == nWSGenConventional)
	{
		if ((nWSGenConventional == nWSGenTomo)
			|| (nWSGenConventional == nWSGenFree)
			|| (nWSGenConventional == nWSGenConventionalTable)
			|| (nWSGenConventional == nWSGenConventionalWall))
		{
			nWSUI = m_nSettingWS;
		}
		else
		{
			nWSUI = WS_CONVENTIONAL;
		}
	}
	else if (nWSGen == nWSGenFree)
	{
		if ((nWSGenFree == nWSGenTomo)
			|| (nWSGenFree == nWSGenConventionalTable)
			|| (nWSGenFree == nWSGenConventionalWall))
		{
			nWSUI = m_nSettingWS;
		}
		else
		{
			nWSUI = WS_FREE;
		}
	}
	else if (nWSGen == nWSGenTomo)
	{
		if ((nWSGenFree == nWSGenConventionalTable)
			|| (nWSGenFree == nWSGenConventionalWall))
		{
			nWSUI = m_nSettingWS;
		}
		else
		{
			nWSUI = WS_TOMO;
		}
	}
	else if (nWSGen == nWSGenConventionalTable)
	{
		if ((nWSGenConventionalTable == nWSGenConventionalWall))
		{
			nWSUI = m_nSettingWS;
		}
		else
		{
			nWSUI = WS_CONVENTIONAL;
		}
	}
	else if (nWSGen == nWSGenConventionalWall)
	{
		nWSUI = WS_CONVENTIONAL;
	}
	else if (nWSGen == nWSGenOrthoWALL)
	{
		nWSUI = WS_WALL;
	}
	else if (nWSGen == nWSGenOrthoTable)
	{
		nWSUI = WS_TABLE;
	}
	else
	{
		PRINTA_INFO("WSGen2UI: Get workstation  %d from Generator，please check the configuration\n", nWSGen);
	}
#pragma endregion
}
//-----------------------------------------------------------------------------
//		SMZDriver
//-----------------------------------------------------------------------------

nsGEN::SMZDriver::SMZDriver ()
{
	m_bConnect = false;
	CreateLogger("Salmon");
}

nsGEN::SMZDriver::~SMZDriver ()
{
	ReleaseLogger();
}

auto nsGEN::SMZDriver::CreateDevice (int index) -> std::unique_ptr <IODevice>
{
	PRINTA_INFO("CreateDevice");
	auto dev = std::unique_ptr <IODevice>(new IODevice(new SMZDevice(EventCenter, m_ConfigFileName)));
	return dev;
}


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


void nsGEN::SMZDriver::Prepare ()
{
	super::Prepare ();
}

bool DATA_ACTION  nsGEN::SMZDriver::Connect ()
{
	PRINTA_INFO("================Salmon version 3.0.32.0 =============================\n");
	
	ResDataObject Connection = GetConnectParam(m_ConfigFileName);
	printf("connections:%s \n", Connection.encode());
	printf("Connect begin \n");

	m_bConnect = true;
	//auto rc = super::Connect();
	//if (!rc)
	//	return 0;
	return 2;
}


void nsGEN::SMZDriver::Disconnect()
{
	super::Disconnect();

	m_bConnect = false;
}

bool nsGEN::SMZDriver::isConnected() const
{
	return m_bConnect;
}



std::string nsGEN::SMZDriver::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", "Siemens");
		HardwareInfo.add ("ProductID", "Salmon");
		HardwareInfo.add ("SerialID", "Drv");
	}
	string ret = HardwareInfo.encode ();
	return ret;
}


std::string nsGEN::SMZDriver::GetResource ()
{
	ResDataObject temp;
	if (!temp.loadFile (m_ConfigFileName.c_str ()))
		return std::string ();

	auto r_config = temp ["CONFIGURATION"];
	for (auto &Item : m_ConfigInfo)
	{
		string key = Item.GetKey ();
		if (key == ConfKey::CcosGeneratorType)
		{
			Item.SetCurrentValue (((string)r_config ["VendorID"]).c_str ());
		}
		else if (key == ConfKey::CcosGeneratorModel)
		{
			Item.SetCurrentValue (((string)r_config ["ProductID"]).c_str ());
		}
		else if (key == ConfKey::CcosWSTable || key == ConfKey::CcosWSWall || key == ConfKey::CcosWSFree
			|| key == ConfKey::CcosWSTomo || key == ConfKey::CcosWSConventional)
		{
			Item.SetCurrentValue (((string)r_config [key.c_str ()]).c_str ());
		}
		else if (key == ConfKey::CcosSynTable || key == ConfKey::CcosSynWall || key == ConfKey::CcosSynFree
			|| key == ConfKey::CcosSynTomo || key == ConfKey::CcosSynConventional)
		{
			Item.SetCurrentValue (((string)r_config [key.c_str ()]).c_str ());
		}
		else if (key == ConfKey::CcosSCFType)
		{
			Item.SetCurrentValue (((string)r_config ["connections"] [0] ["type"]).c_str ());
		}
		else if (key == ConfKey::CcosSCFPort || key == ConfKey::CcosSCFBaudrate || key == ConfKey::CcosSCFBytesize
			|| key == ConfKey::CcosSCFParity || key == ConfKey::CcosSCFStopbits || key == ConfKey::CcosSCFIP)
		{
			if (r_config ["connections"] [0].GetFirstOf (key.c_str ()) >= 0)
			{
				Item.SetCurrentValue (((string)r_config ["connections"] [0] [key.c_str ()]).c_str ());
			}
		}
	}
	ResDataObject resAttr, resDescription;
	for (auto Item : m_ConfigInfo)
	{
		resAttr.add (Item.GetKey (), Item.GetCurrentValue ());
		resDescription.add (Item.GetKey (), Item.GetDescription ());
	}
	ResDataObject resDeviceResource;
	resDeviceResource.add (ConfKey::CcosGeneratorAttribute, resAttr);
	resDeviceResource.add (ConfKey::CcosGeneratorDescription, resDescription);
	string res = resDeviceResource.encode ();
	printf ("resDeviceResource :%s \n", resDeviceResource.encode ());

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

	m_DeviceConfig = DescriptionTempEx;

	return res;
}

bool nsGEN::SMZDriver::GetDeviceConfig(std::string& Cfg)
{
	Cfg = m_DeviceConfig.encode();

	PRINTA_INFO("GetDeviceConfig over");

	return true;
}

std::string nsGEN::SMZDriver::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", "Siemens");
		HardwareInfo.add ("ProductID", "Salmon");
		HardwareInfo.add ("SerialID", "1234");
	}
	string ret = HardwareInfo.encode ();
	return ret;
}

void nsGEN::SMZDriver::Dequeue (const char * Packet, DWORD Length)
{
	
}

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

static nsGEN::SMZDriver  gIODriver;

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


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