PhysicalDevice/Detector/Konica/DIOS.Dev.FPD.KonicaDR/KonicaCtrl.cpp

#include "stdafx.h"
#include "KonicaCtrl.h"
#include "CCOS.Dev.FPD.KonicaDR.h"
#include "MyPingip.h"
#include <comutil.h>

#pragma comment(lib, "comsuppw.lib")

KonicaCtrl* g_pDetector = nullptr;
IKonicaObject* g_pKonicaObject = nullptr;
IKonicaObject2* g_pKonicaObject2 = nullptr;

extern Log4CPP::Logger* gLogger;


KonicaCtrl::KonicaCtrl()
{
	m_pDPC2PanelID = new map<FPDDeviceKonica*, int>();
	m_pPanelID2DPC = new map<int, FPDDeviceKonica*>();
	m_nPanelCount = 0;
	m_nCurrentPanelID = 0;
	m_hSDKModule = nullptr;
	m_nSyncMode = SYNC_AED;
	m_pRawImgBuffer = nullptr;
	m_pPreImgBuffer = nullptr;
	m_pImgBuffer = nullptr;
	m_nImageWidth = 0;
	m_nImageHeight = 0;
	m_nWidthOffset = 0;
	m_nHeightOffset = 0;
	m_nRawImgWidth = 0;
	m_nRawImgHeight = 0;
	m_nPreviewEnable = 0;
	m_nPreImgWidth = 0;
	m_nPreImgHeight = 0;
	m_nAppStatus = APP_STATUS_IDLE;
	m_nSaveRaw = 0;
	m_eCaliType = CCOS_CALIBRATION_TYPE_NONE;
	m_nXwindow = 2000;
	m_nImageNo = 0;
	m_nCurrentLogicMode = AcqMode::NONE;
	m_nCalibrationMode = CCOS_CALIBRATION_MODE_ZSKK;
	m_nCalibrationRounds = 0;
	m_nCalibCurrentCalibrationRound = 0;
	m_nCalibCurrentExposureIndex = 0;
	m_nExposureNumCurrentRound = 0;
	m_pZSKKCalib = nullptr;
	m_strDetectorType = "";
	m_nNotifyStatusTimePeriod = 10000;//默认10秒推一次
	m_nReconnectTimePeriod = 5000;
	m_nDetectorStatus = AEROSDK_PANEL_STATUS_UNKNOWN;
	m_nXgboxNo = 1;
	m_bConnectXgbox = false;
	m_nRefCount = 0;
	m_nLastMessageType = 0;
	m_pShareMem = new CShareMem("KonicaDetectorBuffer");
	m_pShareMem2 = new CShareMem("KonicaDetectorBuffer2");
	m_nComServerID = 1;
	m_nResolution = AEROSDK_RESOLUTION_NORMAL;
	m_bSupportNormalResolution = false;
	m_bSupportHighResolution = false;
	m_bFirstEnterExam = true;

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

	m_hStopScanEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hProcessImgEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hDarkEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hGainEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hInitEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hArrayEvent[0] = m_hStopScanEvent;
	m_hArrayEvent[1] = m_hProcessImgEvent;
	m_hArrayEvent[2] = m_hDarkEvent;
	m_hArrayEvent[3] = m_hGainEvent;
	m_hArrayEvent[4] = m_hInitEvent;

	m_hToggleEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	m_hFPDScanThread = nullptr;
	m_hFPDStatusThread = nullptr;
	m_bExit = false;
	m_hReconnectThread = nullptr;
	m_hConsumeThread = nullptr;
}


KonicaCtrl::~KonicaCtrl()
{
	// Closing XG-IFBOX (refer Section 8.3.2 of AeroSDK Library Manual)
	if (g_pKonicaObject)
	{
		FINFO("Call CloseXgBox");
		HRESULT hRet = g_pKonicaObject->CloseXgBox();
		if (hRet == S_OK)
		{
			FINFO("CloseXgBox success!");
		}
		else
		{
			FERROR("CloseXgBox fail!");
		}

		FINFO("Call ClosePanel");
		hRet = g_pKonicaObject->ClosePanel();
		if (hRet == S_OK)
		{
			FINFO("ClosePanel success!");
		}
		else
		{
			FERROR("ClosePanel fail!");
		}

		// Closing AeroSDK (refer Section 8.1.2 of AeroSDK Library Manual)
		FINFO("Call CloseSdk");
		hRet = g_pKonicaObject->CloseSdk();
		if (hRet == S_OK)
		{
			FINFO("CloseSdk success!");
		}
		else
		{
			FERROR("CloseSdk fail!");
		}
	}
	if (g_pKonicaObject2)
	{
		FINFO("Call CloseXgBox");
		HRESULT hRet = g_pKonicaObject2->CloseXgBox();
		if (hRet == S_OK)
		{
			FINFO("CloseXgBox success!");
		}
		else
		{
			FERROR("CloseXgBox fail!");
		}

		FINFO("Call ClosePanel");
		hRet = g_pKonicaObject2->ClosePanel();
		if (hRet == S_OK)
		{
			FINFO("ClosePanel success!");
		}
		else
		{
			FERROR("ClosePanel fail!");
		}

		// Closing AeroSDK (refer Section 8.1.2 of AeroSDK Library Manual)
		FINFO("Call CloseSdk");
		hRet = g_pKonicaObject2->CloseSdk();
		if (hRet == S_OK)
		{
			FINFO("CloseSdk success!");
		}
		else
		{
			FERROR("CloseSdk fail!");
		}
	}

	if (m_hStopScanEvent)
	{
		CloseHandle(m_hStopScanEvent);
		m_hStopScanEvent = nullptr;
	}
	if (m_hGainEvent)
	{
		CloseHandle(m_hGainEvent);
		m_hGainEvent = nullptr;
	}
	if (m_hDarkEvent)
	{
		CloseHandle(m_hDarkEvent);
		m_hDarkEvent = nullptr;
	}
	if (m_hRespond)
	{
		CloseHandle(m_hRespond);
		m_hRespond = nullptr;
	}
	if (m_hToggleEvent)
	{
		CloseHandle(m_hToggleEvent);
		m_hToggleEvent = nullptr;
	}
	if (m_pRawImgBuffer)
	{
		delete[]m_pRawImgBuffer;
		m_pRawImgBuffer = nullptr;
	}
	if (m_pPreImgBuffer)
	{
		delete[]m_pPreImgBuffer;
		m_pPreImgBuffer = nullptr;
	}
	if (m_pImgBuffer)
	{
		delete[]m_pImgBuffer;
		m_pImgBuffer = nullptr;
	}
	if (m_pZSKKCalib)
	{
		delete m_pZSKKCalib;
		m_pZSKKCalib = nullptr;
	}
	if (m_hFPDScanThread)
	{
		CloseHandle(m_hFPDScanThread);
		m_hFPDScanThread = nullptr;
	}
	if (m_hFPDStatusThread)
	{
		CloseHandle(m_hFPDStatusThread);
		m_hFPDStatusThread = nullptr;
	}
	if (m_hReconnectThread)
	{
		CloseHandle(m_hReconnectThread);
		m_hReconnectThread = nullptr;
	}
	if (m_hConsumeThread)
	{
		CloseHandle(m_hConsumeThread);
		m_hConsumeThread = nullptr;
	}

	//注销COM组件
	::CoUninitialize();
	if (g_pKonicaObject)
	{
		g_pKonicaObject->Release();
	}
	if (g_pKonicaObject2)
	{
		g_pKonicaObject2->Release();
	}
}


bool KonicaCtrl::DriverEntry(FPDDeviceKonica* pDrvDPC, ResDataObject& Configuration)
{
	FINFO("======== DriverEntry {$}", pDrvDPC);

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

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

	m_pDPC2PanelID->insert(pair<FPDDeviceKonica*, int>(pDrvDPC, m_nPanelCount));
	m_pPanelID2DPC->insert(pair<int, FPDDeviceKonica*>(m_nPanelCount, pDrvDPC));
	m_nPanelCount++;
	m_ModeConfig = Configuration; //记录配置  --目前只有一个平板，多板时应该分别存储
	//FINFO("Config: {$}", m_ModeConfig.encode());

	try
	{
		m_nCalibrationMode = (CCOS_CALIBRATION_MODE)(int)m_ModeConfig["CalibMode"];
		m_nNotifyStatusTimePeriod = (int)m_ModeConfig["NotifyStatusTimePeriod"];
		m_nReconnectTimePeriod = (int)m_ModeConfig["ReConnectTimePeriod"];
		m_strDetectorType = (string)m_ModeConfig["SerialNumber"];
		m_nComServerID = (int)m_ModeConfig["ComServerID"];
	}
	catch (ResDataObjectExption& e)
	{
		FERROR("Read configuration failed, Error code: {$}", e.what());
	}
	FINFO("m_nCalibrationMode:{$},m_nNotifyStatusTimePeriod:{$},m_nReconnectTimePeriod:{$},m_strDetectorType:{$},m_nComServerID:{$}",
		(int)m_nCalibrationMode, m_nNotifyStatusTimePeriod, m_nReconnectTimePeriod, m_strDetectorType, m_nComServerID);

	//这里进行com组件的调用
	HRESULT hRet = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
	if (FAILED(hRet))
	{
		FERROR("CoInitializeEx fail!");
		return false;
	}

	FINFO("m_nComServerID:{$}", m_nComServerID);
	if (m_nComServerID == 1)
	{
		hRet = ::CoCreateInstance(CLSID_KonicaObject, NULL, CLSCTX_LOCAL_SERVER, IID_IKonicaObject, (LPVOID*)&g_pKonicaObject);
		if (hRet == S_OK)
		{
			FINFO("Get KonicaCom pointer success!");
		}
		else
		{
			FERROR("Get KonicaCom pointer fail!");
			return false;
		}
	}
	else 
	{
		hRet = ::CoCreateInstance(CLSID_KonicaObject2, NULL, CLSCTX_LOCAL_SERVER, IID_IKonicaObject2, (LPVOID*)&g_pKonicaObject2);
		if (hRet == S_OK)
		{
			FINFO("Get KonicaCom pointer success!");
		}
		else
		{
			FERROR("Get KonicaCom pointer fail!");
			return false;
		}
	}
	
	return true;
}


bool KonicaCtrl::Connect(FPDDeviceKonica* pDrvDPC, const char* szWorkPath)
{
	FINFO("======== Connect start");

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

	if (!m_pZSKKCalib)
	{
		m_pZSKKCalib = new CZSKKCalibrationCtrl();
	}

	m_strWorkPath = szWorkPath;
	if (nullptr == m_hFPDScanThread)
	{
		unsigned uThreadId;
		_beginthreadex(NULL, 0, onFPDScanThread, this, 0, &uThreadId);
		m_hFPDScanThread = OpenThread(THREAD_ALL_ACCESS, TRUE, uThreadId);
	}
	SetEvent(m_hInitEvent);

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


void KonicaCtrl::EnterExamMode(int nExamMode)
{
	switch (nExamMode)
	{
	case APP_STATUS_WORK_BEGIN:
		FINFO("Enter into Exam Windows");
		m_nAppStatus = APP_STATUS_WORK_BEGIN;
		if (m_bFirstEnterExam)
		{
			if (m_bSupportNormalResolution && m_bSupportHighResolution)
			{
				ConfFeedback(EVT_CONF_SUPPORT_SWITCH_RESOLUTION, m_nCurrentPanelID, "SupportSwitchResolution", 1);
				//支持切换分辨率的时候就默认高分辨率 不支持切换的时候就默认低
				m_nResolution = AEROSDK_RESOLUTION_HIGH;
			}
			else
			{
				ConfFeedback(EVT_CONF_SUPPORT_SWITCH_RESOLUTION, m_nCurrentPanelID, "SupportSwitchResolution", 0);
				m_nResolution = AEROSDK_RESOLUTION_NORMAL;
			}
			ConfFeedback(EVT_CONF_CURRENT_RESOLUTION, m_nCurrentPanelID, "CurrentResolution", m_nResolution);
			m_bFirstEnterExam = false;
		}
		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;
	}

	HRESULT hRet = 0;
	if (nExamMode == APP_STATUS_WORK_END || nExamMode == APP_STATUS_CAL_END)
	{
		m_pStPanelStatus[m_nCurrentPanelID]->eFPDStatus = eDetStatus::DetStatus_Standby;
		if (m_nSyncMode == SYNC_HARDWARE && m_bConnectXgbox)//EnterExamMode
		{
			FINFO("m_nSyncMode == SYNC_HARDWARE");
			if (g_pKonicaObject)
			{
				hRet = g_pKonicaObject->CloseXgBox();
			}
			if (g_pKonicaObject2)
			{
				hRet = g_pKonicaObject2->CloseXgBox();
			}
			if (hRet == S_OK)
			{
				FINFO("CloseXgBox success!");
				m_bConnectXgbox = false;
			}
			else
			{
				FERROR("CloseXgBox fail!");
			}
		}
	}
}


/***
** 根据采集模式申请图像buffer
***/
bool KonicaCtrl::SetAcqMode(int nMode)
{
	FINFO("======== KonicaCtrl::SetAcqMode mode:{$}", nMode);
	if (m_nCurrentLogicMode == nMode)
	{
		FINFO("Same acq mode,return");
		return true;
	}
	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectState)
	{
		FERROR("bConnectState is false, Detector not connected, return");
		return false;
	}

	try
	{
		int nModeCount = (int)m_ModeConfig["ModeTable"].size();
		for (int i = 0; i < nModeCount; i++)
		{
			int nAppModeID = (int)m_ModeConfig["ModeTable"][i]["LogicMode"];
			if (nAppModeID == nMode)
			{
				m_nWidthOffset = (int)m_ModeConfig["ModeTable"][i]["WidthOffset"];
				m_nHeightOffset = (int)m_ModeConfig["ModeTable"][i]["HeightOffset"];
				m_nPreviewEnable = (int)m_ModeConfig["ModeTable"][i]["PreviewEnable"];
				m_nXwindow = (int)m_ModeConfig["ModeTable"][i]["XWindow"];
				m_nSaveRaw = (int)m_ModeConfig["ModeTable"][i]["IsSaveRaw"];
				FINFO("image WidthOffset: {$}, HeightOffset: {$}, m_nPreviewEnable:{$},m_nXwindow:{$},m_nSaveRaw:{$}",
					m_nWidthOffset, m_nHeightOffset, m_nPreviewEnable, m_nXwindow, m_nSaveRaw);

				m_nCurrentLogicMode = nMode;
				break;
			}
		}
	}
	catch (ResDataObjectExption& e)
	{
		FERROR("Get config error: {$}", e.what());
		return false;
	}
	
	return true;
}

