PhysicalDevice/Detector/PZMedical/DIOS.Dev.FPD.PZMedicalDR/PZMedicalCtrl.cpp

#include "stdafx.h"
#include "PZMedicalCtrl.h"
#include "CCOS.Dev.FPD.PZMedicalDR.h"
#include "common_api.h"


PZMedicalCtrl* g_pDetector = nullptr;

#define LOAD_PROC_ADDRESS(handle,func) \
if ((API_##func = (PZ_##func)GetProcAddress(handle, #func)) == NULL) { printf("Error occurs while loading entry point!!! \n'%s'\n", #func); }\


PZMedicalCtrl::PZMedicalCtrl()
{
	m_pDPC2PanelID = new map<FPDDevicePZMedical*, int>();
	m_pPanelID2DPC = new map<int, FPDDevicePZMedical*>();
	m_nPanelCount = 0;
	m_strCtrlWorkPath = "";
	m_nCurrentPanelID = 0;
	m_strTplDarkPath = "";
	m_strTplFloodPath = "";
	m_ePZDPCstate = PZDPC_STATE_INIT;
	m_nImageWidth = 0;
	m_nImageHeight = 0;
	m_nWidthOffset = 0;
	m_nHeightOffset = 0;
	m_nRawImgWidth = 0;
	m_nRawImgHeight = 0;
	m_pRawImgBuffer = nullptr;
	m_pImgBuffer = nullptr;
	m_nAppStatus = APP_STATUS_IDLE;
	m_eType = CCOS_CALIBRATION_TYPE_NONE;
	m_nOffsetImg = 0;
	m_nGainImg = 0;
	m_eCalState = PZ_CALIBRATION_MAX;
	m_bCalibrationOver = false;
	m_bWired = true;
	m_cFpCurStat = STATUS_NULL;
	m_nCalibrationRounds = 0;
	m_eStatus = DetStatus_NotIni;
	m_nCalibrationMode = CCOS_CALIBRATION_MODE_ZSKK;
	m_pZSKKCalib = nullptr;
	m_strPanelType = "";
	m_bLoadedSDK = false;
	m_bInitializedSDK = false;
	m_nSaveRaw = 0;
	m_nCalibCurrentCalibrationRound = 0;
	m_nCalibCurrentExposureIndex = 0;
	m_nExposureNumCurrentRound = 0;
	m_bAutoContinueCal = false;
	m_nGainExposureNum = 0;
	m_nNotifyStatusTimePeriod = 10000;
	m_nReconnectTimePeriod = 5000;

	m_hPZSDKModule = nullptr;
	m_hRespond = CreateEvent(NULL, FALSE, FALSE, NULL);

	m_hFPDScanThread = nullptr;
	m_hStopScanEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hProcessImgEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hXWinOnEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hInitFPDEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hReInitEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hArrayEvent[0] = m_hStopScanEvent;
	m_hArrayEvent[1] = m_hProcessImgEvent;
	m_hArrayEvent[2] = m_hXWinOnEvent;
	m_hArrayEvent[3] = m_hInitFPDEvent;
	m_hArrayEvent[4] = m_hReInitEvent;

	m_hCalibrationThread = nullptr;
	m_hPZMPrepare = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hPZMStartOffset = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hPZMInOffset = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hPZMStartGain = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hPZMInGain = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hEndCalibEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hPZMEndEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hPZMCalibration[0] = m_hPZMPrepare;
	m_hPZMCalibration[1] = m_hPZMStartOffset;
	m_hPZMCalibration[2] = m_hPZMInOffset;
	m_hPZMCalibration[3] = m_hPZMStartGain;
	m_hPZMCalibration[4] = m_hPZMInGain;
	m_hPZMCalibration[5] = m_hEndCalibEvent;
	m_hPZMCalibration[6] = m_hPZMEndEvent;

	m_hNotifyStatusThread = nullptr;
	m_hReconnectDetectorThread = nullptr;

	//SDK Interface
	API_COM_Init = nullptr;
	API_COM_List = nullptr;
	API_COM_Open = nullptr;
	API_COM_Close = nullptr;
	API_COM_RegisterEvCallBack = nullptr;
	API_COM_SetCalibMode = nullptr;
	API_COM_GetCalibMode = nullptr;
	API_COM_Trigger = nullptr;
	API_COM_AedAcq = nullptr;
	API_COM_HstAcq = nullptr;
	API_COM_Prep = nullptr;
	API_COM_ExposeReq = nullptr;
	API_COM_Stop = nullptr;
	API_COM_GetImageMode = nullptr;
	API_COM_GetImageShiftMode = nullptr;
	API_COM_GetImage = nullptr;
	API_COM_SetAllTpl = nullptr;
	API_COM_GenOffsetTpl = nullptr;
	API_COM_GenGainTpl = nullptr;
	API_COM_GenDefectTpl = nullptr;
	API_COM_TplPathSet = nullptr;
	API_COM_TplPathGet = nullptr;
	API_COM_LogPathSet = nullptr;
	API_COM_GetFPType = nullptr;
	API_COM_SetAedCorrKB = nullptr;
	API_COM_GetDllVer = nullptr;
	API_COM_GetFPInfo = nullptr;
	API_COM_GetFPConf = nullptr;
	API_COM_SetFPConf = nullptr;
	API_COM_GetWifiMode = nullptr;
	API_COM_GetFPStatus = nullptr;
	API_COM_GetFPCurStatus = nullptr;
	API_COM_GetFPsn = nullptr;
	API_COM_GetFPWireState = nullptr;
	API_COM_GetFPLicense = nullptr;
	API_COM_ResetFP = nullptr;
	API_COM_GetErrNo = nullptr;
	API_COM_GetXwin = nullptr;
	API_COM_SetXwin = nullptr;
	API_COM_GetRBConf = nullptr;
	API_COM_SetRBConf = nullptr;
	API_COM_SetFpIpNetmask = nullptr;
}


PZMedicalCtrl::~PZMedicalCtrl()
{
	if (m_nPanelCount != 0)
	{
		for (int i = 0; i < m_nPanelCount; i++)
		{
			delete[]m_pStPanelStatus[i];
		}
	}
	if (m_pRawImgBuffer)
	{
		delete[]m_pRawImgBuffer;
		m_pRawImgBuffer = nullptr;
	}
	if (m_pImgBuffer != nullptr)
	{
		delete[]m_pImgBuffer;
		m_pImgBuffer = nullptr;
	}
	if (nullptr != m_pDPC2PanelID)
	{
		delete m_pDPC2PanelID;
		m_pDPC2PanelID = nullptr;
	}
	if (nullptr != m_pPanelID2DPC)
	{
		delete m_pPanelID2DPC;
		m_pPanelID2DPC = nullptr;
	}
	if (m_hStopScanEvent)
	{
		CloseHandle(m_hStopScanEvent);
		m_hStopScanEvent = nullptr;
	}
	if (m_hProcessImgEvent)
	{
		CloseHandle(m_hProcessImgEvent);
		m_hProcessImgEvent = nullptr;
	}
	if (m_hXWinOnEvent)
	{
		CloseHandle(m_hXWinOnEvent);
		m_hXWinOnEvent = nullptr;
	}
	if (m_hInitFPDEvent)
	{
		CloseHandle(m_hInitFPDEvent);
		m_hInitFPDEvent = nullptr;
	}
	if (m_hRespond)
	{
		CloseHandle(m_hRespond);
		m_hRespond = nullptr;
	}
	if (m_hPZMPrepare)
	{
		CloseHandle(m_hPZMPrepare);
		m_hPZMPrepare = nullptr;
	}
	if (m_hPZMStartOffset)
	{
		CloseHandle(m_hPZMStartOffset);
		m_hPZMStartOffset = nullptr;
	}
	if (m_hPZMInOffset)
	{
		CloseHandle(m_hPZMInOffset);
		m_hPZMInOffset = nullptr;
	}
	if (m_hPZMStartGain)
	{
		CloseHandle(m_hPZMStartGain);
		m_hPZMStartGain = nullptr;
	}
	if (m_hPZMInGain)
	{
		CloseHandle(m_hPZMInGain);
		m_hPZMInGain = nullptr;
	}
	if (m_hReInitEvent)
	{
		CloseHandle(m_hReInitEvent);
		m_hReInitEvent = nullptr;
	}
	if (m_pZSKKCalib)
	{
		delete m_pZSKKCalib;
		m_pZSKKCalib = nullptr;
	}
	if (m_hEndCalibEvent)
	{
		CloseHandle(m_hEndCalibEvent);
		m_hEndCalibEvent = nullptr;
	}
	if (m_hPZMEndEvent)
	{
		CloseHandle(m_hPZMEndEvent);
		m_hPZMEndEvent = nullptr;
	}
	if (m_hFPDScanThread)
	{
		CloseHandle(m_hFPDScanThread);
		m_hFPDScanThread = nullptr;
	}
	if (m_hCalibrationThread)
	{
		CloseHandle(m_hCalibrationThread);
		m_hCalibrationThread = nullptr;
	}
	if (m_hNotifyStatusThread)
	{
		CloseHandle(m_hNotifyStatusThread);
		m_hNotifyStatusThread = nullptr;
	}
	if (m_hReconnectDetectorThread)
	{
		CloseHandle(m_hReconnectDetectorThread);
		m_hReconnectDetectorThread = nullptr;
	}
}


bool PZMedicalCtrl::DriverEntry(FPDDevicePZMedical * pDrvDPC, ResDataObject & Configuration)
{
	printf("========DriverEntry %p \n", pDrvDPC);
	FINFO("========DriverEntry {$}", pDrvDPC);

	map<FPDDevicePZMedical*, int>::iterator iter = m_pDPC2PanelID->find(pDrvDPC);
	if (iter != m_pDPC2PanelID->end())
	{
		printf("This DPC already exist\n");
		FERROR("This DPC already exist");
		return false;
	}

	CPanelStatus* p = new CPanelStatus();
	m_pStPanelStatus[m_nPanelCount] = p;

	m_pDPC2PanelID->insert(pair<FPDDevicePZMedical*, int>(pDrvDPC, m_nPanelCount));
	m_pPanelID2DPC->insert(pair<int, FPDDevicePZMedical*>(m_nPanelCount, pDrvDPC));
	m_objFPDConfig = Configuration; //记录配置  --目前只有一个平板，多板时应该分别存储

	try
	{
		m_nCalibrationMode = (CCOS_CALIBRATION_MODE)(int)m_objFPDConfig["CalibMode"];
		m_nNotifyStatusTimePeriod = (int)m_objFPDConfig["NotifyStatusTimePeriod"];
		m_nReconnectTimePeriod = (int)m_objFPDConfig["ReConnectTimePeriod"];
		m_strPanelType = (string)m_objFPDConfig["Description"];
	}
	catch (ResDataObjectExption& e)
	{
		FERROR("Read configuration failed, Error code: {$}", e.what());
	}
	FINFO("DriverEntry m_nCalibrationMode:{$},m_strPanelType:{$}", (int)m_nCalibrationMode, m_strPanelType);

	if (!m_pZSKKCalib)
	{
		m_pZSKKCalib = new CZSKKCalibrationCtrl();
	}
	DWORD dwThreadId;
	if (m_hFPDScanThread == nullptr)
	{
		m_hFPDScanThread = CreateThread(NULL, 0, onFPDScanThread, this, 0, &dwThreadId); //Connect启动辅助线程
	}
	SetEvent(m_hInitFPDEvent);
	return true;
}

/// <summary>
///  设备连接，启动开始Scan线程
/// [DONE.CHECKED.]
/// </summary>
/// <param name="pDrvDPC"></param>
/// <param name="szWorkPath"></param>
/// <returns></returns>
bool PZMedicalCtrl::Connect(FPDDevicePZMedical * pDrvDPC, const char* szWorkPath)
{
	printf("========Connect begin...\n");
	FINFO("========Connect. work path:{$}", szWorkPath);

	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		printf("Not current DPC, return\n");
		FERROR("Not current DPC, return");
		return true;
	}

	if (m_strCtrlWorkPath == "")
	{
		m_strCtrlWorkPath = szWorkPath;
	}
	
	if (!ConnectDetector())
	{
		FERROR("ConnectDetector fail!");
	}

	FINFO("======== Connect over");
	return true;
}

void PZMedicalCtrl::EnterExamMode(int nExamMode)
{
	switch (nExamMode)
	{
	case APP_STATUS_WORK_BEGIN:
		FINFO("Enter into Exam Windows");
		m_nAppStatus = APP_STATUS_WORK_BEGIN;
		break;
	case APP_STATUS_WORK_END:
		FINFO("Quit Exam Windows");
		m_nAppStatus = APP_STATUS_WORK_END;
		break;
	case APP_STATUS_DETSHARE_BEGIN:
		FINFO("Enter into Detector Share Windows");
		m_nAppStatus = APP_STATUS_DETSHARE_BEGIN;
		break;
	case APP_STATUS_DETSHAR_END:
		m_nAppStatus = APP_STATUS_IDLE;
		FINFO("Quit Detector Share Windows");
		m_nAppStatus = APP_STATUS_DETSHAR_END;
		break;
	case APP_STATUS_CAL_BEGIN:
		FINFO("Enter into Calibration Windows");
		m_nAppStatus = APP_STATUS_CAL_BEGIN;
		break;
	case APP_STATUS_CAL_END:
		FINFO("Quit Calibration Windows");
		m_nAppStatus = APP_STATUS_CAL_END;
		break;
	case APP_STATUS_WORK_IN_SENSITIVITY:
		FINFO("Enter into sensitivity test interface");
		m_nAppStatus = APP_STATUS_WORK_IN_SENSITIVITY;
		break;
	default:
		break;
	}

	if (APP_STATUS_WORK_END == m_nAppStatus)
	{
		FINFO("m_nAppStatus == APP_STATUS_WORK_END");
		if (m_cFpCurStat > STATUS_IDLE)
		{
			BOOL nRet = FALSE;
			FINFO("Exit check view Call COM_Stop");
			nRet = API_COM_Stop();//EnterExamMode
			TestError(nRet, "COM_Stop");
		}
	}
}

bool PZMedicalCtrl::PrepareAcquisition(FPDDevicePZMedical * pDrvDPC)
{
	FINFO("========PrepareAcquisition");
	BOOL nRet = FALSE;
	int nTimeout = 12000;

	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		printf("Not current DPC, return\n");
		FERROR("Not current DPC, return");
		return false;
	}

	SetPZDPCState(PZDPC_STATE_WORK); //此时进入检查
	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectStatus)
	{
		FERROR("There is no detector connected, return");
		return false;
	}

	if (m_cFpCurStat > STATUS_IDLE)
	{
		FINFO("not Idle state Call COM_Stop");
		nRet = API_COM_Stop();//PrepareAcquisition
		if (!TestError(nRet, "COM_Stop"))
		{
			return false;
		}
	}

	try
	{
		nTimeout = (int)m_objFPDConfig["ReadyTimeout"];
	}
	catch (ResDataObjectExption& e)
	{
		FERROR("Read configuration failed, Error code: {$}", e.what());
	}

	if (SYNC_AED == m_pStPanelStatus[m_nCurrentPanelID]->eSyncMode)
	{
		FINFO("Call API_COM_AedAcq");
		nRet = API_COM_AedAcq();
		if (!TestError(nRet, "API_COM_AedAcq"))
		{
			return false;
		}

		if (!WaitRespond(nTimeout, "AED2"))//等待心跳中返回状态
		{
			return false;
		}
	}
	else
	{
		//因为心跳是500ms回调一次，这里睡800ms 保证心跳中获取探测器状态可以正常获取
		Sleep(800);
		FINFO("Call API_COM_HstAcq");
		nRet = API_COM_HstAcq();
		if (!TestError(nRet, "API_COM_HstAcq"))
		{
			return false;
		}
		if (!WaitRespond(nTimeout, "HST"))//等待心跳中返回状态
		{
			return false;
		}
	}

	FINFO("PrepareAcquisition over");
	return true;
}


