#include "stdafx.h"
#include "MachineryManager.h"
#include "IMechnicalComponentFactory.h"
#include "ITubeAngleController.h"
#include "ITubeHeightController.h"
#include "ISensorADController.h"
#include "ISensorEncoderController.h"
#include "ILandmarkController.h"
#include "ICommunicateEntity.h"
#include "IServoDrive.h"
#include "ServoDriveManager.h"
#include "IExposureController.h"
#include "ConfigurerMotion.h"
#include "ICollimatorController.h"
#include "ServoDriveNameDef.h"
#include "TubeLineMotionSwitchController.h"
#include "TubeHorizontalController.h"

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

MachineryManager *MachineryManager::m_instance = nullptr;

MachineryManager::MachineryManager()
:m_communicate(nullptr),
m_mechnicalFactory(nullptr),
m_motorTubeAngle(nullptr),
m_motorTubeHeight(nullptr),
m_adTubeAngle(nullptr),
m_adTubeHeight(nullptr),
m_adDetectorHeight(nullptr),
m_encoderTubeAngle(nullptr),
m_encoderTubeHeight(nullptr),
m_encoderDetectorHeight(nullptr),
m_exposure(nullptr),
m_landmark(nullptr),
m_collimator(nullptr),
m_tubeLineMotionSwitch(nullptr),
m_motorTubeHorizontal(nullptr),
m_adTubeHorizontal(nullptr),
m_encoderTubeHorizontal(nullptr),
m_adDetectorHorizontal(nullptr)
{
}