bool KonicaCtrl::ActiveSyncMode(int nSyncMode)
{
	FINFO("======== KonicaCtrl::ActiveSyncMode nSyncMode:{$}", nSyncMode);
	m_nSyncMode = nSyncMode;

	//告诉COM组件同步模式
	if (g_pKonicaObject)
	{
		HRESULT hRet = g_pKonicaObject->SetSyncMode(nSyncMode);
		if (hRet == S_OK)
		{
			FINFO("SetSyncMode success!");
		}
		else
		{
			FERROR("SetSyncMode fail!");
			return false;
		}
	}
	if (g_pKonicaObject2)
	{
		HRESULT hRet = g_pKonicaObject2->SetSyncMode(nSyncMode);
		if (hRet == S_OK)
		{
			FINFO("SetSyncMode success!");
		}
		else
		{
			FERROR("SetSyncMode fail!");
			return false;
		}
	}
	
	return true;
}

bool KonicaCtrl::PrepareAcquisition(FPDDeviceKonica* pDrvDPC)
{
	FINFO("======== PrepareAcquisition start");
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		printf("Not current DPC, return\n");
		FERROR("Not current DPC, return");
		return false;
	}
	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectState)
	{
		FERROR("bConnectState is false, Detector not connected, return");
		return false;
	}
	if (!GetImageSize())
	{
		return false;
	}

	HRESULT hRet = 0;
	m_nImageNo++;
	if (m_nSyncMode == SYNC_AED)
	{
		// Starting Exposure Sequence in AeroSync mode (refer Section 4.3 and 8.4.2 of AeroSDK Library Manual)
		if (g_pKonicaObject)
		{
			FINFO("Call SetPanelResolution");
			hRet = g_pKonicaObject->SetPanelResolution(m_nResolution);
			if (hRet == S_OK)
			{
				FINFO("SetPanelResolution success!");
			}
			else
			{
				FERROR("SetPanelResolution fail!");
				return false;
			}

			FINFO("Call StartExposureSequenceIt");
			hRet = g_pKonicaObject->StartExposureSequenceIt(0, m_nImageNo, AEROSDK_COOPERATION_AEROSYNC, AEROSDK_INTEGRATION_DEFAULT);
			if (hRet == S_OK)
			{
				FINFO("StartExposureSequenceIt AED mode success!");
			}
			else
			{
				FERROR("StartExposureSequenceIt AED mode fail!");
				return false;
			}
		}
		if (g_pKonicaObject2)
		{
			FINFO("Call SetPanelResolution");
			hRet = g_pKonicaObject2->SetPanelResolution(m_nResolution);
			if (hRet == S_OK)
			{
				FINFO("SetPanelResolution success!");
			}
			else
			{
				FERROR("SetPanelResolution fail!");
				return false;
			}

			FINFO("Call StartExposureSequenceIt");
			hRet = g_pKonicaObject2->StartExposureSequenceIt(0, m_nImageNo, AEROSDK_COOPERATION_AEROSYNC, AEROSDK_INTEGRATION_DEFAULT);
			if (hRet == S_OK)
			{
				FINFO("StartExposureSequenceIt AED mode success!");
			}
			else
			{
				FERROR("StartExposureSequenceIt AED mode fail!");
				return false;
			}
		}
	}
	else if (m_nSyncMode == SYNC_HARDWARE)
	{
		//由于调用SDK的CloseXgBox后，没有关闭成功的回调消息，此时程序不知道是否正常关闭
		//故此处逻辑改为不管有没有关成功都调用OpenXgBox，如果有重复打开的错误码则略过
		if (!m_bConnectXgbox) 
		{
			FINFO("Call OpenXgBox");
			if (g_pKonicaObject)
			{
				HRESULT hRet = g_pKonicaObject->OpenXgBox(m_nXgboxNo);
				if (hRet == S_OK)
				{
					FINFO("OpenXgBox success!");
				}
				else
				{
					FERROR("OpenXgBox fail!");
					return false;
				}
			}
			if (g_pKonicaObject2)
			{
				HRESULT hRet = g_pKonicaObject2->OpenXgBox(m_nXgboxNo);
				if (hRet == S_OK)
				{
					FINFO("OpenXgBox success!");
				}
				else
				{
					FERROR("OpenXgBox fail!");
					return false;
				}
			}
			bool bRet = WaitRespond(10000, "XgboxConnect");
			if (!bRet)
			{
				return false;
			}
		}

		// Starting Exposure Sequence in AeroSync mode (refer Section 4.3 and 8.4.2 of AeroSDK Library Manual)
		if (g_pKonicaObject)
		{
			FINFO("Call SetPanelResolution");
			HRESULT hRet = g_pKonicaObject->SetPanelResolution(m_nResolution);
			if (hRet == S_OK)
			{
				FINFO("SetPanelResolution success!");
			}
			else
			{
				FERROR("SetPanelResolution fail!");
				return false;
			}

			FINFO("Call StartExposureSequenceIt");
			hRet = g_pKonicaObject->StartExposureSequenceIt(m_nXgboxNo, m_nImageNo, AEROSDK_COOPERATION_SRM, AEROSDK_INTEGRATION_LONG);
			if (hRet == S_OK)
			{
				FINFO("StartExposureSequenceIt Trigger mode success!");
			}
			else
			{
				// Fatal Error
				// This is just a sample program, so program is terminated.
				// But this error can be often happened, so User Program has to StartExposureSequence again
				// after showing the notification on GUI and waiting for operator's recovery procedure.
				FERROR("StartExposureSequenceIt Trigger mode fail!");
				return false;
			}
		}
		if (g_pKonicaObject2)
		{
			FINFO("Call SetPanelResolution");
			HRESULT hRet = g_pKonicaObject2->SetPanelResolution(m_nResolution);
			if (hRet == S_OK)
			{
				FINFO("SetPanelResolution success!");
			}
			else
			{
				FERROR("SetPanelResolution fail!");
				return false;
			}

			FINFO("Call StartExposureSequenceIt");
			hRet = g_pKonicaObject2->StartExposureSequenceIt(m_nXgboxNo, m_nImageNo, AEROSDK_COOPERATION_SRM, AEROSDK_INTEGRATION_LONG);
			if (hRet == S_OK)
			{
				FINFO("StartExposureSequenceIt Trigger mode success!");
			}
			else
			{
				// Fatal Error
				// This is just a sample program, so program is terminated.
				// But this error can be often happened, so User Program has to StartExposureSequence again
				// after showing the notification on GUI and waiting for operator's recovery procedure.
				FERROR("StartExposureSequenceIt Trigger mode fail!");
				return false;
			}
		}
	}
	else 
	{
		FERROR("Not support this sync mode:{$}", m_nSyncMode);
		return false;
	}
	
	m_pStPanelStatus[m_nCurrentPanelID]->eFPDStatus = eDetStatus::DetStatus_Work;
	FINFO("======== PrepareAcquisition end");
	return true;
}


bool KonicaCtrl::StartAcquisition(FPDDeviceKonica* pDrvDPC)
{
	FINFO("======== StartAcquisition start");
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		printf("Not current DPC, return\n");
		FERROR("Not current DPC, return");
		return false;
	}
	//未初始化、未连接 不执行
	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectState)
	{
		FERROR("bConnectState is false, Detector not connected, return");
		return false;
	}

	m_pStPanelStatus[m_nCurrentPanelID]->eFPDStatus = eDetStatus::DetStatus_Acquire;
	FINFO("======== StartAcquisition end");
	return true;
}


bool KonicaCtrl::StopAcquisition(FPDDeviceKonica* pDrvDPC)
{
	FINFO("======== StopAcquisition start");
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		printf("Not current DPC, return\n");
		FERROR("Not current DPC, return");
		return false;
	}
	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectState)
	{
		FERROR("bConnectState is false, Detector not connected, return");
		return false;
	}
	HRESULT hRet = 0;
	//如果探测器仍为曝光状态 那么取消曝光状态
	int nDetectorStatus = AEROSDK_PANEL_STATUS_UNKNOWN;
	FINFO("Call GetPanelStatusInfo");
	if (g_pKonicaObject)
	{
		hRet = g_pKonicaObject->GetPanelStatusInfo(&nDetectorStatus);
		if (hRet == S_OK)
		{
			FINFO("GetPanelStatusInfo success!");
		}
		else
		{
			FERROR("GetPanelStatusInfo fail!");
			return false;
		}
	}
	if (g_pKonicaObject2)
	{
		hRet = g_pKonicaObject2->GetPanelStatusInfo(&nDetectorStatus);
		if (hRet == S_OK)
		{
			FINFO("GetPanelStatusInfo success!");
		}
		else
		{
			FERROR("GetPanelStatusInfo fail!");
			return false;
		}
	}
	
	FINFO("nDetectorStatus:{$}", nDetectorStatus);
	if (nDetectorStatus == AEROSDK_PANEL_STATUS_READY /*|| nDetectorStatus == AEROSDK_PANEL_STATUS_EXPOSURE*/ || nDetectorStatus == AEROSDK_PANEL_STATUS_WAIT_READY)
	{
		FINFO("Call CancelExposureSequence");
		if (g_pKonicaObject)
		{
			hRet = g_pKonicaObject->CancelExposureSequence(m_nImageNo);
			if (hRet == S_OK)
			{
				FINFO("CancelExposureSequence success!");
			}
			else
			{
				FERROR("CancelExposureSequence fail!");
				return false;
			}
		}
		if (g_pKonicaObject2)
		{
			hRet = g_pKonicaObject2->CancelExposureSequence(m_nImageNo);
			if (hRet == S_OK)
			{
				FINFO("CancelExposureSequence success!");
			}
			else
			{
				FERROR("CancelExposureSequence fail!");
				return false;
			}
		}
		//等待AEROSDK_CBTYPE_END_EXPOSURE_SEQUENCE到来再进行后边的操作
		bool bRet = WaitRespond(60000, "AEROSDK_CBTYPE_END_EXPOSURE_SEQUENCE");
		if (!bRet)
		{
			return false;
		}
	}
	
	m_pStPanelStatus[m_nCurrentPanelID]->eFPDStatus = eDetStatus::DetStatus_Standby;
	FINFO("======== StopAcquisition end");
	return true;
}


bool KonicaCtrl::ActiveCalibration(FPDDeviceKonica* pDrvDPC, CCOS_CALIBRATION_TYPE eType)
{
	FINFO("======== ActiveCalibration start");
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		printf("Not current DPC, return\n");
		FERROR("Not current DPC, return");
		return false;
	}

	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectState)
	{
		FERROR("bConnectState is false, Detector not connected, return");
		return false;
	}

	StatusFeedback(EVT_STATUS_CALIBRATIOIN, PANEL_EVENT_START);
	m_nAppStatus = APP_STATUS_CAL_BEGIN; //激活校正，置为校正界面
	m_eCaliType = eType;

	if (CCOS_CALIBRATION_TYPE_DARK == m_eCaliType)
	{
		FINFO("Active Dark Calibration");
	}
	if (CCOS_CALIBRATION_TYPE_XRAY == m_eCaliType)
	{
		FINFO("Active Xray Calibration");
		if (m_nCalibrationMode) //厂商校正ActiveCalibration
		{

		}
		else //ZSKK校正
		{
			if (!m_pZSKKCalib)
			{
				FERROR("ZSKK Calibration object is undefined");
			}
			else
			{
				//加载ZSKK的校正文件
				m_pZSKKCalib->m_strRawImgPath = m_strWorkPath + "\\rawdata\\";
				m_pZSKKCalib->m_strRefFilePath = m_strWorkPath + "\\references\\";
				m_pZSKKCalib->m_nFullImgWidth = m_nImageWidth;
				m_pZSKKCalib->m_nFullImgHeight = m_nImageHeight;
				m_pZSKKCalib->m_nReferenceNum = m_nCalibrationRounds;
				m_pZSKKCalib->m_nSaturationValue = 50000;
				//LoadZSKKGainMap 参数为false,意思是开始增益校正
				m_pZSKKCalib->LoadZSKKGainMap(false, "Konica-" + m_strDetectorType);
				m_pZSKKCalib->LoadZSKKPixelMap(false, "Konica-" + m_strDetectorType);
				FINFO("Load ecom gain and pixel map, references file path: {$}", m_pZSKKCalib->m_strRefFilePath);
			}
		}
	}
	FINFO("======== ActiveCalibration end");
	return true;
}