bool PZMedicalCtrl::StartAcquisition(FPDDevicePZMedical * pDrvDPC)
{
	FINFO("========StartAcquisition");
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		printf("Not current DPC, return\n");
		FERROR("Not current DPC, return");
		return false;
	}
	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectStatus)
	{
		FERROR("There is no detector connected, return");
		return false;
	}
	
	if (SYNC_SOFTWARE == m_pStPanelStatus[m_nCurrentPanelID]->eSyncMode)
	{
		//品臻4.2.5版本的动态库，非AED模式，在ExposeReq后会有ready事件的回调
		FINFO("Call API_COM_ExposeReq");
		BOOL nRet = API_COM_ExposeReq();
		if (!TestError(nRet, "API_COM_ExposeReq"))
		{
			return false;
		}
	}
	else if (SYNC_AED == m_pStPanelStatus[m_nCurrentPanelID]->eSyncMode)
	{
		StatusFeedback(EVT_STATUS_PANEL, PANEL_START_ACQ);
		StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_ON);
	}
	else 
	{
		FERROR("Not Support Sync Mode!!!");
		return false;
	}
	return true;
}


/***
** 调用api，结束采集
** pDrvDPC，ctrl模块内部调用时为nullptr
***/
bool PZMedicalCtrl::StopAcquisition(FPDDevicePZMedical * pDrvDPC)
{
	FINFO("========StopAcquisition");
	if (nullptr != pDrvDPC)
	{
		if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
		{
			printf("Not current DPC, return\n");
			FERROR("Not current DPC, return");
			return false;
		}
	}

	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectStatus)
	{
		FERROR("There is no detector connected, return");
		return false;
	}

	BOOL nRet = FALSE;
	if (m_cFpCurStat > STATUS_IDLE)
	{
		FINFO("Stop acq Call COM_Stop");
		nRet = API_COM_Stop();//StopAcquisition
		if (!TestError(nRet, "COM_Stop"))
		{
			return false;
		}
	}
	return true;
}

/***
** 说明：激活校正
** 增益校正（探测器采用post-offset，暗场校正基本没用了）时拿到dose回调，算作执行完毕
***/
bool PZMedicalCtrl::ActiveCalibration(FPDDevicePZMedical * pDrvDPC, CCOS_CALIBRATION_TYPE eType)
{
	FINFO("========ActiveCalibration");
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		printf("Not current DPC, return\n");
		FERROR("Not current DPC, return");
		return false;
	}

	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectStatus)
	{
		FERROR("There is no detector connected, return");
		return false;
	}
	StatusFeedback(EVT_STATUS_CALIBRATIOIN, PANEL_EVENT_START);

	DWORD dwThreadId;
	if (m_hCalibrationThread == nullptr)
	{
		m_hCalibrationThread = CreateThread(NULL, 0, onCalibrationThread, this, 0, &dwThreadId);
	}
	else
	{
		FERROR("The calibration process is ongoing");
	}
	if (nullptr == m_hCalibrationThread)
	{
		FERROR("Start calibration process failed");
		return false;
	}

	m_eType = eType;
	SetPZDPCState(PZDPC_STATE_CALIBRATION);
	m_nOffsetImg = 0;
	m_nGainImg = 0;
	m_eCalState = PZ_CALIBRATION_INIT;
	m_bCalibrationOver = false;

	printf("ActiveCalibration stop acquisition\n");
	FINFO("ActiveCalibration stop acquisition");
	//停止采集，使探测器进入IDLE状态
	if (!StopAcquisition(nullptr))//ActiveCalibration
	{
		return false;
	}

	//参考trixellDR 流程
	if (CCOS_CALIBRATION_TYPE_DARK == eType)
	{
		FINFO("Active Dark Calibration");
	}
	else if (CCOS_CALIBRATION_TYPE_XRAY == eType)
	{
		FINFO("Active Xray Calibration");
		m_eStatus = DetStatus_XrayCalibration;

		if (m_nCalibrationMode) //PZMedical校正
		{

		}
		else //ZSKK校正
		{
			if (!m_pZSKKCalib)
			{
				FERROR("ZSKK Calibration object is undefined");
			}
			else
			{
				//加载ZSKK的校正文件
				m_pZSKKCalib->m_strRawImgPath = m_strCtrlWorkPath + "\\rawdata\\";
				m_pZSKKCalib->m_strRefFilePath = m_strCtrlWorkPath + "\\references\\";
				m_pZSKKCalib->m_nFullImgWidth = m_nImageWidth;
				m_pZSKKCalib->m_nFullImgHeight = m_nImageHeight;
				m_pZSKKCalib->m_nReferenceNum = m_nCalibrationRounds;
				m_pZSKKCalib->m_nSaturationValue = 50000;
				m_pZSKKCalib->LoadZSKKGainMap(false, m_strPanelType);//ActiveCalibration
				m_pZSKKCalib->LoadZSKKPixelMap(false, m_strPanelType);
				FINFO("Load ZSKK Gain map success!");
				FINFO("references file path: {$}", m_pZSKKCalib->m_strRefFilePath.c_str());
			}
		}
	}
	else
	{
		FINFO("Active not supported calibration({$}), return!", (int)eType);
	}

	return true;
}

/***
** 说明：准备校正（状态机FramePrep）
** 刷暗场 开窗
***/
bool PZMedicalCtrl::PrepareCalibration(FPDDevicePZMedical * pDrvDPC)
{
	FINFO("========PrepareCalibration");
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		printf("Not current DPC, return\n");
		FERROR("Not current DPC, return");
		return false;
	}

	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectStatus)
	{
		FERROR("There is no detector connected, return");
		return false;
	}

	BOOL nRet = FALSE;
	if (m_cFpCurStat > STATUS_IDLE)
	{
		FINFO("not Idle state Call COM_Stop");
		nRet = API_COM_Stop();//PrepareCalibration
		if (!TestError(nRet, "COM_Stop"))
		{
			return false;
		}
	}

	int nTimeout = 12000; //ready缺省等12s
	try
	{
		nTimeout = (int)m_objFPDConfig["ReadyTimeout"];
	}
	catch (ResDataObjectExption& e)
	{
		FERROR("Read configuration failed, Error code: {$}", e.what());
	}

	if (CCOS_CALIBRATION_TYPE_XRAY == m_eType)
	{
		FINFO("PrepareCalibration -- Gain");
		m_eCalState = PZ_CALIBRATION_GAIN;
		if (SYNC_AED == m_pStPanelStatus[m_nCurrentPanelID]->eSyncMode)
		{
			FINFO("Call AedAcq");
			nRet = API_COM_AedAcq();
			if (!TestError(nRet, "AedAcq"))
			{
				return false;
			}
			if (!WaitRespond(nTimeout, "AED2"))
			{
				return false;
			}
		}
		else
		{
			FINFO("Call HstAcq");
			nRet = API_COM_HstAcq();
			if (!TestError(nRet, "HstAcq"))
			{
				return false;
			}
			if (!WaitRespond(nTimeout, "HST"))
			{
				return false;
			}
		}
	}
	else
	{
		FINFO("PrepareCalibration -- DARK");
		m_eCalState = PZ_CALIBRATION_OFFSET;
		//刷暗场 ZSKK 和 厂商校正都刷一下
		FINFO("Call API_COM_Prep");
		nRet = API_COM_Prep();
		if (!TestError(nRet, "Com_Prep"))
		{
			FERROR("refresh offset template fail");
		}
		else
		{
			FINFO("refresh offset template success");
		}
		StatusFeedback(EVT_STATUS_PANEL, PANEL_READY_EXP);
	}
	return nRet;
}


