PhysicalDevice/Machine/MachineryECOM/Trunk/DIOS.Dev.Machinery.Motion.Driver/DIOS.Dev.Machinery.Driver.ECOM/LogicDeviceMechTomo.cpp

#include "stdafx.h"
#include "LogicDeviceMechTomo.h"
#include "IExamHandler.h"
#include "ITomoExamHandler.h"
#include "ICalibrationHandler.h"
#include "IMotionTestHandler.h"
#include "ExamHandlerManager.h"
#include "LogicDriverThreadLocker.h"
#include "PositionManager.h"
#include "WorkFlowManager.h"
#include "ISelfTestHandler.h"
#include "IParkingHandler.h"
#include "ExamHandlerNameDef.h"
#include "DIOS.Dev.Machinery.Driver.ECOM.h"

const string MACHINERY_READY = "MachineryReady";

using namespace DIOS::Dev::Detail::MachineryECOM;

LogicDeviceMechTomo::LogicDeviceMechTomo(MachineryECOMDriver* pMachineryDriver)
	: m_Mode(EXAM_MODE::EXM_SINGLE),
	MotionControlUnit(pMachineryDriver)
{

}


LogicDeviceMechTomo::~LogicDeviceMechTomo()
{
}

/****************************
"DX":
{
	"TOMO": "1"
}

"DX":
{
	"Single": "1"
}
*****************************/
//RET_STATUS LogicDeviceMechTomo::SetExamInfo(ResDataObject& ParamIn)
//{
//	RET_STATUS ret = RET_STATUS::RET_SUCCEED;
//
//	if (ParamIn.IsObject())
//	{
//		if(gbusinessLog) gbusinessLog->Info("[SetExamInfo]->[Enter]");
//
//		if(gbusinessLog) gbusinessLog->Info("[SetExamInfo]->[ParamIn: %s]", ParamIn.encode());
//		const char* pszKey = ParamIn.GetKey(0);
//		if (pszKey)
//		{
//			int idx = m_ExamList.GetFirstOf(pszKey);
//			if (idx >= 0)
//			{
//				m_ExamList[pszKey] = ParamIn[pszKey];
//			}
//			else
//			{
//				//new one
//				m_ExamList.add(pszKey, ParamIn[pszKey]);
//			}
//
//			return RET_STATUS::RET_SUCCEED;
//		}
//	}
//
//	return ret;
//}

/****************************
"P0": "DX"
*****************************/
//RET_STATUS LogicDeviceMechTomo::SelectExamMode(const char *pExamKey)
//{
//	RET_STATUS ret = RET_STATUS::RET_SUCCEED;
//
//	//LogicDriverThreadLocker::Instance()->Lock();
//
//	//const char *pExamType = GetExamType();
//	if(gbusinessLog) gbusinessLog->Info("[SelectExamMode]->[Enter]");
//	const char* pExamType = "DX";
//
//	if(gbusinessLog) gbusinessLog->Info("[SelectExamMode]->[m_ExamList: %s]", m_ExamList.encode());
//
//	pExamType = m_ExamList[pExamKey].GetKey(0);
//
//	if(gbusinessLog) gbusinessLog->Info("[SelectExamMode]->[ExamKey=%s, ExamType=%s]", pExamKey, pExamType);
//
//	m_Mode = (EXAM_MODE)WorkFlowManager::Instance()->ChangeExamMode(pExamKey,pExamType);
//
//	//LogicDriverThreadLocker::Instance()->UnLock();
//
//	if(gbusinessLog) gbusinessLog->Info("[SelectExamMode]->[Leave]");
//
//	return ret;
//}

