Merge branch 'liuyang' into clh

LAPTOP-SNT8I5JK\Boounion

2024-12-02 aedb3b85fed48cb2cf0abb5fafa8e7591644c9f4

 SourceCode/Bond/BondEq/View/AxisSettingsDlg.cpp

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,964 @@
// AxisSettingsDlg.cpp: å®žçŽ°æ–‡ä»¶
//

#include "stdafx.h"
#include "BondEq.h"
#include "afxdialogex.h"
#include "AxisSettingsDlg.h"
#include "ToolUnits.h"
#include <cctype>
#include <algorithm>

#define TIMER_INIT            1
#define TIMER_READ_PLC_DATA      2
#define TIMER_JOG_ADD           3
#define TIMER_JOG_SUB           4

// CAxisSettingsDlg å¯¹è¯æ¡†

IMPLEMENT_DYNAMIC(CAxisSettingsDlg, CDialogEx)

CAxisSettingsDlg::CAxisSettingsDlg(CWnd* pParent /*=nullptr*/)
   : CDialogEx(IDD_DIALOG_AXIS_SETTINGS, pParent)
{
   m_nInitialWidth = 0;
   m_nInitialHeight = 0;
   m_pPLC = nullptr;
}

CAxisSettingsDlg::~CAxisSettingsDlg()
{
   for (auto& pair : m_mapFonts) {
      if (pair.second) {
         pair.second->DeleteObject();
         delete pair.second;
      }
   }
   m_mapFonts.clear();
}

void CAxisSettingsDlg::SetPLC(CPLC* pPLC)
{
   ASSERT(pPLC);
   m_pPLC = pPLC;
}

void CAxisSettingsDlg::SetRecipeName(const CString& strRecipeName)
{
   m_strRecipeName = strRecipeName;
}

void CAxisSettingsDlg::DoDataExchange(CDataExchange* pDX)
{
   CDialogEx::DoDataExchange(pDX);
   DDX_Control(pDX, IDC_STATIC_AXIS_TEST_FLS, m_staticFLS);
   DDX_Control(pDX, IDC_STATIC_AXIS_TEST_DOG, m_staticDOG);
   DDX_Control(pDX, IDC_STATIC_AXIS_TEST_RLS, m_staticRLS);
   DDX_Control(pDX, IDC_STATIC_AXIS_TEST_READY, m_staticReady);
   DDX_Control(pDX, IDC_STATIC_AXIS_TEST_BUSY, m_staticBusy);
   DDX_Control(pDX, IDC_STATIC_AXIS_TEST_ERR, m_staticErr);
   DDX_Control(pDX, IDC_COMBO_AXIS_NAME, m_comboAxisNO);
   DDX_Control(pDX, IDC_STATIC_AXIS_NUMBER, m_staticAxisNO);
   DDX_Control(pDX, IDC_STATIC_AXIS_DESCRIP, m_staticAxisDescription);
   DDX_Control(pDX, IDC_STATIC_START_ADDRESS, m_staticStartAddress);
   DDX_Control(pDX, IDC_EDIT_AXIS_MODITFY_POS, m_editManualSpeed);
   DDX_Control(pDX, IDC_EDIT_AXIS_MODITFY_AUTO_SPEED, m_editAutoSpeed);
   DDX_Control(pDX, IDC_EDIT_AXIS_MODITFY_ACCE_TIME, m_editAccelerationTime);
   DDX_Control(pDX, IDC_EDIT_AXIS_MODITFY_DECE_TIME, m_editDecelerationTime);
   DDX_Control(pDX, IDC_EDIT_AXIS_MODITFY_MICROMENTUM, m_editJogDistance);
   DDX_Control(pDX, IDC_BUTTON_AXIS_ANCHOR_POINT_GROUP1, m_pageButtons[0]);
   DDX_Control(pDX, IDC_BUTTON_AXIS_ANCHOR_POINT_GROUP2, m_pageButtons[1]);
   DDX_Control(pDX, IDC_BUTTON_AXIS_ANCHOR_POINT_GROUP3, m_pageButtons[2]);
   DDX_Control(pDX, IDC_BUTTON_AXIS_ANCHOR_POINT_GROUP4, m_pageButtons[3]);
   DDX_Control(pDX, IDC_BUTTON_AXIS_ANCHOR_POINT_GROUP5, m_pageButtons[4]);
}

UINT CAxisSettingsDlg::FindIDByName(const CString& strControlID)
{
   // å°†èµ„源文件中定义的控件名称和 ID åŠ è½½åˆ°ä¸€ä¸ªæ˜ å°„中
   static const std::map<CString, UINT> controlIdMap = {
      {"IDC_EDIT_AXIS_ANCHOR_POINT_DESCRIP1", IDC_EDIT_AXIS_ANCHOR_POINT_DESCRIP1},
      {"IDC_EDIT_AXIS_ANCHOR_POINT_DESCRIP2", IDC_EDIT_AXIS_ANCHOR_POINT_DESCRIP2},
      {"IDC_EDIT_AXIS_ANCHOR_POINT_DESCRIP3", IDC_EDIT_AXIS_ANCHOR_POINT_DESCRIP3},
      {"IDC_EDIT_AXIS_ANCHOR_POINT_DESCRIP4", IDC_EDIT_AXIS_ANCHOR_POINT_DESCRIP4},
      {"IDC_EDIT_AXIS_ANCHOR_POINT_DESCRIP5", IDC_EDIT_AXIS_ANCHOR_POINT_DESCRIP5},
      {"IDC_EDIT_AXIS_ANCHOR_POINT1", IDC_EDIT_AXIS_ANCHOR_POINT1},
      {"IDC_EDIT_AXIS_ANCHOR_POINT2", IDC_EDIT_AXIS_ANCHOR_POINT2},
      {"IDC_EDIT_AXIS_ANCHOR_POINT3", IDC_EDIT_AXIS_ANCHOR_POINT3},
      {"IDC_EDIT_AXIS_ANCHOR_POINT4", IDC_EDIT_AXIS_ANCHOR_POINT4},
      {"IDC_EDIT_AXIS_ANCHOR_POINT5", IDC_EDIT_AXIS_ANCHOR_POINT5}
      // å¯ä»¥ç»§ç»­æ·»åŠ å…¶ä»–控件名称和 ID
   };

   // æŸ¥æ‰¾æŽ§ä»¶åç§°æ˜¯å¦åœ¨æ˜ å°„中
   auto it = controlIdMap.find(strControlID);
   if (it != controlIdMap.end()) {
      return it->second;
   }

   return 0;
}

