PhysicalDevice/Detector/HaoBo/CCOS.Dev.FPD.HaoBo/Detector_HaoBo.cpp

#include <dlfcn.h> 
#include "Detector_HaoBo.h"
#include "CCOS.Dev.FPD.HaoBo.h"
#include "LogLocalHelper.h"       
#include "Log4CPP.h"

Detector_HaoBoRF* g_pDetector = nullptr;

//#define LOAD_PROC_ADDRESS(handle, func) \
//    do { \
//        void* p = dlsym(handle, #func); \
//        if (p == NULL) { \
//            FERROR("loading entry point %s error: %s", #func, dlerror()); \
//        } else { \
//            this->func = reinterpret_cast<decltype(this->func)>(p); \
//        } \
//    } while(0)
#ifdef _WIN32
#define LOAD_PROC_ADDRESS(handle,func) \
    if ((func = reinterpret_cast<API_##func>(GetProcAddress(handle, #func))) == NULL) { \
        FERROR("loading entry point {$} error!!!", #func); \
    }
#else
#define LOAD_PROC_ADDRESS(handle,func) \
    if ((func = reinterpret_cast<API_##func>(dlsym(handle, #func))) == NULL) { \
        FERROR("loading entry point {$} error!!!", #func); \
    }
#endif

#define BREAK_UINT32(var, ByteNum) \
		(unsigned char)((unsigned int)(((var) >> ((ByteNum)* 8)) & 0x00FF))
#define BUILD_UINT32(Byte0, Byte1, Byte2, Byte3) \
	((unsigned int)((unsigned int)((Byte0)& 0x00FF) \
	+ ((unsigned int)((Byte1)& 0x00FF) << 8) \
	+ ((unsigned int)((Byte2)& 0x00FF) << 16) \
	+ ((unsigned int)((Byte3)& 0x00FF) << 24)))


Detector_HaoBoRF::Detector_HaoBoRF()
{
	m_pDPC2PanelID = new map<void*, int>();
	m_pPanelID2DPC = new map<int, void*>();
	m_nPanelCount = 0;
	m_nCurrentPanelID = 0;
	m_bConnected = false;
	m_nCurrentLogicMode = -1;
	m_pRawImgBuffer = nullptr;
	m_pFullImgBuffer = nullptr;
	m_nSaveRaw = 0;
	m_strCtrlWorkPath = "";
	m_eCaliType = CCOS_CALIBRATION_TYPE::CCOS_CALIBRATION_TYPE_NONE;
	m_eStatus = eDetStatus::DetStatus_NotIni;
	m_nMaxImgWidth = 0;
	m_nMaxImgHeight = 0;
	m_nRawImageWidth = 0;
	m_nRawImageHeight = 0;
	m_nCropLeft = 0;
	m_nCropRight = 0;
	m_nCropTop = 0;
	m_nCropBottom = 0;
	m_nImageWidth = 0;
	m_nImageHeight = 0;
	m_nFrameID = 0;
	m_nDropImgNum = 0;
	m_nDropImgCount = 0;
	m_nExamMode = APP_STATUS::APP_STATUS_MAX;
	m_hFPDScanThread = 0;
	m_fFrameRate = 10.0f; //缺省值，10帧每秒
	m_nDelayTime = 0;
	m_nExiThreshold = 200;//新增配置
	m_nImageBits = 16;
	m_bFirstImage = true;
	m_nModeID = 1;
	m_nGainLevel = 3;
	m_hSDKModule = nullptr;
	m_nFpdHandle = nullptr;
	m_bLoaded = false;
	nPGALevel = 0;
	nBinning = 0;
	nPrepareTime = 0;
	nLiveAcqTime = 0;

	m_hStopScanEvent = LinuxEvent::CreateEvent(LinuxEvent::AUTO_RESET, FALSE);
	m_hAcqEvent = LinuxEvent::CreateEvent(LinuxEvent::AUTO_RESET, FALSE);
	m_hGainEvent = LinuxEvent::CreateEvent(LinuxEvent::AUTO_RESET, FALSE);
	m_hDarkEvent = LinuxEvent::CreateEvent(LinuxEvent::AUTO_RESET, FALSE);
	m_hProcessImgEvent = LinuxEvent::CreateEvent(LinuxEvent::AUTO_RESET, FALSE);
	m_hArrayEvent.push_back(m_hStopScanEvent);
	m_hArrayEvent.push_back(m_hAcqEvent);
	m_hArrayEvent.push_back(m_hGainEvent);
	m_hArrayEvent.push_back(m_hDarkEvent);
	m_hArrayEvent.push_back(m_hProcessImgEvent);
	
	m_hStopOffsetEvent = LinuxEvent::CreateEvent(LinuxEvent::AUTO_RESET, FALSE);
	m_hStartAllOffset = LinuxEvent::CreateEvent(LinuxEvent::AUTO_RESET, FALSE);
	m_hStartOffset = LinuxEvent::CreateEvent(LinuxEvent::AUTO_RESET, FALSE);
	m_hAbortOffset = LinuxEvent::CreateEvent(LinuxEvent::AUTO_RESET, FALSE);
	m_hOffsetEvent.push_back(m_hStopOffsetEvent);
	m_hOffsetEvent.push_back(m_hStartAllOffset);
	m_hOffsetEvent.push_back(m_hStartOffset);
	m_hOffsetEvent.push_back(m_hAbortOffset);
}

Detector_HaoBoRF::~Detector_HaoBoRF()
{
	FINFO("~Detector_HaoBoRF");
	
	if (m_pRawImgBuffer)
	{
		delete[]m_pRawImgBuffer;
		m_pRawImgBuffer = nullptr;
	}
	if (m_pFullImgBuffer != nullptr)
	{
		delete[]m_pFullImgBuffer;
		m_pFullImgBuffer = nullptr;
	}

	FINFO("Call HBI_Destroy");
	HBI_Destroy(m_nFpdHandle);
}

//参数说明：
// @USER_CALLBACK_HANDLE_ENVENT
// @pContext:参数 1，上位机对象指针，可以为空（NULL）
// @ufpdId:参数 2，例如平板id
// @byteEventid:参数 3，事件 ID，参考HbiType.h 中 enumeCallbackEventCommType
// @PVEventParam1:参数 4，配置指针或图像结构体指针
// @nEventParam2:参数 5，例如datasize 或状态
// @nEventParam3:参数 6，例如帧号 frameid
// @nEventParam4:参数 7，例如帧率 framerate 或状态等
int CallBackFunc(void* _contex, int nDevId, unsigned char byteEventId, void* param1, int param2, int param3, int param4)
{
	FINFO("CallBackFunc nDevId:{$},byteEventId:{$},param2:{$},param3:{$},param4:{$}", nDevId, (int)byteEventId, param2, param3, param4);
	int ret = 0;
	ImageData* imagedata = NULL;
	RegCfgInfo* pRegCfg = NULL;
	int status = -1;

	switch (byteEventId)
	{
	case ECALLBACK_TYPE_INVALVE:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_INVALVE");
		break;
	}
	case ECALLBACK_TYPE_COMM_RIGHT:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_COMM_RIGHT");
		break;
	}
	case ECALLBACK_TYPE_COMM_WRONG:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_COMM_WRONG");
		break;
	}
	case ECALLBACK_TYPE_DUMMPLING:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_DUMMPLING");
		break;
	}
	case ECALLBACK_TYPE_ACQ_END:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_ACQ_END");
		break;
	}
	case ECALLBACK_TYPE_UPDATE_FIRMWARE:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_UPDATE_FIRMWARE");
		break;
	}
	case ECALLBACK_TYPE_ERASE_FIRMWARE:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_ERASE_FIRMWARE");
		break;
	}
	case ECALLBACK_TYPE_FPD_STATUS:  // detetor status：connect/disconnect/ready/busy and so on
	{
		FINFO("Callback Type: ECALLBACK_TYPE_FPD_STATUS");
		if (param2 <= 0 && param2 >= -11)
		{
			if (param2 == 0)
				FERROR("ECALLBACK_TYPE_FPD_STATUS,Err:Network not connected!");
			else if (param2 == -1)
				FERROR("ECALLBACK_TYPE_FPD_STATUS,Err:Parameter exception!");
			else if (param2 == -2)
				FERROR("ECALLBACK_TYPE_FPD_STATUS,Err:Failed to return the number of ready descriptors!");
			else if (param2 == -3)
				FERROR("ECALLBACK_TYPE_FPD_STATUS,Err:Receive timeout!");
			else if (param2 == -4)
				FERROR("ECALLBACK_TYPE_FPD_STATUS,Err:Receive failed!");
			else if (param2 == -5)
				FERROR("ECALLBACK_TYPE_FPD_STATUS,Err:Socket-Port unreadable!");
			else if (param2 == -6)
				FERROR("ECALLBACK_TYPE_FPD_STATUS,Network card unusual!");
			else if (param2 == -7)
				FERROR("ECALLBACK_TYPE_FPD_STATUS,Network card ok!");
			else if (param2 == -8)
				FERROR("ECALLBACK_TYPE_FPD_STATUS:Update Firmware end!");
			else if (param2 == -9)
				FERROR("ECALLBACK_TYPE_FPD_STATUS:Light Fiber disconnected!");
			else if (param2 == -10)
				FERROR("ECALLBACK_TYPE_FPD_STATUS:Read ddr failed,try restarting the PCIe driver!");
			else /*if (param2 == -11)*/
				FERROR("ECALLBACK_TYPE_FPD_STATUS:is not jumb!");
			status = (int)FPD_DISCONN_STATUS;
			FERROR("Detector not connected!");
			g_pDetector->StatusFeedback(EVT_STATUS_PANEL, PANEL_CLOSE);
		}
		else if (param2 == FPD_CONN_SUCCESS) // connect
		{
			FINFO("Detector connected!");
			status = (int)FPD_CONN_SUCCESS;
			g_pDetector->StatusFeedback(EVT_STATUS_PANEL, PANEL_CONNECT);
			g_pDetector->GetPanelInfo();
		}
		else if (param2 == FPD_PREPARE_STATUS) // prepare
		{
			FINFO("Detector prepare!");
			status = (int)FPD_PREPARE_STATUS;
			g_pDetector->StatusFeedback(EVT_STATUS_PANEL, PANEL_STANDBY);
		}
		else if (param2 == FPD_READY_STATUS) // ready
		{
			FINFO("Detector ready!");
			status = (int)FPD_READY_STATUS;
			g_pDetector->StatusFeedback(EVT_STATUS_PANEL, PANEL_READY_EXP);
		}
		else if (param2 == FPD_DOOFFSET_TEMPLATE)// do offset template
		{
			FINFO("Detector do offset template!");
			status = (int)FPD_DOOFFSET_TEMPLATE;
		}
		else if (param2 == FPD_EXPOSE_STATUS)  // busy expose
		{
			FINFO("Detector Exposing!");
			status = FPD_EXPOSE_STATUS;
		}
		else if (param2 == FPD_CONTINUE_READY) // continue ready
		{
			FINFO("Detector Continue ready!");
			status = FPD_CONTINUE_READY;
			g_pDetector->StatusFeedback(EVT_STATUS_PANEL, PANEL_READY_EXP);
		}
		else if (param2 == FPD_DWONLOAD_GAIN) // download gain template
		{
			FINFO("Detector Download gain template!");
			status = FPD_DWONLOAD_GAIN;
		}
		else if (param2 == FPD_DWONLOAD_DEFECT) // download defect template
		{
			FINFO("Detector Download defect template!");
			status = FPD_DWONLOAD_DEFECT;
		}
		else if (param2 == FPD_DWONLOAD_OFFSET)// download offset template
		{
			FINFO("Detector Download offset template!");
			status = FPD_DWONLOAD_OFFSET;
		}
		else if (param2 == FPD_UPDATE_FIRMARE)// update firmware
		{
			FINFO("Detector Update firmware!");
			status = FPD_UPDATE_FIRMARE;
		}
		else if (param2 == FPD_RETRANS_MISS)// Retrans mission
		{
			FINFO("Detector Retrans mission!");
			status = FPD_RETRANS_MISS;
		}
		else
			FERROR("Detector Other error:{$}", param2);

		if (status != -1)// error, diconnect detector
		{
			if (param2 <= 0 && param2 >= -10)
			{
				g_pDetector->HBI_DisConnectDetector(g_pDetector->m_nFpdHandle);
			}
		}
		break;
	}
	case ECALLBACK_TYPE_ROM_UPLOAD:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_ROM_UPLOAD");
		if (param1 == NULL || param2 == 0)
		{
			FERROR("Parameter exception!");
			return ret;
		}
		pRegCfg = new RegCfgInfo;
		if (pRegCfg != NULL)
		{
			memset(pRegCfg, 0x00, sizeof(RegCfgInfo));
			memcpy(pRegCfg, (unsigned char*)param1, sizeof(RegCfgInfo));
			g_pDetector->PrintDetectorCfg(pRegCfg);
		}
		break;
	}
	case ECALLBACK_TYPE_RAM_UPLOAD:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_RAM_UPLOAD");
		if (param1 == NULL || param2 == 0)
		{
			FERROR("Parameter exception!");
			return ret;
		}
		break;
	}
	case ECALLBACK_TYPE_FACTORY_UPLOAD:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_FACTORY_UPLOAD");
		if (param1 == NULL || param2 == 0)
		{
			printf("err:Parameter exception!\n");
			return ret;
		}
		break;
	}
	case ECALLBACK_TYPE_WLAN_BATTERY:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_WLAN_BATTERY");
		break;
	}
	case ECALLBACK_TYPE_BUFFER_WARNING:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_BUFFER_WARNING");
		break;
	}
	case ECALLBACK_TYPE_ILLEGAL_PACKAGE_NUM:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_ILLEGAL_PACKAGE_NUM");
		break;
	}
	case ECALLBACK_TYPE_USER_DDR_UPLOAD:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_USER_DDR_UPLOAD");
		break;
	}
	case ECALLBACK_TYPE_WIRELESS_NETWORK:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_WIRELESS_NETWORK");
		break;
	}
	case ECALLBACK_TYPE_WIRELESS_SETKEYOK:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_WIRELESS_SETKEYOK");
		break;
	}
	case ECALLBACK_FIRMWARE_TEMPLATE_STATUS:
	{
		FINFO("Callback Type: ECALLBACK_FIRMWARE_TEMPLATE_STATUS");
		break;
	}
	case ECALLBACK_TYPE_SINGLE_IMAGE:
	case ECALLBACK_TYPE_MULTIPLE_IMAGE:
		FINFO("Callback Type: ECALLBACK_TYPE_SINGLE_IMAGE or ECALLBACK_TYPE_MULTIPLE_IMAGE");
		if (param1 == NULL || param2 == 0)
		{
			FERROR("Parameter exception!");
			return ret;
		}
		imagedata = (ImageData*)param1;
		g_pDetector->m_nRawImageWidth = imagedata->uwidth;
		g_pDetector->m_nRawImageHeight = imagedata->uheight;
		g_pDetector->m_nFrameID = imagedata->uframeid;
		FINFO("Callback ImageWidth:{$},ImageHeight:{$},FrameID:{$},datalen:{$}", imagedata->uwidth, imagedata->uheight, imagedata->uframeid, imagedata->datalen);
		memcpy(g_pDetector->m_pRawImgBuffer, (unsigned char*)imagedata->databuff, imagedata->datalen);
		//获取图像后需要调用停止采集，所以改到子线程处理
		g_pDetector->m_hProcessImgEvent->SetEvent();
		break;
	case ECALLBACK_TYPE_PREVIEW_IMAGE:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_PREVIEW_IMAGE");
		if (param1 == NULL || param2 == 0)
		{
			FERROR("Parameter exception!");
			return ret;
		}
		imagedata = (ImageData*)param1;
		break;
	}
	case ECALLBACK_TYPE_LIVE_IMAGE:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_LIVE_IMAGE");
		if (param1 == NULL || param2 == 0)
		{
			FERROR("Parameter exception!");
			return ret;
		}
		imagedata = (ImageData*)param1;
		g_pDetector->m_nRawImageWidth = imagedata->uwidth;
		g_pDetector->m_nRawImageHeight = imagedata->uheight;
		g_pDetector->m_nFrameID = imagedata->uframeid;
		FINFO("Callback ImageWidth:{$},ImageHeight:{$},FrameID:{$},datalen:{$}", imagedata->uwidth, imagedata->uheight, imagedata->uframeid, imagedata->datalen);
		memcpy(g_pDetector->m_pRawImgBuffer, (unsigned char*)imagedata->databuff, imagedata->datalen);
		//获取图像后需要调用停止采集，所以改到子线程处理
		g_pDetector->m_hProcessImgEvent->SetEvent();
		break;
	}
	case ECALLBACK_TYPE_PACKET_MISS:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_PACKET_MISS");
		break;
	}
	case ECALLBACK_TYPE_OFFSET_TMP:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_OFFSET_TMP");
		if (param1 == NULL || param2 == 0)
		{
			FERROR("Parameter exception!");
			return ret;
		}
		imagedata = (ImageData*)param1;
		break;
	}
	case ECALLBACK_OVERLAY_NUMBER:
	{
		FINFO("Callback Type: ECALLBACK_OVERLAY_NUMBER");
		break;
	}
	case ECALLBACK_OVERLAY_16BIT_IMAGE:
	{
		FINFO("Callback Type: ECALLBACK_OVERLAY_16BIT_IMAGE");
		if (param1 == NULL || param2 == 0)
		{
			FERROR("Parameter exception!");
			return ret;
		}
		imagedata = (ImageData*)param1;
		break;
	}
	case ECALLBACK_OVERLAY_32BIT_IMAGE:
	{
		FINFO("Callback Type: ECALLBACK_OVERLAY_32BIT_IMAGE");
		if (param1 == NULL || param2 == 0)
		{
			FERROR("Parameter exception!");
			return ret;
		}
		imagedata = (ImageData*)param1;
		break;
	}
	case ECALLBACK_TYPE_8BIT_IMAGE:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_8BIT_IMAGE");
		break;
	}
	case ECALLBACK_TYPE_SENDTO_WIZARD:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_SENDTO_WIZARD");
		break;
	}
	case ECALLBACK_TYPE_PACKET_MISS_MSG:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_PACKET_MISS_MSG");
		break;
	}
	case ECALLBACK_TYPE_THREAD_EVENT:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_THREAD_EVENT");
		if (param2 == 100)
			FINFO("ECALLBACK_TYPE_THREAD_EVENT,start recv data!");
		else if (param2 == 101)
			FINFO("ECALLBACK_TYPE_THREAD_EVENT,end recv data!");
		else if (param2 == 104)
			FINFO("ECALLBACK_TYPE_THREAD_EVENT,Packet Retransmission:start recv data!");
		else if (param2 == 105)
			FINFO("ECALLBACK_TYPE_THREAD_EVENT,Frame Retransmission:start recv data!");
		else if (param2 == 106)
			FINFO("ECALLBACK_TYPE_THREAD_EVENT,Frame loss retransmission over,end recv data!");
		else if (param2 == 107)
			FINFO("ECALLBACK_TYPE_THREAD_EVENT,image buff is null:end recv data!");
		else if (param2 == 108)
			FINFO("ECALLBACK_TYPE_THREAD_EVENT,Generate Offset Template:start thread!");
		else if (param2 == 109)
			FINFO("ECALLBACK_TYPE_THREAD_EVENT,Generate Offset Template:end thread!");
		else if (param2 == 110)
			FINFO("ECALLBACK_TYPE_THREAD_EVENT,Generate Gain Template:start thread!");
		else if (param2 == 111)
			FINFO("ECALLBACK_TYPE_THREAD_EVENT,Generate Gain Template:end thread!");
		else if (param2 == 112)
			FINFO("ECALLBACK_TYPE_THREAD_EVENT,offset calibrate:success!");
		else if (param2 == 113)
			FINFO("ECALLBACK_TYPE_THREAD_EVENT,offset calibrate:failed!");
		else if (param2 == 114)
			FINFO("ECALLBACK_TYPE_THREAD_EVENT,gain calibrate:success!");
		else if (param2 == 115)
			FINFO("ECALLBACK_TYPE_THREAD_EVENT,gain calibrate:failed!");
		else if (param2 == 116)
			FINFO("ECALLBACK_TYPE_THREAD_EVENT,defect calibrate:success!");
		else if (param2 == 117)
			FINFO("ECALLBACK_TYPE_THREAD_EVENT,defect calibrate:failed!");
		else if (param2 == 118)
			FINFO("ECALLBACK_TYPE_THREAD_EVENT,InitGainTemplate:failed!");
		else if (param2 == 119)
			FINFO("ECALLBACK_TYPE_THREAD_EVENT,firmare offset calibrate:success!");
		else if (param2 == 120)
			FINFO("ECALLBACK_TYPE_THREAD_EVENT,Generate Defect Template:start thread!");
		else if (param2 == 121)
			FINFO("ECALLBACK_TYPE_THREAD_EVENT,Generate Defect Template:end thread!");
		else
			FERROR("ECALLBACK_TYPE_THREAD_EVENT,Err:other error [{$}]", param2);
		break;
	}
	case ECALLBACK_TYPE_ACQ_DISCARDDED:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_ACQ_DISCARDDED");
		break;
	}
	case ECALLBACK_TYPE_OFFSET_ERR_MSG:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_OFFSET_ERR_MSG");
		break;
	}
	case ECALLBACK_TYPE_GAIN_ERR_MSG:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_GAIN_ERR_MSG");
		break;
	}
	case ECALLBACK_TYPE_DEFECT_ERR_MSG:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_DEFECT_ERR_MSG");
		break;
	}
	case ECALLBACK_TYPE_NET_ERR_MSG:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_NET_ERR_MSG");
		break;
	}
	case ECALLBACK_TYPE_SET_CFG_OK:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_SET_CFG_OK set rom param succuss!");
		break;
	}
	case ECALLBACK_TYPE_SAVE_SUCCESS:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_SAVE_SUCCESS");
		break;
	}
	case ECALLBACK_TYPE_GENERATE_TEMPLATE:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_GENERATE_TEMPLATE");
		if (param2 == ECALLBACK_TEMPLATE_BEGIN)
		{
			FINFO("ECALLBACK_TEMPLATE_BEGIN");
		}
		else if (param2 == ECALLBACK_TEMPLATE_INVALVE_PARAM)
		{
			FINFO("ECALLBACK_TEMPLATE_INVALVE_PARAM:{$}", param3);
		}
		else if (param2 == ECALLBACK_TEMPLATE_MALLOC_FAILED)
		{
			FINFO("ECALLBACK_TEMPLATE_MALLOC_FAILED:{$}", param3);
		}
		else if (param2 == ECALLBACK_TEMPLATE_SEND_FAILED)
		{
			FINFO("ECALLBACK_TEMPLATE_SEND_FAILED:{$}", param3);
		}
		else if (param2 == ECALLBACK_TEMPLATE_STATUS_ABORMAL)
		{
			FINFO("ECALLBACK_TEMPLATE_STATUS_ABORMAL:{$}", param3);
		}
		else if (param2 == ECALLBACK_TEMPLATE_FRAME_NUM)
		{
			FINFO("ECALLBACK_TEMPLATE_FRAME_NUM:{$}", param3);
		}
		else if (param2 == ECALLBACK_TEMPLATE_TIMEOUT)
		{
			FINFO("ECALLBACK_TEMPLATE_TIMEOUT:{$}", param3);
		}
		else if (param2 == ECALLBACK_TEMPLATE_MEAN)
		{
			ECALLBACK_RAW_INFO* ptr = (ECALLBACK_RAW_INFO*)param1;
			if (ptr != NULL)
			{
				FINFO("ECALLBACK_TEMPLATE_MEAN:{$},dMean={$.2f}", ptr->szRawName, ptr->dMean);
			}
		}
		else if (param2 == ECALLBACK_TEMPLATE_GENERATE)
		{
			if (param3 == OFFSET_TMP)
				FINFO("ECALLBACK_TEMPLATE_GENERATE:OFFSET_TMP");
			else if (param3 == GAIN_TMP)
				FINFO("ECALLBACK_TEMPLATE_GENERATE:GAIN_TMP");
			else if (param3 == DEFECT_TMP)
				FINFO("ECALLBACK_TEMPLATE_GENERATE:DEFECT_TMP,bad point={$}", param2);
			else
				FINFO("ECALLBACK_TEMPLATE_GENERATE:nid={$}", param3);
		}
		else if (param2 == ECALLBACK_TEMPLATE_RESULT)
		{
			FINFO("ECALLBACK_TEMPLATE_RESULT:{$}", param3);
		}
		else
		{
			FINFO("other:len={$},nid={$}", param2, param3);
		}
		break;
	}
	case ECALLBACK_TYPE_FILE_NOTEXIST:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_FILE_NOTEXIST");
		if (param1 != NULL)
			FERROR("err:{$} not exist!", (char*)param1);
		break;
	}
	case ECALLBACK_TYPE_WORK_STATUS:
	{
		FINFO("Callback Type: ECALLBACK_TYPE_WORK_STATUS");
		break;
	}
	default:
		FINFO("default Callback Type[{$}]", (int)byteEventId);
		break;
	}

	if (pRegCfg)
	{
		delete pRegCfg;
		pRegCfg = nullptr;
	}
	return 0;
}