/****************************
"P0": "TOMO"

"P0": "Single"
*****************************/
RET_STATUS LogicDeviceMechTomo::SetExpMode(const char* pExpMode)
{
	RET_STATUS ret = RET_STATUS::RET_SUCCEED;

	if(gbusinessLog) gbusinessLog->Info("[SetExpMode]->[Enter]");

	const char* pExamType = "DX";

	if(gbusinessLog) gbusinessLog->Info("[SetExpMode]->[ExamKey={$}, ExamType={$}]", pExamType, pExpMode);

	m_Mode = (EXAM_MODE)WorkFlowManager::Instance()->ChangeExamMode(pExamType, pExpMode);

	if(gbusinessLog) gbusinessLog->Info("[SetExpMode]->[Leave]");

	return ret;
}

RET_STATUS LogicDeviceMechTomo::SetWorkStation(const char* pWorkStation)
{
	RET_STATUS ret = RET_STATUS::RET_SUCCEED;

	if (gbusinessLog) gbusinessLog->Info("[SetWorkStation]->[ExamKey={$}]", pWorkStation);

	(EXAM_MODE)WorkFlowManager::Instance()->ChangeWorkstation(pWorkStation);

	return ret;
}

//
//RET_STATUS LogicDeviceMechTomo::BlindRotateMech(FLOAT Angle)
//{
//	RET_STATUS ret = RET_STATUS::RET_FAILED;
//	ITomoExamHandler *handler = (ITomoExamHandler *)ExamHandlerManager::Instance()->GetHandler(TOMO_EXAMHANDLER);
//	if (handler)
//	{
//		ret = handler->OnBlindRotateMech(Angle);
//	}
//
//	return ret;
//}
//
//RET_STATUS LogicDeviceMechTomo::MoveMech(FLOAT Pos)
//{
//	RET_STATUS ret = RET_STATUS::RET_FAILED;
//
//	ITomoExamHandler *handler = (ITomoExamHandler *)ExamHandlerManager::Instance()->GetHandler(TOMO_EXAMHANDLER);
//	if (handler)
//	{
//		ret = handler->OnMoveMech(Pos);
//	}
//
//	return ret;
//
//}
//
//RET_STATUS LogicDeviceMechTomo::RotateMech(FLOAT Angle)
//{
//	RET_STATUS ret = RET_STATUS::RET_FAILED;
//
//	ITomoExamHandler *handler = (ITomoExamHandler *)ExamHandlerManager::Instance()->GetHandler(TOMO_EXAMHANDLER);
//	if (handler)
//	{
//		ret = handler->OnRotateMech(Angle);
//	}
//
//	return ret;
//}
//
RET_STATUS LogicDeviceMechTomo::GetTomoResult(ResDataObject &resultAngle, ResDataObject &resultHeight)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	ITomoExamHandler *handler = (ITomoExamHandler *)ExamHandlerManager::Instance()->GetHandler(TOMO_EXAMHANDLER);
	if (handler)
	{
		ret = handler->OnGetTomoResults(resultAngle, resultHeight);
	}

	return ret;

}
//
//RET_STATUS LogicDeviceMechTomo::ActionMech(FLOAT Pos, FLOAT Angle)
//{
//	RET_STATUS ret = RET_STATUS::RET_FAILED;
//
//	ITomoExamHandler *handler = (ITomoExamHandler *)ExamHandlerManager::Instance()->GetHandler(TOMO_EXAMHANDLER);
//	if (handler)
//	{
//		ret = handler->OnActionMech(Pos, Angle);
//	}
//
//	return ret;
//
//}
//
//RET_STATUS LogicDeviceMechTomo::RESET()
//{
//	RET_STATUS ret = RET_STATUS::RET_SUCCEED;
//
//	return ret;
//
//}
//
//RET_STATUS LogicDeviceMechTomo::StopMech()
//{
//	RET_STATUS ret = RET_STATUS::RET_FAILED;
//
//	//LogicDriverThreadLocker::Instance()->Lock();
//
//	IExamHandler *handler = ExamHandlerManager::Instance()->GetCurrentHandler();
//	if (handler)
//	{
//		ret = handler->OnStopMech();
//	}
//
//	//LogicDriverThreadLocker::Instance()->UnLock();
//
//	return ret;
//}

