1.修复： CEID 校验恒通过：ceidDefined 返回 true，PauseEvent ID 不做有效性检查。Host 若下发无效 CEID，...

chenluhua1980

2026-01-15 437d3d047183eed3bbd8eb79e4b40c4a1e0427c9

 SourceCode/Bond/Servo/HsmsPassive.cpp

@@ -14,6 +14,47 @@
#include <regex>
#include <sstream>

// ---- Encoding helpers ----
static bool hasUtf8Bom(const std::string& s)
{
   return s.size() >= 3 &&
      static_cast<unsigned char>(s[0]) == 0xEF &&
      static_cast<unsigned char>(s[1]) == 0xBB &&
      static_cast<unsigned char>(s[2]) == 0xBF;
}

static bool isLikelyUtf8(const std::string& s)
{
   // Simple heuristic: try to convert; if success without errors, treat as UTF-8.
   int wlen = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.c_str(), (int)s.size(), nullptr, 0);
   return wlen > 0;
}

static CStringW Utf8ToWide(const char* psz)
{
   if (psz == nullptr) return L"";
   int wlen = MultiByteToWideChar(CP_UTF8, 0, psz, -1, nullptr, 0);
   if (wlen <= 0) return L"";
   CStringW ws;
   LPWSTR buf = ws.GetBufferSetLength(wlen - 1);
   MultiByteToWideChar(CP_UTF8, 0, psz, -1, buf, wlen);
   ws.ReleaseBuffer();
   return ws;
}

static CStringW AnsiToWide(const char* psz)
{
   if (psz == nullptr) return L"";
   int wlen = MultiByteToWideChar(CP_ACP, 0, psz, -1, nullptr, 0);
   if (wlen <= 0) return L"";
   CStringW ws;
   LPWSTR buf = ws.GetBufferSetLength(wlen - 1);
   MultiByteToWideChar(CP_ACP, 0, psz, -1, buf, wlen);
   ws.ReleaseBuffer();
   return ws;
}
// ---- End helpers ----

// ControlState values (keep in sync with Model::ControlState / VariableList.txt)
static constexpr uint8_t kControlStateOnlineRemote = 5;

@@ -66,8 +107,6 @@
   m_listener.onEQOffLine = nullptr;
   m_listener.onEQOnLine = nullptr;
   m_listener.onCommand = nullptr;
   m_listener.onEQConstantRequest = nullptr;
   m_listener.onEQConstantSend = nullptr;
   m_pActiveAction = nullptr;
   InitializeCriticalSection(&m_criticalSection);
}
@@ -217,6 +256,9 @@
   SERVO::CReport* pReport = new SERVO::CReport(RPTID, vids);
   for (auto vid : vids) {
      SERVO::CVariable* pVariable = getVariable(vid);
      if (pVariable == nullptr) {
         pVariable = getDataVariable(vid);
      }
      if (pVariable != nullptr) {
         pReport->addVariable(pVariable);
         LOGI("<CHsmsPassive>defineReport RPTID=%d", RPTID);
@@ -424,15 +466,222 @@
   return 0;
}

int CHsmsPassive::loadDataVarialbles(const char* pszFilepath)
{
   if (pszFilepath == NULL) {
      return -1;
   }
   m_strDataVariableFilepath = pszFilepath;
   m_bDataVariableUtf8 = false;
   m_bDataVariableUtf8Bom = 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();

   if (hasUtf8Bom(buffer)) {
      m_bDataVariableUtf8 = true;
      m_bDataVariableUtf8Bom = true;
      buffer = buffer.substr(3);
   }
   else if (isLikelyUtf8(buffer)) {
      m_bDataVariableUtf8 = true;
   }
   CStringW content = m_bDataVariableUtf8 ? Utf8ToWide(buffer.c_str()) : AnsiToWide(buffer.c_str());

   // Regex: DVID,DV Name,DV Format,DV Remark
   std::wregex pattern(L"^\\d+,[^,]*,[^,]*,.*");
   std::vector<SERVO::CDataVariable*> dataVars;
   int index;
   CStringW strLine, 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;
      }
      index = strLine.Find(L",", 0);
      if (index < 0) continue;
      strId = strLine.Left(index);

      strLine = strLine.Right(strLine.GetLength() - index - 1);
      index = strLine.Find(L",", 0);
      if (index < 0) continue;
      strName = strLine.Left(index);

      strLine = strLine.Right(strLine.GetLength() - index - 1);
      index = strLine.Find(L",", 0);
      if (index < 0) continue;
      strFormat = strLine.Left(index);

      strRemark = strLine.Right(strLine.GetLength() - index - 1);
      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::CDataVariable* pVarialble = new SERVO::CDataVariable(
         sId.c_str(),
         sName.c_str(),
         sFormat.c_str(),
         sRemark.c_str());
      dataVars.push_back(pVarialble);
   }

   if (!dataVars.empty()) {
      clearAllDataVariabel();
      for (auto item : dataVars) {
         m_dataVariabels.push_back(item);
      }
   }

   return 0;
}

