PhysicalDevice/Detector/RunZe/DIOS.Dev.UltrasonicProbe/UltrasonicProbeCtrl.cpp

#include "stdafx.h"
#include "UltrasonicProbeCtrl.h"
#include "common_api.h"
#include "StringOpt.h"

#define UltrasonicProbeGuidStr "{636A944E-AD06-4099-910F-B519253C2715}"

UltrasonicProbe* g_pDetector = nullptr;

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


UltrasonicProbe::UltrasonicProbe()
{
	m_pDPC2PanelID = new map<FPDDeviceUltrasonicProbe*, int>();
	m_pPanelID2DPC = new map<int, FPDDeviceUltrasonicProbe*>();
	m_nPanelCount = 1;
	m_strWorkPath = "";
	m_nCurrentPanelID = 0; 
	m_ePZDPCstate = DPC_STATE_INIT;
	m_nImageWidth = 0;
	m_nImageHeight = 0;
	m_nRawImgWidth = 0;
	m_nLeftOffset = 0;
	m_nTopOffset = 0;
	m_nRightOffset = 0;
	m_nBottomOffset = 0;
	m_nRawImgHeight = 0;
	m_pRawImgBuffer24 = nullptr;
	m_pRawImgBuffer32 = nullptr;
	m_pImgBuffer = nullptr;
	//m_bFirstInIDLE = true;
	//m_eType = CCOS_CALIBRATION_TYPE_NONE;
	//m_nOffsetImg = 0;
	//m_nGainImg = 0;
	//m_eCalState = PZ_CALIBRATION_MAX;
	//m_bCalibrationOver = false;
	m_bWired = true;
	//m_nCalibrationRounds = 0;
	m_eStatus = DetectorStatus_NotIni;
	//m_nCalibrationMode = CCOS_CALIBRATION_MODE_ZSKK;
	//m_nCaliFailedCount = 0;
	m_strPanelType = "";
	m_bLoadedSDK = false;
	m_bInitializedSDK = false;
	m_bConnectWaiting = false;
	m_nCurrentMode = -1;
	m_nImgBits = 24;
	m_nPixelPitch = 0;
	m_nFrameID = 0;
	m_nSaveRaw = 0;
	//m_nCalibCurrentCalibrationRound = 0;
	//m_nCalibCurrentExposureIndex = 0;
	//m_nExposureNumCurrentRound = 0;
	//m_bConfirmCaliRst = false;
	//m_bAutoContinueCal = false;
	//m_bAutonumousMode = false;
	//m_nGainExposureNum = 0;
	m_bOnlyHaveFpd = false;
	m_pRzsdk = nullptr;
	//test
	/*m_pCaptureWriter = nullptr;
	m_pMatrix = nullptr;
	m_pSenderGroup = nullptr;
	m_pDataMgr = nullptr;*/
	m_bFirstImage = true;

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

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

	//test
	//if (!m_pDataMgr)
	//{
	//	m_pDataMgr = new CCOS_DataElement::CDataMgr();
	//}
	//if (!m_pDataMgr)
	//{
	//	Error("new CCOS_DataElement::CDataMgr fail!");
	//	return;
	//}
	//int ret = m_pDataMgr->Init();
	//if (!ret)
	//{
	//	Error("m_pDataMgr->Init fail!");
	//	return;
	//}
	//if (!m_pSenderGroup)
	//{
	//	m_pSenderGroup = m_pDataMgr->CreateGroupElement(CCOS_Kernel::CStringOpt::Transformstring2wstring(UltrasonicProbeGuidStr).c_str());
	//}
	//if (!m_pSenderGroup)
	//{
	//	Error("m_pDataMgr->CreateGroupElement fail!");
	//	return;
	//}
	////CCaptureWriter参数是共享内存名称
	//if (!m_pCaptureWriter)
	//{
	//	m_pCaptureWriter = new (std::nothrow)CCOS_Kernel::CCaptureWriter(L"USSpace2");//testname
	//}
	//if (!m_pCaptureWriter)
	//{
	//	Error("m_pCaptureWriter is nullptr!");
	//	return;
	//}
	//if (!m_pCaptureWriter->Init(true))
	//{
	//	Error("m_pCaptureWriter->Init fail!");
	//	delete m_pCaptureWriter;
	//	m_pCaptureWriter = NULL;
	//	return;
	//}
	//if (!m_pCaptureWriter->SetPerBlockLen(48 * 1024 * 1024))
	//{
	//	Error("m_pCaptureWriter->SetPerBlockLen fail!");
	//	delete m_pCaptureWriter;
	//	m_pCaptureWriter = NULL;
	//	return;
	//}
	//wstring wstrInput = L"";
	//if (!m_pCaptureWriter->BeginWriteSequence(wstrInput.c_str()))
	//{
	//	Error("m_pCaptureWriter->BeginWriteSequence fail!");
	//	return;
	//}

}


UltrasonicProbe::~UltrasonicProbe()
{
	if (m_nPanelCount != 0)
	{
		for (int i = 0; i < m_nPanelCount; i++)
		{
			delete m_pStPanelStatus[i];
		}
	}
	if (m_pRawImgBuffer24)
	{
		delete m_pRawImgBuffer24;
		m_pRawImgBuffer24 = nullptr;
	}
	if (m_pRawImgBuffer32)
	{
		delete m_pRawImgBuffer32;
		m_pRawImgBuffer32 = nullptr;
	}
	if (m_pImgBuffer != nullptr)
	{
		delete m_pImgBuffer;
		m_pImgBuffer = nullptr;
	}
	if (nullptr != m_pDPC2PanelID)
	{
		delete m_pDPC2PanelID;
		m_pDPC2PanelID = nullptr;
	}
	if (nullptr != m_pPanelID2DPC)
	{
		delete m_pPanelID2DPC;
		m_pPanelID2DPC = nullptr;
	}
	if (m_hStopScanEvent)
	{
		CloseHandle(m_hStopScanEvent);
		m_hStopScanEvent = nullptr;
	}
	if (m_hProcessImgEvent)
	{
		CloseHandle(m_hProcessImgEvent);
		m_hProcessImgEvent = nullptr;
	}
	if (m_hXWinOnEvent)
	{
		CloseHandle(m_hXWinOnEvent);
		m_hXWinOnEvent = nullptr;
	}
	if (m_hInitFPDEvent)
	{
		CloseHandle(m_hInitFPDEvent);
		m_hInitFPDEvent = nullptr;
	}
	if (m_hRespond)
	{
		CloseHandle(m_hRespond);
		m_hRespond = nullptr;
	}
	if (m_hReInitEvent)
	{
		CloseHandle(m_hReInitEvent);
		m_hReInitEvent = nullptr;
	}
	//test
	/*if (m_pCaptureWriter != NULL)
	{
		delete m_pCaptureWriter;
		m_pCaptureWriter = NULL;
	}
	if (m_pSenderGroup != NULL)
		CCOS_DataElement::CDataMgr::ReleaseElement(m_pSenderGroup);
	else if (m_pMatrix != NULL)
		CCOS_DataElement::CDataMgr::ReleaseElement(m_pMatrix);

	if (m_pDataMgr != NULL)
	{
		delete m_pDataMgr;
		m_pDataMgr = NULL;
	}*/
}


