From bdf0dc4cb183d3fec40e1d51b3bb94b7e53d0a55 Mon Sep 17 00:00:00 2001
From: chenluhua1980 <Chenluhua@qq.com>
Date: 星期日, 04 一月 2026 10:45:07 +0800
Subject: [PATCH] 1.修复报文字段差异风险： S1F3：项目用 getSubItemU4(0) 取 SVID；日志里有 U2 的情况，可能导致解析失败后回退成 SV=0。 S6F11：项目发送 DATAID(U4) + CEID(U4)；日志样例里第一个字段是 U2，可能存在类型/字段定义不一致。
---
SourceCode/Bond/Servo/HsmsPassive.cpp | 1206 +++++++++++++++++++++++++++++++++++++++++++++++++++++++--
1 files changed, 1,158 insertions(+), 48 deletions(-)
diff --git a/SourceCode/Bond/Servo/HsmsPassive.cpp b/SourceCode/Bond/Servo/HsmsPassive.cpp
index 76bb93a..ae7ef22 100644
--- a/SourceCode/Bond/Servo/HsmsPassive.cpp
+++ b/SourceCode/Bond/Servo/HsmsPassive.cpp
@@ -8,6 +8,8 @@
#include <time.h>
#include <stdlib.h>
#include <string.h>
+#include <algorithm>
+#include <set>
#include <regex>
@@ -103,6 +105,43 @@
}
+void CHsmsPassive::addVariableValueToItem(ISECS2Item* pParent, SERVO::CVariable* pVariable)
+{
+ ASSERT(pParent);
+ ASSERT(pVariable);
+
+
+ ISECS2Item* pItemList;
+ SERVO::SVFromat format = pVariable->getFormat();
+ switch (format)
+ {
+ case SERVO::SVFromat::U1:
+ pParent->addU1Item((unsigned char)pVariable->getIntValue(), "SV");
+ break;
+ case SERVO::SVFromat::U2:
+ pParent->addU2Item((unsigned char)pVariable->getIntValue(), "SV");
+ break;
+ case SERVO::SVFromat::I2:
+ pParent->addI2Item((unsigned char)pVariable->getIntValue(), "SV");
+ break;
+ case SERVO::SVFromat::A20:
+ case SERVO::SVFromat::A50:
+ pParent->addItem(pVariable->getValue().c_str(), "SV");
+ break;
+ case SERVO::SVFromat::L:
+ pItemList = pParent->addItem();
+ {
+ auto vars = pVariable->getVarsValue();
+ for (auto v : vars) {
+ addVariableValueToItem(pItemList, &v);
+ }
+ }
+ break;
+ default:
+ break;
+ }
+}
+
void CHsmsPassive::linkEventReport(unsigned int CEID, unsigned int RPTID)
{
SERVO::CCollectionEvent* pEvent = getEvent(CEID);
@@ -191,40 +230,133 @@
int CHsmsPassive::loadVarialbles(const char* pszFilepath)
{
- CStdioFile file;
- if (!file.Open(pszFilepath, CFile::modeRead)) {
+ m_strVariableFilepath = pszFilepath;
+ m_bVariableUtf8 = false;
+ m_bVariableUtf8Bom = false;
+ // 鍏堣鍘熷瀛楄妭锛屽悗缁啀鎸� UTF-8/BOM 鎴栨湰鍦扮紪鐮佽浆鎹�
+ CFile file;
+ if (!file.Open(pszFilepath, CFile::modeRead | CFile::shareDenyNone)) {
return -1;
}
- std::regex pattern("^\\d+,.*"); // 鍖归厤浠ユ暟瀛�+閫楀彿寮�澶寸殑瀛楃涓�
+ const ULONGLONG nLen = file.GetLength();
+ if (nLen == 0) {
+ return -1;
+ }
+
+ std::string buffer;
+ buffer.resize(static_cast<size_t>(nLen));
+ file.Read(buffer.data(), static_cast<UINT>(nLen));
+ file.Close();
+
+ const unsigned char* bytes = reinterpret_cast<const unsigned char*>(buffer.data());
+ size_t offset = 0;
+ CStringW content;
+
+ // UTF-8 BOM
+ if (nLen >= 3 && bytes[0] == 0xEF && bytes[1] == 0xBB && bytes[2] == 0xBF) {
+ offset = 3;
+ m_bVariableUtf8 = true;
+ m_bVariableUtf8Bom = true;
+ }
+
+ // UTF-16 LE BOM
+ if (nLen >= 2 && bytes[0] == 0xFF && bytes[1] == 0xFE) {
+ const wchar_t* wdata = reinterpret_cast<const wchar_t*>(buffer.data() + 2);
+ const size_t wlen = (nLen - 2) / sizeof(wchar_t);
+ content.SetString(wdata, static_cast<int>(wlen));
+ }
+ // UTF-16 BE BOM
+ else if (nLen >= 2 && bytes[0] == 0xFE && bytes[1] == 0xFF) {
+ const size_t wlen = (nLen - 2) / sizeof(wchar_t);
+ std::wstring temp;
+ temp.reserve(wlen);
+ for (size_t i = 0; i < wlen; ++i) {
+ wchar_t ch = static_cast<wchar_t>(bytes[2 + i * 2] << 8 | bytes[2 + i * 2 + 1]);
+ temp.push_back(ch);
+ }
+ content = temp.c_str();
+ }
+ // 灏濊瘯 UTF-8锛堝惈鏃� BOM锛�
+ else {
+ auto tryUtf8 = [&](size_t off) -> bool {
+ int need = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, buffer.data() + off,
+ static_cast<int>(buffer.size() - off), nullptr, 0);
+ if (need <= 0) return false;
+ std::wstring temp;
+ temp.resize(need);
+ MultiByteToWideChar(CP_UTF8, 0, buffer.data() + off,
+ static_cast<int>(buffer.size() - off), temp.data(), need);
+ content = temp.c_str();
+ m_bVariableUtf8 = true;
+ return true;
+ };
+
+ if (!tryUtf8(offset)) {
+ // 鍥為��鍒版湰鍦颁唬鐮侀〉
+ int need = MultiByteToWideChar(CP_ACP, 0, buffer.data(), static_cast<int>(buffer.size()), nullptr, 0);
+ if (need > 0) {
+ std::wstring temp;
+ temp.resize(need);
+ MultiByteToWideChar(CP_ACP, 0, buffer.data(), static_cast<int>(buffer.size()), temp.data(), need);
+ content = temp.c_str();
+ }
+ }
+ }
+
+ if (content.IsEmpty()) {
+ return -1;
+ }
+
+ std::wregex pattern(L"^\\d+,.+"); // 鍖归厤浠ユ暟瀛�+閫楀彿寮�澶寸殑瀛楃涓�
std::vector<SERVO::CVariable*> variables;
int index, last;
- CString strLine;
- CString strId, strName, strFormat, strRemark;
- while (file.ReadString(strLine)) {
- if (!std::regex_match((LPTSTR)(LPCTSTR)strLine, pattern)) {
+ CStringW strLine;
+ CStringW strId, strName, strFormat, strRemark;
+ std::wstringstream ss(content.GetString());
+ auto narrowFromW = [](const CStringW& s) -> std::string {
+ int need = WideCharToMultiByte(CP_ACP, 0, s, -1, nullptr, 0, nullptr, nullptr);
+ if (need <= 0) return {};
+ std::string out(static_cast<size_t>(need - 1), '\0');
+ WideCharToMultiByte(CP_ACP, 0, s, -1, out.data(), need, nullptr, nullptr);
+ return out;
+ };
+ std::wstring line;
+ while (std::getline(ss, line, L'\n')) {
+ strLine = line.c_str();
+ strLine.Trim();
+ if (strLine.IsEmpty()) continue;
+ if (!std::regex_match(static_cast<LPCWSTR>(strLine), pattern)) {
continue;
}
last = 0;
- index = strLine.Find(",", last);
+ index = strLine.Find(L",", last);
if (index < 0) continue;
strId = strLine.Left(index);
last = index + 1;
- index = strLine.Find(",", last);
+ index = strLine.Find(L",", last);
if (index < 0) continue;
strName = strLine.Mid(last, index - last);
last = index + 1;
- index = strLine.Find(",", last);
+ index = strLine.Find(L",", last);
if (index < 0) continue;
strFormat = strLine.Mid(last, index - last);
strRemark = strLine.Right(strLine.GetLength() - index - 1);
- strRemark.Replace(_T("\\r\\n"), _T("\r\n"));
+ strRemark.Replace(L"\\r\\n", L"\r\n");
+
+ std::string sId = narrowFromW(strId);
+ std::string sName = narrowFromW(strName);
+ std::string sFormat = narrowFromW(strFormat);
+ std::string sRemark = narrowFromW(strRemark);
SERVO::CVariable* pVarialble = new SERVO::CVariable(
- (LPTSTR)(LPCTSTR)strId, (LPTSTR)(LPCTSTR)strName, (LPTSTR)(LPCTSTR)strFormat, (LPTSTR)(LPCTSTR)strRemark);
+ sId.c_str(),
+ sName.c_str(),
+ sFormat.c_str(),
+ sRemark.c_str());
variables.push_back(pVarialble);
}
@@ -235,8 +367,6 @@
}
}
-
- file.Close();
return 0;
}
@@ -245,10 +375,32 @@
return m_variabels;
}
+unsigned int CHsmsPassive::getMaxVariableId() const
+{
+ unsigned int maxId = 0;
+ for (auto item : m_variabels) {
+ if (item && item->getVarialbleId() > maxId) {
+ maxId = item->getVarialbleId();
+ }
+ }
+ return maxId;
+}
+
SERVO::CVariable* CHsmsPassive::getVariable(int variableId)
{
for (auto item : m_variabels) {
if (item->getVarialbleId() == variableId) {
+ return item;
+ }
+ }
+
+ return nullptr;
+}
+
+SERVO::CVariable* CHsmsPassive::getVariable(const char* pszName)
+{
+ for (auto item : m_variabels) {
+ if (item->getName().compare(pszName) == 0) {
return item;
}
}
@@ -264,32 +416,298 @@
m_variabels.clear();
}
+CStringA WideToUtf8(const CStringW& ws)
+{
+ int need = WideCharToMultiByte(CP_UTF8, 0, ws, -1, nullptr, 0, nullptr, nullptr);
+ if (need <= 0) return "";
+ CStringA out;
+ LPSTR buf = out.GetBufferSetLength(need - 1);
+ WideCharToMultiByte(CP_UTF8, 0, ws, -1, buf, need, nullptr, nullptr);
+ out.ReleaseBuffer();
+ return out;
+}
+
+CStringA WideToAnsi(const CStringW& ws)
+{
+ int need = WideCharToMultiByte(CP_ACP, 0, ws, -1, nullptr, 0, nullptr, nullptr);
+ if (need <= 0) return "";
+ CStringA out;
+ LPSTR buf = out.GetBufferSetLength(need - 1);
+ WideCharToMultiByte(CP_ACP, 0, ws, -1, buf, need, nullptr, nullptr);
+ out.ReleaseBuffer();
+ return out;
+}
+
+static CStringA AnsiToUtf8(const std::string& s)
+{
+ int wlen = MultiByteToWideChar(CP_ACP, 0, s.c_str(), -1, nullptr, 0);
+ if (wlen <= 0) return "";
+ CStringW ws;
+ LPWSTR wbuf = ws.GetBufferSetLength(wlen - 1);
+ MultiByteToWideChar(CP_ACP, 0, s.c_str(), -1, wbuf, wlen);
+ ws.ReleaseBuffer();
+ return WideToUtf8(ws);
+}
+
+int CHsmsPassive::deleteVariable(int variableId)
+{
+ Lock();
+ auto it = std::find_if(m_variabels.begin(), m_variabels.end(), [=](SERVO::CVariable* v) {
+ return v != nullptr && v->getVarialbleId() == variableId;
+ });
+ if (it == m_variabels.end()) {
+ Unlock();
+ return -1;
+ }
+ delete *it;
+ m_variabels.erase(it);
+ auto filepath = m_strVariableFilepath;
+ Unlock();
+
+ if (filepath.empty()) return -2;
+
+ return writeVariablesToFile(filepath);
+}
+
+void CHsmsPassive::setVariableValue(const char* pszName, __int64 value)
+{
+ auto v = getVariable(pszName);
+ if (v != nullptr) {
+ v->setValue(value);
+ }
+}
+
+void CHsmsPassive::setVariableValue(const char* pszName, const char* value)
+{
+ auto v = getVariable(pszName);
+ if (v != nullptr) {
+ v->setValue(value);
+ }
+}
+
+void CHsmsPassive::setVariableValue(const char* pszName, std::vector<SERVO::CVariable>& vars)
+{
+ auto v = getVariable(pszName);
+ if (v != nullptr) {
+ v->setValue(vars);
+ }
+}
+
+static bool isValidFormat(const std::string& fmt)
+{
+ static const std::set<std::string> allow = { "U1","U2","I2","A20","A50","L" };
+ return allow.count(fmt) > 0;
+}
+
+int CHsmsPassive::addVariable(const char* pszName, const char* pszFormat, const char* pszRemark, int& outId)
+{
+ if (pszName == nullptr || pszFormat == nullptr) return -1;
+ std::string fmt = pszFormat;
+ std::transform(fmt.begin(), fmt.end(), fmt.begin(), ::toupper);
+ if (!isValidFormat(fmt)) return -2;
+
+ Lock();
+ int maxId = 0;
+ for (auto v : m_variabels) {
+ if (v != nullptr && v->getVarialbleId() > maxId) {
+ maxId = v->getVarialbleId();
+ }
+ }
+ outId = maxId + 1;
+
+ SERVO::CVariable* pNew = new SERVO::CVariable(std::to_string(outId).c_str(), pszName, fmt.c_str(), pszRemark ? pszRemark : "");
+ m_variabels.push_back(pNew);
+ auto filepath = m_strVariableFilepath;
+ Unlock();
+
+ if (filepath.empty()) return -3;
+ return writeVariablesToFile(filepath);
+}
+
+int CHsmsPassive::updateVariable(int variableId, const char* pszName, const char* pszFormat, const char* pszRemark)
+{
+ if (pszName == nullptr || pszFormat == nullptr) return -1;
+ std::string fmt = pszFormat;
+ std::transform(fmt.begin(), fmt.end(), fmt.begin(), ::toupper);
+ if (!isValidFormat(fmt)) return -2;
+
+ Lock();
+ auto it = std::find_if(m_variabels.begin(), m_variabels.end(), [=](SERVO::CVariable* v) {
+ return v != nullptr && v->getVarialbleId() == variableId;
+ });
+ if (it == m_variabels.end()) {
+ Unlock();
+ return -4;
+ }
+ (*it)->setName(pszName);
+ (*it)->setFormat(fmt.c_str());
+ (*it)->setRemark(pszRemark ? pszRemark : "");
+ auto filepath = m_strVariableFilepath;
+ Unlock();
+
+ if (filepath.empty()) return -3;
+ return writeVariablesToFile(filepath);
+}
+
+int CHsmsPassive::writeVariablesToFile(const std::string& filepath)
+{
+ if (filepath.empty()) return -3;
+
+ CFile file;
+ if (!file.Open(filepath.c_str(), CFile::modeCreate | CFile::modeWrite | CFile::shareDenyNone)) {
+ return -3;
+ }
+
+ // header
+ const std::string headerAnsi = "SVID,SV Name,SV Format,SV Remark\r\n";
+ if (m_bVariableUtf8) {
+ if (m_bVariableUtf8Bom) {
+ const BYTE bom[3] = { 0xEF, 0xBB, 0xBF };
+ file.Write(bom, 3);
+ }
+ CStringA header = AnsiToUtf8(headerAnsi);
+ file.Write(header.GetString(), header.GetLength());
+ }
+ else {
+ file.Write(headerAnsi.data(), (UINT)headerAnsi.size());
+ }
+
+ for (auto v : m_variabels) {
+ if (v == nullptr) continue;
+ std::string lineAnsi;
+ lineAnsi.reserve(256);
+ lineAnsi += std::to_string(v->getVarialbleId());
+ lineAnsi.push_back(',');
+ lineAnsi += v->getName();
+ lineAnsi.push_back(',');
+ lineAnsi += SERVO::CVariable::formatToString(v->getFormat());
+ lineAnsi.push_back(',');
+ lineAnsi += v->getRemark();
+ lineAnsi.append("\r\n");
+
+ if (m_bVariableUtf8) {
+ CStringA outLine = AnsiToUtf8(lineAnsi);
+ file.Write(outLine.GetString(), outLine.GetLength());
+ }
+ else {
+ file.Write(lineAnsi.data(), (UINT)lineAnsi.size());
+ }
+ }
+ file.Close();
+
+ return 0;
+}
+
int CHsmsPassive::loadReports(const char* pszFilepath)
{
- CStdioFile file;
- if (!file.Open(pszFilepath, CFile::modeRead)) {
+ m_strReportFilepath = pszFilepath;
+ m_bReportUtf8 = false;
+ m_bReportUtf8Bom = false;
+ // 鍏煎 UTF-8/BOM 涓庢湰鍦扮紪鐮佽鍙�
+ CFile file;
+ if (!file.Open(pszFilepath, CFile::modeRead | CFile::shareDenyNone)) {
return -1;
}
- std::regex pattern("^\\d+,\\(\\d+(,\\d+)*\\).*"); // 鍖归厤浠ユ暟瀛�+閫楀彿寮�澶寸殑瀛楃涓�
+ const ULONGLONG nLen = file.GetLength();
+ if (nLen == 0) {
+ return -1;
+ }
+
+ std::string buffer;
+ buffer.resize(static_cast<size_t>(nLen));
+ file.Read(buffer.data(), static_cast<UINT>(nLen));
+ file.Close();
+
+ const unsigned char* bytes = reinterpret_cast<const unsigned char*>(buffer.data());
+ size_t offset = 0;
+ CStringW content;
+
+ // UTF-8 BOM
+ if (nLen >= 3 && bytes[0] == 0xEF && bytes[1] == 0xBB && bytes[2] == 0xBF) {
+ offset = 3;
+ m_bReportUtf8 = true;
+ m_bReportUtf8Bom = true;
+ }
+
+ // UTF-16 LE BOM
+ if (nLen >= 2 && bytes[0] == 0xFF && bytes[1] == 0xFE) {
+ const wchar_t* wdata = reinterpret_cast<const wchar_t*>(buffer.data() + 2);
+ const size_t wlen = (nLen - 2) / sizeof(wchar_t);
+ content.SetString(wdata, static_cast<int>(wlen));
+ }
+ // UTF-16 BE BOM
+ else if (nLen >= 2 && bytes[0] == 0xFE && bytes[1] == 0xFF) {
+ const size_t wlen = (nLen - 2) / sizeof(wchar_t);
+ std::wstring temp;
+ temp.reserve(wlen);
+ for (size_t i = 0; i < wlen; ++i) {
+ wchar_t ch = static_cast<wchar_t>(bytes[2 + i * 2] << 8 | bytes[2 + i * 2 + 1]);
+ temp.push_back(ch);
+ }
+ content = temp.c_str();
+ }
+ else {
+ auto tryUtf8 = [&](size_t off) -> bool {
+ int need = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, buffer.data() + off,
+ static_cast<int>(buffer.size() - off), nullptr, 0);
+ if (need <= 0) return false;
+ std::wstring temp;
+ temp.resize(need);
+ MultiByteToWideChar(CP_UTF8, 0, buffer.data() + off,
+ static_cast<int>(buffer.size() - off), temp.data(), need);
+ content = temp.c_str();
+ m_bReportUtf8 = true;
+ return true;
+ };
+
+ if (!tryUtf8(offset)) {
+ int need = MultiByteToWideChar(CP_ACP, 0, buffer.data(), static_cast<int>(buffer.size()), nullptr, 0);
+ if (need > 0) {
+ std::wstring temp;
+ temp.resize(need);
+ MultiByteToWideChar(CP_ACP, 0, buffer.data(), static_cast<int>(buffer.size()), temp.data(), need);
+ content = temp.c_str();
+ }
+ }
+ }
+
+ if (content.IsEmpty()) {
+ return -1;
+ }
+
+ std::wregex pattern(L"^\\d+,\\(\\d+(,\\d+)*\\).*"); // 鍖归厤浠ユ暟瀛�+閫楀彿寮�澶寸殑瀛楃涓�
std::vector<SERVO::CReport*> reports;
int index;
- CString strLine, strVariable;
- CString strId;
- while (file.ReadString(strLine)) {
- if (!std::regex_match((LPTSTR)(LPCTSTR)strLine, pattern)) {
+ CStringW strLine, strVariable;
+ CStringW strId;
+ std::wstringstream ss(content.GetString());
+ auto narrowFromW = [](const CStringW& s) -> std::string {
+ int need = WideCharToMultiByte(CP_ACP, 0, s, -1, nullptr, 0, nullptr, nullptr);
+ if (need <= 0) return {};
+ std::string out(static_cast<size_t>(need - 1), '\0');
+ WideCharToMultiByte(CP_ACP, 0, s, -1, out.data(), need, nullptr, nullptr);
+ return out;
+ };
+ std::wstring line;
+ while (std::getline(ss, line, L'\n')) {
+ strLine = line.c_str();
+ strLine.Trim();
+ if (strLine.IsEmpty()) continue;
+ if (!std::regex_match(static_cast<LPCWSTR>(strLine), pattern)) {
continue;
}
- index = strLine.Find(",", 0);
+ index = strLine.Find(L",", 0);
if (index < 0) continue;
strId = strLine.Left(index);
strVariable = strLine.Right(strLine.GetLength() - index - 1);
strVariable.Delete(0);
strVariable.Delete(strVariable.GetLength() - 1);
- auto vids = parseVidList(strVariable);
+ CString strVariableA(narrowFromW(strVariable).c_str());
+ auto vids = parseVidList(strVariableA);
- SERVO::CReport* pReport = new SERVO::CReport(atoi((LPTSTR)(LPCTSTR)strId), vids);
+ SERVO::CReport* pReport = new SERVO::CReport(_wtoi(strId), vids);
for (auto vid : vids) {
SERVO::CVariable* pVariable = getVariable(vid);
if (pVariable != nullptr) {
@@ -308,13 +726,23 @@
}
- file.Close();
return 0;
}
std::vector<SERVO::CReport*>& CHsmsPassive::getReports()
{
return m_reports;
+}
+
+unsigned int CHsmsPassive::getMaxReportId() const
+{
+ unsigned int maxId = 0;
+ for (auto item : m_reports) {
+ if (item && item->getReportId() > maxId) {
+ maxId = item->getReportId();
+ }
+ }
+ return maxId;
}
SERVO::CReport* CHsmsPassive::getReport(int rptid)
@@ -341,6 +769,49 @@
return false;
}
+int CHsmsPassive::deleteReport(int rptid)
+{
+ if (!removeReport(rptid)) {
+ return -1;
+ }
+ return writeReportsToFile(m_strReportFilepath);
+}
+
+int CHsmsPassive::addReport(int rptid, const std::vector<unsigned int>& vids)
+{
+ if (getReport(rptid) != nullptr) {
+ return -1;
+ }
+ SERVO::CReport* pReport = new SERVO::CReport(rptid, vids);
+ for (auto vid : vids) {
+ SERVO::CVariable* pVariable = getVariable((int)vid);
+ if (pVariable != nullptr) {
+ pReport->addVariable(pVariable);
+ }
+ }
+ m_reports.push_back(pReport);
+ return writeReportsToFile(m_strReportFilepath);
+}
+
+int CHsmsPassive::updateReport(int rptid, const std::vector<unsigned int>& vids)
+{
+ for (auto iter = m_reports.begin(); iter != m_reports.end(); ++iter) {
+ if ((*iter)->getReportId() == rptid) {
+ delete (*iter);
+ SERVO::CReport* pReport = new SERVO::CReport(rptid, vids);
+ for (auto vid : vids) {
+ SERVO::CVariable* pVariable = getVariable((int)vid);
+ if (pVariable != nullptr) {
+ pReport->addVariable(pVariable);
+ }
+ }
+ *iter = pReport;
+ return writeReportsToFile(m_strReportFilepath);
+ }
+ }
+ return -1;
+}
+
void CHsmsPassive::clearAllReport()
{
for (auto item : m_reports) {
@@ -349,44 +820,183 @@
m_reports.clear();
}
-int CHsmsPassive::loadCollectionEvents(const char* pszFilepath)
+int CHsmsPassive::writeReportsToFile(const std::string& filepath)
{
- CStdioFile file;
- if (!file.Open(pszFilepath, CFile::modeRead)) {
+ if (filepath.empty()) return -1;
+
+ CFile file;
+ if (!file.Open(filepath.c_str(), CFile::modeCreate | CFile::modeWrite)) {
return -1;
}
- std::regex pattern("^\\d+,[^,]*,[^,]*,\\(\\d+(,\\d+)*\\).*"); // 鍖归厤浠ユ暟瀛�+閫楀彿寮�澶寸殑瀛楃涓�
+ if (m_bReportUtf8 && m_bReportUtf8Bom) {
+ const BYTE bom[3] = { 0xEF, 0xBB, 0xBF };
+ file.Write(bom, 3);
+ }
+
+ // header
+ const std::string headerAnsi = "RPTID,(VID1,VID2,...)\r\n";
+ if (m_bReportUtf8) {
+ CStringA header = AnsiToUtf8(headerAnsi);
+ file.Write(header.GetString(), header.GetLength());
+ }
+ else {
+ file.Write(headerAnsi.data(), (UINT)headerAnsi.size());
+ }
+
+ for (auto rpt : m_reports) {
+ if (rpt == nullptr) continue;
+ std::string line;
+ line.reserve(64);
+ line += std::to_string(rpt->getReportId());
+ line += ",(";
+
+ const auto& vids = rpt->getVids();
+ for (size_t i = 0; i < vids.size(); ++i) {
+ line += std::to_string(vids[i]);
+ if (i + 1 < vids.size()) {
+ line.push_back(',');
+ }
+ }
+ line += ")\r\n";
+
+ if (m_bReportUtf8) {
+ CStringA out = AnsiToUtf8(line);
+ file.Write(out.GetString(), out.GetLength());
+ }
+ else {
+ file.Write(line.data(), (UINT)line.size());
+ }
+ }
+
+ file.Close();
+ return 0;
+}
+
+int CHsmsPassive::loadCollectionEvents(const char* pszFilepath)
+{
+ m_strCollectionEventFilepath = pszFilepath;
+ m_bCollectionUtf8 = false;
+ m_bCollectionUtf8Bom = false;
+ CFile file;
+ if (!file.Open(pszFilepath, CFile::modeRead | CFile::shareDenyNone)) {
+ return -1;
+ }
+
+ const ULONGLONG nLen = file.GetLength();
+ if (nLen == 0) {
+ return -1;
+ }
+
+ std::string buffer;
+ buffer.resize(static_cast<size_t>(nLen));
+ file.Read(buffer.data(), static_cast<UINT>(nLen));
+ file.Close();
+
+ const unsigned char* bytes = reinterpret_cast<const unsigned char*>(buffer.data());
+ size_t offset = 0;
+ CStringW content;
+
+ // UTF-8 BOM
+ if (nLen >= 3 && bytes[0] == 0xEF && bytes[1] == 0xBB && bytes[2] == 0xBF) {
+ offset = 3;
+ m_bCollectionUtf8 = true;
+ m_bCollectionUtf8Bom = true;
+ }
+
+ // UTF-16 LE BOM
+ if (nLen >= 2 && bytes[0] == 0xFF && bytes[1] == 0xFE) {
+ const wchar_t* wdata = reinterpret_cast<const wchar_t*>(buffer.data() + 2);
+ const size_t wlen = (nLen - 2) / sizeof(wchar_t);
+ content.SetString(wdata, static_cast<int>(wlen));
+ }
+ // UTF-16 BE BOM
+ else if (nLen >= 2 && bytes[0] == 0xFE && bytes[1] == 0xFF) {
+ const size_t wlen = (nLen - 2) / sizeof(wchar_t);
+ std::wstring temp;
+ temp.reserve(wlen);
+ for (size_t i = 0; i < wlen; ++i) {
+ wchar_t ch = static_cast<wchar_t>(bytes[2 + i * 2] << 8 | bytes[2 + i * 2 + 1]);
+ temp.push_back(ch);
+ }
+ content = temp.c_str();
+ }
+ else {
+ auto tryUtf8 = [&](size_t off) -> bool {
+ int need = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, buffer.data() + off,
+ static_cast<int>(buffer.size() - off), nullptr, 0);
+ if (need <= 0) return false;
+ std::wstring temp;
+ temp.resize(need);
+ MultiByteToWideChar(CP_UTF8, 0, buffer.data() + off,
+ static_cast<int>(buffer.size() - off), temp.data(), need);
+ content = temp.c_str();
+ m_bCollectionUtf8 = true;
+ return true;
+ };
+
+ if (!tryUtf8(offset)) {
+ int need = MultiByteToWideChar(CP_ACP, 0, buffer.data(), static_cast<int>(buffer.size()), nullptr, 0);
+ if (need > 0) {
+ std::wstring temp;
+ temp.resize(need);
+ MultiByteToWideChar(CP_ACP, 0, buffer.data(), static_cast<int>(buffer.size()), temp.data(), need);
+ content = temp.c_str();
+ }
+ }
+ }
+
+ if (content.IsEmpty()) {
+ return -1;
+ }
+
+ std::wregex pattern(L"^\\d+,[^,]*,[^,]*,\\(\\d+(,\\d+)*\\).*"); // 鍖归厤浠ユ暟瀛�+閫楀彿寮�澶寸殑瀛楃涓�
std::vector<SERVO::CCollectionEvent*> events;
int index, last;
- CString strLine, strRPTIDs;
- CString strId, strName, strDescription;
- while (file.ReadString(strLine)) {
- if (!std::regex_match((LPTSTR)(LPCTSTR)strLine, pattern)) {
+ CStringW strLine, strRPTIDs;
+ CStringW strId, strName, strDescription;
+ std::wstringstream ss(content.GetString());
+ auto narrowFromW = [](const CStringW& s) -> std::string {
+ int need = WideCharToMultiByte(CP_ACP, 0, s, -1, nullptr, 0, nullptr, nullptr);
+ if (need <= 0) return {};
+ std::string out(static_cast<size_t>(need - 1), '\0');
+ WideCharToMultiByte(CP_ACP, 0, s, -1, out.data(), need, nullptr, nullptr);
+ return out;
+ };
+ std::wstring line;
+ while (std::getline(ss, line, L'\n')) {
+ strLine = line.c_str();
+ strLine.Trim();
+ if (strLine.IsEmpty()) continue;
+ if (!std::regex_match(static_cast<LPCWSTR>(strLine), pattern)) {
continue;
}
last = 0;
- index = strLine.Find(",", last);
+ index = strLine.Find(L",", last);
if (index < 0) continue;
strId = strLine.Left(index);
last = index + 1;
- index = strLine.Find(",", last);
+ index = strLine.Find(L",", last);
if (index < 0) continue;
strName = strLine.Mid(last, index - last);
last = index + 1;
- index = strLine.Find(",", last);
+ index = strLine.Find(L",", last);
if (index < 0) continue;
strDescription = strLine.Mid(last, index - last);
strRPTIDs = strLine.Right(strLine.GetLength() - index - 1);
strRPTIDs.Delete(0);
strRPTIDs.Delete(strRPTIDs.GetLength() - 1);
- auto prtids = parseVidList(strRPTIDs);
+ CString strRPTIDsA(narrowFromW(strRPTIDs).c_str());
+ auto prtids = parseVidList(strRPTIDsA);
+
+ std::string sName = narrowFromW(strName);
+ std::string sDesc = narrowFromW(strDescription);
SERVO::CCollectionEvent* pEvent = new SERVO::CCollectionEvent(
- atoi(strId), (LPTSTR)(LPCTSTR)strName, (LPTSTR)(LPCTSTR)strDescription, prtids);
+ _wtoi(strId), sName.c_str(), sDesc.c_str(), prtids);
for (auto rptid : prtids) {
SERVO::CReport* pReport = getReport(rptid);
if (pReport != nullptr) {
@@ -402,15 +1012,70 @@
m_collectionEvents.push_back(item);
}
}
-
-
- file.Close();
return 0;
}
std::vector<SERVO::CCollectionEvent*>& CHsmsPassive::getCollectionEvents()
{
return m_collectionEvents;
+}
+
+unsigned int CHsmsPassive::getMaxCollectionEventId() const
+{
+ unsigned int maxId = 0;
+ for (auto item : m_collectionEvents) {
+ if (item && item->getEventId() > maxId) {
+ maxId = item->getEventId();
+ }
+ }
+ return maxId;
+}
+
+int CHsmsPassive::deleteCollectionEvent(unsigned short CEID)
+{
+ for (auto iter = m_collectionEvents.begin(); iter != m_collectionEvents.end(); ++iter) {
+ if ((*iter)->getEventId() == CEID) {
+ delete (*iter);
+ m_collectionEvents.erase(iter);
+ return writeCollectionEventsToFile(m_strCollectionEventFilepath);
+ }
+ }
+ return -1;
+}
+
+int CHsmsPassive::addCollectionEvent(unsigned int CEID, const char* name, const char* desc, const std::vector<unsigned int>& rptids)
+{
+ if (getEvent((unsigned short)CEID) != nullptr) {
+ return -1;
+ }
+ auto* pEvent = new SERVO::CCollectionEvent(CEID, name, desc, const_cast<std::vector<unsigned int>&>(rptids));
+ for (auto rptid : rptids) {
+ SERVO::CReport* pReport = getReport((int)rptid);
+ if (pReport != nullptr) {
+ pEvent->addReport(pReport);
+ }
+ }
+ m_collectionEvents.push_back(pEvent);
+ return writeCollectionEventsToFile(m_strCollectionEventFilepath);
+}
+
+int CHsmsPassive::updateCollectionEvent(unsigned int CEID, const char* name, const char* desc, const std::vector<unsigned int>& rptids)
+{
+ for (auto iter = m_collectionEvents.begin(); iter != m_collectionEvents.end(); ++iter) {
+ if ((*iter)->getEventId() == CEID) {
+ delete (*iter);
+ auto* pEvent = new SERVO::CCollectionEvent(CEID, name, desc, const_cast<std::vector<unsigned int>&>(rptids));
+ for (auto rptid : rptids) {
+ SERVO::CReport* pReport = getReport((int)rptid);
+ if (pReport != nullptr) {
+ pEvent->addReport(pReport);
+ }
+ }
+ *iter = pEvent;
+ return writeCollectionEventsToFile(m_strCollectionEventFilepath);
+ }
+ }
+ return -1;
}
void CHsmsPassive::clearAllCollectionEvent()
@@ -452,6 +1117,62 @@
}
return result;
+}
+
+int CHsmsPassive::writeCollectionEventsToFile(const std::string& filepath)
+{
+ if (filepath.empty()) return -1;
+
+ CFile file;
+ if (!file.Open(filepath.c_str(), CFile::modeCreate | CFile::modeWrite)) {
+ return -1;
+ }
+
+ if (m_bCollectionUtf8 && m_bCollectionUtf8Bom) {
+ const BYTE bom[3] = { 0xEF, 0xBB, 0xBF };
+ file.Write(bom, 3);
+ }
+
+ const std::string headerAnsi = "CEID,CE Name,Descriptions,Attached RPTID\r\n";
+ if (m_bCollectionUtf8) {
+ CStringA header = AnsiToUtf8(headerAnsi);
+ file.Write(header.GetString(), header.GetLength());
+ }
+ else {
+ file.Write(headerAnsi.data(), (UINT)headerAnsi.size());
+ }
+
+ for (auto ev : m_collectionEvents) {
+ if (ev == nullptr) continue;
+ std::string line;
+ line.reserve(128);
+ line += std::to_string(ev->getEventId());
+ line.push_back(',');
+ line += ev->getName();
+ line.push_back(',');
+ line += ev->getDescription();
+ line.push_back(',');
+ line.push_back('(');
+ auto rptIds = ev->getReportIds();
+ for (size_t i = 0; i < rptIds.size(); ++i) {
+ line += std::to_string(rptIds[i]);
+ if (i + 1 < rptIds.size()) {
+ line.push_back(',');
+ }
+ }
+ line += ")\r\n";
+
+ if (m_bCollectionUtf8) {
+ CStringA out = AnsiToUtf8(line);
+ file.Write(out.GetString(), out.GetLength());
+ }
+ else {
+ file.Write(line.data(), (UINT)line.size());
+ }
+ }
+
+ file.Close();
+ return 0;
}
int CHsmsPassive::init(CModel* pModel, const char* pszName, unsigned int port)
@@ -509,6 +1230,9 @@
// S1F1
replyAreYouThere(pMessage);
}
+ else if (nStream == 1 && pHeader->function == 3) {
+ replySelectedEquipmentStatusData(pMessage);
+ }
else if (nStream == 1 && pHeader->function == 13) {
replyEstablishCommunications(pMessage);
}
@@ -556,6 +1280,12 @@
}
else if (nStream == 10 && pHeader->function == 3) {
replyTerminalDisplay(pMessage);
+ }
+ else if (nStream == 14 && pHeader->function == 9) {
+ replyCreateObj(pMessage);
+ }
+ else if (nStream == 16 && pHeader->function == 15) {
+ replyPRJobMultiCreate(pMessage);
}
};
@@ -875,6 +1605,46 @@
return 0;
}
+// S1F3
+int CHsmsPassive::replySelectedEquipmentStatusData(IMessage* pRecv)
+{
+ if (m_pPassive == NULL || STATE::SELECTED != m_pPassive->getState()) {
+ return ER_NOTSELECT;
+ }
+
+ IMessage* pMessage = NULL;
+ HSMS_Create1Message(pMessage, m_nSessionId, 1, 4, pRecv->getHeader()->systemBytes);
+ ASSERT(pMessage);
+
+ unsigned char SVU1 = 0;
+ unsigned short SVID = 0;
+ ISECS2Item* pBody = pRecv->getBody();
+ if (pBody == nullptr || pBody->getType() != SITYPE::L) {
+ pMessage->getBody()->addU1Item(SVU1, "SV");
+ goto MYREPLY;
+ }
+ if (!pBody->getSubItemU2(0, SVID)) {
+ pMessage->getBody()->addU1Item(SVU1, "SV");
+ goto MYREPLY;
+ }
+
+ SERVO::CVariable* pVariable = getVariable((int)SVID);
+ if (pVariable == nullptr) {
+ pMessage->getBody()->addU1Item(SVU1, "SV");
+ goto MYREPLY;
+ }
+ addVariableValueToItem(pMessage->getBody(), pVariable);
+
+MYREPLY:
+ m_pPassive->sendMessage(pMessage);
+ LOGI("<HSMS>[SECS Msg SEND]%s", pMessage->toString());
+ HSMS_Destroy1Message(pMessage);
+
+
+
+ return 0;
+}
+
// S2F13
int CHsmsPassive::replyEquipmentConstantRequest(IMessage* pRecv)
{
@@ -1095,7 +1865,7 @@
// 妫�楠岀粨鏋滄槸鍚︽纭�
for (auto item : m_collectionEvents) {
- LOGE("=== ceid:%d, prtid:%d", item->getEventId(), item->getPortID());
+ LOGE("=== ceid:%d, prtid:%d", item->getEventId(), item->getFirstPortID());
}
MYREPLY:
@@ -1420,6 +2190,245 @@
return 0;
}
+// S14F9
+int CHsmsPassive::replyCreateObj(IMessage* pRecv)
+{
+ if (m_pPassive == NULL || STATE::SELECTED != m_pPassive->getState()) {
+ return ER_NOTSELECT;
+ }
+ ISECS2Item* pBody = pRecv->getBody();
+ if (pBody == nullptr || pBody->getType() != SITYPE::L) ER_PARAM_ERROR;
+
+
+ // 鏄惁鍒涘缓鎴愬姛骞跺噯澶囧洖澶嶆姤鏂�
+ bool bCreateOk = false;
+ IMessage* pReply = NULL;
+ HSMS_Create1Message(pReply, m_nSessionId, 14, 10, ++m_nSystemByte);
+ ASSERT(pReply);
+
+
+
+ // 瑙ｉ噴鏁版嵁锛屽緱鍒癈ontrolJob
+ ISECS2Item* pItemAttrs, * pItemAttr, *pItemAttrData;
+ const char* pszObjSpec, *pszObjType, *pszAttrId, *pszProcessJobId;
+ std::string strObjName, strObjId;
+ if (!pBody->getSubItemString(0, pszObjSpec)) return ER_PARAM_ERROR;
+ if (!pBody->getSubItemString(1, pszObjType)) return ER_PARAM_ERROR;
+
+ pReply->getBody()->addItem(pszObjSpec, "OBJSPEC");
+ ISECS2Item* pReplyItemAttrs = pReply->getBody()->addItem();
+ ISECS2Item* pReplyItemAcks = pReply->getBody()->addItem();
+ ISECS2Item* pReplyItemAck = pReplyItemAcks->addU1Item(0, "OBJACK");
+ ISECS2Item* pReplyItemErrs = pReplyItemAcks->addItem();
+
+ // 褰撳墠鍙鐞嗙被鍚勪负ControlJob
+ if (_strcmpi(pszObjType, "ControlJob") == 0) {
+
+ // 绫籭d
+ std::regex re("^([^:]+):([^>]+)>");
+ std::smatch match;
+ std::string strObjSpec(pszObjSpec);
+ if (!std::regex_search(strObjSpec, match, re)) {
+ ISECS2Item* pItemError = pReplyItemErrs->addItem();
+ pItemError->addU4Item(2001, "ERRCODE");
+ pItemError->addItem("鍙傛暟鎴栨姤鏂囦笉姝ｇ‘", "ERRTEXT");
+ goto MYREPLY;
+ }
+
+ if (match[1].compare("ControlJob") != 0) {
+ ISECS2Item* pItemError = pReplyItemErrs->addItem();
+ pItemError->addU4Item(2001, "ERRCODE");
+ pItemError->addItem("涓嶆敮鎸佺殑OBJ", "ERRTEXT");
+ goto MYREPLY;
+ }
+ strObjId = match[2];
+
+ // 鍒涘缓绫籆ControlJob
+ SERVO::CControlJob controlJob(strObjId);
+
+ // 绫诲睘鎬�
+ pItemAttrs = pBody->getSubItem(2);
+ if (pItemAttrs == nullptr) return ER_PARAM_ERROR;
+ for (int i = 0; i < pItemAttrs->getSubItemSize(); i++) {
+ pItemAttr = pItemAttrs->getSubItem(i);
+ if (pItemAttr == nullptr) continue;
+ if (!pItemAttr->getSubItemString(0, pszAttrId)) continue;
+ if (_strcmpi(pszAttrId, CJ_ATTR_PRIORITY) == 0) {
+ uint8_t priority;
+ if (pItemAttr->getSubItemU1(1, priority)) {
+ controlJob.setPriority(priority);
+ }
+ }
+ else if (_strcmpi(pszAttrId, CJ_ATTR_PRJOBLIST) == 0) {
+ pItemAttrData = pItemAttr->getSubItem(1);
+ if (pItemAttrData != nullptr && pItemAttrData->getType() == SITYPE::L) {
+ for (int i = 0; i < pItemAttrData->getSubItemSize(); i++) {
+ if (pItemAttrData->getSubItemString(i, pszProcessJobId)) {
+ std::string strProcessJobId(pszProcessJobId);
+ controlJob.addPJ(strProcessJobId);
+ }
+ }
+ }
+ }
+ }
+
+
+ ASSERT(m_listener.onControlJobCreate != nullptr);
+ int nRet = m_listener.onControlJobCreate(this, controlJob);
+ bCreateOk = nRet == 0;
+
+ // 娣诲姞鏂板缓绫荤殑鍚勭灞炴�у埌鍥炲鎶ユ枃涓�
+ if(bCreateOk) {
+ {
+ ISECS2Item* pReplyItemAttr = pReplyItemAttrs->addItem();
+ pReplyItemAttr->addItem(CJ_ATTR_PRIORITY, "ATTRID");
+ pReplyItemAttr->addU1Item(controlJob.priority(), "ATTRDATA");
+ }
+
+ {
+ ISECS2Item* pReplyItemAttr = pReplyItemAttrs->addItem();
+ pReplyItemAttr->addItem(CJ_ATTR_PRJOBLIST, "ATTRID");
+ ISECS2Item* pItemPjs = pReplyItemAttr->addItem();
+ auto pjIds = controlJob.pjIds();
+ for (auto id : pjIds) {
+ pItemPjs->addItem(id.c_str(), "PRJOBID");
+ }
+ }
+ }
+ else {
+ auto issues = controlJob.issues();
+ for (auto i : issues) {
+ ISECS2Item* pItemError = pReplyItemErrs->addItem();
+ pItemError->addU4Item(i.code, "ERRCODE");
+ pItemError->addItem(i.text.c_str(), "ERRTEXT");
+ }
+ }
+ }
+
+
+ else {
+ ISECS2Item* pItemError = pReplyItemErrs->addItem();
+ pItemError->addU4Item(2001, "ERRCODE");
+ pItemError->addItem("涓嶆敮鎸佺殑OBJ", "ERRTEXT");
+ }
+
+
+ // 瀹屽杽鎶ユ枃骞跺洖澶�
+MYREPLY:
+ pReplyItemAck->setU1(bCreateOk ? 0 : 1, "OBJACK");
+ m_pPassive->sendMessage(pReply);
+ LOGI("<HSMS>[SECS Msg SEND]S14F10 (SysByte=%u)", pReply->getHeader()->systemBytes);
+ HSMS_Destroy1Message(pReply);
+
+
+ return 0;
+}
+
+// S16F15
+int CHsmsPassive::replyPRJobMultiCreate(IMessage* pRecv)
+{
+ if (m_pPassive == NULL || STATE::SELECTED != m_pPassive->getState()) {
+ return ER_NOTSELECT;
+ }
+ ISECS2Item* pBody = pRecv->getBody();
+ if (pBody == nullptr || pBody->getType() != SITYPE::L) ER_PARAM_ERROR;
+
+
+ // 瑙ｉ噴鏁版嵁锛屽緱鍒癈ProcessJob
+ ISECS2Item* pItemPjs, * pItemPj,* pItemCarriers, * pItemCarrier, *pItemSlots, *pItemRecipes;
+ unsigned int DATAID;
+ const char* pszPrjobid, *pszMF, *pszCarrierId, *pszRecipeName;
+ std::string strCarrierId;
+ unsigned int len;
+ unsigned char slot, PRRECIPEMETHOD;
+ std::vector<unsigned char> slots;
+ std::vector<SERVO::CProcessJob*> pjs;
+
+ if (!pBody->getSubItemU4(0, DATAID)) return ER_PARAM_ERROR;
+ pItemPjs = pBody->getSubItem(1);
+ if (pItemPjs == nullptr) return ER_PARAM_ERROR;
+ for (int i = 0; i < pItemPjs->getSubItemSize(); i++) {
+ pItemPj = pItemPjs->getSubItem(i);
+ if (pItemPj == nullptr) continue;
+ if (!pItemPj->getSubItemString(0, pszPrjobid)) continue;
+ if (!pItemPj->getSubItemBinary(1, pszMF, len)) continue;
+ pItemCarriers = pItemPj->getSubItem(2);
+ if (pItemCarriers == nullptr) continue;
+ pItemRecipes = pItemPj->getSubItem(3);
+ if (pItemRecipes == nullptr) continue;
+ SERVO::CProcessJob* pj = new SERVO::CProcessJob(pszPrjobid);
+ int size = pItemCarriers->getSubItemSize();
+ for (int j = 0; j < size; j++) {
+ pItemCarrier = pItemCarriers->getSubItem(j);
+ strCarrierId.clear();
+ if (pItemCarrier->getSubItemString(0, pszCarrierId)) {
+ strCarrierId = pszCarrierId;
+ }
+
+ slots.clear();
+ pItemSlots = pItemCarrier->getSubItem(1);
+ if (pItemSlots != nullptr) {
+ int size2 = pItemSlots->getSubItemSize();
+ for (int k = 0; k < size2; k++) {
+ if (pItemSlots->getSubItemU1(k, slot)) {
+ slots.push_back(slot);
+ }
+ }
+ }
+ pj->addCarrier(strCarrierId, slots);
+ }
+ if (pItemRecipes->getSubItemU1(0, PRRECIPEMETHOD)
+ && pItemRecipes->getSubItemString(1, pszRecipeName)) {
+ pj->setRecipe(SERVO::RecipeMethod(PRRECIPEMETHOD), std::string(pszRecipeName));
+ }
+
+ pjs.push_back(pj);
+ }
+
+ ASSERT(m_listener.onPRJobMultiCreate != nullptr);
+ int nRet = m_listener.onPRJobMultiCreate(this, pjs);
+
+
+ // 鍥炲鎶ユ枃
+ IMessage* pMessage = NULL;
+ HSMS_Create1Message(pMessage, m_nSessionId, 16, 16, ++m_nSystemByte);
+ ASSERT(pMessage);
+ ISECS2Item* pItemPrjobIds = pMessage->getBody()->addItem();
+ ISECS2Item* pItemErrors = pMessage->getBody()->addItem();
+ bool bHasError = false;
+ for (auto p : pjs) {
+ if (p->issues().empty()) {
+ pItemPrjobIds->addItem(p->id().c_str(), "PRJOBID");
+ }
+ else {
+ bHasError = true;
+ }
+ }
+ if (bHasError) {
+ pItemErrors->addBoolItem(false, "ACKA");
+ ISECS2Item* pItemErrors2 = pItemErrors->addItem();
+ for (auto p : pjs) {
+ if (!p->issues().empty()) {
+ ISECS2Item* pItemErr = pItemErrors2->addItem();
+ pItemErr->addU4Item(p->issues()[0].code, "ERRCODE");
+ pItemErr->addItem(("<" + p->id() + ">" + p->issues()[0].text).c_str(), "ERRTEXT");
+ }
+ }
+ }
+ m_pPassive->sendMessage(pMessage);
+ LOGI("<HSMS>[SECS Msg SEND]S16F16 (SysByte=%u)", pMessage->getHeader()->systemBytes);
+ HSMS_Destroy1Message(pMessage);
+
+
+ // 閲婃斁鏈夐棶棰�(鏈坊鍔犲埌master)鐨勫唴瀛�
+ for (auto p : pjs) {
+ if(!p->issues().empty()) delete p;
+ }
+ pjs.clear();
+
+ return 0;
+}
+
// S5F1
int CHsmsPassive::requestAlarmReport(int ALCD, int ALID, const char* ALTX)
{
@@ -1450,15 +2459,19 @@
}
// S6F11
-int CHsmsPassive::requestEventReportSend(unsigned int DATAID, unsigned int CEID, const std::vector<std::string>& values)
+static unsigned short DATAID = 0;
+int CHsmsPassive::requestEventReportSend(unsigned int CEID)
{
SERVO::CCollectionEvent* pEvent = getEvent(CEID);
if (pEvent == nullptr) {
return ER_NO_EVENT;
}
- if (pEvent == nullptr) {
+
+ SERVO::CReport* pReport = pEvent->getFirstReport();
+ if (pReport == nullptr) {
return ER_UNLINK_EVENT_REPORT;
}
+
Lock();
CHsmsAction* pAction = new CHsmsAction(ACTION_EVENT_REPORT, TRUE, m_nActionTimeout);
@@ -1466,14 +2479,17 @@
HSMS_Create1Message(pMessage, m_nSessionId, 6 | REPLY, 11, ++m_nSystemByte);
ASSERT(pMessage);
ISECS2Item* pItem = pMessage->getBody();
- pItem->addU4Item(DATAID, "DATAID");
+ // pItem->addU2Item(++DATAID, "DATAID"); // 鏍规嵁鍒殑鏃ュ織鏄剧ずDATAID鎭掍负0锛屾墍浠ユ垜浠厛鐓т娇鐢�0
+ pItem->addU2Item(0, "DATAID");
pItem->addU4Item(CEID, "CEID");
ISECS2Item* pItemList1 = pItem->addItem();
ISECS2Item* pItemList2 = pItemList1->addItem();
- pItemList2->addU4Item(pEvent->getPortID(), "RPTID");
+ pItemList2->addU4Item(pReport->getReportId(), "RPTID");
ISECS2Item* pItemList3 = pItemList2->addItem();
- for (auto item : values) {
- pItemList3->addItem(item.c_str(), "V");
+
+ auto vars = pReport->getVariables();
+ for (auto var : vars) {
+ addVariableValueToItem(pItemList3, var);
}
pAction->setSendMessage(pMessage);
if (m_pPassive == NULL || STATE::SELECTED != m_pPassive->getState()) {
@@ -1488,5 +2504,99 @@
return ER_NOERROR;
}
+int CHsmsPassive::requestEventReportSend(const char* pszEventName)
+{
+ SERVO::CCollectionEvent* pEvent = nullptr;
+ for (auto e : m_collectionEvents) {
+ if (e->getName().compare(pszEventName) == 0) {
+ pEvent = e;
+ break;
+ }
+ }
+ if (pEvent == nullptr) {
+ return ER_NO_EVENT;
+ }
+ return requestEventReportSend(pEvent->getEventId());
+}
+
+int CHsmsPassive::requestEventReportSend_CarrierID_Readed()
+{
+ return requestEventReportSend("CarrierID_Readed");
+}
+
+int CHsmsPassive::requestEventReportSend_CheckSlotMap()
+{
+ return requestEventReportSend("CheckSlotMap");
+}
+
+int CHsmsPassive::requestEventReportSend_SlotMapVerificationOK()
+{
+ return requestEventReportSend("SlotMapVerificationOK");
+}
+
+int CHsmsPassive::requestEventReportSend_SlotMapVerificationNG()
+{
+ return requestEventReportSend("SlotMapVerificationNG");
+}
+
+int CHsmsPassive::requestEventReportSend_Port_Unload_Ready()
+{
+ return requestEventReportSend("Port_Unload_Ready");
+}
+
+int CHsmsPassive::requestEventReportSend_Port_Load_Ready()
+{
+ return requestEventReportSend("Port_Load_Ready");
+}
+
+int CHsmsPassive::requestEventReportSend_Port_Ready_To_Release()
+{
+ return requestEventReportSend("Port_Ready_To_Release");
+}
+
+int CHsmsPassive::requestEventReportSend_Port_Blocked()
+{
+ return requestEventReportSend("Port_Blocked");
+}
+
+int CHsmsPassive::requestEventReportSend_PJ_Queued()
+{
+ return requestEventReportSend("PJ_Queued");
+}
+
+int CHsmsPassive::requestEventReportSend_PJ_Start()
+{
+ return requestEventReportSend("PJ_Start");
+}
+
+int CHsmsPassive::requestEventReportSend_PJ_End()
+{
+ return requestEventReportSend("PJ_End");
+}
+
+int CHsmsPassive::requestEventReportSend_CJ_Start()
+{
+ return requestEventReportSend("CJ_Start");
+}
+
+int CHsmsPassive::requestEventReportSend_CJ_End()
+{
+ return requestEventReportSend("CJ_End");
+}
+
+int CHsmsPassive::requestEventReportSend_Panel_Start()
+{
+ return requestEventReportSend("Panel_Start");
+}
+
+int CHsmsPassive::requestEventReportSend_Panel_End()
+{
+ return requestEventReportSend("Panel_End");
+}
+
+int CHsmsPassive::requestEventReportSend_OCR_PanelID_Read_OK()
+{
+ return requestEventReportSend("OCR_PanelID_Read_OK");
+}
--
Gitblit v1.9.3