bool Detector_HaoBoRF::DriverEntry(void* pDrvDPC, ResDataObject& Configuration, const char* szWorkPath)
{
	printf("========DriverEntry %p\n", pDrvDPC);
	FINFO("========DriverEntry {$}", pDrvDPC);

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

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

	if (m_hFPDScanThread == 0)
	{
		int ret = pthread_create(&m_hFPDScanThread, NULL, onFPDScanThread, this);
		if (ret != 0)
		{
			FERROR("Create FPD scan thread failed!");
			return false;
		}
	}

	if (m_hOffsetThread == 0)
	{
		int ret = pthread_create(&m_hOffsetThread, NULL, RefreshOffsetThread, this);
		if (ret != 0)
		{
			FERROR("Create offset thread failed!");
			return false;
		}
	}

	m_strCtrlWorkPath = szWorkPath;
	if (!LoadDll(szWorkPath))
	{
		FERROR("Load dll failed!");
		return false;
	}

	if (m_bLoaded)
	{
		FINFO("Calling HBI_Init");
		m_nFpdHandle = HBI_Init(0);
		if (!m_nFpdHandle)
		{
			FERROR("HBI_Init error!");
			return false;
		}

		FINFO("Calling HBI_RegEventCallBackFun");
		int nRet = HBI_RegEventCallBackFun(m_nFpdHandle, CallBackFunc, NULL);
		if (TestError(nRet, "HBI_RegEventCallBackFun"))
		{
			FERROR("Register call back fun fail!");
			return false;
		}
	}

	return true;
}