bool UltrasonicProbe::DriverEntry(FPDDeviceUltrasonicProbe* pDrvDPC, ResDataObject & Configuration)
{
	printf("--Func-- DriverEntry %p \n", pDrvDPC);
	Info("--Func-- DriverEntry {$}", pDrvDPC);

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

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

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

	return true;
}

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

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

	if (m_strWorkPath == "")
	{
		m_strWorkPath = szWorkPath;
	}

	DWORD dwThreadId;
	if (m_hFPDScanThread == nullptr)
	{
		m_hFPDScanThread = CreateThread(NULL, 0, onFPDScanThread, this, 0, &dwThreadId); //启动辅助线程
	}
	SetPZDPCState(DPC_STATE_INIT); //进入初始化状态
	SetEvent(m_hInitFPDEvent);
	
	return true;
}


bool UltrasonicProbe::Disconnect()
{
	Info("--Func-- Disconnect");
	//先退出线程，避免重连流程和调用关闭接口冲突
	StopThread();

	if (m_pStPanelStatus[m_nCurrentPanelID]->bConnectStatus)
	{
		
	}

	Info("Disconnect over");
	return true;
}


bool UltrasonicProbe::PrepareAcquisition(FPDDeviceUltrasonicProbe* pDrvDPC)
{
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		printf("Not current DPC, return\n");
		Error("Not current DPC, return");
		return false;
	}

	SetPZDPCState(DPC_STATE_STANDBY); //此时进入检查
	return true;
}


bool UltrasonicProbe::StartAcquisition(FPDDeviceUltrasonicProbe* pDrvDPC)
{
	if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
	{
		printf("Not current DPC, return\n");
		Error("Not current DPC, return");
		return false;
	}
	m_bFirstImage = true;
	int nConnectRet = INIT_SUCCESS;
	
	Info("StartAcquisition bConnectStatus:{$}", m_pStPanelStatus[m_nCurrentPanelID]->bConnectStatus);
	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectStatus)
	{
		//连接探测器
		nConnectRet = ConnectDetector();
		if (INIT_FAILED == nConnectRet)
		{
			m_pStPanelStatus[m_nCurrentPanelID]->bInitError = true;
			m_pStPanelStatus[m_nCurrentPanelID]->bConnectStatus = false;
			ErrorFeedback(EVT_ERR_INIT_FAILED, "true");
			ErrorFeedback(EVT_ERR_COMMUNICATE, "true", m_nCurrentPanelID);
			StatusFeedback(EVT_STATUS_INIT, PANEL_EVENT_END_ERROR);
			StatusFeedback(EVT_STATUS_DETECTORSHARE, PANEL_DISCONNECT_SUCCESS);
			return false;
		}
		else if (INIT_CONNECT_ERR == nConnectRet)
		{
			m_pStPanelStatus[m_nCurrentPanelID]->bConnErrorInInit = true;
			m_pStPanelStatus[m_nCurrentPanelID]->bConnectStatus = false;
			ErrorFeedback(EVT_ERR_COMMUNICATE, "true", m_nCurrentPanelID);
			StatusFeedback(EVT_STATUS_INIT, PANEL_EVENT_END);
			StatusFeedback(EVT_STATUS_DETECTORSHARE, PANEL_DISCONNECT_SUCCESS);
			return false;
		}
	}
	
	//到这里理论上是连上探头了
	m_pRzsdk->set_mode(MODE_B);
	SetPZDPCState(DPC_STATE_WORK);
	StatusFeedback(EVT_STATUS_ACQUISITION, PANEL_EVENT_START);
	Info("unfreeze US");
	m_pRzsdk->set_freeze(0);//解冻
	return true;
}


/***
** 调用api，结束采集
** pDrvDPC，ctrl模块内部调用时为nullptr
***/
bool UltrasonicProbe::StopAcquisition(FPDDeviceUltrasonicProbe* pDrvDPC)
{
	if (nullptr != pDrvDPC)
	{
		if ((*m_pDPC2PanelID)[pDrvDPC] != m_nCurrentPanelID)
		{
			printf("Not current DPC, return\n");
			Error("Not current DPC, return");
			return false;
		}
	}
	m_bFirstImage = true;
	SetPZDPCState(DPC_STATE_STANDBY);
	StatusFeedback(EVT_STATUS_ACQUISITION, PANEL_EVENT_END_OK);
	if (m_pStPanelStatus[m_nCurrentPanelID]->bConnectStatus)
	{
		Info("freeze US");
		m_pRzsdk->set_freeze(1);//冻结
	}
	else 
	{
		Info("StopAcquisition USProbe is not connected!");
	}
	
	return true;
}


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

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

	//m_hSdkModule = LoadLibraryEx(strDllpath.c_str(), NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
	//if (m_hSdkModule == nullptr)
	//{
	//	DWORD dw = GetLastError();
	//	Error("Load {$} failed! error code:{$}", strDllpath.c_str(), dw);
	//	return false;
	//}

	/*LOAD_PROC_ADDRESS(m_hSdkModule, init);
	LOAD_PROC_ADDRESS(m_hSdkModule, instance);
	LOAD_PROC_ADDRESS(m_hSdkModule, reg_image_done_cb);
	LOAD_PROC_ADDRESS(m_hSdkModule, reg_probe_connected_cb);
	LOAD_PROC_ADDRESS(m_hSdkModule, reg_probe_disconnected_cb);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_mode);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_preset);
	LOAD_PROC_ADDRESS(m_hSdkModule, get_B_depth);
	LOAD_PROC_ADDRESS(m_hSdkModule, get_B_dynamic_range);
	LOAD_PROC_ADDRESS(m_hSdkModule, get_B_focus);
	LOAD_PROC_ADDRESS(m_hSdkModule, get_B_frequency);
	LOAD_PROC_ADDRESS(m_hSdkModule, get_B_gain);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_B_depth);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_B_dynamic_range);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_B_focus);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_B_frequency);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_B_gain);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_B_harmonic);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_B_power);
	LOAD_PROC_ADDRESS(m_hSdkModule, get_C_angle);
	LOAD_PROC_ADDRESS(m_hSdkModule, get_C_frequency);
	LOAD_PROC_ADDRESS(m_hSdkModule, get_C_gain);
	LOAD_PROC_ADDRESS(m_hSdkModule, get_C_prf);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_C_ROI);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_C_angle);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_C_frequency);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_C_gain);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_C_linear_angle);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_C_persistence);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_C_prf);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_C_range_wall_filter);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_C_speed_wall_filter);
	LOAD_PROC_ADDRESS(m_hSdkModule, get_ctrl_table);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_ctrl_table);
	LOAD_PROC_ADDRESS(m_hSdkModule, get_freeze);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_freeze);
	LOAD_PROC_ADDRESS(m_hSdkModule, get_tgc1);
	LOAD_PROC_ADDRESS(m_hSdkModule, get_tgc2);
	LOAD_PROC_ADDRESS(m_hSdkModule, get_tgc3);
	LOAD_PROC_ADDRESS(m_hSdkModule, get_tgc4);
	LOAD_PROC_ADDRESS(m_hSdkModule, get_tgc5);
	LOAD_PROC_ADDRESS(m_hSdkModule, get_tgc6);
	LOAD_PROC_ADDRESS(m_hSdkModule, get_tgc7);
	LOAD_PROC_ADDRESS(m_hSdkModule, get_tgc8);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_tgc1);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_tgc2);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_tgc3);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_tgc4);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_tgc5);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_tgc6);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_tgc7);
	LOAD_PROC_ADDRESS(m_hSdkModule, set_tgc8);*/

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