CFont* CAxisSettingsDlg::GetOrCreateFont(int nFontSize)
{
   auto it = m_mapFonts.find(nFontSize);
   if (it != m_mapFonts.end()) {
      return it->second;
   }

   CFont* font = new CFont();
   LOGFONT logFont = { 0 };
   _tcscpy_s(logFont.lfFaceName, _T("Segoe UI"));
   logFont.lfHeight = -nFontSize;
   logFont.lfQuality = CLEARTYPE_QUALITY;
   font->CreateFontIndirect(&logFont);
   m_mapFonts[nFontSize] = font;

   return font;
}

void CAxisSettingsDlg::SetDefaultFont()
{
   CFont* defaultFont = GetOrCreateFont(12);

   // éåŽ†æ‰€æœ‰æŽ§ä»¶ï¼Œåº”用默认字体
   CWnd* pWnd = GetWindow(GW_CHILD);
   while (pWnd) {
      pWnd->SetFont(defaultFont, TRUE);
      pWnd = pWnd->GetNextWindow();
   }
}

void CAxisSettingsDlg::AdjustControls(float dScaleX, float dScaleY)
{
   CWnd* pWnd = GetWindow(GW_CHILD);
   while (pWnd) {
      int nCtrlID = pWnd->GetDlgCtrlID();
      if (nCtrlID != -1 && m_mapCtrlLayouts.find(nCtrlID) != m_mapCtrlLayouts.end())
      {
         CRect originalRect = m_mapCtrlLayouts[nCtrlID];
         CRect newRect(
            static_cast<int>(originalRect.left * dScaleX),
            static_cast<int>(originalRect.top * dScaleY),
            static_cast<int>(originalRect.right * dScaleX),
            static_cast<int>(originalRect.bottom * dScaleY));

         TCHAR szClassName[256];
         GetClassName(pWnd->m_hWnd, szClassName, sizeof(szClassName));

         if (_tcsicmp(szClassName, _T("ComboBox")) == 0) {
            CComboBox* pComboBox = (CComboBox*)pWnd;
            pComboBox->SetItemHeight(-1, newRect.Height());  // -1 è¡¨ç¤ºæ‰€æœ‰é¡¹çš„高度
         }

         pWnd->MoveWindow(&newRect);
         AdjustControlFont(pWnd, newRect.Width(), newRect.Height());
      }
      pWnd = pWnd->GetNextWindow();
   }
}

void CAxisSettingsDlg::AdjustControlFont(CWnd* pWnd, int nWidth, int nHeight)
{
   // æ ¹æ®æŽ§ä»¶é«˜åº¦åŠ¨æ€è°ƒæ•´å­—体大小
   int fontSize = nHeight / 2;
   if (fontSize < 8) fontSize = 8;
   if (fontSize > 24) fontSize = 24;  // æœ€å¤§å­—体大小

   // èŽ·å–或创建字体
   CFont* pFont = GetOrCreateFont(fontSize);

   pWnd->SetFont(pFont);
   pWnd->Invalidate(); // åˆ·æ–°æŽ§ä»¶æ˜¾ç¤º
}

void CAxisSettingsDlg::AdjustLabelFont(CBLLabel& label)
{
   // èŽ·å–控件的矩形区域
   CRect rect;
   label.GetClientRect(&rect);

   // åŠ¨æ€è®¡ç®—字体大小，基于控件的高度
   int fontSize = rect.Height() / 2; // æŽ§ä»¶é«˜åº¦çš„一半作为字体大小
   if (fontSize < 8) fontSize = 8;   // æœ€å°å­—体大小
   if (fontSize > 30) fontSize = 30; // æœ€å¤§å­—体大小

   // è®¾ç½®å­—体大小
   label.SetFontSize(fontSize);

   // åˆ·æ–°æŽ§ä»¶æ˜¾ç¤º
   label.Invalidate();
   label.UpdateWindow();
}

void CAxisSettingsDlg::SetStatusColor(CBLLabel& label, BOOL bStatus)
{
   if (bStatus) {
      label.SetBkColor(RGB(0, 255, 0)); // ç»¿è‰²
   }
   else {
      label.SetBkColor(RGB(255, 0, 0)); // çº¢è‰²
   }

   label.Invalidate();              // æ ‡è®°åŒºåŸŸæ— æ•ˆ
   label.UpdateWindow();            // ç«‹å³åˆ·æ–°
}

void CAxisSettingsDlg::updatePageButtonStates()
{
   for (int i = 0; i < 5; ++i) {
      if (i + 1 == m_currentPage) {
         m_pageButtons[i].SetFaceColor(RGB(0, 122, 204));   // é€‰ä¸­èƒŒæ™¯è‰²ï¼ˆè“è‰²ï¼‰
      }
      else {
         m_pageButtons[i].SetFaceColor(RGB(240, 240, 240));   // é»˜è®¤èƒŒæ™¯è‰²
      }

      m_pageButtons[i].Invalidate();
   }
}

int CAxisSettingsDlg::getCurrentSelectedAxisID()
{
   int currentIndex = m_comboAxisNO.GetCurSel();
   if (currentIndex == CB_ERR) {
      return -1;
   }

   CString strAxisIDStr;
   m_comboAxisNO.GetLBText(currentIndex, strAxisIDStr);
   return _ttoi(strAxisIDStr);
}

