PhysicalDevice/Detector/CCOS.Dev.FPDDeviceMould/CCOS.Dev.FPD.SyncUnit.cpp

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

#include "CCOS.Dev.FPDDeviceMould.hpp"
#include "Log4CPP.h"

using namespace CCOS::Dev;
using namespace CCOS::Dev::Detail::Detector;
namespace nsFPD = CCOS::Dev::Detail::Detector;

//extern Log4CPP::Logger* //gLogger;

//-----------------------------------------------------------------------------
//		SyncUnit
//-----------------------------------------------------------------------------
nsFPD::SyncUnit::SyncUnit()
{
	m_strReady4EXP = "";
	m_strXwindowStatus = "";
	m_strXrayON = "";
	m_strConnectStatus = "";
	m_strImageReadingStatus = "";
	m_strSupportSyncMode = "";
}

nsFPD::SyncUnit:: ~SyncUnit()
{

}


void OEM_IF nsFPD::SyncUnit::SetEventCenter(std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter)
{
	m_EventCenter = EventCenter;
}


RET_STATUS nsFPD::SyncUnit::JSSetXwindowSize(std::string in, std::string & out)
{
	//FINFO("JSSetXwindowSize. {$}",in.c_str());

	ResDataObject json;
	json.decode(in.c_str());
	string strXwindow = (string)json[0];
	float XwindowSize = stof(strXwindow.c_str());
	return SetXwindow(XwindowSize);
}

RET_STATUS nsFPD::SyncUnit::JSSetFrameRate(std::string in, std::string& out)
{
	//FINFO("JSSetFrameRate. {$}",in.c_str());

	ResDataObject json;
	json.decode(in.c_str());
	string strFrameRate = (string)json[0];
	float FrameRate = stof(strFrameRate.c_str());
	return SetFrameRate(FrameRate);
}

RET_STATUS nsFPD::SyncUnit::JSSetSyncMode(std::string in, std::string & out)
{
	//FINFO("JSSetSyncMode. {$}",in.c_str());

	ResDataObject json;
	json.decode(in.c_str());
	int mode = json[0];
	int trigger = json[1];
	SYNC_MODE syncMode;
	HARDWARE_TRIGGER_MODE HWtrigger;
		
	if (mode == SYNC_SOFTWARE)
	{
		syncMode = SYNC_SOFTWARE;
	}
	else if (mode == SYNC_HARDWARE)
	{
		syncMode = SYNC_HARDWARE;
	}
	else if (mode == SYNC_AED)
	{
		syncMode = SYNC_AED;
	}
	else if (mode == SYNC_HARDWARE_DIRECT)
	{
		syncMode = SYNC_HARDWARE_DIRECT;
	}
	else
	{
		return RET_STATUS::RET_INVALID;
	}

	 if (trigger == HW_TRIGGER_NONE || trigger == HW_TRIGGER_MAX)
	 {
		 if (mode == SYNC_HARDWARE)
		 {
			 return RET_STATUS::RET_INVALID;
		 }

		 HWtrigger = HW_TRIGGER_NONE;
	 }
	 else if (trigger == HW_TRIGGER_INTERNAL)
	 {
		 HWtrigger = HW_TRIGGER_INTERNAL;
	 }
	 else if (trigger == HW_TRIGGER_EXTERNAL)
	 {
		 HWtrigger = HW_TRIGGER_EXTERNAL;
	 }
	 else
	 {
		return RET_STATUS::RET_INVALID;
	 }
	 
	return SetSyncMode(syncMode, HWtrigger);
}


RET_STATUS nsFPD::SyncUnit::JSGetSyncMode(std::string& out)
{
	SYNC_MODE syncMode = SYNC_MAX;
	GetSyncMode(syncMode);

	auto str = std::to_string(syncMode);
	out = str;
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsFPD::SyncUnit::JSPrepareAcquisition(std::string in, std::string& out)
{
	//FINFO("JSPrepareAcquisition.");
	return PrepareAcquisition();
}

RET_STATUS nsFPD::SyncUnit::JSStartAcquisition(std::string in, std::string& out)
{
	//FINFO("JSStartAcquisition.");
	ResDataObject json;
	json.decode(in.c_str());
	if (json.GetFirstOf("P0") >= 0)
	{
		string strAcqMode = (string)json["P0"];
		return StartAcquisition(strAcqMode);
	}
	else 
	{
		//FINFO("JSStartAcquisition param in is null but it's not error!");
		return StartAcquisition();
	}
}

RET_STATUS nsFPD::SyncUnit::JSStopAcquisition(std::string in, std::string& out)
{
	//FINFO("JSStopAcquisition.");
	return StopAcquisition();
}

RET_STATUS nsFPD::SyncUnit::JSGetFPDReady(std::string & out)
{
	out = m_strReady4EXP;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::SyncUnit::JSSetFPDReady(std::string in)
{
	//FINFO("JSSetFPDReady in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strReady4EXP = in;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::SyncUnit::JSGetConnectStatus(std::string& out)
{
	out = m_strConnectStatus;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::SyncUnit::JSGetXrayON(std::string& out)
{
	out = m_strXrayON;
	return  RET_STATUS::RET_SUCCEED;
}

void OEM_NOTIFY nsFPD::SyncUnit::FPDReadyNotify(bool bReady)
{	
	if (bReady)
	{
		m_strReady4EXP = "1";
		m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::FPDReadyStatus, m_strReady4EXP);
	}
	else
	{
		m_strReady4EXP = "0";
		m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::FPDReadyStatus, m_strReady4EXP);
	}
}

void OEM_NOTIFY nsFPD::SyncUnit::FPDConnectStatusNotify(bool bConnect)
{
	if (bConnect)
	{
		m_strConnectStatus = "2";
		m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::DetectorConnectStatus, m_strConnectStatus);
	}
	else
	{
		m_strConnectStatus = "0";
		m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::DetectorConnectStatus, m_strConnectStatus);
	}
}