bool Detector_HaoBoRF::Connect(void* pDrvDPC)
{
	printf("========Connect detector begin \r\n");
	FINFO("========Connect detector begin \n");

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

	if (m_bLoaded)
	{
		if (!ConnectDetector())
		{
			return false;
		}
	}
	else 
	{
		FERROR("DLL is not loaded!");
		return false;
	}

	FINFO("Connect over");
	printf("Connect over \n");
	return true;
}

void Detector_HaoBoRF::DisConnect()
{
	printf("========DisConnect with detector \n");
	FINFO("========DisConnect");
	int nRet = HBI_SUCCSS;
	
}

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

	if (APP_STATUS_WORK_END == m_nExamMode)
	{
		if (DetStatus_Acquire == GetDpcStatus())
		{
			FINFO("quit exam but detector status is acquire,so stop acquire");
			StopAcquisition(nullptr);
		}
	}
}

bool Detector_HaoBoRF::SetAcqMode(int nMode)
{
	printf("========SetAcqMode nMode:%d \n", nMode);
	FINFO("========SetAcqMode nMode:{$}",nMode);

	if (m_nCurrentLogicMode == nMode)
	{
		FINFO("Same mode, return");
		return true;
	}

	//只有RAD模式读取全部的配置文件，CF和PF不读取全部配置，只读取部分
	try
	{
		int nModeCount = (int)m_ModeConfig["ModeTable"].size();
		for (int i = 0; i < nModeCount; i++)
		{
			int logicMode = (int)m_ModeConfig["ModeTable"][i]["LogicMode"];//SetAcqMode
			if (logicMode == nMode)
			{
				//FINFO("ModeTable22 {$}, {$}", i, m_ModeConfig["ModeTable"][i].encode());
				FINFO("find LogicMode == nMode");
				if (logicMode == RAD)
				{
					m_nModeID = (int)m_ModeConfig["ModeTable"][i]["OperationMode"];//RAD 固定用1*1的Binning
				}
				m_nDelayTime = (int)m_ModeConfig["ModeTable"][i]["DelayTime"];
				m_nDropImgCount = (int)m_ModeConfig["ModeTable"][i]["DropImgCount"];
				m_nSaveRaw = (int)m_ModeConfig["ModeTable"][i]["IsSaveRaw"];
				m_nTriggerMode = (int)m_ModeConfig["ModeTable"][i]["ExamType"];
				FINFO("m_nDelayTime:{$}, m_nDropImgCount:{$}, m_nSaveRaw:{$}, m_nModeID:{$}, m_nTriggerMode:{$}", 
					m_nDelayTime, m_nDropImgCount, m_nSaveRaw, m_nModeID, m_nTriggerMode);

				m_nCropLeft = (int)m_ModeConfig["ModeTable"][i]["CropLeft"];
				m_nCropRight = (int)m_ModeConfig["ModeTable"][i]["CropRight"];
				m_nCropTop = (int)m_ModeConfig["ModeTable"][i]["CropTop"];
				m_nCropBottom = (int)m_ModeConfig["ModeTable"][i]["CropBottom"];
				FINFO("Crop left:{$}, top:{$}, right:{$}, bottom:{$}", m_nCropLeft, m_nCropTop, m_nCropRight, m_nCropBottom);

				m_nImageBits = (int)m_ModeConfig["ModeTable"][i]["PhySizeInfoBit"];
				m_nGainLevel = (int)m_ModeConfig["ModeTable"][i]["GainValue"];
				FINFO("m_nImageBits:{$}, m_nGainLevel:{$}", m_nImageBits, m_nGainLevel);
				break;
			}
		}
	}
	catch (ResDataObjectExption& e)
	{
		FERROR("Read configuration failed, Error code: {$}", e.what());
		return false;
	}
	
	m_nCurrentLogicMode = nMode;
	return true;
}

bool Detector_HaoBoRF::SetExposureTimes(int nTimes)
{
	FINFO("========SetExposureTimes({$})", nTimes);
	return true;
}

bool Detector_HaoBoRF::PrepareAcquisition(void* pDrvDPC)
{
	printf("========PrepareAcquisition \n");
	FINFO("========PrepareAcquisition ");
	int nRet = HBI_SUCCSS;

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

	if (-1 == m_nCurrentLogicMode)
	{
		FERROR("Illegal exam mode");
		return false;
	}

	eDetStatus detectorStatus = GetDpcStatus();
	if (detectorStatus == DetStatus_Acquire)
	{
		bool ret = StopAcquisition(pDrvDPC);
		if (!ret) 
		{
			return false;
		}
	}

	//modeID 1->1*1 2->2*2
	FINFO("m_nTriggerMode:{$}, m_nModeID:{$}, acqTime:{$}", m_nTriggerMode, m_nModeID, 1 / (int)m_fFrameRate);
	FINFO("Call HBI_TriggerBinningAcqTime");
	nRet = HBI_TriggerBinningAcqTime(m_nFpdHandle, m_nTriggerMode, m_nModeID, 1 / (int)m_fFrameRate, 0);
	if (TestError(nRet,"HBI_TriggerBinningAcqTime"))
	{
		FERROR("HBI_TriggerBinningAcqTime fail!");
		return false;
	}
	return true;
}