void CAxisSettingsDlg::initializeAxisIDCombo()
{
   // æ£€æŸ¥é…æ–¹æ˜¯å¦åŠ è½½æˆåŠŸ
   RecipeManager& recipeManager = RecipeManager::getInstance();
   if (m_strRecipeName.IsEmpty() || !recipeManager.loadRecipe(std::string(CT2A(m_strRecipeName)))) {
      AfxMessageBox(_T("加载配方失败！"));
      return;
   }

   // èŽ·å–所有轴的编号
   auto axisNumbers = recipeManager.getAllAxisID();

   // æ¸…空下拉框
   m_comboAxisNO.ResetContent();

   // å¡«å……数据到下拉框
   for (const auto& axisID : axisNumbers) {
      CString axisCString;
      axisCString.Format(_T("%d"), axisID);
      m_comboAxisNO.AddString(axisCString);
   }

   // é»˜è®¤é€‰æ‹©ç¬¬ä¸€é¡¹
   if (m_comboAxisNO.GetCount() > 0) {
      m_comboAxisNO.SetCurSel(0);
   }
}

void CAxisSettingsDlg::refreshAxisDetails(int nAxisId)
{
   // èŽ·å–轴数据
   RecipeManager& recipeManager = RecipeManager::getInstance();
   auto axisDetails = recipeManager.getAxis(nAxisId);

   auto formatDouble = [](double value) -> CString {
      CString str;
      str.Format(_T("%.3f"), value);
      return str;
   };

   // æ›´æ–°æŽ§ä»¶æ˜¾ç¤º
   m_staticAxisNO.SetWindowText(CString(axisDetails.number.c_str()));               // è½´ç¼–号
   m_staticAxisDescription.SetWindowText(CString(axisDetails.description.c_str()));   // è½´æè¿°
   m_staticStartAddress.SetWindowText(CString(axisDetails.startAddress.c_str()));      // èµ·å§‹åœ°å€
   m_editJogDistance.SetWindowText(formatDouble(axisDetails.jogDistance));            // å¾®åŠ¨é‡
   m_editManualSpeed.SetWindowText(formatDouble(axisDetails.manualSpeed));            // æ‰‹åŠ¨é€Ÿåº¦
   m_editAutoSpeed.SetWindowText(formatDouble(axisDetails.autoSpeed));               // è‡ªåŠ¨é€Ÿåº¦
   m_editAccelerationTime.SetWindowText(formatDouble(axisDetails.accelerationTime));   // åŠ é€Ÿæ—¶é—´
   m_editDecelerationTime.SetWindowText(formatDouble(axisDetails.decelerationTime));   // å‡é€Ÿæ—¶é—´
}

void CAxisSettingsDlg::refreshPositionDetails(int nAxisId, int pageNumber)
{
   RecipeManager& recipeManager = RecipeManager::getInstance();
   // æ¯é¡µæ˜¾ç¤ºçš„定位点数量
   const int pageSize = 5;

   // èŽ·å–定位点数据
   auto positions = recipeManager.getPositions(nAxisId, pageNumber, pageSize);

   // åˆ·æ–° UI
   for (int i = 0; i < pageSize; ++i) {
      CString descriptionCtrlName, positionCtrlName;
      descriptionCtrlName.Format(_T("IDC_EDIT_AXIS_ANCHOR_POINT_DESCRIP%d"), i + 1);
      positionCtrlName.Format(_T("IDC_EDIT_AXIS_ANCHOR_POINT%d"), i + 1);

      UINT descriptionCtrlId = FindIDByName(descriptionCtrlName);
      UINT positionCtrlId = FindIDByName(positionCtrlName);

      CWnd* pDescriptionCtrl = GetDlgItem(descriptionCtrlId);
      CWnd* pPositionCtrl = GetDlgItem(positionCtrlId);

      if (i < positions.size()) {
         CString description = CString(positions[i].first.c_str());
         CString value;
         value.Format(_T("%.3f"), positions[i].second);

         if (pDescriptionCtrl) pDescriptionCtrl->SetWindowText(description);
         if (pPositionCtrl) pPositionCtrl->SetWindowText(value);
      }
      else {
         if (pDescriptionCtrl) pDescriptionCtrl->SetWindowText(_T(""));
         if (pPositionCtrl) pPositionCtrl->SetWindowText(_T(""));
      }
   }
}

void CAxisSettingsDlg::updateAxisSelection(int offset)
{
   int currentIndex = m_comboAxisNO.GetCurSel();
   if (currentIndex == CB_ERR) {
      AfxMessageBox(_T("请选择一个有效的轴编号！"));
      return;
   }

   int newIndex = currentIndex + offset;
   if (newIndex < 0 || newIndex >= m_comboAxisNO.GetCount()) {
      CString error;
      error.Format(_T("已经到达%s一个轴！"), offset < 0 ? _T("上") : _T("下"));
      AfxMessageBox(error);
      return;
   }

   m_comboAxisNO.SetCurSel(newIndex);
   refreshAxisDetails(newIndex + 1);
   refreshPositionDetails(newIndex + 1, m_currentPage);
   updatePageButtonStates();
}

