PhysicalDevice/Machine/MachineryECOM/Trunk/DIOS.Dev.Machinery.Common/DIOS.Dev.Machinery.BaseLogic/PacketDispatcher.cpp

#include "stdafx.h"
#include "PacketDispatcher.h"
#include "IExamHandler.h"
#include "DIOSBoardProtocolParser.h"
#include "PacketDefine.h"
#include "IWorkFlowManager.h"
#include "CanDeviceMessageCenter.h"
#include "DeviceDataDef.h"

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


PacketDispatcher::PacketDispatcher() :m_workflowManager(nullptr)
{
}


PacketDispatcher::~PacketDispatcher()
{
}

void PacketDispatcher::Initialize(IWorkflowManager *workflowmanager)
{
	m_workflowManager = workflowmanager;
}

void PacketDispatcher::DispatchPacket(SCFPacket *packet)
{
	//if(gcommLog) gcommLog->Info("[PacketDispatcher][DispatchPacket]->[%s]", FormatPacketString(packet).c_str());
	{ if (gcommLog) { gcommLog->Info("[PacketDispatcher][DispatchPacket]->[{$}]", FormatPacketString(packet).c_str()); } }

	PacketNotifyType pnt = PNT_NAN;

	PacketClass pc = DIOSBoardProtocolParser::IdentifyPacketClass(packet);
	if (pc == PC_NOTIFY)
	{
		pnt = DIOSBoardProtocolParser::IdentifyPacketNotifyType(packet);
	}

	if (m_workflowManager == nullptr)
	{
		return;
	}

	if (pnt == PNT_SYSTEM_RESET_START || pnt == PNT_SYSTEM_RESET_SWING_START || pnt == PNT_SYSTEM_RESET_CIRCULAR_START)
	{
		m_workflowManager->ChangeToResetMode();
	}

	IExamHandler *handler = m_workflowManager->GetCurrentWorkFlowHandler();

	if (handler != nullptr)
	{
		if(gbusinessLog) gbusinessLog->Info("[DispatchPacket]->[Dispatch Packet To {$}]", handler->Name().c_str());

		switch (pnt)
		{
		case PNT_SYSTEM_RESET_START:
		{
									   m_workflowManager->EnterSystemReset();
		}
			break;
		case PNT_SYSTEM_RESET_STOP:
		{
									  m_workflowManager->ExitSystemReset();
									  break;
		}
		case PNT_SYSTEM_RESET_SWING_START:
			m_workflowManager->EnterSystemResetSwing();
			break;
		case PNT_SYSTEM_RESET_SWING_STOP:
			m_workflowManager->ExitSystemResetSwing();
			break;
		case PNT_SYSTEM_RESET_CIRCULAR_START:
			m_workflowManager->EnterSystemResetCircular();
			break;
		case PNT_SYSTEM_RESET_CIRCULAR_STOP:
			m_workflowManager->ExitSystemResetCircular();
			break;
		case PNT_HANDSWITCH_FIRST_PRESSED:
			handler->OnHandSwitchGearFirstPressed();
			break;
		case PNT_HANDSWITCH_FIRST_RELEASE:
			handler->OnHandSwitchGearFirstReleased();
			break;
		case PNT_HANDSWITCH_SECOND_PRESSED:
			handler->OnHandSwitchGearSecondPressed();
			break;
		case PNT_HANDSWITCH_SECOND_RELEASE:
			handler->OnHandSwitchGearSecondReleased();
			break;
		case PNT_PWM_OFFSET:
		{
							   
							   PWMOffsetPacket opacket;
							   if (DIOSBoardProtocolParser::ParsePWMOffsetPacket(packet, &opacket))
							   {
								   handler->OnPWMOffset(&opacket);
							   }
		}
			break;
		case PNT_CAN:
		{
							   CanDeviceData data;
							   if (DIOSBoardProtocolParser::ParseCanPacket(packet, &data))
							   {
								   CanDeviceMessageCenter::Instance()->OnMessageArrived(m_workflowManager, &data);
							   }						
		}
			break;
		case PNT_XRAY_ON:
			handler->OnXrayOn();
			break;
		case PNT_XRAY_OFF:
			handler->OnXrayOff();
			break;
		case PNT_TUBE_HEIGHT_AD:
		{						   
			TubeLineADPacket opacket;
			if (DIOSBoardProtocolParser::ParseTubeHeightADPacket(packet, &opacket))
			{
				handler->OnTubeHeightAD(&opacket);
			}
		}
			break;
		case PNT_TUBE_ANGLE_LOW_LIMIT:
			handler->OnTubeAngleLowLimitPos();
			break;
		case PNT_TUBE_ANGLE_HIGH_LIMIT:
			handler->OnTubeAngleHighLimitPos();
			break;
		case PNT_TUBE_ANGLE_LEAVE_LOW_LIMIT:
			handler->OnTubeAngleLeaveLowLimitPos();
			break;
		case PNT_TUBE_ANGLE_LEAVE_HIGH_LIMIT:
			handler->OnTubeAngleLeaveHighLimitPos();
			break;
		case PNT_TUBE_ANGLE_ENCODER:
		{
									   EncoderPacket opacket;
									   if (DIOSBoardProtocolParser::ParseEncoderPacket(packet, &opacket))
									   {
										   handler->OnTubeAngleEncoder(&opacket);
									   }
		}
			break;
		case PNT_TUBE_HEIGHT_ENCODER:
		{
										EncoderPacket opacket;
										if (DIOSBoardProtocolParser::ParseEncoderPacket(packet, &opacket))
										{
											handler->OnTubeHeightEncoder(&opacket);
										}
		}
			break;
		case PNT_TUBE_ANGLE_ENCODER_Z_CLEAR:
			handler->OnTubeAngleEncoderZPos();
			break;
		case PNT_TUBE_HEIGHT_HIGH_LIMIT:
		{
										   handler->OnTubeHeightHighLimitPos();
		}
			break;
		case PNT_TUBE_HEIGHT_LEAVE_HIGH_LIMIT:
		{
												 handler->OnTubeHeightLeaveHighLimitPos();
		}
			break;
		case PNT_TUBE_HEIGHT_LOW_LIMIT:
		{
										  handler->OnTubeHeightLowLimitPos();
		}
			break;
		case PNT_TUBE_HEIGHT_LEAVE_LOW_LIMIT:
		{
												handler->OnTubeHeightLeaveLowLimitPos();
		}
			break;
		case  PNT_TUBE_HEIGHT_ENCODER_Z_CLEAR:
			handler->OnTubeHeightEncoderZPos();
			break;
		case  PNT_TUBE_HEIGHT_CONTROLLER_DIRECTION_1_START:
			handler->OnStartMove(TOMO_TUBE_HEIGHT, 0);
			break;
		case  PNT_TUBE_HEIGHT_CONTROLLER_DIRECTION_1_STOP:
			handler->OnStopMove(TOMO_TUBE_HEIGHT);
			break;
		case  PNT_TUBE_HEIGHT_CONTROLLER_DIRECTION_2_START:
			handler->OnStartMove(TOMO_TUBE_HEIGHT, 1);
			break;
		case  PNT_TUBE_HEIGHT_CONTROLLER_DIRECTION_2_STOP:
			handler->OnStopMove(TOMO_TUBE_HEIGHT);
			break;
		case  PNT_TUBE_ANGLE_CONTROLLER_DIRECTION_1_START:
			handler->OnStartMove(TOMO_TUBE_ANGLE, 0);
			break;
		case  PNT_TUBE_ANGLE_CONTROLLER_DIRECTION_1_STOP:
			handler->OnStopMove(TOMO_TUBE_ANGLE);
			break;
		case  PNT_TUBE_ANGLE_CONTROLLER_DIRECTION_2_START:
			handler->OnStartMove(TOMO_TUBE_ANGLE, 1);
			break;
		case  PNT_TUBE_ANGLE_CONTROLLER_DIRECTION_2_STOP:
			handler->OnStopMove(TOMO_TUBE_ANGLE);
			break;
		case PNT_CARM_SCANNING_SWITCH_SWING:
			m_workflowManager->SwitchScanning(TOMO_TUBE_ANGLE);
			break;
		case PNT_CARM_SCANNING_SWITCH_CIRCULAR:
			m_workflowManager->SwitchScanning(TOMO_TUBE_HEIGHT);
			break;
		case PNT_TUBE_HORIZONTAL_CONTROLLER_DIRECTION_1_START:
			handler->OnStartMove(TOMO_TUBE_HORIZONTAL, 0);
			break;
		case PNT_TUBE_HORIZONTAL_CONTROLLER_DIRECTION_1_STOP:
			handler->OnStopMove(TOMO_TUBE_HORIZONTAL);
			break;
		case PNT_TUBE_HORIZONTAL_CONTROLLER_DIRECTION_2_START:
			handler->OnStartMove(TOMO_TUBE_HORIZONTAL, 1);
			break;
		case PNT_TUBE_HORIZONTAL_CONTROLLER_DIRECTION_2_STOP:
			handler->OnStopMove(TOMO_TUBE_HORIZONTAL);
			break;
		case PNT_TUBE_HORIZONTAL_ENCODER_Z_CLEAR:
			handler->OnTubeHorizontalEncoderZPos();
			break;
		case PNT_TUBE_HORIZONTAL_LEFT_LIMIT:
			handler->OnTubeHorizontalLeftLimitPos();
			break;
		case PNT_TUBE_HORIZONTAL_LEAVE_LEFT_LIMIT:
			handler->OnTubeHorizontalLeaveLeftLimitPos();
			break;
		case PNT_TUBE_HORIZONTAL_RIGHT_LIMIT:
			handler->OnTubeHorizontalRightLimitPos();
			break;
		case PNT_TUBE_HORIZONTAL_LEAVE_RIGHT_LIMIT:
			handler->OnTubeHorizontalLeaveRightLimitPos();
			break;
		default:
			break;
		}
	}
}

std::string PacketDispatcher::FormatPacketString(SCFPacket *packet)
{
	std::string formated = "";

	if (!packet || packet->GetPacketLen() <= 0)
	{
		return formated;
	}

	auto packetLength = packet->GetPacketLen();
	char *chpacket = (char *)(*packet);
	char tmp[16] = { 0 };
	for (DWORD i = 0; i < packetLength; ++i)
	{
		if ((i >= 2 && i <= 6) || (i == packetLength - 3))
		{
			formated = formated + "#";
		}
		memset(tmp, 0, sizeof(tmp));
		sprintf_s(tmp, "%02X", (unsigned char)chpacket[i]);
		formated = formated + std::string(tmp);
	}

	return formated;
}