int CHsmsPassive::loadEquipmentConstants(const char* pszFilepath)
{
   if (pszFilepath == NULL) return -1;
   m_strEquipmentConstantFilepath = pszFilepath;
   m_bEquipmentConstantUtf8 = false;
   m_bEquipmentConstantUtf8Bom = 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();

   if (hasUtf8Bom(buffer)) {
      m_bEquipmentConstantUtf8 = true;
      m_bEquipmentConstantUtf8Bom = true;
      buffer = buffer.substr(3);
   }
   else if (isLikelyUtf8(buffer)) {
      m_bEquipmentConstantUtf8 = true;
   }
   CStringW content = m_bEquipmentConstantUtf8 ? Utf8ToWide(buffer.c_str()) : AnsiToWide(buffer.c_str());
   if (content.IsEmpty()) return -1;

   std::wregex pattern(L"^\\d+,[^,]*,[^,]*,([^,]*),.*");
   std::vector<EquipmentConstantEntry> constants;
   CStringW strLine, strId, strName, strFormat, strRemark, strDefault;
   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 (strLine.Find(L"ECID") == 0) continue; // skip header
      if (!std::regex_match(static_cast<LPCWSTR>(strLine), pattern)) {
         continue;
      }
      int last = 0;
      int idx = strLine.Find(L",", last);
      if (idx < 0) continue;
      strId = strLine.Left(idx);
      last = idx + 1;

      idx = strLine.Find(L",", last);
      if (idx < 0) continue;
      strName = strLine.Mid(last, idx - last);
      last = idx + 1;

      idx = strLine.Find(L",", last);
      if (idx < 0) continue;
      strFormat = strLine.Mid(last, idx - last);
      last = idx + 1;

      idx = strLine.Find(L",", last);
      if (idx < 0) continue;
      strRemark = strLine.Mid(last, idx - last);
      last = idx + 1;

      strDefault = strLine.Right(strLine.GetLength() - last);

      EquipmentConstantEntry entry;
      entry.id = _wtoi(strId);
      entry.name = narrowFromW(strName);
      entry.format = narrowFromW(strFormat);
      entry.remark = narrowFromW(strRemark);
      entry.value = narrowFromW(strDefault);
      constants.push_back(entry);
   }

   if (!constants.empty()) {
      m_equipmentConstants = std::move(constants);
   }
   return 0;
}

std::vector<SERVO::CVariable*>& CHsmsPassive::getVariables()
{
   return m_variabels;
}

std::vector<SERVO::CDataVariable*>& CHsmsPassive::getDataVariables()
{
   return m_dataVariabels;
}

unsigned int CHsmsPassive::getMaxVariableId() const
{
   unsigned int maxId = 0;
   for (auto item : m_variabels) {
      if (item && item->getVarialbleId() > maxId) {
         maxId = item->getVarialbleId();
      }
   }
   for (auto item : m_dataVariabels) {
      if (item && item->getVarialbleId() > maxId) {
         maxId = item->getVarialbleId();
      }
   }
   return maxId;
}

unsigned int CHsmsPassive::getMaxDataVariableId() const
{
   unsigned int maxId = 0;
   for (auto item : m_variabels) {
      if (item && item->getVarialbleId() > maxId) {
         maxId = item->getVarialbleId();
      }
   }
   for (auto item : m_dataVariabels) {
      if (item && item->getVarialbleId() > maxId) {
         maxId = item->getVarialbleId();
      }
@@ -458,7 +707,30 @@
         return item;
      }
   }
   // try numeric id string
   if (pszName != nullptr && *pszName) {
      const int id = atoi(pszName);
      if (id > 0) {
         return getVariable(id);
      }
   }

   return nullptr;
}