bool Detector_HaoBoRF::StartAcquisition(void* pDrvDPC)
{
	printf("========StartAcquisition \n");
	FINFO("========StartAcquisition ");
	int nRet = HBI_SUCCSS;

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

	if (-1 == m_nCurrentLogicMode)
	{
		FERROR("Illegal exam mode");
		return false;
	}
	else
	{
		m_bValidImage = false; //开始采集，恢复初值
		m_nDropImgNum = 0; //开始采集，恢复初值
		m_bFirstImage = true;
		struct timespec ts;
		clock_gettime(CLOCK_MONOTONIC, &ts);  // 使用CLOCK_MONOTONIC时钟，不受系统时间调整影响
		m_dwBeginTime = (unsigned long long)ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
	}

	FPD_AQC_MODE aqc_mode;
	FINFO("m_nCurrentLogicMode:{$}", m_nCurrentLogicMode);
	if (m_nCurrentLogicMode == RAD)
	{
		aqc_mode.nAcqnumber = 1;
	}
	else if (m_nCurrentLogicMode == CF || m_nCurrentLogicMode == PF)
	{
		aqc_mode.eAqccmd = EnumIMAGE_ACQ_CMD::LIVE_ACQ_DEFAULT_TYPE;
		aqc_mode.eLivetype = EnumLIVE_ACQUISITION::ONLY_IMAGE;
	}

	FINFO("Call HBI_LiveAcquisition");
	nRet = HBI_LiveAcquisition(m_nFpdHandle, aqc_mode);
	if (TestError(nRet,"HBI_LiveAcquisition"))
	{
		FERROR("HBI_LiveAcquisition fail!");
		return false;
	}

	SetDpcStatus(DetStatus_Acquire); //动态模式激活采集，设置状态
	
	return true;
}

bool Detector_HaoBoRF::StopAcquisition(void* pDrvDPC)
{
	printf("========StopAcquisition \n");
	FINFO("========StopAcquisition ");
	int nRet = HBI_SUCCSS;

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

	FINFO("Call HBI_StopAcquisition");
	nRet = HBI_StopAcquisition(m_nFpdHandle);
	if (TestError(nRet,"HBI_StopAcquisition"))
	{
		FERROR("Stop Acqusition fail!");
		return false;
	}
	return true;
}

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

	if (-1 == m_nCurrentLogicMode)
	{
		FERROR("Illegal exam mode");
		return false;
	}

	if (CCOS_CALIBRATION_TYPE_XRAY == eType)
	{
		SetDpcStatus(DetStatus_GainCalibration);
	}
	m_eCaliType = eType;
	return true;
}

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

	if (GetDpcStatus() != DetStatus_GainCalibration)
	{
		FINFO("Current status is not XrayCalibration, return succeed");
		return true;
	}

	return bRet;
}

bool Detector_HaoBoRF::StartCalibration(void* pDrvDPC)
{
	printf("========StartCalibration \n");
	FINFO("========StartCalibration ");
	bool bRet = false;
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		FERROR("Not current DPC, return");
		return bRet;
	}
	if (CCOS_CALIBRATION_TYPE_DARK == m_eCaliType)
	{
		m_hDarkEvent->SetEvent();
		bRet = true;
	}
	else if (CCOS_CALIBRATION_TYPE_XRAY == m_eCaliType)
	{
		bRet = StartGainCalibration();
	}
	return bRet;
}

bool Detector_HaoBoRF::StopCalibration(void* pDrvDPC)
{
	printf("========StopCalibration \n");
	FINFO("========StopCalibration ");
	bool bRet = false;
	int nRet = HBI_SUCCSS;

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

	FINFO("StopCalibration Calling StopCalibration");
	
	return bRet;
}

bool Detector_HaoBoRF::LoadDll(string strWorkPath)
{
	printf("========LoadDll \n");
	FINFO("========LoadDll start");
	string strSDKPath = "";
	try
	{
		strSDKPath = (string)m_ModeConfig["SDKPath"];
	}
	catch (ResDataObjectExption& e)
	{
		FERROR("Read configuration failed, Error code: {$}", e.what());
		return false;
	}

	string workpath = strWorkPath + strSDKPath;
	FINFO("workpath:{$}", workpath);
	string drvpath = workpath + "/libHBISDKApi.so";
	m_hSDKModule = dlopen(drvpath.c_str(), RTLD_GLOBAL | RTLD_LAZY);
	if (m_hSDKModule == nullptr)
	{
		FERROR("Load {$} failed! FERROR: {$}", drvpath.c_str(), dlerror());
		return false;
	}

	LOAD_PROC_ADDRESS(m_hSDKModule, HBI_Init);
	LOAD_PROC_ADDRESS(m_hSDKModule, HBI_Destroy);
	LOAD_PROC_ADDRESS(m_hSDKModule, HBI_ConnectDetector);
	LOAD_PROC_ADDRESS(m_hSDKModule, HBI_DisConnectDetector);
	LOAD_PROC_ADDRESS(m_hSDKModule, HBI_RegEventCallBackFun);
	LOAD_PROC_ADDRESS(m_hSDKModule, HBI_GetSDKVerion);
	LOAD_PROC_ADDRESS(m_hSDKModule, HBI_GetFirmareVerion);
	LOAD_PROC_ADDRESS(m_hSDKModule, HBI_GetError);
	LOAD_PROC_ADDRESS(m_hSDKModule, HBI_GetFpdCfgInfo);
	LOAD_PROC_ADDRESS(m_hSDKModule, HBI_GetImageProperty);
	LOAD_PROC_ADDRESS(m_hSDKModule, HBI_LiveAcquisition);
	LOAD_PROC_ADDRESS(m_hSDKModule, HBI_StopAcquisition);
	LOAD_PROC_ADDRESS(m_hSDKModule, HBI_SetSelfDumpingTime);
	LOAD_PROC_ADDRESS(m_hSDKModule, HBI_TriggerAndCorrectApplay);
	LOAD_PROC_ADDRESS(m_hSDKModule, HBI_UpdateTriggerMode);
	LOAD_PROC_ADDRESS(m_hSDKModule, HBI_UpdateCorrectEnable);
	LOAD_PROC_ADDRESS(m_hSDKModule, HBI_SetBinning);
	LOAD_PROC_ADDRESS(m_hSDKModule, HBI_GenerateTemplate);
	LOAD_PROC_ADDRESS(m_hSDKModule, HBI_TriggerBinningAcqTime);
	LOAD_PROC_ADDRESS(m_hSDKModule, HBI_IsMutilMode);
	LOAD_PROC_ADDRESS(m_hSDKModule, HBI_SinglePrepare);
	LOAD_PROC_ADDRESS(m_hSDKModule, HBI_SingleAcquisition);
	LOAD_PROC_ADDRESS(m_hSDKModule, HBI_RegProgressCallBack);
	LOAD_PROC_ADDRESS(m_hSDKModule, HBI_WaitForReadyStatus);
	LOAD_PROC_ADDRESS(m_hSDKModule, HBI_SetPGALevel);

	m_bLoaded = true;
	FINFO("LoadDll end");
	return true;
}

int Detector_HaoBoRF::GetPGA(unsigned short usValue)
{
	unsigned short gainMode = ((usValue & 0xff) << 8) | ((usValue >> 8) & 0xff);
	int nPGA = (gainMode >> 10) & 0x3f;
	if (nPGA == 0x02) return 1;
	else if (nPGA == 0x04) return 2;
	else if (nPGA == 0x08) return 3;
	else if (nPGA == 0x0c) return 4;
	else if (nPGA == 0x10) return 5;
	else if (nPGA == 0x18) return 6;
	else if (nPGA == 0x3e) return 7;
	else return 0;
}