/***
* 接受曝光图像
***/
bool KonicaCtrl::AcceptCalibration()
{
	FINFO("======== AcceptCalibration");
	if (m_nCalibrationMode)//厂商校正AcceptCalibration
	{
		//不做处理
	}
	else //ZSKK校正
	{
		WORD* pImageBuffer = nullptr;
		//这里要注意使用的image buffer是哪个，裁剪和不裁剪是不一样的
		if (m_nWidthOffset != 0 || m_nHeightOffset != 0)
		{
			pImageBuffer = m_pImgBuffer;
		}
		else 
		{
			pImageBuffer = m_pRawImgBuffer;
		}

		if (m_nCalibCurrentExposureIndex == 1)
		{
			m_pZSKKCalib->AddImageToPixMap(pImageBuffer);
			m_pZSKKCalib->AverageZSKKGainMap(pImageBuffer, m_nCalibCurrentCalibrationRound - 1, true);
		}
		else
		{
			m_pZSKKCalib->AverageZSKKGainMap(pImageBuffer, m_nCalibCurrentCalibrationRound - 1, false); //曝光第几轮
		}
	}
	return true;
}

/***
* 拒绝曝光图像
***/
bool KonicaCtrl::RejectCalibration()
{
	FINFO("======== RejectCalibration");
	return true;
}

/***
* 设置校正轮数
***/
void KonicaCtrl::SetCalibRounds(int nCalibRounds)
{
	m_nCalibrationRounds = nCalibRounds;
	FINFO("======== Set CalibrationRounds: {$}", m_nCalibrationRounds);
}

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


//使探测器ready
bool KonicaCtrl::PrepareCalibration(FPDDeviceKonica* pDrvDPC)
{
	FINFO("======== PrepareCalibration start");
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		printf("Not current DPC, return\n");
		FERROR("Not current DPC, return");
		return false;
	}
	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectState)
	{
		FERROR("bConnectState is false, Detector not connected, return");
		return false;
	}

	if (CCOS_CALIBRATION_TYPE_DARK == m_eCaliType)
	{
		FINFO("PrepareCalibration -- DARK");
		if (m_nCalibrationMode)//厂商校正PrepareCalibration
		{
			
		}
		else 
		{
			
		}
	}
	else if (CCOS_CALIBRATION_TYPE_XRAY == m_eCaliType)
	{
		FINFO("PrepareCalibration -- XRAY");
		bool ret = PrepareAcquisition(pDrvDPC);
		if (ret)
		{
			FINFO("PrepareCalibration PrepareAcquisition success!");
		}
		else
		{
			FERROR("PrepareCalibration PrepareAcquisition fail!");
			return false;
		}
	}
	FINFO("======== PrepareCalibration end");
	return true;
}


//软同步调用接口，其它同步模式没有动作
bool KonicaCtrl::StartCalibration(FPDDeviceKonica* pDrvDPC)
{
	FINFO("======== StartCalibration start");
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		printf("Not current DPC, return\n");
		FERROR("Not current DPC, return");
		return false;
	}

	//未初始化、未连接 不执行
	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectState)
	{
		FERROR("bConnectState is false, Detector not connected, return");
		return false;
	}

	if (CCOS_CALIBRATION_TYPE_DARK == m_eCaliType)
	{
		FINFO("StartCalibration DARK");
		StatusFeedback(EVT_STATUS_CALIBRATIOIN, PANEL_EVENT_END_OK);
		m_pStPanelStatus[m_nCurrentPanelID]->eFPDStatus = eDetStatus::DetStatus_Offset;
	}
	else if (CCOS_CALIBRATION_TYPE_XRAY == m_eCaliType)
	{
		FINFO("StartCalibration XRAY");
		bool ret = StartAcquisition(pDrvDPC);
		if (!ret)
		{
			return false;
		}
		m_pStPanelStatus[m_nCurrentPanelID]->eFPDStatus = eDetStatus::DetStatus_XrayCalibration;
	}
	FINFO("======== StartCalibration end");
	return true;
}


/***
** 说明：终止校正
***/
bool KonicaCtrl::AbortCalibration(FPDDeviceKonica* pDrvDPC)
{
	FINFO("======== AbortCalibration start");
	m_eCaliType = CCOS_CALIBRATION_TYPE_NONE; //恢复初值

	if (m_nCalibrationMode) //厂商校正AbortCalibration
	{

	}
	else
	{
		FINFO("Reload Gain Map And Pixel Map");
		//重新加载增益校正文件
		if (!m_pZSKKCalib->LoadZSKKGainMap(true, "Konica-" + m_strDetectorType))
		{
			Warn("Load ZSKK Gain calibration failed");
		}
		//放弃坏点校正并重新加载原来的坏点校正文件
		m_pZSKKCalib->AbortZSKKPixMap("Konica-" + m_strDetectorType);
	}
	m_nAppStatus = APP_STATUS_CAL_END;
	FINFO("======== AbortCalibration over");
	return true;
}

bool KonicaCtrl::StopCalibration(FPDDeviceKonica* 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]->bConnectState)
	{
		FERROR("bConnectState is false, Detector not connected, return");
		return false;
	}

	m_nAppStatus = APP_STATUS_CAL_END;
	return true;
}

/***
** 说明：获取校正时间
** 连接成功后，校正完成后 获取
***/
bool KonicaCtrl::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;
}

/***
** 说明：结束校正
** DPC处理完校正报告后调用，此处上传map、报告等文件
***/
bool KonicaCtrl::CompleteCalibration(FPDDeviceKonica* pDrvDPC)
{
	FINFO("======== CompleteCalibration calib type {$}", (int)m_eCaliType);
	if (m_eCaliType == CCOS_CALIBRATION_TYPE_DARK)
	{
		printf("DARK DARK Calib over \r\n");
		FINFO("DARK Calib over");
	}
	else if (m_eCaliType == CCOS_CALIBRATION_TYPE_XRAY)
	{
		printf("XRAY Calib over \r\n");
		FINFO("XRAY Calib over");
		GetCalibrationTime();
		m_nAppStatus = APP_STATUS_CAL_END;
	}

	return true;
}

bool KonicaCtrl::SaveCalibrationFile()
{
	FINFO("======== Save Calibration File");
	StatusFeedback(EVT_STATUS_SAVECALIB, PANEL_EVENT_START);
	if (m_nCalibrationMode)//厂商校正SaveCalibrationFile
	{
		//不做处理
	}
	else
	{
		FINFO("Save ZSKK Calibration File");
		m_pZSKKCalib->StoreZSKKGainMap("Konica-" + m_strDetectorType);
		m_pZSKKCalib->StoreZSKKPixMap("Konica-" + m_strDetectorType);
	}

	StatusFeedback(EVT_STATUS_SAVECALIB, PANEL_EVENT_END);
	//更新配置文件中校正日期和时间
	SYSTEMTIME stCurrentTime = { 0 };
	GetLocalTime(&stCurrentTime);
	FINFO("save calib file 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;
}

CCOS_CALIBRATION_TYPE KonicaCtrl::GetCalibType()
{
	FINFO("======== GetCalibType {$}", (int)m_eCaliType);
	return m_eCaliType;
}


/***
** 连接探测器
***/
bool KonicaCtrl::OpenDetector()
{
	FINFO("OpenDetector start");

	if (g_pKonicaObject)
	{
		FINFO("Call OpenSdk");
		HRESULT hRet = g_pKonicaObject->OpenSdk();
		if (hRet == S_OK)
		{
			FINFO("OpenSdk success!");
		}
		else
		{
			FERROR("OpenSdk fail!");
			return false;
		}

		FINFO("Call OpenPanel");
		hRet = g_pKonicaObject->OpenPanel();
		if (hRet == S_OK)
		{
			FINFO("OpenPanel success!");
		}
		else
		{
			FERROR("OpenPanel fail!");
			//重试5次如果仍不能连上再返回错误
			for (size_t i = 0; i < 5; i++)
			{
				FINFO("Call OpenPanel");
				hRet = g_pKonicaObject->OpenPanel();
				if (hRet != S_OK) 
				{
					FERROR("OpenPanel fail!");
					Sleep(3000);
				}
				else 
				{
					FINFO("OpenPanel success!");
					return true;
				}
			}
			return false;
		}
	}
	if (g_pKonicaObject2)
	{
		FINFO("Call OpenSdk");
		HRESULT hRet = g_pKonicaObject2->OpenSdk();
		if (hRet == S_OK)
		{
			FINFO("OpenSdk success!");
		}
		else
		{
			FERROR("OpenSdk fail!");
			return false;
		}

		FINFO("Call OpenPanel");
		hRet = g_pKonicaObject2->OpenPanel();
		if (hRet == S_OK)
		{
			FINFO("OpenPanel success!");
		}
		else
		{
			FERROR("OpenPanel fail!");
			//重试5次如果仍不能连上再返回错误
			for (size_t i = 0; i < 5; i++)
			{
				FINFO("Call OpenPanel");
				hRet = g_pKonicaObject2->OpenPanel();
				if (hRet != S_OK)
				{
					FERROR("OpenPanel fail!");
					Sleep(3000);
				}
				else
				{
					FINFO("OpenPanel success!");
					return true;
				}
			}
			return false;
		}
	}

	FINFO("OpenDetector end");
	return true;
}


/***
** 初始化探测器
***/
bool KonicaCtrl::InitDetector()
{
	FINFO("InitDetector start");
	int nRet = -1;

	//输出探测器版本信息、序列号等
	nRet = ShowDetectorInfo();
	if (nRet != AEROSDK_OK)
	{
		FERROR("Get detector info fail!");
		return false;
	}

	//开启单独的线程每隔一段时间调一下接口读取探测器的温度和电量和wifi信号
	if (nullptr == m_hFPDStatusThread)
	{
		unsigned uThreadId;
		_beginthreadex(NULL, 0, onFPDStatusThread, this, 0, &uThreadId);
		m_hFPDStatusThread = OpenThread(THREAD_ALL_ACCESS, TRUE, uThreadId);
	}

	if (nullptr == m_hConsumeThread)
	{
		unsigned uThreadId;
		_beginthreadex(NULL, 0, onConsumeThread, this, 0, &uThreadId);
		m_hConsumeThread = OpenThread(THREAD_ALL_ACCESS, TRUE, uThreadId);
	}

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

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

	FINFO("InitDetector end");
	return true;
}

/*API_AerosdkGetPanelSettingInfo;
	API_AerosdkGetPanelVersionInfo;
	API_AerosdkGetPanelConservationInfo;
	API_AerosdkGetCradleConservationInfo;
	API_AerosdkGetXgboxStatusInfo;
	API_AerosdkGetXgboxSettingInfo;
	API_AerosdkGetXgboxVersionInfo;
	API_AerosdkGetXgboxConservationInfo;
	API_AerosdkGetPanelGenarationInfo;
	API_AerosdkGetPanelResolutionInfo;
	API_AerosdkGetPanelAlignmentInfo;*/
int KonicaCtrl::ShowDetectorInfo()
{
	FINFO("Getting Detector Info");
	int nRet = AEROSDK_OK;
	HRESULT hRet = 0;
	int nGetPanelResolution = AEROSDK_RESOLUTION_NORMAL;

	if (g_pKonicaObject)
	{
		//老板子1417HQ 不支持高分辨率的模式
		FINFO("Call GetPanelResolution");
		hRet = g_pKonicaObject->GetPanelResolution(&nGetPanelResolution);
		if (hRet == S_OK)
		{
			FINFO("GetPanelResolution success!");
		}
		else
		{
			FERROR("GetPanelResolution fail!");
			nRet = 2;
			return nRet;
		}
	}
	if (g_pKonicaObject2)
	{
		//老板子1417HQ 不支持高分辨率的模式
		FINFO("Call GetPanelResolution");
		hRet = g_pKonicaObject2->GetPanelResolution(&nGetPanelResolution);
		if (hRet == S_OK)
		{
			FINFO("GetPanelResolution success!");
		}
		else
		{
			FERROR("GetPanelResolution fail!");
			nRet = 2;
			return nRet;
		}
	}
	FINFO("Panel resolution:{$}", nGetPanelResolution);
	if (nGetPanelResolution & AEROSDK_RESOLUTION_NORMAL)
	{
		FINFO("support normal resolution");
		m_bSupportNormalResolution = true;
	}
	if (nGetPanelResolution & AEROSDK_RESOLUTION_HIGH)
	{
		FINFO("support high resolution");
		m_bSupportHighResolution = true;
	}

	char strPanelID[68] = { 0 };
	int nPanelSize = 0;
	FINFO("Call GetPanelSettingInfo");
	if (g_pKonicaObject)
	{
		hRet = g_pKonicaObject->GetPanelSettingInfo(strPanelID, &nPanelSize);
	}
	if (g_pKonicaObject2)
	{
		hRet = g_pKonicaObject2->GetPanelSettingInfo(strPanelID, &nPanelSize);
	}
	if (hRet == S_OK)
	{
		FINFO("GetPanelSettingInfo success!");
	}
	else
	{
		FERROR("GetPanelSettingInfo fail!");
		nRet = 5;
		return nRet;
	}
	FINFO("Panel ID:{$},Panel size:{$}", strPanelID, nPanelSize);

	unsigned char ucharDllVersion[4] = {0};
	unsigned char ucharAllVersion[4] = { 0 };
	unsigned char ucharFwComnBootVersion[4] = { 0 };
	unsigned char ucharFwComnVersion[4] = { 0 };
	unsigned char ucharFwPowerBootVersion[4] = { 0 };
	unsigned char ucharFwPowerVersion[4] = { 0 };
	unsigned char ucharFpgaVersion[4] = { 0 };
	FINFO("Call GetPanelVersionInfo");
	if (g_pKonicaObject)
	{
		hRet = g_pKonicaObject->GetPanelVersionInfo(ucharDllVersion, ucharAllVersion, ucharFwComnBootVersion, ucharFwComnVersion, ucharFwPowerBootVersion, ucharFwPowerVersion, ucharFpgaVersion);
	}
	if (g_pKonicaObject2)
	{
		hRet = g_pKonicaObject2->GetPanelVersionInfo(ucharDllVersion, ucharAllVersion, ucharFwComnBootVersion, ucharFwComnVersion, ucharFwPowerBootVersion, ucharFwPowerVersion, ucharFpgaVersion);
	}
	if (hRet == S_OK)
	{
		FINFO("GetPanelVersionInfo success!");
	}
	else
	{
		FERROR("GetPanelVersionInfo fail!");
		nRet = 6;
		return nRet;
	}
	FINFO("Firmware dll version:{$}.{$}.{$}.{$}", (int)ucharDllVersion[0], (int)ucharDllVersion[1], (int)ucharDllVersion[2], (int)ucharDllVersion[3]);
	FINFO("Generic version:{$}.{$}.{$}.{$}", (int)ucharAllVersion[0], (int)ucharAllVersion[1], (int)ucharAllVersion[2], (int)ucharAllVersion[3]);
	FINFO("Communication control boot version:{$}.{$}.{$}.{$}", (int)ucharFwComnBootVersion[0], (int)ucharFwComnBootVersion[1], (int)ucharFwComnBootVersion[2], (int)ucharFwComnBootVersion[3]);
	FINFO("Communication control firmware version:{$}.{$}.{$}.{$}", (int)ucharFwComnVersion[0], (int)ucharFwComnVersion[1], (int)ucharFwComnVersion[2], (int)ucharFwComnVersion[3]);
	FINFO("Power control boot version:{$}.{$}.{$}.{$}", (int)ucharFwPowerBootVersion[0], (int)ucharFwPowerBootVersion[1], (int)ucharFwPowerBootVersion[2], (int)ucharFwPowerBootVersion[3]);
	FINFO("Power control firmware version:{$}.{$}.{$}.{$}", (int)ucharFwPowerVersion[0], (int)ucharFwPowerVersion[1], (int)ucharFwPowerVersion[2], (int)ucharFwPowerVersion[3]);
	FINFO("FPGA version:{$}.{$}.{$}.{$}", (int)ucharFpgaVersion[0], (int)ucharFpgaVersion[1], (int)ucharFpgaVersion[2], (int)ucharFpgaVersion[3]);

	unsigned int nShootCount = 0;
	FINFO("Call GetPanelConservationInfo");
	if (g_pKonicaObject)
	{
		hRet = g_pKonicaObject->GetPanelConservationInfo(&nShootCount);
	}
	if (g_pKonicaObject2)
	{
		hRet = g_pKonicaObject2->GetPanelConservationInfo(&nShootCount);
	}
	if (hRet == S_OK)
	{
		FINFO("GetPanelConservationInfo success!");
	}
	else
	{
		FERROR("GetPanelConservationInfo fail!");
		nRet = 7;
		return nRet;
	}
	FINFO("Panel nShootCount:{$}", nShootCount);

	int nConnectCount = 0;
	FINFO("Call GetCradleConservationInfo");
	if (g_pKonicaObject)
	{
		hRet = g_pKonicaObject->GetCradleConservationInfo(&nConnectCount);
	}
	if (g_pKonicaObject2)
	{
		hRet = g_pKonicaObject2->GetCradleConservationInfo(&nConnectCount);
	}
	if (hRet == S_OK)
	{
		FINFO("GetCradleConservationInfo success!");
	}
	else
	{
		FERROR("GetCradleConservationInfo fail!");
		nRet = 8;
		return nRet;
	}
	FINFO("Cradle connect count:{$}", nConnectCount);

	return nRet;
}


bool KonicaCtrl::ActiveDetector(FPDDeviceKonica* pDrvDPC, bool bActive)
{
	FINFO("========ActiveDetector bActive:{$}", bActive);
	
	if (bActive)
	{
		if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
		{
			printf("Not current DPC, return\n");
			FERROR("Not current DPC, return");
			return false;
		}
		//未初始化、未连接 不执行
		if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectState)
		{
			FERROR("bConnectState is false, Detector not connected, return");
			return false;
		}
	}
	else 
	{
		bool bRet = StopAcquisition(pDrvDPC);
		if (bRet) 
		{
			FERROR("StopAcquisition fail!");
			return false;
		}
	}

	return true;
}