RET_STATUS LogicDeviceMechTomo::StartMove()
{
	RET_STATUS ret = RET_STATUS::RET_SUCCEED;

	if(gbusinessLog) gbusinessLog->Info("[StartMove]");

	////LogicDriverThreadLocker::Instance()->Lock();

	//IExamHandler *handler = ExamHandlerManager::Instance()->GetCurrentHandler();
	//if (handler)
	//{
	//	ret = handler->OnStartMove();
	//}

	////LogicDriverThreadLocker::Instance()->UnLock();


	return ret;
}

RET_STATUS LogicDeviceMechTomo::StopMove()
{
	RET_STATUS ret = RET_STATUS::RET_SUCCEED;

	if(gbusinessLog) gbusinessLog->Info("[StopMove]");

	return ret;
}

RET_STATUS LogicDeviceMechTomo::FramePrep()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	//LogicDriverThreadLocker::Instance()->Lock();

	IExamHandler *handler = ExamHandlerManager::Instance()->GetCurrentHandler();
	if (handler)
	{
		ret = handler->OnFramePrep();
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;

}

RET_STATUS LogicDeviceMechTomo::FrameReady()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	//LogicDriverThreadLocker::Instance()->Lock();

	IExamHandler *handler = ExamHandlerManager::Instance()->GetCurrentHandler();
	if (handler)
	{
		ret = handler->OnFrameReady();
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::FrameAcq()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[FrameAcq]");

	//LogicDriverThreadLocker::Instance()->Lock();

	IExamHandler *handler = ExamHandlerManager::Instance()->GetCurrentHandler();
	if (handler)
	{
		ret = handler->OnFrameAcq();
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::FrameStart()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	//LogicDriverThreadLocker::Instance()->Lock();

	IExamHandler *handler = ExamHandlerManager::Instance()->GetCurrentHandler();
	if (handler)
	{
		ret = handler->OnFrameStart();
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::FrameEnd()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	//LogicDriverThreadLocker::Instance()->Lock();

	IExamHandler *handler = ExamHandlerManager::Instance()->GetCurrentHandler();
	if (handler)
	{
		ret = handler->OnFrameEnd();
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::FramePost()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	//LogicDriverThreadLocker::Instance()->Lock();

	IExamHandler *handler = ExamHandlerManager::Instance()->GetCurrentHandler();
	if (handler)
	{
		ret = handler->OnFramePost();
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::FrameError()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	//LogicDriverThreadLocker::Instance()->Lock();

	IExamHandler *handler = ExamHandlerManager::Instance()->GetCurrentHandler();
	if (handler)
	{
		ret = handler->OnFrameError();
	}

	//LogicDriverThreadLocker::Instance()->UnLock();


	return ret;
}

nDev::RET_STATUS LogicDeviceMechTomo::FrameIn()
{
	return RET_STATUS::RET_FAILED;
}

//RET_STATUS LogicDeviceMechTomo::FrameRecover()
//{
//	RET_STATUS ret = RET_STATUS::RET_FAILED;
//
//	//LogicDriverThreadLocker::Instance()->Lock();
//
//	IExamHandler *handler = ExamHandlerManager::Instance()->GetCurrentHandler();
//	if (handler)
//	{
//		ret = handler->OnFrameRecover();
//	}
//
//	//LogicDriverThreadLocker::Instance()->UnLock();
//
//
//	return ret;
//}

RET_STATUS LogicDeviceMechTomo::SeqError()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	//LogicDriverThreadLocker::Instance()->Lock();

	IExamHandler *handler = ExamHandlerManager::Instance()->GetCurrentHandler();
	if (handler)
	{
		ret = handler->OnSeqError();
	}

	//LogicDriverThreadLocker::Instance()->UnLock();


	return ret;
}

RET_STATUS LogicDeviceMechTomo::SeqEnd()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	//LogicDriverThreadLocker::Instance()->Lock();

	IExamHandler *handler = ExamHandlerManager::Instance()->GetCurrentHandler();
	if (handler)
	{
		ret = handler->OnSeqEnd();
	}

	//LogicDriverThreadLocker::Instance()->UnLock();


	return ret;
}

RET_STATUS LogicDeviceMechTomo::SetFrameRate(FLOAT frameRate)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	//LogicDriverThreadLocker::Instance()->Lock();

	IExamHandler *handler = ExamHandlerManager::Instance()->GetCurrentHandler();
	if (handler)
	{
		ret = handler->OnSetFrameRate(frameRate);
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::SetTechParamsInfo(ResDataObject &ParamIn)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	//LogicDriverThreadLocker::Instance()->Lock();

	IExamHandler *handler = (IExamHandler *)ExamHandlerManager::Instance()->GetCurrentHandler();
	if (handler)
	{
		ret = handler->OnSetTechParamsInfo(ParamIn);
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

bool LogicDeviceMechTomo::GetMachineryReadyState()
{
	return PositionManager::Instance()->IsSystemReady();
}

int LogicDeviceMechTomo::GetMachineryTomoMotionLimitationState()
{
	return PositionManager::Instance()->IsTomoMotionLimitationStatus();
}

RET_STATUS LogicDeviceMechTomo::NotifyMachineryReadyState(bool bMachineryReady)
{
	m_MachineryReady[AttrKey::MachineryReady] = bMachineryReady;
	
	m_pMachineryDriver->FireNotify(AttrKey::MachineryReady, to_string(bMachineryReady));

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS LogicDeviceMechTomo::NotifyMachineryTechParams(float tid, float sid, int project, float angle, int direction, std::string geometry)
{
	m_MachineryTID[AttrKey::MachineryTID] = tid;
	m_pMachineryDriver->FireNotify(AttrKey::MachineryTID, to_string(tid));

	m_MachinerySID[AttrKey::MachinerySID] = sid;
	m_pMachineryDriver->FireNotify(AttrKey::MachinerySID, to_string(sid));

	m_MachineryProjectionNumber[AttrKey::MachineryProjectionNumber] = project;
	m_pMachineryDriver->FireNotify(AttrKey::MachineryProjectionNumber, to_string(project));

	m_MachineryScanAngle[AttrKey::MachineryScanAngle] = angle;
	m_pMachineryDriver->FireNotify(AttrKey::MachineryScanAngle, to_string(angle));

	m_MachineryScanDirection[AttrKey::MachineryScanDirection] = direction;
	m_pMachineryDriver->FireNotify(AttrKey::MachineryScanDirection, to_string(direction));

	m_MachineryScanGeometry[AttrKey::MachineryScanGeometry] = geometry.c_str();
	m_pMachineryDriver->FireNotify(AttrKey::MachineryScanGeometry, geometry);
	
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS LogicDeviceMechTomo::EnterCalibration()
{
	//LogicDriverThreadLocker::Instance()->Lock();

	WorkFlowManager::Instance()->EnterCalibration();

	//LogicDriverThreadLocker::Instance()->UnLock();

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS LogicDeviceMechTomo::ExitCalibration()
{
	//LogicDriverThreadLocker::Instance()->Lock();

	WorkFlowManager::Instance()->ExitCalibration();

	//LogicDriverThreadLocker::Instance()->UnLock();

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS LogicDeviceMechTomo::CalMotionTubeLineV(ResDataObject &ParamIn)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	ICalibrationHandler *handler = (ICalibrationHandler *)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnMoveTubeHeight(ParamIn);
	}

	return ret;
}

RET_STATUS LogicDeviceMechTomo::CalMotionTubeAngleRotate(ResDataObject &ParamIn)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	//LogicDriverThreadLocker::Instance()->Lock();

	ICalibrationHandler *handler = (ICalibrationHandler *)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnRotateTubeAngle(ParamIn);
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::CalMotionTubeAngleFindeAxisZ(ResDataObject &ParamIn)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	return ret;
}

RET_STATUS LogicDeviceMechTomo::CalGetADofTubeLineV(ResDataObject &ParamOut)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	//LogicDriverThreadLocker::Instance()->Lock();

	ICalibrationHandler *handler = (ICalibrationHandler *)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnGetTubeHeightAD(ParamOut);
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::CalGetADofDetector(ResDataObject &ParamOut)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	//LogicDriverThreadLocker::Instance()->Lock();

	ICalibrationHandler *handler = (ICalibrationHandler *)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnGetDetectorHeightAD(ParamOut);
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::CalGetADofTubeAngle(ResDataObject &ParamOut)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	//LogicDriverThreadLocker::Instance()->Lock();

	ICalibrationHandler *handler = (ICalibrationHandler *)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnGetTubeAngleAD(ParamOut);
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::CalSaveParamsofTubeLiveV(ResDataObject &ParamIn, ResDataObject &pParamOut)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	ICalibrationHandler *handler = (ICalibrationHandler *)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnSaveTubeHeightADCalibrationResult(ParamIn, pParamOut);
	}

	return ret;
}

RET_STATUS LogicDeviceMechTomo::CalSaveParamsofTubeAngle(ResDataObject &ParamIn, ResDataObject &pParamOut)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	//LogicDriverThreadLocker::Instance()->Lock();

	ICalibrationHandler *handler = (ICalibrationHandler *)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnSaveTubeAngleADCalibrationResult(ParamIn, pParamOut);
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::CalSaveParamsofDetector(ResDataObject &ParamIn, ResDataObject &pParamOut)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[CalSaveParamsofDetector]");

	//LogicDriverThreadLocker::Instance()->Lock();

	ICalibrationHandler *handler = (ICalibrationHandler *)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnSaveDetectorADCalibrationResult(ParamIn, pParamOut);
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::CalGetEncoderofTubeLineV(ResDataObject &ParamOut)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[CalGetEncoderofTubeLineV]");

	//LogicDriverThreadLocker::Instance()->Lock();

	ICalibrationHandler *handler = (ICalibrationHandler *)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnGetTubeHeightEncoder(ParamOut);
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS  LogicDeviceMechTomo::CalGetEncoderofTubeAngle(ResDataObject &ParamOut)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[CalGetEncoderofTubeAngle]");

	//LogicDriverThreadLocker::Instance()->Lock();

	ICalibrationHandler *handler = (ICalibrationHandler *)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnGetTubeAngleEncoder(ParamOut);
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::CalSaveEncoderCorrectonofTubeLiveV(ResDataObject &ParamIn, ResDataObject &pParamOut)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[CalSaveEncoderCorrectonofTubeLiveV]");

	return ret;
}

RET_STATUS LogicDeviceMechTomo::CalSetADLimitationofEncoder(ResDataObject &ParamIn)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[CalSetADLimitationofEncoder]");

	return ret;
}

RET_STATUS LogicDeviceMechTomo::AutoADCalibration(ResDataObject &ParamIn)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[AutoADCalibration]");

	//LogicDriverThreadLocker::Instance()->Lock();

	ICalibrationHandler *handler = (ICalibrationHandler *)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnAutoCalibrationAD(ParamIn);
	}

	//LogicDriverThreadLocker::Instance()->UnLock();


	return ret;
}