void UltrasonicProbe::FuncLinkUpCallBack(unsigned char probe_type)
{
	printf("[EVENT_LINKUP] \n");
	Info("[EVENT_LINKUP] probe_type:{$}", probe_type);

	g_pDetector->OnProcessLink(probe_type);
}

void UltrasonicProbe::FuncLinkDownCallBack(unsigned char probe_type)
{
	printf("[EVENT_LINKDOWN] \n");
	Info("[EVENT_LINKDOWN] probe_type:{$}", probe_type);
	g_pDetector->OnProcessDown();
}

void UltrasonicProbe::FuncImageCallBack(unsigned char* frame_msg)
{
	Info("[EVENT_IMAGE_CALLBACK]");
	printf("[EVENT_IMAGE_CALLBACK] \n");

	if (frame_msg == nullptr)
	{
		Error("frame_msg is nullptr!!!!");
		return;
	}

	if (g_pDetector->m_ePZDPCstate != DPC_STATE_WORK)
	{
		return;
	}
	if (g_pDetector->m_bFirstImage)
	{
		Info("First Image");
		g_pDetector->StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_ON);
		g_pDetector->m_bFirstImage = false;
	}
	g_pDetector->OnProcessImg(frame_msg);
}

/// <summary>
/// 初始化 品臻 SDK
/// [DONE.CHECKED.]
/// </summary>
/// <returns></returns>
bool UltrasonicProbe::InitSDK()
{
	Info("Begin initialize SDK");
	printf("Begin initialize SDK \n");
	int nRet = 0;

	Info("Call API_instance");
	m_pRzsdk = ramzed_sdk::instance();
	if (!m_pRzsdk) 
	{
		Error("Call API_instance fail,can't get the pointer!!!");
		m_bInitializedSDK = false;
		return false;
	}

	Info("Call API_reg_probe_connected_cb");
	m_pRzsdk->reg_probe_connected_cb(FuncLinkUpCallBack);

	Info("Call API_reg_probe_disconnected_cb");
	m_pRzsdk->reg_probe_disconnected_cb(FuncLinkDownCallBack);

	Info("Call API_reg_image_done_cb");
	m_pRzsdk->reg_image_done_cb(FuncImageCallBack);

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


int UltrasonicProbe::ConnectDetector()
{
	Info("Begin connect detector");
	printf("Begin connect detector \n");
	int nRet = 0;
	int nTimeoutInit = 10000;

	try
	{
		nTimeoutInit = (int)m_objFPDConfig["ConnectTimeout"];
	}
	catch (ResDataObjectExption& e)
	{
		Error("Read configuration failed, Error code: {$}", e.what());
		return INIT_FAILED;
	}

	Info("ConnectTimeout:{$}", nTimeoutInit);
	// 初始化并连接探头
	Info("Call API_init");
	nRet = m_pRzsdk->init();
	if (!TestError(nRet, "init"))
	{
		return INIT_FAILED;
	}

	m_bConnectWaiting = true;
	if (!WaitRespond(nTimeoutInit, "Open")) //m_hRespond 初始化等待link回调
	{
		printf("连接等待超时\n");
		Error("Connect detector fail!");
		SetEvent(m_hReInitEvent);
		return INIT_CONNECT_ERR;
	}
	m_bConnectWaiting = false;

	Info("Connect detector Success!");
	printf("Connect detector Success! \n");
	//连接上探测器后获取gain校正曝光的总次数
	//m_nGainExposureNum = ((FPDDeviceUltrasonicProbe*)(*m_pPanelID2DPC)[m_nCurrentPanelID])->GetGainExposureNum();
	//Info("Gain Exposure Num:{$}",m_nGainExposureNum);
	//从UltrasonicProbeDM中获取当前环境是不是只有探测器一个真实设备，从配置文件driverconfig中读取的
	m_bOnlyHaveFpd = ((FPDDeviceUltrasonicProbe*)(*m_pPanelID2DPC)[m_nCurrentPanelID])->GetOnlyHaveFpd();
	if (m_bOnlyHaveFpd)
	{
		Info("Current system only have FPD other is demo!");
	}
	return INIT_SUCCESS;
}


/***
** 设置校正文件路径
** 说明：device\references\xxxxxx\dark是暗场校正过程文件
**      device\references\xxxxxx\flood是亮场校正过程文件
**     校正完成后校正文件会生成到device\references\路径，strPanelSerial表示探测器序列号
***/
bool UltrasonicProbe::SetFPDTplPath()
{
	BOOL nRet = FALSE;
	string strTplRootPath = m_strWorkPath + "\\references";
	string strDarkTplPath = "";
	string strFloodTplPath = "";
	string strPanelSerial = "";

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

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

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

	//将references路径设置给SDK
	//char* szTplRootPath = const_cast<char*>(strTplRootPath.c_str());
	//Info("Call TplPathSet, Template Root Path : {$}", szTplRootPath);
	////nRet = API_COM_TplPathSet(szTplRootPath);
	//if (!TestError(nRet, "TplPathSet"))
	//{
	//	return false;
	//}
	return true;
}


/***
** 获取探测器连接模式
***/
void UltrasonicProbe::GetConnectionMode()
{
	//BOOL nRet;
	//CHAR szFPSn[32] = { '\0' }; //SDK升级，改为32位数组

	//Info("Call GetFPSn");
	////nRet = API_COM_GetFPsn(szFPSn);
	//if (!TestError(nRet, "GetFPSn"))
	//{
	//	Error("Get detector serial number failed");
	//}
	//else
	//{
	//	Info("FP Sn: {$}", szFPSn);
	//}
	//string panel_sn = szFPSn;
	//ConfFeedback(EVT_CONF_PANEL_SERIAL, m_nCurrentPanelID, panel_sn.c_str());

	//Info("Call GetFPWireState");
	//CHAR cStateTemp = API_COM_GetFPWireState(); //是否是wifi连接方式
	//if (cStateTemp == CONNECT_WIFI)
	//{
	//	Info("GetFPWireState return: Wireless Mode");
	//	m_bWired = false;
	//}
	//else if (cStateTemp == CONNECT_WIRE)
	//{
	//	Info("GetFPWireState return: Wired Mode");
	//	m_bWired = true;
	//}
	//else
	//{
	//	Warn("GetFPWireState return unknown mode: {$}", cStateTemp);
	//}
}


DWORD __stdcall UltrasonicProbe::onFPDScanThread(PVOID pvoid)
{
	UltrasonicProbe* pOpr = (UltrasonicProbe*)pvoid;
	Info("Enter Scan Thread");
	bool bExit = false;
	DWORD dwTimeOut = 5000;

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

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


void UltrasonicProbe::StopThread()
{
	SetEvent(m_hStopScanEvent); //关闭Scan线程
}

/***
** 裁剪图像
** pOutImg: 裁剪后图像;	pInImg: 裁剪前图像;	nInWidth: 裁剪前图像宽度
***/
//参照RFOC康众动态代码整理的图像裁剪功能
int UltrasonicProbe::CropImageMargin(LPVOID pDstData, int& nDstWidth, int& nDstHeight,
	LPVOID pScrData, int nSrcWidth, int nSrcHeight, int nBits,
	int nLeftMargin, int nTopMargin, int nRightMargin, int nBottomMargin)
{
	Info("CropImageMargin start");
	if ((pDstData == NULL) || (pScrData == NULL) || (nSrcWidth <= 0) || (nSrcHeight <= 0) || (nBits <= 0))
		return -1;
	if ((nLeftMargin >= nSrcWidth) || (nTopMargin >= nSrcHeight))
		return -1;
	int nBitsToBYTE = (int)((nBits + 7) * 0.125);
	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;

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

	int i = 0;
#pragma omp parallel private(i) 
	{
#pragma omp for 
		for (i = nYL; i <= nYR; i++)
		{
			::memcpy((WORD*)pDstData + (i - nYL) * nDstWidth, (WORD*)pScrData + (i * nSrcWidth + nXL), nDstWidth * nBitsToBYTE);
		}
	}
	Info("CropImageMargin end");
	return 0;
}


/***
** 处理图像
***/
void UltrasonicProbe::OnProcessImg(unsigned char* frame_msg)
{
	BOOL nRet = FALSE;
	printf("Image Arrived...\n");
	Info("Image Arrived...");

	image_msg_t* msg = (image_msg_t*)frame_msg;
	unsigned short version;
	unsigned short frame_type;//B模式  C模式
	unsigned int frame_id;
	unsigned int width;//640
	unsigned int height;//480
	unsigned int length;
	//unsigned int image_format;
	char probe_type;
	unsigned char res[3] = {0};

	version = msg->version;
	frame_type = msg->frame_type;
	frame_id = msg->frame_id;
	m_nFrameID = msg->frame_id;
	width = msg->width;
	height = msg->height;
	length = msg->length;
	//image_format = msg->image_format;润泽开发说这个值没用 //RGB888（24位）还是ARGB8888（32位）
	probe_type = msg->probe_type;
	memcpy(res,msg->res,3);
	Info("version:{$},frame_type:{$},frame_id:{$},width:{$},height:{$},length:{$},probe_type:{$},res:{$}", 
		version, frame_type, frame_id, width, height, length, probe_type, res);
	ConfFeedback(EVT_CONF_RAW_WIDTH, m_nCurrentPanelID, "", width);
	ConfFeedback(EVT_CONF_RAW_HIGHT, m_nCurrentPanelID, "", height);

	if (msg->payload == nullptr)
	{
		Error("callback image is null!!!");
		return;
	}

	//32位图和24位图用两个buffer防止buffer来回申请释放影响性能
	if (MODE_B == frame_type)
	{
		m_nImgBits = 24;
		if (m_pRawImgBuffer24 == nullptr)
		{
			m_pRawImgBuffer24 = new unsigned char[length];
		}
		memcpy(m_pRawImgBuffer24, msg->payload, length);

		ConfFeedback(EVT_CONF_RAW_BITS, m_nCurrentPanelID, "", m_nImgBits);
		if (m_nSaveRaw)
		{
			SaveRawFunc(m_pRawImgBuffer24, length);
		}

		DataFeedback(EVT_DATA_RAW_IMAGE, m_pRawImgBuffer24);
	}
	else if (MODE_C == frame_type)
	{
		if (m_pRawImgBuffer32 == nullptr)
		{
			m_pRawImgBuffer32 = new unsigned char[length];
		}
		memcpy(m_pRawImgBuffer32, msg->payload, length);

		if (m_nSaveRaw)
		{
			SaveRawFunc(m_pRawImgBuffer32, length);
		}
		//虽然是32位图但是会转成24位图，故这里向上通知24位图
		m_nImgBits = 24;
		ConfFeedback(EVT_CONF_RAW_BITS, m_nCurrentPanelID, "", m_nImgBits);
		if (m_pRawImgBuffer24 == nullptr)
		{
			m_pRawImgBuffer24 = new unsigned char[m_nRawImgHeight * m_nRawImgWidth * 3];
		}
		//这里需要把32位图的Alpha去掉，保证向上推图时是24位图
		for (unsigned int i = 0; i < width*height; i++)
		{
			memcpy(m_pRawImgBuffer24 + i * 3, m_pRawImgBuffer32 + i * 4, 3);
		}
		DataFeedback(EVT_DATA_RAW_IMAGE, m_pRawImgBuffer24);
	}

	/*if (m_nFrameID == 300)
	{
		Info("switch to mode C");
		m_pRzsdk->set_mode(MODE_C);
	}*/
	
	//test
	/*if (!m_pMatrix)
	{
		m_pMatrix = m_pDataMgr->CreateDataElement(L"EC_BYTE_BYTE_BYTE", 2, L"DATA");
	}
	if (m_pMatrix == nullptr)
	{
		Error("m_pDataMgr->CreateDataElement fail!");
		return;
	}
	if (m_pSenderGroup != NULL)
	{
		m_pSenderGroup->AddElement(m_pMatrix);
	}
	wstring wstrDataType = L"FullData";
	m_pMatrix->SetDescription(L"ZSKK_DataType", wstrDataType.c_str());
	unsigned int uDimensions[2] = { (unsigned int)width, (unsigned int)height };
	if (!m_pMatrix->CreateDataBuffer(uDimensions, 2))
	{
		Error("m_pMatrix->CreateDataBuffer fail!");
		return;
	}
	unsigned int nLen = 0;
	void* pBuffer = m_pMatrix->WritePixelDataBuffer(nLen);
	memcpy(pBuffer, m_pRawImgBuffer32, frame_size);
	std::wstring wstrFrameHeader = L"";
	m_pSenderGroup->SetDescription(L"FrameDescription", wstrFrameHeader.c_str());
	CCOS_Kernel::CBytesBufBolbWriter oBuffer;
	if (!m_pDataMgr->SaveElement(m_pSenderGroup, oBuffer)) 
	{
		Error("m_pDataMgr->SaveElement fail!");
		return;
	}
	if (!m_pCaptureWriter->WriteData((void*)oBuffer.contents(), (int)oBuffer.Length()))
	{
		Error("m_pCaptureWriter->WriteData fail!");
		return;
	}*/
}


void UltrasonicProbe::SaveRawFunc(unsigned char* pInImg, DWORD nFrameSize)
{
	FILE* fp;
	//SYSTEMTIME st;
	//GetLocalTime(&st);
	//Info("Date: [%04d:%02d:%02d] ", st.wYear, st.wMonth, st.wDay);
	//char filename[256];
	//sprintf(filename, "\\Image\\Raw%02d-%02d-%02d-%02d-%02d.raw", st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
	//sprintf(filename, "\\Image\\Raw.raw");
	string filename = "\\Image\\Frame";
	filename += std::to_string(m_nFrameID);
	filename += ".raw";
	string strFileName = m_strWorkPath + filename;
	Info("begin save image path:{$}",strFileName);
	if ((fp = fopen(strFileName.c_str(), "wb+")) == NULL)
	{
		DWORD dw = GetLastError();
		Error("fopen {$} failed, {$}", strFileName.c_str(), dw);
		return;
	}
	fwrite(pInImg, sizeof(unsigned char), nFrameSize, fp);
	fclose(fp);
	Info("Save image over");
}


/// <summary>
/// 实际探测器初始化，事件触发
/// 连接探测器并进行初始化操作
/// </summary>
void UltrasonicProbe::OnProcessInitFPD()
{
	Info("OnProcessInitFPD begin");
	StatusFeedback(EVT_STATUS_INIT, PANEL_EVENT_START);

	//加载SDK
	if (!m_bLoadedSDK && !LoadSDK())
	{
		Error("LoadSDK fail!");
		m_pStPanelStatus[m_nCurrentPanelID]->bInitError = true;
		ErrorFeedback(EVT_ERR_INIT_FAILED, "true");
		StatusFeedback(EVT_STATUS_INIT, PANEL_EVENT_END_ERROR);
		return;
	}

	//初始化SDK
	if (!m_bInitializedSDK && !InitSDK())
	{
		Error("InitSDK fail!");
		m_pStPanelStatus[m_nCurrentPanelID]->bInitError = true;
		ErrorFeedback(EVT_ERR_INIT_FAILED, "true");
		StatusFeedback(EVT_STATUS_INIT, PANEL_EVENT_END_ERROR);
		return;
	}
	SetPZDPCState(DPC_STATE_STANDBY);
	StatusFeedback(EVT_STATUS_INIT, PANEL_EVENT_END_OK);
}


/***
** 说明：重连探测器
***/
void UltrasonicProbe::OnReInitFPD()
{
	Info("OnReInitFPD begin");
	StatusFeedback(EVT_STATUS_INIT, PANEL_EVENT_START);
	int nRet = INIT_FAILED;

	if (!m_bInitializedSDK)
	{
		if (InitSDK())
		{
			Info("OnReInitFPD InitSDK Success!");
		}
		else 
		{
			Error("OnReInitFPD InitSDK Fail!");
			m_pStPanelStatus[m_nCurrentPanelID]->bInitError = true;
			ErrorFeedback(EVT_ERR_INIT_FAILED, "true");
			StatusFeedback(EVT_STATUS_INIT, PANEL_EVENT_END_ERROR);
			return;
		}
	}
	if (!m_pStPanelStatus[m_nCurrentPanelID]->bConnectStatus)
	{
		nRet = ConnectDetector();
		if (INIT_FAILED == nRet)
		{
			m_pStPanelStatus[m_nCurrentPanelID]->bInitError = true;
			m_pStPanelStatus[m_nCurrentPanelID]->bConnectStatus = false;
			ErrorFeedback(EVT_ERR_INIT_FAILED, "true");
			ErrorFeedback(EVT_ERR_COMMUNICATE, "true", m_nCurrentPanelID);
			StatusFeedback(EVT_STATUS_INIT, PANEL_EVENT_END_ERROR);
			StatusFeedback(EVT_STATUS_DETECTORSHARE, PANEL_DISCONNECT_SUCCESS);
		}
		else if (INIT_CONNECT_ERR == nRet)
		{
			m_pStPanelStatus[m_nCurrentPanelID]->bConnErrorInInit = true;
			m_pStPanelStatus[m_nCurrentPanelID]->bConnectStatus = false;
			ErrorFeedback(EVT_ERR_COMMUNICATE, "true", m_nCurrentPanelID);
			StatusFeedback(EVT_STATUS_DETECTORSHARE, PANEL_DISCONNECT_SUCCESS);
			StatusFeedback(EVT_STATUS_INIT, PANEL_EVENT_END);
		}
		else
		{
			m_pStPanelStatus[m_nCurrentPanelID]->bConnErrorInInit = false;
			StatusFeedback(EVT_STATUS_INIT, PANEL_EVENT_END_OK);
			SetPZDPCState(DPC_STATE_STANDBY);
		}
	}

	Info("OnReInitFPD over");
}


void UltrasonicProbe::SetPZDPCState(DPC_State ePZDPCstate)
{
	string strlog = "Unknown";
	switch (ePZDPCstate)
	{
	case DPC_STATE_INIT:
		strlog = "INIT";
		break;
	case DPC_STATE_STANDBY:
		strlog = "STANDBY";
		break;
	case DPC_STATE_WORK:
		strlog = "WORK";
		break;
	case DPC_STATE_CALIBRATION:
		strlog = "CALIBRATION";
		break;
	case DPC_STATE_EXIT:
		strlog = "EXIT";
		break;
	case DPC_STATE_MAX:
		break;
	default:
		break;
	}
	Info("Set PZ DPC state {$}", strlog.c_str());
	m_ePZDPCstate = ePZDPCstate;
}


DPC_State UltrasonicProbe::GetPZDPCState()
{
	string strlog = "Unknown";
	switch (m_ePZDPCstate)
	{
	case DPC_STATE_INIT:
		strlog = "INIT";
		break;
	case DPC_STATE_STANDBY:
		strlog = "STANDBY";
		break;
	case DPC_STATE_WORK:
		strlog = "WORK";
		break;
	case DPC_STATE_CALIBRATION:
		strlog = "CALIBRATION";
		break;
	case DPC_STATE_EXIT:
		strlog = "EXIT";
		break;
	case DPC_STATE_MAX:
		break;
	default:
		break;
	}
	Info("Get state, {$}", strlog.c_str());
	return m_ePZDPCstate;
}


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

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

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


/***
** 处理SDK LINK回调
***/
BOOL UltrasonicProbe::OnProcessLink(unsigned char probe_type)
{
	float depth_cm, focus_cm, frequency;
	unsigned char gain;
	unsigned char gears;
	unsigned char gears_f;
	unsigned char dynamic_range;
	unsigned char prf;
	unsigned char angle;

	if (probe_type == PROBE_CONVEX) //凸阵
	{
		Info("OnProcessLink probe_type == PROBE_CONVEX");
		m_pRzsdk->set_preset(PRESET_LIVERPART);//腹部（适用于凸阵）
		m_pRzsdk->set_mode(MODE_B);
		m_pRzsdk->get_B_depth(&gears, &depth_cm);
		m_pRzsdk->get_B_frequency(&frequency);
		m_pRzsdk->get_B_gain(&gain);
		m_pRzsdk->get_B_focus(&gears_f, &focus_cm);
		m_pRzsdk->get_B_dynamic_range(&dynamic_range);

		//m_pRzsdk->set_mode(MODE_C);
		//m_pRzsdk->set_C_ROI(50, 80, 100, 300);
		//m_pRzsdk->set_C_gain(254);
		//m_pRzsdk->get_C_angle(&angle);
		//m_pRzsdk->get_C_frequency(&frequency);
		//m_pRzsdk->get_C_gain(&gain);
		//m_pRzsdk->get_C_prf(&prf);
	}
	else if (probe_type == PROBE_LINEAR)//线阵
	{
		Info("OnProcessLink probe_type == PROBE_LINEAR");
		m_pRzsdk->set_preset(PRESET_SMALLPART);//小器官（适用于线阵）
		m_pRzsdk->set_mode(MODE_B);
		m_pRzsdk->get_B_depth(&gears, &depth_cm);
		m_pRzsdk->get_B_frequency(&frequency);
		m_pRzsdk->get_B_gain(&gain);
		m_pRzsdk->get_B_focus(&gears_f, &focus_cm);
		m_pRzsdk->get_B_dynamic_range(&dynamic_range);

		//m_pRzsdk->set_mode(MODE_C);
		//m_pRzsdk->set_C_ROI(50, 80, 100, 300);
		//m_pRzsdk->set_C_gain(254);
		//m_pRzsdk->get_C_angle(&angle);
		//m_pRzsdk->get_C_frequency(&frequency);
		//m_pRzsdk->get_C_gain(&gain);
		//m_pRzsdk->get_C_prf(&prf);
	}
	StatusFeedback(EVT_PROBE_TYPE, probe_type);
	Info("unfreeze US");
	m_pRzsdk->set_freeze(0);//解冻

	Info("gears:{$},depth:{$}cm,frequency:{$},gain:{$},gears_f:{$},focus:{$},dynamic_range:{$},angle:{$},prf:{$}", 
		gears, depth_cm, frequency, gain, gears_f, focus_cm, dynamic_range, angle, prf);

	if (m_bConnectWaiting)
	{
		StopWaiting("Open");
	}

	m_pStPanelStatus[m_nCurrentPanelID]->bConnectStatus = true;
	ErrorFeedback(EVT_ERR_COMMUNICATE, "false", m_nCurrentPanelID);
	StatusFeedback(EVT_STATUS_DETECTORSHARE, PANEL_CONNECT_OK);
	return TRUE;
}


/***
** 处理SDK BREAK回调
***/
BOOL UltrasonicProbe::OnProcessDown()
{
	m_pStPanelStatus[m_nCurrentPanelID]->bConnectStatus = false;
	ErrorFeedback(EVT_ERR_COMMUNICATE, "true", m_nCurrentPanelID);
	StatusFeedback(EVT_STATUS_DETECTORSHARE, PANEL_DISCONNECT_SUCCESS);
	return TRUE;
}


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

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

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

	//// 电池电量状态
	//float fBatRemain = (float)(objFPStat.tBatInfo1.Remain + objFPStat.tBatInfo2.Remain) / (objFPStat.tBatInfo1.full + objFPStat.tBatInfo2.full);
	//int nBattery = (int)(fBatRemain * 100);
	//Info("Battery remain:{$}, upload:{$}", fBatRemain, nBattery);

	//if (nBattery < 0)
	//{
	//	nBattery = 100; //没有电池按满电反馈
	//}
	//StatusFeedback(EVT_STATUS_BATTERY_VALUE, nBattery, "", m_nCurrentPanelID);
}

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

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

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

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

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


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

void UltrasonicProbe::NotifyXWindowOn()
{
	((FPDDeviceUltrasonicProbe*)(*m_pPanelID2DPC)[m_nCurrentPanelID])->NotifyXWindowOn();
}

void UltrasonicProbe::NotifyXWindowOff()
{
	((FPDDeviceUltrasonicProbe*)(*m_pPanelID2DPC)[m_nCurrentPanelID])->NotifyXWindowOff();
}


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

	Info("SelectExamMode:{$}", nLogicMode);
	if (nLogicMode < 0 || nLogicMode > 9) //sdk 最多9个mode
	{
		Error("Illegal appmode");
		return false;
	}

	//if (m_nCurrentMode == nLogicMode) //同样appmode下没必要再次走下面的流程
	//{
	//	Info("Same appmode, return true");
	//	return true;
	//}

	m_ModeConfig = m_pStPanelStatus[m_nCurrentPanelID]->objPanelConfig;
	int nModeCount = (int)m_ModeConfig["ModeTable"].GetKeyCount("DetectorMode");
	bool bInitBuffer = false;
	for (int i = 0; i < nModeCount; i++)
	{
		if (nLogicMode == (int)m_ModeConfig["ModeTable"][i]["LogicMode"])
		{
			try
			{
				int havePreview = (int)m_ModeConfig["ModeTable"][i]["HavePreview"];
				m_nRawImgWidth = (int)m_ModeConfig["ModeTable"][i]["RawImgWidth"];
				m_nRawImgHeight = (int)m_ModeConfig["ModeTable"][i]["RawImgHeight"];
				m_nImageWidth = (int)m_ModeConfig["ModeTable"][i]["ImageWidth"];
				m_nImageHeight = (int)m_ModeConfig["ModeTable"][i]["ImageHeight"];
				m_nLeftOffset = (int)m_ModeConfig["ModeTable"][i]["CropImageLeft"];
				m_nTopOffset = (int)m_ModeConfig["ModeTable"][i]["CropImageTop"];
				m_nRightOffset = (int)m_ModeConfig["ModeTable"][i]["CropImageRight"];
				m_nBottomOffset = (int)m_ModeConfig["ModeTable"][i]["CropImageBottom"];
				m_nImgBits = (int)m_ModeConfig["ModeTable"][i]["PhySizeInfoBit"];
				m_nPixelPitch = (int)m_ModeConfig["ModeTable"][i]["PixelPitch"];
				m_nSaveRaw = (int)m_ModeConfig["ModeTable"][i]["IsSaveRaw"];
				int m_nSyncType = (int)m_ModeConfig["ModeTable"][i]["SyncType"];
				
				m_pStPanelStatus[m_nCurrentPanelID]->eSyncMode = (SYNC_MODE)m_nSyncType;
				if (m_pRawImgBuffer24)
				{
					delete m_pRawImgBuffer24;
					m_pRawImgBuffer24 = NULL;
				}
				m_pRawImgBuffer24 = new unsigned char[m_nRawImgHeight * m_nRawImgWidth * 3];
				if (m_pRawImgBuffer32)
				{
					delete m_pRawImgBuffer32;
					m_pRawImgBuffer32 = NULL;
				}
				m_pRawImgBuffer32 = new unsigned char[m_nRawImgHeight * m_nRawImgWidth * 4];
				if (m_pImgBuffer)
				{
					delete m_pImgBuffer;
					m_pImgBuffer = NULL;
				}
				m_pImgBuffer = new unsigned char[m_nImageHeight * m_nImageWidth * (m_nImgBits / 8)];

				Info("Config file image raw({$}*{$}), After crop size({$}*{$}), Offset({$},{$},{$},{$}), Bits({$}), PixelPitch({$}), SaveRaw({$})",
					m_nRawImgWidth, m_nRawImgHeight, m_nImageWidth, m_nImageHeight, m_nLeftOffset, m_nTopOffset, m_nRightOffset, m_nBottomOffset, 
					m_nImgBits, m_nPixelPitch, m_nSaveRaw);

				bInitBuffer = true;

				if(havePreview)
				{
					//ConfFeedback(EVT_CONF_PREVIEW_WIDTH, m_nCurrentPanelID, "", m_nPreviewWidth);
					//ConfFeedback(EVT_CONF_PREVIEW_HIGHT, m_nCurrentPanelID, "", m_nPreviewHeight);
				}
				ConfFeedback(EVT_CONF_RAW_WIDTH, m_nCurrentPanelID, "", m_nImageWidth);
				ConfFeedback(EVT_CONF_RAW_HIGHT, m_nCurrentPanelID, "", m_nImageHeight);
				ConfFeedback(EVT_CONF_RAW_BITS, m_nCurrentPanelID, "", m_nImgBits);
				ConfFeedback(EVT_CONF_PIXELSPACE, m_nCurrentPanelID, "", 0, (float)m_nPixelPitch);
				break;
			}
			catch (ResDataObjectExption& exp)
			{
				Error("SelectExamMode failed, reason:{$}", exp.what());
			}
		}
	}
	if (!bInitBuffer)
	{
		Error("Image buffer is NULL");
		return false;
	}

	return true;
}


