// CPageGraph1.cpp: 实现文件
//

#include "stdafx.h"
#include "Servo.h"
#include "CPageGraph1.h"
#include "afxdialogex.h"
#include "Common.h"

const POINT g_arm1Offset = { -30, -45 }; // ARM1 从中心向左47, 向上33
const POINT g_arm2Offset = { 27, -45 };	 // ARM2 从中心向右10, 向上33

const std::map<SERVO::ROBOT_POSITION, RobotPositionMapping> g_positionMap = {
	{ SERVO::ROBOT_POSITION::Port1,     { SERVO::ROBOT_POSITION::Port1,     1.00f,   0.00f } },
	{ SERVO::ROBOT_POSITION::Port2,     { SERVO::ROBOT_POSITION::Port2,     0.90f,   0.00f } },
	{ SERVO::ROBOT_POSITION::Port3,     { SERVO::ROBOT_POSITION::Port3,     0.75f,   0.00f } },
	{ SERVO::ROBOT_POSITION::Port4,     { SERVO::ROBOT_POSITION::Port4,     0.60f,   0.00f } },
	{ SERVO::ROBOT_POSITION::Aligner,   { SERVO::ROBOT_POSITION::Aligner,   0.40f,   0.00f } },
	{ SERVO::ROBOT_POSITION::Fliper,    { SERVO::ROBOT_POSITION::Fliper,    0.25f,	 0.00f } },
	{ SERVO::ROBOT_POSITION::Bonder1,   { SERVO::ROBOT_POSITION::Bonder1,   0.00f,   0.00f } },
	{ SERVO::ROBOT_POSITION::Bonder2,   { SERVO::ROBOT_POSITION::Bonder2,   0.00f,   180.00f } },
	{ SERVO::ROBOT_POSITION::Bake,      { SERVO::ROBOT_POSITION::Bake,      0.35f,   180.00f } },
	{ SERVO::ROBOT_POSITION::Cooling,   { SERVO::ROBOT_POSITION::Cooling,   0.65f,   180.00f } },
	{ SERVO::ROBOT_POSITION::Measurement,{SERVO::ROBOT_POSITION::Measurement,1.00f,  180.00f } },
};

// Image
#define IMAGE_ROBOT				2

#define INDICATE_BONDER1		1
#define INDICATE_BONDER2		2
#define INDICATE_FLIPER			3
#define INDICATE_ALIGNER		4
#define INDICATE_LPORT4			5
#define INDICATE_LPORT3			6
#define INDICATE_LPORT2			7
#define INDICATE_LPORT1			8
#define INDICATE_ROBOT_ARM1		9
#define INDICATE_ROBOT_ARM2		10
#define INDICATE_VACUUM_BAKE	11
#define INDICATE_BAKE_COOLING	12
#define INDICATE_MEASUREMENT	13

// CPageGraph1 对话框

IMPLEMENT_DYNAMIC(CPageGraph1, CDialogEx)

CPageGraph1::CPageGraph1(CWnd* pParent /*=nullptr*/)
	: CDialogEx(IDD_PAGE_GRAPH1, pParent)
{
	m_pGraph = nullptr;
	m_pObserver = nullptr;
	m_bIsRobotMoving = FALSE;
	m_crBkgnd = PAGE_GRPAH1_BACKGROUND_COLOR;
	m_hbrBkgnd = nullptr;
}

CPageGraph1::~CPageGraph1()
{
}

void CPageGraph1::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
}


BEGIN_MESSAGE_MAP(CPageGraph1, CDialogEx)
	ON_WM_CTLCOLOR()
	ON_WM_DESTROY()
	ON_WM_SIZE()
	ON_NOTIFY(BYSERVOGRAPH_ITEM_CLICKED, IDC_SERVO_GRAPH1, &CPageGraph1::OnGraphItemClicked)
	ON_WM_ERASEBKGND()
	ON_WM_TIMER()
END_MESSAGE_MAP()


// CPageGraph1 消息处理程序