bool PZMedicalCtrl::StartCalibration(FPDDevicePZMedical * pDrvDPC)
{
	FINFO("========StartCalibration");
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		printf("Not current DPC, return\n");
		FERROR("Not current DPC, return");
		return false;
	}

	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectStatus)
	{
		FERROR("There is no detector connected, return");
		printf("the detector is not connected\n");
		return false;
	}

	if (CCOS_CALIBRATION_TYPE_DARK == m_eType)
	{
		FINFO("start dark Calibration");
		m_eCalState = PZ_CALIBRATION_OFFSET;
		StatusFeedback(EVT_STATUS_CALIBRATIOIN, PANEL_EVENT_END_OK);
	}
	else if (CCOS_CALIBRATION_TYPE_XRAY == m_eType)
	{
		FINFO("start gain Calibration");
		m_eCalState = PZ_CALIBRATION_GAIN;
		if (SYNC_SOFTWARE == m_pStPanelStatus[m_nCurrentPanelID]->eSyncMode)
		{
			//品臻4.2.5版本的动态库，非AED模式，在ExposeReq后会有ready事件的回调
			FINFO("Call API_COM_ExposeReq");
			BOOL nRet = API_COM_ExposeReq();
			if (!TestError(nRet, "API_COM_ExposeReq"))
			{
				return false;
			}
		}
		else if (SYNC_AED == m_pStPanelStatus[m_nCurrentPanelID]->eSyncMode)
		{
			StatusFeedback(EVT_STATUS_PANEL, PANEL_START_ACQ);
			StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_ON);
		}
		else
		{
			FERROR("Not Support Sync Mode!!!");
			return false;
		}
	}
	return true;
}


bool PZMedicalCtrl::StopCalibration(FPDDevicePZMedical * pDrvDPC)
{
	FINFO("========StopCalibration");
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		printf("Not current DPC, return\n");
		FERROR("Not current DPC, return");
		return false;
	}

	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectStatus)
	{
		FERROR("There is no detector connected, return");
		return false;
	}
	bool bWrite = false;
	BOOL bRet = FALSE;

	if (!StopAcquisition(nullptr))//StopCalibration
	{
		FERROR("Stop acquisition in calibration failed");
		return false;
	}

	TFPUserCfg stUserCfg;
	memset(&stUserCfg, 0, sizeof(stUserCfg));
	FINFO("Call GetFPConf");
	bRet = API_COM_GetFPConf(&stUserCfg);
	if (!TestError(bRet, "GetFPConf"))
	{
		FERROR("Get FPConf fail!");
	}

	if (bRet && stUserCfg.wPreProcessing != 1)
	{
		stUserCfg.wPreProcessing = 1; // 前校正offset
		FINFO("Call SetFPConf, Set PreProcessing to OFFSET");
		bRet = API_COM_SetFPConf(&stUserCfg);
		if (!TestError(bRet, "SetFPConf"))
		{
			FERROR("Set FPConf fail!");
		}
		else
		{
			bWrite = true;
		}
	}

	if (bWrite)
	{
		Sleep(5000); // 5s延迟，保证配置完成
	}
	return true;
}


/// <summary>
/// 动态加载设备厂商SDK DLL，指定驱动目录
/// 动态拉取接口，并重命名
/// [DONE.CHECKED.]
/// TBD. 接口是否够用？升级后需要新添加别的接口
/// </summary>
/// <returns></returns>
bool PZMedicalCtrl::LoadSDK()
{
	string strSDKPath = "";
	string strDllpath = "";
	try
	{
		strSDKPath = (string)m_objFPDConfig["SDKPath"];
	}
	catch (ResDataObjectExption& e)
	{
		FERROR("Read configuration failed, Error code: {$}", e.what());
		return false;
	}
	strSDKPath = m_strCtrlWorkPath + "\\" + strSDKPath;
	strDllpath = strSDKPath + "\\ComApi.dll";
	FINFO("Load SDK path: {$}", strDllpath.c_str());

	//将SDK路径加入环境变量
	char* pathvar;
	pathvar = getenv("Path");
	printf("pathvar = %s \n\n", pathvar);
	string strPath = "Path=";
	strPath += pathvar;
	strPath += ";";
	strPath += strSDKPath;
	printf("strPath:%s \n\n", strPath.c_str());
	if (_putenv(strPath.c_str()) != 0)
	{
		DWORD dw = GetLastError();
		printf("put env failed! last error:%ld \n", dw);
		return false;
	}
	//pathvar = getenv("Path"); //test
	//printf("pathvar = %s \n\n", pathvar);

	m_hPZSDKModule = LoadLibraryEx(strDllpath.c_str(), NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
	if (m_hPZSDKModule == nullptr)
	{
		DWORD dw = GetLastError();
		FERROR("Load %s failed: {$} \n", strDllpath.c_str(), dw);
		return false;
	}

	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_Init);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_List);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_Open);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_Close);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_RegisterEvCallBack);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_SetCalibMode);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_GetCalibMode);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_Trigger);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_AedAcq);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_HstAcq);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_Prep);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_ExposeReq);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_Stop);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_GetImageMode);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_GetImage);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_SetAllTpl);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_GenOffsetTpl);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_GenGainTpl);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_GenDefectTpl);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_TplPathSet);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_TplPathGet);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_LogPathSet);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_GetFPType);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_SetAedCorrKB);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_GetDllVer);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_GetFPInfo);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_GetFPConf);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_SetFPConf);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_GetWifiMode);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_GetFPStatus);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_GetFPCurStatus);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_GetFPsn);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_GetFPWireState);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_GetFPLicense);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_AedTrigger);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_ResetFP);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_GetErrNo);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_GetXwin);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_SetXwin);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_GetRBConf);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_SetRBConf);
	LOAD_PROC_ADDRESS(m_hPZSDKModule, COM_SetFpIpNetmask);

	m_bLoadedSDK = true;
	FINFO("Load SDK over");
	return true;
}

/// <summary>
/// 初始化 品臻 SDK
/// [DONE.CHECKED.]
/// </summary>
/// <returns></returns>
bool PZMedicalCtrl::InitSDK()
{
	printf("========InitSDK \n");
	FINFO("======== InitSDK");
	BOOL nRet = FALSE;

	FINFO("Call RegisterEvCallback, EVENT_LINKUP");
	nRet = API_COM_RegisterEvCallBack(EVENT_LINKUP, FuncLinkUpCallBack);
	TestError(nRet, "Register EVENT_LINKUP");

	FINFO("Call RegisterEvCallback, EVENT_LINKDOWN");
	nRet = API_COM_RegisterEvCallBack(EVENT_LINKDOWN, FuncLinkDownCallBack);
	TestError(nRet, "Register EVENT_LINKDOWN");

	FINFO("Call RegisterEvCallback, EVENT_IMAGEVALID");
	nRet = API_COM_RegisterEvCallBack(EVENT_IMAGEVALID, FuncImageCallBack);
	TestError(nRet, "Register EVENT_IMAGEVALID");

	FINFO("Call RegisterEvCallback, EVENT_HEARTBEAT");
	nRet = API_COM_RegisterEvCallBack(EVENT_HEARTBEAT, FuncHeartBeatCallBack);
	TestError(nRet, "Register EVENT_HEARTBEAT");

	FINFO("Call RegisterEvCallback, EVENT_READY");
	nRet = API_COM_RegisterEvCallBack(EVENT_READY, FuncReadyCallBack);
	TestError(nRet, "Register EVENT_READY");

	FINFO("Call RegisterEvCallback, EVENT_EXPOSE");
	nRet = API_COM_RegisterEvCallBack(EVENT_EXPOSE, FuncExposeCallBack);
	TestError(nRet, "Register EVENT_EXPOSE");

	FINFO("Call RegisterEvCallback, EVENT_EXPEND");
	nRet = API_COM_RegisterEvCallBack(EVENT_EXPEND, FuncExposeEndCallBack);
	TestError(nRet, "Register EVENT_EXPEND");

	FINFO("Call RegisterEvCallback, EVENT_OFFSETDONE");
	nRet = API_COM_RegisterEvCallBack(EVENT_OFFSETDONE, FuncOffsetDoneCallBack);
	TestError(nRet, "Register EVENT_OFFSETDONE");

	FINFO("Call RegisterEvCallback, EVENT_AED_A1");
	nRet = API_COM_RegisterEvCallBack(EVENT_AED_A1, FuncAedA1CallBack);
	TestError(nRet, "Register EVENT_AED_A1");

	FINFO("Call RegisterEvCallback, EVENT_AED_A2");
	nRet = API_COM_RegisterEvCallBack(EVENT_AED_A2, FuncAedA2CallBack);
	TestError(nRet, "Register EVENT_AED_A2");

	FINFO("Call RegisterEvCallback, EVENT_IMAGESTART");
	nRet = API_COM_RegisterEvCallBack(EVENT_IMAGESTART, FuncImageStartCallBack);
	TestError(nRet, "Register EVENT_IMAGESTART");

	FINFO("Call RegisterEvCallback, EVENT_IMAGEEND");
	nRet = API_COM_RegisterEvCallBack(EVENT_IMAGEEND, FuncImageEndCallBack);
	TestError(nRet, "Register EVENT_IMAGEEND");

	FINFO("Call RegisterEvCallback, EVENT_BATTLOW1");
	nRet = API_COM_RegisterEvCallBack(EVENT_BATTLOW1, FuncBattLow1CallBack);
	TestError(nRet, "Register EVENT_BATTLOW1");

	FINFO("Call RegisterEvCallback, EVENT_BATTLOW2");
	nRet = API_COM_RegisterEvCallBack(EVENT_BATTLOW2, FuncBattLow2CallBack);
	TestError(nRet, "Register EVENT_BATTLOW2");

	// 设置SDK日志文件路径
	string strLogPath = "";
	strLogPath = m_strCtrlWorkPath + "\\Logs";
	char* szLogPath = const_cast<char*>(strLogPath.c_str());
	FINFO("szLogPath: {$}", szLogPath);

	FINFO("Call LogPathSet");
	nRet = API_COM_LogPathSet(szLogPath);
	if (!TestError(nRet, "LogPathSet"))
	{
		return false;
	}

	// 初始化
	FINFO("Call Init");
	nRet = API_COM_Init();
	if (!TestError(nRet, "Init"))
	{
		return false;
	}

	Sleep(3000); //根据品臻工程师建议，Init接口要和Open接口间隔一段时间执行。

	FINFO("Initialize SDK over");
	printf("Initialize SDK over \n");
	m_bInitializedSDK = true;
	return true;
}