MachineryManager::~MachineryManager()
{
}

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

	return m_instance;
}

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

	CreateComponents();

	DistributeServoDrive();

	m_motorTubeAngle->AttachCommunicateID(IOInterfaceMapper::ID_TUBE_ANGLE_PULSE);
	m_motorTubeHeight->AttachCommunicateID(IOInterfaceMapper::ID_TUBE_HEIGHT_PULSE);
	m_encoderTubeAngle->AttachCommunicateID(IOInterfaceMapper::ID_TUBE_ANGLE_ENCODER);
	m_encoderTubeHeight->AttachCommunicateID(IOInterfaceMapper::ID_TUBE_HEIGHT_ENCODER);
	m_adDetectorHeight->AttachCommunicateID(IOInterfaceMapper::ID_DETECTOR_HEIGHT_AD);
	m_adTubeHeight->AttachCommunicateID(IOInterfaceMapper::ID_TUBE_HEIGHT_AD);
	m_adTubeAngle->AttachCommunicateID(IOInterfaceMapper::ID_TUBE_ANGLE_AD);
	m_exposure->AttachCommunicateID(IOInterfaceMapper::ID_EXPOSURE_TRIGGER);
	m_collimator->AttachCommunicateID(IOInterfaceMapper::ID_CAN);
	m_tubeLineMotionSwitch->AttachCommunicateID(IOInterfaceMapper::ID_TUBE_LINE_MOTION_SWITCH_OUT);

	m_motorTubeHorizontal->AttachCommunicateID(IOInterfaceMapper::ID_TUBE_HORIZONTAL_PULSE);
	m_adTubeHorizontal->AttachCommunicateID(IOInterfaceMapper::ID_TUBE_HORIZONTAL_AD);
	m_encoderTubeHorizontal->AttachCommunicateID(IOInterfaceMapper::ID_TUBE_HORIZONTAL_ENCODER);
	m_adDetectorHorizontal->AttachCommunicateID(IOInterfaceMapper::ID_DETECTOR_HORIZONTAL_AD);

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

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

	m_encoderTubeHorizontal->LoadAxisInterfaceID(
		IOInterfaceMapper::ID_TUBE_HORIZONTAL_ENCODER_AXIS_A,
		IOInterfaceMapper::ID_TUBE_HORIZONTAL_ENCODER_AXIS_B,
		IOInterfaceMapper::ID_TUBE_HORIZONTAL_ENCODER_AXIS_Z
	);

	LoadMotorTubeAngleCommunicateInterfaceIDs();
	LoadMotorTubeHeightCommunicateInterfaceIDs();
	LoadMotorTubeHorizontalCommunicateInterfaceIDs();
	LoadSensorADTubeAngleCommunicateInterfaceIDs();
	LoadSensorEncoderTubeAngleCommunicateInterfaceIDs();
	LoadSensorADTubeHeightCommunicateInterfaceIDs();
	LoadSensorEncoderTubeHeightCommunicateInterfaceIDs();
	LoadSensorADDetectorHeightCommunicateInterfaceIDs();
	LoadSensorEncoderDetectorHeightCommunicateInterfaceIDs();
	LoadSensorADTubeHorizontalCommunicateInterfaceIDs();
	LoadSensorEncoderTubeHorizontalCommunicateInterfaceIDs();
	LoadExposureCommunicateInterfaceIDs();
	LoadLandmarkCommunicateInterfaceIDs();
	LoadOutputSignalInterfaceIDs();
	LoadSensorADDetectorHorizontalCommunicateInterfaceIDs();
	LoadSensorEncoderDetectorHorizontalCommunicateInterfaceIDs();
}

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

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

	SetupMotorBrake();
	SetFilterTimeOnComponents();
	//SetupAutouploadOnComponents();
	SetupExposureTrigger();
	SetupTubeAD();

	m_motorTubeAngle->OnCommunicationEstablished(m_communicate);
	m_motorTubeHeight->OnCommunicationEstablished(m_communicate);
	m_adTubeAngle->OnCommunicationEstablished(m_communicate);
	m_adTubeHeight->OnCommunicationEstablished(m_communicate);
	m_adDetectorHeight->OnCommunicationEstablished(m_communicate);
	m_encoderTubeAngle->OnCommunicationEstablished(m_communicate);
	m_encoderTubeAngle->BindABAxis();
	m_encoderTubeHeight->OnCommunicationEstablished(m_communicate);
	m_encoderTubeHeight->BindABAxis();
	m_encoderDetectorHeight->OnCommunicationEstablished(m_communicate);
	m_landmark->OnCommunicationEstablished(m_communicate);
	m_exposure->OnCommunicationEstablished(m_communicate);
	m_collimator->OnCommunicationEstablished(m_communicate);
	m_tubeLineMotionSwitch->OnCommunicationEstablished(m_communicate);

	m_motorTubeHorizontal->OnCommunicationEstablished(m_communicate);
	m_adTubeHorizontal->OnCommunicationEstablished(m_communicate);
	m_encoderTubeHorizontal->OnCommunicationEstablished(m_communicate);
	m_encoderTubeHorizontal->BindABAxis();

	m_adDetectorHorizontal->OnCommunicationEstablished(m_communicate);

	auto pulseonecircletubeAngle = ConfigurerMotion::GetPulseInOneCircleOfTubeAngleMotor();
	m_motorTubeAngle->SetPulseOneCircle((unsigned short)pulseonecircletubeAngle);
	auto pulseonecircletubeHeight = ConfigurerMotion::GetPulseInOneCircleOfTubeHeightMotor();
	m_motorTubeHeight->SetPulseOneCircle((unsigned short)pulseonecircletubeHeight);
	auto pulseonecircletubeHorizontal = ConfigurerMotion::GetPulseInOneCircleOfTubeHorizontalMotor();
	m_motorTubeHorizontal->SetPulseOneCircle((unsigned short)pulseonecircletubeHorizontal);

	auto dutyCycleoftubeangle = ConfigurerMotion::GetPulseDutyCycleOfTubeAngleMoror();
	m_motorTubeAngle->SetPulseDutyCycle(dutyCycleoftubeangle);
	auto dutyCycleoftubeHeight = ConfigurerMotion::GetPulseDutyCycleOfTubeHeightMotor();
	m_motorTubeHeight->SetPulseDutyCycle(dutyCycleoftubeHeight);
	auto dutyCycleoftubeHorizontal = ConfigurerMotion::GetPulseDutyCycleOfTubeHorizontalMoror();
	m_motorTubeHorizontal->SetPulseDutyCycle(dutyCycleoftubeHorizontal);

}