void Detector_HaoBoRF::PrintDetectorCfg(RegCfgInfo* pCfg)
{
	FINFO("========PrintDetectorCfg");
	if (pCfg == NULL)
	{
		FERROR("pCfg is NULL!");
		return;
	}

	FINFO("Xray sensor type:{$}", (int)pCfg->m_SysBaseInfo.m_byXRaySensorType);
	// detector type,width and hight
	if (pCfg->m_SysBaseInfo.m_byPanelSize == 0x01)
		FINFO("PanelSize:{$},fpd type:4343-140um", (int)pCfg->m_SysBaseInfo.m_byPanelSize);
	else if (pCfg->m_SysBaseInfo.m_byPanelSize == 0x02)
		FINFO("PanelSize:{$},fpd type:3543-140um", (int)pCfg->m_SysBaseInfo.m_byPanelSize);
	else if (pCfg->m_SysBaseInfo.m_byPanelSize == 0x03)
		FINFO("PanelSize:{$},fpd type:1613-125um", (int)pCfg->m_SysBaseInfo.m_byPanelSize);
	else if (pCfg->m_SysBaseInfo.m_byPanelSize == 0x04)
		FINFO("PanelSize:{$},fpd type:3030-140um", (int)pCfg->m_SysBaseInfo.m_byPanelSize);
	else if (pCfg->m_SysBaseInfo.m_byPanelSize == 0x05)
		FINFO("PanelSize:{$},fpd type:2530-85um", (int)pCfg->m_SysBaseInfo.m_byPanelSize);
	else if (pCfg->m_SysBaseInfo.m_byPanelSize == 0x06)
		FINFO("PanelSize:{$},fpd type:3025-140um", (int)pCfg->m_SysBaseInfo.m_byPanelSize);
	else if (pCfg->m_SysBaseInfo.m_byPanelSize == 0x07)
		FINFO("PanelSize:{$},fpd type:4343-100um", (int)pCfg->m_SysBaseInfo.m_byPanelSize);
	else if (pCfg->m_SysBaseInfo.m_byPanelSize == 0x08)
		FINFO("PanelSize:{$},fpd type:2530-75um", (int)pCfg->m_SysBaseInfo.m_byPanelSize);
	else if (pCfg->m_SysBaseInfo.m_byPanelSize == 0x09)
		FINFO("PanelSize:{$},fpd type:2121-200um", (int)pCfg->m_SysBaseInfo.m_byPanelSize);
	else if (pCfg->m_SysBaseInfo.m_byPanelSize == 0x0a)
		FINFO("PanelSize:{$},fpd type:1412-50um", (int)pCfg->m_SysBaseInfo.m_byPanelSize);
	else if (pCfg->m_SysBaseInfo.m_byPanelSize == 0x0b)
		FINFO("PanelSize:{$},fpd type:0606-50um", (int)pCfg->m_SysBaseInfo.m_byPanelSize);
	else
		FERROR("PanelSize:{$},invalid fpd type!", (int)pCfg->m_SysBaseInfo.m_byPanelSize);

	FINFO("PixelPitch:{$}", (int)pCfg->m_SysBaseInfo.m_byPixelPitch);

	m_nMaxImgWidth = pCfg->m_SysBaseInfo.m_sImageWidth;
	m_nMaxImgHeight = pCfg->m_SysBaseInfo.m_sImageHeight;
	FINFO("Detector Width={$},Hight={$}", m_nMaxImgWidth, m_nMaxImgHeight);
	ConfFeedback(EVT_CONF_MAX_IMAGESIZE, m_nCurrentPanelID, "", m_nMaxImgWidth * m_nMaxImgHeight);
	if (m_pRawImgBuffer)
	{
		delete[] m_pRawImgBuffer;
		m_pRawImgBuffer = nullptr;
	}
	m_pRawImgBuffer = new WORD[(size_t)m_nMaxImgWidth * (size_t)m_nMaxImgHeight];
	if (m_pFullImgBuffer)
	{
		delete[] m_pFullImgBuffer;
		m_pFullImgBuffer = nullptr;
	}
	m_pFullImgBuffer = new WORD[(size_t)m_nMaxImgWidth * (size_t)m_nMaxImgHeight];

	FINFO("Serial Number:{$}", pCfg->m_SysBaseInfo.m_cSnNumber);
	FINFO("MaxFPS:{$}", (int)pCfg->m_SysBaseInfo.m_cMaxFps);
	
	//ip and port
	unsigned short usValue = ((pCfg->m_EtherInfo.m_sDestUDPPort & 0xff) << 8) | ((pCfg->m_EtherInfo.m_sDestUDPPort >> 8) & 0xff);
	FINFO("SourceIP:{$}.{$}.{$}.{$}:{$}",
		pCfg->m_EtherInfo.m_byDestIP[0],
		pCfg->m_EtherInfo.m_byDestIP[1],
		pCfg->m_EtherInfo.m_byDestIP[2],
		pCfg->m_EtherInfo.m_byDestIP[3],
		usValue);

	usValue = ((pCfg->m_EtherInfo.m_sSourceUDPPort & 0xff) << 8) | ((pCfg->m_EtherInfo.m_sSourceUDPPort >> 8) & 0xff);
	FINFO("DestIP:{$}.{$}.{$}.{$}:{$}",
		pCfg->m_EtherInfo.m_bySourceIP[0],
		pCfg->m_EtherInfo.m_bySourceIP[1],
		pCfg->m_EtherInfo.m_bySourceIP[2],
		pCfg->m_EtherInfo.m_bySourceIP[3],
		usValue);

	//trigger mode
	if (pCfg->m_SysCfgInfo.m_byTriggerMode == 0x01)
		FINFO("static software trigger.[0x{$02X}]", pCfg->m_SysCfgInfo.m_byTriggerMode);
	else if (pCfg->m_SysCfgInfo.m_byTriggerMode == 0x03)
		FINFO("static hvg trigger.[0x{$02X}]", pCfg->m_SysCfgInfo.m_byTriggerMode);
	else if (pCfg->m_SysCfgInfo.m_byTriggerMode == 0x04)
		FINFO("Free AED trigger mode.[0x{$02X}]", pCfg->m_SysCfgInfo.m_byTriggerMode);
	else if (pCfg->m_SysCfgInfo.m_byTriggerMode == 0x05)
		FINFO("Dynamic:Hvg Sync mode.[0x{$02X}]", pCfg->m_SysCfgInfo.m_byTriggerMode);
	else if (pCfg->m_SysCfgInfo.m_byTriggerMode == 0x06)
		FINFO("Dynamic:Fpd Sync mode.[0x{$02X}]", pCfg->m_SysCfgInfo.m_byTriggerMode);
	else if (pCfg->m_SysCfgInfo.m_byTriggerMode == 0x07)
		FINFO("Dynamic:Fpd Continue mode.[0x{$02X}]", pCfg->m_SysCfgInfo.m_byTriggerMode);
	else if (pCfg->m_SysCfgInfo.m_byTriggerMode == 0x08)
		FINFO("Static:SAEC mode.[0x{$02X}]", pCfg->m_SysCfgInfo.m_byTriggerMode);
	else
		FINFO("other trigger mode.[0x{$02X}]", pCfg->m_SysCfgInfo.m_byTriggerMode);

	// Binning type
	nBinning = (int)pCfg->m_SysCfgInfo.m_byBinning;
	if (nBinning < 1 || nBinning > 4)
	{
		nBinning = 1;
	}
	FINFO("Binning type:{$}*{$}", nBinning, nBinning);

	// acq delay time
	FINFO("Pre Acquisition Delay Time:{$}ms", pCfg->m_SysCfgInfo.m_unPreAcquisitionDelayTime);

	// prepare delayed
	BYTE byte1 = 0, byte2 = 0, byte3 = 0, byte4 = 0;
	byte1 = BREAK_UINT32(pCfg->m_SysCfgInfo.m_unPreAcquisitionDelayTime, 0);
	byte2 = BREAK_UINT32(pCfg->m_SysCfgInfo.m_unPreAcquisitionDelayTime, 1);
	byte3 = BREAK_UINT32(pCfg->m_SysCfgInfo.m_unPreAcquisitionDelayTime, 2);
	byte4 = BREAK_UINT32(pCfg->m_SysCfgInfo.m_unPreAcquisitionDelayTime, 3);
	nPrepareTime = BUILD_UINT32(byte4, byte3, byte2, byte1);
	FINFO("nPrepareTime:{$}ms", nPrepareTime);

	FINFO("commCfg._type:{$}", (int)commCfg._type);
	// Continuous acquisition time interval and frame rate calculation
	if (commCfg._type == UDP_COMM_TYPE || commCfg._type == WALN_COMM_TYPE)
	{
		byte1 = BREAK_UINT32(pCfg->m_SysCfgInfo.m_unContinuousAcquisitionSpanTime, 0);
		byte2 = BREAK_UINT32(pCfg->m_SysCfgInfo.m_unContinuousAcquisitionSpanTime, 1);
		byte3 = BREAK_UINT32(pCfg->m_SysCfgInfo.m_unContinuousAcquisitionSpanTime, 2);
		byte4 = BREAK_UINT32(pCfg->m_SysCfgInfo.m_unContinuousAcquisitionSpanTime, 3);
	}
	else
	{
		byte1 = BREAK_UINT32(pCfg->m_SysCfgInfo.m_unSelfDumpingSpanTime, 0);
		byte2 = BREAK_UINT32(pCfg->m_SysCfgInfo.m_unSelfDumpingSpanTime, 1);
		byte3 = BREAK_UINT32(pCfg->m_SysCfgInfo.m_unSelfDumpingSpanTime, 2);
		byte4 = BREAK_UINT32(pCfg->m_SysCfgInfo.m_unSelfDumpingSpanTime, 3);
	}

	nLiveAcqTime = BUILD_UINT32(byte4, byte3, byte2, byte1);
	if (nLiveAcqTime <= 0)
	{
		FWARN("live aqc time:{$}ms", nLiveAcqTime);
		nLiveAcqTime = 1000;
	}
	FINFO("nLiveAcqTime:{$}ms", nLiveAcqTime);

	unsigned int nMaxFps = (unsigned int)(1000 / nLiveAcqTime);
	if (nMaxFps <= 0) nMaxFps = 1;
	FINFO("nMaxFps:{$}", nMaxFps);

	//correction enable
	if (pCfg->m_ImgCaliCfg.m_byOffsetCorrection == 0x01)
		FINFO("Firmware offset correction disenable.[0x{$02X}]", pCfg->m_ImgCaliCfg.m_byOffsetCorrection);
	else if (pCfg->m_ImgCaliCfg.m_byOffsetCorrection == 0x02)
		FINFO("Firmware offset correction enable.[0x{$02X}]", pCfg->m_ImgCaliCfg.m_byOffsetCorrection);
	else
		FINFO("Firmware other offset correction enable.[0x{$02X}]", pCfg->m_ImgCaliCfg.m_byOffsetCorrection);

	if (pCfg->m_ImgCaliCfg.m_byGainCorrection == 0x01)
		FINFO("Firmware gain correction disenable.[0x{$02X}]", pCfg->m_ImgCaliCfg.m_byGainCorrection);
	else if (pCfg->m_ImgCaliCfg.m_byGainCorrection == 0x02)
		FINFO("Firmware gain correction enable.[0x{$02X}]", pCfg->m_ImgCaliCfg.m_byGainCorrection);
	else
		FINFO("Firmware gain offset correction enable.[0x{$02X}]", pCfg->m_ImgCaliCfg.m_byGainCorrection);

	if (pCfg->m_ImgCaliCfg.m_byDefectCorrection == 0x01)
		FINFO("Firmware defect correction disenable.[0x{$02X}]", pCfg->m_ImgCaliCfg.m_byDefectCorrection);
	else if (pCfg->m_ImgCaliCfg.m_byDefectCorrection == 0x02)
		FINFO("Firmware defect correction enable.[0x{$02X}]", pCfg->m_ImgCaliCfg.m_byDefectCorrection);
	else
		FINFO("Firmware defect offset correction enable.[0x{$02X}]", pCfg->m_ImgCaliCfg.m_byDefectCorrection);

	if (pCfg->m_ImgCaliCfg.m_byDummyCorrection == 0x01)
		FINFO("Firmware Dummy correction disenable.[0x{$02X}]", pCfg->m_ImgCaliCfg.m_byDummyCorrection);
	else if (pCfg->m_ImgCaliCfg.m_byDummyCorrection == 0x02)
		FINFO("Firmware Dummy correction enable.[0x{$02X}]", pCfg->m_ImgCaliCfg.m_byDummyCorrection);
	else
		FINFO("Firmware Dummy offset correction enable.[0x{$02X}]", pCfg->m_ImgCaliCfg.m_byDummyCorrection);

	// PGA level
	nPGALevel = GetPGA(pCfg->m_TICOFCfg.m_sTICOFRegister[26]);
	FINFO("nPGALevel:{$}", nPGALevel);
}

bool Detector_HaoBoRF::ConnectDetector()
{
	printf("========ConnectDetector \n");
	FINFO("========ConnectDetector ");
	int nRet = HBI_SUCCSS;
	int j = 0;
	commCfg._type = UDP_JUMBO_COMM_TYPE;//标准网口，支持jumbo类型
	commCfg._loacalPort = 32896;
	commCfg._remotePort = 32897;
	memset(commCfg._localip, 0, sizeof(commCfg._localip));
	memset(commCfg._remoteip,0, sizeof(commCfg._remoteip));
	j = sprintf(commCfg._localip, "%s", "192.168.10.20");//本机IP
	commCfg._localip[j] = '\0';
	j = sprintf(commCfg._remoteip, "%s", "192.168.10.40");//探测器IP
	commCfg._remoteip[j] = '\0';
	commCfg._pcieId = 7024;
	int dooffsetTemplate = 0;

	FINFO("Calling HBI_ConnectDetector");
	nRet = HBI_ConnectDetector(m_nFpdHandle, commCfg, dooffsetTemplate);
	if (TestError(nRet,"HBI_ConnectDetector"))
	{
		FERROR("Connect detector fail!");
		return false;
	}

	return true;
}