bool PZMedicalCtrl::ConnectDetector()
{
	printf("========ConnectDetector \n");
	FINFO("======== ConnectDetector");
	BOOL nRet = FALSE;
	string strPanelSerial = "";
	int nTimeoutInit = 10000;

	try
	{
		strPanelSerial = (string)m_objFPDConfig["SerialNumber"];
		nTimeoutInit = (int)m_objFPDConfig["ConnectTimeout"];
	}
	catch (ResDataObjectExption& e)
	{
		FERROR("Read configuration failed! Error code: {$}", e.what());
		return false;
	}
	if (strPanelSerial == "")
	{
		FERROR("Serial number is null!");
		return false;
	}

	if (m_pStPanelStatus[m_nCurrentPanelID]->bConnectStatus)
	{
		FINFO("Detector has connected!");
		return true;
	}

	char szPanelSerial[32] = { '\0' }; //SDK需要32位char* 否则有可能解析出乱码，导致初始化失败
	memcpy(szPanelSerial, strPanelSerial.c_str(), strPanelSerial.length());
	FINFO("Call COM_Open, Detector Serial: {$}, Timeout: {$}", szPanelSerial, nTimeoutInit);
	nRet = API_COM_Open(szPanelSerial);
	if (!TestError(nRet, "Open"))
	{
		FINFO("Call Open again");
		nRet = API_COM_Open(szPanelSerial); //根据品臻工程师建议，OPEN接口失败一次后尝试再调用一次
		if (!TestError(nRet, "Open"))
		{
			return false;
		}
	}

	//if (!WaitRespond(nTimeoutInit, "Link")) //m_hRespond 初始化等待link回调
	//{
	//	FERROR("connect detector timeout!");
	//	return false;
	//}
	FINFO("Connect detector over");
	return true;
}

//设置校正文件路径，获取SDK版本信息，获取探测器信息：sn version ip mac...
bool PZMedicalCtrl::GetPanelInfo()
{
	FINFO("========GetPanelInfo");
	BOOL bRet = FALSE;

	//设置ZSKK校正文件路径
	bool bRes = SetFPDTplPath();
	if (!bRes)
	{
		return false;
	}

	CHAR szVersion[25] = { 0 }; //字节数不能太小，否则会导致崩溃，经测试不能小于20
	FINFO("Call GetDllVer");
	bRet = API_COM_GetDllVer(szVersion);
	if (!TestError(bRet, "GetDllVer"))
	{
		return false;
	}
	else
	{
		FINFO("[DLL Version: {$}]", szVersion);
	}

	CHAR szFPSn[32] = { 0 }; //SDK升级，改为32位数组
	FINFO("Call GetFPSn");
	bRet = API_COM_GetFPsn(szFPSn);
	if (!TestError(bRet, "GetFPSn"))
	{
		FERROR("Get detector serial number failed");
	}
	else
	{
		FINFO("FP Sn: {$}", szFPSn);
	}
	string panel_sn = szFPSn;
	ConfFeedback(EVT_CONF_PANEL_SERIAL, m_nCurrentPanelID, panel_sn.c_str());

	TFPInfo tFPInfo = { 0 };
	FINFO("Call GetFPInfo");
	bRet = API_COM_GetFPInfo(&tFPInfo);
	if (!TestError(bRet, "GetFPInfo"))
	{
		return false;
	}
	else
	{
		//转换IP
		//IP格式是int32的4个字节，每个字节转换成10进制就是IP
		UCHAR* pData = (UCHAR*)&tFPInfo.dwFpIp;
		FINFO("[SN:{$}, McuVer:{$}, FPGA:{$}, PPCVer:{$}, IP:{$}.{$}.{$}.{$}]", tFPInfo.dwBoardSn,
			tFPInfo.dwMcuVer, tFPInfo.dwFpgaVer, tFPInfo.dwSwVer, pData[3], pData[2], pData[1], pData[0]);
	}

	USHORT uXwin;
	FINFO("Call GetXwin");
	bRet = API_COM_GetXwin(&uXwin);
	if (!TestError(bRet, "GetXwin"))
	{
		return false;
	}
	else
	{
		FINFO("Xwindow:{$}", uXwin);
	}

	FINFO("Call SetXwin");
	bRet = API_COM_SetXwin(uXwin);
	if (!TestError(bRet, "SetXwin"))
	{
		return false;
	}

	TRBConf RbConf = { 0 };
	FINFO("Call GetRbConf");
	bRet = API_COM_GetRBConf(&RbConf);
	if (!TestError(bRet, "GetRbConf"))
	{
		return false;
	}
	else
	{
		RbConf.wXwin = uXwin;
		FINFO("xwin_clock:{$}", RbConf.wXwin);
	}

	FINFO("Call SetRBConf");
	bRet = API_COM_SetRBConf(&RbConf);
	if (!TestError(bRet, "SetRbConf"))
	{
		return false;
	}

	try
	{
		int nModeCount = (int)m_objFPDConfig["ModeTable"].size();
		for (int i = 0; i < nModeCount; i++)
		{
			int nAppModeID = (int)m_objFPDConfig["ModeTable"][i]["LogicMode"];
			if (nAppModeID == AcqMode::RAD)
			{
				m_nImageWidth = (int)m_objFPDConfig["ModeTable"][i]["ImageWidth"];
				m_nImageHeight = (int)m_objFPDConfig["ModeTable"][i]["ImageHeight"];
				break;
			}
		}
	}
	catch (ResDataObjectExption& e)
	{
		FERROR("Get config error: {$}", e.what());
		return false;
	}

	if (m_nCalibrationMode)//厂商校正GetPanelInfo
	{
	}
	else
	{
		Info("Load ZSKK Reference file");
		m_pZSKKCalib->m_strRawImgPath = m_strCtrlWorkPath + "\\rawdata\\";
		m_pZSKKCalib->m_strRefFilePath = m_strCtrlWorkPath + "\\references\\";
		//读取配置文件中RAD模式的高和宽
		m_pZSKKCalib->m_nFullImgWidth = m_nImageWidth;
		m_pZSKKCalib->m_nFullImgHeight = m_nImageHeight;
		m_pZSKKCalib->m_nSaturationValue = 50000;
		if (!m_pZSKKCalib->LoadZSKKGainMap(true, m_strPanelType))//GetPanelInfo
		{
			Warn("Load ZSKK Gain calibration failed");
		}
		if (!m_pZSKKCalib->LoadZSKKPixelMap(true, m_strPanelType))
		{
			Warn("Load ZSKK Defect calibration failed");
		}
	}

	GetConnectionMode();

	FINFO("========GetPanelInfo over");
	return true;
}


/***
** 设置ZSKK校正文件路径(如果目录不存在则创建相应的目录)
** 说明：device\references\xxxxxx\dark是暗场校正过程文件
**      device\references\xxxxxx\flood是亮场校正过程文件
**     校正完成后校正文件会生成到device\references\路径，strPanelSerial表示探测器序列号
***/
bool PZMedicalCtrl::SetFPDTplPath()
{
	FINFO("========SetFPDTplPath");
	BOOL nRet = FALSE;
	string strTplRootPath = m_strCtrlWorkPath + "\\references";
	string strDarkTplPath = "";
	string strFloodTplPath = "";
	string strPanelSerial = "";

	try
	{
		strPanelSerial = (string)m_objFPDConfig["SerialNumber"];
	}
	catch (ResDataObjectExption& e)
	{
		FERROR("Read configuration failed, Error code: {$}", e.what());
		return false;
	}
	strDarkTplPath = strTplRootPath + "\\" + strPanelSerial + "\\dark\\";
	strFloodTplPath = strTplRootPath + "\\" + strPanelSerial + "\\flood\\";

	// 创建dark文件路径
	if (CreateFileDirectory(strDarkTplPath))
	{
		FINFO("Create Directory: {$}", strDarkTplPath.c_str());
		m_strTplDarkPath = strDarkTplPath;
	}
	else
	{
		FERROR("Create Directory: {$} failed", strDarkTplPath.c_str());
		return false;
	}

	// 创建flood文件路径
	if (CreateFileDirectory(strFloodTplPath))
	{
		FINFO("Create Directory: {$}", strFloodTplPath.c_str());
		m_strTplFloodPath = strFloodTplPath;
	}
	else
	{
		FERROR("Create Directory: {$} failed", strFloodTplPath.c_str());
		return false;
	}

	return true;
}


/***
** 设置品臻板子出图时都应用哪些校正
* 当校正模式是PZ自己的校正时调用
***/
bool PZMedicalCtrl::SetFPDCalibrationMode()
{
	FINFO("========SetFPDCalibrationMode");
	BOOL nRet = FALSE;
	nRet = API_COM_SetCalibMode(IMG_CALIB_OFFSET | IMG_CALIB_GAIN | IMG_CALIB_DEFECT);
	if (!TestError(nRet, "SetCalibMode"))
	{
		return false;
	}

	FINFO("Call SetAllTpl");
	nRet = API_COM_SetAllTpl();
	if (!TestError(nRet, "SetAllTpl"))
	{
		m_pStPanelStatus[m_nCurrentPanelID]->bLostTemplate = true;
		FERROR("Set Template Failed, There are no Templates here");
	}
	return true;
}


/***
** 获取探测器连接模式
***/
void PZMedicalCtrl::GetConnectionMode()
{
	FINFO("========GetConnectionMode");
	FINFO("Call GetFPWireState");
	CHAR cWireState = API_COM_GetFPWireState(); //是否是wifi连接方式
	if (cWireState == CONNECT_WIFI)
	{
		FINFO("GetFPWireState return: Wireless Mode");
		m_bWired = false;
	}
	else if (cWireState == CONNECT_WIRE)
	{
		FINFO("GetFPWireState return: Wired Mode");
		m_bWired = true;
	}
	else
	{
		FERROR("GetFPWireState return unknown mode: {$}", (int)cWireState);
	}
}


DWORD __stdcall PZMedicalCtrl::onFPDScanThread(PVOID pvoid)
{
	PZMedicalCtrl* pOpr = (PZMedicalCtrl*)pvoid;
	FINFO("Enter Scan Thread");
	bool bExit = false;

	while (!bExit)
	{
		DWORD dwRet = WaitForMultipleObjects(5, pOpr->m_hArrayEvent, FALSE, INFINITE);
		if (WAIT_OBJECT_0 == dwRet) //m_hStopScanEvent
		{
			bExit = true;
		}
		else if (WAIT_OBJECT_0 + 1 == dwRet) //m_hProcessImgEvent
		{
			pOpr->OnProcessImg();
		}
		else if (WAIT_OBJECT_0 + 2 == dwRet) //m_hXWinOnEvent
		{
			DWORD dwXrayOnTime, dwXrayOffTime;
			dwXrayOnTime = dwXrayOffTime = GetTickCount();
			printf("XWindowOn \n");
			FINFO("XWindowOn: {$}", dwXrayOnTime);
			pOpr->StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_ON);
			while (dwXrayOffTime - dwXrayOnTime < 750)
			{
				dwXrayOffTime = GetTickCount();
			}
			printf("XWindowOff \n");
			FINFO("XWindowOff: {$}", dwXrayOffTime);
			pOpr->StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_OFF);
		}
		else if (WAIT_OBJECT_0 + 3 == dwRet) //m_hInitFPDEvent
		{
			pOpr->OnProcessInitFPD();
		}
		else if (WAIT_OBJECT_0 + 4 == dwRet) //m_hReInitEvent
		{
			pOpr->OnReInitFPD();
		}
	}

	FINFO("Exit Scan Thread");
	CloseHandle(pOpr->m_hFPDScanThread);
	pOpr->m_hFPDScanThread = nullptr;
	return 0;
}