SERVO::CDataVariable* CHsmsPassive::getDataVariable(int dvid)
{
   for (auto item : m_dataVariabels) {
      if (item->getVarialbleId() == (unsigned int)dvid) return item;
   }
   return nullptr;
}

SERVO::CDataVariable* CHsmsPassive::getDataVariable(const char* pszName)
{
   for (auto item : m_dataVariabels) {
      if (item->getName().compare(pszName) == 0) return item;
   }
   return nullptr;
}

@@ -483,6 +755,14 @@
      delete item;
   }
   m_variabels.clear();
}

void CHsmsPassive::clearAllDataVariabel()
{
   for (auto item : m_dataVariabels) {
      delete item;
   }
   m_dataVariabels.clear();
}

CStringA WideToUtf8(const CStringW& ws)
@@ -545,6 +825,9 @@
   if (auto v = getVariable(pszName)) {
      v->setValue(value);
   }
   else if (auto dv = getDataVariable(pszName)) {
      dv->setValue(value);
   }
   Unlock();
}

@@ -554,6 +837,9 @@
   if (auto v = getVariable(pszName)) {
      v->setValue(value);
   }
   else if (auto dv = getDataVariable(pszName)) {
      dv->setValue(value);
   }
   Unlock();
}

@@ -562,6 +848,9 @@
   Lock();
   if (auto v = getVariable(pszName)) {
      v->setValue(vars);
   }
   else if (auto dv = getDataVariable(pszName)) {
      dv->setValue(vars);
   }
   Unlock();
}
@@ -629,6 +918,75 @@
   return writeVariablesToFile(filepath);
}

int CHsmsPassive::deleteDataVariable(int dvid)
{
   Lock();
   auto it = std::find_if(m_dataVariabels.begin(), m_dataVariabels.end(), [=](SERVO::CDataVariable* v) {
      return v != nullptr && v->getVarialbleId() == (unsigned int)dvid;
      });
   if (it == m_dataVariabels.end()) {
      Unlock();
      return -1;
   }
   delete *it;
   m_dataVariabels.erase(it);
   auto filepath = m_strDataVariableFilepath;
   Unlock();

   if (filepath.empty()) return -2;
   return writeDataVariablesToFile(filepath);
}

int CHsmsPassive::addDataVariable(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_dataVariabels) {
      if (v != nullptr && static_cast<int>(v->getVarialbleId()) > maxId) {
         maxId = static_cast<int>(v->getVarialbleId());
      }
   }
   outId = maxId + 1;

   SERVO::CDataVariable* pNew = new SERVO::CDataVariable(std::to_string(outId).c_str(), pszName, fmt.c_str(), pszRemark ? pszRemark : "");
   m_dataVariabels.push_back(pNew);
   auto filepath = m_strDataVariableFilepath;
   Unlock();

   if (filepath.empty()) return -3;
   return writeDataVariablesToFile(filepath);
}

int CHsmsPassive::updateDataVariable(int dvid, 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_dataVariabels.begin(), m_dataVariabels.end(), [=](SERVO::CDataVariable* v) {
      return v != nullptr && v->getVarialbleId() == (unsigned int)dvid;
      });
   if (it == m_dataVariabels.end()) {
      Unlock();
      return -4;
   }
   (*it)->setName(pszName);
   (*it)->setFormat(fmt.c_str());
   (*it)->setRemark(pszRemark ? pszRemark : "");
   auto filepath = m_strDataVariableFilepath;
   Unlock();

   if (filepath.empty()) return -3;
   return writeDataVariablesToFile(filepath);
}

int CHsmsPassive::writeVariablesToFile(const std::string& filepath)
{
   if (filepath.empty()) return -3;
@@ -675,6 +1033,53 @@
   }
   file.Close();

   return 0;
}

int CHsmsPassive::writeDataVariablesToFile(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;
   }

   const std::string headerAnsi = "DVID,DV Name,DV Format,DV Remark\r\n";
   if (m_bDataVariableUtf8) {
      if (m_bDataVariableUtf8Bom) {
         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_dataVariabels) {
      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_bDataVariableUtf8) {
         CStringA outLine = AnsiToUtf8(lineAnsi);
         file.Write(outLine.GetString(), outLine.GetLength());
      }
      else {
         file.Write(lineAnsi.data(), (UINT)lineAnsi.size());
      }
   }
   file.Close();
   return 0;
}