void CPageGraph1::InitRxWindows()
{
	/* code */
	// 订阅数据
	IRxWindows* pRxWindows = RX_GetRxWindows();
	pRxWindows->enableLog(5);
	if (m_pObserver == NULL) {
		m_pObserver = pRxWindows->allocObserver([&](IAny* pAny) -> void {
			// onNext
			pAny->addRef();
			int code = pAny->getCode();
			if (RX_CODE_EQ_ALIVE == code) {
				// 通知设备状态
				SERVO::CEquipment* pEquipment = nullptr;
				if (pAny->getPtrValue("ptr", (void*&)pEquipment)) {
					if (pEquipment != nullptr) {
						int nID = pEquipment->getID();
						BOOL bAlive = pEquipment->isAlive();
						if (EQ_ID_EFEM == nID) {
							DeviceStatus status = bAlive ? DeviceStatus::ONLINE : DeviceStatus::OFFLINE;
							UpdateDeviceStatus(INDICATE_FLIPER, status);
							UpdateDeviceStatus(INDICATE_ALIGNER, status);
							UpdateDeviceStatus(INDICATE_LPORT1, status);
							UpdateDeviceStatus(INDICATE_LPORT2, status);
							UpdateDeviceStatus(INDICATE_LPORT3, status);
							UpdateDeviceStatus(INDICATE_LPORT4, status);
							UpdateDeviceStatus(INDICATE_ROBOT_ARM1, status);
							UpdateDeviceStatus(INDICATE_ROBOT_ARM2, status);
						}
						else if(EQ_ID_Bonder1 == nID) {
							DeviceStatus status = bAlive ? DeviceStatus::ONLINE : DeviceStatus::OFFLINE;
							UpdateDeviceStatus(INDICATE_BONDER1, status);
						}
						else if (EQ_ID_Bonder2 == nID) {
							DeviceStatus status = bAlive ? DeviceStatus::ONLINE : DeviceStatus::OFFLINE;
							UpdateDeviceStatus(INDICATE_BONDER2, status);
						}
						else if (EQ_ID_VACUUMBAKE == nID) {
							DeviceStatus status = bAlive ? DeviceStatus::ONLINE : DeviceStatus::OFFLINE;
							UpdateDeviceStatus(INDICATE_VACUUM_BAKE, status);
						}
						else if (EQ_ID_BAKE_COOLING == nID) {
							DeviceStatus status = bAlive ? DeviceStatus::ONLINE : DeviceStatus::OFFLINE;
							UpdateDeviceStatus(INDICATE_BAKE_COOLING, status);
						}
						else if (EQ_ID_MEASUREMENT == nID) {
							DeviceStatus status = bAlive ? DeviceStatus::ONLINE : DeviceStatus::OFFLINE;
							UpdateDeviceStatus(INDICATE_MEASUREMENT, status);
						}
					}
				}
			}

			pAny->release();
			}, [&]() -> void {
				// onComplete
			}, [&](IThrowable* pThrowable) -> void {
				// onErrorm
				pThrowable->printf();
			});

		theApp.m_model.getObservable()->observeOn(pRxWindows->mainThread())
			->subscribe(m_pObserver);
	}
}

