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

#include "stdafx.h"
#include "CArmMachineryManager.h"
#include "CArmComponentNameDef.h"
#include "IMechnicalComponentFactory.h"
#include "ServoDriveManager.h"
#include "ICircularController.h"
#include "ISwingController.h"
#include "IExposureController.h"
#include "ICollimatorController.h"
#include "ISensorEncoderController.h"
#include "..\\ServoDriveNameDef.h"
#include "ConfigurerMotion.h"
#include "ICommunicateEntity.h"
#include "ILandmarkController.h"
#include "FluoroSwitchController.h"

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

CArmMachineryManager *CArmMachineryManager::m_instance = nullptr;

CArmMachineryManager::CArmMachineryManager() 
:m_communicate(nullptr),
m_mechnicalFactory(nullptr),
m_cirular(nullptr),
m_swing(nullptr),
m_exposure(nullptr),
m_collimator(nullptr),
m_encoderCircular(nullptr),
m_encoderSwing(nullptr),
m_landmark(nullptr),
m_fluoroSwitch(nullptr)
{
}


CArmMachineryManager::~CArmMachineryManager()
{
}

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

	return m_instance;
}

void CArmMachineryManager::Initialize(IMechnicalComponentFactory *factory)
{
	m_mechnicalFactory = factory;

	CreateComponents();
	DistributeServoDrive();

	m_swing->AttachCommunicateID(IOInterfaceMapper::ID_TUBE_ANGLE_PULSE);
	m_cirular->AttachCommunicateID(IOInterfaceMapper::ID_TUBE_HEIGHT_PULSE);
	m_encoderSwing->AttachCommunicateID(IOInterfaceMapper::ID_TUBE_ANGLE_ENCODER);
	m_encoderCircular->AttachCommunicateID(IOInterfaceMapper::ID_TUBE_HEIGHT_ENCODER);
	m_exposure->AttachCommunicateID(IOInterfaceMapper::ID_EXPOSURE_TRIGGER);
	m_collimator->AttachCommunicateID(IOInterfaceMapper::ID_CAN);
	m_fluoroSwitch->AttachCommunicateID(IOInterfaceMapper::ID_FLUORO_SWITCH_OUT);

	m_encoderSwing->LoadAxisInterfaceID(
		IOInterfaceMapper::ID_TUBE_ANGLE_ENCODER_AXIS_A,
		IOInterfaceMapper::ID_TUBE_ANGLE_ENCODER_AXIS_B,
		IOInterfaceMapper::ID_TUBE_ANGLE_ENCODER_AXIS_Z);

	m_encoderCircular->LoadAxisInterfaceID(
		IOInterfaceMapper::ID_TUBE_HEIGHT_ENCODER_AXIS_A,
		IOInterfaceMapper::ID_TUBE_HEIGHT_ENCODER_AXIS_B,
		IOInterfaceMapper::ID_TUBE_HEIGHT_ENCODER_AXIS_Z
		);

	LoadSwingCommunicateInterfaceIDs();
	LoadCircularCommunicateInterfaceIDs();
	LoadSwingEncoderCommunicateInterfaceIDs();
	LoadCircularEncoderCommunicateInterfaceIDs();
	LoadExposureCommunicateInterfaceIDs();
	LoadLandmarkCommunicateInterfaceIDs();
	LoadOutputSignalInterfaceIDs();
}

void CArmMachineryManager::OnCommunicationEstablished(ICommunicateEntity *communicate)
{
	m_communicate = communicate;

	if(gcommLog) gcommLog->Info("[CArmMachineryManager][OnCommunicationEstablished]");

	SetFilterTimeOnComponents();
	SetupAutouploadOnComponents();
	SetupPFSTrigger();

	m_cirular->OnCommunicationEstablished(m_communicate);
	m_swing->OnCommunicationEstablished(m_communicate);
	m_encoderCircular->OnCommunicationEstablished(m_communicate);
	m_encoderCircular->BindABAxis();
	m_encoderSwing->OnCommunicationEstablished(m_communicate);
	m_encoderSwing->BindABAxis();
	m_exposure->OnCommunicationEstablished(m_communicate);
	m_collimator->OnCommunicationEstablished(m_communicate);
	m_landmark->OnCommunicationEstablished(m_communicate);
	m_fluoroSwitch->OnCommunicationEstablished(m_communicate);

	auto pulseonecircletubeAngle = ConfigurerMotion::GetPulseInOneCircleOfTubeAngleMotor();
	m_swing->SetPulseOneCircle((unsigned short)pulseonecircletubeAngle);
	auto pulseonecircletubeHeight = ConfigurerMotion::GetPulseInOneCircleOfTubeHeightMotor();
	m_cirular->SetPulseOneCircle((unsigned short)pulseonecircletubeHeight);

	auto dutyCycleoftubeangle = ConfigurerMotion::GetPulseDutyCycleOfTubeAngleMoror();
	m_swing->SetPulseDutyCycle(dutyCycleoftubeangle);
	auto dutyCycleoftubeHeight = ConfigurerMotion::GetPulseDutyCycleOfTubeHeightMotor();
	m_cirular->SetPulseDutyCycle(dutyCycleoftubeHeight);
}