void *MachineryManager::Resove(const std::string &name)
{
	if (name == CONTROLLER_TUBE_ANGLE)
	{
		return m_motorTubeAngle;
	}
	else if (name == CONTROLLER_TUBE_HEIGHT)
	{
		return m_motorTubeHeight;
	}
	else if (name == CONTROLLER_TUBE_ANGLE_AD)
	{
		return m_adTubeAngle;
	}
	else if (name == CONTROLLER_TUBE_HEIGHT_AD)
	{
		return m_adTubeHeight;
	}
	else if (name == CONTROLLER_DETECTOR_HEIGHT_AD)
	{
		return m_adDetectorHeight;
	}
	else if (name == CONTROLLER_TUBE_ANGLE_ENCODER)
	{
		return m_encoderTubeAngle;
	}
	else if (name == CONTROLLER_TUBE_HEIGHT_ENCODER)
	{
		return m_encoderTubeHeight;
	}
	else if (name == CONTROLLER_DETECTOR_HEIGHT_ENCODER)
	{
		return m_encoderDetectorHeight;
	}
	else if (name == CONTROLLER_EXPOSURE)
	{
		return m_exposure;
	}
	else if (name == CONTROLLER_LANDMARK)
	{
		return m_landmark;
	}
	else if (name == CONTROLLER_COLLIMATOR)
	{
		return m_collimator;
	}
	else if (name == CONTROLLER_TUBE_LINE_MOTION_SWTICH)
	{
		return m_tubeLineMotionSwitch;
	}
	else if (name == CONTROLLER_TUBE_HORIZONTAL)
	{
		return m_motorTubeHorizontal;
	}
	else if (name == CONTROLLER_TUBE_HORIZONTAL_AD)
	{
		return m_adTubeHorizontal;
	}
	else if (name == CONTROLLER_TUBE_HORIZONTAL_ENCODER)
	{
		return m_encoderTubeHorizontal;
	}
	else if (name == CONTROLLER_DETECTOR_HORIZONTAL_AD)
	{
		return m_adDetectorHorizontal;
	}
	else
	{
		return nullptr;
	}
}

void MachineryManager::CreateComponents()
{
	m_motorTubeAngle = (ITubeAngleController*)m_mechnicalFactory->CreateController(COMPONENT_CONTROLLER_TOMO_TUBEANGLE,CONTROLLER_TUBE_ANGLE);
	m_motorTubeHeight = (ITubeHeightController*)m_mechnicalFactory->CreateController(COMPONENT_CONTROLLER_TOMO_TUBEHEIGHT, CONTROLLER_TUBE_HEIGHT);
	m_adTubeAngle = (ISensorADController*)m_mechnicalFactory->CreateController(COMPONENT_CONTROLLER_AD, CONTROLLER_TUBE_ANGLE_AD);
	m_adTubeHeight = (ISensorADController*)m_mechnicalFactory->CreateController(COMPONENT_CONTROLLER_AD, CONTROLLER_TUBE_HEIGHT_AD);
	m_adDetectorHeight = (ISensorADController*)m_mechnicalFactory->CreateController(COMPONENT_CONTROLLER_AD, CONTROLLER_DETECTOR_HEIGHT_AD);
	m_encoderTubeAngle = (ISensorEncoderController*)m_mechnicalFactory->CreateController(COMPONENT_CONTROLLER_ENCODER, CONTROLLER_TUBE_ANGLE_ENCODER);
	m_encoderTubeHeight = (ISensorEncoderController*)m_mechnicalFactory->CreateController(COMPONENT_CONTROLLER_ENCODER, CONTROLLER_TUBE_HEIGHT_ENCODER);
	m_encoderDetectorHeight = (ISensorEncoderController*)m_mechnicalFactory->CreateController(COMPONENT_CONTROLLER_ENCODER, CONTROLLER_DETECTOR_HEIGHT_ENCODER);
	m_exposure = (IExposureController*)m_mechnicalFactory->CreateController(COMPONENT_CONTROLLER_EXPOSURE, CONTROLLER_EXPOSURE);
	m_landmark = (ILandmarkController*)m_mechnicalFactory->CreateController(COMPONENT_CONTROLLER_LANDMARK,CONTROLLER_LANDMARK);
	m_collimator = (ICollimatorController*)m_mechnicalFactory->CreateController(COMPONENT_CONTROLLER_COLLIMATOR,CONTROLLER_COLLIMATOR);
	m_tubeLineMotionSwitch = (IOutputController*)m_mechnicalFactory->CreateController(COMPONENT_CONTROLLER_TUBE_LINE_MOTION_SWITCH, CONTROLLER_TUBE_LINE_MOTION_SWTICH);
	m_motorTubeHorizontal = (ITubeHeightController*)m_mechnicalFactory->CreateController(COMPONENT_CONTROLLER_TOMO_TUBEHORIZONTAL, CONTROLLER_TUBE_HORIZONTAL);
	m_adTubeHorizontal = (ISensorADController*)m_mechnicalFactory->CreateController(COMPONENT_CONTROLLER_AD, CONTROLLER_TUBE_HORIZONTAL_AD);
	m_encoderTubeHorizontal = (ISensorEncoderController*)m_mechnicalFactory->CreateController(COMPONENT_CONTROLLER_ENCODER, CONTROLLER_TUBE_HORIZONTAL_ENCODER);
	m_adDetectorHorizontal = (ISensorADController*)m_mechnicalFactory->CreateController(COMPONENT_CONTROLLER_AD, CONTROLLER_DETECTOR_HORIZONTAL_AD);
}