/***
** 处理图像
***/
void PZMedicalCtrl::OnProcessImg()
{
	BOOL bRet = FALSE;
	printf("========Here Come the Image.....\n");
	FINFO("========Here Come the Image");

	StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_ON);
	//先获取一下出图大小
	TImageMode tImageMode;
	FINFO("Call GetImageMode");
	bRet = API_COM_GetImageMode(&tImageMode); //经过测试，这个接口要放到连接成功之后，否则获取不到信息
	if (!TestError(bRet, "GetImageMode"))
	{
		return;
	}
	else
	{
		m_nRawImgWidth = tImageMode.usCol;
		m_nRawImgHeight = tImageMode.usRow;
		ConfFeedback(EVT_CONF_RAW_WIDTH, m_nCurrentPanelID, "ImageWidth", m_nRawImgWidth);
		ConfFeedback(EVT_CONF_RAW_HIGHT, m_nCurrentPanelID, "ImageHeight", m_nRawImgHeight);
		FINFO("Get Image Mode, Width: {$}; Height: {$}", m_nRawImgWidth, m_nRawImgHeight);
	}
	if (m_pRawImgBuffer)
	{
		delete m_pRawImgBuffer;
		m_pRawImgBuffer = nullptr;
	}
	m_pRawImgBuffer = new WORD[m_nRawImgHeight * m_nRawImgWidth];

	bRet = API_COM_GetImage((CHAR*)m_pRawImgBuffer);
	if (!TestError(bRet, "GetImage"))
	{
		return;
	}

	if (m_nWidthOffset != 0 || m_nHeightOffset != 0)
	{
		printf("Begin get effect image \n");
		FINFO("Begin get effect image");
		if (!GetEffectiveImage(m_pImgBuffer, m_pRawImgBuffer, m_nRawImgWidth))
		{
			return;
		}
		printf("Get effect image over \n");
		FINFO("Get effect image over");
		if (m_nAppStatus != APP_STATUS_CAL_BEGIN && m_nCalibrationMode == CCOS_CALIBRATION_MODE_ZSKK)
		{
			FINFO("Apply ZSKK Calibration File");
			m_pZSKKCalib->m_nGridSuppressed = 6;
			m_pZSKKCalib->ApplyZSKKReference(m_nImageHeight, m_nImageWidth, m_pImgBuffer);
		}
		if (m_nSaveRaw)
		{
			SaveRaw(m_pImgBuffer, m_nImageWidth, m_nImageHeight);
		}

		DataFeedback(EVT_DATA_RAW_IMAGE, m_pImgBuffer);
	}
	else
	{
		FINFO("m_nWidthOffset and m_nHeightOffset is 0");
		if (m_nAppStatus != APP_STATUS_CAL_BEGIN && m_nCalibrationMode == CCOS_CALIBRATION_MODE_ZSKK)
		{
			FINFO("Apply ZSKK Calibration File");
			m_pZSKKCalib->m_nGridSuppressed = 6;
			m_pZSKKCalib->ApplyZSKKReference(m_nRawImgHeight, m_nRawImgWidth, m_pRawImgBuffer);
		}
		if (m_nSaveRaw)
		{
			SaveRaw(m_pRawImgBuffer, m_nRawImgWidth, m_nRawImgHeight);
		}

		DataFeedback(EVT_DATA_RAW_IMAGE, m_pRawImgBuffer);
	}

	StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_OFF);
}

void PZMedicalCtrl::SaveRaw(WORD * pInImg, int nImgWidth, int nImgHeight)
{
	FINFO("========SaveRaw");
	FILE* fp;
	SYSTEMTIME st;
	GetLocalTime(&st);
	//FINFO("Date: [%04d:%02d:%02d] ", st.wYear, st.wMonth, st.wDay);
	char filename[256];
	//sprintf(filename, "\\Image\\Raw%02d-%02d-%02d-%02d-%02d.raw", st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
	sprintf(filename, "\\RawData\\Raw.raw");

	string strFileName = m_strCtrlWorkPath + filename;
	if ((fp = fopen(strFileName.c_str(), "wb")) == NULL)
	{
		DWORD dw = GetLastError();
		FERROR("fopen {$} failed, {$}", strFileName.c_str(), dw);
		return;
	}
	fwrite(pInImg, sizeof(WORD), nImgWidth * nImgHeight, fp);
	fclose(fp);
	FINFO("Save raw over");
}


/***
* 保存RAW图像
***/
bool PZMedicalCtrl::SaveRaw(const char* pRawName, const WORD* pRawImg, int nWidth, int nHeight)
{
	FINFO("========SaveRaw RawName:{$}", pRawName);

	if (pRawImg == NULL || pRawName == NULL)
	{
		return false;
	}
	string strImagePath = m_strCtrlWorkPath + "\\rawdata\\" + pRawName;

	FILE* fp;
	if ((fp = fopen(strImagePath.c_str(), "wb")) == NULL)
	{
		DWORD dw = GetLastError();
		FERROR("fopen {$} failed, {$}", strImagePath.c_str(), dw);
		return false;
	}
	fwrite(pRawImg, sizeof(WORD), nWidth * nHeight, fp);
	fclose(fp);

	FINFO("End to Save Raw");
	return true;
}


/***
** 裁剪图像
** pOutImg: 裁剪后图像;	pInImg: 裁剪前图像;	nInWidth: 裁剪前图像宽度
***/
bool PZMedicalCtrl::GetEffectiveImage(WORD * pOutImg, WORD * pInImg, int nInWidth)
{
	FINFO("========GetEffectiveImage");
	if (pOutImg == NULL || pInImg == NULL || nInWidth < 0)
	{
		FERROR("Illegal parameter, can not get effective image");
		return false;
	}
	try
	{
		for (int i = 0; i < m_nImageHeight; i++)
		{
			memcpy(pOutImg + i * m_nImageWidth,
				pInImg + (i + m_nHeightOffset) * nInWidth + m_nWidthOffset,
				m_nImageWidth * sizeof(WORD));
		}
	}
	catch (...)
	{
		FERROR("Get effective image crashed");
		return false;
	}
	return true;
}

/// <summary>
/// 实际探测器初始化，事件触发
/// 连接探测器并进行初始化操作
/// </summary>
void PZMedicalCtrl::OnProcessInitFPD()
{
	FINFO("========OnProcessInitFPD");
	StatusFeedback(EVT_STATUS_INIT, PANEL_EVENT_START);
	int nRet = INIT_SUCCESS;
	//加载SDK
	if (!m_bLoadedSDK && !LoadSDK())
	{
		nRet = INIT_FAILED;
		FERROR("LoadSDK fail!");
	}

	//初始化SDK
	if (INIT_SUCCESS == nRet && !m_bInitializedSDK && !InitSDK())
	{
		nRet = INIT_FAILED;
		FERROR("InitSDK fail!");
	}

	if (INIT_FAILED == nRet)
	{
		FERROR("INIT_FAILED");
		m_pStPanelStatus[m_nCurrentPanelID]->bInitError = true;
		ErrorFeedback(EVT_ERR_INIT_FAILED, "true");
		StatusFeedback(EVT_STATUS_INIT, PANEL_EVENT_END_ERROR);
	}
	else
	{
		StatusFeedback(EVT_STATUS_INIT, PANEL_EVENT_END_OK);//OnProcessInitFPD
		SetPZDPCState(PZDPC_STATE_INIT);
	}
}


/***
** 说明：初始化阶段，未连接探测器，重连后需要继续初始化探测器
***/
void PZMedicalCtrl::OnReInitFPD()
{
	FINFO("========OnReInitFPD");
	StatusFeedback(EVT_STATUS_INIT, PANEL_EVENT_START);
	if (!GetPanelInfo())//OnReInitFPD
	{
		m_pStPanelStatus[m_nCurrentPanelID]->bInitError = true;
		ErrorFeedback(EVT_ERR_INIT_FAILED, "true");
		StatusFeedback(EVT_STATUS_INIT, PANEL_EVENT_END_ERROR);
	}
	StatusFeedback(EVT_STATUS_INIT, PANEL_EVENT_END_OK);//OnReInitFPD
}


DWORD __stdcall PZMedicalCtrl::onCalibrationThread(PVOID pvoid)
{
	PZMedicalCtrl* pOpr = (PZMedicalCtrl*)pvoid;
	if (pOpr->OnProcessCalibration())
	{
		FINFO("Calibration process over");
	}
	else
	{
		pOpr->StatusFeedback(EVT_STATUS_CALIBRATIOIN, PANEL_EVENT_END_ERROR);
		FERROR("Quit calibration over(with error)");
	}
	CloseHandle(pOpr->m_hCalibrationThread);
	pOpr->m_hCalibrationThread = nullptr;
	FINFO("Quit calibration process");
	return 0;
}


/***
** 校正过程
** 说明：校正辅助线程，结合校正process的阶段和SDK回调完成校正流程
** (ActiveCalibration)停止采集，进入idle状态（set prepare event）[CalibINIT process]
** 修改配置
**   == dark ==
**    1.(StartCalibration)调用api，进入hst状态（set offset event）
**    2.调用api，开始采集dark图像(image callback)
**    3.保存8张dark图像，停止采集，进入idle状态（set endcalib/aed event）[CalibOFFSET process]
**    （上aed图过程目前只在aed同步模式下进行）
**    4.接收10张aed图像，上传数据，停止采集，进入idle状态（set endcalib event）[CalibAED process]
**   == flood ==
**    1.(PrepareCalibration)调用api，进入hst或aed状态
**    2.(StartCalibration)调用api，采集flood图像（image callback）
**    3.修改配置，进入hst或aed模式，采集亮场图像
**    4.重复1、2、3，采集8张flood图像，停止采集，进入idle状态（set endcalib event）[CalibGAIN process]
** (endcalib event)生成校正文件，恢复配置
***/
bool PZMedicalCtrl::OnProcessCalibration()
{
	FINFO("========OnProcessCalibration");
	bool bExitThread = false;
	BOOL nRet = FALSE;
	while (!bExitThread)
	{
		DWORD dwSignal = WaitForMultipleObjects(7, m_hPZMCalibration, FALSE, INFINITE);
		if (dwSignal == WAIT_OBJECT_0) // 采集前配置 m_hPZMPrepare
		{
			// 修改探测器配置
			// 参考品臻提供的Demo代码，每次都是先Get再Set
			TFPUserCfg stUserCfg;
			memset(&stUserCfg, 0, sizeof(stUserCfg));
			FINFO("Get [Calibration Prepare] Event, Call GetFPConf");
			nRet = API_COM_GetFPConf(&stUserCfg);
			if (!TestError(nRet, "GetFPConf"))
			{
				return false;
			}
			stUserCfg.wPreProcessing = 0; // 前校正raw
			FINFO("Call SetFPConf, Set PreProcessing to RAW");
			nRet = API_COM_SetFPConf(&stUserCfg);
			if (!TestError(nRet, "SetFPConf"))
			{
				return false;
			}

			Sleep(5000); // 5s延迟，保证配置完成
		}
		//暗场校正开始  由于品臻的暗场校正就调一个sdk刷暗场就可以了，不采集暗场图，故此处直接结束
		else if (dwSignal == WAIT_OBJECT_0 + 1) //m_hPZMStartOffset
		{
			FINFO("Start Offset Event");
		}
		// 采集暗场图过程 
		else if (dwSignal == WAIT_OBJECT_0 + 2) //m_hPZMInOffset
		{
			FINFO("Start Offset Event more picture");
		}
		// 开始采集亮场图 
		else if (dwSignal == WAIT_OBJECT_0 + 3) //m_hPZMStartGain
		{

		}
		// 是否采够亮场图数量，采集完成就停止采集，否则继续采集 
		else if (dwSignal == WAIT_OBJECT_0 + 4) //m_hPZMInGain
		{
			FINFO("gain calibration gather {$} pictures", m_nGainImg);
			if (m_nGainImg == m_nGainExposureNum)
			{
				FINFO("m_hPZMInGain stop acquisition");
				if (!StopAcquisition(nullptr))
				{
					return false;
				}

				//Sleep(5000); // 厂家的建议20s，使探测器完成上一阶段过程
				// 修改探测器配置 参考品臻提供的Demo代码，每次都是先Get再Set
				TFPUserCfg stUserCfg;
				memset(&stUserCfg, 0, sizeof(stUserCfg));
				FINFO("Get [Calibration StartAED] Event, Call GetFPConf");
				nRet = API_COM_GetFPConf(&stUserCfg);
				if (!TestError(nRet, "GetFPConf"))
				{
					return false;
				}
				stUserCfg.wPreProcessing = 1; // 前校正offset
				FINFO("Call SetFPConf, Set PreProcessing to OFFSET");
				nRet = API_COM_SetFPConf(&stUserCfg);
				if (!TestError(nRet, "SetFPConf"))
				{
					return false;
				}

				FINFO("Sleep 5s.... ensure configuration complete");
				Sleep(5000); // 5s延迟，保证配置完成

				//结束亮场校正
				StatusFeedback(EVT_STATUS_CALIBRATIOIN, PANEL_EVENT_END_OK);
			}
		}
		// 正常结束校正 
		else if (dwSignal == WAIT_OBJECT_0 + 5) //m_hEndCalibEvent
		{

		}
		// 退出校正，可能是异常退出 
		else if (dwSignal == WAIT_OBJECT_0 + 6) //m_hPZMEndEvent
		{
			FINFO("Get [PZ End] Event");
			if (m_bCalibrationOver) // 如果是校正结束，则更新校正文件
			{
				if (m_nCalibrationMode)//PZMedical校正
				{
					if (CCOS_CALIBRATION_TYPE_DARK == m_eType)
					{
						FINFO("Call GenOffsetTpl");
						nRet = API_COM_GenOffsetTpl();
						if (!TestError(nRet, "GenOffsetTpl"))
						{
							FERROR("Save Offset Template Failed");
							//return false;
						}
					}
					else
					{
						FINFO("Call GenGainTpl");
						nRet = API_COM_GenGainTpl();
						if (!TestError(nRet, "GenGainTpl"))
						{
							FERROR("Save Gain Template Failed");
							//return false;
						}
						FINFO("Call GenDefectTpl");
						nRet = API_COM_GenDefectTpl();
						if (!TestError(nRet, "GenDefectTpl"))
						{
							FERROR("Save Defect Template Failed");
							//return false;
						}
					}
				}
			}

			// 修改探测器配置
			// 参考品臻提供的Demo代码，每次都是先Get再Set
			TFPUserCfg stUserCfg;
			memset(&stUserCfg, 0, sizeof(stUserCfg));
			FINFO("Call GetFPConf");
			nRet = API_COM_GetFPConf(&stUserCfg);
			if (!TestError(nRet, "GetFPConf"))
			{
				//return false;
			}
			stUserCfg.wPreProcessing = 1; // 前校正offset
			FINFO("Call SetFPConf, Set PreProcessing to OFFSET");
			nRet = API_COM_SetFPConf(&stUserCfg);
			if (!TestError(nRet, "SetFPConf"))
			{
				//return false;
			}

			Sleep(5000); // 5s延迟，保证配置完成
			bExitThread = true;
		}
	}
	return true;
}