void CAxisSettingsDlg::updateDataFromUI(int nAxisId)
{
   const int pageSize = 5; // æ¯é¡µæ˜¾ç¤º 5 ä¸ªå®šä½ç‚¹

   RecipeManager& recipeManager = RecipeManager::getInstance();
   auto axisData = recipeManager.getAxis(nAxisId);

   // èŽ·å–界面上的修改参数
   CString text;
   m_editManualSpeed.GetWindowText(text);
   axisData.manualSpeed = _ttof(text);

   m_editAutoSpeed.GetWindowText(text);
   axisData.autoSpeed = _ttof(text);

   m_editAccelerationTime.GetWindowText(text);
   axisData.accelerationTime = _ttof(text);

   m_editDecelerationTime.GetWindowText(text);
   axisData.decelerationTime = _ttof(text);

   m_editJogDistance.GetWindowText(text);
   axisData.jogDistance = _ttof(text);

   // æ›´æ–°å®šä½ç‚¹æ•°æ®
   for (int i = 0; i < pageSize; ++i) {
      int index = (m_currentPage - 1) * pageSize + i;

      if (index < axisData.positions.size()) {
         CString descriptionName, positionName;
         descriptionName.Format(_T("IDC_EDIT_AXIS_ANCHOR_POINT_DESCRIP%d"), i + 1);
         positionName.Format(_T("IDC_EDIT_AXIS_ANCHOR_POINT%d"), i + 1);

         CEdit* pDescriptionEdit = (CEdit*)GetDlgItem(FindIDByName(descriptionName));
         CEdit* pPositionEdit = (CEdit*)GetDlgItem(FindIDByName(positionName));

         if (pDescriptionEdit && pPositionEdit) {
            CString description, positionValue;
            pDescriptionEdit->GetWindowText(description);
            pPositionEdit->GetWindowText(positionValue);

            // æ›´æ–° RecipeManager ä¸­çš„数据
            axisData.positions[index].first = CT2A(description);
            axisData.positions[index].second = _ttof(positionValue);
         }
      }
   }

   // ä¿å­˜å›ž RecipeManager
   recipeManager.updateAxis(axisData);
}

void CAxisSettingsDlg::switchToPage(int targetPage)
{
   try {
      // å¦‚果当前页面已经是目标页面，直接返回
      if (m_currentPage == targetPage) {
         return;
      }

      // èŽ·å–当前选中的轴 ID
      int axisId = getCurrentSelectedAxisID();
      if (axisId == -1) {
         AfxMessageBox(_T("请选择一个有效的轴编号！"));
         return;
      }

      // æ›´æ–° UI æ•°æ®åˆ°å†…å­˜
      updateDataFromUI(axisId);

      // åˆ‡æ¢é¡µé¢
      m_currentPage = targetPage;
      refreshPositionDetails(axisId, targetPage);
      updatePageButtonStates();
   }
   catch (const std::exception& ex) {
      CString errorMsg;
      errorMsg.Format(_T("刷新定位组%d失败：%s"), targetPage, CString(ex.what()));
      AfxMessageBox(errorMsg, MB_ICONERROR);
   }
}

void CAxisSettingsDlg::writeAxisDataToPLC(int nAxisId)
{
   // ä»Ž RecipeManager èŽ·å–轴数据
   RecipeManager& recipeManager = RecipeManager::getInstance();
   auto axisData = recipeManager.getAxis(nAxisId);

   // åŽ»é™¤éžæ•°å­—字符并转换起始地址
   std::string cleanAddress = axisData.startAddress;
   cleanAddress.erase(std::remove_if(cleanAddress.begin(), cleanAddress.end(),
      [](char c) { return !std::isdigit(c); }), cleanAddress.end());
   if (cleanAddress.empty()) {
      AfxMessageBox(_T("无效的起始地址！"));
      return;
   }
   int startAddress = std::stoi(cleanAddress);

   // å†™å…¥æ‰‹åŠ¨é€Ÿåº¦
   m_pPLC->writeWord(MC::SOFT_COMPONENT::D, 5120, (int)axisData.manualSpeed, [](IMcChannel* pChannel, int addr, DWORD value, int flag) {
      if (flag == 0) {
         TRACE("\n写入成功: æ‰‹åŠ¨é€Ÿåº¦, åœ°å€: %d, å€¼: %lu\n", addr, value);
      }
      else {
         TRACE("\n写入失败: æ‰‹åŠ¨é€Ÿåº¦, åœ°å€: %d, é”™è¯¯ç : %d\n", addr, flag);
      }
   });

   // å†™å…¥è‡ªåŠ¨é€Ÿåº¦
   m_pPLC->writeWord(MC::SOFT_COMPONENT::D, startAddress + 2, (int)axisData.autoSpeed, [](IMcChannel* pChannel, int addr, DWORD value, int flag) {
      if (flag == 0) {
         TRACE("\n写入成功: è‡ªåŠ¨é€Ÿåº¦, åœ°å€: %d, å€¼: %lu\n", addr, value);
      }
      else {
         TRACE("\n写入失败: è‡ªåŠ¨é€Ÿåº¦, åœ°å€: %d, é”™è¯¯ç : %d\n", addr, flag);
      }
   });

   // å†™å…¥åŠ é€Ÿæ—¶é—´, è½¬æ¢ä¸ºæ¯«ç§’
   m_pPLC->writeWord(MC::SOFT_COMPONENT::D, startAddress + 4, (int)(axisData.accelerationTime * 1000), [](IMcChannel* pChannel, int addr, DWORD value, int flag) {
      if (flag == 0) {
         TRACE("\n写入成功: åŠ é€Ÿæ—¶é—´, åœ°å€: %d, å€¼: %lu\n", addr, value);
      }
      else {
         TRACE("\n写入失败: åŠ é€Ÿæ—¶é—´, åœ°å€: %d, é”™è¯¯ç : %d\n", addr, flag);
      }
   });

   // å†™å…¥å‡é€Ÿæ—¶é—´, è½¬æ¢ä¸ºæ¯«ç§’
   m_pPLC->writeWord(MC::SOFT_COMPONENT::D, startAddress + 6, (int)(axisData.decelerationTime * 1000), [](IMcChannel* pChannel, int addr, DWORD value, int flag) {
      if (flag == 0) {
         TRACE("\n写入成功: å‡é€Ÿæ—¶é—´, åœ°å€: %d, å€¼: %lu\n", addr, value);
      }
      else {
         TRACE("\n写入失败: å‡é€Ÿæ—¶é—´, åœ°å€: %d, é”™è¯¯ç : %d\n", addr, flag);
      }
   });

   // å†™å…¥å¾®åŠ¨é‡
   m_pPLC->writeWord(MC::SOFT_COMPONENT::D, startAddress + 8, (int)axisData.jogDistance, [](IMcChannel* pChannel, int addr, DWORD value, int flag) {
      if (flag == 0) {
         TRACE("\n写入成功: å¾®åŠ¨é‡, åœ°å€: %d, å€¼: %lu\n", addr, value);
      }
      else {
         TRACE("\n写入失败: å¾®åŠ¨é‡, åœ°å€: %d, é”™è¯¯ç : %d\n", addr, flag);
      }
   });

   // å†™å…¥å®šä½ç‚¹æ•°æ®
   int positionStartAddress = startAddress + 10;
   for (size_t i = 0; i < axisData.positions.size(); ++i) {
      const auto& position = axisData.positions[i];
      int positionAddress = positionStartAddress + (i * 2);

      m_pPLC->writeWord(MC::SOFT_COMPONENT::D, positionAddress, (int)position.second, [i](IMcChannel* pChannel, int addr, DWORD value, int flag) {
         if (flag == 0) {
            TRACE("\n写入成功: å®šä½ç‚¹ %d, åœ°å€: %d, å€¼: %lu\n", i + 1, addr, value);
         }
         else {
            TRACE("\n写入失败: å®šä½ç‚¹ %d, åœ°å€: %d, é”™è¯¯ç : %d\n", i + 1, addr, flag);
         }
      });
   }
}