@@ -790,6 +1195,9 @@
      SERVO::CReport* pReport = new SERVO::CReport(_wtoi(strId), vids);
      for (auto vid : vids) {
         SERVO::CVariable* pVariable = getVariable(vid);
         if (pVariable == nullptr) {
            pVariable = getDataVariable(vid);
         }
         if (pVariable != nullptr) {
            pReport->addVariable(pVariable);
         }
@@ -868,6 +1276,9 @@
   SERVO::CReport* pReport = new SERVO::CReport(rptid, vids);
   for (auto vid : vids) {
      SERVO::CVariable* pVariable = getVariable((int)vid);
      if (pVariable == nullptr) {
         pVariable = getDataVariable((int)vid);
      }
      if (pVariable != nullptr) {
         pReport->addVariable(pVariable);
      }
@@ -884,6 +1295,9 @@
         SERVO::CReport* pReport = new SERVO::CReport(rptid, vids);
         for (auto vid : vids) {
            SERVO::CVariable* pVariable = getVariable((int)vid);
            if (pVariable == nullptr) {
               pVariable = getDataVariable((int)vid);
            }
            if (pVariable != nullptr) {
               pReport->addVariable(pVariable);
            }
@@ -1323,6 +1737,9 @@
      }
      else if (nStream == 1 && pHeader->function == 11) {
         replyStatusVariableNamelistRequest(pMessage);
      }
      else if (nStream == 1 && pHeader->function == 21) {
         replyDataVariableNamelistRequest(pMessage);
      }
      else if (nStream == 1 && pHeader->function == 23) {
         replyCollectionEventNamelistRequest(pMessage);
@@ -1941,6 +2358,109 @@
   return ER_NOERROR;
}

int CHsmsPassive::writeEquipmentConstantsToFile(const std::string& filepath)
{
   if (filepath.empty()) return -1;
   CFile file;
   if (!file.Open(filepath.c_str(), CFile::modeCreate | CFile::modeWrite | CFile::shareDenyNone)) {
      return -1;
   }
   const std::string headerAnsi = "ECID,EC Name,EC Format,EC Remark,Default Value\r\n";
   if (m_bEquipmentConstantUtf8) {
      if (m_bEquipmentConstantUtf8Bom) {
         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 (const auto& e : m_equipmentConstants) {
      std::string line;
      line.reserve(128);
      line += std::to_string(e.id);
      line.push_back(',');
      line += e.name;
      line.push_back(',');
      line += e.format;
      line.push_back(',');
      line += e.remark;
      line.push_back(',');
      line += e.value;
      line.append("\r\n");
      if (m_bEquipmentConstantUtf8) {
         CStringA out = AnsiToUtf8(line);
         file.Write(out.GetString(), out.GetLength());
      }
      else {
         file.Write(line.data(), (UINT)line.size());
      }
   }
   file.Close();
   return 0;
}
// S1F21/S1F22 - Data Variable Namelist
int CHsmsPassive::replyDataVariableNamelistRequest(IMessage* pRecv)
{
   if (m_pPassive == NULL || STATE::SELECTED != m_pPassive->getState()) {
      return ER_NOTSELECT;
   }

   std::vector<unsigned short> reqIds;
   ISECS2Item* pBody = pRecv->getBody();
   if (pBody != nullptr && pBody->getType() == SITYPE::L) {
      const int sz = pBody->getSubItemSize();
      for (int i = 0; i < sz; ++i) {
         unsigned short id = 0;
         if (pBody->getSubItemU2(i, id)) {
            reqIds.push_back(id);
         }
      }
   }

   std::vector<unsigned short> dvids;
   std::set<unsigned short> requested(reqIds.begin(), reqIds.end());
   Lock();
   if (reqIds.empty()) {
      for (auto v : m_dataVariabels) {
         if (v) dvids.push_back(static_cast<unsigned short>(v->getVarialbleId()));
      }
   }
   else {
      for (auto id : requested) dvids.push_back(id);
   }
   Unlock();

   IMessage* pMessage = NULL;
   HSMS_Create1Message(pMessage, m_nSessionId, 1, 22, pRecv->getHeader()->systemBytes);
   ASSERT(pMessage);

   ISECS2Item* pList = pMessage->getBody(); // L[n] of {DVID, DVNAME, UNITS}
   for (auto id : dvids) {
      ISECS2Item* pEntry = pList->addItem();
      pEntry->addU2Item(id, "DVID");
      SERVO::CDataVariable* v = getDataVariable((int)id);
      if (v != nullptr) {
         pEntry->addItem(v->getName().c_str(), "DVNAME");
         pEntry->addItem(v->getRemark().c_str(), "UNITS");
      }
      else {
         pEntry->addItem("", "DVNAME");
         pEntry->addItem("", "UNITS");
      }
   }

   m_pPassive->sendMessage(pMessage);
   LOGI("<HSMS>[SEND]sessionId:%d, sType:%d systemBytes:%d",
      pMessage->getHeader()->sessionId, pMessage->getHeader()->sType, pMessage->getHeader()->systemBytes);
   LogSecsMessageBrief("<HSMS>[SEND]", pMessage);
   HSMS_Destroy1Message(pMessage);

   return ER_NOERROR;
}

// S1F23
int CHsmsPassive::replyCollectionEventNamelistRequest(IMessage* pRecv)
{
@@ -2039,32 +2559,42 @@
   }


   // 要获取的常量表表
   BOOL bCheckData = FALSE;
   std::vector<EQConstant> eqcs;
   {
      ISECS2Item* pItem = pRecv->getBody();
      int ecidSize = pItem->getSubItemSize();
      const int ecidSize = pItem ? pItem->getSubItemSize() : 0;
      for (int i = 0; i < ecidSize; i++) {
         EQConstant eqc;
         unsigned short id;
         if (pItem->getSubItemU2(i, id)) {
         EQConstant eqc{};
         unsigned short id = 0;
         if (pItem && pItem->getSubItemU2(i, id)) {
            eqc.id = id;
            eqcs.push_back(eqc);
         }
      }
   }


   // 交由上层应用来获取机器常量值
   if (m_listener.onEQConstantRequest != nullptr) {
      m_listener.onEQConstantRequest(this, eqcs);
   // 空列表表示请求全部 ECID
   if (eqcs.empty()) {
      for (const auto& e : m_equipmentConstants) {
         EQConstant eqc{};
         eqc.id = e.id;
         strcpy_s(eqc.szValue, EQCONSTANT_VALUE_MAX, e.value.c_str());
         eqcs.push_back(eqc);
      }
   } else {
      for (auto& item : eqcs) {
         auto it = std::find_if(m_equipmentConstants.begin(), m_equipmentConstants.end(),
            [&](const EquipmentConstantEntry& e) { return e.id == item.id; });
         if (it != m_equipmentConstants.end()) {
            strcpy_s(item.szValue, EQCONSTANT_VALUE_MAX, it->value.c_str());
         } else {
            item.szValue[0] = '\0'; // unknown -> empty
         }
      }
   }


   // 回复
   IMessage* pMessage = NULL;
   HSMS_Create1Message(pMessage, m_nSessionId, 1, 14, pRecv->getHeader()->systemBytes);
   HSMS_Create1Message(pMessage, m_nSessionId, 2, 14, pRecv->getHeader()->systemBytes);
   ASSERT(pMessage);
   ISECS2Item* pItem = pMessage->getBody();
   for (auto& item : eqcs) {
@@ -2088,33 +2618,38 @@
   }


   // 要设置的常量表表
   BOOL bCheckData = FALSE;
   // 要设置的常量表
   std::vector<EQConstant> eqcs;
   {
      ISECS2Item* pItem = pRecv->getBody();
      int ecidSize = pItem->getSubItemSize();
      int ecidSize = pItem ? pItem->getSubItemSize() : 0;
      for (int i = 0; i < ecidSize; i++) {
         ISECS2Item* pItemEqc = pItem->getSubItem(i);
         if (pItemEqc != nullptr) {
            EQConstant eqc;
            unsigned short eqcid;
            const char* pszValue;
            if (pItemEqc->getSubItemU2(0, eqcid)
               && pItemEqc->getSubItemString(1, pszValue)) {
               eqc.id = eqcid;
               strcpy_s(eqc.szValue, EQCONSTANT_VALUE_MAX, pszValue);
               eqcs.push_back(eqc);
            }
         ISECS2Item* pItemEqc = pItem ? pItem->getSubItem(i) : nullptr;
         if (pItemEqc == nullptr) continue;
         EQConstant eqc{};
         unsigned short eqcid = 0;
         const char* pszValue = nullptr;
         if (pItemEqc->getSubItemU2(0, eqcid)
            && pItemEqc->getSubItemString(1, pszValue)) {
            eqc.id = eqcid;
            strcpy_s(eqc.szValue, EQCONSTANT_VALUE_MAX, pszValue);
            eqcs.push_back(eqc);
         }
      }
   }


   // 交由上层应用来保存和设置机器常量值
   std::vector<unsigned int> ecvs;
   if (m_listener.onEQConstantSend != nullptr) {
      m_listener.onEQConstantSend(this, eqcs);
   // 更新内存表并落盘
   bool changed = false;
   for (auto& item : eqcs) {
      auto it = std::find_if(m_equipmentConstants.begin(), m_equipmentConstants.end(),
         [&](const EquipmentConstantEntry& e) { return e.id == item.id; });
      if (it != m_equipmentConstants.end()) {
         it->value = item.szValue;
         changed = true;
      }
   }
   if (changed && !m_strEquipmentConstantFilepath.empty()) {
      writeEquipmentConstantsToFile(m_strEquipmentConstantFilepath);
   }


@@ -2870,6 +3405,26 @@


   // 解释数据，得到CProcessJob
   // 容量前置检查：当前实现仅支持单批 PJ 集合，如果已有 PJ/CJ，直接返回 ACKA=false
   if (m_pModel != nullptr && !m_pModel->getMaster().isProcessJobsEmpty()) {
      IMessage* pMessage = NULL;
      HSMS_Create1Message(pMessage, m_nSessionId, 16, 16, ++m_nSystemByte);
      ASSERT(pMessage);
      pMessage->getBody()->addItem(); // PRJOBID list 为空
      ISECS2Item* pItemErrors = pMessage->getBody()->addItem();
      pItemErrors->addBoolItem(false, "ACKA");
      ISECS2Item* pItemErrors2 = pItemErrors->addItem();
      auto err = pItemErrors2->addItem();
      err->addU4Item(1000, "ERRCODE");
      err->addItem("PJobSpace=0 (existing ProcessJob/ControlJob)", "ERRTEXT");
      m_pPassive->sendMessage(pMessage);
      LOGI("<HSMS>[SEND]sessionId:%d, sType:%d systemBytes:%d",
         pMessage->getHeader()->sessionId, pMessage->getHeader()->sType, pMessage->getHeader()->systemBytes);
      LogSecsMessageBrief("<HSMS>[SEND]", pMessage);
      HSMS_Destroy1Message(pMessage);
      return 0;
   }

   ISECS2Item* pItemPjs, * pItemPj,* pItemCarriers, * pItemCarrier, *pItemSlots, *pItemRecipes;
   unsigned short DATAID;
   const char* pszPrjobid, *pszMF, *pszCarrierId, *pszRecipeName;
@@ -2921,7 +3476,11 @@
   }


   // 回复报文
   ASSERT(m_listener.onPRJobMultiCreate != nullptr);
   int nRet = m_listener.onPRJobMultiCreate(this, pjs);


   // 回复报文（在校验/落库后再回复，以便带上真实的 issues）
   IMessage* pMessage = NULL;
   HSMS_Create1Message(pMessage, m_nSessionId, 16, 16, ++m_nSystemByte);
   ASSERT(pMessage);
@@ -2947,15 +3506,15 @@
         }
      }
   }
   else {
      pItemErrors->addBoolItem(true, "ACKA");
      pItemErrors->addItem(); // 空列表
   }
   m_pPassive->sendMessage(pMessage);
   LOGI("<HSMS>[SEND]sessionId:%d, sType:%d systemBytes:%d",
      pMessage->getHeader()->sessionId, pMessage->getHeader()->sType, pMessage->getHeader()->systemBytes);
   LogSecsMessageBrief("<HSMS>[SEND]", pMessage);
   HSMS_Destroy1Message(pMessage);


   ASSERT(m_listener.onPRJobMultiCreate != nullptr);
   int nRet = m_listener.onPRJobMultiCreate(this, pjs);


   // 释放有问题(未添加到master)的内存
@@ -3010,6 +3569,10 @@
   if (pEvent == nullptr) {
      return ER_NO_EVENT;
   }
   // 触发 PauseEvent 检测桩（由 Master 负责实际策略）
   if (m_pModel != nullptr) {
      m_pModel->getMaster().handleCollectionEvent(CEID);
   }

   SERVO::CReport* pReport = pEvent->getFirstReport();