void PZMedicalCtrl::SetPZDPCState(PZDPC_State ePZDPCstate)
{
	string strlog = "Unknown";
	switch (ePZDPCstate)
	{
	case PZDPC_STATE_INIT:
		strlog = "INIT";
		break;
	case PZDPC_STATE_STANDBY:
		strlog = "STANDBY";
		break;
	case PZDPC_STATE_WORK:
		strlog = "WORK";
		break;
	case PZDPC_STATE_CALIBRATION:
		strlog = "CALIBRATION";
		break;
	case PZDPC_STATE_EXIT:
		strlog = "EXIT";
		break;
	case PZDPC_STATE_MAX:
		break;
	default:
		break;
	}
	FINFO("Set PZ DPC state {$}", strlog.c_str());
	m_ePZDPCstate = ePZDPCstate;
}


PZDPC_State PZMedicalCtrl::GetPZDPCState()
{
	string strlog = "Unknown";
	switch (m_ePZDPCstate)
	{
	case PZDPC_STATE_INIT:
		strlog = "INIT";
		break;
	case PZDPC_STATE_STANDBY:
		strlog = "STANDBY";
		break;
	case PZDPC_STATE_WORK:
		strlog = "WORK";
		break;
	case PZDPC_STATE_CALIBRATION:
		strlog = "CALIBRATION";
		break;
	case PZDPC_STATE_EXIT:
		strlog = "EXIT";
		break;
	case PZDPC_STATE_MAX:
		break;
	default:
		break;
	}
	FINFO("Get state, {$}", strlog.c_str());
	return m_ePZDPCstate;
}


/***
* 执行失败，记录错误号，返回false；执行成功，返回true
* SDK接口(BOOL返回值)成功则返回TRUE, 失败返回FALSE
***/
bool PZMedicalCtrl::TestError(BOOL bRet, const char* szFuncName)
{
	if (bRet)
	{
		FINFO("{$} returned OK", szFuncName);
		return true;
	}
	else
	{
		FERROR("{$} returned failed, Error Code: {$}", szFuncName, API_COM_GetErrNo());
		return false;
	}
}

bool PZMedicalCtrl::WaitRespond(int nTimeOut, const char* szPosition)
{
	FINFO("--- {$} WaitRespond, {$}ms ---", szPosition, nTimeOut);
	DWORD dwRet = WaitForSingleObject(m_hRespond, nTimeOut);
	if (dwRet == WAIT_TIMEOUT)
	{
		FERROR("Timeout in wait respond");
		return false;
	}
	return true;
}

void PZMedicalCtrl::StopWaiting(const char* szPosition)
{
	FINFO("--- Stop waiting respond, {$} ---", szPosition);
	SetEvent(m_hRespond);
}

BOOL __stdcall PZMedicalCtrl::FuncLinkUpCallBack(char cEvent)
{
	FINFO("[EVENT_LINKUP] EventNum({$}): Detector connected.", (int)cEvent);
	return g_pDetector->OnProcessLink(cEvent);
}

BOOL __stdcall PZMedicalCtrl::FuncLinkDownCallBack(char cEvent)
{
	//探测器会自己尝试重连，断开后不用主动重连，连上后会有 LINKUP 回调
	FINFO("[EVENT_LINKDOWN] EventNum({$}): Detector disconnected!", (int)cEvent);
	return g_pDetector->OnProcessBreak(cEvent);
}

BOOL __stdcall PZMedicalCtrl::FuncImageCallBack(char cEvent)
{
	FINFO("[EVENT_IMAGEVALID]");
	printf("[EVENT_IMAGEVALID] \n");
	return g_pDetector->OnProcessImage(cEvent);
}

BOOL __stdcall PZMedicalCtrl::FuncHeartBeatCallBack(char cEvent)
{
	// FINFO("[EVENT_HEARTBEAT] EventNum(%d): Detector activate", (int)cEvent);
	return g_pDetector->OnProcessHeartBeat(cEvent);
}

BOOL __stdcall PZMedicalCtrl::FuncReadyCallBack(char cEvent)
{
	printf("[EVENT_READY] EventNum(%d)\n", cEvent);
	FINFO("[EVENT_READY] EventNum({$})", (int)cEvent);
	g_pDetector->StatusFeedback(EVT_STATUS_PANEL, PANEL_START_ACQ);
	g_pDetector->StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_ON);
	return TRUE;
}

BOOL __stdcall PZMedicalCtrl::FuncExposeCallBack(char cEvent)
{
	//此事件只有在A843B探测器工作在AED模式的时候才会回调
	printf("PZ FPD Detect Xray comed .....\n");
	FINFO("[EVENT_EXPOSE] EventNum({$})", (int)cEvent);
	g_pDetector->StatusFeedback(EVT_STATUS_PANEL, PANEL_XRAY_ON);
	return TRUE;
}

BOOL __stdcall PZMedicalCtrl::FuncExposeEndCallBack(char cEvent)
{
	//此事件只有在A843B探测器工作在AED模式的时候才会回调
	FINFO("[EVENT_EXPEND] EventNum({$})", (int)cEvent);
	printf("PZ FPD Detect Xray expose end .....\n");
	g_pDetector->StatusFeedback(EVT_STATUS_PANEL, PANEL_XRAY_OFF);
	return TRUE;
}

BOOL __stdcall PZMedicalCtrl::FuncOffsetDoneCallBack(char cEvent)
{
	FINFO("[EVENT_OFFSETDONE] EventNum({$})", (int)cEvent);
	printf("offset done success.....\n");
	return TRUE;
}

BOOL __stdcall PZMedicalCtrl::FuncAedA1CallBack(char cEvent)
{
	FINFO("[EVENT_AED_A1] EventNum({$})", (int)cEvent);
	printf("detector notify at aed a1 status.....\n");
	return TRUE;
}

BOOL __stdcall PZMedicalCtrl::FuncAedA2CallBack(char cEvent)
{
	FINFO("[EVENT_AED_A2] EventNum({$})", (int)cEvent);
	printf("detector notify at aed a2 status.....\n");
	g_pDetector->StatusFeedback(EVT_STATUS_PANEL, PANEL_READY_EXP);
	return TRUE;
}

BOOL __stdcall PZMedicalCtrl::FuncImageStartCallBack(char cEvent)
{
	FINFO("[EVENT_IMAGESTART] EventNum({$})", (int)cEvent);
	printf("start to transmit image data......\n");
	return TRUE;
}

BOOL __stdcall PZMedicalCtrl::FuncImageEndCallBack(char cEvent)
{
	FINFO("[EVENT_IMAGEEND] EventNum({$})", (int)cEvent);
	printf("end to transmit image data.....\n");
	return TRUE;
}

BOOL __stdcall PZMedicalCtrl::FuncBattLow1CallBack(char cEvent)
{
	FINFO("[EVENT_BATTLOW1] EventNum({$})", (int)cEvent);
	printf("detector battery low1 event.....\n");
	return TRUE;
}

BOOL __stdcall PZMedicalCtrl::FuncBattLow2CallBack(char cEvent)
{
	FINFO("[EVENT_BATTLOW2] EventNum({$})", (int)cEvent);
	printf("detector battery low2 event.....\n");
	return TRUE;
}

/***
** 处理SDK LINK回调
***/
BOOL PZMedicalCtrl::OnProcessLink(char cEvent)
{
	FINFO("========OnProcessLink");

	StopWaiting("Link");
	DWORD dwThreadId;
	if (m_hNotifyStatusThread == nullptr)
	{
		m_hNotifyStatusThread = CreateThread(NULL, 0, onNotifyStatusThread, this, 0, &dwThreadId);//Link 回调
	}

	m_pStPanelStatus[m_nCurrentPanelID]->bConnectStatus = true;
	StatusFeedback(EVT_STATUS_PANEL, PANEL_CONNECT);
	if (!GetPanelInfo())
	{
		FERROR("GetPanelInfo fail!");
	}
	return TRUE;
}


/***
** 处理SDK BREAK回调
***/
BOOL PZMedicalCtrl::OnProcessBreak(char cEvent)
{
	m_pStPanelStatus[m_nCurrentPanelID]->bConnectStatus = false;
	StatusFeedback(EVT_STATUS_PANEL, PANEL_CLOSE);
	//DWORD dwThreadId;
	//if (m_hReconnectDetectorThread == nullptr)
	//{
	//	m_hReconnectDetectorThread = CreateThread(NULL, 0, onReconnectDetectorThread, this, 0, &dwThreadId);//OnProcessBreak
	//}
	return TRUE;
}


/***
** 处理SDK IMAGE回调
***/
BOOL PZMedicalCtrl::OnProcessImage(char cEvent)
{
	SetEvent(m_hProcessImgEvent);
	return TRUE;
}