void *CArmMachineryManager::Resove(const std::string &name)
{
	if (name == CONTROLLER_CARM_TUBE_CIRCULAR)
	{
		return m_cirular;
	}
	else if (name == CONTROLLER_CARM_TUBE_SWING)
	{
		return m_swing;
	}
	else if (name == CONTROLLER_CARM_TUBE_CIRCULAR_ENCODER)
	{
		return m_encoderCircular;
	}
	else if (name == CONTROLLER_CARM_TUBE_SWING_ENCODER)
	{
		return m_encoderSwing;
	}
	else if (name == CONTROLLER_EXPOSURE)
	{
		return m_exposure;
	}
	else if (name == CONTROLLER_COLLIMATOR)
	{
		return m_collimator;
	}
	else if (name == CONTROLLER_LANDMARK)
	{
		return m_landmark;
	}
	else if (name == CONTROLLER_FLUOROSWITCH)
	{
		return m_fluoroSwitch;
	}
	else
	{
		return nullptr;
	}
	
}

void CArmMachineryManager::CreateComponents()
{
	m_cirular = (ICircularController*)m_mechnicalFactory->CreateController(COMPONENT_CONTROLLER_CARM_TUBECIRCULAR, CONTROLLER_CARM_TUBE_CIRCULAR);
	m_swing = (ISwingController*)m_mechnicalFactory->CreateController(COMPONENT_CONTROLLER_CARM_TUBESWING, CONTROLLER_CARM_TUBE_SWING);
	m_encoderCircular = (ISensorEncoderController*)m_mechnicalFactory->CreateController(COMPONENT_CONTROLLER_ENCODER, CONTROLLER_CARM_TUBE_CIRCULAR_ENCODER);
	m_encoderSwing = (ISensorEncoderController*)m_mechnicalFactory->CreateController(COMPONENT_CONTROLLER_ENCODER, CONTROLLER_CARM_TUBE_SWING_ENCODER);
	m_exposure = (IExposureController*)m_mechnicalFactory->CreateController(COMPONENT_CONTROLLER_EXPOSURE, CONTROLLER_EXPOSURE);
	m_collimator = (ICollimatorController*)m_mechnicalFactory->CreateController(COMPONENT_CONTROLLER_COLLIMATOR, CONTROLLER_COLLIMATOR);
	m_landmark = (ILandmarkController*)m_mechnicalFactory->CreateController(COMPONENT_CONTROLLER_LANDMARK, CONTROLLER_LANDMARK);
	m_fluoroSwitch = (IOutputController*)m_mechnicalFactory->CreateController(COMPONENT_CONTROLLER_FLUOROSWITCH, CONTROLLER_FLUOROSWITCH);
}

void CArmMachineryManager::DistributeServoDrive()
{
	auto servoDriveTubeCircular = ServoDriveManager::Instance()->Resove(SERVO_DRIVE_TUBE_CIRCULAR);
	if (servoDriveTubeCircular != nullptr)
	{
		m_cirular->AttachServoDrive(servoDriveTubeCircular);
	}

	auto servodriveTubeSwing = ServoDriveManager::Instance()->Resove(SERVO_DRIVE_TUBE_SWING);
	if (servodriveTubeSwing != nullptr)
	{
		m_swing->AttachServoDrive(servodriveTubeSwing);
	}
}

void CArmMachineryManager::LoadSwingCommunicateInterfaceIDs()
{
	std::map<string, int> interfaceIDs;
	interfaceIDs[ID_RS232] = IOInterfaceMapper::ID_RS232;
	interfaceIDs[ID_CAN] = IOInterfaceMapper::ID_CAN;
	interfaceIDs[ID_TUBE_ANGLE_DIRECTION] = IOInterfaceMapper::ID_TUBE_ANGLE_DIRECTION;
	interfaceIDs[ID_TUBE_ANGLE_PULSE] = IOInterfaceMapper::ID_TUBE_ANGLE_PULSE;
	interfaceIDs[ID_TUBE_ANGLE_SERVO_ON] = IOInterfaceMapper::ID_TUBE_ANGLE_SERVO_ON;
	m_swing->LoadCommunicationInterfaceIDs(interfaceIDs);
}

