From bc7f1c4e028e69be51079b59dae4ae5c4d43f5bb Mon Sep 17 00:00:00 2001
From: chenluhua1980 <Chenluhua@qq.com>
Date: 星期六, 31 一月 2026 21:54:56 +0800
Subject: [PATCH] 1.状态指示图，目前灰色表示掉线，绿色表示在线。增加Slot的小点表示有没有料，及加工状态 。 2.增加图示

---
 SourceCode/Bond/Servo/CCLinkPerformance/PerformanceMelsec.cpp |  729 ++++++++++++++++++++++++++++++++++++-------------------
 1 files changed, 473 insertions(+), 256 deletions(-)

diff --git a/SourceCode/Bond/Servo/CCLinkPerformance/PerformanceMelsec.cpp b/SourceCode/Bond/Servo/CCLinkPerformance/PerformanceMelsec.cpp
index 1f6deab..0f11149 100644
--- a/SourceCode/Bond/Servo/CCLinkPerformance/PerformanceMelsec.cpp
+++ b/SourceCode/Bond/Servo/CCLinkPerformance/PerformanceMelsec.cpp
@@ -9,7 +9,7 @@
 
 #ifdef _DEBUG
 #undef THIS_FILE
-static char THIS_FILE[] = __FILE__;
+static char* THIS_FILE = __FILE__;
 #define new DEBUG_NEW
 #endif
 
@@ -23,9 +23,9 @@
 #define LOG_DEBUG(msg)
 #endif
 
-// 鍒濆鍖栭潤鎬佹垚鍛樺彉閲�
+// 初始化静态成员变量
 std::unordered_map<int, std::string> CPerformanceMelsec::m_mapError = {
-    // 鏉垮潡SDK閿欒鐮�
+    // 板块SDK错误码
     {0, "No error, communication successful."},
     {1, "Driver not started. The driver is not running."},
     {2, "Timeout error (board response error). Request not completed within timeout."},
@@ -118,7 +118,7 @@
     {-28634, "Hardware self-diagnosis error."},
     {-28636, "Hardware self-diagnosis error."},
 
-    // 鑷畾涔夐敊璇爜
+    // 自定义错误码
     {ERROR_CODE_UNKNOWN, "Error: Unknown error code."},
     {ERROR_CODE_NOT_CONNECTED, "Error: Not connected to the device."},
     {ERROR_CODE_INVALID_PARAM, "Error: Invalid parameter."},
@@ -137,26 +137,26 @@
     m_bConnected.store(false);
 }
 
-// 鏋愭瀯鍑芥暟
+// 析构函数
 CPerformanceMelsec::~CPerformanceMelsec() {
     Disconnect();
 }
 
-// 鑾峰彇鏈�杩戠殑閿欒淇℃伅
+// 获取最近的错误信息
 std::string CPerformanceMelsec::GetLastError() const {
     return m_strLastError;
 }
 