unsigned __stdcall KonicaCtrl::onFPDScanThread(PVOID pvoid)
{
	FINFO("onFPDScanThread start");
	KonicaCtrl* pOpr = (KonicaCtrl*)pvoid;

	while (!pOpr->m_bExit)
	{
		DWORD dwRet = WaitForMultipleObjects(SCAN_EVENT_COUNT, pOpr->m_hArrayEvent, FALSE, INFINITE);
		if (WAIT_OBJECT_0 == dwRet) //m_hStopScanEvent
		{
			pOpr->m_bExit = true;
		}
		else if (WAIT_OBJECT_0 + 1 == dwRet) //m_hProcessImgEvent
		{
			pOpr->OnProcessImg();
		}
		else if (WAIT_OBJECT_0 + 2 == dwRet) //m_hDarkEvent
		{
			pOpr->StartDarkCalibration();
		}
		else if (WAIT_OBJECT_0 + 3 == dwRet) //m_hGainEvent
		{
			pOpr->StartGainCalibration();
		}
		else if (WAIT_OBJECT_0 + 4 == dwRet) //m_hInitEvent
		{
			pOpr->InitFPD();
		}
	}
	SetEvent(pOpr->m_hToggleEvent);
	FINFO("onFPDScanThread end");
	return 0;
}

/***
** 说明：检查探测器状态线程
***/
unsigned __stdcall KonicaCtrl::onFPDStatusThread(PVOID pvoid)
{
	FINFO("onFPDStatusThread start");
	KonicaCtrl* pOpr = (KonicaCtrl*)pvoid;
	int nRet = 0;
	int nBatteryValue = 0;//0-100
	//AEROSDK_PANEL_BATTERY_LITTLE(1) | AEROSDK_PANEL_BATTERY_ENOUGH(2) | AEROSDK_PANEL_BATTERY_CHARGE(3)
	int nBatteryStatus = 0;
	//  0 : Outside the range
	//	1 : Low(about 1 third of 3)
	//	2 : Medium(about 2 thirds of 3)
	//	3 : High
	int nSignalLevel = 0;
	int nSignalStrength = 0;
	HRESULT hRet = 0;

	while (!pOpr->m_bExit)
	{
		if (!pOpr->m_pStPanelStatus[pOpr->m_nCurrentPanelID]->bConnectState)
		{
			FERROR("Detector is not connected!");
			Sleep(pOpr->m_nNotifyStatusTimePeriod);
			continue;
		}
		FINFO("Call GetPanelBatteryInfo");
		if (g_pKonicaObject)
		{
			hRet = g_pKonicaObject->GetPanelBatteryInfo(&nBatteryValue, &nBatteryStatus);
		}
		if (g_pKonicaObject2)
		{
			hRet = g_pKonicaObject2->GetPanelBatteryInfo(&nBatteryValue, &nBatteryStatus);
		}
		if (hRet == S_OK)
		{
			FINFO("GetPanelBatteryInfo success!");
			FINFO("nBatteryValue:{$},nBatteryStatus:{$}", nBatteryValue, nBatteryStatus);
			pOpr->StatusFeedback(EVT_STATUS_BATTERY_VALUE, nBatteryValue, "", pOpr->m_nCurrentPanelID);
		}
		else
		{
			FERROR("GetPanelBatteryInfo fail!");
		}

		FINFO("Call GetPanelSignalInfo");
		if (g_pKonicaObject)
		{
			hRet = g_pKonicaObject->GetPanelSignalInfo(&nSignalLevel);
		}
		if (g_pKonicaObject2)
		{
			hRet = g_pKonicaObject2->GetPanelSignalInfo(&nSignalLevel);
		}
		if (hRet == S_OK)
		{
			FINFO("GetPanelSignalInfo success!");
			FINFO("nSignalLevel:{$}", nSignalLevel);
			switch (nSignalLevel)
			{
			case 0:
				nSignalStrength = 0;
				break;
			case 1:
				nSignalStrength = 33;
				break;
			case 2:
				nSignalStrength = 66;
				break;
			case 3:
				nSignalStrength = 99;
				break;
			default:
				nSignalStrength = 0;
				break;
			}
			pOpr->StatusFeedback(EVT_STATUS_WIFI, nSignalStrength, "", pOpr->m_nCurrentPanelID);
		}
		else
		{
			FERROR("GetPanelSignalInfo fail!");
		}

		//不能获取温度信息
		//pOpr->StatusFeedback(EVT_STATUS_TEMPERATURE, 0, "", pOpr->m_nCurrentPanelID, stInfo.temperature.maxTemperature);

		Sleep(pOpr->m_nNotifyStatusTimePeriod);
	}

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

/***
** 说明：通过com接口，从com中获取当前是否有探测器推送的消息，从队列中取，然后进行消费，从共享内存中取数据
***/
unsigned __stdcall KonicaCtrl::onConsumeThread(PVOID pvoid)
{
	FINFO("onConsumeThread start");
	KonicaCtrl* pOpr = (KonicaCtrl*)pvoid;
	int nMessageType = 0;
	HRESULT hresult = 0;

	while (!pOpr->m_bExit)
	{
		if (g_pKonicaObject)
		{
			hresult = g_pKonicaObject->GetQueueData(&nMessageType);
		}
		if (g_pKonicaObject2)
		{
			hresult = g_pKonicaObject2->GetQueueData(&nMessageType);
		}
		if (hresult != S_OK)//队列无值
		{
			Sleep(20);
			continue;
		}
		//从共享内存指定位置取值
		pOpr->DealWithEventType(nMessageType);
		
		Sleep(20);
	}

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


void KonicaCtrl::OnProcessImg()
{
	FINFO("OnProcessImg start");
	Sleep(200);
	StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_ON);
	int nRet = -1;

	//获取图像
	if (m_nWidthOffset != 0 || m_nHeightOffset != 0)
	{
		FINFO("Begin get effect image");
		printf("Begin get effect image \r\n");
		if (!GetEffectiveImage(m_pImgBuffer, m_pRawImgBuffer, m_nRawImgWidth))
		{
			return;
		}
		FINFO("Get effect image over");
		printf("Get effect image over \r\n");
		//非校正状态才应用校正文件 校正时不使用校正文件
		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);
		}
		
		DataFeedback(EVT_DATA_RAW_IMAGE, m_pImgBuffer);
		if (m_nSaveRaw)
		{
			SaveRawFunc(m_pImgBuffer, m_nImageWidth, m_nImageHeight);
		}
	}
	else
	{
		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);
		}
		DataFeedback(EVT_DATA_RAW_IMAGE, m_pRawImgBuffer);
		if (m_nSaveRaw)
		{
			SaveRawFunc(m_pRawImgBuffer, m_nRawImgWidth, m_nRawImgHeight);
		}
	}
	StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_OFF);

	FINFO("OnProcessImg end");
}


void KonicaCtrl::StartDarkCalibration()
{
	FINFO("dark calibration start");
	
	FINFO("dark calibration end");
}


void KonicaCtrl::StartGainCalibration()
{
	FINFO("StartGainCalibration start");

	FINFO("StartGainCalibration end");
}