void CAxisSettingsDlg::handleAxisOperation(AxisOperationType eOpType, bool bPressed)
{
   int nAxisId = getCurrentSelectedAxisID();
   if (nAxisId == -1) {
      AfxMessageBox(_T("未选择有效的轴编号！"));
      return;
   }

   // èŽ·å–轴数据
   RecipeManager& recipeManager = RecipeManager::getInstance();
   auto axisData = recipeManager.getAxis(nAxisId);

   std::string strCleanAddress = axisData.startAddress;
   strCleanAddress.erase(std::remove_if(strCleanAddress.begin(), strCleanAddress.end(),
      [](unsigned char c) { return !std::isdigit(c); }), strCleanAddress.end());
   if (strCleanAddress.empty()) {
      AfxMessageBox(_T("无效的起始地址！"));
      return;
   }

   int nStartAddress = std::stoi(strCleanAddress);

   // æ ¹æ®æ“ä½œç±»åž‹è®¡ç®—目标地址
   int nTargetAddress = nStartAddress;
   switch (eOpType) {
   case AxisOperationType::OPR:
      nTargetAddress += 10; // OPR ä¿¡å·åœ°å€
      break;
   case AxisOperationType::JOG_ADD:
      nTargetAddress += 12; // JOG+ ä¿¡å·åœ°å€
      break;
   case AxisOperationType::JOG_SUB:
      nTargetAddress += 13; // JOG- ä¿¡å·åœ°å€
      break;
   case AxisOperationType::STOP:
      nTargetAddress += 14; // STOP ä¿¡å·åœ°å€
      break;
   case AxisOperationType::POSITION_1:
      nTargetAddress += 16; // å®šä½ç‚¹ 1 ä¿¡å·åœ°å€
      break;
   case AxisOperationType::POSITION_2:
      nTargetAddress += 18; // å®šä½ç‚¹ 2 ä¿¡å·åœ°å€
      break;
   case AxisOperationType::POSITION_3:
      nTargetAddress += 20; // å®šä½ç‚¹ 3 ä¿¡å·åœ°å€
      break;
   case AxisOperationType::POSITION_4:
      nTargetAddress += 22; // å®šä½ç‚¹ 4 ä¿¡å·åœ°å€
      break;
   case AxisOperationType::POSITION_5:
      nTargetAddress += 24; // å®šä½ç‚¹ 5 ä¿¡å·åœ°å€
      break;
   default:
      AfxMessageBox(_T("未知操作类型！"));
      return;
   }

   // å‘ PLC å†™å…¥ä¿¡å·
   m_pPLC->writeBit(MC::SOFT_COMPONENT::D, nTargetAddress, bPressed, [eOpType, nTargetAddress, bPressed](IMcChannel* pChannel, int nAddr, DWORD nValue, int nFlag) {
      if (nFlag == 0) {
         TRACE("操作成功：类型=%d，地址=%d，值=%d\n", static_cast<int>(eOpType), nAddr, bPressed);
      }
      else {
         TRACE("操作失败：类型=%d，地址=%d，错误码=%d\n", static_cast<int>(eOpType), nAddr, nFlag);
      }
   });
}


BEGIN_MESSAGE_MAP(CAxisSettingsDlg, CDialogEx)
   ON_BN_CLICKED(IDC_BUTTON_AXIS_LAST, &CAxisSettingsDlg::OnBnClickedButtonAxisLast)
   ON_BN_CLICKED(IDC_BUTTON_AXIS_NEXT, &CAxisSettingsDlg::OnBnClickedButtonAxisNext)
   ON_BN_CLICKED(IDC_BUTTON_AXIS_ANCHOR_POINT_GROUP1, &CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPointGroup1)
   ON_BN_CLICKED(IDC_BUTTON_AXIS_ANCHOR_POINT_GROUP2, &CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPointGroup2)
   ON_BN_CLICKED(IDC_BUTTON_AXIS_ANCHOR_POINT_GROUP3, &CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPointGroup3)
   ON_BN_CLICKED(IDC_BUTTON_AXIS_ANCHOR_POINT_GROUP4, &CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPointGroup4)
   ON_BN_CLICKED(IDC_BUTTON_AXIS_ANCHOR_POINT_GROUP5, &CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPointGroup5)
   ON_BN_CLICKED(IDC_BUTTON_AXIS_ANCHOR_POINT1, &CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPoint1)
   ON_BN_CLICKED(IDC_BUTTON_AXIS_ANCHOR_POINT2, &CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPoint2)
   ON_BN_CLICKED(IDC_BUTTON_AXIS_ANCHOR_POINT3, &CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPoint3)
   ON_BN_CLICKED(IDC_BUTTON_AXIS_ANCHOR_POINT4, &CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPoint4)
   ON_BN_CLICKED(IDC_BUTTON_AXIS_ANCHOR_POINT5, &CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPoint5)
   ON_BN_CLICKED(IDC_BUTTON_AXIS_TEST_OPR, &CAxisSettingsDlg::OnBnClickedButtonAxisTestOpr)
   ON_BN_CLICKED(IDC_BUTTON_AXIS_TEST_STOP, &CAxisSettingsDlg::OnBnClickedButtonAxisTestStop)
   ON_CBN_SELCHANGE(IDC_COMBO_AXIS_NAME, &CAxisSettingsDlg::OnSelchangeComboAxisName)
   ON_BN_CLICKED(IDC_BUTTON_AXIS_SAVE, &CAxisSettingsDlg::OnBnClickedButtonAxisSave)
   ON_WM_SIZE()
   ON_WM_CTLCOLOR()
   ON_WM_SIZING()
   ON_WM_TIMER()