-// 淇濆瓨閿欒淇℃伅
+// 保存错误信息
 bool CPerformanceMelsec::SaveErrorInfoToFile(const std::string& filename) {
-    // 鎵撳紑鏂囦欢
+    // 打开文件
     std::ofstream file(filename);
     if (!file.is_open()) {
         std::cerr << "Failed to open file for saving: " << filename << std::endl;
         return false;
     }
 
-    // 閬嶅巻闈欐�佹垚鍛樺彉閲� m_mapError 骞跺皢姣忎釜閿欒淇℃伅鍐欏叆鏂囦欢
+    // 遍历静态成员变量 m_mapError 并将每个错误信息写入文件
     for (const auto& entry : m_mapError) {
         const int nCode = entry.first;
         const std::string& strMessage = entry.second;
@@ -167,7 +167,7 @@
     return true;
 }
 
-// 鍔犺浇閿欒淇℃伅
+// 加载错误信息
 bool CPerformanceMelsec::LoadErrorInfoFromFile(const std::string& filename) {
     std::ifstream inFile(filename);
     if (!inFile.is_open()) {
@@ -183,7 +183,7 @@
         std::string strToken;
         std::string strMessage;
 
-        // 浣跨敤鍒嗛殧绗� "|" 瑙ｆ瀽姣忎竴琛�
+        // 使用分隔符 "|" 解析每一行
         if (std::getline(iss, strToken, '|')) {
             nCode = std::stoi(strToken);
         }
@@ -200,7 +200,7 @@
     return true;
 }
 
-// 杩炴帴鍒癙LC
+// 连接到PLC
 int CPerformanceMelsec::Connect(const short nChannel, const short nMode) {
     std::lock_guard<std::mutex> lock(m_mtx);
 
@@ -214,12 +214,13 @@
         return ERROR_CODE_INVALID_PARAM;
     }
 
-    // 杩炴帴PLC锛屾樉寮忕被鍨嬭浆鎹互鍖归厤 mdOpen 鐨勭鍚�
+    // 连接PLC，显式类型转换以匹配 mdOpen 的签名
     const short nRet = mdOpen(nChannel, nMode, &m_nPath);
     if (nRet == 0) {
         m_bConnected.store(true);
         m_enBoardType = enBoardType;
-    } else {
+    }
+    else {
         UpdateLastError(nRet);
         LOG_ERROR(m_strLastError);
     }
@@ -227,7 +228,7 @@
     return nRet;
 }
 
-// 鏂紑杩炴帴
+// 断开连接
 int CPerformanceMelsec::Disconnect() {
     std::lock_guard<std::mutex> lock(m_mtx);
 
@@ -244,7 +245,7 @@
     return nRet;
 }
 
-// 鍙紪绋嬫帶鍒跺櫒杞厓浠朵俊鎭〃鐨勫垵濮嬪寲
+// 可编程控制器软元件信息表的初始化
 int CPerformanceMelsec::InitializeController() {
     std::lock_guard<std::mutex> lock(m_mtx);
 
@@ -262,15 +263,15 @@
     return nRet;
 }
 
-// 鑾峰彇鐗堟湰淇℃伅
+// 获取版本信息
 int CPerformanceMelsec::GetBoardVersion(BoardVersion& version) {
     if (!m_bConnected.load()) {
         UpdateLastError(ERROR_CODE_NOT_CONNECTED);
         return ERROR_CODE_NOT_CONNECTED;
     }
 
-    // 鑾峰彇鐗堟湰淇℃伅
-    short buf[32] = {0};
+    // 获取版本信息
+    short buf[32] = { 0 };
     const short nRet = mdBdVerRead(m_nPath, buf);
     if (nRet != 0) {
         UpdateLastError(nRet);
@@ -278,7 +279,7 @@
         return nRet;
     }
 
-    // 濉厖鐗堟湰淇℃伅鍒扮粨鏋勪綋
+    // 填充版本信息到结构体
     version.fixedValue[0] = static_cast<char>(buf[0] & 0xFF);
     version.fixedValue[1] = static_cast<char>((buf[0] >> 8) & 0xFF);
 
@@ -309,16 +310,16 @@
     return nRet;
 }
 
-// 璇诲彇鐩爣绔欑偣CPU绫诲瀷
+// 读取目标站点CPU类型
 int CPerformanceMelsec::ReadCPUCode(const StationIdentifier& station, short& nCPUCode) {
-    // 楠岃瘉绔欑偣鍙傛暟鍜屾暟鎹湁鏁堟��
+    // 验证站点参数和数据有效性
     int nRet = ValidateStation(station);
     if (nRet != 0) {
         UpdateLastError(nRet);
         return nRet;
     }
 
-    // 纭繚绾跨▼瀹夊叏鐨勬渶灏忛攣瀹氳寖鍥�
+    // 确保线程安全的最小锁定范围
     {
         nCPUCode = 0;
         std::lock_guard<std::mutex> lock(m_mtx);
@@ -333,15 +334,15 @@
     return nRet;
 }
 
-// 鏉挎ā寮忚缃�
+// 板模式设置
 int CPerformanceMelsec::SetBoardMode(const short nMode) {
-    // 妫�鏌ユ槸鍚﹀凡缁忚繛鎺�
+    // 检查是否已经连接
     if (!m_bConnected.load()) {
         UpdateLastError(ERROR_CODE_NOT_CONNECTED);
         return ERROR_CODE_NOT_CONNECTED;
     }
 
-    // 纭繚绾跨▼瀹夊叏鐨勬渶灏忛攣瀹氳寖鍥�
+    // 确保线程安全的最小锁定范围
     short nRet = 0;
     {
         std::lock_guard<std::mutex> lock(m_mtx);
@@ -356,9 +357,9 @@
     return nRet;
 }
 
-// 鑾峰彇鏉挎ā寮�
+// 获取板模式
 int CPerformanceMelsec::GetBoardMode(short& nMode) {
-    // 妫�鏌ユ槸鍚﹀凡缁忚繛鎺�
+    // 检查是否已经连接
     if (!m_bConnected.load()) {
         UpdateLastError(ERROR_CODE_NOT_CONNECTED);
         return ERROR_CODE_NOT_CONNECTED;
@@ -380,7 +381,7 @@
     return 0;
 }
 
-// 鏉垮浣�
+// 板复位
 int CPerformanceMelsec::BoardReset() {
     std::lock_guard<std::mutex> lock(m_mtx);
     if (!m_bConnected.load()) {
@@ -397,7 +398,7 @@
     return nRet;
 }
 
-// 鏉縇ED璇诲彇
+// 板LED读取
 int CPerformanceMelsec::ReadBoardLed(std::vector<short>& vecLedBuffer) {
     std::lock_guard<std::mutex> lock(m_mtx);
     if (!m_bConnected.load()) {
@@ -405,11 +406,11 @@
         return ERROR_CODE_NOT_CONNECTED;
     }
 
-    // 娓呯┖ LED 缂撳啿鍖�
+    // 清空 LED 缓冲区
     vecLedBuffer.clear();
     vecLedBuffer.resize(16, 0);
 
-    // 璋冪敤 SDK 鍑芥暟璇诲彇 LED 鏁版嵁
+    // 调用 SDK 函数读取 LED 数据
     const short nRet = mdBdLedRead(m_nPath, vecLedBuffer.data());
     if (nRet != 0) {
         UpdateLastError(ERROR_CODE_NOT_CONNECTED);
@@ -420,7 +421,7 @@
     return nRet;
 }
 
-// 鑾峰彇鏉跨姸鎬�
+// 获取板状态
 int CPerformanceMelsec::GetBoardStatus(BoardStatus& status) {
     std::lock_guard<std::mutex> lock(m_mtx);
     if (!m_bConnected) {
@@ -428,36 +429,37 @@
         return ERROR_CODE_NOT_CONNECTED;
     }
 
-    short buf[6] = {0};
+    short buf[6] = { 0 };
     const short nRet = mdBdSwRead(m_nPath, buf);
     if (nRet != 0) {
         UpdateLastError(nRet);
         LOG_ERROR(m_strLastError);
     }
 
-    // 灏� buf 鏄犲皠鍒扮粨鏋勪綋
+    // 将 buf 映射到结构体
     status = BoardStatus::fromBuffer(buf);
     return 0;
 }
 
-// 閫氱敤璇绘暟鎹�
-int CPerformanceMelsec::ReadData(const StationIdentifier& station, const short nDevType, const short nDevNo, short nSize, std::vector<short>& vecData) {
-    // 楠岃瘉绔欑偣鍙傛暟鍜屾暟鎹湁鏁堟��
+// 通用读数据
+int CPerformanceMelsec::ReadData(const StationIdentifier& station, const long nDevType, const long nDevNo, long nSize, std::vector<short>& vecData) {
+    // 验证站点参数和数据有效性
     int nRet = ValidateStationAndSize(station, nSize);
     if (nRet != 0) {
         UpdateLastError(nRet);
         return nRet;
     }
 
-    // 鍒濆鍖栬鍙栫紦鍐插尯
+    // 初始化读取缓冲区
     vecData.clear();
-    vecData.resize(nSize);
+    vecData.resize(nSize, 0);
 
-    // 纭繚绾跨▼瀹夊叏鐨勬渶灏忛攣瀹氳寖鍥�
+    // 确保线程安全的最小锁定范围
     {
         std::lock_guard<std::mutex> lock(m_mtx);
         short* pData = vecData.data();
-        nRet = mdReceive(m_nPath, CombineStation(station), nDevType, nDevNo, &nSize, pData);
+        nSize *= sizeof(short);
+        nRet = mdReceiveEx(m_nPath, station.nNetNo, station.nStNo, nDevType, (long)(unsigned short)nDevNo, &nSize, pData);
     }
 
     if (nRet != 0) {
@@ -466,38 +468,56 @@
     }
 
     if (nRet != 0) {
-        vecData.clear(); // 濡傛灉璇诲彇澶辫触锛屾竻绌虹紦鍐插尯
+        vecData.clear(); // 如果读取失败，清空缓冲区
     }
 
     return nRet;
 }
 
-// 璇诲彇浣嶆暟鎹�
+// 读取位数据
 int CPerformanceMelsec::ReadBitData(const StationIdentifier& station, const DeviceType enDevType, const short nDevNo, const short nBitCount, BitContainer& vecData) {
-    // 楠岃瘉绔欑偣鍙傛暟鍜屾暟鎹湁鏁堟��
+    // 验证站点参数和数据有效性
     int nRet = ValidateStationAndSize(station, nBitCount);
     if (nRet != 0) {
         UpdateLastError(nRet);
         return nRet;
     }
 
-    // 璁＄畻闇�瑕佽鍙栫殑瀛楄妭澶у皬锛堟寜浣嶅榻愪负瀛楄妭鏁帮級
+    if (nDevNo % 8 != 0) {
+        nRet = -2;
+        UpdateLastError(nRet);
+        return nRet;
+    }
+
     const short nDevType = CalculateDeviceType(station, enDevType);
-    const auto nSize = static_cast<short>((nBitCount + 7) / 8);     // 鍚戜笂鍙栨暣
-    std::vector<short> vecTempBuffer((nSize + 1) / 2, 0); // 涓存椂缂撳啿鍖猴紝瀛楄妭瀵归綈
+    const auto nSize = static_cast<short>((static_cast<int>(nBitCount) + 15) / 16);  // 计算需要读取的字数量（向上取整）
+
+    std::vector<short> vecTempBuffer(nSize, 0);
     nRet = ReadData(station, nDevType, nDevNo, nSize, vecTempBuffer);
 
     if (nRet == 0) {
-        std::lock_guard<std::mutex> lock(m_mtx); // 绾跨▼瀹夊叏淇濇姢
-        ConvertShortToUint8(vecTempBuffer, vecData);
+        vecData.clear();
+
+        // 将字数据解析为位数据
+        for (short nIdx = 0; nIdx < nSize; ++nIdx) {
+            const short nCurrentValue = vecTempBuffer[nIdx];
+            // 遍历当前 short 中的每一位
+            for (int bitIdx = 0; bitIdx < 16; ++bitIdx) {
+                bool bBit = (nCurrentValue & (1 << bitIdx)) != 0;
+                vecData.push_back(bBit);
+                if (vecData.size() >= nBitCount) {
+                    return nRet;  // 如果已经读取完所需的位数，提前退出
+                }
+            }
+        }
     }
 
     return nRet;
 }
 
-// 璇诲彇瀛楁暟鎹�
+// 读取字数据
 int CPerformanceMelsec::ReadWordData(const StationIdentifier& station, const DeviceType enDevType, const short nDevNo, const short nWordCount, WordContainer& vecData) {
-    // 楠岃瘉绔欑偣鍙傛暟鍜屾暟鎹湁鏁堟��
+    // 验证站点参数和数据有效性
     int nRet = ValidateStationAndSize(station, nWordCount);
     if (nRet != 0) {
         UpdateLastError(nRet);
@@ -516,47 +536,48 @@
     return nRet;
 }
 
-// 璇诲彇鍙屽瓧鏁版嵁
+// 读取双字数据
 int CPerformanceMelsec::ReadDWordData(const StationIdentifier& station, const DeviceType enDevType, const short nDevNo, const short nDWordCount, DWordContainer& vecData) {
-    // 楠岃瘉绔欑偣鍙傛暟鍜屾暟鎹湁鏁堟��
+    // 验证站点参数和数据有效性
     int nRet = ValidateStationAndSize(station, nDWordCount);
     if (nRet != 0) {
         UpdateLastError(nRet);
         return nRet;
     }
 
-    const auto nSize = static_cast<short>(nDWordCount * 2); // 姣忎釜鍙屽瓧鍗犱袱涓瓧锛堟瘡涓弻瀛楀崰 4 瀛楄妭锛�
+    const auto nSize = static_cast<short>(nDWordCount * 2); // 每个双字占两个字（每个双字占 4 字节）
     const short nDevType = CalculateDeviceType(station, enDevType);
     std::vector<short> vecTempBuffer(nSize, 0);
     nRet = ReadData(station, nDevType, nDevNo, nSize, vecTempBuffer);
 
     if (nRet == 0) {
-        std::lock_guard<std::mutex> lock(m_mtx); // 绾跨▼瀹夊叏淇濇姢
+        std::lock_guard<std::mutex> lock(m_mtx); // 线程安全保护
         ConvertShortToUint32(vecTempBuffer, vecData);
     }
 
     return nRet;
 }
 
-// 閫氱敤鍐欐暟鎹�
-int CPerformanceMelsec::WriteData(const StationIdentifier& station, const short nDevType, const short nDevNo, short nSize, short* pData) {
-    // 楠岃瘉绔欑偣鍙傛暟
+// 通用写数据
+int CPerformanceMelsec::WriteData(const StationIdentifier& station, const long nDevType, const long nDevNo, long nSize, short* pData) {
+    // 验证站点参数
     int nRet = ValidateStation(station);
     if (nRet != 0) {
         UpdateLastError(nRet);
         return nRet;
     }
 
-    // 鏁版嵁鏈夋晥鎬�
+    // 数据有效性
     if (nSize < 0 || pData == nullptr) {
         UpdateLastError(ERROR_CODE_INVALID_PARAM);
         return ERROR_CODE_INVALID_PARAM;
     }
 
-    // 纭繚绾跨▼瀹夊叏鐨勬渶灏忛攣瀹氳寖鍥�
+    // 确保线程安全的最小锁定范围
     {
         std::lock_guard<std::mutex> lock(m_mtx);
-        nRet = mdSend(m_nPath, CombineStation(station), nDevType, nDevNo, &nSize, pData);
+        nSize *= sizeof(short);
+        nRet = mdSendEx(m_nPath, station.nNetNo, station.nStNo, nDevType, nDevNo, &nSize, pData);
     }
 
     if (nRet != 0) {
@@ -567,68 +588,81 @@
     return nRet;
 }
 
-// 鍐欎綅鏁版嵁
+// 写位数据
 int CPerformanceMelsec::WriteBitData(const StationIdentifier& station, const DeviceType enDevType, const short nDevNo, const BitContainer& vecData) {
-    // 楠岃瘉绔欑偣鍙傛暟鍜屾暟鎹湁鏁堟��
-    const int nRet = ValidateStationAndData(station, vecData);
+    // 验证站点参数和数据有效性
+    int nRet = ValidateStationAndData(station, vecData);
     if (nRet != 0) {
         UpdateLastError(nRet);
         return nRet;
     }
 
-    // 璁＄畻闇�瑕佸啓鍏ョ殑瀛楄妭鏁帮紙浣嶆暟鎹渶瑕佹寜 8 浣嶅榻愪负瀛楄妭鏁帮級
-    const short nDevType = CalculateDeviceType(station, enDevType);
-    const auto nSize = static_cast<short>((vecData.size() + 7) / 8);
-    std::vector<short> vecBuffer(vecData.size() / 2 + vecData.size() % 2, 0);
-    {
-        std::lock_guard<std::mutex> lock(m_mtx); // 绾跨▼瀹夊叏淇濇姢
-        ConvertUint8ToShort(vecData, vecBuffer);
+    if (nDevNo % 8 != 0) {
+        nRet = -2;
+        UpdateLastError(nRet);
+        return nRet;
     }
 
-    return WriteData(station, nDevType, nDevNo, nSize, vecBuffer.data());
+    const short nDevType = CalculateDeviceType(station, enDevType);
+    const auto nSize = static_cast<short>((static_cast<int>(vecData.size()) + 15) / 16);  // 计算需要写入的字数量（向上取整）
+
+    // 准备临时缓冲区来存储转换后的 16 位数据
+    std::vector<short> vecTempBuffer(nSize, 0);
+    {
+        std::lock_guard<std::mutex> lock(m_mtx); // 线程安全保护
+        // 将位数据按字打包到临时缓冲区
+        for (int i = 0; i < vecData.size(); ++i) {
+            if (vecData[i]) {
+                // 使用 & 0xFFFF 保证不会超过 16 位，防止溢出
+                vecTempBuffer[i / 16] |= static_cast<short>((1 << (i % 16)) & 0xFFFF);
+            }
+        }
+    }
+
+    return WriteData(station, nDevType, nDevNo, nSize, vecTempBuffer.data());
 }
 
-// 鍐欏瓧鏁版嵁
+// 写字数据
 int CPerformanceMelsec::WriteWordData(const StationIdentifier& station, const DeviceType enDevType, const short nDevNo, const WordContainer& vecData) {
-    // 楠岃瘉绔欑偣鍙傛暟鍜屾暟鎹湁鏁堟��
+    // 验证站点参数和数据有效性
     const int nRet = ValidateStationAndData(station, vecData);
     if (nRet != 0) {
         UpdateLastError(nRet);
         return nRet;
     }
 
-    // 璁＄畻闇�瑕佸啓鍏ョ殑瀛楄妭鏁帮紙姣忎釜瀛楀崰 2 瀛楄妭锛�
+    // 计算需要写入的字节数（每个字占 2 字节）
     const short nDevType = CalculateDeviceType(station, enDevType);
-    const auto nSize = static_cast<short>(vecData.size() * sizeof(uint16_t));
+    const auto nSize = static_cast<short>(vecData.size());
     const auto pData = const_cast<short*>(reinterpret_cast<const short*>(vecData.data()));
 
     return WriteData(station, nDevType, nDevNo, nSize, pData);
 }
 
-// 鍐欏弻瀛楁暟鎹�
+// 写双字数据
 int CPerformanceMelsec::WriteDWordData(const StationIdentifier& station, const DeviceType enDevType, const short nDevNo, const DWordContainer& vecData) {
-    // 楠岃瘉绔欑偣鍙傛暟鍜屾暟鎹湁鏁堟��
+    // 验证站点参数和数据有效性
     const int nRet = ValidateStationAndData(station, vecData);
     if (nRet != 0) {
         UpdateLastError(nRet);
         return nRet;
     }
 
-    // 璁＄畻闇�瑕佸啓鍏ョ殑瀛楄妭鏁帮紙姣忎釜鍙屽瓧鍗� 4 瀛楄妭锛�
+    // 计算需要写入的字节数（每个双字占 4 字节）
     const short nDevType = CalculateDeviceType(station, enDevType);
-    const auto nSize = static_cast<short>(vecData.size() * sizeof(uint32_t));
-    std::vector<short> vecBuffer(vecData.size() * 2, 0);
+    const auto nSize = static_cast<short>(vecData.size() * sizeof(short));
+    std::vector<short> vecBuffer(nSize, 0);
     {
-        std::lock_guard<std::mutex> lock(m_mtx); // 绾跨▼瀹夊叏淇濇姢
+        std::lock_guard<std::mutex> lock(m_mtx); // 线程安全保护
         ConvertUint32ToShort(vecData, vecBuffer);
     }
 
     return WriteData(station, nDevType, nDevNo, nSize, vecBuffer.data());
 }
 
-// 鎵╁睍璇绘暟鎹�
+// 扩展读数据
 long CPerformanceMelsec::ReadDataEx(const StationIdentifier& station, long nDevType, long nDevNo, long nSize, std::vector<char>& vecData) {
-    // 楠岃瘉绔欑偣鍙傛暟鍜岃鍙栧ぇ灏忔槸鍚︽湁鏁�
+    // 验证站点参数和读取大小是否有效
     long nRet = ValidateStation(station);
     if (nRet != 0) {
         UpdateLastError(nRet);
@@ -640,46 +674,142 @@
         return ERROR_CODE_INVALID_PARAM;
     }
 
-    vecData.resize(nSize);
-    long nActualSize = (nSize + 1) / 2;
-    std::vector<short> vecBuffer(nActualSize, 0);
+    nSize = nSize % 2 != 0 ? nSize + 1 : nSize;
+    std::vector<short> vecBuffer(nSize / 2, 0);
 
     {
-        std::lock_guard<std::mutex> lock(m_mtx); // 绾跨▼瀹夊叏淇濇姢
-        nRet = mdReceiveEx(m_nPath, station.nNetNo, station.nStNo, nDevType, nDevNo, &nActualSize, vecBuffer.data());
+        std::lock_guard<std::mutex> lock(m_mtx); // 线程安全保护
+        nRet = mdReceiveEx(m_nPath, station.nNetNo, station.nStNo, nDevType, nDevNo, &nSize, vecBuffer.data());
     }
 
     if (nRet != 0) {
         UpdateLastError(nRet);
         LOG_ERROR(m_strLastError);
-    } else {
-        std::lock_guard<std::mutex> lock(m_mtx); // 绾跨▼瀹夊叏淇濇姢
+    }
+    else {
+        std::lock_guard<std::mutex> lock(m_mtx); // 线程安全保护
+        vecData.resize(nSize);
         ConvertShortToChar(vecBuffer, vecData);
     }
 
     return 0;
 }
 
-// 鎵╁睍鍐欐暟鎹�
+// 扩展读取位数据
+long CPerformanceMelsec::ReadBitDataEx(const StationIdentifier& station, DeviceType enDevType, long nDevNo, long nBitCount, BitContainer& vecData) {
+    long nRet = ValidateStationAndSize(station, nBitCount);
+    if (nRet != 0) {
+        UpdateLastError(nRet);
+        return nRet;
+    }
+
+    if (nDevNo % 8 != 0) {
+        UpdateLastError(ERROR_CODE_INVALID_PARAM);
+        return ERROR_CODE_INVALID_PARAM;
+    }
+
+    const short nDevType = CalculateDeviceType(station, enDevType);
+    const long nWordCount = (nBitCount + 15) / 16;
+    const long nByteSize = nWordCount * sizeof(short);
+
+    std::vector<char> vecRaw;
+    nRet = ReadDataEx(station, nDevType, nDevNo, nByteSize, vecRaw);
+    if (nRet != 0) {
+        return nRet;
+    }
+
+    vecData.clear();
+    for (long i = 0; i < nWordCount; ++i) {
+        short word = static_cast<unsigned char>(vecRaw[i * 2]) |
+            (static_cast<unsigned char>(vecRaw[i * 2 + 1]) << 8);
+        for (int j = 0; j < 16; ++j) {
+            vecData.push_back((word & (1 << j)) != 0);
+            if (vecData.size() >= static_cast<size_t>(nBitCount)) {
+                return 0;
+            }
+        }
+    }
+
+    return 0;
+}
+
+// 扩展读取字数据
+long CPerformanceMelsec::ReadWordDataEx(const StationIdentifier& station, DeviceType enDevType, long nDevNo, long nWordCount, WordContainer& vecData) {
+    long nRet = ValidateStationAndSize(station, nWordCount);
+    if (nRet != 0) {
+        UpdateLastError(nRet);
+        return nRet;
+    }
+
+    const short nDevType = CalculateDeviceType(station, enDevType);
+    const long nByteSize = nWordCount * sizeof(short);
+
+    std::vector<char> vecRaw;
+    nRet = ReadDataEx(station, nDevType, nDevNo, nByteSize, vecRaw);
+    if (nRet != 0) {
+        return nRet;
+    }
+
+    vecData.clear();
+    for (long i = 0; i < nWordCount; ++i) {
+        short value = static_cast<unsigned char>(vecRaw[i * 2]) |
+            (static_cast<unsigned char>(vecRaw[i * 2 + 1]) << 8);
+        vecData.push_back(value);
+    }
+
+    return 0;
+}
+
+// 扩展读取双字数据
+long CPerformanceMelsec::ReadDWordDataEx(const StationIdentifier& station, DeviceType enDevType, long nDevNo, long nDWordCount, DWordContainer& vecData) {
+    long nRet = ValidateStationAndSize(station, nDWordCount);
+    if (nRet != 0) {
+        UpdateLastError(nRet);
+        return nRet;
+    }
+
+    const short nDevType = CalculateDeviceType(station, enDevType);
+    const long nByteSize = nDWordCount * sizeof(uint32_t);
+
+    std::vector<char> vecRaw;
+    nRet = ReadDataEx(station, nDevType, nDevNo, nByteSize, vecRaw);
+    if (nRet != 0) {
+        return nRet;
+    }
+
+    vecData.clear();
+    for (long i = 0; i < nDWordCount; ++i) {
+        uint32_t val = static_cast<unsigned char>(vecRaw[i * 4 + 0]) |
+            (static_cast<unsigned char>(vecRaw[i * 4 + 1]) << 8) |
+            (static_cast<unsigned char>(vecRaw[i * 4 + 2]) << 16) |
+            (static_cast<unsigned char>(vecRaw[i * 4 + 3]) << 24);
+        vecData.push_back(val);
+    }
+
+    return 0;
+}
+
+// 扩展写数据
 long CPerformanceMelsec::WriteDataEx(const StationIdentifier& station, long nDevType, long nDevNo, const std::vector<char>& vecData) {
-    // 楠岃瘉绔欑偣鍙傛暟鍜屾暟鎹湁鏁堟��
+    // 验证站点参数和数据有效性
     long nRet = ValidateStationAndData(station, vecData);
     if (nRet != 0) {
         UpdateLastError(nRet);
         return nRet;
     }
 
-    // 灏� vecData 杞崲涓� short 绫诲瀷鐨勭紦鍐插尯
+    // 将 vecData 转换为 short 类型的缓冲区
     long nSize = static_cast<long>(vecData.size());
-    std::vector<short> vecBuffer((nSize + 1) / 2, 0);
+    nSize = nSize % 2 != 0 ? nSize + 1 : nSize;
+    std::vector<short> vecBuffer(nSize / 2, 0);
 
     {
-        std::lock_guard<std::mutex> lock(m_mtx); // 绾跨▼瀹夊叏淇濇姢
+        std::lock_guard<std::mutex> lock(m_mtx); // 线程安全保护
         ConvertCharToShort(vecData, vecBuffer);
         nRet = mdSendEx(m_nPath, station.nNetNo, station.nStNo, nDevType, nDevNo, &nSize, vecBuffer.data());
     }
 
-    // 閿欒澶勭悊鍜屾棩蹇楄褰�
+    // 错误处理和日志记录
     if (nRet != 0) {
         UpdateLastError(nRet);
         LOG_ERROR(m_strLastError);
@@ -688,7 +818,83 @@
     return nRet;
 }
 
-// 鎵╁睍杞厓浠堕殢鏈鸿鍙�
+// 扩展写位数据
+long CPerformanceMelsec::WriteBitDataEx(const StationIdentifier& station, DeviceType enDevType, long nDevNo, const BitContainer& vecData) {
+    long nRet = ValidateStationAndData(station, vecData);
+    if (nRet != 0) {
+        UpdateLastError(nRet);
+        return nRet;
+    }
+
+    if (nDevNo % 8 != 0) {
+        UpdateLastError(ERROR_CODE_INVALID_PARAM);
+        return ERROR_CODE_INVALID_PARAM;
+    }
+
+    const short nDevType = CalculateDeviceType(station, enDevType);
+    const size_t nWordCount = (vecData.size() + 15) / 16;
+
+    std::vector<short> vecWordBuffer(nWordCount, 0);
+    for (size_t i = 0; i < vecData.size(); ++i) {
+        if (vecData[i]) {
+            vecWordBuffer[i / 16] |= (1 << (i % 16));
+        }
+    }
+
+    // 转换 short -> char
+    std::vector<char> vecByteBuffer;
+    vecByteBuffer.resize(nWordCount * sizeof(short));
+    for (size_t i = 0; i < nWordCount; ++i) {
+        vecByteBuffer[i * 2] = static_cast<char>(vecWordBuffer[i] & 0xFF);
+        vecByteBuffer[i * 2 + 1] = static_cast<char>((vecWordBuffer[i] >> 8) & 0xFF);
+    }
+
+    return WriteDataEx(station, nDevType, nDevNo, vecByteBuffer);
+}
+
+// 扩展写字数据
+long CPerformanceMelsec::WriteWordDataEx(const StationIdentifier& station, DeviceType enDevType, long nDevNo, const WordContainer& vecData) {
+    long nRet = ValidateStationAndData(station, vecData);
+    if (nRet != 0) {
+        UpdateLastError(nRet);
+        return nRet;
+    }
+
+    const short nDevType = CalculateDeviceType(station, enDevType);
+    std::vector<char> vecByteBuffer;
+    vecByteBuffer.resize(vecData.size() * sizeof(short));
+
+    for (size_t i = 0; i < vecData.size(); ++i) {
+        vecByteBuffer[i * 2] = static_cast<char>(vecData[i] & 0xFF);
+        vecByteBuffer[i * 2 + 1] = static_cast<char>((vecData[i] >> 8) & 0xFF);
+    }
+
+    return WriteDataEx(station, nDevType, nDevNo, vecByteBuffer);
+}
+
+// 扩展写双字数据
+long CPerformanceMelsec::WriteDWordDataEx(const StationIdentifier& station, DeviceType enDevType, long nDevNo, const DWordContainer& vecData) {
+    long nRet = ValidateStationAndData(station, vecData);
+    if (nRet != 0) {
+        UpdateLastError(nRet);
+        return nRet;
+    }
+
+    const short nDevType = CalculateDeviceType(station, enDevType);
+    std::vector<char> vecByteBuffer;
+    vecByteBuffer.resize(vecData.size() * sizeof(uint32_t));
+
+    for (size_t i = 0; i < vecData.size(); ++i) {
+        vecByteBuffer[i * 4] = static_cast<char>(vecData[i] & 0xFF);
+        vecByteBuffer[i * 4 + 1] = static_cast<char>((vecData[i] >> 8) & 0xFF);
+        vecByteBuffer[i * 4 + 2] = static_cast<char>((vecData[i] >> 16) & 0xFF);
+        vecByteBuffer[i * 4 + 3] = static_cast<char>((vecData[i] >> 24) & 0xFF);
+    }
+
+    return WriteDataEx(station, nDevType, nDevNo, vecByteBuffer);
+}
+
+// 扩展软元件随机读取
 long CPerformanceMelsec::ReadRandomDataEx(const StationIdentifier& station, const std::vector<SoftElement>& vecSoftElements, std::vector<char>& vecData) {
     if (vecSoftElements.empty()) {
         UpdateLastError(ERROR_INVALID_PARAMETER);
@@ -696,48 +902,48 @@
         return ERROR_INVALID_PARAMETER;
     }
 
-    // 鍑嗗 dev 鏁版嵁
-    std::vector<short> devBuffer(vecSoftElements.size() * 3 + 1, 0); // 姣忎釜杞厓浠堕渶瑕� 3 涓� short锛屽鍔犱竴涓鏁板櫒
-    devBuffer[0] = static_cast<short>(vecSoftElements.size());                 // 绗竴涓厓绱犳槸杞厓浠舵暟閲�
+    // 准备 dev 数据
+    std::vector<short> devBuffer(vecSoftElements.size() * 3 + 1, 0); // 每个软元件需要 3 个 short，外加一个计数器
+    devBuffer[0] = static_cast<short>(vecSoftElements.size());                 // 第一个元素是软元件数量
     for (size_t i = 0; i < vecSoftElements.size(); ++i) {
         const SoftElement& element = vecSoftElements[i];
-        devBuffer[i * 3 + 1] = element.nType;                        // 杞厓浠剁被鍨�
-        devBuffer[i * 3 + 2] = static_cast<short>(element.nStartNo); // 璧峰杞厓浠剁紪鍙�
-        devBuffer[i * 3 + 3] = element.nElementCount;                // 鐐规暟
+        devBuffer[i * 3 + 1] = element.nType;                        // 软元件类型
+        devBuffer[i * 3 + 2] = static_cast<short>(element.nStartNo); // 起始软元件编号
+        devBuffer[i * 3 + 3] = element.nElementCount;                // 点数
     }
 
-    // 璁＄畻璇诲彇鏁版嵁鎵�闇�缂撳啿鍖哄ぇ灏�
+    // 计算读取数据所需缓冲区大小
     long nBufferSize = 0;
     for (const auto& element : vecSoftElements) {
-        nBufferSize += element.nElementCount * 2; // 姣忎釜鐐瑰崰鐢� 2 涓瓧鑺�
+        nBufferSize += element.nElementCount * 2; // 每个点占用 2 个字节
     }
 
-    // 閿佷繚鎶ゅ強璋冪敤 mdRandREx
+    // 锁保护及调用 mdRandREx
     long nRet = 0;
     std::vector<short> vecBuffer(nBufferSize / 2, 0);
     {
-        std::lock_guard<std::mutex> lock(m_mtx); // 纭繚绾跨▼瀹夊叏
+        std::lock_guard<std::mutex> lock(m_mtx); // 确保线程安全
         nRet = mdRandREx(m_nPath, station.nNetNo, station.nStNo, devBuffer.data(), vecBuffer.data(), nBufferSize);
     }
 
-    // 閿欒澶勭悊鍜屾棩蹇楄褰�
+    // 错误处理和日志记录
     if (nRet != 0) {
         UpdateLastError(nRet);
         LOG_ERROR(m_strLastError);
         return nRet;
     }
 
-    // 灏嗚鍙栧埌鐨� short 鏁版嵁杞崲涓� char 鏁版嵁
+    // 将读取到的 short 数据转换为 char 数据
     vecData.resize(nBufferSize);
     for (size_t i = 0; i < vecBuffer.size(); ++i) {
-        vecData[i * 2] = static_cast<char>(vecBuffer[i] & 0xFF);            // 浣庡瓧鑺�
-        vecData[i * 2 + 1] = static_cast<char>((vecBuffer[i] >> 8) & 0xFF); // 楂樺瓧鑺�
+        vecData[i * 2] = static_cast<char>(vecBuffer[i] & 0xFF);            // 低字节
+        vecData[i * 2 + 1] = static_cast<char>((vecBuffer[i] >> 8) & 0xFF); // 高字节
     }
 
     return nRet;
 }
 
-// 鎵╁睍杞厓浠堕殢鏈哄啓鍏ワ紙鏀寔澶氫釜杞厓浠讹級
+// 扩展软元件随机写入（支持多个软元件）
 long CPerformanceMelsec::WriteRandomDataEx(const StationIdentifier& station, const std::vector<SoftElement>& vecSoftElements, const std::vector<char>& vecData) {
     if (vecSoftElements.empty() || vecData.empty()) {
         UpdateLastError(ERROR_INVALID_PARAMETER);
@@ -745,26 +951,26 @@
         return ERROR_INVALID_PARAMETER;
     }
 
-    // 鍑嗗 dev 鏁版嵁
-    std::vector<long> devBuffer(vecSoftElements.size() * 3 + 1, 0); // 姣忎釜杞厓浠堕渶瑕� 3 涓� long锛屽鍔犱竴涓鏁板櫒
-    devBuffer[0] = static_cast<long>(vecSoftElements.size());                 // 绗竴涓厓绱犳槸杞厓浠舵暟閲�
+    // 准备 dev 数据
+    std::vector<long> devBuffer(vecSoftElements.size() * 3 + 1, 0); // 每个软元件需要 3 个 long，外加一个计数器
+    devBuffer[0] = static_cast<long>(vecSoftElements.size());                 // 第一个元素是软元件数量
     for (size_t i = 0; i < vecSoftElements.size(); ++i) {
         const SoftElement& element = vecSoftElements[i];
-        devBuffer[i * 3 + 1] = static_cast<long>(element.nType);    // 杞厓浠剁被鍨�
-        devBuffer[i * 3 + 2] = element.nStartNo;                    // 璧峰杞厓浠剁紪鍙凤紙宸茬粡鏄� long 绫诲瀷锛屾棤闇�杞崲锛�
-        devBuffer[i * 3 + 3] = static_cast<long>(element.nElementCount); // 鐐规暟
+        devBuffer[i * 3 + 1] = static_cast<long>(element.nType);    // 软元件类型
+        devBuffer[i * 3 + 2] = element.nStartNo;                    // 起始软元件编号（已经是 long 类型，无需转换）
+        devBuffer[i * 3 + 3] = static_cast<long>(element.nElementCount); // 点数
     }
 
-    // 閿佷繚鎶ゅ強璋冪敤 mdRandWEx
+    // 锁保护及调用 mdRandWEx
     long nRet = 0;
     std::vector<short> vecBuffer(vecData.size() / 2, 0);
     {
-        std::lock_guard<std::mutex> lock(m_mtx); // 纭繚绾跨▼瀹夊叏
+        std::lock_guard<std::mutex> lock(m_mtx); // 确保线程安全
         ConvertCharToShort(vecData, vecBuffer);
         nRet = mdRandWEx(m_nPath, station.nNetNo, station.nStNo, devBuffer.data(), vecBuffer.data(), static_cast<long>(vecBuffer.size()));
     }
 
-    // 閿欒澶勭悊鍜屾棩蹇楄褰�
+    // 错误处理和日志记录
     if (nRet != 0) {
         UpdateLastError(nRet);
         LOG_ERROR(m_strLastError);
@@ -773,9 +979,9 @@
     return nRet;
 }
 
-// 杩滅▼璁惧绔�/杩滅▼绔欑殑缂撳啿瀛樺偍鍣ㄨ鍙�
+// 远程设备站/远程站的缓冲存储器读取
 long CPerformanceMelsec::ReadRemoteBuffer(const StationIdentifier& station, long nOffset, long nSize, std::vector<char>& vecData) {
-    // 楠岃瘉绔欑偣鍙傛暟鍜屾暟鎹湁鏁堟��
+    // 验证站点参数和数据有效性
     int nRet = ValidateStation(station);
     if (nRet != 0) {
         UpdateLastError(nRet);
@@ -790,36 +996,37 @@
     long nActualSize = (nSize + 1) / 2;
     std::vector<short> vecBuffer(nActualSize, 0);
     {
-        std::lock_guard<std::mutex> lock(m_mtx); // 绾跨▼瀹夊叏淇濇姢
+        std::lock_guard<std::mutex> lock(m_mtx); // 线程安全保护
         nRet = mdRemBufReadEx(m_nPath, station.nNetNo, station.nStNo, nOffset, &nActualSize, vecBuffer.data());
     }
 
     if (nRet != 0) {
-        UpdateLastError(nRet); // 鏇存柊閿欒鐮�
+        UpdateLastError(nRet); // 更新错误码
         LOG_ERROR(m_strLastError);
-    } else {
-        std::lock_guard<std::mutex> lock(m_mtx); // 绾跨▼瀹夊叏淇濇姢
+    }
+    else {
+        std::lock_guard<std::mutex> lock(m_mtx); // 线程安全保护
         ConvertShortToChar(vecBuffer, vecData);
     }
 
     return nRet;
 }
 
-// 杩滅▼璁惧绔�/杩滅▼绔欑殑缂撳啿瀛樺偍鍣ㄥ啓鍏�
+// 远程设备站/远程站的缓冲存储器写入
 long CPerformanceMelsec::WriteRemoteBuffer(const StationIdentifier& station, long nOffset, const std::vector<char>& vecData) {
-    // 楠岃瘉绔欑偣鍙傛暟鍜屾暟鎹湁鏁堟��
+    // 验证站点参数和数据有效性
     long nRet = ValidateStationAndData(station, vecData);
     if (nRet != 0) {
         UpdateLastError(nRet);
         return nRet;
     }
 
-    // 灏� vecData 杞崲涓� short 绫诲瀷鐨勭紦鍐插尯
+    // 将 vecData 转换为 short 类型的缓冲区
     long nSize = static_cast<long>(vecData.size());
     std::vector<short> vecBuffer((nSize + 1) / 2, 0);
 
     {
-        std::lock_guard<std::mutex> lock(m_mtx); // 绾跨▼瀹夊叏淇濇姢
+        std::lock_guard<std::mutex> lock(m_mtx); // 线程安全保护
         ConvertCharToShort(vecData, vecBuffer);
         nRet = mdRemBufWriteEx(m_nPath, station.nNetNo, station.nStNo, nOffset, &nSize, vecBuffer.data());
     }
@@ -832,7 +1039,7 @@
     return nRet;
 }
 
-// 杩滅▼绔欑殑缂撳啿瀛樺偍鍣ㄨ鍙� 瀵硅薄绔橧P鍦板潃鎸囧畾
+// 远程站的缓冲存储器读取 对象站IP地址指定
 long CPerformanceMelsec::ReadRemoteBufferByIp(const std::string& strIP, long nOffset, long nSize, std::vector<char>& vecData) {
     uint32_t nAddress = 0;
     if (nSize < 0 || !ConvertIpStringToUint32(strIP, nAddress)) {
@@ -840,29 +1047,30 @@
         return ERROR_CODE_INVALID_PARAM;
     }
 
-    // 灏嗙紦鍐插尯澶у皬璋冩暣涓� nSize
+    // 将缓冲区大小调整为 nSize
     vecData.resize(nSize, 0);
-    std::vector<short> vecBuffer((nSize + 1) / 2, 0); // 杞崲涓� short 绫诲瀷
+    std::vector<short> vecBuffer((nSize + 1) / 2, 0); // 转换为 short 类型
 
-    // 璋冪敤搴曞眰 SDK
+    // 调用底层 SDK
     long nRet = 0;
     {
-        std::lock_guard<std::mutex> lock(m_mtx); // 绾跨▼瀹夊叏淇濇姢
+        std::lock_guard<std::mutex> lock(m_mtx); // 线程安全保护
         nRet = mdRemBufReadIPEx(m_nPath, static_cast<long>(nAddress), nOffset, &nSize, vecBuffer.data());
     }
 
     if (nRet != 0) {
         UpdateLastError(nRet);
         LOG_ERROR(m_strLastError);
-    } else {
-        std::lock_guard<std::mutex> lock(m_mtx); // 绾跨▼瀹夊叏淇濇姢
+    }
+    else {
+        std::lock_guard<std::mutex> lock(m_mtx); // 线程安全保护
         ConvertShortToChar(vecBuffer, vecData);
     }
 
     return nRet;
 }
 
-// 杩滅▼绔欑殑缂撳啿瀛樺偍鍣ㄥ啓鍏� 瀵硅薄绔橧P鍦板潃鎸囧畾
+// 远程站的缓冲存储器写入 对象站IP地址指定
 long CPerformanceMelsec::WriteRemoteBufferByIp(const std::string& strIP, long nOffset, const std::vector<char>& vecData) {
     uint32_t nAddress = 0;
     if (vecData.empty() || !ConvertIpStringToUint32(strIP, nAddress)) {
@@ -870,13 +1078,13 @@
         return ERROR_CODE_INVALID_PARAM;
     }
 
-    // 杞崲 vecData 涓� short 绫诲瀷鐨勭紦鍐插尯
+    // 转换 vecData 为 short 类型的缓冲区
     long nSize = static_cast<long>(vecData.size());
     std::vector<short> vecBuffer((nSize + 1) / 2, 0);
 
     long nRet = 0;
     {
-        std::lock_guard<std::mutex> lock(m_mtx); // 绾跨▼瀹夊叏
+        std::lock_guard<std::mutex> lock(m_mtx); // 线程安全
         ConvertCharToShort(vecData, vecBuffer);
         nRet = mdRemBufWriteIPEx(m_nPath, static_cast<long>(nAddress), nOffset, &nSize, vecBuffer.data());
     }
@@ -889,18 +1097,18 @@
     return nRet;
 }
 
-// 璁剧疆(ON)瀵硅薄绔欑殑鎸囧畾浣嶈蒋鍏冧欢
+// 设置(ON)对象站的指定位软元件
 int CPerformanceMelsec::SetBitDevice(const StationIdentifier& station, const DeviceType enDevType, const short nDevNo) {
-    // 楠岃瘉绔欑偣鍙傛暟
+    // 验证站点参数
     int nRet = ValidateStation(station);
     if (nRet != 0) {
         UpdateLastError(nRet);
         return nRet;
     }
 
-    // 纭繚绾跨▼瀹夊叏鐨勬渶灏忛攣瀹氳寖鍥�
+    // 确保线程安全的最小锁定范围
     {
-        std::lock_guard<std::mutex> lock(m_mtx); // 绾跨▼瀹夊叏
+        std::lock_guard<std::mutex> lock(m_mtx); // 线程安全
         const short nDevType = CalculateDeviceType(station, enDevType);
         nRet = mdDevSet(m_nPath, CombineStation(station), nDevType, nDevNo);
     }
@@ -913,16 +1121,16 @@
     return nRet;
 }
 
-// 澶嶄綅(OFF)瀵硅薄绔欑殑鎸囧畾浣嶈蒋鍏冧欢
+// 复位(OFF)对象站的指定位软元件
 int CPerformanceMelsec::ResetBitDevice(const StationIdentifier& station, const DeviceType enDevType, const short enDevNo) {
-    // 楠岃瘉绔欑偣鍙傛暟
+    // 验证站点参数
     int nRet = ValidateStation(station);
     if (nRet != 0) {
         UpdateLastError(nRet);
         return nRet;
     }
 
-    // 纭繚绾跨▼瀹夊叏鐨勬渶灏忛攣瀹氳寖鍥�
+    // 确保线程安全的最小锁定范围
     {
         std::lock_guard<std::mutex> lock(m_mtx);
         const short nDevType = CalculateDeviceType(station, enDevType);
@@ -937,11 +1145,11 @@
     return nRet;
 }
 
-// 鎵╁睍浣嶈蒋鍏冧欢璁剧疆
+// 扩展位软元件设置
 long CPerformanceMelsec::SetBitDeviceEx(const StationIdentifier& station, long nDevType, long nDevNo) {
     std::lock_guard<std::mutex> lock(m_mtx);
 
-    // 妫�鏌ュ弬鏁版湁鏁堟��
+    // 检查参数有效性
     long nRet = ValidateStation(station);
     if (nRet != 0) {
         UpdateLastError(nRet);
@@ -957,11 +1165,11 @@
     return nRet;
 }
 
-// 鎵╁睍浣嶈蒋鍏冧欢澶嶄綅
+// 扩展位软元件复位
 long CPerformanceMelsec::ResetBitDeviceEx(const StationIdentifier& station, long nDevType, long nDevNo) {
     std::lock_guard<std::mutex> lock(m_mtx);
 
-    // 妫�鏌ュ弬鏁版湁鏁堟��
+    // 检查参数有效性
     long nRet = ValidateStation(station);
     if (nRet != 0) {
         UpdateLastError(nRet);
@@ -977,23 +1185,23 @@
     return nRet;
 }
 
-// 鎵ц瀵硅薄绔欑殑CPU
+// 执行对象站的CPU
 int CPerformanceMelsec::ControlCPU(const StationIdentifier& station, ControlCode enControlCode) {
-    // 楠岃瘉绔欑偣鍙傛暟鍜屾暟鎹湁鏁堟��
+    // 验证站点参数和数据有效性
     int nRet = ValidateStation(station);
     if (nRet != 0) {
         UpdateLastError(nRet);
         return nRet;
     }
 
-    // 楠岃瘉鎺у埗鐮佹槸鍚﹀悎娉�
+    // 验证控制码是否合法
     const auto nControlCode = static_cast<short>(enControlCode);
     if (nControlCode < 0 || nControlCode > 2) {
-        UpdateLastError(ERROR_CODE_INVALID_PARAM); // 鍙傛暟閿欒
+        UpdateLastError(ERROR_CODE_INVALID_PARAM); // 参数错误
         return ERROR_CODE_INVALID_PARAM;
     }
 
-    // 纭繚绾跨▼瀹夊叏鐨勬渶灏忛攣瀹氳寖鍥�
+    // 确保线程安全的最小锁定范围
     {
         std::lock_guard<std::mutex> lock(m_mtx);
         nRet = mdControl(m_nPath, CombineStation(station), nControlCode);
@@ -1007,7 +1215,7 @@
     return nRet;
 }
 
-// 浜嬩欢绛夊緟
+// 事件等待
 int CPerformanceMelsec::WaitForBoardEvent(std::vector<short> vecEventNumbers, const int nTimeoutMs, EventDetails& details) {
     std::lock_guard<std::mutex> lock(m_mtx);
 
@@ -1021,12 +1229,12 @@
         return ERROR_CODE_INVALID_PARAM;
     }
 
-    // 绗� 0 涓厓绱犲瓨鍌ㄦ暟閲忥紝鏈�澶ф敮鎸� 64 涓簨浠�
-    std::array<short, 65> eventno = {0};
+    // 第 0 个元素存储数量，最大支持 64 个事件
+    std::array<short, 65> eventno = { 0 };
     eventno[0] = static_cast<short>(vecEventNumbers.size());
     std::copy(vecEventNumbers.begin(), vecEventNumbers.end(), eventno.begin() + 1);
 
-    // 鍒濆鍖栬緭鍑哄弬鏁�
+    // 初始化输出参数
     details.nEventNo = 0;
     details.details.fill(0);
 
@@ -1039,99 +1247,100 @@
     return nRet;
 }
 
-//============================================杈呭姪鍑芥暟=======================================================
-// 鏇存柊鏈�杩戠殑閿欒淇℃伅
+//============================================辅助函数=======================================================
+// 更新最近的错误信息
 void CPerformanceMelsec::UpdateLastError(const int nCode) {
     if (nCode == 0) {
         return;
     }
 
-    // 妫�鏌ラ敊璇爜鏄惁瀛樺湪浜庢槧灏勮〃涓�
+    // 检查错误码是否存在于映射表中
     const auto it = m_mapError.find(nCode);
     if (it != m_mapError.end()) {
-        // 濡傛灉鎵惧埌锛岀洿鎺ヨ繑鍥炲搴旇瑷�鐨勯敊璇俊鎭�
+        // 如果找到，直接返回对应语言的错误信息
         m_strLastError = it->second;
-    } else {
-        // 濡傛灉鏈壘鍒帮紝澶勭悊鐗规畩鑼冨洿
+    }
+    else {
+        // 如果未找到，处理特殊范围
         m_strLastError = "Unknown error.";
         if (nCode == -28611 || nCode == -28612) {
-            // 绯荤粺鍑洪敊
+            // 系统出错
             m_strLastError = "System error.";
         }
 
         if (nCode >= -20480 && nCode <= -16384) {
-            // CC-Link 绯荤粺妫�娴嬪嚭鐨勯敊璇�
+            // CC-Link 系统检测出的错误
             m_strLastError = "Error detected in the CC-Link system.";
         }
 
         if (nCode >= -12288 && nCode <= -8193) {
-            // CC-Link IE TSN 绯荤粺妫�娴嬪嚭鐨勯敊璇�
+            // CC-Link IE TSN 系统检测出的错误
             m_strLastError = "Error detected in the CC-Link IE TSN system.";
         }
 
         if (nCode >= -8192 && nCode <= -4097) {
-            // CC-Link IE 鎺у埗缃戠粶绯荤粺妫�娴嬪嚭鐨勯敊璇�
+            // CC-Link IE 控制网络系统检测出的错误
             m_strLastError = "Error detected in the CC-Link IE control network system.";
         }
 
         if (nCode >= -4096 && nCode <= -257) {
-            // MELSECNET/10 鎴� MELSECNET/缃戠粶绯荤粺閿欒鑼冨洿
+            // MELSECNET/10 或 MELSECNET/网络系统错误范围
             m_strLastError = "Errors detected in MELSECNET/10 or MELSECNET/network system.";
         }
 
         if (nCode >= 4096 && nCode <= 16383) {
-            // MELSEC 鏁版嵁閾炬帴搴撹寖鍥�
+            // MELSEC 数据链接库范围
             m_strLastError = "Internal error detected by MELSEC Data Link Library.";
         }
 
         if (nCode == 18944 || nCode == 18945) {
-            // 閾炬帴鍏宠仈鍑洪敊
+            // 链接关联出错
             m_strLastError = "Link association error: Network does not exist, unsupported CPU, or incorrect network No./station number.";
         }
 
         if (nCode >= 16384 && nCode <= 20479) {
-            // PLC CPU 妫�娴嬭寖鍥�
+            // PLC CPU 检测范围
             m_strLastError = "Errors detected by the programmable controller CPU in the target station.";
         }
 
         if (nCode >= 28416 && nCode <= 28671) {
-            // 鍐椾綑鍔熻兘妯″潡鑼冨洿
+            // 冗余功能模块范围
             m_strLastError = "Error detected in the redundancy module of the target station.";
         }
     }
 }
 
-// 妫�鏌ヨ繛鎺ョ姸鎬佸拰绔欑偣鍙傛暟鏈夋晥鎬�
+// 检查连接状态和站点参数有效性
 int CPerformanceMelsec::ValidateStation(const StationIdentifier& station) const {
-    // 妫�鏌ユ槸鍚﹀凡杩炴帴
+    // 检查是否已连接
     if (!m_bConnected.load()) {
         return ERROR_CODE_NOT_CONNECTED;
     }
 
-    // 妫�鏌ョ綉缁滃彿鍜岀珯鐐瑰彿鑼冨洿
+    // 检查网络号和站点号范围
     if (station.nNetNo < 0 || station.nNetNo > 239 || station.nStNo < 0 || station.nStNo > 255) {
         return ERROR_CODE_INVALID_PARAM;
     }
 
-    return 0; // 鍙傛暟鏈夋晥
+    return 0; // 参数有效
 }
 
-// 楠岃瘉绔欑偣鍙傛暟鍜屾暟鎹湁鏁堟��
+// 验证站点参数和数据有效性
 int CPerformanceMelsec::ValidateStationAndSize(const StationIdentifier& station, const short nCount) const {
-    // 楠岃瘉绔欑偣鍙傛暟
+    // 验证站点参数
     const int nRet = ValidateStation(station);
     if (nRet != 0) {
-        return nRet; // 濡傛灉绔欑偣楠岃瘉澶辫触锛岃繑鍥炲搴旈敊璇爜
+        return nRet; // 如果站点验证失败，返回对应错误码
     }
 
     if (nCount <= 0) {
         return ERROR_CODE_INVALID_PARAM;
     }
 
-    return 0; // 楠岃瘉閫氳繃
+    return 0; // 验证通过
 }
 
-// IP瀛楃涓茶浆uint32_t
+// IP字符串转uint32_t
 bool CPerformanceMelsec::ConvertIpStringToUint32(const std::string& strIP, uint32_t& nIP) {
     nIP = 0;
     std::stringstream ss(strIP);
@@ -1150,173 +1359,181 @@
     return true;
 }
 
-//============================================闈欐�佽緟鍔╁嚱鏁�====================================================
-// 寤舵椂锛屽苟涓旇浆鍙戠獥鍙ｆ秷鎭�
+//============================================静态辅助函数====================================================
+// 延时，并且转发窗口消息
 void CPerformanceMelsec::Delay(const unsigned int nDelayMs) {
     MSG message;
-    // 濡傛灉寤惰繜鏃堕棿涓� 0锛屼粎澶勭悊涓�娆℃秷鎭槦鍒�
+    // 如果延迟时间为 0，仅处理一次消息队列
     if (nDelayMs == 0) {
-        // 闈為樆濉炵殑妫�鏌ユ秷鎭槦鍒�
+        // 非阻塞的检查消息队列
         if (PeekMessage(&message, nullptr, 0, 0, PM_REMOVE)) {
-            TranslateMessage(&message);  // 灏嗘秷鎭浆鍖栦负鏈夋晥鐨勭獥鍙ｆ秷鎭�
-            DispatchMessage(&message);   // 娲惧彂娑堟伅缁欑浉搴旂殑绐楀彛杩囩▼
+            TranslateMessage(&message);  // 将消息转化为有效的窗口消息
+            DispatchMessage(&message);   // 派发消息给相应的窗口过程
         }
         return;
     }
 
     DWORD finish;
-    const DWORD start = GetTickCount();  // 鑾峰彇褰撳墠鐨勬椂闂存埑锛堜粠绯荤粺鍚姩浠ユ潵鐨勬绉掓暟锛�
+    const DWORD start = GetTickCount();  // 获取当前的时间戳（从系统启动以来的毫秒数）
     do {
         if (PeekMessage(&message, nullptr, 0, 0, PM_REMOVE)) {
-            TranslateMessage(&message);  // 杞崲娑堟伅
-            DispatchMessage(&message);   // 澶勭悊娑堟伅
+            TranslateMessage(&message);  // 转换消息
+            DispatchMessage(&message);   // 处理消息
         }
-        Sleep(1);   // 鏆傚仠 1 姣锛岄槻姝㈣繃搴﹀崰鐢� CPU
-        finish = GetTickCount(); // 鑾峰彇褰撳墠鐨勬椂闂存埑
-    } while ((finish - start) < nDelayMs);  // 寰幆鐩村埌缁忚繃鐨勬椂闂村ぇ浜庢寚瀹氱殑寤惰繜鏃堕棿
+        Sleep(1);   // 暂停 1 毫秒，防止过度占用 CPU
+        finish = GetTickCount(); // 获取当前的时间戳
+    } while ((finish - start) < nDelayMs);  // 循环直到经过的时间大于指定的延迟时间
 }
 
 BoardType CPerformanceMelsec::FindBoardTypeByChannel(const int nChannel) {
     if (nChannel >= MELSECNET_CHANNEL(1) && nChannel <= MELSECNET_CHANNEL(4)) {
         return BoardType::MELSECNET_H;
-    } else if (nChannel >= CC_LINK_CHANNEL(1) && nChannel <= CC_LINK_CHANNEL(4)) {
+    }
+    else if (nChannel >= CC_LINK_CHANNEL(1) && nChannel <= CC_LINK_CHANNEL(4)) {
         return BoardType::CC_LINK_VER_2;
-    } else if (nChannel >= CC_LINK_IE_CONTROL_CHANNEL(1) && nChannel <= CC_LINK_IE_CONTROL_CHANNEL(4)) {
+    }
+    else if (nChannel >= CC_LINK_IE_CONTROL_CHANNEL(1) && nChannel <= CC_LINK_IE_CONTROL_CHANNEL(4)) {
         return BoardType::CC_LINK_IE_CONTROL;
-    } else if (nChannel >= CC_LINK_IE_FIELD_CHANNEL(1) && nChannel <= CC_LINK_IE_FIELD_CHANNEL(4)) {
+    }
+    else if (nChannel >= CC_LINK_IE_FIELD_CHANNEL(1) && nChannel <= CC_LINK_IE_FIELD_CHANNEL(4)) {
         return BoardType::CC_LINK_IE_FIELD;
-    } else if (nChannel >= CC_LINK_IE_TSN_CHANNEL(1) && nChannel <= CC_LINK_IE_TSN_CHANNEL(4)) {
+    }
+    else if (nChannel >= CC_LINK_IE_TSN_CHANNEL(1) && nChannel <= CC_LINK_IE_TSN_CHANNEL(4)) {
         return BoardType::CC_LINK_IE_TSN;
     }
     return BoardType::UNKNOWN;
 }
 
-// 鍚堝苟缃戠粶鍙峰拰绔欑偣鍙�
+// 合并网络号和站点号
 short CPerformanceMelsec::CombineStation(const StationIdentifier& station) {
     return static_cast<short>(station.nStNo | ((station.nNetNo << 8) & 0xFF00));
 }
 
-// 璁＄畻杞厓浠剁被鍨�
+// 计算软元件类型
 short CPerformanceMelsec::CalculateDeviceType(const StationIdentifier& station, DeviceType enDevType) {
     int nDevType = static_cast<int>(enDevType);
 
-    // 鏍规嵁杞厓浠剁被鍨嬬殑鐗瑰畾瑙勫垯杩涜璁＄畻
+    // 根据软元件类型的特定规则进行计算
     if (enDevType == DeviceType::LX || enDevType == DeviceType::LY ||
         enDevType == DeviceType::LB || enDevType == DeviceType::LW ||
         enDevType == DeviceType::LSB || enDevType == DeviceType::LSW) {
-        // 缃戠粶鍙峰姞鍋忕Щ
+        // 网络号加偏移
         nDevType += station.nNetNo;
-    } else if (enDevType == DeviceType::ER) {
-        // 鏂囦欢瀵勫瓨鍣ㄧ殑鍧楀彿鍔犲亸绉�
+    }
+    else if (enDevType == DeviceType::ER) {
+        // 文件寄存器的块号加偏移
         nDevType += 0;
-    } else if (enDevType == DeviceType::SPG) {
-        // 璧峰 I/O No. 梅 16 鐨勫��
+    }
+    else if (enDevType == DeviceType::SPG) {
+        // 起始 I/O No. ÷ 16 的值
         nDevType += 0 / 16;
     }
 
     return static_cast<short>(nDevType);
 }
 
-// std::vector<char>杞崲涓簊td::vector<short>
+// std::vector<char>转换为std::vector<short>
 void CPerformanceMelsec::ConvertCharToShort(const std::vector<char>& vecChar, std::vector<short>& vecShort) {
-    vecShort.resize((vecChar.size() + 1) / 2, 0); // 璋冩暣 short 瀹瑰櫒澶у皬
+    vecShort.resize((vecChar.size() + 1) / 2, 0); // 调整 short 容器大小
     for (size_t i = 0; i < vecChar.size(); i++) {
         if (i % 2 == 0) {
-            vecShort[i / 2] = static_cast<unsigned char>(vecChar[i]);       // 浣庡瓧鑺�
-        } else {
-            vecShort[i / 2] |= static_cast<unsigned char>(vecChar[i]) << 8; // 楂樺瓧鑺�
+            vecShort[i / 2] = static_cast<unsigned char>(vecChar[i]);       // 低字节
+        }
+        else {
+            vecShort[i / 2] |= static_cast<unsigned char>(vecChar[i]) << 8; // 高字节
         }
     }
 }
 
-// std::vector<short>杞崲涓簊td::vector<char>
+// std::vector<short>转换为std::vector<char>
 void CPerformanceMelsec::ConvertShortToChar(const std::vector<short>& vecShort, std::vector<char>& vecChar) {
-    vecChar.resize(vecShort.size() * 2); // 璋冩暣 char 瀹瑰櫒澶у皬
+    vecChar.resize(vecShort.size() * 2); // 调整 char 容器大小
     for (size_t i = 0; i < vecShort.size(); i++) {
-        vecChar[i * 2] = static_cast<char>(vecShort[i] & 0xFF);             // 浣庡瓧鑺�
-        vecChar[i * 2 + 1] = static_cast<char>((vecShort[i] >> 8) & 0xFF);  // 楂樺瓧鑺�
+        vecChar[i * 2] = static_cast<char>(vecShort[i] & 0xFF);             // 低字节
+        vecChar[i * 2 + 1] = static_cast<char>((vecShort[i] >> 8) & 0xFF);  // 高字节
     }
 }
 
-// std::vector<uint8_t>杞崲涓簊td::vector<short>
+// std::vector<uint8_t>转换为std::vector<short>
 void CPerformanceMelsec::ConvertUint8ToShort(const std::vector<uint8_t>& vecUint8, std::vector<short>& vecShort) {
-    vecShort.resize((vecUint8.size() + 1) / 2, 0); // 璋冩暣 short 瀹瑰櫒澶у皬
+    vecShort.resize((vecUint8.size() + 1) / 2, 0); // 调整 short 容器大小
     for (size_t i = 0; i < vecUint8.size(); i++) {
         if (i % 2 == 0) {
-            vecShort[i / 2] = static_cast<short>(vecUint8[i]);          // 浣庡瓧鑺�
-        } else {
-            vecShort[i / 2] |= static_cast<short>(vecUint8[i] << 8);    // 楂樺瓧鑺�
+            vecShort[i / 2] = static_cast<short>(vecUint8[i]);          // 低字节
+        }
+        else {
+            vecShort[i / 2] |= static_cast<short>(vecUint8[i] << 8);    // 高字节
         }
     }
 }
 
-// std::vector<short>杞崲涓簊td::vector<uint8_t>
+// std::vector<short>转换为std::vector<uint8_t>
 void CPerformanceMelsec::ConvertShortToUint8(const std::vector<short>& vecShort, std::vector<uint8_t>& vecUint8) {
-    vecUint8.resize(vecShort.size() * 2); // 璋冩暣 uint8_t 瀹瑰櫒澶у皬
+    vecUint8.resize(vecShort.size() * 2); // 调整 uint8_t 容器大小
     for (size_t i = 0; i < vecShort.size(); i++) {
-        vecUint8[i * 2] = static_cast<uint8_t>(vecShort[i] & 0xFF);             // 浣庡瓧鑺�
-        vecUint8[i * 2 + 1] = static_cast<uint8_t>((vecShort[i] >> 8) & 0xFF);  // 楂樺瓧鑺�
+        vecUint8[i * 2] = static_cast<uint8_t>(vecShort[i] & 0xFF);             // 低字节
+        vecUint8[i * 2 + 1] = static_cast<uint8_t>((vecShort[i] >> 8) & 0xFF);  // 高字节
     }
 }
 
-// std::vector<uint32_t>杞崲涓簊td::vector<short>
+// std::vector<uint32_t>转换为std::vector<short>
 void CPerformanceMelsec::ConvertUint32ToShort(const std::vector<uint32_t>& vecUint32, std::vector<short>& vecShort) {
-    vecShort.resize(vecUint32.size() * 2); // 姣忎釜 uint32_t 杞崲涓轰袱涓� short
+    vecShort.resize(vecUint32.size() * 2); // 每个 uint32_t 转换为两个 short
     for (size_t i = 0; i < vecUint32.size(); i++) {
-        vecShort[i * 2] = static_cast<short>(vecUint32[i] & 0xFFFF);             // 浣�16浣�
-        vecShort[i * 2 + 1] = static_cast<short>((vecUint32[i] >> 16) & 0xFFFF); // 楂�16浣�
+        vecShort[i * 2] = static_cast<short>(vecUint32[i] & 0xFFFF);             // 低16位
+        vecShort[i * 2 + 1] = static_cast<short>((vecUint32[i] >> 16) & 0xFFFF); // 高16位
     }
 }
 
-// std::vector<short>杞崲涓簊td::vector<uint32_t>
+// std::vector<short>转换为std::vector<uint32_t>
 void CPerformanceMelsec::ConvertShortToUint32(const std::vector<short>& vecShort, std::vector<uint32_t>& vecUint32) {
-    vecUint32.resize((vecShort.size() + 1) / 2, 0); // 姣忎袱涓� short 鍚堝苟涓轰竴涓� uint32_t
+    vecUint32.resize((vecShort.size() + 1) / 2, 0); // 每两个 short 合并为一个 uint32_t
     for (size_t i = 0; i < vecUint32.size(); i++) {
-        vecUint32[i] = (static_cast<uint32_t>(static_cast<uint16_t>(vecShort[i * 2 + 1])) << 16) | // 楂�16浣�
-                       static_cast<uint32_t>(static_cast<uint16_t>(vecShort[i * 2]));              // 浣�16浣�
+        vecUint32[i] = (static_cast<uint32_t>(static_cast<uint16_t>(vecShort[i * 2 + 1])) << 16) | // 高16位
+            static_cast<uint32_t>(static_cast<uint16_t>(vecShort[i * 2]));              // 低16位
     }
 }
 
-//============================================妯℃澘杈呭姪鍑芥暟====================================================
-// 楠岃瘉绔欑偣鍙傛暟鍜屾暟鎹湁鏁堟��
+//============================================模板辅助函数====================================================
+// 验证站点参数和数据有效性
 template <typename T>
 int CPerformanceMelsec::ValidateStationAndData(const StationIdentifier& station, const std::vector<T>& vecData) {
-    // 楠岃瘉绔欑偣鍙傛暟
+    // 验证站点参数
     const int nRet = ValidateStation(station);
     if (nRet != 0) {
-        return nRet; // 濡傛灉绔欑偣楠岃瘉澶辫触锛岃繑鍥炲搴旈敊璇爜
+        return nRet; // 如果站点验证失败，返回对应错误码
     }
 
-    // 楠岃瘉鏁版嵁鏄惁涓虹┖
+    // 验证数据是否为空
     if (vecData.empty()) {
         return ERROR_CODE_INVALID_PARAM;
     }
 
-    return 0; // 楠岃瘉閫氳繃
+    return 0; // 验证通过
 }
 
-// 鐢变綆杞珮瀹瑰櫒鐨勬ā鏉匡紙鏁村瀷锛�
+// 由低转高容器的模板（整型）
 template <typename T, typename U>
 void CPerformanceMelsec::ConvertLowToHigh(const std::vector<T>& vecLow, std::vector<U>& vecHigh) {
     static_assert(std::is_integral<T>::value && std::is_integral<U>::value, "T and U must be integral types");
 
-    // 鑷姩璁＄畻 nGroupSize
+    // 自动计算 nGroupSize
     constexpr size_t nGroupSize = sizeof(U) / sizeof(T);
 
-    // 濡傛灉 T 鍜� U 鐨勫ぇ灏忕浉绛夛紝鐩存帴杞崲
+    // 如果 T 和 U 的大小相等，直接转换
     if (sizeof(T) == sizeof(U)) {
         vecHigh.assign(vecLow.begin(), vecLow.end());
         return;
     }
 
-    // 濡傛灉 U 鐨勫ぇ灏忔槸 T 鐨勫�嶆暟锛屾甯哥粍鍚�
+    // 如果 U 的大小是 T 的倍数，正常组合
     static_assert(sizeof(U) > sizeof(T), "Size of U must be greater than or equal to size of T");
 
-    // 璁＄畻瀹屾暣缁勭殑鏁伴噺
-    size_t nHighSize = (vecLow.size() + nGroupSize - 1) / nGroupSize; // 鍚戜笂鍙栨暣
+    // 计算完整组的数量
+    size_t nHighSize = (vecLow.size() + nGroupSize - 1) / nGroupSize; // 向上取整
     vecHigh.resize(nHighSize, 0);
 
-    // 鍚堝苟浣庝綅鏁版嵁鍒伴珮浣嶆暟鎹�
+    // 合并低位数据到高位数据
     for (size_t i = 0; i < vecLow.size(); i++) {
         vecHigh[i / nGroupSize] |= (static_cast<U>(vecLow[i]) << ((i % nGroupSize) * CHAR_BIT * sizeof(T)));
     }
@@ -1324,27 +1541,27 @@
     return vecHigh;
 }
 
-// 鐢遍珮杞綆瀹瑰櫒鐨勬ā鏉匡紙鏁村瀷锛�
+// 由高转低容器的模板（整型）
 template <typename T, typename U>
 void CPerformanceMelsec::ConvertHighToLow(const std::vector<T>& vecHigh, std::vector<U>& vecLow) {
     static_assert(std::is_integral<T>::value && std::is_integral<U>::value, "T and U must be integral types");
 
-    // 鑷姩璁＄畻 nGroupSize
+    // 自动计算 nGroupSize
     constexpr size_t nGroupSize = sizeof(T) / sizeof(U);
 
-    // 濡傛灉 T 鍜� U 鐨勫ぇ灏忕浉绛夛紝鐩存帴杞崲
+    // 如果 T 和 U 的大小相等，直接转换
     if (sizeof(T) == sizeof(U)) {
         vecLow.assign(vecHigh.begin(), vecHigh.end());
         return;
     }
 
-    // 濡傛灉 T 鐨勫ぇ灏忔槸 U 鐨勫�嶆暟锛屾甯稿垎瑙�
+    // 如果 T 的大小是 U 的倍数，正常分解
     static_assert(sizeof(T) > sizeof(U), "Size of T must be greater than or equal to size of U");
 
-    size_t nLowSize = vecHigh.size() * nGroupSize; // 浣庡鍣ㄧ殑澶у皬
+    size_t nLowSize = vecHigh.size() * nGroupSize; // 低容器的大小
     vecLow.resize(nLowSize, 0);
 
-    // 鍒嗚В楂樹綅鏁版嵁鍒颁綆浣嶆暟鎹�
+    // 分解高位数据到低位数据
     for (size_t i = 0; i < vecHigh.size(); i++) {
         for (size_t j = 0; j < nGroupSize; j++) {
             vecLow[i * nGroupSize + j] = static_cast<U>((vecHigh[i] >> (j * CHAR_BIT * sizeof(U))) & ((1ULL << (CHAR_BIT * sizeof(U))) - 1));

--
Gitblit v1.9.3