void PZMedicalCtrl::NotifyDetectorInfo()
{
	BOOL nRet;
	TFPStat objFPStat; // 温度、电量、信号
	//FINFO("Call GetFPStatus");
	nRet = API_COM_GetFPStatus(&objFPStat);
	if (!TestError(nRet, "GetFPStatus"))
	{
		FERROR("Get Detector Status Failed");
		return;
	}
	if (!m_bWired)
	{
		// WIFI信号状态
		int nSignal_level = (int)objFPStat.tWifiStatus.ucSignal_level;
		int nWifiValue = 0; //SDK之反馈1~5，自己转换一下
		FINFO("Wifi signal:{$}", nSignal_level);
		switch (nSignal_level)// station0-4;ap0-5
		{
		case 5:
			nWifiValue = 100;
			break;
		case 4:
			nWifiValue = 100;
			break;
		case 3:
			nWifiValue = 80;
			break;
		case 2:
			nWifiValue = 50;
			break;
		case 1:
			nWifiValue = 20;
			break;
		case 0:
			nWifiValue = 0;
			break;
		default:
			break;
		}

		if (nWifiValue < 0) //如果发生异常，获取到的wifi值应该是负的
		{
			nWifiValue = 0;
		}
		StatusFeedback(EVT_STATUS_WIFI, nWifiValue, "", m_nCurrentPanelID);
	}

	// 温度湿度状态
	FINFO("Temperature:{$}, Humidity:{$}%", ((float)objFPStat.tFpTempHum.Temp) / 10, ((float)objFPStat.tFpTempHum.Hum) / 10);
	float fTemperature = ((float)objFPStat.tFpTempHum.Temp) / 10;
	StatusFeedback(EVT_STATUS_TEMPERATURE, 0, "", m_nCurrentPanelID, fTemperature);

	// 电池电量状态
	float fBatRemain = (float)(objFPStat.tBatInfo1.Remain + objFPStat.tBatInfo2.Remain) / (objFPStat.tBatInfo1.full + objFPStat.tBatInfo2.full);
	FINFO("Battery remain:{$}", fBatRemain);
	int nBattery = (int)(fBatRemain * 100);
	if (nBattery < 0)
	{
		nBattery = 100; //没有电池按满电反馈
	}
	StatusFeedback(EVT_STATUS_BATTERY_VALUE, nBattery, "", m_nCurrentPanelID);
}


/***
** 处理SDK 心跳回调
***/
BOOL PZMedicalCtrl::OnProcessHeartBeat(char cEvent)
{
	// 500ms一次回调，状态有变化的时候记日志，否则日志文件会很大
	BOOL bRet = FALSE;
	CHAR cFpCurStat = API_COM_GetFPCurStatus();
	if (cFpCurStat != m_cFpCurStat)
	{
		printf("now PZ FPD Status is %d, LAST IS %d \n", cFpCurStat, m_cFpCurStat);
		FINFO("[HeartBeat] now PZ FPD Status is {$}, LAST IS {$}", (int)cFpCurStat, (int)m_cFpCurStat);

		switch (cFpCurStat)
		{
		case STATUS_NULL:
			FINFO("Detector current status: STATUS_NULL");
			break;
		case STATUS_IDLE:
			FINFO("Detector current status: STATUS_IDLE");
			break;
		case STATUS_HST:
			FINFO("Detector current status: STATUS_HST");
			if (m_cFpCurStat == STATUS_NULL)
			{
				FINFO("Call COM_Stop");
				bRet = API_COM_Stop();//OnProcessHeartBeat STATUS_HST
				if (!TestError(bRet, "COM_Stop"))
				{
					return false;
				}
			}
			else 
			{
				StopWaiting("HST");
				StatusFeedback(EVT_STATUS_PANEL, PANEL_READY_EXP);
			}
			break;
		case STATUS_AED1:
			FINFO("Detector current status: STATUS_AED1");
			break;
		case STATUS_AED2:
			FINFO("Detector current status: STATUS_AED2");
			if (m_cFpCurStat == STATUS_NULL)
			{
				FINFO("Call COM_Stop");
				bRet = API_COM_Stop();//OnProcessHeartBeat STATUS_AED2
				if (!TestError(bRet, "COM_Stop"))
				{
					return false;
				}
			}
			else 
			{
				StopWaiting("AED2");
				StatusFeedback(EVT_STATUS_PANEL, PANEL_READY_EXP);
			}
			break;
		case STATUS_RECOVER: //探测器在这个状态下刷新offset，结束后自动进入IDLE状态
			FINFO("Detector current status: STATUS_RECOVER");
			break;
		default:
			FINFO("Detector current status:{$}", (int)cFpCurStat);
			break;
		}
		m_cFpCurStat = cFpCurStat;//心跳回调
	}

	return TRUE;
}