void MachineryManager::DistributeServoDrive()
{
	auto servoDriveTubeAngle = ServoDriveManager::Instance()->Resove(SERVO_DRIVE_TUBE_ANGLE);
	if (servoDriveTubeAngle != nullptr)
	{
		m_motorTubeAngle->AttachServoDrive(servoDriveTubeAngle);
	}

	auto servodriveTubeHeight = ServoDriveManager::Instance()->Resove(SERVO_DRIVE_TUBE_HEIGHT);
	if (servodriveTubeHeight != nullptr)
	{
		m_motorTubeHeight->AttachServoDrive(servodriveTubeHeight);
	}

	auto servoDriveTubeHorizontal = ServoDriveManager::Instance()->Resove(SERVO_DRIVE_TUBE_HORIZONTAL);
	if (servoDriveTubeHorizontal != nullptr)
	{
		m_motorTubeHorizontal->AttachServoDrive(servoDriveTubeHorizontal);
	}
}

void MachineryManager::SetAttribute(GPIO_DI_ID ID, GPIO_DI_PARAM param)
{
	if (ID > 0)
	{
		m_communicate->GPIO_DI_Ctrl(OP_SET, ID, DI_ATTR_SET_MODE, param);
	}
}

void MachineryManager::SetAutoUpload(GPIO_DI_ID ID, GPIO_DI_PARAM param)
{
	if (ID > 0)
	{
		m_communicate->GPIO_DI_Ctrl(OP_SET, ID, DI_ATTR_SET_AUTO_UPLOAD, param);
	}
}