BOOL CPageGraph1::OnInitDialog()
{
	CDialogEx::OnInitDialog();
	InitRxWindows();
	SetTimer(1, 3000, nullptr);


	// 图示
	m_pGraph = CServoGraph::Hook(GetDlgItem(IDC_SERVO_GRAPH1)->GetSafeHwnd());
	CString strPath;
	strPath.Format(_T("%s\\res\\Servo001.bmp"), (LPTSTR)(LPCTSTR)theApp.m_strAppDir);
	m_pGraph->AddImage(1, (LPTSTR)(LPCTSTR)strPath, 0, 0);

	strPath.Format(_T("%s\\res\\Robot001.bmp"), (LPTSTR)(LPCTSTR)theApp.m_strAppDir);
	m_pGraph->AddImage(IMAGE_ROBOT, (LPTSTR)(LPCTSTR)strPath, 170, 270);

	// 添加指示器
	// Bonder
	m_pGraph->AddIndicateBox(INDICATE_BONDER1, 220, 172, 48, RGB(22, 22, 22),
		RGB(255, 127, 39), EQ_BOX_OFFLINE);
	m_pGraph->SetBoxText(INDICATE_BONDER1, "10", "Bonder 1");
	m_pGraph->AddIndicateBox(INDICATE_BONDER2, 220, 516, 48, RGB(22, 22, 22),
		RGB(255, 127, 39), EQ_BOX_OFFLINE);
	m_pGraph->SetBoxText(INDICATE_BONDER2, "11", "Bonder 2");


	// 翻转
	m_pGraph->AddIndicateBox(INDICATE_FLIPER, 338, 172, 48, RGB(22, 22, 22),
		RGB(255, 127, 39), EQ_BOX_OFFLINE);
	m_pGraph->SetBoxText(INDICATE_FLIPER, "8", "Fliper");


	// 对位
	m_pGraph->AddIndicateBox(INDICATE_ALIGNER, 428, 172, 48, RGB(22, 22, 22),
		RGB(255, 127, 39), EQ_BOX_OFFLINE);
	m_pGraph->SetBoxText(INDICATE_ALIGNER, "7", "Aligner");


	// Load port 4
	m_pGraph->AddIndicateBox(INDICATE_LPORT4, 518, 172, 48, RGB(22, 22, 22),
		RGB(255, 127, 39), EQ_BOX_OFFLINE);
	m_pGraph->SetBoxText(INDICATE_LPORT4, "4", "LPort4");


	// Load port 3
	m_pGraph->AddIndicateBox(INDICATE_LPORT3, 606, 172, 48, RGB(22, 22, 22),
		RGB(255, 127, 39), EQ_BOX_OFFLINE);
	m_pGraph->SetBoxText(INDICATE_LPORT3, "3", "LPort3");


	// Load port 2
	m_pGraph->AddIndicateBox(INDICATE_LPORT2, 690, 172, 48, RGB(22, 22, 22),
		RGB(255, 127, 39), EQ_BOX_OFFLINE);
	m_pGraph->SetBoxText(INDICATE_LPORT2, "2", "LPort2");


	// Load port 1
	m_pGraph->AddIndicateBox(INDICATE_LPORT1, 774, 172, 48, RGB(22, 22, 22),
		RGB(255, 127, 39), EQ_BOX_OFFLINE);
	m_pGraph->SetBoxText(INDICATE_LPORT1, "1", "LPort1");


	// Robot
	m_pGraph->AddIndicateBox(INDICATE_ROBOT_ARM1, 190, 294, 48, RGB(22, 22, 22),
		RGB(255, 127, 39), EQ_BOX_OFFLINE);
	m_pGraph->SetBoxText(INDICATE_ROBOT_ARM1, "5", "Robot");
	m_pGraph->AddIndicateBox(INDICATE_ROBOT_ARM2, 243, 294, 48, RGB(22, 22, 22),
		RGB(255, 127, 39), EQ_BOX_OFFLINE);
	m_pGraph->SetBoxText(INDICATE_ROBOT_ARM2, "6", "Robot");


	// Vacuum bake
	m_pGraph->AddIndicateBox(INDICATE_VACUUM_BAKE, 396, 516, 48, RGB(22, 22, 22),
		RGB(255, 127, 39), EQ_BOX_OFFLINE);
	m_pGraph->SetBoxText(INDICATE_VACUUM_BAKE, "9", "Vacuum bake");


	// Bake cooling
	m_pGraph->AddIndicateBox(INDICATE_BAKE_COOLING, 566, 516, 48, RGB(22, 22, 22),
		RGB(255, 127, 39), EQ_BOX_OFFLINE);
	m_pGraph->SetBoxText(INDICATE_BAKE_COOLING, "12", "Bake cooling");


	// 精度检
	m_pGraph->AddIndicateBox(INDICATE_MEASUREMENT, 737, 516, 48, RGB(22, 22, 22),
		RGB(255, 127, 39), EQ_BOX_OFFLINE);
	m_pGraph->SetBoxText(INDICATE_MEASUREMENT, "13", "Measurement");


	return TRUE;  // return TRUE unless you set the focus to a control
				  // 异常: OCX 属性页应返回 FALSE
}

void CPageGraph1::UpdateDeviceStatus(int id, DeviceStatus status)
{
	// 根据状态设置颜色
	COLORREF newBackgroundColor;
	COLORREF newFrameColor1;
	COLORREF newFrameColor2;

	switch (status) {
	case ONLINE:
		newBackgroundColor = EQ_BOX_ONLINE;
		newFrameColor1 = EQ_BOX_FRAME1;
		newFrameColor2 = EQ_BOX_FRAME2;
		break;
	case OFFLINE:
		newBackgroundColor = RGB(222, 222, 222);
		newFrameColor1 = EQ_BOX_FRAME1;
		newFrameColor2 = EQ_BOX_FRAME2;
		break;
	default:
		newBackgroundColor = RGB(255, 255, 255); // 默认白色背景
		newFrameColor1 = RGB(0, 0, 0);           // 默认黑色框架1
		newFrameColor2 = RGB(0, 0, 0);           // 默认黑色框架2
		break;
	}

	m_pGraph->UpdateIndicateBox1Colors(id, newBackgroundColor, newFrameColor1, newFrameColor2);

	// 刷新界面
	Invalidate();
	UpdateWindow();
}