END_MESSAGE_MAP()


// CAxisSettingsDlg æ¶ˆæ¯å¤„理程序


BOOL CAxisSettingsDlg::OnInitDialog()
{
   CDialogEx::OnInitDialog();

   // TODO:  åœ¨æ­¤æ·»åŠ é¢å¤–的初始化
   CString strTitle;
   strTitle.Format(_T("Axis设定(配方: %s)"), m_strRecipeName);
   SetWindowText(strTitle);

   // è®¾ç½®æµ‹è¯•çŠ¶æ€
   CBLLabel* pLabels[] = { &m_staticFLS, &m_staticDOG, &m_staticRLS, &m_staticReady, &m_staticBusy, &m_staticErr };
   for (auto pLabel : pLabels) {
      SetStatusColor(*pLabel, FALSE);
      pLabel->ModifyStyle(0, SS_NOTIFY);
      pLabel->SetTextColor(RGB(255, 255, 255));
      pLabel->SetAlignment(AlignCenter);
      pLabel->SetDynamicFont(TRUE);
   }

   // åˆå§‹åŒ–当前页面为第一页
   m_currentPage = 1;
   updatePageButtonStates();

   initializeAxisIDCombo();
   refreshAxisDetails(1);
   refreshPositionDetails(1, m_currentPage);

   CRect screenRect, dlgRect, clientRect;
   GetClientRect(&clientRect);
   m_nInitialWidth = clientRect.Width();
   m_nInitialHeight = clientRect.Height();

   // åˆå§‹åŒ–默认字体
   CFont* pDefaultFont = GetOrCreateFont(12);

   // éåŽ†æ‰€æœ‰å­æŽ§ä»¶ï¼Œè®°å½•åˆå§‹ä½ç½®å¹¶è®¾ç½®é»˜è®¤å­—体
   CWnd* pWnd = GetWindow(GW_CHILD);
   while (pWnd) {
      int nCtrlID = pWnd->GetDlgCtrlID();
      if (nCtrlID != -1) {
         // è®°å½•æŽ§ä»¶åˆå§‹å¸ƒå±€
         CRect ctrlRect;
         pWnd->GetWindowRect(&ctrlRect);
         ScreenToClient(&ctrlRect);
         m_mapCtrlLayouts[nCtrlID] = ctrlRect;

         // è®¾ç½®é»˜è®¤å­—体
         pWnd->SetFont(pDefaultFont);
      }
      pWnd = pWnd->GetNextWindow();
   }

   GetWindowRect(&dlgRect);
   int dlgWidth = dlgRect.Width() * 2;
   int dlgHeight = dlgRect.Height() * 2;

   SystemParametersInfo(SPI_GETWORKAREA, 0, &screenRect, 0);
   if (dlgWidth > screenRect.Width()) {
      dlgWidth = screenRect.Width();
   }
   if (dlgHeight > screenRect.Height()) {
      dlgHeight = screenRect.Height();
   }

   int centerX = screenRect.left + (screenRect.Width() - dlgWidth) / 2;
   int centerY = screenRect.top + (screenRect.Height() - dlgHeight) / 2;
   MoveWindow(centerX, centerY, dlgWidth, dlgHeight);
	
   SetTimer(TIMER_READ_PLC_DATA, 500, nullptr);

   return TRUE;  // return TRUE unless you set the focus to a control
   // å¼‚常: OCX å±žæ€§é¡µåº”返回 FALSE
}

BOOL CAxisSettingsDlg::PreTranslateMessage(MSG* pMsg)
{
   // TODO: åœ¨æ­¤æ·»åŠ ä¸“用代码和/或调用基类

   if (pMsg->message == WM_LBUTTONDOWN)
   {
      if (pMsg->hwnd == GetDlgItem(IDC_BUTTON_AXIS_TEST_JOG_ADD)->m_hWnd)
      {
         TRACE("JOG+ æŒ‰é’®æŒ‰ä¸‹\n");
         m_bJogAddPressed = TRUE;

         // å¯åŠ¨å®šæ—¶å™¨è¿žç»­å‘送信号
         SetTimer(TIMER_JOG_ADD, 200, nullptr);
         handleAxisOperation(AxisOperationType::JOG_ADD, true);
      }
      else if (pMsg->hwnd == GetDlgItem(IDC_BUTTON_AXIS_TEST_JOG_SUB)->m_hWnd)
      {
         TRACE("JOG- æŒ‰é’®æŒ‰ä¸‹\n");
         m_bJogSubPressed = TRUE;

         // å¯åŠ¨å®šæ—¶å™¨è¿žç»­å‘送信号
         SetTimer(TIMER_JOG_SUB, 200, nullptr);
         handleAxisOperation(AxisOperationType::JOG_SUB, true);
      }
   }
   else if (pMsg->message == WM_LBUTTONUP)
   {
      if (pMsg->hwnd == GetDlgItem(IDC_BUTTON_AXIS_TEST_JOG_ADD)->m_hWnd)
      {
         TRACE("JOG+ æŒ‰é’®æ¾å¼€\n");
         m_bJogAddPressed = FALSE;

         // åœæ­¢å®šæ—¶å™¨
         KillTimer(TIMER_JOG_ADD);
         handleAxisOperation(AxisOperationType::JOG_ADD, false);
      }
      else if (pMsg->hwnd == GetDlgItem(IDC_BUTTON_AXIS_TEST_JOG_SUB)->m_hWnd)
      {
         TRACE("JOG- æŒ‰é’®æ¾å¼€\n");
         m_bJogSubPressed = FALSE;

         // åœæ­¢å®šæ—¶å™¨
         KillTimer(TIMER_JOG_SUB);
         handleAxisOperation(AxisOperationType::JOG_SUB, false);
      }
   }

   return CDialogEx::PreTranslateMessage(pMsg);
}