RET_STATUS LogicDeviceMechTomo::SetSvoStatus(ResDataObject &ParamIn)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[SetSvoStatus]");

	//LogicDriverThreadLocker::Instance()->Lock();

	ICalibrationHandler *handler = (ICalibrationHandler *)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnSwitchSvoStatus(ParamIn);
	}

	//LogicDriverThreadLocker::Instance()->UnLock();


	return ret;
}

RET_STATUS LogicDeviceMechTomo::EnterMechnicalSelfTest()
{
	//LogicDriverThreadLocker::Instance()->Lock();

	WorkFlowManager::Instance()->EnterSelfTest();

	//LogicDriverThreadLocker::Instance()->UnLock();

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS LogicDeviceMechTomo::ExitMechnicalSelfTest()
{
	//LogicDriverThreadLocker::Instance()->Lock();

	WorkFlowManager::Instance()->ExitSelfTest();

	//LogicDriverThreadLocker::Instance()->UnLock();

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS LogicDeviceMechTomo::StartSelfTest(ResDataObject &ParamIn)
{
	//LogicDriverThreadLocker::Instance()->Lock();

	ISelfTestHandler *handler = (ISelfTestHandler *)ExamHandlerManager::Instance()->GetHandler(SELF_TEST_HANDLER);
	if (handler)
	{
		handler->OnStartSelfTest(ParamIn);
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS LogicDeviceMechTomo::ParkingTo(ResDataObject &ParamIn)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[ParkingTo]");

	//LogicDriverThreadLocker::Instance()->Lock();

	IParkingHandler *handler = (IParkingHandler *)ExamHandlerManager::Instance()->GetHandler(PARKING_HANDLER);
	if (handler)
	{
		WorkFlowManager::Instance()->EnterParking();
		ret = handler->OnStartParking(ParamIn);
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::ActiveTubeAngleZAxisClear()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[ActiveTubeAngleZAxisClear]");

	//LogicDriverThreadLocker::Instance()->Lock();

	ICalibrationHandler *handler = (ICalibrationHandler *)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnActiveTubeAngleZAxisClear();
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::CancelTubeAngleZAxisClear()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[CancelTubeAngleZAxisClear]");

	//LogicDriverThreadLocker::Instance()->Lock();

	ICalibrationHandler *handler = (ICalibrationHandler *)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnCancleTubeAngleZAxisClear();
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::ActiveTubeHeightZAxisClear()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[ActiveTubeHeightZAxisClear]");

	//LogicDriverThreadLocker::Instance()->Lock();

	ICalibrationHandler *handler = (ICalibrationHandler *)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnActiveTubeHeightZAxisClear();
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::CancelTubeHeightZAxisClear()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[CancelTubeHeightZAxisClear]");

	//LogicDriverThreadLocker::Instance()->Lock();

	ICalibrationHandler *handler = (ICalibrationHandler *)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnCancelTubeHeightZAxisClear();
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::TubeAngleRotateToZAxis()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[TubeAngleRotateToZAxis]");

	//LogicDriverThreadLocker::Instance()->Lock();

	ICalibrationHandler *handler = (ICalibrationHandler *)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnTubeAngleRotateToZAxis();
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::TubeHeightMoveToZAxis()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[TubeHeightMoveToZAxis]");

	//LogicDriverThreadLocker::Instance()->Lock();

	ICalibrationHandler *handler = (ICalibrationHandler *)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnTubeHeightMoveToZAxis();
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::ForceStopAllMotion()
{
	if(gbusinessLog) gbusinessLog->Info("[ForceStopAllMotion]");

	//LogicDriverThreadLocker::Instance()->Lock();

	auto handler = WorkFlowManager::Instance()->GetCurrentWorkFlowHandler();
	if (handler)
	{
		handler->OnStopMech();
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS LogicDeviceMechTomo::MotionTest_StartTubeLineVMotion2Target(ResDataObject &ParamIn)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[MotionTest_StartTubeLineVMotion2Target]");

	//LogicDriverThreadLocker::Instance()->Lock();

	IMotionTestHandler *handler = (IMotionTestHandler *)ExamHandlerManager::Instance()->GetHandler(MOTIONTEST_HANDLER);
	if (handler)
	{
		ret = handler->OnStartTubeLineVMotion2Target(ParamIn);
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::MotionTest_StopLineVMotion(ResDataObject &ParamIn)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[MotionTest_StopLineVMotion]");

	//LogicDriverThreadLocker::Instance()->Lock();

	IMotionTestHandler *handler = (IMotionTestHandler *)ExamHandlerManager::Instance()->GetHandler(MOTIONTEST_HANDLER);
	if (handler)
	{
		ret = handler->OnStopLineVMotion(ParamIn);
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::MotionTest_TubeAngleRotate2Target(ResDataObject &ParamIn)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[MotionTest_TubeAngleRotate2Target]");

	//LogicDriverThreadLocker::Instance()->Lock();

	IMotionTestHandler *handler = (IMotionTestHandler *)ExamHandlerManager::Instance()->GetHandler(MOTIONTEST_HANDLER);
	if (handler)
	{
		ret = handler->OnTubeAngleRotate2Target(ParamIn);
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::MotionTest_StopRotation(ResDataObject &ParamIn)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[MotionTest_StopRotation]");

	//LogicDriverThreadLocker::Instance()->Lock();

	IMotionTestHandler *handler = (IMotionTestHandler *)ExamHandlerManager::Instance()->GetHandler(MOTIONTEST_HANDLER);
	if (handler)
	{
		ret = handler->OnStopRotation(ParamIn);
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::MotionTest_BindRotationEncoder(ResDataObject &ParamIn)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[MotionTest_BindRotationEncoder]");

	//LogicDriverThreadLocker::Instance()->Lock();

	IMotionTestHandler *handler = (IMotionTestHandler *)ExamHandlerManager::Instance()->GetHandler(MOTIONTEST_HANDLER);
	if (handler)
	{
		ret = handler->OnBindRotationEncoder(ParamIn);
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::MotionTest_UnbindRotationEncoder(ResDataObject &ParamIn)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[MotionTest_UnbindRotationEncoder]");

	//LogicDriverThreadLocker::Instance()->Lock();

	IMotionTestHandler *handler = (IMotionTestHandler *)ExamHandlerManager::Instance()->GetHandler(MOTIONTEST_HANDLER);
	if (handler)
	{
		ret = handler->OnUnbindRotationEncoder(ParamIn);
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::MotionTest_SystemInitial(ResDataObject &ParamIn)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[MotionTest_SystemInitial]");

	//LogicDriverThreadLocker::Instance()->Lock();

	IMotionTestHandler *handler = (IMotionTestHandler *)ExamHandlerManager::Instance()->GetHandler(MOTIONTEST_HANDLER);
	if (handler)
	{
		ret = handler->OnSystemInitial(ParamIn);
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::MotionTest_TubeCenterAlign(ResDataObject &ParamIn)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[MotionTest_TubeCenterAlign]");

	//LogicDriverThreadLocker::Instance()->Lock();

	IMotionTestHandler *handler = (IMotionTestHandler *)ExamHandlerManager::Instance()->GetHandler(MOTIONTEST_HANDLER);
	if (handler)
	{
		ret = handler->OnTubeCenterAlign(ParamIn);
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::MotionTest_Move2ParkingPosition(ResDataObject &ParamIn)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if(gbusinessLog) gbusinessLog->Info("[MotionTest_Move2ParkingPosition]");

	//LogicDriverThreadLocker::Instance()->Lock();

	IMotionTestHandler *handler = (IMotionTestHandler *)ExamHandlerManager::Instance()->GetHandler(MOTIONTEST_HANDLER);
	if (handler)
	{
		ret = handler->OnMoveToParkingPosition(ParamIn);
	}

	//LogicDriverThreadLocker::Instance()->UnLock();

	return ret;
}

RET_STATUS LogicDeviceMechTomo::CenterAdjust(ResDataObject& ParamIn)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	ICalibrationHandler* handler = (ICalibrationHandler*)ExamHandlerManager::Instance()->GetHandler(SINGLE_EXAMHANDLER);
	if (handler)
	{
		ret = handler->OnCenterAdjust(MECH_ALL);
	}

	return ret;
}

RET_STATUS LogicDeviceMechTomo::QueryAlignStatus(ResDataObject& ParamIn)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	return ret;
}

RET_STATUS LogicDeviceMechTomo::NotifyMachineryAlignStatus(bool bSystemAlign)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	return ret;
}


nDev::RET_STATUS LogicDeviceMechTomo::CalMotionTubeLineH(ResDataObject& ParamIn)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	ICalibrationHandler* handler = (ICalibrationHandler*)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnMoveTubeHorizontal(ParamIn);
	}

	return ret;
}

nDev::RET_STATUS LogicDeviceMechTomo::CalGetADofTubeLineH(ResDataObject& ParamOut)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (gbusinessLog) gbusinessLog->Info("[CalGetADofTubeLineH]");

	ICalibrationHandler* handler = (ICalibrationHandler*)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnGetTubeHorizontalAD(ParamOut);
	}

	return ret;
}

nDev::RET_STATUS LogicDeviceMechTomo::CalGetEncoderofTubeLineH(ResDataObject& ParamOut)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (gbusinessLog) gbusinessLog->Info("[CalGetEncoderofTubeLineH]");

	ICalibrationHandler* handler = (ICalibrationHandler*)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnGetTubeHorizontalEncoder(ParamOut);
	}

	return ret;
}

nDev::RET_STATUS LogicDeviceMechTomo::CalGetADofHorizontalDetector(ResDataObject& ParamOut)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	ICalibrationHandler* handler = (ICalibrationHandler*)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnGetDetectorHorizontalAD(ParamOut);
	}

	return ret;
}
nDev::RET_STATUS LogicDeviceMechTomo::CalSaveParamsofTubeLiveH(ResDataObject& ParamIn, ResDataObject& ParamOut)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	ICalibrationHandler* handler = (ICalibrationHandler*)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnSaveTubeHorizontalADCalibrationResult(ParamIn, ParamOut);
	}

	return ret;
}

nDev::RET_STATUS LogicDeviceMechTomo::CalSaveParamsofDetectorHorizontal(ResDataObject& ParamIn, ResDataObject& ParamOut)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	ICalibrationHandler* handler = (ICalibrationHandler*)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnSaveDetectorHorizontalADCalibrationResult(ParamIn, ParamOut);
	}

	return ret;
}

