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

#include "stdafx.h"
#include "NormalExamHandler.h"
#include "IMotionModel.h"
#include "MotionStages.h"
#include "IMotionModelManager.h"
#include "ConfigurerMotion.h"
#include "ConfigurerPositionCode.h"
#include "LogicDeviceHandSwitch.h"
#include "LogicDeviceManager.h"
#include "IPositionManager.h"
#include "MechnicalMonitor.h"
#include "IMotionStageArgs.h"
#include "RADMotionStageArgs.h"
#include "ConfigurerWS.h"

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

NormalExamHandler::NormalExamHandler() 
:m_handSwitchState(HS_NONE),
m_modelLoaded(FALSE),
m_postionManager(nullptr),
m_modelManager(nullptr),
m_bSendHandswitchStatusAfterCenterAdjust(TRUE)
{
}


NormalExamHandler::~NormalExamHandler()
{
}

void NormalExamHandler::OnModelLoaded(IMotionModelManager *modelManager)
{
	m_modelManager = modelManager;
}

void NormalExamHandler::OnCoordinatesLoaded(IPositionManager *coordinates)
{
	m_postionManager = coordinates;
}

void NormalExamHandler::OnMotionEvent(const std::string &motionEventName)
{
	auto model = m_modelManager->Resove(MOTION_MODEL_RAD);
	auto args = model->GetStageArgs();
	auto stageName = model->GetStageName();

	if (motionEventName == MONITOR_EVENT_TUBEANGLE_MOVE_STOP)
	{
		if (gmotionLog) gmotionLog->Info("[NormalExamHandler][OnMotionEvent]->[Tube Angle Motion Stop]");

		args->SetTubeAngleMotionStatus(FALSE);
	}
	else if (motionEventName == MONITOR_EVENT_TUBEHEIGHT_MOVE_STOP)
	{
		if (gmotionLog) gmotionLog->Info("[NormalExamHandler][OnMotionEvent]->[Tube Height Motion Stop]");

		args->SetTubeHeightMotionStatus(FALSE);

		if (stageName == RAD_STAGE_ADJUST_SID_MOVE)
		{
			ChangeMotionModelStage(RAD_STAGE_CENTER_ADJUST);
		}
	}
	else if (motionEventName == MONITOR_EVENT_TUBEHORIZONTAL_MOVE_STOP)
	{
		if (gmotionLog) gmotionLog->Info("[NormalExamHandler][OnMotionEvent]->[Tube Horizontal Motion Stop]");

		args->SetTubeHorizontalMotionStatus(FALSE);

		if (stageName == RAD_STAGE_ADJUST_SID_MOVE)
		{
			ChangeMotionModelStage(RAD_STAGE_CENTER_ADJUST);
		}
	}

	if (stageName == RAD_STAGE_CENTER_ADJUST)
	{
		if (args->IsMotionStoped())
		{
			m_postionManager->NotifyAlignStatus(TRUE);

			printf("[NormalExamHandler][OnMotionEvent]->[SendHandswitchStatusAfterCenterAdjust = %d]\n", m_bSendHandswitchStatusAfterCenterAdjust);

			if (m_bSendHandswitchStatusAfterCenterAdjust)
			{
				TransferHandSwitchState(HSW_FIRST_DOWN);

				if (m_handSwitchState == HS_GEAR_SECOND_PRESSED)
				{
					TransferHandSwitchState(HSW_SECOND_DOWN);
				}
			}

			m_bSendHandswitchStatusAfterCenterAdjust = TRUE;
			printf("[NormalExamHandler][OnMotionEvent]->[SendHandswitchStatusAfterCenterAdjust %s]\n", "TRUE");
		}
	}
}