void CAxisSettingsDlg::OnSize(UINT nType, int cx, int cy)
{
   CDialogEx::OnSize(nType, cx, cy);

   // TODO: åœ¨æ­¤å¤„添加消息处理程序代码
   if (nType == SIZE_MINIMIZED || m_mapCtrlLayouts.empty()) {
      return;
   }

   float dScaleX = static_cast<float>(cx) / m_nInitialWidth;
   float dScaleY = static_cast<float>(cy) / m_nInitialHeight;

   // éåŽ†å¯¹è¯æ¡†ä¸­çš„所有控件
   AdjustControls(dScaleX, dScaleY);

   // åŠ¨æ€è°ƒæ•´å„个 CBLLabel çš„字体大小
   CBLLabel* pLabels[] = { &m_staticFLS, &m_staticDOG, &m_staticRLS, &m_staticReady, &m_staticBusy, &m_staticErr };
   for (auto pLabel : pLabels) {
      AdjustLabelFont(*pLabel);
   }

   // è°ƒæ•´ä¸‹æ‹‰æ¡†é«˜åº¦
   CComboBox* pComboBox = (CComboBox*)GetDlgItem(IDC_COMBO_AXIS_NAME);
   CButton* pButtonLeft = (CButton*)GetDlgItem(IDC_BUTTON_AXIS_LAST);
   CButton* pButtonRight = (CButton*)GetDlgItem(IDC_BUTTON_AXIS_NEXT);

   if (pComboBox && pButtonLeft && pButtonRight) {
      CRect rectButton;
      pButtonLeft->GetWindowRect(&rectButton);   // èŽ·å–按钮尺寸
      ScreenToClient(&rectButton);            // è½¬æ¢ä¸ºå®¢æˆ·ç«¯åæ ‡

      CRect rectComboBox;
      pComboBox->GetWindowRect(&rectComboBox);
      ScreenToClient(&rectComboBox);

      // è°ƒæ•´ä¸‹æ‹‰æ¡†é«˜åº¦
      int heightAdjustment = 2;
      rectComboBox.top = rectButton.top;
      rectComboBox.bottom = rectButton.bottom + heightAdjustment;
      pComboBox->MoveWindow(&rectComboBox);
      pComboBox->SetItemHeight(-1, rectButton.Height() - 6);
   }
}

void CAxisSettingsDlg::OnSizing(UINT fwSide, LPRECT pRect)
{
   if (fwSide == WMSZ_BOTTOMRIGHT) {
      if (pRect->right - pRect->left < 200) {
         pRect->right = pRect->left + 200;
      }
      if (pRect->bottom - pRect->top < 150) {
         pRect->bottom = pRect->top + 150;
      }
   }

   CDialogEx::OnSizing(fwSide, pRect);
}

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

   // TODO:  åœ¨æ­¤æ›´æ”¹ DC çš„任何特性

   // TODO:  å¦‚果默认的不是所需画笔，则返回另一个画笔
   return hbr;
}

void CAxisSettingsDlg::OnBnClickedButtonAxisLast()
{
   // TODO: åœ¨æ­¤æ·»åŠ æŽ§ä»¶é€šçŸ¥å¤„理程序代码
   updateAxisSelection(-1);
}

void CAxisSettingsDlg::OnBnClickedButtonAxisNext()
{
   // TODO: åœ¨æ­¤æ·»åŠ æŽ§ä»¶é€šçŸ¥å¤„理程序代码
   updateAxisSelection(1);
}

void CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPointGroup1()
{
   // TODO: åœ¨æ­¤æ·»åŠ æŽ§ä»¶é€šçŸ¥å¤„理程序代码
   switchToPage(1);
}

void CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPointGroup2()
{
   // TODO: åœ¨æ­¤æ·»åŠ æŽ§ä»¶é€šçŸ¥å¤„理程序代码
   switchToPage(2);
}

void CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPointGroup3()
{
   // TODO: åœ¨æ­¤æ·»åŠ æŽ§ä»¶é€šçŸ¥å¤„理程序代码
   switchToPage(3);
}

void CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPointGroup4()
{
   // TODO: åœ¨æ­¤æ·»åŠ æŽ§ä»¶é€šçŸ¥å¤„理程序代码
   switchToPage(4);
}

void CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPointGroup5()
{
   // TODO: åœ¨æ­¤æ·»åŠ æŽ§ä»¶é€šçŸ¥å¤„理程序代码
   switchToPage(5);
}

void CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPoint1()
{
   // TODO: åœ¨æ­¤æ·»åŠ æŽ§ä»¶é€šçŸ¥å¤„理程序代码
   handleAxisOperation(AxisOperationType::POSITION_1, true);
}

void CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPoint2()
{
   // TODO: åœ¨æ­¤æ·»åŠ æŽ§ä»¶é€šçŸ¥å¤„理程序代码
   handleAxisOperation(AxisOperationType::POSITION_2, true);
}

void CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPoint3()
{
   // TODO: åœ¨æ­¤æ·»åŠ æŽ§ä»¶é€šçŸ¥å¤„理程序代码
   handleAxisOperation(AxisOperationType::POSITION_3, true);
}

void CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPoint4()
{
   // TODO: åœ¨æ­¤æ·»åŠ æŽ§ä»¶é€šçŸ¥å¤„理程序代码
   handleAxisOperation(AxisOperationType::POSITION_4, true);
}

void CAxisSettingsDlg::OnBnClickedButtonAxisAnchorPoint5()
{
   // TODO: åœ¨æ­¤æ·»åŠ æŽ§ä»¶é€šçŸ¥å¤„理程序代码
   handleAxisOperation(AxisOperationType::POSITION_5, true);
}

void CAxisSettingsDlg::OnBnClickedButtonAxisTestOpr()
{
   // TODO: åœ¨æ­¤æ·»åŠ æŽ§ä»¶é€šçŸ¥å¤„理程序代码
   handleAxisOperation(AxisOperationType::OPR, true);
}

void CAxisSettingsDlg::OnBnClickedButtonAxisTestStop()
{
   // TODO: åœ¨æ­¤æ·»åŠ æŽ§ä»¶é€šçŸ¥å¤„理程序代码
   handleAxisOperation(AxisOperationType::STOP, true);
}

void CAxisSettingsDlg::OnSelchangeComboAxisName()
{
   // TODO: åœ¨æ­¤æ·»åŠ æŽ§ä»¶é€šçŸ¥å¤„理程序代码
   int axisId = getCurrentSelectedAxisID();
   if (axisId == -1) {
      AfxMessageBox(_T("请选择一个有效的轴编号！"));
      return;
   }

   refreshAxisDetails(axisId);
   refreshPositionDetails(axisId, m_currentPage);
   updatePageButtonStates();
}

void CAxisSettingsDlg::OnBnClickedButtonAxisSave()
{
   // TODO: åœ¨æ­¤æ·»åŠ æŽ§ä»¶é€šçŸ¥å¤„理程序代码
   int axisId = getCurrentSelectedAxisID();
   if (axisId == -1) {
      AfxMessageBox(_T("请选择一个有效的轴编号！"));
      return;
   }

   CString cstrMessage;
   cstrMessage.Format(_T("是否保存轴 [%d] å‚数？"), axisId);
   int ret = AfxMessageBox(_T(cstrMessage), MB_OKCANCEL | MB_ICONEXCLAMATION);
   if (ret != IDOK) {
      return;
   }

   updateDataFromUI(axisId);
   if (RecipeManager::getInstance().saveRecipe(std::string(CT2A(m_strRecipeName)))) {
      writeAxisDataToPLC(axisId);
      cstrMessage.Format(_T("保存轴 [%d] å‚数成功！"), axisId);
      SystemLogManager::getInstance().log(SystemLogManager::LogType::Operation, std::string(CT2A(cstrMessage)));
   }
   else {
      cstrMessage.Format(_T("保存轴 [%d] å‚数失败！"), axisId);
      SystemLogManager::getInstance().log(SystemLogManager::LogType::Error, std::string(CT2A(cstrMessage)));
   }

   AfxMessageBox(cstrMessage);
}

void CAxisSettingsDlg::OnTimer(UINT_PTR nIDEvent)
{
   if (TIMER_READ_PLC_DATA == nIDEvent) {
      ASSERT(m_pPLC);

      int addr1, addr2, readSize;
      addr1 = 5120;
      addr2 = 5425;
      readSize = (addr2 - addr1 + 1) * 2;
      auto funOnReadData = [&, addr1, readSize](IMcChannel* pChannel, int addr, char* pData, unsigned int nDataSize, int flag) -> void {
         if (nDataSize == readSize && flag == 0) {
            double fCurPos = CToolUnits::toInt32(pData) * 0.001;
            double fManualSpeed = CToolUnits::toInt32(&pData[(5422- addr1)*2]) * 0.001;
            double fAutoSpeed = CToolUnits::toInt32(&pData[(5424 - addr1) * 2]) * 0.001;
            double fPrm = CToolUnits::toInt32(&pData[(5150 - addr1) * 2]) * 0.1;
            int nLoad = CToolUnits::toInt16(&pData[(5154 - addr1) * 2]);
            int nErrCode = CToolUnits::toInt16(&pData[(5126 - addr1) * 2]);
            int nAlarmCode = CToolUnits::toInt16(&pData[(5127 - addr1) * 2]);
            CToolUnits::setDlgItemDouble(this, IDC_EDIT_AXIS_CURR_POS, fCurPos);
            CToolUnits::setDlgItemDouble(this, IDC_EDIT_AXIS_CURR_MANUAL_SPEED, fManualSpeed);
            CToolUnits::setDlgItemDouble(this, IDC_EDIT_AXIS_CURR_AUTO_SPEED, fAutoSpeed);
            CToolUnits::setDlgItemDouble(this, IDC_EDIT_AXIS_CURR_ROTA_SPEED, fPrm);
            SetDlgItemInt(IDC_EDIT_AXIS_CURR_LOAD, nLoad);
            SetDlgItemInt(IDC_EDIT_AXIS_CURR_ERROR_NUMBER, nErrCode);
            SetDlgItemInt(IDC_EDIT_AXIS_CURR_ALARM_NUMBER, nAlarmCode);
         }
      };
      m_pPLC->readData(MC::SOFT_COMPONENT::D, addr1, readSize, funOnReadData);
   }	
   else if (nIDEvent == TIMER_JOG_ADD && m_bJogAddPressed) {
      TRACE("持续发送 JOG+\n");
      handleAxisOperation(AxisOperationType::JOG_ADD, true); // æŒç»­å‘送 JOG+
      Sleep(20);
   }
   else if (nIDEvent == TIMER_JOG_SUB && m_bJogSubPressed) {
      TRACE("持续发送 JOG-\n");
      handleAxisOperation(AxisOperationType::JOG_SUB, true); // æŒç»­å‘送 JOG-
      Sleep(20);
   }

   CDialogEx::OnTimer(nIDEvent);
}