nDev::RET_STATUS LogicDeviceMechTomo::CalSaveResetLowPosition(ResDataObject& ParamIn, ResDataObject& ParamOut)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	ICalibrationHandler* handler = (ICalibrationHandler*)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnSaveResetLowPosition(ParamIn, ParamOut);
	}

	return ret;
}

nDev::RET_STATUS LogicDeviceMechTomo::CalSaveResetEcoderZeroPosition(ResDataObject& ParamIn, ResDataObject& ParamOut)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	ICalibrationHandler* handler = (ICalibrationHandler*)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnSaveResetEncorderZeroPosition(ParamIn, ParamOut);
	}

	return ret;
}

nDev::RET_STATUS LogicDeviceMechTomo::CalGetResetPosParam(ResDataObject& ParamIn, ResDataObject& ParamOut)
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	ICalibrationHandler* handler = (ICalibrationHandler*)ExamHandlerManager::Instance()->GetHandler(CALIBRATION_HANDLER);
	if (handler)
	{
		ret = handler->OnGetResetPosition(ParamIn, ParamOut);
	}

	return ret;
}

nDev::RET_STATUS LogicDeviceMechTomo::RecalculateTomoMotionParam()
{
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	ITomoExamHandler* handler = (ITomoExamHandler*)ExamHandlerManager::Instance()->GetHandler(TOMO_EXAMHANDLER);
	if (handler)
	{
		ret = handler->OnRecalculateTomoMotionParam();
	}

	return ret;
}