void MachineryManager::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);
	}

	param.filter_time = (unsigned char)lswfiltertime;
	SetAutoUpload((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_ANGLE_HIGH_LIMIT, param);
	SetAttribute((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_ANGLE_HIGH_LIMIT, param);

	SetAutoUpload((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_ANGLE_LOW_LIMIT, param);
	SetAttribute((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_ANGLE_LOW_LIMIT, param);

	SetAutoUpload((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HEIGHT_HIGH_LIMIT, param);
	SetAttribute((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HEIGHT_HIGH_LIMIT, param);

	SetAutoUpload((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HEIGHT_LOW_LIMIT, param);
	SetAttribute((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HEIGHT_LOW_LIMIT, param);

	SetAutoUpload((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HORIZONTAL_LEFT_LIMIT, param);
	SetAttribute((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HORIZONTAL_LEFT_LIMIT, param);

	SetAutoUpload((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HORIZONTAL_RIGHT_LIMIT, param);
	SetAttribute((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HORIZONTAL_RIGHT_LIMIT, param);

	SetAutoUpload((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HORIZONTAL_CONTROLLER_DIRECTION_1, param);
	SetAttribute((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HORIZONTAL_CONTROLLER_DIRECTION_1, param);

	SetAutoUpload((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HORIZONTAL_CONTROLLER_DIRECTION_2, param);
	SetAttribute((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HORIZONTAL_CONTROLLER_DIRECTION_2, param);

	SetAutoUpload((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HEIGHT_CONTROLLER_DIRECTION_1, param);
	SetAttribute((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HEIGHT_CONTROLLER_DIRECTION_1, param);

	SetAutoUpload((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HEIGHT_CONTROLLER_DIRECTION_2, param);
	SetAttribute((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HEIGHT_CONTROLLER_DIRECTION_2, param);

	SetAutoUpload((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_ANGLE_CONTROLLER_DIRECTION_1, param);
	SetAttribute((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_ANGLE_CONTROLLER_DIRECTION_1, param);

	SetAutoUpload((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_ANGLE_CONTROLLER_DIRECTION_2, param);
	SetAttribute((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_ANGLE_CONTROLLER_DIRECTION_2, 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);
}

void MachineryManager::SetupAutouploadOnComponents()
{
	GPIO_DI_PARAM param;
	param.autoupload_switch = (unsigned char)GAUTO_DI_UPLOAD_ON;

	SetAutoUpload((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_ANGLE_HIGH_LIMIT, param);
	SetAutoUpload((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_ANGLE_LOW_LIMIT, param);
	SetAutoUpload((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HEIGHT_HIGH_LIMIT, param);
	SetAutoUpload((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HEIGHT_LOW_LIMIT, param);
	SetAutoUpload((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HORIZONTAL_LEFT_LIMIT, param);
	SetAutoUpload((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HORIZONTAL_RIGHT_LIMIT, param);
	SetAutoUpload((GPIO_DI_ID)IOInterfaceMapper::ID_XRAYON_NOTIFY, param);
	SetAutoUpload((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HORIZONTAL_CONTROLLER_DIRECTION_1, param);
	SetAutoUpload((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HORIZONTAL_CONTROLLER_DIRECTION_2, param);
	SetAutoUpload((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HEIGHT_CONTROLLER_DIRECTION_1, param);
	SetAutoUpload((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_HEIGHT_CONTROLLER_DIRECTION_2, param);
	SetAutoUpload((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_ANGLE_CONTROLLER_DIRECTION_1, param);
	SetAutoUpload((GPIO_DI_ID)IOInterfaceMapper::ID_TUBE_ANGLE_CONTROLLER_DIRECTION_2, param);
}

void MachineryManager::SetupTubeAngleLimition()
{
	auto a_trigger_level = ConfigurerMotion::GetSoftwareChainInterfaceATriggerLevel();
	auto b_trigger_level = ConfigurerMotion::GetSoftwareChainInterfaceBTriggerLevel();

	SCL_PARAM sclparam;
	sclparam.a_id = (unsigned char)IOInterfaceMapper::ID_TUBE_ANGLE_HIGH_LIMIT;
	sclparam.a_trigger_level = a_trigger_level;
	sclparam.b_id = (unsigned char)IOInterfaceMapper::ID_TUBE_ANGLE_DIRECTION;
	sclparam.b_trigger_level = b_trigger_level;
	sclparam.f_id = (unsigned char)IOInterfaceMapper::ID_TUBE_ANGLE_PULSE;
	m_communicate->SCL_Ctrl(OP_SET, (SCL_ID)IOInterfaceMapper::ID_SOFTWARE_CHAIN_INTERFACE_A, SCL_ATTR_SET, sclparam);
	sclparam.a_id = (unsigned char)IOInterfaceMapper::ID_TUBE_ANGLE_LOW_LIMIT;
	m_communicate->SCL_Ctrl(OP_SET, (SCL_ID)IOInterfaceMapper::ID_SOFTWARE_CHAIN_INTERFACE_B, SCL_ATTR_SET, sclparam);
}

void MachineryManager::SetupExposureTrigger()
{
	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);
}

void MachineryManager::SetupTubeAD()
{
	AD_PARAM adparam;
	m_communicate->AD_Ctrl(OP_SET, (AD_ID)IOInterfaceMapper::ID_TUBE_HEIGHT_AD, AD_ATTR_AUTO_UPLOAD_CLEAR_TABLE, adparam);
	m_communicate->AD_Ctrl(OP_SET, (AD_ID)IOInterfaceMapper::ID_TUBE_HORIZONTAL_AD, AD_ATTR_AUTO_UPLOAD_CLEAR_TABLE, adparam);
	m_communicate->AD_Ctrl(OP_SET, (AD_ID)IOInterfaceMapper::ID_TUBE_ANGLE_AD, AD_ATTR_AUTO_UPLOAD_CLEAR_TABLE, adparam);
}

void MachineryManager::LoadMotorTubeAngleCommunicateInterfaceIDs()
{
	std::map<string, int> interfaceIDs;
	interfaceIDs[ID_RS232] = IOInterfaceMapper::ID_RS232;
	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;
	interfaceIDs[ID_TUBE_ANGLE_BRAKE] = IOInterfaceMapper::ID_TUBE_ANGLE_BRAKE;
	m_motorTubeAngle->LoadCommunicationInterfaceIDs(interfaceIDs);
}

void MachineryManager::LoadMotorTubeHeightCommunicateInterfaceIDs()
{
	std::map<string, int> interfaceIDs;
	interfaceIDs[ID_RS232] = IOInterfaceMapper::ID_RS232;
	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;
	interfaceIDs[ID_TUBE_HEIGHT_BRAKE] = IOInterfaceMapper::ID_TUBE_HEIGHT_BRAKE;
	m_motorTubeHeight->LoadCommunicationInterfaceIDs(interfaceIDs);
}

void MachineryManager::LoadMotorTubeHorizontalCommunicateInterfaceIDs()
{
	std::map<string, int> interfaceIDs;
	interfaceIDs[ID_RS232] = IOInterfaceMapper::ID_RS232;
	interfaceIDs[ID_TUBE_HORIZONTAL_DIRECTION] = IOInterfaceMapper::ID_TUBE_HORIZONTAL_DIRECTION;
	interfaceIDs[ID_TUBE_HORIZONTAL_PULSE] = IOInterfaceMapper::ID_TUBE_HORIZONTAL_PULSE;
	interfaceIDs[ID_TUBE_HORIZONTAL_SERVO_ON] = IOInterfaceMapper::ID_TUBE_HORIZONTAL_SERVO_ON;
	interfaceIDs[ID_TUBE_HORIZONTAL_BRAKE] = IOInterfaceMapper::ID_TUBE_HORIZONTAL_BRAKE;
	m_motorTubeHorizontal->LoadCommunicationInterfaceIDs(interfaceIDs);
}

void MachineryManager::LoadSensorADTubeAngleCommunicateInterfaceIDs()
{
	std::map<string, int> interfaceIDs;
	interfaceIDs[ID_TUBE_ANGLE_AD] = IOInterfaceMapper::ID_TUBE_ANGLE_AD;
	m_adTubeAngle->LoadCommunicationInterfaceIDs(interfaceIDs);
}

void MachineryManager::LoadSensorEncoderTubeAngleCommunicateInterfaceIDs()
{
	std::map<string, int> interfaceIDs;
	interfaceIDs[ID_TUBE_ANGLE_ENCODER] = IOInterfaceMapper::ID_TUBE_ANGLE_ENCODER;
	m_encoderTubeAngle->LoadCommunicationInterfaceIDs(interfaceIDs);
}

void MachineryManager::LoadSensorADTubeHeightCommunicateInterfaceIDs()
{
	std::map<string, int> interfaceIDs;
	interfaceIDs[ID_TUBE_HEIGHT_AD] = IOInterfaceMapper::ID_TUBE_HEIGHT_AD;
	m_adTubeHeight->LoadCommunicationInterfaceIDs(interfaceIDs);
}

void MachineryManager::LoadSensorEncoderTubeHeightCommunicateInterfaceIDs()
{
	std::map<string, int> interfaceIDs;
	interfaceIDs[ID_TUBE_HEIGHT_ENCODER] = IOInterfaceMapper::ID_TUBE_HEIGHT_ENCODER;
	m_encoderTubeHeight->LoadCommunicationInterfaceIDs(interfaceIDs);
}

void MachineryManager::LoadSensorADDetectorHeightCommunicateInterfaceIDs()
{
	std::map<string, int> interfaceIDs;
	interfaceIDs[ID_DETECTOR_HEIGHT_AD] = IOInterfaceMapper::ID_DETECTOR_HEIGHT_AD;
	m_adDetectorHeight->LoadCommunicationInterfaceIDs(interfaceIDs);
}

void MachineryManager::LoadSensorEncoderDetectorHeightCommunicateInterfaceIDs()
{
	std::map<string, int> interfaceIDs;
	m_encoderDetectorHeight->LoadCommunicationInterfaceIDs(interfaceIDs);
}

void MachineryManager::LoadSensorADTubeHorizontalCommunicateInterfaceIDs()
{
	std::map<string, int> interfaceIDs;
	interfaceIDs[ID_TUBE_HORIZONTAL_AD] = IOInterfaceMapper::ID_TUBE_HORIZONTAL_AD;
	m_adTubeHorizontal->LoadCommunicationInterfaceIDs(interfaceIDs);
}

void MachineryManager::LoadSensorEncoderTubeHorizontalCommunicateInterfaceIDs()
{
	std::map<string, int> interfaceIDs;
	interfaceIDs[ID_TUBE_HORIZONTAL_ENCODER] = IOInterfaceMapper::ID_TUBE_HORIZONTAL_ENCODER;
	m_encoderTubeHorizontal->LoadCommunicationInterfaceIDs(interfaceIDs);
}

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

void MachineryManager::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;
	interfaceIDs[ID_TUBE_HORIZONTAL_LEFT_LIMIT] = IOInterfaceMapper::ID_TUBE_HORIZONTAL_LEFT_LIMIT;
	interfaceIDs[ID_TUBE_HORIZONTAL_RIGHT_LIMIT] = IOInterfaceMapper::ID_TUBE_HORIZONTAL_RIGHT_LIMIT;
	m_landmark->LoadCommunicationInterfaceIDs(interfaceIDs);
}

void MachineryManager::SetupMotorBrake()
{
	auto hswfiltertime = ConfigurerMotion::GetFilterTimeMotorBrake();
	if (hswfiltertime < 1)
	{
		hswfiltertime = 2;
	}

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

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

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

void MachineryManager::LoadOutputSignalInterfaceIDs()
{
	std::map<string, int> interfaceIDs;
	interfaceIDs[ID_TUBE_LINE_MOTION_SWITCH_OUT] = IOInterfaceMapper::ID_TUBE_LINE_MOTION_SWITCH_OUT;
	m_tubeLineMotionSwitch->LoadCommunicationInterfaceIDs(interfaceIDs);
}

void MachineryManager::LoadSensorADDetectorHorizontalCommunicateInterfaceIDs()
{
	if (IOInterfaceMapper::ID_DETECTOR_HORIZONTAL_AD > 0)
	{
		std::map<string, int> interfaceIDs;
		interfaceIDs[ID_DETECTOR_HORIZONTAL_AD] = IOInterfaceMapper::ID_DETECTOR_HORIZONTAL_AD;
		m_adDetectorHorizontal->LoadCommunicationInterfaceIDs(interfaceIDs);
	}
}

void MachineryManager::LoadSensorEncoderDetectorHorizontalCommunicateInterfaceIDs()
{
	std::map<string, int> interfaceIDs;
	m_encoderDetectorHeight->LoadCommunicationInterfaceIDs(interfaceIDs);
}