void CArmMachineryManager::LoadCircularCommunicateInterfaceIDs()
{
	std::map<string, int> interfaceIDs;
	interfaceIDs[ID_RS232] = IOInterfaceMapper::ID_RS232;
	interfaceIDs[ID_CAN] = IOInterfaceMapper::ID_CAN;
	interfaceIDs[ID_TUBE_HEIGHT_DIRECTION] = IOInterfaceMapper::ID_TUBE_HEIGHT_DIRECTION;
	interfaceIDs[ID_TUBE_HEIGHT_PULSE] = IOInterfaceMapper::ID_TUBE_HEIGHT_PULSE;
	interfaceIDs[ID_TUBE_HEIGHT_SERVO_ON] = IOInterfaceMapper::ID_TUBE_HEIGHT_SERVO_ON;
	m_cirular->LoadCommunicationInterfaceIDs(interfaceIDs);
}

void CArmMachineryManager::LoadSwingEncoderCommunicateInterfaceIDs()
{
	std::map<string, int> interfaceIDs;
	interfaceIDs[ID_TUBE_ANGLE_ENCODER] = IOInterfaceMapper::ID_TUBE_ANGLE_ENCODER;
	interfaceIDs[ID_CAN] = IOInterfaceMapper::ID_CAN;
	m_encoderSwing->LoadCommunicationInterfaceIDs(interfaceIDs);
	m_encoderSwing->DistributeCanSequence(IOInterfaceMapper::ID_CAN_STDID_TUBE_SWING_ENCODER);
}

void CArmMachineryManager::LoadCircularEncoderCommunicateInterfaceIDs()
{
	std::map<string, int> interfaceIDs;
	interfaceIDs[ID_TUBE_HEIGHT_ENCODER] = IOInterfaceMapper::ID_TUBE_HEIGHT_ENCODER;
	interfaceIDs[ID_CAN] = IOInterfaceMapper::ID_CAN;
	m_encoderCircular->LoadCommunicationInterfaceIDs(interfaceIDs);
	m_encoderCircular->DistributeCanSequence(IOInterfaceMapper::ID_CAN_STDID_TUBE_CIRCULAR_ENCODER);
}

void CArmMachineryManager::LoadExposureCommunicateInterfaceIDs()
{
	std::map<string, int> interfaceIDs;
	interfaceIDs[ID_XRAYON_NOTIFY] = IOInterfaceMapper::ID_XRAYON_NOTIFY;
	m_exposure->LoadCommunicationInterfaceIDs(interfaceIDs);
}

void CArmMachineryManager::LoadLandmarkCommunicateInterfaceIDs()
{
	std::map<string, int> interfaceIDs;
	interfaceIDs[ID_TUBE_ANGLE_LOW_LIMIT] = IOInterfaceMapper::ID_TUBE_ANGLE_LOW_LIMIT;
	interfaceIDs[ID_TUBE_ANGLE_HIGH_LIMIT] = IOInterfaceMapper::ID_TUBE_ANGLE_HIGH_LIMIT;
	interfaceIDs[ID_TUBE_HEIGHT_LOW_LIMIT] = IOInterfaceMapper::ID_TUBE_HEIGHT_LOW_LIMIT;
	interfaceIDs[ID_TUBE_HEIGHT_HIGH_LIMIT] = IOInterfaceMapper::ID_TUBE_HEIGHT_HIGH_LIMIT;
	m_landmark->LoadCommunicationInterfaceIDs(interfaceIDs);
}

void CArmMachineryManager::LoadOutputSignalInterfaceIDs()
{
	std::map<string, int> interfaceIDs;
	interfaceIDs[ID_FLUORO_SWITCH_OUT] = IOInterfaceMapper::ID_FLUORO_SWITCH_OUT;
	m_fluoroSwitch->LoadCommunicationInterfaceIDs(interfaceIDs);
}

