From f8971cfc3abcc23fd2a5541a7bf698389d5e9300 Mon Sep 17 00:00:00 2001
From: LAPTOP-SNT8I5JK\Boounion <Chenluhua@qq.com>
Date: 星期六, 15 二月 2025 16:47:54 +0800
Subject: [PATCH] 1.增加CMaster, CBonder，CEFEM等类，测试读取CC-Link数据；
---
SourceCode/Bond/Servo/Servo.vcxproj | 11
SourceCode/Bond/Servo/CCLinkPerformance/PerformanceMelsec.h | 418 ++++++++--------
SourceCode/Bond/Servo/Servo.vcxproj.user | 6
SourceCode/Bond/Servo/CCLinkPerformance/PerformanceMelsec.cpp | 437 +++++++++---------
SourceCode/Bond/Servo/CEFEM.h | 20
SourceCode/Bond/Servo/CMaster.h | 32 +
SourceCode/Bond/Servo/Model.cpp | 2
SourceCode/Bond/Servo/ServoDlg.cpp | 7
SourceCode/Bond/Servo/CCLinkPerformance/CCLinkIEControl.cpp | 46 +
SourceCode/Bond/Servo/Servo.vcxproj.filters | 8
SourceCode/Bond/Servo/CEquipment.cpp | 93 +++
SourceCode/Bond/Servo/Model.h | 2
SourceCode/Bond/Servo/CEFEM.cpp | 40 +
SourceCode/Bond/Servo/CMaster.cpp | 127 +++++
SourceCode/Bond/Servo/CCLinkPerformance/CCLinkIEControl.h | 44
SourceCode/Bond/Servo/CEquipment.h | 51 ++
SourceCode/Bond/Servo/CBonder.h | 20
SourceCode/Bond/Servo/packages.config | 5
Document/Panel Bonder八零联合 SecsTest CheckList_v3.0.xlsx | 0
SourceCode/Bond/Servo/CBonder.cpp | 40 +
20 files changed, 952 insertions(+), 457 deletions(-)
diff --git "a/Document/Panel Bonder\345\205\253\351\233\266\350\201\224\345\220\210 SecsTest CheckList_v3.0.xlsx" "b/Document/Panel Bonder\345\205\253\351\233\266\350\201\224\345\220\210 SecsTest CheckList_v3.0.xlsx"
index 18989d8..33de0ae 100644
--- "a/Document/Panel Bonder\345\205\253\351\233\266\350\201\224\345\220\210 SecsTest CheckList_v3.0.xlsx"
+++ "b/Document/Panel Bonder\345\205\253\351\233\266\350\201\224\345\220\210 SecsTest CheckList_v3.0.xlsx"
Binary files differ
diff --git a/SourceCode/Bond/Servo/CBonder.cpp b/SourceCode/Bond/Servo/CBonder.cpp
new file mode 100644
index 0000000..11d90d8
--- /dev/null
+++ b/SourceCode/Bond/Servo/CBonder.cpp
@@ -0,0 +1,40 @@
+#include "stdafx.h"
+#include "CBonder.h"
+
+namespace SERVO {
+ CBonder::CBonder()
+ {
+
+ }
+
+ CBonder::~CBonder()
+ {
+
+ }
+
+ const char* CBonder::getClassName()
+ {
+ static char* pszName = "CBonder";
+ return pszName;
+ }
+
+ void CBonder::init()
+ {
+ CEquipment::init();
+ }
+
+ void CBonder::term()
+ {
+ CEquipment::term();
+ }
+
+ void CBonder::onTimer(UINT nTimerid)
+ {
+ CEquipment::onTimer(nTimerid);
+ }
+
+ void CBonder::serialize(CArchive& ar)
+ {
+ CEquipment::serialize(ar);
+ }
+}
diff --git a/SourceCode/Bond/Servo/CBonder.h b/SourceCode/Bond/Servo/CBonder.h
new file mode 100644
index 0000000..3cf9c78
--- /dev/null
+++ b/SourceCode/Bond/Servo/CBonder.h
@@ -0,0 +1,20 @@
+#pragma once
+#include "CEquipment.h"
+
+namespace SERVO {
+ class CBonder :
+ public CEquipment
+ {
+ public:
+ CBonder();
+ ~CBonder();
+
+ public:
+ virtual const char* getClassName();
+ virtual void init();
+ virtual void term();
+ virtual void onTimer(UINT nTimerid);
+ virtual void serialize(CArchive& ar);
+ };
+}
+
diff --git a/SourceCode/Bond/Servo/CCLinkPerformance/CCLinkIEControl.cpp b/SourceCode/Bond/Servo/CCLinkPerformance/CCLinkIEControl.cpp
index bc85cc4..582cc6b 100644
--- a/SourceCode/Bond/Servo/CCLinkPerformance/CCLinkIEControl.cpp
+++ b/SourceCode/Bond/Servo/CCLinkPerformance/CCLinkIEControl.cpp
@@ -40,7 +40,7 @@
return ERROR_CODE_INVALID_DATA;
}
- // 瑙ｆ瀽鍚勪綅鐘舵��
+ // 解析各位状态
const short nBuffer = vecLedBuffer[0];
outLedStatus.bExtPw = (nBuffer & (1 << 15)) != 0;
outLedStatus.bRd = (nBuffer & (1 << 6)) != 0;
@@ -56,26 +56,48 @@
CCLinkIEControlMode CCCLinkIEControl::ConvertToCCLinkIEControlMode(const short nMode) {
switch (static_cast<CCLinkIEControlMode>(nMode)) {
- case CCLinkIEControlMode::ONLINE: return CCLinkIEControlMode::ONLINE; // 鍦ㄧ嚎
- case CCLinkIEControlMode::OFFLINE: return CCLinkIEControlMode::OFFLINE; // 绂荤嚎
- case CCLinkIEControlMode::INTER_STATION_TEST: return CCLinkIEControlMode::INTER_STATION_TEST; // 绔欓棿娴嬭瘯
- case CCLinkIEControlMode::LINE_TEST: return CCLinkIEControlMode::LINE_TEST; // 绾胯矾娴嬭瘯
- case CCLinkIEControlMode::LOOPBACK_TEST: return CCLinkIEControlMode::LOOPBACK_TEST; // 鑷洖閫佹祴璇�
- case CCLinkIEControlMode::HW_TEST: return CCLinkIEControlMode::HW_TEST; // H/W娴嬭瘯
- case CCLinkIEControlMode::BUS_IF_TEST: return CCLinkIEControlMode::BUS_IF_TEST; // 鎬荤嚎I/F娴嬭瘯
+ case CCLinkIEControlMode::ONLINE: return CCLinkIEControlMode::ONLINE; // 在线
+ case CCLinkIEControlMode::OFFLINE: return CCLinkIEControlMode::OFFLINE; // 离线
+ case CCLinkIEControlMode::INTER_STATION_TEST: return CCLinkIEControlMode::INTER_STATION_TEST; // 站间测试
+ case CCLinkIEControlMode::LINE_TEST: return CCLinkIEControlMode::LINE_TEST; // 线路测试
+ case CCLinkIEControlMode::LOOPBACK_TEST: return CCLinkIEControlMode::LOOPBACK_TEST; // 自回送测试
+ case CCLinkIEControlMode::HW_TEST: return CCLinkIEControlMode::HW_TEST; // H/W测试
+ case CCLinkIEControlMode::BUS_IF_TEST: return CCLinkIEControlMode::BUS_IF_TEST; // 总线I/F测试
default: return CCLinkIEControlMode::UNKNOWN;
}
}
int CCCLinkIEControl::ValidateBoardStatus(const BoardStatus& status) {
if (status.nStationValue < 1 || status.nStationValue > 120) {
- return ERROR_CODE_STATION_OUT_OF_RANGE; // 绔欏彿瓒呭嚭鑼冨洿
+ return ERROR_CODE_STATION_OUT_OF_RANGE; // 站号超出范围
}
if (status.nGroupValue < 0 || status.nGroupValue > 32) {
- return ERROR_CODE_GROUP_OUT_OF_RANGE; // 缁勮秴鍑鸿寖鍥�
+ return ERROR_CODE_GROUP_OUT_OF_RANGE; // 组超出范围
}
if (status.nNetworkValue < 1 || status.nNetworkValue > 239) {
- return ERROR_CODE_NETWORK_OUT_OF_RANGE; // 缃戠粶鍙疯秴鍑鸿寖鍥�
+ return ERROR_CODE_NETWORK_OUT_OF_RANGE; // 网络号超出范围
}
- return 0; // 鏍￠獙閫氳繃
+ return 0; // 校验通过
+}
+
+int CCCLinkIEControl::ReadData2(const StationIdentifier& station, short devType, short devNo, short size, void* pData)
+{
+ // 验证站点参数和数据有效性
+ int nRet = ValidateStationAndSize(station, size);
+ if (nRet != 0) {
+ UpdateLastError(nRet);
+ return nRet;
+ }
+
+ // 确保线程安全的最小锁定范围
+ {
+ std::lock_guard<std::mutex> lock(m_mtx);
+ nRet = mdReceive(m_nPath, CombineStation(station), devType, devNo, &size, pData);
+ }
+
+ if (nRet != 0) {
+ UpdateLastError(nRet);
+ }
+
+ return nRet;
}
\ No newline at end of file
diff --git a/SourceCode/Bond/Servo/CCLinkPerformance/CCLinkIEControl.h b/SourceCode/Bond/Servo/CCLinkPerformance/CCLinkIEControl.h
index a7006fd..3a33626 100644
--- a/SourceCode/Bond/Servo/CCLinkPerformance/CCLinkIEControl.h
+++ b/SourceCode/Bond/Servo/CCLinkPerformance/CCLinkIEControl.h
@@ -4,14 +4,14 @@
#include "PerformanceMelsec.h"
enum class CCLinkIEControlMode : short {
- UNKNOWN = 0x0194, // 鏈煡
- ONLINE = 0x0000, // 鍦ㄧ嚎
- OFFLINE = 0x0002, // 绂荤嚎
- INTER_STATION_TEST = 0x0005, // 绔欓棿娴嬭瘯
- LINE_TEST = 0x0006, // 绾胯矾娴嬭瘯
- LOOPBACK_TEST = 0x0007, // 鑷洖閫佹祴璇�
- HW_TEST = 0x0009, // H/W娴嬭瘯
- BUS_IF_TEST = 0x000E // 鎬荤嚎I/F娴嬭瘯
+ UNKNOWN = 0x0194, // 未知
+ ONLINE = 0x0000, // 在线
+ OFFLINE = 0x0002, // 离线
+ INTER_STATION_TEST = 0x0005, // 站间测试
+ LINE_TEST = 0x0006, // 线路测试
+ LOOPBACK_TEST = 0x0007, // 自回送测试
+ HW_TEST = 0x0009, // H/W测试
+ BUS_IF_TEST = 0x000E // 总线I/F测试
};
class CCCLinkIEControl final : public CPerformanceMelsec {
@@ -20,16 +20,16 @@
~CCCLinkIEControl() override;
struct LedStatus {
- bool bExtPw; // 澶栭儴鐢垫簮鐘舵�� (b15)
- bool bRd; // 鏁版嵁鎺ユ敹鐘舵�� (b6)
- bool bDLnk; // 鏁版嵁閾炬帴鐘舵�� (b5)
- bool bPrm; // 绠＄悊鍔熻兘鐘舵�� (b4)
- bool bErr; // 閿欒鐘舵�� (b3)
- bool bSd; // 鏁版嵁鍙戦�佺姸鎬� (b2)
- bool bMode; // 鍔ㄤ綔妯″紡 (b1)
- bool bRun; // 杩愯鐘舵�� (b0)
+ bool bExtPw; // 外部电源状态 (b15)
+ bool bRd; // 数据接收状态 (b6)
+ bool bDLnk; // 数据链接状态 (b5)
+ bool bPrm; // 管理功能状态 (b4)
+ bool bErr; // 错误状态 (b3)
+ bool bSd; // 数据发送状态 (b2)
+ bool bMode; // 动作模式 (b1)
+ bool bRun; // 运行状态 (b0)
- // 杞崲涓哄瓧绗︿覆锛岀敤浜庤皟璇�
+ // 转换为字符串，用于调试
std::string ToString() const {
std::ostringstream oss;
oss << "CC-Link IE Control Network LED Status: {"
@@ -46,19 +46,21 @@
}
};
- // 璇诲彇鐩爣绔欑偣CPU绫诲瀷
+ // 读取目标站点CPU类型
// short ReadCPUCodeEx(const StationIdentifier& station, short& nCPUCode);
- // 鏉挎ā寮忚幏鍙�/璁剧疆
+ // 板模式获取/设置
int SetBoardModeEx(CCLinkIEControlMode mode);
CCLinkIEControlMode GetBoardModeEx();
- // 鑾峰彇鏉跨姸鎬�
+ // 获取板状态
int GetBoardStatusEx(BoardStatus& status);
- // 璇诲彇LED鐘舵��
+ // 读取LED状态
int ReadLedStatus(LedStatus& outLedStatus);
+ int ReadData2(const StationIdentifier& station, short devType, short devNo, short size, void* pData);
+
private:
static CCLinkIEControlMode ConvertToCCLinkIEControlMode(short nMode);
static int ValidateBoardStatus(const BoardStatus& status);
diff --git a/SourceCode/Bond/Servo/CCLinkPerformance/PerformanceMelsec.cpp b/SourceCode/Bond/Servo/CCLinkPerformance/PerformanceMelsec.cpp
index 1f6deab..8807138 100644
--- a/SourceCode/Bond/Servo/CCLinkPerformance/PerformanceMelsec.cpp
+++ b/SourceCode/Bond/Servo/CCLinkPerformance/PerformanceMelsec.cpp
@@ -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,7 +214,7 @@
return ERROR_CODE_INVALID_PARAM;
}
- // 杩炴帴PLC锛屾樉寮忕被鍨嬭浆鎹互鍖归厤 mdOpen 鐨勭鍚�
+ // 连接PLC，显式类型转换以匹配 mdOpen 的签名
const short nRet = mdOpen(nChannel, nMode, &m_nPath);
if (nRet == 0) {
m_bConnected.store(true);
@@ -227,7 +227,7 @@
return nRet;
}
-// 鏂紑杩炴帴
+// 断开连接
int CPerformanceMelsec::Disconnect() {
std::lock_guard<std::mutex> lock(m_mtx);
@@ -244,7 +244,7 @@
return nRet;
}
-// 鍙紪绋嬫帶鍒跺櫒杞厓浠朵俊鎭〃鐨勫垵濮嬪寲
+// 可编程控制器软元件信息表的初始化
int CPerformanceMelsec::InitializeController() {
std::lock_guard<std::mutex> lock(m_mtx);
@@ -262,14 +262,14 @@
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};
const short nRet = mdBdVerRead(m_nPath, buf);
if (nRet != 0) {
@@ -278,7 +278,7 @@
return nRet;
}
- // 濉厖鐗堟湰淇℃伅鍒扮粨鏋勪綋
+ // 填充版本信息到结构体
version.fixedValue[0] = static_cast<char>(buf[0] & 0xFF);
version.fixedValue[1] = static_cast<char>((buf[0] >> 8) & 0xFF);
@@ -309,16 +309,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 +333,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 +356,9 @@
return nRet;
}
-// 鑾峰彇鏉挎ā寮�
+// 获取板模式
int CPerformanceMelsec::GetBoardMode(short& nMode) {
- // 妫�鏌ユ槸鍚﹀凡缁忚繛鎺�
+ // 检查是否已经连接
if (!m_bConnected.load()) {
UpdateLastError(ERROR_CODE_NOT_CONNECTED);
return ERROR_CODE_NOT_CONNECTED;
@@ -380,7 +380,7 @@
return 0;
}
-// 鏉垮浣�
+// 板复位
int CPerformanceMelsec::BoardReset() {
std::lock_guard<std::mutex> lock(m_mtx);
if (!m_bConnected.load()) {
@@ -397,7 +397,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 +405,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 +420,7 @@
return nRet;
}
-// 鑾峰彇鏉跨姸鎬�
+// 获取板状态
int CPerformanceMelsec::GetBoardStatus(BoardStatus& status) {
std::lock_guard<std::mutex> lock(m_mtx);
if (!m_bConnected) {
@@ -435,25 +435,25 @@
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 nRet = ValidateStationAndSize(station, nSize);
if (nRet != 0) {
UpdateLastError(nRet);
return nRet;
}
- // 鍒濆鍖栬鍙栫紦鍐插尯
+ // 初始化读取缓冲区
vecData.clear();
vecData.resize(nSize);
- // 纭繚绾跨▼瀹夊叏鐨勬渶灏忛攣瀹氳寖鍥�
+ // 确保线程安全的最小锁定范围
{
std::lock_guard<std::mutex> lock(m_mtx);
short* pData = vecData.data();
@@ -466,38 +466,38 @@
}
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;
}
- // 璁＄畻闇�瑕佽鍙栫殑瀛楄妭澶у皬锛堟寜浣嶅榻愪负瀛楄妭鏁帮級
+ // 计算需要读取的字节大小（按位对齐为字节数）
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>((nBitCount + 7) / 8); // 向上取整
+ std::vector<short> vecTempBuffer((nSize + 1) / 2, 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); // 线程安全保护
ConvertShortToUint8(vecTempBuffer, vecData);
}
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,44 +516,44 @@
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 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);
@@ -567,37 +567,37 @@
return nRet;
}
-// 鍐欎綅鏁版嵁
+// 写位数据
int CPerformanceMelsec::WriteBitData(const StationIdentifier& station, const DeviceType enDevType, const short nDevNo, const BitContainer& vecData) {
- // 楠岃瘉绔欑偣鍙傛暟鍜屾暟鎹湁鏁堟��
+ // 验证站点参数和数据有效性
const int nRet = ValidateStationAndData(station, vecData);
if (nRet != 0) {
UpdateLastError(nRet);
return nRet;
}
- // 璁＄畻闇�瑕佸啓鍏ョ殑瀛楄妭鏁帮紙浣嶆暟鎹渶瑕佹寜 8 浣嶅榻愪负瀛楄妭鏁帮級
+ // 计算需要写入的字节数（位数据需要按 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); // 绾跨▼瀹夊叏淇濇姢
+ std::lock_guard<std::mutex> lock(m_mtx); // 线程安全保护
ConvertUint8ToShort(vecData, vecBuffer);
}
return WriteData(station, nDevType, nDevNo, nSize, vecBuffer.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 pData = const_cast<short*>(reinterpret_cast<const short*>(vecData.data()));
@@ -605,30 +605,30 @@
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);
{
- 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);
@@ -645,7 +645,7 @@
std::vector<short> vecBuffer(nActualSize, 0);
{
- std::lock_guard<std::mutex> lock(m_mtx); // 绾跨▼瀹夊叏淇濇姢
+ std::lock_guard<std::mutex> lock(m_mtx); // 线程安全保护
nRet = mdReceiveEx(m_nPath, station.nNetNo, station.nStNo, nDevType, nDevNo, &nActualSize, vecBuffer.data());
}
@@ -653,33 +653,33 @@
UpdateLastError(nRet);
LOG_ERROR(m_strLastError);
} else {
- std::lock_guard<std::mutex> lock(m_mtx); // 绾跨▼瀹夊叏淇濇姢
+ std::lock_guard<std::mutex> lock(m_mtx); // 线程安全保护
ConvertShortToChar(vecBuffer, vecData);
}
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);
{
- 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 +688,7 @@
return nRet;
}
-// 鎵╁睍杞厓浠堕殢鏈鸿鍙�
+// 扩展软元件随机读取
long CPerformanceMelsec::ReadRandomDataEx(const StationIdentifier& station, const std::vector<SoftElement>& vecSoftElements, std::vector<char>& vecData) {
if (vecSoftElements.empty()) {
UpdateLastError(ERROR_INVALID_PARAMETER);
@@ -696,48 +696,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 +745,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 +773,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 +790,36 @@
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); // 绾跨▼瀹夊叏淇濇姢
+ 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 +832,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,14 +840,14 @@
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());
}
@@ -855,14 +855,14 @@
UpdateLastError(nRet);
LOG_ERROR(m_strLastError);
} else {
- std::lock_guard<std::mutex> lock(m_mtx); // 绾跨▼瀹夊叏淇濇姢
+ 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 +870,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 +889,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 +913,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 +937,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 +957,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 +977,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 +1007,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 +1021,12 @@
return ERROR_CODE_INVALID_PARAM;
}
- // 绗� 0 涓厓绱犲瓨鍌ㄦ暟閲忥紝鏈�澶ф敮鎸� 64 涓簨浠�
+ // 第 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 +1039,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 {
- // 濡傛灉鏈壘鍒帮紝澶勭悊鐗规畩鑼冨洿
+ // 如果未找到，处理特殊范围
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,30 +1151,30 @@
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) {
@@ -1191,132 +1192,132 @@
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) {
- // 鏂囦欢瀵勫瓨鍣ㄧ殑鍧楀彿鍔犲亸绉�
+ // 文件寄存器的块号加偏移
nDevType += 0;
} else if (enDevType == DeviceType::SPG) {
- // 璧峰 I/O No. 梅 16 鐨勫��
+ // 起始 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]); // 浣庡瓧鑺�
+ 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]) << 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]); // 浣庡瓧鑺�
+ 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] << 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 +1325,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));
diff --git a/SourceCode/Bond/Servo/CCLinkPerformance/PerformanceMelsec.h b/SourceCode/Bond/Servo/CCLinkPerformance/PerformanceMelsec.h
index 903ca41..31ba329 100644
--- a/SourceCode/Bond/Servo/CCLinkPerformance/PerformanceMelsec.h
+++ b/SourceCode/Bond/Servo/CCLinkPerformance/PerformanceMelsec.h
@@ -10,151 +10,151 @@
#include <sstream>
#include <unordered_map>
-// 杩炴帴鍙傛暟
-#define PLC_MAX_RETRY 3 // 鏈�澶ч噸璇曟鏁帮細鍦ㄤ笌PLC閫氫俊鏃讹紝濡傛灉鍙戠敓閫氫俊閿欒锛屽皢鏈�澶氶噸璇�3娆�
-#define PLC_TIMEOUT 500 // 瓒呮椂鏃堕棿锛堟绉掞級锛氭瘡娆￠�氫俊鎿嶄綔鐨勮秴鏃剁瓑寰呮椂闂翠负500姣
+// 连接参数
+#define PLC_MAX_RETRY 3 // 最大重试次数：在与PLC通信时，如果发生通信错误，将最多重试3次
+#define PLC_TIMEOUT 500 // 超时时间（毫秒）：每次通信操作的超时等待时间为500毫秒
/*
- * 缃戠粶閫氶亾锛氭寚瀹氶�氫俊鎵�浣跨敤鐨勭綉缁滈�氶亾鍙凤紝閫氬父鍦ㄥ閫氶亾閫氫俊涓缃�
- * 51 鍒� 54 鏄� MELSECNET/H 鐨� 1-4 閫氶亾
- * 81 鍒� 84 鏄� CC-Link 鐨� 1-4 閫氶亾
- * 151 鍒� 154 鏄� CC-Link IE 鎺у埗鍣ㄧ綉缁滅殑 1-4 閫氶亾
- * 181 鍒� 184 鏄� CC-Link IE 鐜板満缃戠粶鐨� 1-4 閫氶亾
- * 281 鍒� 284 鏄� CC-Link IE TSN 缃戠粶鐨� 1-4 閫氶亾
+ * 网络通道：指定通信所使用的网络通道号，通常在多通道通信中设置
+ * 51 到 54 是 MELSECNET/H 的 1-4 通道
+ * 81 到 84 是 CC-Link 的 1-4 通道
+ * 151 到 154 是 CC-Link IE 控制器网络的 1-4 通道
+ * 181 到 184 是 CC-Link IE 现场网络的 1-4 通道
+ * 281 到 284 是 CC-Link IE TSN 网络的 1-4 通道
**/
-#define MELSECNET_CHANNEL(x) (50 + (x)) // x 鑼冨洿锛�1~4
-#define CC_LINK_CHANNEL(x) (80 + (x)) // x 鑼冨洿锛�1~4
-#define CC_LINK_IE_CONTROL_CHANNEL(x) (150 + (x)) // x 鑼冨洿锛�1~4
-#define CC_LINK_IE_FIELD_CHANNEL(x) (180 + (x)) // x 鑼冨洿锛�1~4
-#define CC_LINK_IE_TSN_CHANNEL(x) (280 + (x)) // x 鑼冨洿锛�1~4
+#define MELSECNET_CHANNEL(x) (50 + (x)) // x 范围：1~4
+#define CC_LINK_CHANNEL(x) (80 + (x)) // x 范围：1~4
+#define CC_LINK_IE_CONTROL_CHANNEL(x) (150 + (x)) // x 范围：1~4
+#define CC_LINK_IE_FIELD_CHANNEL(x) (180 + (x)) // x 范围：1~4
+#define CC_LINK_IE_TSN_CHANNEL(x) (280 + (x)) // x 范围：1~4
-// 鑷畾涔夐敊璇爜
-#define ERROR_CODE_UNKNOWN 0x00010000 // 鏈煡
-#define ERROR_CODE_NOT_CONNECTED 0x00020000 // 鏈繛鎺�
-#define ERROR_CODE_INVALID_PARAM 0x00030000 // 鍙傛暟鏃犳晥
-#define ERROR_CODE_INVALID_DATA 0x00040000 // 鏁版嵁鏃犳晥
-#define ERROR_CODE_STATION_OUT_OF_RANGE 0x00050000 // 绔欏彿瓒呭嚭鑼冨洿
-#define ERROR_CODE_GROUP_OUT_OF_RANGE 0x00060000 // 缁勫彿瓒呭嚭鑼冨洿
-#define ERROR_CODE_NETWORK_OUT_OF_RANGE 0x00070000 // 缃戠粶鍙疯秴鍑鸿寖鍥�
+// 自定义错误码
+#define ERROR_CODE_UNKNOWN 0x00010000 // 未知
+#define ERROR_CODE_NOT_CONNECTED 0x00020000 // 未连接
+#define ERROR_CODE_INVALID_PARAM 0x00030000 // 参数无效
+#define ERROR_CODE_INVALID_DATA 0x00040000 // 数据无效
+#define ERROR_CODE_STATION_OUT_OF_RANGE 0x00050000 // 站号超出范围
+#define ERROR_CODE_GROUP_OUT_OF_RANGE 0x00060000 // 组号超出范围
+#define ERROR_CODE_NETWORK_OUT_OF_RANGE 0x00070000 // 网络号超出范围
-// 鏉垮潡绫诲瀷
+// 板块类型
enum class BoardType {
- UNKNOWN = -1, // 鏈煡绫诲瀷
+ UNKNOWN = -1, // 未知类型
MELSECNET_H = MELSECNET_CHANNEL(1), // MELSECNET/H
CC_LINK_VER_2 = CC_LINK_CHANNEL(1), // CC-Link Ver. 2
- CC_LINK_IE_CONTROL = CC_LINK_IE_CONTROL_CHANNEL(1), // CC-Link IE 鎺у埗缃戠粶
- CC_LINK_IE_FIELD = CC_LINK_IE_FIELD_CHANNEL(1), // CC-Link IE 鐜板満缃戠粶
+ CC_LINK_IE_CONTROL = CC_LINK_IE_CONTROL_CHANNEL(1), // CC-Link IE 控制网络
+ CC_LINK_IE_FIELD = CC_LINK_IE_FIELD_CHANNEL(1), // CC-Link IE 现场网络
CC_LINK_IE_TSN = CC_LINK_IE_TSN_CHANNEL(1) // CC-Link IE TSN
};
-// 杞厓浠剁被鍨嬫灇涓�
+// 软元件类型枚举
enum class DeviceType {
/*
- * ER銆丩X銆丩Y銆丩B銆丩W銆丩SB銆丩SW鍜孲PG杞厓浠堕兘鏄寖鍥村瀷
- * ER锛欴evER0锝�256
- * LX锛欴evLX1锝�255锛孌evLX(x) (DevX*1000+(x))
- * LY锛欴evLY1锝�255锛孌evLY(x) (DevY*1000+(x))
- * LB锛欴evLB1锝�255锛孌evLB(x) (DevB*1000+(x))
- * LW锛欴evLW1锝�255锛孌evLW(x) (DevW*1000+(x))
- * LSB锛欴evLSB1锝�255锛孌evLSB(x) (DevQSB*1000+(x))
- * LSW锛欴evLSW1锝�255锛孌evLSW(x) (DevQSW*1000+(x))
- * SPG锛欴evSPG0锝�255锛孌evSPG(x) (29*1000+(x))
- * 鎵╁睍鏂囦欢瀵勫瓨鍣ㄤ唬鐮佹寚瀹�(10杩涘埗鏁�)鐨勫悗3浣嶆暟鍙婅蒋鍏冧欢鍚嶆寚瀹氱殑鏁板�间腑锛屽簲鎸囧畾鍧桸o.(0锝�256)
- * 閾炬帴鐩存帴杞厓浠朵唬鐮佹寚瀹�(10杩涘埗鏁�)鐨勫悗3浣嶆暟鍙婅蒋鍏冧欢鍚嶆寚瀹氱殑鏁板�间腑锛屽簲鎸囧畾缃戠粶No.(1锝�255)
- * 鏅鸿兘鍔熻兘妯″潡杞厓浠朵唬鐮佹寚瀹�(10杩涘埗鏁�)鐨勫悗3浣嶆暟鍙婅蒋鍏冧欢鍚嶆寚瀹氱殑鏁板�间腑锛屽簲鎸囧畾(璧峰I/ONo.梅16)鐨勫��
- * 鎵╁睍鏂囦欢瀵勫瓨鍣ㄥ拰閾炬帴鐩存帴杞厓浠跺湪闅忔満璇诲彇(mdRandR銆乵dRandREx)鍑芥暟涓紝鍗充娇鎸囧畾瀹為檯涓嶅瓨鍦ㄧ殑杞厓浠朵篃鏈夊彲鑳芥甯哥粨鏉�
- * MAIL鍜孧AILMC鍦⊿END鍔熻兘鍙奟ECV鍔熻兘涓紝涓庤蒋鍏冧欢璁块棶涓�鏍凤紝鎸囧畾鍚勫姛鑳藉搴旂殑杞厓浠剁被鍨嬶紝杩涜鏁版嵁鐨勫彂閫�(mdSend銆乵dSendEx)鎴栨暟鎹殑璇诲彇(mdReceive銆乵dReceiveEx)
+ * ER、LX、LY、LB、LW、LSB、LSW和SPG软元件都是范围型
+ * ER：DevER0～256
+ * LX：DevLX1～255，DevLX(x) (DevX*1000+(x))
+ * LY：DevLY1～255，DevLY(x) (DevY*1000+(x))
+ * LB：DevLB1～255，DevLB(x) (DevB*1000+(x))
+ * LW：DevLW1～255，DevLW(x) (DevW*1000+(x))
+ * LSB：DevLSB1～255，DevLSB(x) (DevQSB*1000+(x))
+ * LSW：DevLSW1～255，DevLSW(x) (DevQSW*1000+(x))
+ * SPG：DevSPG0～255，DevSPG(x) (29*1000+(x))
+ * 扩展文件寄存器代码指定(10进制数)的后3位数及软元件名指定的数值中，应指定块No.(0～256)
+ * 链接直接软元件代码指定(10进制数)的后3位数及软元件名指定的数值中，应指定网络No.(1～255)
+ * 智能功能模块软元件代码指定(10进制数)的后3位数及软元件名指定的数值中，应指定(起始I/ONo.÷16)的值
+ * 扩展文件寄存器和链接直接软元件在随机读取(mdRandR、mdRandREx)函数中，即使指定实际不存在的软元件也有可能正常结束
+ * MAIL和MAILMC在SEND功能及RECV功能中，与软元件访问一样，指定各功能对应的软元件类型，进行数据的发送(mdSend、mdSendEx)或数据的读取(mdReceive、mdReceiveEx)
**/
- X = 0x0001, // 杈撳叆 (浣�)
- Y = 0x0002, // 杈撳嚭 (浣�)
- L = 0x0003, // 閿佸瓨缁х數鍣� (浣�)
- M = 0x0004, // 鍐呴儴缁х數鍣� (浣�)
- SM = 0x0005, // 鐗规畩缁х數鍣� (浣�)
- F = 0x0006, // 鎶ヨ鍣� (浣�)
- TT = 0x0007, // 瀹氭椂鍣� (瑙︾偣) (浣�)
- TC = 0x0008, // 璁℃暟鍣� (绾垮湀) (浣�)
- CT = 0x0009, // 璁℃暟鍣� (瑙︾偣) (浣�)
- CC = 0x000A, // 璁℃暟鍣� (绾垮湀) (瀛�)
- TN = 0x000B, // 瀹氭椂鍣� (褰撳墠鍊�) (瀛�)
- CN = 0x000C, // 璁℃暟鍣� (褰撳墠鍊�) (瀛�)
- D = 0x000D, // 鏁版嵁瀵勫瓨鍣� (瀛�)
- SD = 0x000E, // 鐗规畩瀵勫瓨鍣� (瀛�)
- TM = 0x000F, // 瀹氭椂鍣� (璁剧疆鍊间富) (瀛�)
- TS = 0x0010, // 瀹氭椂鍣� (璁剧疆鍊间富1) (瀛�)
- TS2 = 0x3E82, // 瀹氭椂鍣� (璁剧疆鍊间富2) (瀛�)
- TS3 = 0x3E83, // 瀹氭椂鍣� (璁剧疆鍊间富3) (瀛�)
- CM = 0x0011, // 璁℃暟鍣� (璁剧疆鍊间富) (瀛�)
- CS = 0x0012, // 璁℃暟鍣� (璁剧疆鍊间富1) (瀛�)
- CS2 = 0x4652, // 璁℃暟鍣� (璁剧疆鍊间富2) (瀛�)
- CS3 = 0x4653, // 璁℃暟鍣� (璁剧疆鍊间富3) (瀛�)
- A = 0x0013, // 绱姞鍣� (瀛�)
- Z = 0x0014, // 鍙樺潃瀵勫瓨鍣� (瀛�)
- V = 0x0015, // 鍙樺潃瀵勫瓨鍣� (瀛�)
- R = 0x0016, // 鏂囦欢瀵勫瓨鍣� (鍧楀垏鎹㈡柟寮�) (瀛�)
- ER = 0x55F0, // 鎵╁睍鏂囦欢瀵勫瓨鍣� (鍧楀垏鎹㈡柟寮�) (0x55F0锝�0x56F0) (瀛�) (鍦ㄩ殢鏈鸿鍙�(mdRandR銆乵dRandREx)鍑芥暟涓紝鍗充娇鎸囧畾瀹為檯涓嶅瓨鍦ㄧ殑杞厓浠朵篃鏈夊彲鑳芥甯哥粨鏉熴��(璇诲彇鏁版嵁涓嶆纭��))
- ZR = 0x00DC, // 鏂囦欢瀵勫瓨鍣� (杩炲彿璁块棶鏂瑰紡) (瀛�)
- B = 0x0017, // 閾炬帴缁х數鍣� (浣�)
- W = 0x0018, // 閾炬帴瀵勫瓨鍣� (瀛�)
- QSB = 0x0019, // 閾炬帴鐗规畩缁х數鍣� (浣�)
- STT = 0x001A, // 绱瀹氭椂鍣� (瑙︾偣) (浣�)
- STC = 0x001B, // 绱瀹氭椂鍣� (绾垮湀) (浣�)
- QSW = 0x001C, // 閾炬帴鐗规畩瀵勫瓨鍣� (瀛�)
- QV = 0x001E, // 鍙樺潃缁х數鍣� (浣�)
- MRB = 0x0021, // 闅忔満璁块棶缂撳啿 (瀛�)
- STN = 0x0023, // 绱瀹氭椂鍣� (褰撳墠鍊�) (瀛�)
- LZ = 0x0026, // 瓒呴暱鍙樺潃瀵勫瓨鍣� (鍙屽瓧)
- RD = 0x0027, // 鍒锋柊鏁版嵁瀵勫瓨鍣� (瀛�)
- LTT = 0x0029, // 瓒呴暱瀹氭椂鍣� (瑙︾偣) (浣�)
- LTC = 0x002A, // 瓒呴暱瀹氭椂鍣� (绾垮湀) (浣�)
- LTN = 0x002B, // 瓒呴暱瀹氭椂鍣� (褰撳墠鍊�) (鍙屽瓧)
- LCT = 0x002C, // 瓒呴暱璁℃暟鍣� (瑙︾偣) (浣�)
- LCC = 0x002D, // 瓒呴暱璁℃暟鍣� (绾垮湀) (浣�)
- LCN = 0x002E, // 瓒呴暱璁℃暟鍣� (褰撳墠鍊�) (鍙屽瓧)
- LSTT = 0x002F, // 瓒呴暱绱瀹氭椂鍣� (瑙︾偣) (浣�)
- LSTC = 0x0030, // 瓒呴暱绱瀹氭椂鍣� (绾垮湀) (浣�)
- LSTN = 0x0031, // 瓒呴暱绱瀹氭椂鍣� (褰撳墠鍊�) (鍙屽瓧)
- SPB = 0x0032, // 缂撳啿瀛樺偍鍣� (瀛�)
- MAIL = 0x0065, // 鐗规畩杞厓浠剁被鍨嬶細閭欢绫诲瀷 (10杩涘埗 101)
- MAILMC = 0x0066, // 鐗规畩杞厓浠剁被鍨嬶細鏃犵‘璁ら偖浠� (10杩涘埗 102)
- LX = 0x03E9, // 閾炬帴鐩存帴杞厓浠� (閾炬帴杈撳叆) (0x03E9锝�0x04E7) (浣�)
- LY = 0x07D1, // 閾炬帴鐩存帴杞厓浠� (閾炬帴杈撳嚭) (0x07D1锝�0x08CF) (浣�)
- LB = 0x59D9, // 閾炬帴鐩存帴杞厓浠� (閾炬帴缁х數鍣�) (0x59D9锝�0x5AD7) (浣�)
- LW = 0x5DC1, // 閾炬帴鐩存帴杞厓浠� (閾炬帴瀵勫瓨鍣�) (0x5DC1锝�0x5EBF) (瀛�)
- LSB = 0x61A9, // 閾炬帴鐩存帴杞厓浠� (閾炬帴鐗规畩缁х數鍣�) (0x61A9锝�0x62A7) (浣�)
- LSW = 0x6D61, // 閾炬帴鐩存帴杞厓浠� (閾炬帴鐗规畩瀵勫瓨鍣�) (0x6D61锝�0x6E5F) (瀛�)
- SPG = 0x7148, // 鏅鸿兘鍔熻兘妯″潡杞厓浠� (0x7148锝�0x7247) (瀛�)
+ X = 0x0001, // 输入 (位)
+ Y = 0x0002, // 输出 (位)
+ L = 0x0003, // 锁存继电器 (位)
+ M = 0x0004, // 内部继电器 (位)
+ SM = 0x0005, // 特殊继电器 (位)
+ F = 0x0006, // 报警器 (位)
+ TT = 0x0007, // 定时器 (触点) (位)
+ TC = 0x0008, // 计数器 (线圈) (位)
+ CT = 0x0009, // 计数器 (触点) (位)
+ CC = 0x000A, // 计数器 (线圈) (字)
+ TN = 0x000B, // 定时器 (当前值) (字)
+ CN = 0x000C, // 计数器 (当前值) (字)
+ D = 0x000D, // 数据寄存器 (字)
+ SD = 0x000E, // 特殊寄存器 (字)
+ TM = 0x000F, // 定时器 (设置值主) (字)
+ TS = 0x0010, // 定时器 (设置值主1) (字)
+ TS2 = 0x3E82, // 定时器 (设置值主2) (字)
+ TS3 = 0x3E83, // 定时器 (设置值主3) (字)
+ CM = 0x0011, // 计数器 (设置值主) (字)
+ CS = 0x0012, // 计数器 (设置值主1) (字)
+ CS2 = 0x4652, // 计数器 (设置值主2) (字)
+ CS3 = 0x4653, // 计数器 (设置值主3) (字)
+ A = 0x0013, // 累加器 (字)
+ Z = 0x0014, // 变址寄存器 (字)
+ V = 0x0015, // 变址寄存器 (字)
+ R = 0x0016, // 文件寄存器 (块切换方式) (字)
+ ER = 0x55F0, // 扩展文件寄存器 (块切换方式) (0x55F0～0x56F0) (字) (在随机读取(mdRandR、mdRandREx)函数中，即使指定实际不存在的软元件也有可能正常结束。(读取数据不正确。))
+ ZR = 0x00DC, // 文件寄存器 (连号访问方式) (字)
+ B = 0x0017, // 链接继电器 (位)
+ W = 0x0018, // 链接寄存器 (字)
+ QSB = 0x0019, // 链接特殊继电器 (位)
+ STT = 0x001A, // 累计定时器 (触点) (位)
+ STC = 0x001B, // 累计定时器 (线圈) (位)
+ QSW = 0x001C, // 链接特殊寄存器 (字)
+ QV = 0x001E, // 变址继电器 (位)
+ MRB = 0x0021, // 随机访问缓冲 (字)
+ STN = 0x0023, // 累计定时器 (当前值) (字)
+ LZ = 0x0026, // 超长变址寄存器 (双字)
+ RD = 0x0027, // 刷新数据寄存器 (字)
+ LTT = 0x0029, // 超长定时器 (触点) (位)
+ LTC = 0x002A, // 超长定时器 (线圈) (位)
+ LTN = 0x002B, // 超长定时器 (当前值) (双字)
+ LCT = 0x002C, // 超长计数器 (触点) (位)
+ LCC = 0x002D, // 超长计数器 (线圈) (位)
+ LCN = 0x002E, // 超长计数器 (当前值) (双字)
+ LSTT = 0x002F, // 超长累计定时器 (触点) (位)
+ LSTC = 0x0030, // 超长累计定时器 (线圈) (位)
+ LSTN = 0x0031, // 超长累计定时器 (当前值) (双字)
+ SPB = 0x0032, // 缓冲存储器 (字)
+ MAIL = 0x0065, // 特殊软元件类型：邮件类型 (10进制 101)
+ MAILMC = 0x0066, // 特殊软元件类型：无确认邮件 (10进制 102)
+ LX = 0x03E9, // 链接直接软元件 (链接输入) (0x03E9～0x04E7) (位)
+ LY = 0x07D1, // 链接直接软元件 (链接输出) (0x07D1～0x08CF) (位)
+ LB = 0x59D9, // 链接直接软元件 (链接继电器) (0x59D9～0x5AD7) (位)
+ LW = 0x5DC1, // 链接直接软元件 (链接寄存器) (0x5DC1～0x5EBF) (字)
+ LSB = 0x61A9, // 链接直接软元件 (链接特殊继电器) (0x61A9～0x62A7) (位)
+ LSW = 0x6D61, // 链接直接软元件 (链接特殊寄存器) (0x6D61～0x6E5F) (字)
+ SPG = 0x7148, // 智能功能模块软元件 (0x7148～0x7247) (字)
};
-// 鏁版嵁绫诲瀷
+// 数据类型
enum class DataType {
- BIT = 1, // 浣� (1浣�)
- WORD = 2, // 瀛� (16浣�)
- DWORD =4 // 鍙屽瓧 (32浣�)
+ BIT = 1, // 位 (1位)
+ WORD = 2, // 字 (16位)
+ DWORD =4 // 双字 (32位)
};
-// 鎺у埗浠ｇ爜
+// 控制代码
enum class ControlCode {
- RUN = 0, // 杩滅▼ RUN
- STOP = 1, // 杩滅▼ STOP
- PAUSE = 2 // 杩滅▼ PAUSE
+ RUN = 0, // 远程 RUN
+ STOP = 1, // 远程 STOP
+ PAUSE = 2 // 远程 PAUSE
};
-// 鐗堟湰淇℃伅
+// 版本信息
struct BoardVersion {
- char fixedValue[2]; // 鍥哄畾鍊�
- char checksum[2]; // 鏍￠獙鍜�
- char swVersion[2]; // 杞欢鐗堟湰
- char date[6]; // 鏃ユ湡 (鏍煎紡 YYMMDD)
- uint32_t reserved; // 淇濈暀鍖哄煙 (4 瀛楄妭)
- char swModel[16]; // 杞欢鍨嬪彿
- char hwModel[16]; // 纭欢鍨嬪彿
- char twoPortMemory[2]; // 涓ょ鍙ｅ瓨鍌ㄥ櫒鍗犵敤瀹归噺
- char twoPortAttribute[2]; // 涓ょ鍙ｅ睘鎬�
- char availableBias[2]; // 鍙娇鐢ㄥ亸缃�
- char moduleType[10]; // 鏈哄瀷绫诲瀷
+ char fixedValue[2]; // 固定值
+ char checksum[2]; // 校验和
+ char swVersion[2]; // 软件版本
+ char date[6]; // 日期 (格式 YYMMDD)
+ uint32_t reserved; // 保留区域 (4 字节)
+ char swModel[16]; // 软件型号
+ char hwModel[16]; // 硬件型号
+ char twoPortMemory[2]; // 两端口存储器占用容量
+ char twoPortAttribute[2]; // 两端口属性
+ char availableBias[2]; // 可使用偏置
+ char moduleType[10]; // 机型类型
- // 杈撳嚭缁撴瀯浣撳唴瀹逛负瀛楃涓� (渚夸簬璋冭瘯)
+ // 输出结构体内容为字符串 (便于调试)
std::string toString() const {
std::ostringstream oss;
oss << "Fixed Value: " << fixedValue[0] << fixedValue[1] << "\n"
@@ -172,18 +172,18 @@
}
};
-// 绔欑偣鏍囪瘑绗︼紝榛樿浣跨敤鏈珯
+// 站点标识符，默认使用本站
struct StationIdentifier {
/*
* [Network No.]
- * 0 琛ㄧず鏈珯
- * 1~239 琛ㄧず鏅�氱綉缁滃彿
+ * 0 表示本站
+ * 1~239 表示普通网络号
**/
/*
* [Station No.]
- * MELSECNET/H锛�1~64 琛ㄧず鍏朵粬绔欑偣锛�255 琛ㄧず鏈珯
- * CC-Link 绯诲垪缃戠粶鐨勮寖鍥寸被浼硷紝鍖哄埆鍦ㄤ簬绔欏彿鐨勫彇鍊艰寖鍥�
+ * MELSECNET/H：1~64 表示其他站点，255 表示本站
+ * CC-Link 系列网络的范围类似，区别在于站号的取值范围
* MELSECNET/H : 1~64(Other stations),255(Own station)
* CC-Link : 0~63(Other stations),255(Own station)
* CC-Link IE Controller : 1~120(Other stations),255(Own station)
@@ -192,35 +192,41 @@
**/
/*
- * 楂� 8 浣嶏紙缃戠粶鍙凤級锛� 鎸囧畾璁惧鎵�灞炵殑缃戠粶
- * 浣� 8 浣嶏紙绔欑偣鍙凤級锛� 鎸囧畾璁惧鍦ㄧ綉缁滀腑鐨勭紪鍙�
- * 鐢ㄤ竴涓弬鏁颁紶閫掕澶囩殑缃戠粶鍙峰拰绔欑偣鍙锋椂: nSt = station.nStNo | ((station.nNetNo << 8) & 0xFF00);
+ * 高 8 位（网络号）： 指定设备所属的网络
+ * 低 8 位（站点号）： 指定设备在网络中的编号
+ * 用一个参数传递设备的网络号和站点号时: nSt = station.nStNo | ((station.nNetNo << 8) & 0xFF00);
**/
- short nNetNo = 0; // 缃戠粶缂栧彿锛歅LC鎵�杩炴帴鐨勭綉缁滅紪鍙凤紝0琛ㄧず榛樿缃戠粶
- short nStNo = 255; // 绔欑偣缂栧彿锛氭寚瀹氫笌PLC杩炴帴鐨勭珯鐐圭紪鍙凤紝255閫氬父琛ㄧず骞挎挱鎴栨墍鏈夌珯鐐�
+ short nNetNo = 0; // 网络编号：PLC所连接的网络编号，0表示默认网络
+ short nStNo = 255; // 站点编号：指定与PLC连接的站点编号，255通常表示广播或所有站点
- // 鑷畾涔夋瀯閫犲嚱鏁帮紝瑕嗙洊榛樿鍊�
+ StationIdentifier()
+ {
+ nNetNo = 0;
+ nStNo = 255;
+ }
+
+ // 自定义构造函数，覆盖默认值
explicit StationIdentifier(const short net, const short st) : nNetNo(net), nStNo(st) {}
- // 灏嗏�滅綉缁滃彿鈥濆拰鈥滅珯鐐瑰彿鈥濈粍鍚堟垚涓�涓渶缁堢紪鐮�
+ // 将“网络号”和“站点号”组合成一个最终编码
short StationIdentifier::toNetworkStationCode() const {
return static_cast<short>(nStNo | ((nNetNo << 8) & 0xFF00));
}
- // 閲嶈浇 < 杩愮畻绗︼紙鐢ㄤ簬鎺掑簭鎴栨瘮杈冿紝閫氬父鐢ㄤ簬 map 鎴� set 涓綔涓� key锛�
+ // 重载 < 运算符（用于排序或比较，通常用于 map 或 set 中作为 key）
bool operator<(const StationIdentifier& other) const {
return std::tie(nNetNo, nStNo) <
std::tie(other.nNetNo, other.nStNo);
}
- // 閲嶈浇 == 杩愮畻绗︼紙鐢ㄤ簬鐩哥瓑姣旇緝锛�
+ // 重载 == 运算符（用于相等比较）
bool operator==(const StationIdentifier& other) const {
return std::tie(nNetNo, nStNo) ==
std::tie(other.nNetNo, other.nStNo);
}
- // 閲嶈浇 = 杩愮畻绗︼紙鐢ㄤ簬璧嬪�硷級
+ // 重载 = 运算符（用于赋值）
StationIdentifier& operator=(const StationIdentifier& other) {
if (this != &other) {
nNetNo = other.nNetNo;
@@ -230,16 +236,16 @@
}
};
-// 鏉跨姸鎬�
+// 板状态
struct BoardStatus {
- short nStationValue = 0; // 绔欏彿鐨勮澶囧�� (buf[0])
- short nGroupValue = 0; // 缁� No. 鐨勮澶囧�� (buf[1])
- short nNetworkValue = 0; // 缃戠粶 No. 鐨勮澶囧�� (buf[2])
- short nReserved1 = 0; // 淇濈暀瀛楁 (buf[3])
- short nReserved2 = 0; // 淇濈暀瀛楁 (buf[4])
- short nReserved3 = 0; // 淇濈暀瀛楁 (buf[5])
+ short nStationValue = 0; // 站号的设备值 (buf[0])
+ short nGroupValue = 0; // 组 No. 的设备值 (buf[1])
+ short nNetworkValue = 0; // 网络 No. 的设备值 (buf[2])
+ short nReserved1 = 0; // 保留字段 (buf[3])
+ short nReserved2 = 0; // 保留字段 (buf[4])
+ short nReserved3 = 0; // 保留字段 (buf[5])
- // 灏嗘暟缁勬槧灏勫埌缁撴瀯浣�
+ // 将数组映射到结构体
static BoardStatus fromBuffer(const short buf[6]) {
return {
buf[0],
@@ -251,7 +257,7 @@
};
}
- // 灏嗙粨鏋勪綋鍐呭鏄犲皠鍒版暟缁�
+ // 将结构体内容映射到数组
void toBuffer(short buf[6]) const {
buf[0] = nStationValue;
buf[1] = nGroupValue;
@@ -261,7 +267,7 @@
buf[5] = nReserved3;
}
- // 璋冭瘯杈撳嚭
+ // 调试输出
std::string toString() const {
std::ostringstream oss;
oss << "Station Value: " << nStationValue << "\n"
@@ -274,12 +280,12 @@
}
};
-// 浜嬩欢璇︽儏
+// 事件详情
struct EventDetails {
- short nEventNo; // 鍙戠敓鐨勪簨浠跺彿
- std::array<short, 4> details; // 瀛樺偍浜嬩欢璇︽儏淇℃伅
+ short nEventNo; // 发生的事件号
+ std::array<short, 4> details; // 存储事件详情信息
- // 瑙ｆ瀽浜嬩欢璇︽儏锛岃繑鍥炴牸寮忓寲瀛楃涓�
+ // 解析事件详情，返回格式化字符串
std::string toString() const {
std::ostringstream oss;
oss << "Details[0]: " << details[0] << ", "
@@ -290,33 +296,33 @@
}
};
-// SoftElement 缁撴瀯浣撳畾涔�
+// SoftElement 结构体定义
struct SoftElement {
- short nType; // 杞厓浠剁被鍨�
- short nElementCount; // 鐐规暟
- long nStartNo; // 璧峰杞厓浠剁紪鍙�
+ short nType; // 软元件类型
+ short nElementCount; // 点数
+ long nStartNo; // 起始软元件编号
};
-// 閿欒淇℃伅
+// 错误信息
struct ErrorInfo {
- int nErrorCode = 0; // 閿欒鐮�
- std::string strErrorMessageCn; // 涓枃鎻忚堪
- std::string strErrorMessageEn; // 鑻辨枃鎻忚堪
+ int nErrorCode = 0; // 错误码
+ std::string strErrorMessageCn; // 中文描述
+ std::string strErrorMessageEn; // 英文描述
- // 灏嗙粨鏋勪綋搴忓垪鍖栦负瀛楃涓�
+ // 将结构体序列化为字符串
std::string toString() const {
std::ostringstream oss;
oss << nErrorCode << "|" << strErrorMessageCn << "|" << strErrorMessageEn;
return oss.str();
}
- // 浠庡瓧绗︿覆鍙嶅簭鍒楀寲涓虹粨鏋勪綋
+ // 从字符串反序列化为结构体
static ErrorInfo fromString(const std::string& line) {
ErrorInfo info;
std::istringstream iss(line);
std::string token;
- // 浣跨敤鍒嗛殧绗� "|" 瑙ｆ瀽瀛楃涓�
+ // 使用分隔符 "|" 解析字符串
std::getline(iss, token, '|');
info.nErrorCode = std::stoi(token);
@@ -330,47 +336,47 @@
}
};
-using BitContainer = std::vector<uint8_t>; // 姣忎釜鍏冪礌瀛樺偍 8 涓綅
-using WordContainer = std::vector<uint16_t>; // 姣忎釜鍏冪礌瀛樺偍 16 浣�
-using DWordContainer = std::vector<uint32_t>; // 姣忎釜鍏冪礌瀛樺偍 32 浣�
+using BitContainer = std::vector<uint8_t>; // 每个元素存储 8 个位
+using WordContainer = std::vector<uint16_t>; // 每个元素存储 16 位
+using DWordContainer = std::vector<uint32_t>; // 每个元素存储 32 位
-// CPerformanceMelsec 绫诲０鏄�
+// CPerformanceMelsec 类声明
class CPerformanceMelsec {
public:
- // 鑾峰彇鏈�杩戠殑閿欒淇℃伅
+ // 获取最近的错误信息
std::string GetLastError() const;
- // 閿欒淇℃伅鍔犺浇涓庝繚瀛樻帴鍙�
- static bool LoadErrorInfoFromFile(const std::string& filename); // 浠庢枃浠跺姞杞介敊璇俊鎭�
- static bool SaveErrorInfoToFile(const std::string& filename); // 淇濆瓨閿欒淇℃伅鍒版枃浠�
+ // 错误信息加载与保存接口
+ static bool LoadErrorInfoFromFile(const std::string& filename); // 从文件加载错误信息
+ static bool SaveErrorInfoToFile(const std::string& filename); // 保存错误信息到文件
- // 杩炴帴/鏂紑
+ // 连接/断开
int Connect(short nChannel, short nMode = -1);
int Disconnect();
- // 鍒濆鍖栧彲缂栫▼鎺у埗鍣ㄨ蒋鍏冧欢淇℃伅琛�
+ // 初始化可编程控制器软元件信息表
int InitializeController();
- // 鑾峰彇鐗堟湰淇℃伅
+ // 获取版本信息
int GetBoardVersion(BoardVersion& version);
- // 鏉垮浣�
+ // 板复位
int BoardReset();
- // 鏉縇ED璇诲彇
+ // 板LED读取
int ReadBoardLed(std::vector<short>& vecLedBuffer);
- // 璇诲彇鐩爣绔欑偣CPU绫诲瀷
+ // 读取目标站点CPU类型
int ReadCPUCode(const StationIdentifier& station, short& nCPUCode);
- // 鏉挎ā寮忚幏鍙�/璁剧疆
+ // 板模式获取/设置
int SetBoardMode(short nMode);
int GetBoardMode(short& nMode);
- // 鑾峰彇鏉跨姸鎬�
+ // 获取板状态
int GetBoardStatus(BoardStatus& status);
- // 璇诲啓鏁版嵁
+ // 读写数据
int ReadData(const StationIdentifier& station, short nDevType, short nDevNo, short nSize, std::vector<short>& vecData);
int ReadBitData(const StationIdentifier& station, DeviceType enDevType, short nDevNo, short nBitCount, BitContainer& vecData);
int ReadWordData(const StationIdentifier& station, DeviceType enDevType, short nDevNo, short nWordCount, WordContainer& vecData);
@@ -380,60 +386,60 @@
int WriteWordData(const StationIdentifier& station, DeviceType enDevType, short nDevNo, const WordContainer& vecData);
int WriteDWordData(const StationIdentifier& station, DeviceType enDevType, short nDevNo, const DWordContainer& vecData);
- // 鎵╁睍璇诲啓鏁版嵁
+ // 扩展读写数据
long ReadDataEx(const StationIdentifier& station, long nDevType, long nDevNo, long nSize, std::vector<char>& vecData);
long WriteDataEx(const StationIdentifier& station, long nDevType, long nDevNo, const std::vector<char>& vecData);
- // 鎵╁睍杞厓浠堕殢鏈鸿鍐欙紙鏀寔澶氫釜杞厓浠讹級
+ // 扩展软元件随机读写（支持多个软元件）
long ReadRandomDataEx(const StationIdentifier& station, const std::vector<SoftElement>& vecSoftElements, std::vector<char>& vecData);
long WriteRandomDataEx(const StationIdentifier& station, const std::vector<SoftElement>& vecSoftElements, const std::vector<char>& vecData);
- // 杩滅▼璁惧绔�/杩滅▼绔欑殑缂撳啿瀛樺偍鍣ㄨ鍐�
+ // 远程设备站/远程站的缓冲存储器读写
long ReadRemoteBuffer(const StationIdentifier& station, long nOffset, long nSize, std::vector<char>& vecData);
long WriteRemoteBuffer(const StationIdentifier& station, long nOffset, const std::vector<char>& vecData);
long ReadRemoteBufferByIp(const std::string& strIP, long nOffset, long nSize, std::vector<char>& vecData);
long WriteRemoteBufferByIp(const std::string& strIP, long nOffset, const std::vector<char>& vecData);
- // 璁剧疆/澶嶄綅瀵硅薄绔欑殑鎸囧畾浣嶈蒋鍏冧欢
+ // 设置/复位对象站的指定位软元件
int SetBitDevice(const StationIdentifier& station, DeviceType enDevType, short nDevNo);
int ResetBitDevice(const StationIdentifier& station, DeviceType enDevType, short enDevNo);
- // 鎵╁睍璁剧疆/澶嶄綅瀵硅薄绔欑殑鎸囧畾浣嶈蒋鍏冧欢
+ // 扩展设置/复位对象站的指定位软元件
long SetBitDeviceEx(const StationIdentifier& station, long nDevType, long nDevNo);
long ResetBitDeviceEx(const StationIdentifier& station, long nDevType, long nDevNo);
- // 鎵ц瀵硅薄绔欑殑CPU
+ // 执行对象站的CPU
int ControlCPU(const StationIdentifier& station, ControlCode enControlCode);
- // 浜嬩欢绛夊緟锛寁ecEventNumbers[0, 64]锛宯TimeoutMs[-1, 2147483647]
- // 鍚屾椂鍙戠敓浜嗗涓簨浠剁殑鎯呭喌涓嬶紝棣栧厛妫�娴嬪嚭鍏朵腑涓�涓簨浠躲�� 鍐嶆鎵ц浜嗘湰鍑芥暟鐨勬儏鍐典笅妫�娴嬪嚭鍏跺畠浜嬩欢銆�
+ // 事件等待，vecEventNumbers[0, 64]，nTimeoutMs[-1, 2147483647]
+ // 同时发生了多个事件的情况下，首先检测出其中一个事件。 再次执行了本函数的情况下检测出其它事件。
int WaitForBoardEvent(std::vector<short> vecEventNumbers, int nTimeoutMs, EventDetails& details);
private:
- // 閿佸畾涓庤В閿侊紙澶氱嚎绋嬪悓姝ヤ繚鎶わ級
+ // 锁定与解锁（多线程同步保护）
void Lock() { m_mtx.lock(); }
void Unlock() { m_mtx.unlock(); }
protected:
- // 鏋勯�犲嚱鏁�/鏋愭瀯鍑芥暟
+ // 构造函数/析构函数
explicit CPerformanceMelsec(BoardType enBoardType);
virtual ~CPerformanceMelsec();
- // 杈呭姪鍑芥暟
- void UpdateLastError(int nCode); // 鏇存柊鏈�杩戠殑閿欒淇℃伅
- int ValidateStation(const StationIdentifier& station) const; // 妫�鏌ヨ繛鎺ョ姸鎬佸拰绔欑偣鍙傛暟鏈夋晥鎬�
+ // 辅助函数
+ void UpdateLastError(int nCode); // 更新最近的错误信息
+ int ValidateStation(const StationIdentifier& station) const; // 检查连接状态和站点参数有效性
int ValidateStationAndSize(const StationIdentifier& station, short nCount) const;
- // 闈欐�佽緟鍔╁嚱鏁�
- static void Delay(unsigned int nDelayMs); // 寤舵椂锛屽苟涓旇浆鍙戠獥鍙ｆ秷鎭�
- static BoardType FindBoardTypeByChannel(int nChannel); // 鏌ユ壘鏉垮潡绫诲瀷
- static short CombineStation(const StationIdentifier& station); // 鍚堝苟缃戠粶鍙峰拰绔欑偣鍙�
- static short CalculateDeviceType(const StationIdentifier& station, DeviceType enDevType); // 璁＄畻杞厓浠剁被鍨�
+ // 静态辅助函数
+ static void Delay(unsigned int nDelayMs); // 延时，并且转发窗口消息
+ static BoardType FindBoardTypeByChannel(int nChannel); // 查找板块类型
+ static short CombineStation(const StationIdentifier& station); // 合并网络号和站点号
+ static short CalculateDeviceType(const StationIdentifier& station, DeviceType enDevType); // 计算软元件类型
- // IP杞崲
+ // IP转换
static bool ConvertIpStringToUint32(const std::string& strIP, uint32_t& nIP);
- // 瀹瑰櫒杞崲
+ // 容器转换
static void ConvertCharToShort(const std::vector<char>& vecChar, std::vector<short>& vecShort);
static void ConvertShortToChar(const std::vector<short>& vecShort, std::vector<char>&vecChar);
static void ConvertUint8ToShort(const std::vector<uint8_t>& vecUint8, std::vector<short>& vecShort);
@@ -441,7 +447,7 @@
static void ConvertUint32ToShort(const std::vector<uint32_t>& vecUint32, std::vector<short>& vecShort);
static void ConvertShortToUint32(const std::vector<short>& vecShort, std::vector<uint32_t>& vecUint32);
- // 妯℃澘杈呭姪鍑芥暟
+ // 模板辅助函数
template <typename T>
int ValidateStationAndData(const StationIdentifier& station, const std::vector<T>& vecData);
@@ -451,15 +457,15 @@
template <typename T, typename U>
void ConvertHighToLow(const std::vector<T>& vecHigh, std::vector<U>& vecLow);
- // 鎴愬憳鍙橀噺
- std::mutex m_mtx; // 浜掓枼閿佷繚鎶�
- BoardType m_enBoardType; // 鏉垮潡绫诲瀷
- long m_nPath; // 閫氫俊璺緞
- std::atomic<bool> m_bConnected; // 鏄惁宸茶繛鎺�
- std::string m_strLastError; // 鏈�杩戜竴娆￠敊璇俊鎭�
+ // 成员变量
+ std::mutex m_mtx; // 互斥锁保护
+ BoardType m_enBoardType; // 板块类型
+ long m_nPath; // 通信路径
+ std::atomic<bool> m_bConnected; // 是否已连接
+ std::string m_strLastError; // 最近一次错误信息
- // 闈欐�佹垚鍛樺彉閲�
- static std::unordered_map<int, std::string> m_mapError; // 閿欒鐮佹槧灏勮〃
+ // 静态成员变量
+ static std::unordered_map<int, std::string> m_mapError; // 错误码映射表
};
#endif // PERFORMANCE_MELSEC_H
\ No newline at end of file
diff --git a/SourceCode/Bond/Servo/CEFEM.cpp b/SourceCode/Bond/Servo/CEFEM.cpp
new file mode 100644
index 0000000..665aa25
--- /dev/null
+++ b/SourceCode/Bond/Servo/CEFEM.cpp
@@ -0,0 +1,40 @@
+#include "stdafx.h"
+#include "CEFEM.h"
+
+namespace SERVO {
+ CEFEM::CEFEM()
+ {
+
+ }
+
+ CEFEM::~CEFEM()
+ {
+
+ }
+
+ const char* CEFEM::getClassName()
+ {
+ static char* pszName = "CEFEM";
+ return pszName;
+ }
+
+ void CEFEM::init()
+ {
+ CEquipment::init();
+ }
+
+ void CEFEM::term()
+ {
+ CEquipment::term();
+ }
+
+ void CEFEM::onTimer(UINT nTimerid)
+ {
+ CEquipment::onTimer(nTimerid);
+ }
+
+ void CEFEM::serialize(CArchive& ar)
+ {
+ CEquipment::serialize(ar);
+ }
+}
diff --git a/SourceCode/Bond/Servo/CEFEM.h b/SourceCode/Bond/Servo/CEFEM.h
new file mode 100644
index 0000000..7a7be7e
--- /dev/null
+++ b/SourceCode/Bond/Servo/CEFEM.h
@@ -0,0 +1,20 @@
+#pragma once
+#include "CEquipment.h"
+
+namespace SERVO {
+ class CEFEM :
+ public CEquipment
+ {
+ public:
+ CEFEM();
+ ~CEFEM();
+
+ public:
+ virtual const char* getClassName();
+ virtual void init();
+ virtual void term();
+ virtual void onTimer(UINT nTimerid);
+ virtual void serialize(CArchive& ar);
+ };
+}
+
diff --git a/SourceCode/Bond/Servo/CEquipment.cpp b/SourceCode/Bond/Servo/CEquipment.cpp
new file mode 100644
index 0000000..6f8cd0b
--- /dev/null
+++ b/SourceCode/Bond/Servo/CEquipment.cpp
@@ -0,0 +1,93 @@
+#include "stdafx.h"
+#include "CEquipment.h"
+
+namespace SERVO {
+
+ CEquipment::CEquipment()
+ {
+ InitializeCriticalSection(&m_criticalSection);
+ }
+
+ CEquipment::~CEquipment()
+ {
+ DeleteCriticalSection(&m_criticalSection);
+ }
+
+ void CEquipment::init()
+ {
+
+ }
+
+ void CEquipment::term()
+ {
+
+ }
+
+ void CEquipment::setName(const char* pszName)
+ {
+ m_strName = pszName;
+ }
+
+ std::string& CEquipment::getName()
+ {
+ return m_strName;
+ }
+
+ void CEquipment::setDescription(const char* pszDescription)
+ {
+ m_strDescription = pszDescription;
+ }
+
+ std::string& CEquipment::getDescription()
+ {
+ return m_strDescription;
+ }
+
+ void CEquipment::setStation(int network, int station)
+ {
+ m_station.nNetNo = network;
+ m_station.nStNo = station;
+ }
+
+ const StationIdentifier& CEquipment::getStation()
+ {
+ return m_station;
+ }
+
+ void CEquipment::setReadBitBlock(unsigned int start, unsigned int end)
+ {
+ m_blockReadBit.type = (unsigned int)DeviceType::LB;;
+ m_blockReadBit.start = start;
+ m_blockReadBit.end = end;
+ m_blockReadBit.size = (m_blockReadBit.end - m_blockReadBit.start + 1) / 8;
+ }
+
+ MemoryBlock& CEquipment::getReadBitBlock()
+ {
+ return m_blockReadBit;
+ }
+
+ void CEquipment::setWriteBitBlock(unsigned int start, unsigned int end)
+ {
+ m_blockWriteBit.type = (unsigned int)DeviceType::LB;
+ m_blockWriteBit.start = start;
+ m_blockWriteBit.end = end;
+ m_blockWriteBit.size = (m_blockWriteBit.end - m_blockWriteBit.start + 1) / 8;
+ }
+
+ MemoryBlock& CEquipment::getWriteBitBlock()
+ {
+ return m_blockWriteBit;
+ }
+
+ void CEquipment::onTimer(UINT nTimerid)
+ {
+
+ }
+
+ void CEquipment::serialize(CArchive& ar)
+ {
+
+ }
+
+}
diff --git a/SourceCode/Bond/Servo/CEquipment.h b/SourceCode/Bond/Servo/CEquipment.h
new file mode 100644
index 0000000..9f83bb8
--- /dev/null
+++ b/SourceCode/Bond/Servo/CEquipment.h
@@ -0,0 +1,51 @@
+#pragma once
+#include "Log.h"
+#include "CCLinkIEControl.h"
+
+namespace SERVO {
+ // Memory Block 结构体定义
+ typedef struct _MemoryBlock {
+ unsigned int type;
+ unsigned int start;
+ unsigned int end;
+ unsigned int size;
+ } MemoryBlock;
+
+ class CEquipment
+ {
+ public:
+ CEquipment();
+ virtual ~CEquipment();
+
+
+ public:
+ virtual const char* getClassName() = 0;
+ void setName(const char* pszName);
+ std::string& getName();
+ void setDescription(const char* pszDescription);
+ std::string& getDescription();
+ void setStation(int network, int station);
+ const StationIdentifier& getStation();
+ void setReadBitBlock(unsigned int start, unsigned int end);
+ MemoryBlock& getReadBitBlock();
+ void setWriteBitBlock(unsigned int start, unsigned int end);
+ MemoryBlock& getWriteBitBlock();
+ virtual void init();
+ virtual void term();
+ virtual void onTimer(UINT nTimerid);
+ virtual void serialize(CArchive& ar);
+
+ protected:
+ inline void Lock() { EnterCriticalSection(&m_criticalSection); }
+ inline void Unlock() { LeaveCriticalSection(&m_criticalSection); }
+
+ protected:
+ std::string m_strName;
+ std::string m_strDescription;
+ CRITICAL_SECTION m_criticalSection;
+ StationIdentifier m_station;
+ MemoryBlock m_blockReadBit;
+ MemoryBlock m_blockWriteBit;
+ };
+}
+
diff --git a/SourceCode/Bond/Servo/CMaster.cpp b/SourceCode/Bond/Servo/CMaster.cpp
new file mode 100644
index 0000000..85bf38e
--- /dev/null
+++ b/SourceCode/Bond/Servo/CMaster.cpp
@@ -0,0 +1,127 @@
+#include "stdafx.h"
+#include "CMaster.h"
+
+namespace SERVO {
+ CMaster* g_pMaster = NULL;
+ void CALLBACK MasterTimerProc(HWND hWnd, UINT nMsg, UINT nTimerid, DWORD dwTime)
+ {
+ if (g_pMaster != NULL) {
+ g_pMaster->onTimer(nTimerid);
+ }
+ }
+
+ CMaster::CMaster()
+ {
+
+ }
+
+ CMaster::~CMaster()
+ {
+ for (auto item : m_listEquipment) {
+ delete item;
+ }
+ m_listEquipment.clear();
+ }
+
+ int CMaster::init()
+ {
+ LOGI("<Master>正在初始化...");
+
+
+ // cclink
+ if (m_cclink.Connect(CC_LINK_IE_CONTROL_CHANNEL(1)) != 0) {
+ LOGE("连接CC-Link失败.");
+ return -1;
+ }
+ else {
+ LOGI("连接CC-Link成功.");
+ BoardVersion version{};
+ int nRet = m_cclink.GetBoardVersion(version);
+ if (nRet == 0) {
+ LOGI("版本信息：%s.", version.toString().c_str());
+ }
+ else {
+ LOGE("获取CC-Link版本信息失败.");
+ }
+
+ BoardStatus status;
+ nRet = m_cclink.GetBoardStatus(status);
+ if (nRet == 0) {
+ LOGI("状态：%s.", status.toString().c_str());
+ }
+ else {
+ LOGE("获取CC-Link状态失败.");
+ }
+ }
+
+
+ // 初始化添加各子设备
+ {
+ CEFEM* pEquipment = new CEFEM();
+ pEquipment->setName("EFEM(ROBOT)");
+ pEquipment->setDescription("EFEM(ROBOT).");
+ pEquipment->setReadBitBlock(0x4000, 0x45ff);
+ pEquipment->setStation(1, 2);
+ addEquipment(pEquipment);
+ LOGE("已添加“EFEM(ROBOT)”.");
+ }
+ /*
+ {
+ CBonder* pBonder = new CBonder();
+ pBonder->setName("Bonder 1");
+ pBonder->setDescription("Bonder 1.");
+ pBonder->setReadBitBlock(0x4600, 0x4bff);
+ pBonder->setStation(1, 3);
+ addEquipment(pBonder);
+ LOGE("已添加“Bonder 1”.");
+ }
+ */
+
+ // 定时器
+ g_pMaster = this;
+ SetTimer(NULL, 1, 250, (TIMERPROC)MasterTimerProc);
+
+
+ LOGI("<Master>初始化完成.");
+ return 0;
+ }
+
+ int CMaster::term()
+ {
+ return 0;
+ }
+
+ int CMaster::addEquipment(CEquipment* pEquipment)
+ {
+ m_listEquipment.push_back(pEquipment);
+ return 0;
+ }
+
+ void CMaster::onTimer(UINT nTimerid)
+ {
+ for (auto item : m_listEquipment) {
+ item->onTimer(nTimerid);
+ }
+
+
+ // 以下为测试代码
+ static int i = 0;
+ i++;
+ if (i % (4 * 1) == 0) {
+
+ for (auto item : m_listEquipment) {
+ const StationIdentifier& station = item->getStation();
+ MemoryBlock& block = item->getReadBitBlock();
+
+ char szBuffer[1024];
+ int nRet = m_cclink.ReadData2(station, (short)block.type,
+ block.start, block.size, szBuffer);
+ for (unsigned int i = 0; i < block.size; i++) {
+ if(szBuffer[i] != 0)
+ TRACE("%d[%x]\n", i, szBuffer[i]);
+ }
+ TRACE("nRet=%d\n", nRet);
+ }
+ }
+ }
+}
diff --git a/SourceCode/Bond/Servo/CMaster.h b/SourceCode/Bond/Servo/CMaster.h
new file mode 100644
index 0000000..ad4d0df
--- /dev/null
+++ b/SourceCode/Bond/Servo/CMaster.h
@@ -0,0 +1,32 @@
+#pragma once
+#include <list>
+#include "CEquipment.h"
+#include "CEFEM.h"
+#include "CBonder.h"
+#include "CCLinkIEControl.h"
+
+
+namespace SERVO {
+ class CMaster
+ {
+ public:
+ CMaster();
+ ~CMaster();
+
+
+ public:
+ int init();
+ int term();
+ void onTimer(UINT nTimerid);
+
+
+ private:
+ int addEquipment(CEquipment* pEquipment);
+
+
+ private:
+ CCCLinkIEControl m_cclink;
+ std::list<CEquipment*> m_listEquipment;
+ };
+}
+
diff --git a/SourceCode/Bond/Servo/Model.cpp b/SourceCode/Bond/Servo/Model.cpp
index 8d621b0..7009492 100644
--- a/SourceCode/Bond/Servo/Model.cpp
+++ b/SourceCode/Bond/Servo/Model.cpp
@@ -96,6 +96,8 @@
{
m_hsmsPassive.term();
CLog::GetLog()->SetOnLogCallback(nullptr);
+ m_master.term();
+
return 0;
}
diff --git a/SourceCode/Bond/Servo/Model.h b/SourceCode/Bond/Servo/Model.h
index 00733d2..6e2655c 100644
--- a/SourceCode/Bond/Servo/Model.h
+++ b/SourceCode/Bond/Servo/Model.h
@@ -1,6 +1,7 @@
#pragma once
#include "Configuration.h"
#include "HsmsPassive.h"
+#include "CMaster.h"
class CModel
{
@@ -31,6 +32,7 @@
public:
CConfiguration m_configuration;
CHsmsPassive m_hsmsPassive;
+ SERVO::CMaster m_master;
private:
IObservable* m_pObservable;
diff --git a/SourceCode/Bond/Servo/Servo.vcxproj b/SourceCode/Bond/Servo/Servo.vcxproj
index 1a138ec..3fa06f5 100644
--- a/SourceCode/Bond/Servo/Servo.vcxproj
+++ b/SourceCode/Bond/Servo/Servo.vcxproj
@@ -132,6 +132,9 @@
<PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<AdditionalIncludeDirectories>$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
</ResourceCompile>
+ <PostBuildEvent>
+ <Command>copy "$(TargetDir)$(ProjectName).exe" "\\Boounion-0106\Servo\\$(ProjectName).exe"</Command>
+ </PostBuildEvent>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
@@ -194,8 +197,12 @@
<ItemGroup>
<ClInclude Include="AlarmManager.h" />
<ClInclude Include="BlButton.h" />
+ <ClInclude Include="CBonder.h" />
<ClInclude Include="CCLinkPerformance\CCLinkIEControl.h" />
<ClInclude Include="CCLinkPerformance\PerformanceMelsec.h" />
+ <ClInclude Include="CEFEM.h" />
+ <ClInclude Include="CEquipment.h" />
+ <ClInclude Include="CMaster.h" />
<ClInclude Include="Common.h" />
<ClInclude Include="Configuration.h" />
<ClInclude Include="Context.h" />
@@ -218,8 +225,12 @@
<ItemGroup>
<ClCompile Include="AlarmManager.cpp" />
<ClCompile Include="BlButton.cpp" />
+ <ClCompile Include="CBonder.cpp" />
<ClCompile Include="CCLinkPerformance\CCLinkIEControl.cpp" />
<ClCompile Include="CCLinkPerformance\PerformanceMelsec.cpp" />
+ <ClCompile Include="CEFEM.cpp" />
+ <ClCompile Include="CEquipment.cpp" />
+ <ClCompile Include="CMaster.cpp" />
<ClCompile Include="Configuration.cpp" />
<ClCompile Include="Context.cpp" />
<ClCompile Include="HsmsAction.cpp" />
diff --git a/SourceCode/Bond/Servo/Servo.vcxproj.filters b/SourceCode/Bond/Servo/Servo.vcxproj.filters
index 58314be..28a906c 100644
--- a/SourceCode/Bond/Servo/Servo.vcxproj.filters
+++ b/SourceCode/Bond/Servo/Servo.vcxproj.filters
@@ -30,6 +30,10 @@
<ClCompile Include="CCLinkPerformance\PerformanceMelsec.cpp">
<Filter>CCLinkPerformance</Filter>
</ClCompile>
+ <ClCompile Include="CEquipment.cpp" />
+ <ClCompile Include="CBonder.cpp" />
+ <ClCompile Include="CMaster.cpp" />
+ <ClCompile Include="CEFEM.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="AlarmManager.h" />
@@ -58,6 +62,10 @@
<ClInclude Include="CCLinkPerformance\PerformanceMelsec.h">
<Filter>CCLinkPerformance</Filter>
</ClInclude>
+ <ClInclude Include="CEquipment.h" />
+ <ClInclude Include="CBonder.h" />
+ <ClInclude Include="CMaster.h" />
+ <ClInclude Include="CEFEM.h" />
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="Servo.rc" />
diff --git a/SourceCode/Bond/Servo/Servo.vcxproj.user b/SourceCode/Bond/Servo/Servo.vcxproj.user
index ef958f5..3980fd1 100644
--- a/SourceCode/Bond/Servo/Servo.vcxproj.user
+++ b/SourceCode/Bond/Servo/Servo.vcxproj.user
@@ -3,4 +3,10 @@
<PropertyGroup>
<RESOURCE_FILE>Servo.rc</RESOURCE_FILE>
</PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+ <RemoteDebuggerCommand>D:\CLH\Servo\Servo.exe</RemoteDebuggerCommand>
+ <RemoteDebuggerWorkingDirectory>D:\CLH\Servo\</RemoteDebuggerWorkingDirectory>
+ <RemoteDebuggerServerName>Boounion-0106</RemoteDebuggerServerName>
+ <DebuggerFlavor>WindowsRemoteDebugger</DebuggerFlavor>
+ </PropertyGroup>
</Project>
\ No newline at end of file
diff --git a/SourceCode/Bond/Servo/ServoDlg.cpp b/SourceCode/Bond/Servo/ServoDlg.cpp
index f8bfb36..a8a340b 100644
--- a/SourceCode/Bond/Servo/ServoDlg.cpp
+++ b/SourceCode/Bond/Servo/ServoDlg.cpp
@@ -290,8 +290,15 @@
SetTimer(TIMER_ID_CREATE_TERMINAL, 3000, nullptr);
InitRxWindows();
+ OnBnClickedButtonLog();
UpdateLogBtn();
Resize();
+
+
+ // 相当于延时调用master的初始化
+ theApp.m_model.m_master.init();
+
+
return TRUE; // 除非将焦点设置到控件，否则返回 TRUE
}
diff --git a/SourceCode/Bond/Servo/packages.config b/SourceCode/Bond/Servo/packages.config
new file mode 100644
index 0000000..8892444
--- /dev/null
+++ b/SourceCode/Bond/Servo/packages.config
@@ -0,0 +1,5 @@
+锘�<?xml version="1.0" encoding="utf-8"?>
+<packages>
+ <package id="Microsoft.Web.WebView2" version="1.0.2903.40" targetFramework="native" />
+ <package id="Microsoft.Windows.ImplementationLibrary" version="1.0.240803.1" targetFramework="native" />
+</packages>
\ No newline at end of file
--
Gitblit v1.9.3