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

#include "stdafx.h"
#include "TomoDPCHandler.h"
#include "SCFLoader.h"
#include "IPacketDispatcher.h"
#include "PacketDispatcherFactory.h"
#include "LogicDeviceManager.h"
#include "LogicDriverThreadLocker.h"
#include "CommunicateEntityFactory.h"
#include "ICommunicateEntity.h"
#include "ExamHandlerManager.h"
#include "MachineryManager.h"
#include "MechnicalMonitor.h"
#include "MotionModelManager.h"
#include "PositionManager.h"
#include "ServoDriveManager.h"
#include "MechnicalComponentFactory.h"
#include "ServoDriveFactory.h"
#include "MotionModelFactory.h"
#include "DeviceHandlerManager.h"
#include "ExamHandlerFactory.h"
#include "DeviceHandlerFactory.h"
#include "LogicDeviceMechTomo.h"
#include "LogicDeviceHandSwitch.h"
#include "LogicDeviceCollimator.h"
#include "ImplPositionManager.h"
#include "WorkFlowManager.h"
#include "ServoDriveNameDef.h"
#include "ExamHandlerNameDef.h"

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

TomoDPCHandler *TomoDPCHandler::m_instance = nullptr;

TomoDPCHandler::TomoDPCHandler()
{
}


TomoDPCHandler::~TomoDPCHandler()
{
}

TomoDPCHandler *TomoDPCHandler::Instance()
{
	if (m_instance == nullptr)
	{
		m_instance = new TomoDPCHandler();
	}

	return m_instance;
}

void TomoDPCHandler::OnDriverEntry(
	MachineryECOMDriver* dpc,
	ICommunicateEntity *&outcommunicate,
	IPacketDispatcher *&outdispatcher,
	bool &outstatus)
{
	outcommunicate = CommunicateEntityFactory::Instance()->CreateSingleton(COMMUNICATE_ENTITY_DIOSBOARD);
	outdispatcher = PacketDispatcherFactory::Instance()->CreateSingleton(GENERAL_DISPATCHER);
	if (outdispatcher)
	{
		outdispatcher->Initialize(WorkFlowManager::Instance());
	}

	if (!outcommunicate || !((ICommunicateEntity *)outcommunicate)->Initialize((IPacketDispatcher*)outdispatcher))
	{
		outstatus = false;
	}

	outstatus = true;
}

void TomoDPCHandler::OnSetDriverWorkPath(const char *workPath)
{
	std::vector<std::string> servoDriveList;
	servoDriveList.push_back(SERVO_DRIVE_TUBE_ANGLE);
	servoDriveList.push_back(SERVO_DRIVE_TUBE_HEIGHT);
	servoDriveList.push_back(SERVO_DRIVE_TUBE_HORIZONTAL);

	std::map<std::string, int> modellist;
	modellist[MOTION_MODEL_TOMO] = MOTION_MODEL_TYPE_TOMO;
	modellist[MOTION_MODEL_RAD] = MOTION_MODEL_TYPE_RAD;
	modellist[MOTION_MODEL_RESET] = MOTION_MODEL_TYPE_TOMO_RESET;
	modellist[MOTION_MODEL_CALIBRATION] = MOTION_MODEL_TYPE_TOMO_CALIBRATION;
	modellist[MOTION_MODEL_PARKING] = MOTION_MODEL_TYPE_TOMO_PARKING;
	modellist[MOTION_MODEL_SELFTEST] = MOTION_MODEL_TYPE_TOMO_SELFTEST;


	std::map<std::string, int> examhandlerlist;
	examhandlerlist[SINGLE_EXAMHANDLER] = EXAM_HANDLER_RAD;
	examhandlerlist[TOMO_EXAMHANDLER] = EXAM_HANDLER_TOMO;
	examhandlerlist[CALIBRATION_HANDLER] = EXAM_HANDLER_CALIBRATION;
	examhandlerlist[MOTIONTEST_HANDLER] = EXAM_HANDLER_MOTIONTEST;
	examhandlerlist[RESET_HANDLER] = EXAM_HANDLER_RESET;
	examhandlerlist[SELF_TEST_HANDLER] = EXAM_HANDLER_SELFTEST;
	examhandlerlist[PARKING_HANDLER] = EXAM_HANDLER_PARKING;


	ServoDriveManager::Instance()->Initialize(ServoDriveFactory::Instance(), servoDriveList);
	MachineryManager::Instance()->Initialize(MechnicalComponentFactory::Instance());
	PositionManager::Instance()->Attach(new ImplPositionManager());
	PositionManager::Instance()->Initialize(MachineryManager::Instance());
	MotionModelManager::Instance()->Initialize(MotionModelFactory::Instance(), MachineryManager::Instance(), PositionManager::Instance(), modellist);
	MechnicalMonitor::Instance()->Initialize(PositionManager::Instance(), TOMO_TUBE_ANGLE, TOMO_TUBE_HEIGHT);
	ExamHandlerManager::Instance()->Initialize(
		ExamHandlerFactory::Instance(), 
		PositionManager::Instance(), 
		MotionModelManager::Instance(), 
		examhandlerlist);
	DeviceHandlerManager::Instance()->Initialize(DeviceHandlerFactory::Instance());
}

void TomoDPCHandler::OnConnected(ICommunicateEntity *communicate)
{
	MachineryManager::Instance()->OnCommunicationEstablished(communicate);
}

void TomoDPCHandler::OnLoadLogicDevices(MachineryECOMDriver* dpc)
{
	LogicDeviceManager::Instance()->LoadLogicDevice(LOGICDEVICE_MECH_TOMO, new LogicDeviceMechTomo(dpc));
	LogicDeviceManager::Instance()->LoadLogicDevice(LOGICDEVICE_MECH_HSW, new LogicDeviceHandSwitch(dpc));
	LogicDeviceManager::Instance()->LoadLogicDevice(LOGICDEVICE_MECH_COLLIMATOR, new LogicDeviceCollimator(dpc));

	PositionManager::Instance()->SetNotifyLogicDevice(dpc);
}

void TomoDPCHandler::OnNitifyReadyStatus(MachineryECOMDriver* dpc)
{
	auto logicTomo = (LogicDeviceMechTomo*)LogicDeviceManager::Instance()->Resove(LOGICDEVICE_MECH_TOMO);
	if (logicTomo)
	{
		logicTomo->NotifyMachineryReadyState(logicTomo->GetMachineryReadyState());
	}
}