RET_STATUS NormalExamHandler::OnStopMech()
{
	ChangeMotionModelStage(RAD_STAGE_STOP_MOVE);

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS NormalExamHandler::OnSelectExamMode(const char *pExamKey)
{
	ChangeMotionModelStage(RAD_STAGE_CLEAR_PARAMS);

	if (!m_modelLoaded)
	{
		auto model = m_modelManager->Resove(MOTION_MODEL_RAD);
		if (model)
		{
			ResDataObject radparms;
			if (ConfigurerMotion::GetSingleRADConfigs(radparms))
			{
				model->LoadModelParams(radparms);
			}
			ResDataObject mechparms;
			if (ConfigurerMotion::GetMachineryConfigs(mechparms))
			{
				model->LoadMachineryParams(mechparms);
			}

			m_modelLoaded = TRUE;
		}
	}

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS NormalExamHandler::OnSetTechParamsInfo(ResDataObject &pParam)
{
	ResDataObject technicals;
	if (ParseTechnicalParams(pParam, technicals))
	{
		auto model = m_modelManager->Resove(MOTION_MODEL_RAD);
		if (model)
		{
			model->SetTechnicalParams(technicals);
		}
	}

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS NormalExamHandler::OnFrameError()
{
	IExamHandler::OnFrameError();

	ChangeMotionModelStage(RAD_STAGE_STOP_MOVE);

	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS NormalExamHandler::OnFrameRecover()
{
	IExamHandler::OnFrameRecover();

	ChangeMotionModelStage(RAD_STAGE_STOP_MOVE);

	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS NormalExamHandler::OnSeqError()
{
	IExamHandler::OnSeqError();

	ChangeMotionModelStage(RAD_STAGE_STOP_MOVE);

	return RET_STATUS::RET_SUCCEED;
}

void NormalExamHandler::OnHandSwitchGearFirstPressed()
{
	m_handSwitchState = HS_GEAR_FIRST_PRESSED;

	printf("[NormalExamHandler][OnHandSwitchGearFirstPressed]\n");

	if (ConfigurerWS::IsDoubleWorkstation())
	{
		ChangeMotionModelStage(RAD_STAGE_ADJUST_SID_MOVE);
	}
	else
	{
		ChangeMotionModelStage(RAD_STAGE_CENTER_ADJUST);
	}
}

void NormalExamHandler::OnHandSwitchGearFirstReleased()
{
	m_handSwitchState = HS_GEAR_FIRST_RELEASED;

	printf("[NormalExamHandler][OnHandSwitchGearFirstReleased]\n");

	ChangeMotionModelStage(RAD_STAGE_STOP_MOVE);

	TransferHandSwitchState(HSW_FIRST_UP);
}

void NormalExamHandler::OnHandSwitchGearSecondPressed()
{
	if(gbusinessLog) gbusinessLog->Info("[NormalExamHandler][OnHandSwitchGearSecondPressed]->[Enter][{$:d}]", m_handSwitchState);

	if (m_handSwitchState != HS_GEAR_FIRST_PRESSED)
	{
		return;
	}

	m_handSwitchState = HS_GEAR_SECOND_PRESSED;

	auto model = m_modelManager->Resove(MOTION_MODEL_RAD);
	auto args = model->GetStageArgs();
	printf("[NormalExamHandler][OnHandSwitchGearSecondPressed]\n");
	if (args->IsMotionStoped())
	{
		printf("[NormalExamHandler][OnHandSwitchGearSecondPressed][MotionStoped]\n");
		TransferHandSwitchState(HSW_SECOND_DOWN);
	}

	if(gbusinessLog) gbusinessLog->Info("[NormalExamHandler][OnHandSwitchGearSecondPressed]->[Exit][{$:d}]", (int)args->IsMotionStoped());
}

void NormalExamHandler::OnHandSwitchGearSecondReleased()
{
	printf("[NormalExamHandler][OnHandSwitchGearSecondReleased]\n");

	m_handSwitchState = HS_GEAR_SECOND_RELEASED;

	TransferHandSwitchState(HSW_SECOND_UP);
}

void NormalExamHandler::ChangeMotionModelStage(const std::string &stageName)
{
	auto model = m_modelManager->Resove(MOTION_MODEL_RAD);
	if (model)
	{
		model->ChangeStage(stageName);
		if (stageName == RAD_STAGE_ADJUST_SID_MOVE)
		{
			if (m_CurWS == WS_WALL)
			{
				auto stageArgs = model->GetStageArgs();
				stageArgs->SetTubeHorizontalMotionStatus(TRUE);
				MechnicalMonitor::Instance()->BeginMonitor(this, MO_TUBE_HORIZONTAL);
			}
			else if (m_CurWS == WS_TABLE)
			{
				auto stageArgs = model->GetStageArgs();
				stageArgs->SetTubeHeightMotionStatus(TRUE);
				MechnicalMonitor::Instance()->BeginMonitor(this, MO_TUBE_HEIGHT);
			}
		}
		else if (stageName == RAD_STAGE_CENTER_ADJUST)
		{
			auto stageArgs = model->GetStageArgs();
			if (!ConfigurerWS::IsDoubleWorkstation())
			{
				stageArgs->SetTubeHorizontalMotionStatus(FALSE);
				stageArgs->SetTubeAngleMotionStatus(TRUE);
				stageArgs->SetTubeHeightMotionStatus(TRUE);
				MechnicalMonitor::Instance()->BeginMonitor(this, MO_TUBE_HEIGHT);
				MechnicalMonitor::Instance()->BeginMonitor(this, MO_TUBE_ANGLE);
			}
			else
			{
				stageArgs->SetTubeAngleMotionStatus(TRUE);
				stageArgs->SetTubeHeightMotionStatus(TRUE);
				MechnicalMonitor::Instance()->BeginMonitor(this);
			}
		}
	}
}

BOOL NormalExamHandler::ParseTechnicalParams(ResDataObject &paramIn, ResDataObject &paramOut)
{
	if(gbusinessLog) gbusinessLog->Info("[ParseTechnicalParams]->[{$}]", paramIn.encode());
	try
	{
		if (paramIn.GetFirstOf("SID") < 0)
		{
			if(gbusinessLog) gbusinessLog->Error("[ParseTechnicalParams][SID is not exist]");

			return FALSE;
		}

		if (paramIn.GetFirstOf("PositionNumber") < 0)
		{
			if(gbusinessLog) gbusinessLog->Error("[ParseTechnicalParams]->[PositionNumber is not exist][{$}]", paramIn.encode());

			return FALSE;
		}

		std::string strCode = (const char *)paramIn["PositionNumber"];
		int nCode = atoi(strCode.c_str());

		ResDataObject PositionCodeParam;
		if (!ConfigurerPositionCode::GetPositionCodeConfigs(PositionCodeParam))
		{
			if(gbusinessLog) gbusinessLog->Error("[ParseTechnicalParams]->[PositionCode is not exist]");

			return FALSE;
		}

		paramOut.clear();
		std::string strKey = "PC" + strCode;
		if (PositionCodeParam.GetFirstOf(strKey.c_str()) >= 0)
		{
			//0到20000之间是单张点片的position code范围
			if (nCode > 0 && nCode < 20000)
			{
				ResDataObject pcset;
				pcset = PositionCodeParam[strKey.c_str()];

				paramOut.add("TubeDesAngle",pcset["TubeDesAngle"]);
				paramOut.add("TubeDesHeight",pcset["TubeDesHeight"]);
				paramOut.add("IsTubeSameHeightWithDetector",(bool)atoi((const char *)pcset["IsTubeSameHeightWithDetector"]));
			}
		}
		else
		{
			paramOut.add("TubeDesAngle",0.0f);
			paramOut.add("TubeDesHeight", 1.1f);
			paramOut.add("IsTubeSameHeightWithDetector", true);
		}

		return TRUE;
	}
	catch (ResDataObjectExption &exp)
	{
		if(gbusinessLog) gbusinessLog->Error("[ParseTechnicalParams][Exception]->[{$}]",exp.what());
	}
	catch (...)
	{
		if(gbusinessLog) gbusinessLog->Error("[ParseTechnicalParams][Exception]->[Unknown]");
	}

	return FALSE;
}

void NormalExamHandler::TransferHandSwitchState(int status)
{
	auto hswDevice = (LogicDeviceHandSwitch *)LogicDeviceManager::Instance()->Resove(LOGICDEVICE_MECH_HSW);
	if (hswDevice)
	{
		string signalname[4] = {"HSW_FIRST_DOWN", "HSW_FIRST_UP", "HSW_SECOND_DOWN", "HSW_SECOND_UP"};

		if (status > -1 & status < 4)
		{
			if (gbusinessLog) gbusinessLog->Info("[NormalExamHandler][TransferHandSwitchState]->[{$:d}, {$}]", status, signalname[status]);
			printf("[NormalExamHandler][TransferHandSwitchState]->[%d, %s]\n", status, signalname[status]);
		}

		hswDevice->SwitchState((HANDSWITCH_STATUS)status);
	}
}

BOOL NormalExamHandler::IsMovingEnable()
{
	BOOL bRes = TRUE;

	if (m_bMachineMoving)
	{
		if (gbusinessLog) gbusinessLog->Warn("[NormalExamHandler][IsMovingEnable]->[Machine is moving, single motion is not allowed]");

		bRes = FALSE;
	}

	return bRes;
}

RET_STATUS NormalExamHandler::OnStartMove(DOF_MECH mech, int nOrientation)
{
	auto model = m_modelManager->Resove(MOTION_MODEL_RAD);
	if (!model)
	{
		return RET_STATUS::RET_FAILED;
	}

	if (!IsMovingEnable())
	{
		return RET_STATUS::RET_FAILED;
	}

	auto modelArgs = (RADMotionStageArgs*) model->GetStageArgs();

	if (mech == TOMO_TUBE_HEIGHT)
	{
		modelArgs->TubeHeightDirection = nOrientation;
		modelArgs->TubeHeightStep = -1;

		if (gbusinessLog) gbusinessLog->Info("[NormalExamHandler][OnStartMove]->[Enter][TOMO_TUBE_HEIGHT][Org: {$:d}]", modelArgs->TubeHeightDirection);

		model->ChangeStage(RAD_STAGE_MOVE_TUBE_HEIGHT);
	}
	else if (mech == TOMO_TUBE_HORIZONTAL)
	{
		modelArgs->TubeHorizontalMoveDirection = nOrientation;
		modelArgs->TubeHorizontalMoveStep = -1;

		if (gbusinessLog) gbusinessLog->Info("[NormalExamHandler][OnStartMove]->[Enter][TOMO_TUBE_HORIZONTAL][Org: {$:d}]", modelArgs->TubeHeightDirection);

		model->ChangeStage(RAD_STAGE_MOVE_TUBE_HORIZONTAL);
	}
	else if (mech == TOMO_TUBE_ANGLE)
	{
		modelArgs->TubeAngleDirection = nOrientation;
		modelArgs->TubeAngleStep = -1;

		if (gbusinessLog) gbusinessLog->Info("[NormalExamHandler][OnStartMove]->[Enter][TOMO_TUBE_ANGLE][Org: {$:d}]", modelArgs->TubeAngleDirection);

		model->ChangeStage(RAD_STAGE_MOVE_TUBE_ROTATION);
	}

	m_bMachineMoving = TRUE;

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

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS NormalExamHandler::OnStopMove(DOF_MECH mech)
{
	if (gbusinessLog) gbusinessLog->Info("[NormalExamHandler][OnStopMove]->[Enter]");

	auto model = m_modelManager->Resove(MOTION_MODEL_RAD);
	if (!model)
	{
		return RET_STATUS::RET_FAILED;
	}

	model->ChangeStage(RAD_STAGE_STOP_MOVE);

	m_bMachineMoving = FALSE;

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

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS NormalExamHandler::OnWorkstationSwitch(const char* pWorkstation)
{
	if (gbusinessLog) gbusinessLog->Info("[NormalExamHandler][OnWorkstationSwitch]->[{$}]", pWorkstation);

	if (!ConfigurerWS::IsDoubleWorkstation())
	{
		m_CurWS = ConfigurerWS::GetDefaultWS();
		if (gbusinessLog) gbusinessLog->Info("[NormalExamHandler][OnWorkstationSwitch]->[It is single WS, change to default {$}]", m_CurWS);
	}
	else
	{
		m_CurWS = pWorkstation;
	}

	auto model = m_modelManager->Resove(MOTION_MODEL_RAD);
	if (!model)
	{
		return RET_STATUS::RET_FAILED;
	}

	model->SwitchWorkstation(m_CurWS);

	return DIOS::Dev::RET_STATUS::RET_SUCCEED;
}

RET_STATUS NormalExamHandler::OnCenterAdjust(DOF_MECH mech)
{
	m_bSendHandswitchStatusAfterCenterAdjust = FALSE;
	printf("[NormalExamHandler][OnCenterAdjust]->[SendHandswitchStatusAfterCenterAdjust %s]\n", "FALSE");
	ChangeMotionModelStage(RAD_STAGE_CENTER_ADJUST);

	return RET_STATUS::RET_SUCCEED;
}