//True 有错 false 没错
bool Detector_HaoBoRF::TestError(int nErrorCode, const char* szFuncName)
{
	if (nErrorCode)
	{
		string strErrorInfo = HBI_GetError(CrErrStrList, 51, nErrorCode);
		if (strErrorInfo.size() == 0) 
		{
			FERROR("HBI_GetError fail! error code:{$}", nErrorCode);
		}
		else 
		{
			FERROR("{$} return error {$}, reason: {$}", szFuncName, nErrorCode, strErrorInfo);
		}
		return true;
	}
	else 
	{
		FINFO("{$} executed successfully", szFuncName);
		return false;
	}
}

bool Detector_HaoBoRF::GetPanelInfo()
{
	FINFO("======GetPanelInfo");
	int nRet = HBI_SUCCSS;

	char serialNumber[20] = { 0 };
	FINFO("Call HBI_GetFPDSerialNumber");
	nRet = HBI_GetFPDSerialNumber(m_nFpdHandle, serialNumber);
	if (TestError(nRet,"HBI_GetFPDSerialNumber"))
	{
		return false;
	}
	FINFO("Detector SN:{$}",serialNumber);

	char sdkVersion[100] = { 0 };
	FINFO("Call HBI_GetSDKVerion");
	nRet = HBI_GetSDKVerion(m_nFpdHandle, sdkVersion);
	if (TestError(nRet, "HBI_GetSDKVerion"))
	{
		return false;
	}
	FINFO("Detector sdk version:{$}", sdkVersion);

	char firmwareVersion[100] = { 0 };
	FINFO("Call HBI_GetFirmareVerion");
	nRet = HBI_GetFirmareVerion(m_nFpdHandle, firmwareVersion);
	if (TestError(nRet, "HBI_GetFirmareVerion"))
	{
		return false;
	}
	FINFO("Detector firmware version:{$}", firmwareVersion);

	RegCfgInfo* pCfgInfo = new RegCfgInfo;
	memset(pCfgInfo, 0x00, sizeof(RegCfgInfo));
	FINFO("Call HBI_GetFirmareVerion");
	nRet = HBI_GetFpdCfgInfo(m_nFpdHandle, pCfgInfo);
	if (TestError(nRet, "HBI_GetFirmareVerion"))
	{
		return false;
	}
	PrintDetectorCfg(pCfgInfo);
	if (pCfgInfo)
	{
		delete pCfgInfo;
		pCfgInfo = nullptr;
	}

	IMAGE_PROPERTY* imageProperty = new ImageProperty();
	FINFO("Call HBI_GetImageProperty");
	nRet = HBI_GetImageProperty(m_nFpdHandle, imageProperty);
	if (TestError(nRet, "HBI_GetImageProperty"))
	{
		return false;
	}
	FINFO("FPD num:{$}, ImageWidth:{$}, ImageHeight:{$}, DataType:{$}, ImageBit:{$}, Endian:{$}, PacketSize:{$}, \
		FrameSize:{$}, TailPacketSize:{$}, CapacitySize:{$}", 
		imageProperty->nFpdNum, imageProperty->nwidth, imageProperty->nheight, imageProperty->datatype, imageProperty->ndatabit,
		imageProperty->nendian, imageProperty->packet_size, imageProperty->frame_size, imageProperty->tailPacketSize, imageProperty->frame_number);

	if (imageProperty)
	{
		delete imageProperty;
		imageProperty = nullptr;
	}

	FINFO("Call HBI_IsMutilMode");
	bool bRet = HBI_IsMutilMode(m_nFpdHandle);
	if (bRet) 
	{
		FINFO("Detector support multi mode!");
	}
	else 
	{
		FINFO("Detector doesn't support multi mode!");
	}

	return true;
}

bool Detector_HaoBoRF::CalculateEXI(WORD* pImgData, int nImgWidth, int nImgHeight, int nImageBit, int nThreshold)
{
	int nROIXL = static_cast<int>(0.3 * nImgWidth);
	int nROIXR = static_cast<int>(0.7 * nImgWidth);
	int nROIYL = static_cast<int>(0.3 * nImgHeight);
	int nROIYR = static_cast<int>(0.7 * nImgHeight);

	WORD* pSrc = NULL;
	long nCount = 0;
	uint64_t nSum = 0;
	int nEXI = 0;
	try
	{
		for (int i = nROIYL; i < nROIYR; i++)
		{
			pSrc = pImgData + (i * nImgWidth);
			for (int j = nROIXL; j < nROIXR; j++)
			{
				nSum += *(pSrc + j);
				nCount++;
			}
		}
		if (nCount > 0) {
			nEXI = static_cast<int>(nSum / nCount);
		}
		else {
			// 处理除零错误
			return false;
		}
	}
	catch (...)
	{
		return false;
	}

	FINFO("Image EXI:{$}, Threshold:{$}", nEXI, nThreshold);

	if (nEXI >= nThreshold)
	{
		FINFO("Image has xray!");
		return true;//有x射线
	}

	return false;
}

bool Detector_HaoBoRF::CheckImageExi(WORD* pImgData, int nImgWidth, int nImgHeight, WORD dwExiThrethold)
{
	if (dwExiThrethold <= 0)
	{
		return true;
	}
	FINFO("Check image exi...");
	bool bResult = CalculateEXI(pImgData, nImgWidth, nImgHeight, 16, dwExiThrethold);
	if (bResult)
	{
		return true;
	}
	FINFO("Check image exi---black Image");

	return false;
}

//nIndex 缺省-1
void Detector_HaoBoRF::OnProcessImage(int nWidth, int nHeight, int nFrameID)
{
	printf("========OnProcessImage \n");
	FINFO("========OnProcessImage nWidth:{$},nHeight:{$},nIndex:{$}", nWidth, nHeight, nFrameID);
	int ret = 0;
	bool bImageCrop = false;

	if (m_nCropLeft != 0 || m_nCropTop != 0 || m_nCropRight != 0 || m_nCropBottom != 0)
	{
		ret = CropImageMargin(m_pFullImgBuffer, m_nImageWidth, m_nImageHeight,
			m_pRawImgBuffer, m_nRawImageWidth, m_nRawImageHeight, m_nImageBits,
			m_nCropLeft, m_nCropTop, m_nCropRight, m_nCropBottom);
		if (ret) 
		{
			FERROR("CropImageMargin fail!!");
		}
		else 
		{
			FINFO("CropImageMargin success!");
			bImageCrop = true;
		}
	}
	//上图之前回调图像的宽高，使得上层在拷贝内存时是正确的图像大小
	size_t processedSize = m_nImageWidth * m_nImageHeight * sizeof(unsigned short);

	if (bImageCrop)
	{
		ConfFeedback(EVT_CONF_RAW_WIDTH, m_nCurrentPanelID, "", m_nImageWidth);
		ConfFeedback(EVT_CONF_RAW_HIGHT, m_nCurrentPanelID, "", m_nImageHeight);
	}
	else 
	{
		processedSize = m_nRawImageWidth * m_nRawImageHeight * sizeof(unsigned short);
		ConfFeedback(EVT_CONF_RAW_WIDTH, m_nCurrentPanelID, "", m_nRawImageWidth);
		ConfFeedback(EVT_CONF_RAW_HIGHT, m_nCurrentPanelID, "", m_nRawImageHeight);
	}

	if (!m_bValidImage && m_nDelayTime > 0)
	{
		struct timespec ts;
		clock_gettime(CLOCK_MONOTONIC, &ts);  // 使用CLOCK_MONOTONIC时钟，不受系统时间调整影响
		m_dwEndTime = (unsigned long long)ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
	}

	FINFO("OnProcessImage m_nDropImgNum:{$} m_nDropImgCount:{$}", m_nDropImgNum, m_nDropImgCount);
	if (m_nDropImgNum < m_nDropImgCount)//配置为0时表示不丢图
	{
		m_nDropImgNum++;
		FINFO("Drop {$} image", m_nDropImgNum);
	}
	else if (!CheckTimeLimit(m_dwBeginTime, m_dwEndTime))//m_nDelayTime 配置为0时表示不延时
	{
		m_nDropImgNum++;
		FERROR("CheckTimeLimit Drop {$} image", m_nDropImgNum);
	}
	else
	{
		if (m_bFirstImage)
		{
			FINFO("m_bFirstImage is true");
			StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_ON);
			m_bFirstImage = false;
		}
		FINFO("OnProcessImage m_nCurrentLogicMode:{$}", m_nCurrentLogicMode);
		//560RF动态模式做点片 
		//if (m_nCurrentLogicMode == AcqMode::RAD)
		{
			//FINFO("RAD mode");
			if (m_bValidImage)
			{
				//RAD模式已经推过图了就不在推图了
				FINFO("RAD has send one image! return");
				return;
			}
			if (bImageCrop)
			{
				//计算图像EXI 不满足的不往上推
				if (!CheckImageExi(m_pFullImgBuffer, m_nImageWidth, m_nImageHeight, m_nExiThreshold)) //true 有射线 false 没射线
				{
					return;
				}
			}
			else
			{
				//计算图像EXI 不满足的不往上推
				if (!CheckImageExi(m_pRawImgBuffer, m_nRawImageWidth, m_nRawImageHeight, m_nExiThreshold)) //true 有射线 false 没射线
				{
					return;
				}
			}
		}

		const std::string baseTimestamp = std::to_string(
			std::chrono::duration_cast<std::chrono::milliseconds>(
				std::chrono::system_clock::now().time_since_epoch()
			).count()
		);
		std::string processedImagePath = "";
		if (bImageCrop)
		{
			processedImagePath = saveProcessedImage(
				m_pFullImgBuffer,
				processedSize,
				baseTimestamp
			);
		}
		else
		{
			processedImagePath = saveProcessedImage(
				m_pRawImgBuffer,
				processedSize,
				baseTimestamp
			);
		}
		InfoFeedback(EVT_DATA_RAW_IMAGE, -1, 0, 0, processedImagePath.c_str());
		m_bValidImage = true; //合法图像，不再判断时间间隔
	}
}