void KonicaCtrl::InitFPD()
{
	FINFO("InitFPD start");
	StatusFeedback(EVT_STATUS_INIT, PANEL_EVENT_START);
	HRESULT hRet = 0;

	if (!g_pKonicaObject && !g_pKonicaObject2)
	{
		FERROR("g_pKonicaObject and g_pKonicaObject2 are invalid!");
		return;
	}
	string strSDKPath = "";
	try
	{
		strSDKPath = (string)m_ModeConfig["SDKPath"];
	}
	catch (ResDataObjectExption& e)
	{
		FERROR("Read configuration failed! reason: {$}", e.what());
		return;
	}
	string workpath = m_strWorkPath + strSDKPath;
	FINFO("SDK Path:{$}", workpath);
	BSTR bstrSdkPath = _com_util::ConvertStringToBSTR(workpath.c_str());
	FINFO("Call LoadDLL");
	if (g_pKonicaObject)
	{
		hRet = g_pKonicaObject->LoadDLL(bstrSdkPath);
	}
	if (g_pKonicaObject2)
	{
		hRet = g_pKonicaObject2->LoadDLL(bstrSdkPath);
	}
	if(hRet == S_OK)
	{
		FINFO("LoadDLL success!");
	}
	else
	{
		FERROR("LoadDLL fail!");
		return;
	}
	SysFreeString(bstrSdkPath);

	FINFO("Call SetPanelType m_strDetectorType:{$}", m_strDetectorType);
	BSTR bstrDetectorType = _com_util::ConvertStringToBSTR(m_strDetectorType.c_str());
	if (g_pKonicaObject)
	{
		hRet = g_pKonicaObject->SetPanelType(bstrDetectorType);
	}
	if (g_pKonicaObject2)
	{
		hRet = g_pKonicaObject2->SetPanelType(bstrDetectorType);
	}
	if(hRet == S_OK)
	{
		FINFO("SetPanelType success!");
	}
	else
	{
		FERROR("SetPanelType fail!");
		return;
	}
	SysFreeString(bstrDetectorType);

	FINFO("Call CloseXgBox");
	if (g_pKonicaObject)
	{
		hRet = g_pKonicaObject->CloseXgBox();
	}
	if (g_pKonicaObject2)
	{
		hRet = g_pKonicaObject2->CloseXgBox();
	}
	if (hRet == S_OK)
	{
		FINFO("CloseXgBox success!");
		m_bConnectXgbox = false;
	}
	else
	{
		FERROR("CloseXgBox fail!");
	}

	FINFO("Call ClosePanel");
	if (g_pKonicaObject)
	{
		hRet = g_pKonicaObject->ClosePanel();
	}
	if (g_pKonicaObject2)
	{
		hRet = g_pKonicaObject2->ClosePanel();
	}
	if (hRet == S_OK)
	{
		FINFO("ClosePanel success!");
	}
	else
	{
		FERROR("ClosePanel fail!");
	}

	// Closing AeroSDK (refer Section 8.1.2 of AeroSDK Library Manual)
	FINFO("Call CloseSdk");
	if (g_pKonicaObject)
	{
		hRet = g_pKonicaObject->CloseSdk();
	}
	if (g_pKonicaObject2)
	{
		hRet = g_pKonicaObject2->CloseSdk();
	}
	if (hRet == S_OK)
	{
		FINFO("CloseSdk success!");
	}
	else
	{
		FERROR("CloseSdk fail!");
	}

	if (!OpenDetector())
	{
		FERROR("Connect detector failed!");
		ErrorFeedback(EVT_ERR_COMMUNICATE, "true");
		StatusFeedback(EVT_STATUS_INIT, PANEL_EVENT_END); //初始化时连接失败
	}
	else
	{
		if (!InitDetector())
		{
			FERROR("Init detector failed, Connect failed");
			ErrorFeedback(EVT_ERR_INIT_FAILED, "true");
			StatusFeedback(EVT_STATUS_INIT, PANEL_EVENT_END_ERROR); //初始化失败
		}
		else
		{
			m_pStPanelStatus[m_nCurrentPanelID]->bInitOver = true;
			StatusFeedback(EVT_STATUS_INIT, PANEL_EVENT_END_OK);
		}
	}
	FINFO("InitFPD end");
}


void KonicaCtrl::SaveRawFunc(WORD* pInImg, int nImgWidth, int nImgHeight, string strFrameID)
{
	FILE* fp;
	string strFileName = "";
	if (strFrameID == "")
	{
		strFileName = m_strWorkPath + "\\rawdata\\Raw.raw";
	}
	else 
	{
		strFileName = m_strWorkPath + "\\rawdata\\Frame" + strFrameID + ".raw";
	}
	FINFO("image file name:{$}", strFileName);
	if ((fp = fopen(strFileName.c_str(), "wb")) == NULL)
	{
		DWORD dw = GetLastError();
		FERROR("fopen {$} failed, error code:{$}", strFileName, dw);
		return;
	}
	fwrite(pInImg, sizeof(WORD), (size_t)nImgWidth * (size_t)nImgHeight, fp);
	fclose(fp);
	FINFO("Save image over");
}