void CArmMachineryManager::SetFilterTimeOnComponents()
{
	auto hswfiltertime = ConfigurerMotion::GetFilterTimeHandSwitchDISignal();
	auto lswfiltertime = ConfigurerMotion::GetFilterTimeLimitSwitchDISignal();

	GPIO_DI_PARAM param;
	param.autoupload_switch = (unsigned char)GAUTO_DI_UPLOAD_ON;
	param.input_mode = (unsigned char)GIM_DIGITAL;
	param.filter_time = (unsigned char)hswfiltertime;
	if (IOInterfaceMapper::ID_SYSTEM_RESET > 0)
	{
		m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_SYSTEM_RESET, DI_ATTR_SET_AUTO_UPLOAD, param);
		m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_SYSTEM_RESET, DI_ATTR_SET_MODE, param);
	}

	if (IOInterfaceMapper::ID_SYSTEM_RESET_SWING > 0)
	{
		m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_SYSTEM_RESET_SWING, DI_ATTR_SET_AUTO_UPLOAD, param);
		m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_SYSTEM_RESET_SWING, DI_ATTR_SET_MODE, param);
	}

	if (IOInterfaceMapper::ID_SYSTEM_RESET_CIRCULAR > 0)
	{
		m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_SYSTEM_RESET_CIRCULAR, DI_ATTR_SET_AUTO_UPLOAD, param);
		m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_SYSTEM_RESET_CIRCULAR, DI_ATTR_SET_MODE, param);
	}

	if (IOInterfaceMapper::ID_TUBE_HEIGHT_CONTROLLER_DIRECTION_1 > 0)
	{
		m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HEIGHT_CONTROLLER_DIRECTION_1, DI_ATTR_SET_AUTO_UPLOAD, param);
		m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HEIGHT_CONTROLLER_DIRECTION_1, DI_ATTR_SET_MODE, param);
	}

	if (IOInterfaceMapper::ID_TUBE_HEIGHT_CONTROLLER_DIRECTION_2 > 0)
	{
		m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HEIGHT_CONTROLLER_DIRECTION_2, DI_ATTR_SET_AUTO_UPLOAD, param);
		m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HEIGHT_CONTROLLER_DIRECTION_2, DI_ATTR_SET_MODE, param);
	}


	if (IOInterfaceMapper::ID_TUBE_ANGLE_CONTROLLER_DIRECTION_1 > 0)
	{
		m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_ANGLE_CONTROLLER_DIRECTION_1, DI_ATTR_SET_AUTO_UPLOAD, param);
		m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_ANGLE_CONTROLLER_DIRECTION_1, DI_ATTR_SET_MODE, param);
	}

	if (IOInterfaceMapper::ID_TUBE_ANGLE_CONTROLLER_DIRECTION_2 > 0)
	{
		m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_ANGLE_CONTROLLER_DIRECTION_2, DI_ATTR_SET_AUTO_UPLOAD, param);
		m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_ANGLE_CONTROLLER_DIRECTION_2, DI_ATTR_SET_MODE, param);
	}

	if (IOInterfaceMapper::ID_CARM_SCANNING_SWITCH > 0)
	{
		m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_CARM_SCANNING_SWITCH, DI_ATTR_SET_AUTO_UPLOAD, param);
		m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_CARM_SCANNING_SWITCH, DI_ATTR_SET_MODE, param);
	}

	m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_HAND_SWITCH_GEAR_FIRST, DI_ATTR_SET_AUTO_UPLOAD, param);
	m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_HAND_SWITCH_GEAR_FIRST, DI_ATTR_SET_MODE, param);
	m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_HAND_SWITCH_GEAR_SECOND, DI_ATTR_SET_AUTO_UPLOAD, param);
	m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_HAND_SWITCH_GEAR_SECOND, DI_ATTR_SET_MODE, param);

	param.filter_time = (unsigned char)lswfiltertime;
	m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_ANGLE_HIGH_LIMIT, DI_ATTR_SET_MODE, param);
	m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HEIGHT_HIGH_LIMIT, DI_ATTR_SET_MODE, param);
}

void CArmMachineryManager::SetupAutouploadOnComponents()
{
	GPIO_DI_PARAM diparam;
	diparam.autoupload_switch = (unsigned char)GAUTO_DI_UPLOAD_ON;
	m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_ANGLE_LOW_LIMIT, DI_ATTR_SET_AUTO_UPLOAD, diparam);
	m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_ANGLE_HIGH_LIMIT, DI_ATTR_SET_AUTO_UPLOAD, diparam);
	m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_XRAYON_NOTIFY, DI_ATTR_SET_AUTO_UPLOAD, diparam);
	m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HEIGHT_HIGH_LIMIT, DI_ATTR_SET_AUTO_UPLOAD, diparam);
	m_communicate->GPIO_DI_Ctrl(OP_SET, (GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HEIGHT_LOW_LIMIT, DI_ATTR_SET_AUTO_UPLOAD, diparam);
}

void CArmMachineryManager::SetupPFSTrigger()
{
	GPIO_DO_PARAM params;
	params.output_mode = GOM_PWM;
	params.peroid.pwmperiod_short = 20002;
	params.effective.pwmperiod_short = 20000;
	params.pwm_step.pwmstep_int = 1;

	m_communicate->GPIO_DO_Ctrl(OP_SET, (GPIO_DO_ID)IOInterfaceMapper::ID_EXPOSURE_TRIGGER,
		DO_ATTR_SET_MODE, params);
	m_communicate->GPIO_DO_Ctrl(OP_SET, (GPIO_DO_ID)IOInterfaceMapper::ID_EXPOSURE_TRIGGER,
		DO_ATTR_SET_PWM_PARAM_TABLE, params);
}