/// <summary>
/// 配置反馈通知 @SDK
/// </summary>
/// <param name="nEventID"></param>
/// <param name="nDetectorID"></param>
/// <param name="pszMsg"></param>
/// <param name="nParam1"></param>
/// <param name="fParam2"></param>
/// <param name="nPtrParamLen"></param>
/// <param name="pParam"></param>
void PZMedicalCtrl::ConfFeedback(int nEventID, int nDetectorID, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	if (-1 == nDetectorID)
	{
		nDetectorID = m_nCurrentPanelID;
	}
	((FPDDevicePZMedical*)(*m_pPanelID2DPC)[nDetectorID])->OnFPDCallback(nDetectorID,
		nEventID, EVT_LEVEL_CONFIGURATION, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
}

/// <summary>
/// Info消息反馈通知 @SDK
/// </summary>
/// <param name="nEventID"></param>
/// <param name="nDetectorID"></param>
/// <param name="nParam1"></param>
/// <param name="fParam2"></param>
/// <param name="pszMsg"></param>
/// <param name="nPtrParamLen"></param>
/// <param name="pParam"></param>
void PZMedicalCtrl::InfoFeedback(int nEventID, int nDetectorID, int nParam1, float fParam2, const char* pszMsg, int nPtrParamLen, void* pParam)
{
	if (-1 == nDetectorID)
	{
		nDetectorID = m_nCurrentPanelID;
	}
	((FPDDevicePZMedical*)(*m_pPanelID2DPC)[nDetectorID])->OnFPDCallback(nDetectorID,
		nEventID, EVT_LEVEL_INFORMATOION, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
}

/// <summary>
/// 设备状态改变通知 @SDK
/// </summary>
/// <param name="nEventID">事件ID 属于部件或者子系统</param>
/// <param name="nParam1">事件状态值，不同事件有不同的取值说明</param>
/// <param name="pszMsg">事件附带文本消息</param>
/// <param name="nDetectorID">探测器ID，单板系统 默认值 -1</param>
/// <param name="fParam2">浮点参数2</param>
/// <param name="nPtrParamLen">附加参数内存长度</param>
/// <param name="pParam">附加参数内存地址</param>
void PZMedicalCtrl::StatusFeedback(int nEventID, int nParam1, const char* pszMsg, int nDetectorID, float fParam2, int nPtrParamLen, void* pParam)
{
	if (-1 == nDetectorID)
	{
		nDetectorID = m_nCurrentPanelID;
	}
	((FPDDevicePZMedical*)(*m_pPanelID2DPC)[nDetectorID])->OnFPDCallback(nDetectorID,
		nEventID, EVT_LEVEL_STATUS, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
}

/// <summary>
/// 数据反馈通知 @SDK
/// </summary>
/// <param name="nEventID">采集数据事件ID</param>
/// <param name="pParam">图像内存地址</param>
/// <param name="nParam1">参数1，默认值0</param>
/// <param name="fParam2">参数2，浮点，默认值0.0 </param>
/// <param name="pszMsg">附带文本消息</param>
/// <param name="nPtrParamLen">图像内存长度，默认值0，固定大小</param>
/// <param name="nDetectorID">探测器ID，单板模式 默认值-1</param>
void PZMedicalCtrl::DataFeedback(int nEventID, void* pParam, int nParam1, float fParam2, const char* pszMsg, int nPtrParamLen, int nDetectorID)
{
	if (-1 == nDetectorID)
	{
		nDetectorID = m_nCurrentPanelID;
	}
	((FPDDevicePZMedical*)(*m_pPanelID2DPC)[nDetectorID])->OnFPDCallback(nDetectorID,
		nEventID, EVT_LEVEL_DATA, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
}

/// <summary>
/// 告警事件反馈通知 @SDK
/// </summary>
/// <param name="nEventID"></param>
/// <param name="pszMsg"></param>
/// <param name="nParam1"></param>
/// <param name="fParam2"></param>
/// <param name="nPtrParamLen"></param>
/// <param name="pParam"></param>
/// <param name="nDetectorID"></param>
void PZMedicalCtrl::WarnFeedback(int nEventID, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam, int nDetectorID)
{
	if (-1 == nDetectorID)
	{
		nDetectorID = m_nCurrentPanelID;
	}
	((FPDDevicePZMedical*)(*m_pPanelID2DPC)[nDetectorID])->OnFPDCallback(nDetectorID,
		nEventID, EVT_LEVEL_WARNING, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
}

/// <summary>
/// 内部错误通知 @SDK
/// </summary>
/// <param name="nEventID">事件ID</param>
/// <param name="pszMsg">事件消息文本内容</param>
/// <param name="nDetectorID">探测器ID，单板模式默认值-1</param>
/// <param name="nParam1">参数1，整型，默认值0</param>
/// <param name="fParam2">参数2，浮点数，默认值0.0</param>
/// <param name="nPtrParamLen">附加参数内存长度</param>
/// <param name="pParam">附加参数内存地址</param>
void PZMedicalCtrl::ErrorFeedback(int nEventID, const char* pszMsg, int nDetectorID, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	if (-1 == nDetectorID)
	{
		nDetectorID = m_nCurrentPanelID;
	}
	((FPDDevicePZMedical*)(*m_pPanelID2DPC)[nDetectorID])->OnFPDCallback(nDetectorID,
		nEventID, EVT_LEVEL_ERROR, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
}


/***
* 设置校正点数
***/
bool PZMedicalCtrl::SetReferenceNum(int nReferenceNum)
{
	m_nCalibrationRounds = nReferenceNum;
	FINFO("========SetReferenceNum: {$}", m_nCalibrationRounds);
	return true;
}

/***
** 说明：设置当前的曝光模式
** 参数：nLogicMode，从配置文件读取，与SDK配置application mode对应
***/
bool PZMedicalCtrl::SetAcqMode(int nLogicMode, FPDDevicePZMedical * pDrvDPC)
{
	FINFO("========SetAcqMode nLogicMode:{$}", nLogicMode);
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		FINFO("not current DPC, panel id {$} != {$}", (*m_pDPC2PanelID)[pDrvDPC], m_nCurrentPanelID);
		return false;
	}

	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectStatus)
	{
		FINFO("Current detector is not connect, return");
		return false;
	}

	bool bInitBuffer = false;
	try
	{
		int nModeCount = (int)m_objFPDConfig["ModeTable"].size();
		for (int i = 0; i < nModeCount; i++)
		{
			if (nLogicMode == (int)m_objFPDConfig["ModeTable"][i]["LogicMode"])
			{
				m_nImageWidth = (int)m_objFPDConfig["ModeTable"][i]["ImageWidth"];
				m_nImageHeight = (int)m_objFPDConfig["ModeTable"][i]["ImageHeight"];
				m_nWidthOffset = (int)m_objFPDConfig["ModeTable"][i]["WidthOffset"];
				m_nHeightOffset = (int)m_objFPDConfig["ModeTable"][i]["HeightOffset"];
				m_nSaveRaw = (int)m_objFPDConfig["ModeTable"][i]["IsSaveRaw"];
				if (m_pImgBuffer)
				{
					delete m_pImgBuffer;
					m_pImgBuffer = NULL;
				}
				m_pImgBuffer = new WORD[m_nImageHeight * m_nImageWidth];

				FINFO("ImageSize({$}*{$}), Offset({$} {$}), SaveRaw({$})",
					m_nImageWidth, m_nImageHeight, m_nWidthOffset, m_nHeightOffset, m_nSaveRaw);

				bInitBuffer = true;
				break;
			}
		}
	}
	catch (ResDataObjectExption& exp)
	{
		FERROR("Get config failed: {$}", exp.what());
		return false;
	}

	if (!bInitBuffer)
	{
		FERROR("Image buffer is NULL");
		return false;
	}

	return true;
}

/***
* 接受曝光图像
***/
bool PZMedicalCtrl::AcceptCalibration()
{
	FINFO("========AcceptCalibration");
	if (m_nCalibrationMode)//PZMedical校正
	{
		//不做处理
	}
	else //ZSKK校正
	{
		if (m_nWidthOffset != 0 || m_nHeightOffset != 0)
		{
			if (m_nCalibCurrentExposureIndex == 1)
			{
				m_pZSKKCalib->AddImageToPixMap(m_pImgBuffer);
				m_pZSKKCalib->AverageZSKKGainMap(m_pImgBuffer, m_nCalibCurrentCalibrationRound - 1, true);
			}
			else
			{
				m_pZSKKCalib->AverageZSKKGainMap(m_pImgBuffer, m_nCalibCurrentCalibrationRound - 1, false); //曝光第几轮
			}
		}
		else 
		{
			if (m_nCalibCurrentExposureIndex == 1)
			{
				m_pZSKKCalib->AddImageToPixMap(m_pRawImgBuffer);
				m_pZSKKCalib->AverageZSKKGainMap(m_pRawImgBuffer, m_nCalibCurrentCalibrationRound - 1, true);
			}
			else
			{
				m_pZSKKCalib->AverageZSKKGainMap(m_pRawImgBuffer, m_nCalibCurrentCalibrationRound - 1, false); //曝光第几轮
			}
		}
	}
	FINFO("Accept calibration exposure over");
	return true;
}

/***
* 拒绝曝光图像
***/
bool PZMedicalCtrl::RejectCalibration()
{
	FINFO("========RejectCalibration");
	//不做处理
	return true;
}

bool PZMedicalCtrl::SaveCalibrationFile()
{
	FINFO("========SaveCalibrationFile");
	if (m_nCalibrationMode)//PZMedical校正
	{
		//不做处理
	}
	else
	{
		FINFO("Save ZSKK Calibration File");
		m_pZSKKCalib->StoreZSKKGainMap(m_strPanelType);
		m_pZSKKCalib->StoreZSKKPixMap(m_strPanelType);
	}

	//更新配置文件中校正日期和时间
	SYSTEMTIME stCurrentTime = { 0 };
	GetLocalTime(&stCurrentTime);
	FINFO("Current time: {$04d}/{$02d}/{$02d} {$02d}:{$02d}:{$02d}:{$03d}",
		stCurrentTime.wYear, stCurrentTime.wMonth, stCurrentTime.wDay,
		stCurrentTime.wHour, stCurrentTime.wMinute, stCurrentTime.wSecond, stCurrentTime.wMilliseconds);

	FINFO("Save Calibration File over");
	return true;
}

bool PZMedicalCtrl::GetCalibrationStep(int nCalibCurrentCalibrationRound, int nCalibrationRounds, int nCalibCurrentExposureIndex, int nExposureNumCurrentRound)
{
	FINFO("========GetCalibrationStep");
	m_nCalibCurrentCalibrationRound = nCalibCurrentCalibrationRound;
	m_nCalibrationRounds = nCalibrationRounds;
	m_nCalibCurrentExposureIndex = nCalibCurrentExposureIndex;
	m_nExposureNumCurrentRound = nExposureNumCurrentRound;
	FINFO("Calibration Step===Round: {$}/{$}, ExposureNum: {$}/{$}", nCalibCurrentCalibrationRound, nCalibrationRounds,
		nCalibCurrentExposureIndex, nExposureNumCurrentRound);
	return true;
}

/***
** 说明：结束校正
** DPC处理完校正报告后调用，此处上传map、报告等文件
***/
bool PZMedicalCtrl::CompleteCalibration(FPDDevicePZMedical * pDrvDPC)
{
	FINFO("======== CompleteCalibration calib type {$}", (int)m_eType);

	m_bCalibrationOver = true;
	if (m_eType == CCOS_CALIBRATION_TYPE_DARK)
	{
		FINFO("Dark Calibration over");
	}
	else if (m_eType == CCOS_CALIBRATION_TYPE_XRAY)
	{
		FINFO("Gain Calibration over");
		m_eCalState = PZ_CALIBRATION;
		GetCalibrationTime();
	}

	return true;
}

/***
** 说明：获取校正时间
** 连接成功后，校正完成后 获取
***/
bool PZMedicalCtrl::GetCalibrationTime(int nDetectorID)
{
	if (nDetectorID == -1)
	{
		nDetectorID = m_nCurrentPanelID;
	}
	else
	{
		InfoFeedback(EVT_INFO_CALIBRATIOIN_TIME, nDetectorID, 0, 0, "0");
		InfoFeedback(EVT_INFO_CALIBRATIOIN_TIMEL, nDetectorID, 0, 0, "0");
	}

	return true;
}

/***
** 说明：终止校正
***/
RET_STATUS PZMedicalCtrl::AbortCalibration(FPDDevicePZMedical * pDrvDPC)
{
	printf("========AbortCalibration\n");
	FINFO("========AbortCalibration");
	m_eType = CCOS_CALIBRATION_TYPE_NONE; //恢复初值
	m_bAutoContinueCal = false; //终止校正，恢复初值
	RET_STATUS Ret = RET_STATUS::RET_FAILED;

	if (m_nCalibrationMode) //PZMedical校正
	{

	}
	else
	{
		FINFO("Abort ZSKK calibration");
		m_pZSKKCalib->LoadZSKKGainMap(true, m_strPanelType); //AbortCalibration 重新加载增益校正文件
		m_pZSKKCalib->AbortZSKKPixMap(m_strPanelType); //放弃坏点校正并重新加载原来的坏点校正文件
	}
	FINFO("AbortCalibration over");
	return RET_STATUS::RET_SUCCEED;
}


CCOS_CALIBRATION_TYPE PZMedicalCtrl::GetPZMedicalCtrlCalibType()
{
	FINFO("========GetPZMedicalCtrlCalibType {$}", (int)m_eType);
	return m_eType;
}

//慎重调用，可能会导致板出问题，硬reset需要很长时间
bool PZMedicalCtrl::ResetDetector(FPDDevicePZMedical * pDrvDPC)
{
	FINFO("========ResetDetector");
	bool nRet = true;
	/*nRet = API_COM_ResetFP();
	if (!TestError(nRet, "ResetFP"))
	{
		printf("Reset Detector fail!\n");
		FERROR("Reset Detector fail!");
		return false;
	}*/
	return nRet;
}

bool PZMedicalCtrl::ActiveSyncMode(int nSyncMode)
{
	FINFO("========ActiveSyncMode");
	m_pStPanelStatus[m_nCurrentPanelID]->eSyncMode = (SYNC_MODE)nSyncMode;
	return true;
}

bool PZMedicalCtrl::UpdateCalibMode(CCOS_CALIBRATION_MODE eCalibMode)
{
	FINFO("========UpdateCalibMode eCalibMode:{$}", (int)eCalibMode);
	m_nCalibrationMode = eCalibMode;
	return true;
}

void PZMedicalCtrl::SetNotifyStatusTimePeriod(int nTime)
{
	FINFO("========SetNotifyStatusTimePeriod nTime:{$}", nTime);
	m_nNotifyStatusTimePeriod = nTime;
}

void PZMedicalCtrl::SetReconnectTimePeriod(int nTime)
{
	FINFO("========SetReconnectTimePeriod nTime:{$}", nTime);
	m_nReconnectTimePeriod = nTime;
}

DWORD __stdcall PZMedicalCtrl::onNotifyStatusThread(PVOID pvoid)
{
	FINFO("onNotifyStatusThread start");
	PZMedicalCtrl* pOpr = (PZMedicalCtrl*)pvoid;
	while (pOpr->m_pStPanelStatus[pOpr->m_nCurrentPanelID]->bConnectStatus)
	{
		pOpr->NotifyDetectorInfo();
		Sleep(pOpr->m_nNotifyStatusTimePeriod);
	}
	CloseHandle(pOpr->m_hNotifyStatusThread);
	pOpr->m_hNotifyStatusThread = nullptr;

	FINFO("onNotifyStatusThread end");
	return 0;
}

DWORD __stdcall PZMedicalCtrl::onReconnectDetectorThread(PVOID pvoid)
{
	FINFO("onReconnectDetectorThread start");
	PZMedicalCtrl* pOpr = (PZMedicalCtrl*)pvoid;
	bool bRet = false;

	while (!pOpr->m_pStPanelStatus[pOpr->m_nCurrentPanelID]->bConnectStatus)
	{
		bRet = pOpr->InitSDK();
		if (!bRet)
		{
			FERROR("onReconnectDetectorThread InitSDK fail!");
			Sleep(pOpr->m_nReconnectTimePeriod);
			continue;
		}
		bRet = pOpr->ConnectDetector();
		if (!bRet)
		{
			FERROR("onReconnectDetectorThread InitSDK fail!");
			Sleep(pOpr->m_nReconnectTimePeriod);
			continue;
		}
		Sleep(pOpr->m_nReconnectTimePeriod);
	}
	CloseHandle(pOpr->m_hReconnectDetectorThread);
	pOpr->m_hReconnectDetectorThread = nullptr;

	FINFO("onNotifyStatusThread end");
	return 0;
}

bool PZMedicalCtrl::SetDetectorWiredIP(string strWiredIP)
{
	FINFO("========SetDetectorWiredIP strWiredIP:{$}", strWiredIP);
	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectStatus)
	{
		FERROR("There is no detector connected, return");
		return false;
	}

	UINT32 IP = 0, NetMask = 0;
	int nTmpIP[4] = { 0 };
	sscanf(strWiredIP.c_str(), "%d.%d.%d.%d", &nTmpIP[0], &nTmpIP[1], &nTmpIP[2], &nTmpIP[3]);
	for (int i = 0; i < 4; i++)
	{
		IP += (nTmpIP[i] << (24 - (i * 8)) & 0xFFFFFFFF);
	}
	FINFO("IP:{$}", IP);
	NetMask = 0xFFFFFF00;
	BOOL bRet = API_COM_SetFpIpNetmask(IP,NetMask);
	if (!TestError(bRet,"API_COM_SetFpIpNetmask"))
	{
		FERROR("SetDetectorWiredIP fail!");
		return false;
	}
	return true;
}

//暂时不支持修改
bool PZMedicalCtrl::SetDetectorWirelessIP(string strWirelessIP)
{
	FINFO("========SetDetectorWirelessIP strWirelessIP:{$}", strWirelessIP);
	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectStatus)
	{
		FERROR("There is no detector connected, return");
		return false;
	}
	/*BOOL bRet = API_COM_SetFpIpNetmask();
	if (!TestError(bRet, "API_COM_SetFpIpNetmask"))
	{
		FERROR("SetDetectorWirelessIP fail!");
		return false;
	}*/
	return true;
}