void Detector_HaoBoRF::SaveImage(int nIndex, bool bImageCrop)
{
	FINFO("========Begin save image");
	char szTemp[30] = { 0 };
	FILE* fp;
	string strFileName = m_strCtrlWorkPath + "/rawdata";
	if (-1 == nIndex)
	{
		strFileName += "/Image_Rad.raw";
	}
	else
	{
		sprintf(szTemp, "/Image_%d.raw", nIndex);
		strFileName += szTemp;
	}
	if ((fp = fopen(strFileName.c_str(), "wb+")) == NULL)
	{
		int err = errno;
		FERROR("fopen {$} failed, {$}", strFileName, err);
		return;
	}

	if (bImageCrop)
	{
		fwrite(m_pFullImgBuffer, sizeof(WORD),
			(unsigned long long)m_nImageWidth * m_nImageHeight, fp);
	}
	else 
	{
		fwrite(m_pRawImgBuffer, sizeof(WORD), 
			(unsigned long long)m_nRawImageWidth * m_nRawImageHeight, fp);
	}
	
	fclose(fp);
	FINFO("Save {$} image over", strFileName);
}

// 说明：调用SDK接口，执行offset校正流程 dark校正、闲时offset刷新都会调用这个函数
bool Detector_HaoBoRF::StartDarkCalibration()
{
	printf("========StartDarkCalibration \n");
	FINFO("========StartDarkCalibration");

	FINFO("Call HBI_GenerateTemplate");
	int ret = HBI_GenerateTemplate(m_nFpdHandle, OFFSET_TEMPLATE_TYPE, 0);
	if (TestError(ret,"HBI_GenerateTemplate"))
	{
		return false;
	}
	return true;
}

bool Detector_HaoBoRF::StartGainCalibration()
{
	printf("========StartGainCalibration \n");
	FINFO("========StartGainCalibration ");

	if (-1 == m_nCurrentLogicMode)
	{
		FERROR("Illegal exam mode");
		return false;
	}
	
	return true;
}

void* Detector_HaoBoRF::onFPDScanThread(void* pvoid)
{
	Detector_HaoBoRF* pOpr = (Detector_HaoBoRF*)pvoid;
	FINFO("Enter scan thread");
	bool bExit = false;

	while (!bExit)
	{
		DWORD dwRet = LinuxEvent::WaitForMultipleEvents(pOpr->m_hArrayEvent,INFINITE);
		if (WAIT_OBJECT_0 == dwRet) //m_hStopScanEvent
		{
			bExit = true;
		}
		else if (WAIT_OBJECT_0 + 1 == dwRet) //m_hAcqEvent
		{
			pOpr->OnAcquireImage();
		}
		else if (WAIT_OBJECT_0 + 2 == dwRet) //m_hGainEvent
		{
			pOpr->OnAcquireGainImage();
		}
		else if (WAIT_OBJECT_0 + 3 == dwRet) //m_hDarkEvent
		{
			pOpr->OnStartDarkCalibration();
		}
		else if (WAIT_OBJECT_0 + 4 == dwRet) //m_hProcessImgEvent
		{
			pOpr->OnProcessImage(pOpr->m_nRawImageWidth, pOpr->m_nRawImageHeight, pOpr->m_nFrameID);
		}
	}
	FINFO("Level scan thread");
	return 0;
}

void* Detector_HaoBoRF::RefreshOffsetThread(void* pvoid)
{
	Detector_HaoBoRF* pOpr = (Detector_HaoBoRF*)pvoid;
	FINFO("========Enter fresh offset thread");
	bool bExit = false;

	while (!bExit)
	{
		DWORD dwRet = LinuxEvent::WaitForMultipleEvents(pOpr->m_hOffsetEvent, INFINITE);
		if (WAIT_OBJECT_0 == dwRet) //m_hStopOffsetEvent
		{
			bExit = true;
		}
		else if (WAIT_OBJECT_0 + 1 == dwRet) //m_hStartAllOffset
		{
			pOpr->RefreshAllOffset();
		}
		else if (WAIT_OBJECT_0 + 2 == dwRet) //m_hStartOffset
		{
			pOpr->OnRefreshOffset();
		}
		else if (WAIT_OBJECT_0 + 3 == dwRet) //m_hAbortOffset
		{
			pOpr->AbortFreshOffset();
		}
	}
	FINFO("Level fresh offset thread");
	return 0;
}

//1800RF支持单独的RAD模式
void Detector_HaoBoRF::OnAcquireImage()
{
	printf("========OnAcquireImage \n");
	FINFO("========OnAcquireImage ");

	SetDpcStatus(DetStatus_Acquire); //动态模式激活采集，设置状态

	SetDpcStatus(DetStatus_Standby); //rad采集失败，设置状态
}

//SDK Rad模式增益校正流程
void Detector_HaoBoRF::OnAcquireGainImage()
{
	printf("========OnAcquireGainImage \n");
	FINFO("========OnAcquireGainImage ");

	SetDpcStatus(DetStatus_Standby);
	StatusFeedback(EVT_STATUS_CALIBRATIOIN, PANEL_EVENT_END_OK);
}

//说明：开始暗场校正
void Detector_HaoBoRF::OnStartDarkCalibration()
{
	printf("========OnStartDarkCalibration \n");
	FINFO("========OnStartDarkCalibration ");
	SetDpcStatus(DetStatus_OffsetCalibration); //开始offset校正

	if (StartDarkCalibration())
	{
		StatusFeedback(EVT_STATUS_CALIBRATIOIN, PANEL_EVENT_END_OK);
	}
	else
	{
		StatusFeedback(EVT_STATUS_CALIBRATIOIN, PANEL_EVENT_END_ERROR);
	}

	SetDpcStatus(DetStatus_Standby); //offset校正完成，置回Standby
}

//获取只用于本DPC记录的探测器状态
eDetStatus Detector_HaoBoRF::GetDpcStatus()
{
	string strStatus = "Unknown";
	switch (m_eStatus)
	{
	case DetStatus_NotIni:
		strStatus = "NotIni";
		break;
	case DetStatus_NotConn:
		strStatus = "NotConn";
		break;
	case DetStatus_Sleep:
		strStatus = "Sleep";
		break;
	case DetStatus_Standby:
		strStatus = "Standby";
		break;
	case DetStatus_Acquire:
		strStatus = "Acquire";
		break;
	case DetStatus_OffsetCalibration:
		strStatus = "OffsetCalibration";
		break;
	case DetStatus_GainCalibration:
		strStatus = "GainCalibration";
		break;
	default:
		break;
	}
	FINFO("Driver status: {$}", strStatus.c_str());
	return m_eStatus;
}

//设置只用于本DPC的探测器状态
bool Detector_HaoBoRF::SetDpcStatus(eDetStatus status)
{
	string strStatus = "Unknown";
	bool bSetStatus = true;
	switch (status)
	{
	case DetStatus_NotIni:
		strStatus = "NotIni";
		break;
	case DetStatus_NotConn:
		strStatus = "NotConn";
		break;
	case DetStatus_Sleep:
		strStatus = "Sleep";
		break;
	case DetStatus_Standby:
		strStatus = "Standby";
		break;
	case DetStatus_Acquire:
		strStatus = "Acquire";
		break;
	case DetStatus_OffsetCalibration:
		strStatus = "OffsetCalibration";
		break;
	case DetStatus_GainCalibration:
		strStatus = "GainCalibration";
		break;
	default:
		bSetStatus = false;
		break;
	}
	if (bSetStatus)
	{
		m_eStatus = status;
		FINFO("Set driver status: {$}", strStatus.c_str());
	}
	else
	{
		FERROR("{$} {$} is a illegal status", strStatus.c_str(), (int)status);
	}
	return bSetStatus;
}

bool Detector_HaoBoRF::LoadCalibrationFiles()
{
	FINFO("========LoadCalibrationFiles");
	
	return true;
}

//参照RFOC康众动态代码整理的图像裁剪功能
int Detector_HaoBoRF::CropImageMargin(void* pDstData, int& nDstWidth, int& nDstHeight,
	void* pScrData, int nSrcWidth, int nSrcHeight, int nBits,
	int nLeftMargin, int nTopMargin, int nRightMargin, int nBottomMargin)
{
	printf("========CropImageMargin \n");
	FINFO("========CropImageMargin ");
	if ((pDstData == NULL) || (pScrData == NULL) || (nSrcWidth <= 0) || (nSrcHeight <= 0) || (nBits <= 0))
		return -1;
	if ((nLeftMargin >= nSrcWidth) || (nTopMargin >= nSrcHeight))
		return -1;
	int nBitsToBYTE = (nBits + 7) / 8;
	if (nBitsToBYTE < 1)
		return -1;
	int nXL, nXR, nYL, nYR;
	nXL = nLeftMargin;//32
	nYL = nTopMargin;
	if (nSrcWidth - nRightMargin < 0)
		return -1;
	nXR = nSrcWidth - nRightMargin - 1; //2783
	if (nXR < nXL)
		return -1;
	if (nSrcHeight - nBottomMargin < 0)
		return -1;
	nYR = nSrcHeight - nBottomMargin - 1;
	if (nYR < nYL)
		return -1;

	nDstWidth = nXR - nXL + 1;
	nDstHeight = nYR - nYL + 1;

	FINFO("TopCrop:{$};Bottom:{$},nDstWidth:{$},nDstHeight:{$},Bits:{$}", nYL, nYR, nDstWidth, nDstHeight, nBitsToBYTE);


	// 检查目标缓冲区是否足够大
	size_t dstBufferSize = nDstWidth * nDstHeight * nBitsToBYTE;
	// 这里应该添加对目标缓冲区大小的检查，但需要知道缓冲区大小信息

	// 使用标准memcpy而不是::memcpy
	for (int i = nYL; i <= nYR; i++)
	{
		// 计算源和目标的偏移量
		size_t srcOffset = (i * nSrcWidth + nXL) * nBitsToBYTE;
		size_t dstOffset = (i - nYL) * nDstWidth * nBitsToBYTE;

		// 使用memcpy复制数据
		memcpy(
			static_cast<char*>(pDstData) + dstOffset,
			static_cast<char*>(pScrData) + srcOffset,
			nDstWidth * nBitsToBYTE
		);
	}
	return 0;
}