BOOL CPageGraph1::OnEraseBkgnd(CDC* pDC)
{
	// TODO: 在此添加消息处理程序代码和/或调用默认值
	if (m_bIsRobotMoving) {
		// 禁止刷新背景，避免闪烁
		return TRUE;
	}

	return CDialogEx::OnEraseBkgnd(pDC);
}

HBRUSH CPageGraph1::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
{
	HBRUSH hbr = CDialogEx::OnCtlColor(pDC, pWnd, nCtlColor);

	if (nCtlColor == CTLCOLOR_STATIC) {
		pDC->SetBkColor(m_crBkgnd);
		pDC->SetTextColor(RGB(0, 0, 0));
	}

	if (m_hbrBkgnd == nullptr) {
		m_hbrBkgnd = CreateSolidBrush(m_crBkgnd);
	}

	return m_hbrBkgnd;
}

void CPageGraph1::OnDestroy()
{
	CDialogEx::OnDestroy();

	if (m_hbrBkgnd != nullptr) {
		::DeleteObject(m_hbrBkgnd);
	}

	if (m_pObserver != nullptr) {
		m_pObserver->unsubscribe();
		m_pObserver = NULL;
	}
}

void CPageGraph1::OnSize(UINT nType, int cx, int cy)
{
	CDialogEx::OnSize(nType, cx, cy);
	if (GetDlgItem(IDC_SERVO_GRAPH1) == nullptr) return;

	CRect rcClient;
	GetClientRect(&rcClient);
	GetDlgItem(IDC_SERVO_GRAPH1)->MoveWindow(0, 0, rcClient.Width(), rcClient.Height());
}

void CPageGraph1::UpdateRobotPosition(float percentage)
{
	if (percentage < 0.0f) percentage = 0.0f;
	if (percentage > 1.0f) percentage = 1.0f;

	auto* pImage = m_pGraph->GetImage(IMAGE_ROBOT);
	if (!pImage) return;

	// 获取当前角度（已通过 RotateRobot 设置）
	float angleDegrees = pImage->angle;
	float radians = angleDegrees * 3.1415926f / 180.0f;

	int startX = pImage->x;
	int endX = static_cast<int>(170 + percentage * (700 - 170));
	int y = 270;
	int cy = y + pImage->bmHeight / 2;

	// 动画时间
	int distance = abs(endX - startX);
	int duration = static_cast<int>((distance / 100.0f) * 1000);
	auto startTime = std::chrono::steady_clock::now();
	auto endTime = startTime + std::chrono::milliseconds(duration);

	m_bIsRobotMoving = TRUE;

	while (std::chrono::steady_clock::now() < endTime) {
		auto currentTime = std::chrono::steady_clock::now();
		float progress = std::chrono::duration<float, std::milli>(currentTime - startTime).count() / duration;
		progress = min(progress, 1.0f);

		int currentX = static_cast<int>(startX + progress * (endX - startX));
		int cx = currentX + pImage->bmWidth / 2;

		// 旋转后的偏移
		int rotatedX1 = static_cast<int>(cos(radians) * g_arm1Offset.x - sin(radians) * g_arm1Offset.y);
		int rotatedY1 = static_cast<int>(sin(radians) * g_arm1Offset.x + cos(radians) * g_arm1Offset.y);
		int rotatedX2 = static_cast<int>(cos(radians) * g_arm2Offset.x - sin(radians) * g_arm2Offset.y);
		int rotatedY2 = static_cast<int>(sin(radians) * g_arm2Offset.x + cos(radians) * g_arm2Offset.y);

		// 应用所有元素的新坐标
		m_pGraph->UpdateImageCoordinates(IMAGE_ROBOT, currentX, y);
		m_pGraph->UpdateIndicateBoxCoordinates(INDICATE_ROBOT_ARM1, cx + rotatedX1, cy + rotatedY1);
		m_pGraph->UpdateIndicateBoxCoordinates(INDICATE_ROBOT_ARM2, cx + rotatedX2, cy + rotatedY2);

		Invalidate();
		UpdateWindow();
		std::this_thread::sleep_for(std::chrono::milliseconds(16));
	}

	// 最终位置校正
	int cx = endX + pImage->bmWidth / 2;
	int rotatedX1 = static_cast<int>(cos(radians) * g_arm1Offset.x - sin(radians) * g_arm1Offset.y);
	int rotatedY1 = static_cast<int>(sin(radians) * g_arm1Offset.x + cos(radians) * g_arm1Offset.y);
	int rotatedX2 = static_cast<int>(cos(radians) * g_arm2Offset.x - sin(radians) * g_arm2Offset.y);
	int rotatedY2 = static_cast<int>(sin(radians) * g_arm2Offset.x + cos(radians) * g_arm2Offset.y);

	m_pGraph->UpdateImageCoordinates(IMAGE_ROBOT, endX, y);
	m_pGraph->UpdateIndicateBoxCoordinates(INDICATE_ROBOT_ARM1, cx + rotatedX1, cy + rotatedY1);
	m_pGraph->UpdateIndicateBoxCoordinates(INDICATE_ROBOT_ARM2, cx + rotatedX2, cy + rotatedY2);

	Invalidate();
	m_bIsRobotMoving = FALSE;
}