/***
* 保存RAW图像
***/
bool KonicaCtrl::SaveRawWithName(const char* pRawName, const WORD* pRawImg, int nWidth, int nHeight)
{
	FINFO("========SaveRawWithName RawName:{$}", pRawName);
	if (pRawImg == NULL || pRawName == NULL)
	{
		return false;
	}
	string strImagePath = m_strWorkPath + "\\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 KonicaCtrl::GetEffectiveImage(WORD* pOutImg, WORD* pInImg, int nInWidth)
{
	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;
}


bool KonicaCtrl::IsConnected(string strIP)
{
	FINFO("Check ping {$}", strIP);

	CMyPingip obPingIp;
	//StatusFeedback(EVT_STATUS_PING, 0, "true");
	if (!obPingIp.PingFunction(strIP.c_str()))
	{
		FINFO("ping {$} Failed", strIP);
		//StatusFeedback(EVT_STATUS_PING, 0, "false");
		return false;
	}
	return true;
}


/***
** 等待探测器操作执行完毕
***/
bool KonicaCtrl::WaitRespond(int nTimeOut, const char* szAction)
{
	FINFO("--- WaitRespond({$}), {$}ms ---", szAction, nTimeOut);
	DWORD dwRet = WaitForSingleObject(m_hRespond, nTimeOut);
	if (dwRet == WAIT_TIMEOUT)
	{
		FERROR("time out in wait response, action:{$}", szAction);
		return false;
	}
	return true;
}


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

string KonicaCtrl::GetStrEventType(int nEventType)
{
	string temp = "";
	switch (nEventType)
	{
	case AEROSDK_CBTYPE_PANEL_CONNECTTED_WIRE:
		temp = "AEROSDK_CBTYPE_PANEL_CONNECTTED_WIRE";
		break;
	case AEROSDK_CBTYPE_PANEL_CONNECTTED_WIRELESS:
		temp = "AEROSDK_CBTYPE_PANEL_CONNECTTED_WIRELESS";
		break;
	case AEROSDK_CBTYPE_PANEL_DISCONNECT:
		temp = "AEROSDK_CBTYPE_PANEL_DISCONNECT";
		break;
	case AEROSDK_CBTYPE_PANEL_STATUS:
		temp = "AEROSDK_CBTYPE_PANEL_STATUS";
		break;
	case AEROSDK_CBTYPE_PANEL_BATTERY_STATUS:
		temp = "AEROSDK_CBTYPE_PANEL_BATTERY_STATUS";
		break;
	case AEROSDK_CBTYPE_PANEL_SIGNAL_STATUS:
		temp = "AEROSDK_CBTYPE_PANEL_SIGNAL_STATUS";
		break;
	case AEROSDK_CBTYPE_PANEL_MOUNTED:
		temp = "AEROSDK_CBTYPE_PANEL_MOUNTED";
		break;
	case AEROSDK_CBTYPE_PANEL_SWITCH_PUSHED:
		temp = "AEROSDK_CBTYPE_PANEL_SWITCH_PUSHED";
		break;
	case AEROSDK_CBTYPE_PANEL_PULSESYNC_STATUS:
		temp = "AEROSDK_CBTYPE_PANEL_PULSESYNC_STATUS";
		break;
	case AEROSDK_CBTYPE_PANEL_ALIGNMENT_STATUS:
		temp = "AEROSDK_CBTYPE_PANEL_ALIGNMENT_STATUS";
		break;
	case AEROSDK_CBTYPE_PANEL_READY_TIMEOUT:
		temp = "AEROSDK_CBTYPE_PANEL_READY_TIMEOUT";
		break;
	case AEROSDK_CBTYPE_PANEL_START_IMAGE:
		temp = "AEROSDK_CBTYPE_PANEL_START_IMAGE";
		break;
	case AEROSDK_CBTYPE_PANEL_DONE_PREVIEW1:
		temp = "AEROSDK_CBTYPE_PANEL_DONE_PREVIEW1";
		break;
	case AEROSDK_CBTYPE_PANEL_DONE_PREVIEW2:
		temp = "AEROSDK_CBTYPE_PANEL_DONE_PREVIEW2";
		break;
	case AEROSDK_CBTYPE_PANEL_DONE_IMAGE:
		temp = "AEROSDK_CBTYPE_PANEL_DONE_IMAGE";
		break;
	case AEROSDK_CBTYPE_PANEL_ERROR_IMAGETRANSFER:
		temp = "AEROSDK_CBTYPE_PANEL_ERROR_IMAGETRANSFER";
		break;
	case AEROSDK_CBTYPE_PANEL_DONE_RETRANSFER:
		temp = "AEROSDK_CBTYPE_PANEL_DONE_RETRANSFER";
		break;
	case AEROSDK_CBTYPE_PANEL_UPDATE_STATUS:
		temp = "AEROSDK_CBTYPE_PANEL_UPDATE_STATUS";
		break;
	case AEROSDK_CBTYPE_PANEL_DONE_UPDATE:
		temp = "AEROSDK_CBTYPE_PANEL_DONE_UPDATE";
		break;
	case AEROSDK_CBTYPE_PANEL_UPDATE_ERROR:
		temp = "AEROSDK_CBTYPE_PANEL_UPDATE_ERROR";
		break;
	case AEROSDK_CBTYPE_PANEL_GAINCALIB_RESULT:
		temp = "AEROSDK_CBTYPE_PANEL_GAINCALIB_RESULT";
		break;
	case AEROSDK_CBTYPE_PANEL_DARKCALIB_PASSAGE:
		temp = "AEROSDK_CBTYPE_PANEL_DARKCALIB_PASSAGE";
		break;
	case AEROSDK_CBTYPE_PANEL_DARKCALIB_RESULT:
		temp = "AEROSDK_CBTYPE_PANEL_DARKCALIB_RESULT";
		break;
	case AEROSDK_CBTYPE_PANEL_OPEN_ERROR:
		temp = "AEROSDK_CBTYPE_PANEL_OPEN_ERROR";
		break;
	case AEROSDK_CBTYPE_PANEL_DETECT_ERROR:
		temp = "AEROSDK_CBTYPE_PANEL_DETECT_ERROR";
		break;
	case AEROSDK_CBTYPE_PANEL_ERROR_CANCELED:
		temp = "AEROSDK_CBTYPE_PANEL_ERROR_CANCELED";
		break;
	case AEROSDK_CBTYPE_PANEL_DONE_DYNAMIC_IMAGE:
		temp = "AEROSDK_CBTYPE_PANEL_DONE_DYNAMIC_IMAGE";
		break;
	case AEROSDK_CBTYPE_PANEL_DYNAMIC_IMAGE_FRAMECOUNT:
		temp = "AEROSDK_CBTYPE_PANEL_DYNAMIC_IMAGE_FRAMECOUNT";
		break;
	case AEROSDK_CBTYPE_PANEL_DONE_DYNAMIC_RETRANSFER:
		temp = "AEROSDK_CBTYPE_PANEL_DONE_DYNAMIC_RETRANSFER";
		break;
	case AEROSDK_CBTYPE_XGBOX_CONNECTTED:
		temp = "AEROSDK_CBTYPE_XGBOX_CONNECTTED";
		break;
	case AEROSDK_CBTYPE_XGBOX_DISCONNECT:
		temp = "AEROSDK_CBTYPE_XGBOX_DISCONNECT";
		break;
	case AEROSDK_CBTYPE_XGBOX_PREPARE_ON:
		temp = "AEROSDK_CBTYPE_XGBOX_PREPARE_ON";
		break;
	case AEROSDK_CBTYPE_XGBOX_EXPOSURE_ON:
		temp = "AEROSDK_CBTYPE_XGBOX_EXPOSURE_ON";
		break;
	case AEROSDK_CBTYPE_XGBOX_KMREADY_ON:
		temp = "AEROSDK_CBTYPE_XGBOX_KMREADY_ON";
		break;
	case AEROSDK_CBTYPE_XGBOX_KMREADY_OFF:
		temp = "AEROSDK_CBTYPE_XGBOX_KMREADY_OFF";
		break;
	case AEROSDK_CBTYPE_XGBOX_EXPOSURE_OFF:
		temp = "AEROSDK_CBTYPE_XGBOX_EXPOSURE_OFF";
		break;
	case AEROSDK_CBTYPE_XGBOX_PREPARE_OFF:
		temp = "AEROSDK_CBTYPE_XGBOX_PREPARE_OFF";
		break;
	case AEROSDK_CBTYPE_XGBOX_EXPOSUREON_TIMEOUT:
		temp = "AEROSDK_CBTYPE_XGBOX_EXPOSUREON_TIMEOUT";
		break;
	case AEROSDK_CBTYPE_XGBOX_ILLEGAL_SWITCH_SEQUENCE:
		temp = "AEROSDK_CBTYPE_XGBOX_ILLEGAL_SWITCH_SEQUENCE";
		break;
	case AEROSDK_CBTYPE_XGBOX_UPDATE_STATUS:
		temp = "AEROSDK_CBTYPE_XGBOX_UPDATE_STATUS";
		break;
	case AEROSDK_CBTYPE_XGBOX_DONE_UPDATE:
		temp = "AEROSDK_CBTYPE_XGBOX_DONE_UPDATE";
		break;
	case AEROSDK_CBTYPE_XGBOX_UPDATE_ERROR:
		temp = "AEROSDK_CBTYPE_XGBOX_UPDATE_ERROR";
		break;
	case AEROSDK_CBTYPE_XGBOX_OPEN_ERROR:
		temp = "AEROSDK_CBTYPE_XGBOX_OPEN_ERROR";
		break;
	case AEROSDK_CBTYPE_XGBOX_DETECT_ERROR:
		temp = "AEROSDK_CBTYPE_XGBOX_DETECT_ERROR";
		break;
	case AEROSDK_CBTYPE_XGBOX_ERROR_CANCELED:
		temp = "AEROSDK_CBTYPE_XGBOX_ERROR_CANCELED";
		break;
	case AEROSDK_CBTYPE_PANEL_XGBOX_CONNECTED_WIRE:
		temp = "AEROSDK_CBTYPE_PANEL_XGBOX_CONNECTED_WIRE";
		break;
	case AEROSDK_CBTYPE_PANEL_XGBOX_CONNECTED_WIRELESS:
		temp = "AEROSDK_CBTYPE_PANEL_XGBOX_CONNECTED_WIRELESS";
		break;
	case AEROSDK_CBTYPE_PANEL_XGBOX_DISCONNECT:
		temp = "AEROSDK_CBTYPE_PANEL_XGBOX_DISCONNECT";
		break;
	case AEROSDK_CBTYPE_PANEL_WARNING_DO_CALIBRATION:
		temp = "AEROSDK_CBTYPE_PANEL_WARNING_DO_CALIBRATION";
		break;
	case AEROSDK_CBTYPE_END_EXPOSURE_SEQUENCE:
		temp = "AEROSDK_CBTYPE_END_EXPOSURE_SEQUENCE";
		break;
	case AEROSDK_CBTYPE_END_IMAGERESENDING_SEQUENCE:
		temp = "AEROSDK_CBTYPE_END_IMAGERESENDING_SEQUENCE";
		break;
	case AEROSDK_CBTYPE_END_DELETEIMAGE_SEQUENCE:
		temp = "AEROSDK_CBTYPE_END_DELETEIMAGE_SEQUENCE";
		break;
	case AEROSDK_CBTYPE_END_PANEL_UPDATE_SEQUENCE:
		temp = "AEROSDK_CBTYPE_END_PANEL_UPDATE_SEQUENCE";
		break;
	case AEROSDK_CBTYPE_END_XGBOX_UPDATE_SEQUENCE:
		temp = "AEROSDK_CBTYPE_END_XGBOX_UPDATE_SEQUENCE";
		break;
	case AEROSDK_CBTYPE_END_PANEL_GAINCALIB_SEQUENCE:
		temp = "AEROSDK_CBTYPE_END_PANEL_GAINCALIB_SEQUENCE";
		break;
	case AEROSDK_CBTYPE_END_PANEL_DARKCALIB_SEQUENCE:
		temp = "AEROSDK_CBTYPE_END_PANEL_DARKCALIB_SEQUENCE";
		break;
	case AEROSDK_CBTYPE_END_UNSHOTIMAGE_SEQUENCE:
		temp = "AEROSDK_CBTYPE_END_UNSHOTIMAGE_SEQUENCE";
		break;
	case AEROSDK_CBTYPE_END_DYNAMIC_EXPOSURE_SEQUENCE:
		temp = "AEROSDK_CBTYPE_END_DYNAMIC_EXPOSURE_SEQUENCE";
		break;
	case AEROSDK_CBTYPE_END_DYNAMIC_IMAGERESENDING_SEQUENCE:
		temp = "AEROSDK_CBTYPE_END_DYNAMIC_IMAGERESENDING_SEQUENCE";
		break;
	}
	return temp;
}

void KonicaCtrl::DealWithEventType(int nEventType)
{
	string strTemp = GetStrEventType(nEventType);
	FINFO("DealWithEventType EventType:{$}", strTemp);
	int nRet = AEROSDK_OK;
	switch (nEventType)
	{
	case AEROSDK_CBTYPE_PANEL_CONNECTTED_WIRE:
	{
		// AeroSDK-Panel connection detection [wired]
		m_pStPanelStatus[m_nCurrentPanelID]->bConnectState = true;
		StatusFeedback(EVT_STATUS_PANEL, PANEL_CONNECT);
		break;
	}
	case AEROSDK_CBTYPE_PANEL_CONNECTTED_WIRELESS:
	{
		// AeroSDK-Panel connection detection [wireless]
		m_pStPanelStatus[m_nCurrentPanelID]->bConnectState = true;
		StatusFeedback(EVT_STATUS_PANEL, PANEL_CONNECT);
		break;
	}
	case AEROSDK_CBTYPE_PANEL_DISCONNECT:
	{
		// AeroSDK-Panel disconnection detection
		m_pStPanelStatus[m_nCurrentPanelID]->bConnectState = false;
		StatusFeedback(EVT_STATUS_PANEL, PANEL_CLOSE);
		//探测器有自动重连功能不需要程序调接口重连
		/*if (nullptr == m_hReconnectThread)
		{
			unsigned uThreadId;
			_beginthreadex(NULL, 0, onReconnectThread, this, 0, &uThreadId);
			m_hReconnectThread = OpenThread(THREAD_ALL_ACCESS, TRUE, uThreadId);
		}*/
		break;
	}
	case AEROSDK_CBTYPE_PANEL_STATUS:
	{
		// Panel status notification
		// In order to know the change of Panel status and show on GUI (outside of AeroSDKCallBack), the event should be set as follows.
		// Especially, when AerosdkStartExposureSequenceIt () is used, this code is needed in order to handle "Wait Ready"  or "Read Out" event at outside of AeroSDKCallBack.
		//从共享内存获取数据
		int nDetectorStatus = 0;
		if (m_nComServerID == 1)
		{
			m_pShareMem->ReadShareMemEx(12, &nDetectorStatus, sizeof(int));
		}
		else 
		{
			m_pShareMem2->ReadShareMemEx(12, &nDetectorStatus, sizeof(int));
		}
		
		m_nDetectorStatus = nDetectorStatus;
		switch (m_nDetectorStatus)
		{
		case AEROSDK_PANEL_STATUS_UNKNOWN:
			FINFO("Detector status: UNKNOWN");
			break;
		case AEROSDK_PANEL_STATUS_INITIALIZE:
			FINFO("Detector status: INITIALIZE");
			break;
		case AEROSDK_PANEL_STATUS_SLEEP:
			FINFO("Detector status: SLEEP");
			StatusFeedback(EVT_STATUS_PANEL, PANEL_SLEEP);
			break;
		case AEROSDK_PANEL_STATUS_STANDBY:
			FINFO("Detector status: STANDBY");
			StatusFeedback(EVT_STATUS_PANEL, PANEL_STANDBY);
			break;
		case AEROSDK_PANEL_STATUS_READY:
			FINFO("Detector status: READY");
			StatusFeedback(EVT_STATUS_PANEL, PANEL_READY_EXP);
			break;
		case AEROSDK_PANEL_STATUS_EXPOSURE:
			FINFO("Detector status: EXPOSURE");
			break;
		case AEROSDK_PANEL_STATUS_SHUTDOWN:
			FINFO("Detector status: SHUTDOWN");
			break;
		case AEROSDK_PANEL_STATUS_UPDATE:
			FINFO("Detector status: UPDATE");
			break;
		case AEROSDK_PANEL_STATUS_MAINTENANCE:
			FINFO("Detector status: MAINTENANCE");
			break;
		case AEROSDK_PANEL_STATUS_WAIT_READY:
			FINFO("Detector status: WAIT_READY");
			//如果是AED模式 com组件会调用SetPanelReady
			break;
		case AEROSDK_PANEL_STATUS_READOUT:
			FINFO("Detector status: READOUT");
			StatusFeedback(EVT_STATUS_PANEL, PANEL_XRAY_ON);
			break;
		case AEROSDK_PANEL_STATUS_ERROR:
			FINFO("Detector status: ERROR");
			break;
		default:
			break;
		}
		break;
	}
	case AEROSDK_CBTYPE_PANEL_BATTERY_STATUS:
	{
		// Panel battery status notification
		// Panel wireless signal strength notification
		FINFO("Detector battery status notification");
		int nBatteryStatus = 0;
		if (m_nComServerID == 1)
		{
			m_pShareMem->ReadShareMemEx(16, &nBatteryStatus, sizeof(int));
		}
		else 
		{
			m_pShareMem2->ReadShareMemEx(16, &nBatteryStatus, sizeof(int));
		}
		FINFO("BatteryStatus:{$}", nBatteryStatus);
		break;
	}
	case AEROSDK_CBTYPE_PANEL_SIGNAL_STATUS:
	{
		// Panel mounted notification
		FINFO("Detector signal status notification");
		int nSignalStatus = 0;
		if (m_nComServerID == 1)
		{
			m_pShareMem->ReadShareMemEx(20, &nSignalStatus, sizeof(int));
		}
		else 
		{
			m_pShareMem2->ReadShareMemEx(20, &nSignalStatus, sizeof(int));
		}
		FINFO("SignalStatus:{$}", nSignalStatus);
		break;
	}
	case AEROSDK_CBTYPE_PANEL_MOUNTED:
		// Panel switch pressed-down notification
		FINFO("Detector mounted notification");
		break;
	case AEROSDK_CBTYPE_PANEL_SWITCH_PUSHED:
		FINFO("Switch pushed notification");
		break;
	case AEROSDK_CBTYPE_PANEL_PULSESYNC_STATUS:
		FINFO("AEROSDK_CBTYPE_PANEL_PULSESYNC_STATUS");
		break;
	case AEROSDK_CBTYPE_PANEL_ALIGNMENT_STATUS:
		FINFO("AEROSDK_CBTYPE_PANEL_ALIGNMENT_STATUS");
		break;
	case AEROSDK_CBTYPE_PANEL_READY_TIMEOUT:
		// Ready timeout notification
		// After several minutes has passed, the Wiress Panel will enter into Standby mode.
		FERROR("Ready timeout notification");
		StatusFeedback(EVT_STATUS_PANEL, PANEL_READY_TIMEOUT);
		break;
	case AEROSDK_CBTYPE_PANEL_START_IMAGE:
		// Image transfer start notification
		FINFO("Image transfer start notnotificationify");
		break;
	case AEROSDK_CBTYPE_PANEL_DONE_PREVIEW1:
		// Preview1 image receiving completion notification
		FINFO("Preview1 image arrived");
		if (m_nCurrentLogicMode == AcqMode::Stitch)
		{
			FINFO("Stitch mode not send preview image!");
			break;
		}
		//从共享内存获取数据
		if (m_nComServerID == 1)
		{
			m_pShareMem->ReadShareMemEx(300, m_pPreImgBuffer, m_nPreImgWidth* m_nPreImgHeight * sizeof(WORD));
		}
		else
		{
			m_pShareMem2->ReadShareMemEx(300, m_pPreImgBuffer, m_nPreImgWidth* m_nPreImgHeight * sizeof(WORD));
		}
		DataFeedback(EVT_DATA_PREVIEW_IMAGE, m_pPreImgBuffer);
		if (m_nSaveRaw)
		{
			SaveRawWithName("Preview.raw", m_pPreImgBuffer, m_nPreImgWidth, m_nPreImgHeight);
		}
		break;
	case AEROSDK_CBTYPE_PANEL_DONE_PREVIEW2:
		// Preview2 image receiving completion notification
		FINFO("Preview2 image arrived");
		//从共享内存获取数据
		//DataFeedback(EVT_DATA_PREVIEW_IMAGE, m_pPreImgBuffer);
		break;
	case AEROSDK_CBTYPE_PANEL_DONE_IMAGE:
	{
		// Final image receiving completion notification
		FINFO("Final image arrived");
		StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_ON);
		// Receiving final image from SDK (refer Section 4.4.1 and 8.9.4 of AeroSDK Library Manual)
		//从共享内存获取数据
		if (m_nComServerID == 1)
		{
			m_pShareMem->ReadShareMemEx(300 + 4 * 1024 * 1024, m_pRawImgBuffer, m_nRawImgWidth* m_nRawImgHeight * sizeof(WORD));
		}
		else 
		{
			m_pShareMem2->ReadShareMemEx(300 + 4 * 1024 * 1024, m_pRawImgBuffer, m_nRawImgWidth* m_nRawImgHeight * sizeof(WORD));
		}
		FINFO("m_nWidthOffset:{$},m_nHeightOffset:{$}", m_nWidthOffset, m_nHeightOffset);
		if (m_nWidthOffset != 0 || m_nHeightOffset != 0)
		{
			FINFO("Begin get effect image");
			if (!GetEffectiveImage(m_pImgBuffer, m_pRawImgBuffer, m_nRawImgWidth))
			{
				return;
			}
			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);
			}
			DataFeedback(EVT_DATA_RAW_IMAGE, m_pImgBuffer);
			if (m_nSaveRaw)
			{
				SaveRawFunc(m_pImgBuffer, m_nImageWidth, m_nImageHeight, std::to_string(m_nImageNo));
			}
		}
		else
		{
			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);
			}
			DataFeedback(EVT_DATA_RAW_IMAGE, m_pRawImgBuffer);
			if (m_nSaveRaw)
			{
				SaveRawFunc(m_pRawImgBuffer, m_nRawImgWidth, m_nRawImgHeight, std::to_string(m_nImageNo));
			}
		}
		StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_OFF);
		break;
	}
	case AEROSDK_CBTYPE_PANEL_ERROR_IMAGETRANSFER:
		// Image transfer error
		FERROR("Image transfer error notification");
		break;
	case AEROSDK_CBTYPE_PANEL_DONE_RETRANSFER:
		// Image resending completion notification
		FINFO("Image resending completion notification");
		break;
	case AEROSDK_CBTYPE_PANEL_UPDATE_STATUS:
		// Panel firmware update status notification
		FINFO("Panel firmware update status notification");
		break;
	case AEROSDK_CBTYPE_PANEL_DONE_UPDATE:
		FINFO("Panel firmware update success");
		break;
	case AEROSDK_CBTYPE_PANEL_UPDATE_ERROR:
		// Panel firmware update error notification
		FERROR("Panel firmware update error notification");
		break;
	case AEROSDK_CBTYPE_PANEL_GAINCALIB_RESULT:	
		// Gain calibration result notification
		FINFO("Gain calibration result notification");
		break;
	case AEROSDK_CBTYPE_PANEL_DARKCALIB_PASSAGE:
		// Dark calibration progress notification
		FINFO("Dark calibration progress notification");
		break;
	case AEROSDK_CBTYPE_PANEL_DARKCALIB_RESULT:
		// Dark calibration result notification
		FINFO("Dark calibration result notification");
		break;
	case AEROSDK_CBTYPE_PANEL_OPEN_ERROR:
		// Panel open error after retry
		FERROR("Panel open fail!");
		break;
	case AEROSDK_CBTYPE_PANEL_DETECT_ERROR:
		// Panel error detection
		FERROR("Panel error detection");
		break;
	case AEROSDK_CBTYPE_PANEL_ERROR_CANCELED:
		// Panel error cancellation
		FERROR("Panel error cancellation");
		break;
	case AEROSDK_CBTYPE_PANEL_DONE_DYNAMIC_IMAGE:
		FINFO("AEROSDK_CBTYPE_PANEL_DONE_DYNAMIC_IMAGE");
		break;
	case AEROSDK_CBTYPE_PANEL_DYNAMIC_IMAGE_FRAMECOUNT:	
		FINFO("AEROSDK_CBTYPE_PANEL_DYNAMIC_IMAGE_FRAMECOUNT");
		break;
	case AEROSDK_CBTYPE_PANEL_DONE_DYNAMIC_RETRANSFER:	
		FINFO("AEROSDK_CBTYPE_PANEL_DONE_DYNAMIC_RETRANSFER");
		break;
	case AEROSDK_CBTYPE_XGBOX_CONNECTTED:
		// AeroSDK - XG-IFBOX connection detection; In AeroSync Mode, this callback does not happen.
		FINFO("XgBox connect notification");
		m_bConnectXgbox = true;
		StopWaiting("XgboxConnect");
		break;
	case AEROSDK_CBTYPE_XGBOX_DISCONNECT:
		// AeroSDK - XG-IFBOX disconnection detection; In AeroSync Mode, this callback does not happen.
		FINFO("XgBox disconnect notification");
		m_bConnectXgbox = false;
		break;
	case AEROSDK_CBTYPE_XGBOX_PREPARE_ON:
		// Prepare Signal On Detection; In AeroSync Mode, this callback does not happen.
		FINFO("AEROSDK_CBTYPE_XGBOX_PREPARE_ON");
		break;
	case AEROSDK_CBTYPE_XGBOX_EXPOSURE_ON:
		// Exposure Signal On Detection; In AeroSync Mode, this callback does not happen.
		FINFO("AEROSDK_CBTYPE_XGBOX_EXPOSURE_ON");
		break;
	case AEROSDK_CBTYPE_XGBOX_KMREADY_ON:
		// KM_Ready Signal On Detection; In AeroSync Mode, this callback does not happen.
		FINFO("AEROSDK_CBTYPE_XGBOX_KMREADY_ON");
		break;
	case AEROSDK_CBTYPE_XGBOX_KMREADY_OFF:
		// KM_Ready Signal Off Detection; In AeroSync Mode, this callback does not happen.
		FINFO("AEROSDK_CBTYPE_XGBOX_KMREADY_OFF");
		break;
	case AEROSDK_CBTYPE_XGBOX_EXPOSURE_OFF:
		// Exposure Signal Off Detection; In AeroSync Mode, this callback does not happen.
		FINFO("AEROSDK_CBTYPE_XGBOX_EXPOSURE_OFF");
		break;
	case AEROSDK_CBTYPE_XGBOX_PREPARE_OFF:
		// Prepare Signal Off Detection; In AeroSync Mode, this callback does not happen.
		FINFO("AEROSDK_CBTYPE_XGBOX_PREPARE_OFF");
		break;
	case AEROSDK_CBTYPE_XGBOX_EXPOSUREON_TIMEOUT:
		// Exposure switch pressed down timeout; In AeroSync Mode, this callback does not happen.
		FERROR("AEROSDK_CBTYPE_XGBOX_EXPOSUREON_TIMEOUT");
		break;
	case AEROSDK_CBTYPE_XGBOX_ILLEGAL_SWITCH_SEQUENCE:
		// Switch sequence interruption; In AeroSync Mode, this callback does not happen.
		FINFO("AEROSDK_CBTYPE_XGBOX_ILLEGAL_SWITCH_SEQUENCE");
		break;
	case AEROSDK_CBTYPE_XGBOX_UPDATE_STATUS:
		// XG-IFBOX firmware update status notification; In AeroSync Mode, this callback does not happen.
		FINFO("AEROSDK_CBTYPE_XGBOX_UPDATE_STATUS");
		break;
	case AEROSDK_CBTYPE_XGBOX_DONE_UPDATE:
		// XG-IFBOX firmware update completion notification; In AeroSync Mode, this callback does not happen.
		FINFO("AEROSDK_CBTYPE_XGBOX_DONE_UPDATE");
		break;
	case AEROSDK_CBTYPE_XGBOX_UPDATE_ERROR:
		// XG-IFBOX firmware update error notification; In AeroSync Mode, this callback does not happen.
		FERROR("AEROSDK_CBTYPE_XGBOX_UPDATE_ERROR");
		break;
	case AEROSDK_CBTYPE_XGBOX_OPEN_ERROR:
		// XG-IFBOX open error; In AeroSync Mode, this callback does not happen.
		FERROR("AEROSDK_CBTYPE_XGBOX_OPEN_ERROR");
		break;
	case AEROSDK_CBTYPE_XGBOX_DETECT_ERROR:
		// XG-IFBOX error detection; In AeroSync Mode, this callback does not happen.
		FINFO("AEROSDK_CBTYPE_XGBOX_DETECT_ERROR");
		break;
	case AEROSDK_CBTYPE_XGBOX_ERROR_CANCELED:
		// XG-IFBOX error cancellation; In AeroSync Mode, this callback does not happen.
		FERROR("AEROSDK_CBTYPE_XGBOX_ERROR_CANCELED");
		break;
	case AEROSDK_CBTYPE_PANEL_XGBOX_CONNECTED_WIRE:
		// Panel -- XG-IFBOX connection is detected (in wired mode) after it was disconnected.
		FINFO("AEROSDK_CBTYPE_PANEL_XGBOX_CONNECTED_WIRE");
		break;
	case AEROSDK_CBTYPE_PANEL_XGBOX_CONNECTED_WIRELESS:
		// Panel -- XG-IFBOX connection is detected (in wireless mode) after it was disconnected.
		FINFO("AEROSDK_CBTYPE_PANEL_XGBOX_CONNECTED_WIRELESS");
		break;
	case AEROSDK_CBTYPE_PANEL_XGBOX_DISCONNECT:
		// Panel -- XG-IFBOX is disconnected.
		FINFO("AEROSDK_CBTYPE_PANEL_XGBOX_DISCONNECT");
		break;
	case AEROSDK_CBTYPE_PANEL_WARNING_DO_CALIBRATION:
		// Warning to let User Program prompt end-users to make calibration of Panel
		FINFO("AEROSDK_CBTYPE_PANEL_WARNING_DO_CALIBRATION");
		break;
	case AEROSDK_CBTYPE_END_EXPOSURE_SEQUENCE:
		// Exposure sequence end notification
		FINFO("Exposure sequence end notification");
		StatusFeedback(EVT_STATUS_PANEL, PANEL_STANDBY);
		StopWaiting("AEROSDK_CBTYPE_END_EXPOSURE_SEQUENCE");
		//曝光序列结束，曝光超时需要重新走ready流程，需要再次调用AerosdkStartExposureSequenceIt
		// These need much processing time, so the code should be written at outside of AeroSDKCallBack().
		break;
	case AEROSDK_CBTYPE_END_IMAGERESENDING_SEQUENCE:	
		// Image resending sequence end notification
		FINFO("Image resending sequence end notification");
		break;
	case AEROSDK_CBTYPE_END_DELETEIMAGE_SEQUENCE:	
		// Image discarding sequence end notification
		FINFO("Image discarding sequence end notification");
		break;
	case AEROSDK_CBTYPE_END_PANEL_UPDATE_SEQUENCE:		
		// Panel firmware update sequence end notification
		FINFO("Panel firmware update sequence end notification");
		break;
	case AEROSDK_CBTYPE_END_XGBOX_UPDATE_SEQUENCE:
		// XG-IFBOX firmware update sequence end notification; In AeroSync Mode, this callback does not happen.
		FINFO("AEROSDK_CBTYPE_END_XGBOX_UPDATE_SEQUENCE");
		break;
	case AEROSDK_CBTYPE_END_PANEL_GAINCALIB_SEQUENCE:	
		// Gain calibration sequence end notification
		FINFO("Gain calibration sequence end notification");
		break;
	case AEROSDK_CBTYPE_END_PANEL_DARKCALIB_SEQUENCE:	
		// Dark calibration sequence end notification
		FINFO("Dark calibration sequence end notification");
		break;
	case AEROSDK_CBTYPE_END_UNSHOTIMAGE_SEQUENCE:
		FINFO("AEROSDK_CBTYPE_END_UNSHOTIMAGE_SEQUENCE");
		break;
	case AEROSDK_CBTYPE_END_DYNAMIC_EXPOSURE_SEQUENCE:
		FINFO("AEROSDK_CBTYPE_END_DYNAMIC_EXPOSURE_SEQUENCE");
		break;
	case AEROSDK_CBTYPE_END_DYNAMIC_IMAGERESENDING_SEQUENCE:
		FINFO("AEROSDK_CBTYPE_END_DYNAMIC_IMAGERESENDING_SEQUENCE");
		break;
	default:
		FWARN("DealWithEventType default type:{$}", nEventType);
		break;
	}
}