std::string Detector_HaoBoRF::saveProcessedImage(void* data, size_t size, const std::string& baseTimestamp)
{
	const size_t MAX_PROC_FILE_COUNT = 10;
	const std::string TMPFS_DIR = "/mnt/tmpfs/";
	const std::string ORIGINAL_DIR = m_strCtrlWorkPath + "/RawData/";
	std::string procDir;
	bool useTmpfs = false;

	// 确定存储目录
	if (std::filesystem::exists(TMPFS_DIR) && std::filesystem::is_directory(TMPFS_DIR))
	{
		procDir = TMPFS_DIR;
		useTmpfs = true;
		std::cout << "[Detector_HaoBoRF::saveProcessedImage] Using tmpfs directory: " << procDir << std::endl;
	}
	else
	{
		procDir = ORIGINAL_DIR;
		std::cout << "[Detector_HaoBoRF::saveProcessedImage] /mnt/tmpfs not found, using original directory: " << procDir << std::endl;
	}

	const std::string FILE_PREFIX = "Proc_";
	std::string filePath;

	try
	{
		std::filesystem::create_directories(procDir);
		filePath = procDir + FILE_PREFIX + baseTimestamp + ".raw";

		std::ofstream file(filePath, std::ios::binary);
		if (file.is_open())
		{
			file.write(reinterpret_cast<const char*>(data), size);
			std::cout << "[Detector_HaoBoRF::saveProcessedImage] Saved image: " << filePath << std::endl;
		}
		else
		{
			std::cout << "[Detector_HaoBoRF::saveProcessedImage] Failed to open file: " << filePath << std::endl;
			return "";
		}

		cleanOldFiles(procDir, FILE_PREFIX, MAX_PROC_FILE_COUNT, useTmpfs);
	}
	catch (const std::filesystem::filesystem_error& e)
	{
		std::cout << "[Detector_HaoBoRF::saveProcessedImage] File system error: " << e.what() << std::endl;
		return "";
	}
	catch (const std::exception& e)
	{
		std::cout << "[Detector_HaoBoRF::saveProcessedImage] Unexpected error: " << e.what() << std::endl;
		return "";
	}

	return filePath;
}

std::filesystem::space_info getFileSystemInfo(const std::string& dirPath) {
	try {
		return std::filesystem::space(dirPath);
	}
	catch (const std::filesystem::filesystem_error& e) {
		std::cout << "[getFileSystemInfo] Failed to get filesystem info for "
			<< dirPath << ": " << e.what() << std::endl;
		return {};
	}
}

void Detector_HaoBoRF::cleanOldFiles(const std::string& dirPath, const std::string& filePrefix,
	size_t maxCount, bool checkSize)
{
	const std::string funcTag = "[Detector_HaoBoRF::cleanOldFiles] ";

	try
	{
		// 检查目录是否存在
		if (!std::filesystem::exists(dirPath) || !std::filesystem::is_directory(dirPath))
		{
			std::cout << funcTag << "Directory not found: " << dirPath << std::endl;
			return;
		}

		std::vector<std::filesystem::directory_entry> targetFiles;
		for (const auto& entry : std::filesystem::directory_iterator(dirPath))
		{
			// 只处理常规文件
			if (!entry.is_regular_file())
				continue;

			// 检查文件扩展名是否为.raw
			const std::string extension = entry.path().extension().string();
			if (extension != ".raw")
				continue;

			// 检查文件名是否以指定前缀开头
			const std::string filename = entry.path().filename().string();
			if (filename.length() < filePrefix.length())
				continue;

			if (filename.substr(0, filePrefix.length()) == filePrefix)
			{
				targetFiles.push_back(entry);
			}
		}

		// 按文件最后修改时间排序（最旧的在前）
		std::sort(targetFiles.begin(), targetFiles.end(),
			[](const std::filesystem::directory_entry& a, const std::filesystem::directory_entry& b)
			{
				return std::filesystem::last_write_time(a) < std::filesystem::last_write_time(b);
			});

		// 1. 先按数量限制清理
		size_t filesToDelete = 0;
		if (targetFiles.size() > maxCount)
		{
			filesToDelete = targetFiles.size() - maxCount;

			// 删除超出数量限制的最旧文件
			for (size_t i = 0; i < filesToDelete; ++i)
			{
				const auto& fileToDelete = targetFiles[i];
				if (std::filesystem::remove(fileToDelete.path()))
				{
					std::cout << funcTag << "Deleted old file (count limit): " << fileToDelete.path() << std::endl;
				}
				else
				{
					std::cout << funcTag << "Failed to delete file: " << fileToDelete.path() << std::endl;
				}
			}

			// 更新目标文件列表（移除已删除的文件）
			targetFiles.erase(targetFiles.begin(), targetFiles.begin() + filesToDelete);
			filesToDelete = 0; // 重置计数器用于大小检查
		}

		// 2. 如果需要，按大小限制清理（仅对tmpfs目录）
		if (checkSize && !targetFiles.empty())
		{
			// 获取文件系统信息
			auto fsInfo = getFileSystemInfo(dirPath);
			if (fsInfo.capacity == 0) // 获取信息失败
			{
				std::cout << funcTag << "Cannot check filesystem size, skipping size check" << std::endl;
				return;
			}

			// 计算最大允许使用空间（预留10%作为缓冲）
			const uintmax_t reservedSpace = fsInfo.capacity / 10; // 10%预留空间
			const uintmax_t maxAllowedSize = fsInfo.capacity - reservedSpace;

			// 计算当前文件总大小
			auto calculateTotalSize = [](const std::vector<std::filesystem::directory_entry>& files) {
				uintmax_t total = 0;
				for (const auto& file : files) {
					total += file.file_size();
				}
				return total;
				};

			uintmax_t currentTotalSize = calculateTotalSize(targetFiles);
			std::cout << funcTag << "Current files total size: " << currentTotalSize
				<< ", Max allowed size: " << maxAllowedSize << std::endl;

			// 如果当前总大小超过限制，继续删除最旧的文件
			while (currentTotalSize > maxAllowedSize && !targetFiles.empty())
			{
				const auto& fileToDelete = targetFiles[0];
				uintmax_t fileSize = fileToDelete.file_size();

				if (std::filesystem::remove(fileToDelete.path()))
				{
					std::cout << funcTag << "Deleted old file (size limit): " << fileToDelete.path()
						<< " (" << fileSize << " bytes)" << std::endl;

					// 更新总量和文件列表
					currentTotalSize -= fileSize;
					targetFiles.erase(targetFiles.begin());
					filesToDelete++;
				}
				else
				{
					std::cout << funcTag << "Failed to delete file: " << fileToDelete.path() << std::endl;
					break; // 删除失败时停止处理
				}
			}
		}

		std::cout << funcTag << "Cleanup completed. Deleted " << filesToDelete
			<< " files. Remaining: " << targetFiles.size() << std::endl;
	}
	catch (const std::filesystem::filesystem_error& e)
	{
		std::cout << funcTag << "File system error: " << e.what() << std::endl;
	}
	catch (const std::exception& e)
	{
		std::cout << funcTag << "Unexpected error: " << e.what() << std::endl;
	}
}

//说明：初始化时刷新所有模式的offset 配置文件的OffsetInterval配置为0时则不会运行此段代码
bool Detector_HaoBoRF::RefreshAllOffset()
{
	printf("========Refresh all mode offset begin \n");
	FINFO("========Refresh all mode offset begin");
	bool bRet = false;

	SetDpcStatus(DetStatus_OffsetCalibration); //开始全模式offset刷新
	StatusFeedback(EVT_STATUS_OFFSET, PANEL_EVENT_START);
	StatusFeedback(EVT_STATUS_OFFSET_PROGRESS, 0);

	bRet = StartDarkCalibration(); //当前mode失败，仍可以进行下一个mode的刷新
	if (!bRet)
	{
		FERROR("RefreshAllOffset StartDarkCalibration failed!");
		StatusFeedback(EVT_STATUS_OFFSET, PANEL_EVENT_END_ERROR);
	}

	StatusFeedback(EVT_STATUS_OFFSET_PROGRESS, 1);
	SetDpcStatus(DetStatus_Standby); //全模式offset刷新结束，置回Standby
	StatusFeedback(EVT_STATUS_OFFSET, PANEL_EVENT_END_OK);
	FINFO("Refresh all mode offset over");
	return bRet;
}

//说明：刷当前模式的offset，什么时候刷由前端控制
void Detector_HaoBoRF::OnRefreshOffset()
{
	FINFO("========OnRefreshOffset begin");
	bool bRet = false;
	SetDpcStatus(DetStatus_OffsetCalibration);
	StatusFeedback(EVT_STATUS_OFFSET_PROGRESS, 0);
	StatusFeedback(EVT_STATUS_OFFSET, PANEL_EVENT_START);
	
	bRet = StartDarkCalibration();
	if (bRet)
	{
		StatusFeedback(EVT_STATUS_OFFSET_PROGRESS, 1);
	}
	else
	{
		FERROR("OnRefreshOffset StartDarkCalibration failed!");
		StatusFeedback(EVT_STATUS_OFFSET, PANEL_EVENT_END_ERROR);
	}

	SetDpcStatus(DetStatus_Standby);
	StatusFeedback(EVT_STATUS_OFFSET, PANEL_EVENT_END_OK);
	FINFO("OnRefreshOffset over");
}

bool Detector_HaoBoRF::CheckTimeLimit(unsigned long long dwBeginTime, unsigned long long dwEndTime)
{
	if (m_bValidImage) //合法图像，不再判断时间间隔，直接返回true
	{
		FINFO("CheckTimeLimit m_bValidImage is true!");
		return true;
	}
	if (m_nDelayTime == 0) //没有开启延时机制
	{
		FINFO("The delay time is invalid, return");
		return true;
	}
	if ((int)(dwEndTime - dwBeginTime) > m_nDelayTime)
	{
		FINFO("The interval({$}) is ok", dwEndTime - dwBeginTime);
		return true;
	}

	FERROR("The interval({$}) is shorter than the delay({$})",dwEndTime - dwBeginTime, m_nDelayTime);
	return false;
}

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

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

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

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

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

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

float Detector_HaoBoRF::SetFluPPS(float fPPS)
{
	FINFO("========SetFluPPS {$}", fPPS);
	m_fFrameRate = fPPS;
	return m_fFrameRate;
}

void Detector_HaoBoRF::GetFluPPS(float& fFluPPS)
{
	fFluPPS = m_fFrameRate;
	FINFO("========GetFluPPS {$}", fFluPPS);
}

void Detector_HaoBoRF::AbortFreshOffset()
{
	FINFO("========AbortFreshOffset");
}

void Detector_HaoBoRF::SetAbortOffsetEvent()
{
	FINFO("========SetAbortOffsetEvent");
	m_hAbortOffset->SetEvent();
}

void Detector_HaoBoRF::SetFreshAllOffsetEvent()
{
	FINFO("========SetFreshAllOffsetEvent");
	m_hStartAllOffset->SetEvent();
}

void Detector_HaoBoRF::SetfreshOffsetEvent()
{
	FINFO("========SetfreshOffsetEvent");
	m_hStartOffset->SetEvent();
}

void Detector_HaoBoRF::UpdateModeInRunning(int nMode, float fFrequency)
{
	FINFO("========UpdateModeInRunning ModeID:{$},Frequency:{$}", nMode, fFrequency);
	m_nModeID = nMode;
	m_fFrameRate = fFrequency;
}