void CPageGraph1::RotateRobot(float angleInDegrees)
{
	// 获取机器人图片
	auto* pImage = m_pGraph->GetImage(IMAGE_ROBOT);
	if (!pImage) return;

	// 修正角度为 0~360
	float finalAngle = fmod(angleInDegrees + 360.0f, 360.0f);
	m_pGraph->UpdateImageAngle(IMAGE_ROBOT, finalAngle);

	// 计算中心点
	int cx = pImage->x + pImage->bmWidth / 2;
	int cy = pImage->y + pImage->bmHeight / 2;

	// 转换角度为弧度
	float radians = angleInDegrees * 3.1415926f / 180.0f;

	// 旋转 offset1
	int rotatedX1 = static_cast<int>(cos(radians) * g_arm1Offset.x - sin(radians) * g_arm1Offset.y);
	int rotatedY1 = static_cast<int>(sin(radians) * g_arm1Offset.x + cos(radians) * g_arm1Offset.y);

	// 旋转 offset2
	int rotatedX2 = static_cast<int>(cos(radians) * g_arm2Offset.x - sin(radians) * g_arm2Offset.y);
	int rotatedY2 = static_cast<int>(sin(radians) * g_arm2Offset.x + cos(radians) * g_arm2Offset.y);

	// 更新指示框
	m_pGraph->UpdateIndicateBoxCoordinates(INDICATE_ROBOT_ARM1, cx + rotatedX1, cy + rotatedY1);
	m_pGraph->UpdateIndicateBoxCoordinates(INDICATE_ROBOT_ARM2, cx + rotatedX2, cy + rotatedY2);

	Invalidate();
}

void CPageGraph1::BindEquipmentToGraph()
{
	struct EquipmentBindInfo
	{
		int nEquipmentID;
		int nIndicateID;
	};

	static const EquipmentBindInfo EQUIPMENT_BIND_LIST[] = {
		{ EQ_ID_EFEM,           INDICATE_ROBOT_ARM1 },
		{ EQ_ID_EFEM,           INDICATE_ROBOT_ARM2 },
		{ EQ_ID_Bonder1,        INDICATE_BONDER1 },
		{ EQ_ID_Bonder2,        INDICATE_BONDER2 },
		{ EQ_ID_LOADPORT1,      INDICATE_LPORT1 },
		{ EQ_ID_LOADPORT2,      INDICATE_LPORT2 },
		{ EQ_ID_LOADPORT3,      INDICATE_LPORT3 },
		{ EQ_ID_LOADPORT4,      INDICATE_LPORT4 },
		{ EQ_ID_FLIPER,         INDICATE_FLIPER },
		{ EQ_ID_VACUUMBAKE,     INDICATE_VACUUM_BAKE },
		{ EQ_ID_ALIGNER,        INDICATE_ALIGNER },
		{ EQ_ID_BAKE_COOLING,   INDICATE_BAKE_COOLING }
	};

	for (const auto& stBindInfo : EQUIPMENT_BIND_LIST)
	{
		SERVO::CEquipment* pEquipment = theApp.m_model.m_master.getEquipment(stBindInfo.nEquipmentID);
		m_pGraph->SetIndicateBoxData(stBindInfo.nIndicateID, pEquipment);
	}
}

void CPageGraph1::MoveRobotToPosition(SERVO::ROBOT_POSITION position)
{
	auto it = g_positionMap.find(position);
	if (it == g_positionMap.end()) {
		TRACE("Invalid robot position: %d\n", static_cast<int>(position));
		return;
	}

	const RobotPositionMapping& mapping = it->second;

	// 平台移动
	UpdateRobotPosition(mapping.percentage);

	// 旋转方向
	RotateRobot(mapping.angle);
}