void KonicaCtrl::ConfFeedback(int nEventID, int nDetectorID, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	if (-1 == nDetectorID)
	{
		nDetectorID = m_nCurrentPanelID;
	}
	((FPDDeviceKonica*)(*m_pPanelID2DPC)[nDetectorID])->OnFPDCallback(nDetectorID,
		nEventID, EVT_LEVEL_CONFIGURATION, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
}


void KonicaCtrl::InfoFeedback(int nEventID, int nDetectorID, int nParam1, float fParam2, const char* pszMsg, int nPtrParamLen, void* pParam)
{
	if (-1 == nDetectorID)
	{
		nDetectorID = m_nCurrentPanelID;
	}
	((FPDDeviceKonica*)(*m_pPanelID2DPC)[nDetectorID])->OnFPDCallback(nDetectorID,
		nEventID, EVT_LEVEL_INFORMATOION, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
}


void KonicaCtrl::StatusFeedback(int nEventID, int nParam1, const char* pszMsg, int nDetectorID, float fParam2, int nPtrParamLen, void* pParam)
{
	if (-1 == nDetectorID)
	{
		nDetectorID = m_nCurrentPanelID;
	}
	((FPDDeviceKonica*)(*m_pPanelID2DPC)[nDetectorID])->OnFPDCallback(nDetectorID,
		nEventID, EVT_LEVEL_STATUS, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
}


void KonicaCtrl::DataFeedback(int nEventID, void* pParam, int nParam1, float fParam2, const char* pszMsg, int nPtrParamLen, int nDetectorID)
{
	if (-1 == nDetectorID)
	{
		nDetectorID = m_nCurrentPanelID;
	}
	((FPDDeviceKonica*)(*m_pPanelID2DPC)[nDetectorID])->OnFPDCallback(nDetectorID,
		nEventID, EVT_LEVEL_DATA, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
}


void KonicaCtrl::WarnFeedback(int nEventID, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam, int nDetectorID)
{
	if (-1 == nDetectorID)
	{
		nDetectorID = m_nCurrentPanelID;
	}
	((FPDDeviceKonica*)(*m_pPanelID2DPC)[nDetectorID])->OnFPDCallback(nDetectorID,
		nEventID, EVT_LEVEL_WARNING, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
}


void KonicaCtrl::ErrorFeedback(int nEventID, const char* pszMsg, int nDetectorID, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	if (-1 == nDetectorID)
	{
		nDetectorID = m_nCurrentPanelID;
	}
	((FPDDeviceKonica*)(*m_pPanelID2DPC)[nDetectorID])->OnFPDCallback(nDetectorID,
		nEventID, EVT_LEVEL_ERROR, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
}

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

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

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

/***
** 说明：重连探测器线程
***/
unsigned __stdcall KonicaCtrl::onReconnectThread(PVOID pvoid)
{
	FINFO("Reconnect detector thread start");
	KonicaCtrl* pOpr = (KonicaCtrl*)pvoid;

	while (!pOpr->m_pStPanelStatus[pOpr->m_nCurrentPanelID]->bConnectState)
	{
		pOpr->OpenDetector();
		Sleep(pOpr->m_nReconnectTimePeriod);
	}

	FINFO("Leave reconnect detector thread");
	return 0;
}

bool KonicaCtrl::SetResolution(int nResolution)
{
	FINFO("========SetResolution nResolution:{$}", nResolution);
	m_nResolution = nResolution;
	ConfFeedback(EVT_CONF_CURRENT_RESOLUTION, m_nCurrentPanelID, "CurrentResolution", m_nResolution);
	return true;
}

bool KonicaCtrl::GetImageSize()
{
	FINFO("========GetImageSize");
	HRESULT hRet = 0;
	if (AEROSDK_RESOLUTION_NORMAL == m_nResolution)
	{
		// Acquisition of preview image size as Normal resolution.
		FINFO("Call GetImageSize");
		if (g_pKonicaObject)
		{
			hRet = g_pKonicaObject->GetImageSize(AEROSDK_IMAGE_PREVIEW, AEROSDK_RESOLUTION_NORMAL, &m_nPreImgWidth, &m_nPreImgHeight);
		}
		if (g_pKonicaObject2)
		{
			hRet = g_pKonicaObject2->GetImageSize(AEROSDK_IMAGE_PREVIEW, AEROSDK_RESOLUTION_NORMAL, &m_nPreImgWidth, &m_nPreImgHeight);
		}
		if (hRet == S_OK)
		{
			FINFO("GetPreivewImageSize success!");
		}
		else
		{
			FERROR("GetPreivewImageSize fail!");
			return false;
		}
		FINFO("Preview Size (Normal Resolution)  width:{$} Height:{$}", m_nPreImgWidth, m_nPreImgHeight);

		// Acquisition of final image size as Normal resolution.
		FINFO("Call GetImageSize");
		if (g_pKonicaObject)
		{
			hRet = g_pKonicaObject->GetImageSize(AEROSDK_IMAGE_EXPOSURE, AEROSDK_RESOLUTION_NORMAL, &m_nRawImgWidth, &m_nRawImgHeight);
		}
		if (g_pKonicaObject2)
		{
			hRet = g_pKonicaObject2->GetImageSize(AEROSDK_IMAGE_EXPOSURE, AEROSDK_RESOLUTION_NORMAL, &m_nRawImgWidth, &m_nRawImgHeight);
		}
		if (hRet == S_OK)
		{
			FINFO("GetFinalImageSize success!");
		}
		else
		{
			FERROR("GetFinalImageSize fail!");
			return false;
		}
		FINFO("Exposure Size (Normal Resolution)  width:{$} Height:{$}", m_nRawImgWidth, m_nRawImgHeight);
	}
	else if (AEROSDK_RESOLUTION_HIGH == m_nResolution)
	{
		// Acquisition of preview image size as High resolution.
		FINFO("Call GetImageSize");
		if (g_pKonicaObject)
		{
			hRet = g_pKonicaObject->GetImageSize(AEROSDK_IMAGE_PREVIEW, AEROSDK_RESOLUTION_HIGH, &m_nPreImgWidth, &m_nPreImgHeight);
		}
		if (g_pKonicaObject2)
		{
			hRet = g_pKonicaObject2->GetImageSize(AEROSDK_IMAGE_PREVIEW, AEROSDK_RESOLUTION_HIGH, &m_nPreImgWidth, &m_nPreImgHeight);
		}
		if (hRet == S_OK)
		{
			FINFO("GetPreivewImageSize success!");
		}
		else
		{
			FERROR("GetPreivewImageSize fail!");
			return false;
		}
		FINFO("Preview Size (High Resolution)  width:{$} Height:{$}", m_nPreImgWidth, m_nPreImgHeight);

		// Acquisition of final image size as High resolution.
		FINFO("Call GetImageSize");
		if (g_pKonicaObject)
		{
			hRet = g_pKonicaObject->GetImageSize(AEROSDK_IMAGE_EXPOSURE, AEROSDK_RESOLUTION_HIGH, &m_nRawImgWidth, &m_nRawImgHeight);
		}
		if (g_pKonicaObject2)
		{
			hRet = g_pKonicaObject2->GetImageSize(AEROSDK_IMAGE_EXPOSURE, AEROSDK_RESOLUTION_HIGH, &m_nRawImgWidth, &m_nRawImgHeight);
		}
		if (hRet == S_OK)
		{
			FINFO("GetFinalImageSize success!");
		}
		else
		{
			FERROR("GetFinalImageSize fail!");
			return false;
		}
		FINFO("Exposure Size (High Resolution)  width:{$} Height:{$}", m_nRawImgWidth, m_nRawImgHeight);
	}
	else
	{
		// Acquisition of preview image size as Normal resolution.
		FINFO("Call GetImageSize");
		if (g_pKonicaObject)
		{
			hRet = g_pKonicaObject->GetImageSize(AEROSDK_IMAGE_PREVIEW, AEROSDK_RESOLUTION_NORMAL, &m_nPreImgWidth, &m_nPreImgHeight);
		}
		if (g_pKonicaObject2)
		{
			hRet = g_pKonicaObject2->GetImageSize(AEROSDK_IMAGE_PREVIEW, AEROSDK_RESOLUTION_NORMAL, &m_nPreImgWidth, &m_nPreImgHeight);
		}
		if (hRet == S_OK)
		{
			FINFO("GetPreivewImageSize success!");
		}
		else
		{
			FERROR("GetPreivewImageSize fail!");
			return false;
		}
		FINFO("Preview Size (Normal Resolution)  width:{$} Height:{$}", m_nPreImgWidth, m_nPreImgHeight);

		// Acquisition of final image size as Normal resolution.
		FINFO("Call GetImageSize");
		if (g_pKonicaObject)
		{
			hRet = g_pKonicaObject->GetImageSize(AEROSDK_IMAGE_EXPOSURE, AEROSDK_RESOLUTION_NORMAL, &m_nRawImgWidth, &m_nRawImgHeight);
		}
		if (g_pKonicaObject2)
		{
			hRet = g_pKonicaObject2->GetImageSize(AEROSDK_IMAGE_EXPOSURE, AEROSDK_RESOLUTION_NORMAL, &m_nRawImgWidth, &m_nRawImgHeight);
		}
		if (hRet == S_OK)
		{
			FINFO("GetFinalImageSize success!");
		}
		else
		{
			FERROR("GetFinalImageSize fail!");
			return false;
		}
		FINFO("Exposure Size (Normal Resolution)  width:{$} Height:{$}", m_nRawImgWidth, m_nRawImgHeight);
	}

	ConfFeedback(EVT_CONF_PREVIEW_WIDTH, m_nCurrentPanelID, "PreviewImageWidth", m_nPreImgWidth);
	ConfFeedback(EVT_CONF_PREVIEW_HIGHT, m_nCurrentPanelID, "PreviewImageHeight", m_nPreImgHeight);
	ConfFeedback(EVT_CONF_RAW_WIDTH, m_nCurrentPanelID, "FullImageWidth", m_nRawImgWidth);
	ConfFeedback(EVT_CONF_RAW_HIGHT, m_nCurrentPanelID, "FullImageHeight", m_nRawImgHeight);

	if (m_pPreImgBuffer != nullptr)
	{
		delete[] m_pPreImgBuffer;
		m_pPreImgBuffer = nullptr;
	}
	m_pPreImgBuffer = new WORD[m_nPreImgWidth * m_nPreImgHeight];
	if (m_pRawImgBuffer != nullptr)
	{
		delete[] m_pRawImgBuffer;
		m_pRawImgBuffer = nullptr;
	}
	m_pRawImgBuffer = new WORD[m_nRawImgWidth * m_nRawImgHeight];
	if (m_pImgBuffer != nullptr)
	{
		delete[] m_pImgBuffer;
		m_pImgBuffer = nullptr;
	}
	m_pImgBuffer = new WORD[m_nRawImgWidth * m_nRawImgHeight];
	return true;
}

bool KonicaCtrl::CheckImageInDetector(FPDDeviceKonica* pDrvDPC)
{
	FINFO("======== CheckImageInDetector");

	HRESULT hRet = 0;
	int nImageNo = 0;
	int nImageResolution = 0;

	FINFO("Call CheckImageEx");
	if (g_pKonicaObject)
	{
		hRet = g_pKonicaObject->CheckImageEx(&nImageNo, &nImageResolution);
	}
	if (g_pKonicaObject2)
	{
		hRet = g_pKonicaObject2->CheckImageEx(&nImageNo, &nImageResolution);
	}
	if (hRet == S_OK)
	{
		FINFO("CheckImageEx success!");
		if (nImageNo)//探测器内有图
		{
			//通知上层是否恢复或者删除图像
			FINFO("Have image in detector!");
		}
		else  //探测器内无图 
		{
			FINFO("NO image in detector!");
			return true;
		}
	}
	else
	{
		FERROR("CheckImageEx fail!");
		StatusFeedback(EVT_STATUS_IMAGEPENDING);
		return false;
	}

	StatusFeedback(EVT_STATUS_IMAGEPENDING);

	//在这里程序肯定会崩溃，程序崩溃后重新把COM服务拉起来
	//这里进行com组件的调用
	/*bool bRet = RestartComServer();
	if (!bRet) 
	{
		FERROR("Restart COM server fail!");
		return false;
	}*/
	
	return false;
}

bool KonicaCtrl::RestartComServer()
{
	HRESULT hRet = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
	if (FAILED(hRet))
	{
		FERROR("CoInitializeEx fail!");
		return false;
	}

	FINFO("m_nComServerID:{$}", m_nComServerID);
	if (m_nComServerID == 1)
	{
		hRet = ::CoCreateInstance(CLSID_KonicaObject, NULL, CLSCTX_LOCAL_SERVER, IID_IKonicaObject, (LPVOID*)&g_pKonicaObject);
		if (hRet == S_OK)
		{
			FINFO("Get KonicaCom pointer success!");
		}
		else
		{
			FERROR("Get KonicaCom pointer fail!");
			return false;
		}
	}
	else
	{
		hRet = ::CoCreateInstance(CLSID_KonicaObject2, NULL, CLSCTX_LOCAL_SERVER, IID_IKonicaObject2, (LPVOID*)&g_pKonicaObject2);
		if (hRet == S_OK)
		{
			FINFO("Get KonicaCom pointer success!");
		}
		else
		{
			FERROR("Get KonicaCom pointer fail!");
			return false;
		}
	}

	if (!g_pKonicaObject && !g_pKonicaObject2)
	{
		FERROR("g_pKonicaObject and g_pKonicaObject2 are invalid!");
		return false;
	}
	string strSDKPath = "";
	try
	{
		strSDKPath = (string)m_ModeConfig["SDKPath"];
	}
	catch (ResDataObjectExption& e)
	{
		FERROR("Read configuration failed! reason: {$}", e.what());
		return false;
	}
	string workpath = m_strWorkPath + strSDKPath;
	FINFO("SDK Path:{$}", workpath);
	BSTR bstrSdkPath = _com_util::ConvertStringToBSTR(workpath.c_str());
	FINFO("Call LoadDLL");
	if (g_pKonicaObject)
	{
		hRet = g_pKonicaObject->LoadDLL(bstrSdkPath);
	}
	if (g_pKonicaObject2)
	{
		hRet = g_pKonicaObject2->LoadDLL(bstrSdkPath);
	}
	if (hRet == S_OK)
	{
		FINFO("LoadDLL success!");
	}
	else
	{
		FERROR("LoadDLL fail!");
		return false;
	}
	SysFreeString(bstrSdkPath);

	FINFO("Call SetPanelType m_strDetectorType:{$}", m_strDetectorType);
	BSTR bstrDetectorType = _com_util::ConvertStringToBSTR(m_strDetectorType.c_str());
	if (g_pKonicaObject)
	{
		hRet = g_pKonicaObject->SetPanelType(bstrDetectorType);
	}
	if (g_pKonicaObject2)
	{
		hRet = g_pKonicaObject2->SetPanelType(bstrDetectorType);
	}
	if (hRet == S_OK)
	{
		FINFO("SetPanelType success!");
	}
	else
	{
		FERROR("SetPanelType fail!");
		return false;
	}
	SysFreeString(bstrDetectorType);

	FINFO("Call CloseXgBox");
	if (g_pKonicaObject)
	{
		hRet = g_pKonicaObject->CloseXgBox();
	}
	if (g_pKonicaObject2)
	{
		hRet = g_pKonicaObject2->CloseXgBox();
	}
	if (hRet == S_OK)
	{
		FINFO("CloseXgBox success!");
		m_bConnectXgbox = false;
	}
	else
	{
		FERROR("CloseXgBox fail!");
	}

	FINFO("Call ClosePanel");
	if (g_pKonicaObject)
	{
		hRet = g_pKonicaObject->ClosePanel();
	}
	if (g_pKonicaObject2)
	{
		hRet = g_pKonicaObject2->ClosePanel();
	}
	if (hRet == S_OK)
	{
		FINFO("ClosePanel success!");
	}
	else
	{
		FERROR("ClosePanel fail!");
	}

	// Closing AeroSDK (refer Section 8.1.2 of AeroSDK Library Manual)
	FINFO("Call CloseSdk");
	if (g_pKonicaObject)
	{
		hRet = g_pKonicaObject->CloseSdk();
	}
	if (g_pKonicaObject2)
	{
		hRet = g_pKonicaObject2->CloseSdk();
	}
	if (hRet == S_OK)
	{
		FINFO("CloseSdk success!");
	}
	else
	{
		FERROR("CloseSdk fail!");
	}

	return true;
}