RET_STATUS nsFPD::SyncUnit::JSGetXWindowStatus(std::string & out)
{
	out = m_strXwindowStatus;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::SyncUnit::JSSetXWindowStatus(std::string in)
{
	//FINFO("JSSetXWindowStatus in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strXwindowStatus = in;
	return RET_STATUS::RET_SUCCEED;
}

void OEM_NOTIFY nsFPD::SyncUnit::XWindowOnNotify()
{
	//FINFO("XWindowOnNotify");
	auto szFDinfo = std::to_string(XWINDOW_ON);
	m_strXwindowStatus = szFDinfo;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::XwindowStatus, m_strXwindowStatus);
}

void OEM_NOTIFY nsFPD::SyncUnit::XWindowOffNotify()
{
	//FINFO("XWindowOffNotify");
	auto szFDinfo = std::to_string(XWINDOW_OFF);
	m_strXwindowStatus = szFDinfo;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::XwindowStatus, m_strXwindowStatus);
}

void OEM_NOTIFY nsFPD::SyncUnit::FakeEIPONNotify()
{
	m_EventCenter->OnNotify((int)ATTRACTION_SET, "FakeEIPON", "1");
}

void OEM_NOTIFY nsFPD::SyncUnit::XrayOnNotify()
{
	m_strXrayON = "1";
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::XrayON, "1");
}

void OEM_NOTIFY nsFPD::SyncUnit::XrayOffNotify()
{
	m_strXrayON = "0";
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::XrayON, "0");
}

RET_STATUS nsFPD::SyncUnit::JSGetImageReadingStatus(std::string & out)
{
	out = m_strImageReadingStatus;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::SyncUnit::JSSetImageReadingStatus(std::string in)
{
	//FINFO("JSSetImageReadingStatus in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strImageReadingStatus = in;
	return RET_STATUS::RET_SUCCEED;
}

void OEM_NOTIFY nsFPD::SyncUnit::ImageReadingNotify()
{
	std::string str = "0";
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::ImageReadingStatus, str);
}

RET_STATUS nsFPD::SyncUnit::GetSyncMode(SYNC_MODE& nSyncMode)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::SyncUnit::JSGetExpReadyStatus(std::string& out)
{
	out = m_strFPDExpReady;
	//FINFO("JSGetExpReadyStatus {$}", out);
	return RET_STATUS::RET_SUCCEED;
}

void OEM_NOTIFY nsFPD::SyncUnit::ExpReadyNotify(int nMillisecond)
{
	auto szFDinfo = std::to_string(nMillisecond);
	m_strFPDExpReady = szFDinfo;
	m_EventCenter->OnNotify((int)ATTRACTION_MSG, AttrKey::FPDExpReady, m_strFPDExpReady);
}

RET_STATUS nsFPD::SyncUnit::SetFrameRate(float fFrameRate)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::SyncUnit::JSGetSupportSyncMode(std::string& out)
{
	out = m_strSupportSyncMode;
	//FINFO("JSGetSupportSyncMode {$}", out);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::SyncUnit::JSUpdateGENERATORSYNCSTATE(std::string in, std::string& out)
{
	cout << "JSUpdateGENERATORSYNCSTATE: " << in << endl;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::SyncUnit::SetSupportSyncMode(string in)
{
	//FINFO("SetSupportSyncMode {$}", in);
	m_strSupportSyncMode = in;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::SyncUnit::JSActiveSyncMode(std::string in, std::string& out)
{
	//FINFO("JSActiveSyncMode in:{$}", in);
	ResDataObject json;
	json.decode(in.c_str());
	if (json.GetFirstOf("SyncMode") >= 0)
	{
		string strSyncMode = json["SyncMode"].encode();
		int nSyncMode = 1;
		if (strSyncMode == "CMD")
		{
			nSyncMode = 1;
		}
		else if (strSyncMode == "HWS")
		{
			nSyncMode = 2;
		}
		else if (strSyncMode == "AED")
		{
			nSyncMode = 3;
		}
		else 
		{
			//FERROR("not support this sync mode!");
			return RET_STATUS::RET_FAILED;
		}
		//FINFO("nSyncMode:{$}", nSyncMode);
		return ActiveSyncMode(nSyncMode);
	}
	else
	{
		//FERROR("JSActiveSyncMode param is invalid!");
		return RET_STATUS::RET_FAILED;
	}
}

RET_STATUS nsFPD::SyncUnit::ActiveSyncMode(int nSyncMode)
{
	return RET_STATUS::RET_SUCCEED;
}