void CPageGraph1::OnGraphItemClicked(NMHDR* pNMHDR, LRESULT* pResult)
{
	BYSERVOGRAPH_NMHDR* pGraphNmhdr = reinterpret_cast<BYSERVOGRAPH_NMHDR*>(pNMHDR);

	// 移动到指定位置 (测试使用)
	if (pGraphNmhdr->dwData == INDICATE_LPORT1) {
		MoveRobotToPosition(SERVO::ROBOT_POSITION::Port1);
	}
	else if (pGraphNmhdr->dwData == INDICATE_LPORT2) {
		MoveRobotToPosition(SERVO::ROBOT_POSITION::Port2);
	}
	else if (pGraphNmhdr->dwData == INDICATE_LPORT3) {
		MoveRobotToPosition(SERVO::ROBOT_POSITION::Port3);
	}
	else if (pGraphNmhdr->dwData == INDICATE_LPORT4) {
		MoveRobotToPosition(SERVO::ROBOT_POSITION::Port4);
	}
	else if (pGraphNmhdr->dwData == INDICATE_ALIGNER) {
		MoveRobotToPosition(SERVO::ROBOT_POSITION::Aligner);
	}
	else if (pGraphNmhdr->dwData == INDICATE_FLIPER) {
		MoveRobotToPosition(SERVO::ROBOT_POSITION::Fliper);
	}
	else if (pGraphNmhdr->dwData == INDICATE_BONDER1) {
		MoveRobotToPosition(SERVO::ROBOT_POSITION::Bonder1);
	}
	else if (pGraphNmhdr->dwData == INDICATE_BONDER2) {
		MoveRobotToPosition(SERVO::ROBOT_POSITION::Bonder2);
	}
	else if (pGraphNmhdr->dwData == INDICATE_VACUUM_BAKE) {
		MoveRobotToPosition(SERVO::ROBOT_POSITION::Bake);
	}
	else if (pGraphNmhdr->dwData == INDICATE_BAKE_COOLING) {
		MoveRobotToPosition(SERVO::ROBOT_POSITION::Cooling);
	}
	else if (pGraphNmhdr->dwData == INDICATE_MEASUREMENT) {
		MoveRobotToPosition(SERVO::ROBOT_POSITION::Measurement);
	}

	CString s; s.Format(_T("OnGraphItemClicked %d"), pGraphNmhdr->dwData);
	SERVO::CEquipment* pEquipment = (SERVO::CEquipment*)m_pGraph->GetIndicateBoxData(pGraphNmhdr->dwData);
	if (pEquipment != nullptr) {
		theApp.m_model.notifyPtr(RX_CODE_SELECT_EQUIPMENT, pEquipment);
	}
	
	*pResult = 0;
}

void CPageGraph1::OnTimer(UINT_PTR nIDEvent)
{
	if (1 == nIDEvent) {
		KillTimer(1);

		// 更新状态
		{
			SERVO::CEquipment* pEquipment = (SERVO::CEFEM*)theApp.m_model.m_master.getEquipment(EQ_ID_EFEM);
			ASSERT(pEquipment);
			DeviceStatus status = pEquipment->isAlive() ? DeviceStatus::ONLINE : DeviceStatus::OFFLINE;
			UpdateDeviceStatus(INDICATE_ROBOT_ARM1, status);
			UpdateDeviceStatus(INDICATE_ROBOT_ARM2, status);
		}

		{
			SERVO::CEquipment* pEquipment = theApp.m_model.m_master.getEquipment(EQ_ID_Bonder1);
			ASSERT(pEquipment);
			DeviceStatus status = pEquipment->isAlive() ? DeviceStatus::ONLINE : DeviceStatus::OFFLINE;
			UpdateDeviceStatus(INDICATE_BONDER1, status);
		}

		{
			SERVO::CEquipment* pEquipment = theApp.m_model.m_master.getEquipment(EQ_ID_Bonder2);
			ASSERT(pEquipment);
			DeviceStatus status = pEquipment->isAlive() ? DeviceStatus::ONLINE : DeviceStatus::OFFLINE;
			UpdateDeviceStatus(INDICATE_BONDER2, status);
		}
	}

	CDialogEx::OnTimer(nIDEvent);
}