/***
* 保存RAW图像
***/
bool UltrasonicProbe::SaveRawImage(const char* pImgName, const WORD* pRawImg, int nWidth, int nHeight)
{
	Info("Begin to Save {$} Image, width: {$}, height: {$}", pImgName, nWidth, nHeight);
	if (pRawImg == NULL || pImgName == NULL)
	{
		return false;
	}
	string strImagePath = "";
	strImagePath = m_strWorkPath + "\\rawdata\\" + pImgName;

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

	Info("End to Save Raw Image");
	return true;
}

//有些板子的reset会持续很长时间，所以这里的调用要谨慎
bool UltrasonicProbe::ResetDetector(FPDDeviceUltrasonicProbe* pDrvDPC)
{
	return true;
}

//超声相关
RET_STATUS UltrasonicProbe::SetFreeze(int nFreeze)
{
	Info("SetFreeze nFreeze:{$}",nFreeze);
	//0-解冻 1-冻结
	int ret = m_pRzsdk->set_freeze(nFreeze);
	if (ret) 
	{
		Error("SetFreeze fail!");
		return RET_STATUS::RET_FAILED;
	}
	else 
	{
		Info("SetFreeze success!");
		if (nFreeze == 1) 
		{
			StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_OFF);
		}
		else 
		{
			StatusFeedback(EVT_STATUS_PANEL, PANEL_XWINDOW_ON);
		}
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::SwitchProbe(int nProbeType)
{
	//暂时不支持
	Info("SwitchProbe nProbeType:{$}", nProbeType);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS UltrasonicProbe::SwitchProbeMode(int nProbeMode)
{
	Info("SwitchProbeMode nProbeMode:{$}", nProbeMode);
	int ret = m_pRzsdk->set_mode(nProbeMode);
	if (ret)
	{
		Error("SwitchProbeMode fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("SwitchProbeMode success!");
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::SetBGain(int nGain)
{
	Info("SetBGain nGain:{$}", nGain);
	int ret = m_pRzsdk->set_B_gain(nGain);
	if (ret)
	{
		Error("SetBGain fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("SetBGain success!");
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::SetBDepth(int nDepth)
{
	Info("SetBDepth nDepth:{$}", nDepth);
	int ret = m_pRzsdk->set_B_depth(nDepth);
	if (ret)
	{
		Error("SetBDepth fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("SetBDepth success!");
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::SetBFrequency(float fFrequency)
{
	Info("SetBFrequency fFrequency:{$}", fFrequency);
	int ret = m_pRzsdk->set_B_frequency(fFrequency);
	if (ret)
	{
		Error("SetBFrequency fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("SetBFrequency success!");
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::SetBFocus(int nFocus)
{
	Info("SetBFocus nFocus:{$}", nFocus);
	int ret = m_pRzsdk->set_B_focus(nFocus);
	if (ret)
	{
		Error("SetBFocus fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("SetBFocus success!");
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::SetBHarmonic(int nHarmonic)
{
	Info("SetBHarmonic nHarmonic:{$}", nHarmonic);
	int ret = m_pRzsdk->set_B_harmonic(nHarmonic);
	if (ret)
	{
		Error("SetBHarmonic fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("SetBHarmonic success!");
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::SetBPower(int nPower)
{
	Info("SetBPower nPower:{$}", nPower);
	int ret = m_pRzsdk->set_B_power(nPower);
	if (ret)
	{
		Error("SetBPower fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("SetBPower success!");
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::SetBDynamicRange(int nRange)
{
	Info("SetBDynamicRange nRange:{$}", nRange);
	int ret = m_pRzsdk->set_B_dynamic_range(nRange);
	if (ret)
	{
		Error("SetBDynamicRange fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("SetBDynamicRange success!");
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::GetBDepth(int& nDepth, float& fDepthCm)
{
	Info("GetBDepth");
	unsigned char tempDepth;
	float tempDepthCm;
	int ret = m_pRzsdk->get_B_depth(&tempDepth, &tempDepthCm);
	if (ret)
	{
		Error("GetBDepth fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("GetBDepth success! depth:{$},depthcm:{$}", tempDepth, tempDepthCm);
		nDepth = tempDepth;
		fDepthCm = tempDepthCm;
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::GetBFrequency(float& fFrequency)
{
	Info("GetBFrequency");
	float tempFrequency;
	int ret = m_pRzsdk->get_B_frequency(&tempFrequency);
	if (ret)
	{
		Error("GetBFrequency fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("GetBFrequency success! frequency:{$}", tempFrequency);
		fFrequency = tempFrequency;
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::GetBGain(int& nGain)
{
	Info("GetBGain");
	unsigned char tempGain;
	int ret = m_pRzsdk->get_B_gain(&tempGain);
	if (ret)
	{
		Error("GetBGain fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("GetBGain success! gain:{$}", tempGain);
		nGain = tempGain;
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::GetBFocus(int& nFocus, float& fFocusCm)
{
	Info("GetBFocus");
	unsigned char tempFocus;
	float tempFocusCm;
	int ret = m_pRzsdk->get_B_focus(&tempFocus, &tempFocusCm);
	if (ret)
	{
		Error("GetBFocus fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("GetBFocus success! depth:{$},depthcm:{$}", tempFocus, tempFocusCm);
		nFocus = tempFocus;
		fFocusCm = tempFocusCm;
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::GetBDynamicRange(int& nRange)
{
	Info("GetBDynamicRange");
	unsigned char tempRange;
	int ret = m_pRzsdk->get_B_dynamic_range(&tempRange);
	if (ret)
	{
		Error("GetBDynamicRange fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("GetBDynamicRange success! range:{$}", tempRange);
		nRange = tempRange;
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::SetCRoi(int x1, int x2, int y1, int y2)
{
	Info("SetCRoi x1:{$},x2:{$},y1:{$},y2:{$}", x1, x2, y1, y2);
	int ret = m_pRzsdk->set_C_ROI(x1,x2,y1,y2);
	if (ret)
	{
		Error("SetCRoi fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("SetCRoi success!");
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::SetCGain(int nGain)
{
	Info("SetCGain nGain:{$}", nGain);
	int ret = m_pRzsdk->set_C_gain(nGain);
	if (ret)
	{
		Error("SetCGain fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("SetCGain success!");
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::SetPostLevel(int nLevel)
{
	//暂不支持
	Info("SetPostLevel nLevel:{$}", nLevel);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS UltrasonicProbe::SetMirror(int nMirror)
{
	//暂不支持
	Info("SetMirror nMirror:{$}", nMirror);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS UltrasonicProbe::SetCFrequency(float fFrequency)
{
	Info("SetCFrequency fFrequency:{$}", fFrequency);
	int ret = m_pRzsdk->set_C_frequency(fFrequency);
	if (ret)
	{
		Error("SetCFrequency fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("SetCFrequency success!");
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::SetCSpeedWallFilter(int nSpeedWallFilter)
{
	//暂不支持
	Info("SetCSpeedWallFilter nSpeedWallFilter:{$}", nSpeedWallFilter);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS UltrasonicProbe::SetCRangeWallFilter(int nRangeWallFilter)
{
	//暂不支持
	Info("SetCRangeWallFilter nRangeWallFilter:{$}", nRangeWallFilter);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS UltrasonicProbe::SetCPersistence(int nPersistence)
{
	//暂不支持
	Info("SetCPersistence nPersistence:{$}", nPersistence);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS UltrasonicProbe::SetCLinearAngle(int nAngle)
{
	Info("SetCLinearAngle nAngle:{$}", nAngle);
	int ret = m_pRzsdk->set_C_angle(nAngle);
	if (ret)
	{
		Error("SetCLinearAngle fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("SetCLinearAngle success!");
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::SetCPrf(int nPrf)
{
	Info("SetCPrf nPrf:{$}", nPrf);
	int ret = m_pRzsdk->set_C_prf(nPrf);
	if (ret)
	{
		Error("SetCPrf fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("SetCPrf success!");
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::GetCFrequency(float& fFrequency)
{
	Info("GetCFrequency");
	float tempFrequency;
	int ret = m_pRzsdk->get_C_frequency(&tempFrequency);
	if (ret)
	{
		Error("GetCFrequency fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("GetCFrequency success! frequency:{$}", tempFrequency);
		fFrequency = tempFrequency;
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::GetCGain(int& nGain)
{
	Info("GetCGain");
	unsigned char tempGain;
	int ret = m_pRzsdk->get_C_gain(&tempGain);
	if (ret)
	{
		Error("GetCGain fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("GetCGain success! gain:{$}", tempGain);
		nGain = tempGain;
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::GetCPrf(int& nPrf)
{
	Info("GetCPrf");
	unsigned char tempPrf;
	int ret = m_pRzsdk->get_C_prf(&tempPrf);
	if (ret)
	{
		Error("GetCPrf fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("GetCPrf success! prf:{$}", tempPrf);
		nPrf = tempPrf;
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::GetCLinearAngle(int& nAngle)
{
	Info("GetCLinearAngle");
	unsigned char tempAngle;
	int ret = m_pRzsdk->get_C_angle(&tempAngle);
	if (ret)
	{
		Error("GetCLinearAngle fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("GetCLinearAngle success! angle:{$}", tempAngle);
		nAngle = tempAngle;
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::SetTgc1(int nTgc)
{
	Info("SetTgc1 nTgc:{$}", nTgc);
	int ret = m_pRzsdk->set_tgc1(nTgc);
	if (ret)
	{
		Error("SetTgc1 fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("SetTgc1 success!");
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::SetTgc2(int nTgc)
{
	Info("SetTgc2 nTgc:{$}", nTgc);
	int ret = m_pRzsdk->set_tgc2(nTgc);
	if (ret)
	{
		Error("SetTgc2 fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("SetTgc2 success!");
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::SetTgc3(int nTgc)
{
	Info("SetTgc3 nTgc:{$}", nTgc);
	int ret = m_pRzsdk->set_tgc3(nTgc);
	if (ret)
	{
		Error("SetTgc3 fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("SetTgc3 success!");
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::SetTgc4(int nTgc)
{
	Info("SetTgc4 nTgc:{$}", nTgc);
	int ret = m_pRzsdk->set_tgc4(nTgc);
	if (ret)
	{
		Error("SetTgc4 fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("SetTgc4 success!");
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::SetTgc5(int nTgc)
{
	Info("SetTgc5 nTgc:{$}", nTgc);
	int ret = m_pRzsdk->set_tgc5(nTgc);
	if (ret)
	{
		Error("SetTgc5 fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("SetTgc5 success!");
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::SetTgc6(int nTgc)
{
	Info("SetTgc6 nTgc:{$}", nTgc);
	int ret = m_pRzsdk->set_tgc6(nTgc);
	if (ret)
	{
		Error("SetTgc6 fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("SetTgc6 success!");
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::SetTgc7(int nTgc)
{
	Info("SetTgc7 nTgc:{$}", nTgc);
	int ret = m_pRzsdk->set_tgc7(nTgc);
	if (ret)
	{
		Error("SetTgc7 fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("SetTgc7 success!");
		return RET_STATUS::RET_SUCCEED;
	}
}
RET_STATUS UltrasonicProbe::SetTgc8(int nTgc)
{
	Info("SetTgc8 nTgc:{$}", nTgc);
	int ret = m_pRzsdk->set_tgc8(nTgc);
	if (ret)
	{
		Error("SetTgc8 fail!");
		return RET_STATUS::RET_FAILED;
	}
	else
	{
		Info("SetTgc8 success!");
		return RET_STATUS::RET_SUCCEED;
	}
}