1.继续完善模拟测试等

chenluhua1980

2026-01-08 9c9100b078e9ac4ee7ed61500b4d7c7a74207549

 SourceCode/Bond/Servo/HsmsPassive.cpp

@@ -1,4 +1,4 @@
#include "stdafx.h"
#include "stdafx.h"
#include "HsmsPassive.h"
#include "Log.h"
#include "Model.h"
@@ -8,6 +8,9 @@
#include <time.h>  
#include <stdlib.h>  
#include <string.h>  
#include <algorithm>
#include <set>
#include <regex>


const char ACK[2] = {0, 1};
@@ -47,6 +50,7 @@
   m_listener.onCommand = nullptr;
   m_listener.onEQConstantRequest = nullptr;
   m_listener.onEQConstantSend = nullptr;
   m_pActiveAction = nullptr;
   InitializeCriticalSection(&m_criticalSection);
}

@@ -61,6 +65,10 @@
      delete item;
   }
   m_listActionSent.clear();
   for (auto item : m_listActionSpooling) {
      delete item;
   }
   m_listActionSpooling.clear();
   Unlock();

   if (m_hCimWorkEvent != NULL) {
@@ -97,70 +105,118 @@

}

void CHsmsPassive::addReport(unsigned int id, const char* pszName)
void CHsmsPassive::addVariableValueToItem(ISECS2Item* pParent, SERVO::CVariable* pVariable)
{
   Lock();
   REPORT report;
   report.id = id;
   strcpy_s(report.szName, REPORT_NAME_MAX, pszName);
   m_mapReport[id] = report;
   Unlock();
   ASSERT(pParent);
   ASSERT(pVariable);

   std::string svNote("SV");
   {
      SERVO::CVariable* pDef = getVariable((int)pVariable->getVarialbleId());
      if (pDef == nullptr) {
         pDef = pVariable;
      }
      auto& name = pDef->getName();
      if (!name.empty()) {
         svNote += " -> ";
         svNote += name;
      }
   }

   ISECS2Item* pItemList;
   SERVO::SVFromat format = pVariable->getFormat();
   switch (format)
   {
   case SERVO::SVFromat::U1:
      pParent->addU1Item((unsigned char)pVariable->getIntValue(), svNote.c_str());
      break;
   case SERVO::SVFromat::U2:
      pParent->addU2Item((unsigned char)pVariable->getIntValue(), svNote.c_str());
      break;
   case SERVO::SVFromat::I2:
      pParent->addI2Item((unsigned char)pVariable->getIntValue(), svNote.c_str());
      break;
   case SERVO::SVFromat::A20:
   case SERVO::SVFromat::A50:
      pParent->addItem(pVariable->getValue().c_str(), svNote.c_str());
      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 RPTID, unsigned int CEID)
void CHsmsPassive::linkEventReport(unsigned int CEID, unsigned int RPTID)
{
   m_mapReportIdToCEID[RPTID] = CEID;
   SERVO::CCollectionEvent* pEvent = getEvent(CEID);
   SERVO::CReport* pReport = getReport(RPTID);
   if (pEvent != nullptr) {
      pEvent->setReport(pReport);
   }
}

void CHsmsPassive::unlinkEventReport(unsigned int CEID)
{
   for (auto it = m_mapReportIdToCEID.begin(); it != m_mapReportIdToCEID.end(); ) {
      if (it->second == CEID) {
         m_mapReportIdToCEID.erase(it++);  // 更新迭代器
      }
      else {
         ++it;
      }
   }

}

unsigned int CHsmsPassive::getCEID(int RPTID)
{
   auto iter = m_mapReportIdToCEID.find(RPTID);
   if (iter != m_mapReportIdToCEID.end()) return iter->second;
   return 0;
}

void CHsmsPassive::deleteReport(unsigned int RPTID)
{
   for (auto it = m_mapValueIdToPRTID.begin(); it != m_mapValueIdToPRTID.end(); ) {
      if (it->second == RPTID) {
         m_mapValueIdToPRTID.erase(it++);  // 更新迭代器
      }
      else {
         ++it;
      }
   LOGI("<CHsmsPassive>unlinkEventReport enter");
   SERVO::CCollectionEvent* pEvent = getEvent(CEID);
   if (pEvent != nullptr) {
      pEvent->setReport(nullptr);
      LOGI("<CHsmsPassive>unlink Event Report.CEID=%d", CEID);
   }
}

void CHsmsPassive::deleteAllReport()
bool CHsmsPassive::shouldSpool(uint8_t streamId, uint8_t functionId) const
{
   m_mapValueIdToPRTID.clear();
   // Comment: stream 1 is not spooled
   if (streamId == 1) return false;

   // Comment: m=0 turns off all streams and fns
   if (!m_spoolingEnabled) return false;

   // Blacklist semantics: in map => do NOT spool/cache.
   // Not in map => allow spooling by default.
   auto it = m_spoolBlacklistByStream.find(streamId);
   if (it == m_spoolBlacklistByStream.end()) return true;

   // Empty set => all functions in this stream
   if (it->second.empty()) return true;

   return it->second.find(functionId) == it->second.end();
}

void CHsmsPassive::defineReport(unsigned int VID, unsigned int RPTID)
SERVO::CReport* CHsmsPassive::defineReport(unsigned int RPTID, std::vector<unsigned int>& vids)
{
   m_mapValueIdToPRTID[VID] = RPTID;
   LOGI("<CHsmsPassive>defineReport enter");
   // 添加定义report
   SERVO::CReport* pReport = new SERVO::CReport(RPTID, vids);
   for (auto vid : vids) {
      SERVO::CVariable* pVariable = getVariable(vid);
      if (pVariable != nullptr) {
         pReport->addVariable(pVariable);
         LOGI("<CHsmsPassive>defineReport RPTID=%d", RPTID);
      }
   }
   m_reports.push_back(pReport);
   writeReportsToFile(m_strReportFilepath);

   return pReport;
}

void CHsmsPassive::OnTimer(UINT nTimerid)
{
   // 所有已发送的Action自加1
   // 所有已发送的Action自加1
   Lock();
   for (auto iter = m_listActionSent.begin(); iter != m_listActionSent.end();) {
      if ((*iter)->incrementAndCheckTimeout()) {
         TRACE("CHsmsPassive::超时\n");
         TRACE("CHsmsPassive::超时\n");
         delete (*iter);
         m_listActionSent.erase(iter++);
      }
@@ -173,13 +229,26 @@

int CHsmsPassive::onRecvMsg(IMessage* pMessage)
{
   LOGI("onRecvMsg:%s", pMessage->toString());
   // LOGI("onRecvMsg:%s", pMessage->toString());
   Lock();
   if (m_pActiveAction != nullptr &&
      (m_pActiveAction->getSendMessage()->getHeader()->systemBytes == pMessage->getHeader()->systemBytes)) {
      SetEvent(m_pActiveAction->getEvent());
      LOGI("CHsmsPassive::当前等待有回复");
      TRACE("CHsmsPassive::当前等待有回复\n");
      Unlock();
      return 0;
   }
   Unlock();


   Lock();
   CHsmsAction* pAction = nullptr;
   for (auto iter = m_listActionSent.begin(); iter != m_listActionSent.end(); iter++) {
      if ((*iter)->getSendMessage()->getHeader()->systemBytes == pMessage->getHeader()->systemBytes) {
         LOGI("CHsmsPassive::找到");
         LOGI("CHsmsPassive::找到");
         pAction = (*iter);
         SetEvent(pAction->getEvent());
         m_listActionSent.erase(iter);
         break;
      }
@@ -187,11 +256,966 @@
   Unlock();

   if (pAction != nullptr) {
      LOGI("onRecvMsg::相应处理");
      LOGI("onRecvMsg::相应处理");
      delete pAction;
   }


   return 0;
}

int CHsmsPassive::loadVarialbles(const char* pszFilepath)
{
   m_strVariableFilepath = pszFilepath;
   m_bVariableUtf8 = false;
   m_bVariableUtf8Bom = false;
   // 先读原始字节，后续再按 UTF-8/BOM 或本地编码转换
   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_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;
   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(L",", last);
      if (index < 0) continue;
      strId = strLine.Left(index);
      last = index + 1;

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

      index = strLine.Find(L",", last);
      if (index < 0) continue;
      strFormat = strLine.Mid(last, index - last);
      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::CVariable* pVarialble = new SERVO::CVariable(
         sId.c_str(),
         sName.c_str(),
         sFormat.c_str(),
         sRemark.c_str());
      variables.push_back(pVarialble);
   }

   if (!variables.empty()) {
      clearAllVariabel();
      for (auto item : variables) {
         m_variabels.push_back(item);
      }
   }

   return 0;
}

std::vector<SERVO::CVariable*>& CHsmsPassive::getVariables()
{
   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;
      }
   }

   return nullptr;
}

void CHsmsPassive::clearAllVariabel()
{
   for (auto item : m_variabels) {
      delete item;
   }
   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)
{
   m_strReportFilepath = pszFilepath;
   m_bReportUtf8 = false;
   m_bReportUtf8Bom = false;
   // 兼容 UTF-8/BOM 与本地编码读取
   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_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;
   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(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);
      CString strVariableA(narrowFromW(strVariable).c_str());
      auto vids = parseVidList(strVariableA);

      SERVO::CReport* pReport = new SERVO::CReport(_wtoi(strId), vids);
      for (auto vid : vids) {
         SERVO::CVariable* pVariable = getVariable(vid);
         if (pVariable != nullptr) {
            pReport->addVariable(pVariable);
         }
      }

      reports.push_back(pReport);
   }
	
   if (!reports.empty()) {
      clearAllReport();
      for (auto item : reports) {
         m_reports.push_back(item);
      }
   }
	

   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)
{
   for (auto item : m_reports) {
      if (item->getReportId() == rptid) {
         return item;
      }
   }

   return nullptr;
}

bool CHsmsPassive::removeReport(int rptid)
{
   for (auto iter = m_reports.begin(); iter != m_reports.end(); ++iter) {
      if ((*iter)->getReportId() == rptid) {
         delete (*iter);
         m_reports.erase(iter);
         return true;
      }
   }

   return false;
}

int CHsmsPassive::deleteReport(int rptid)
{
   LOGI("<CHsmsPassive>deleteReport enter");
   if (!removeReport(rptid)) {
      return -1;
   }
   LOGI("<CHsmsPassive>delete Report. rptid=%d", rptid);

   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(BOOL bSave/* = FALSE*/)
{
   LOGI("<CHsmsPassive>clearAllReport enter");
   for (auto item : m_reports) {
      delete item;
   }
   m_reports.clear();

   if(bSave)
      writeReportsToFile(m_strReportFilepath);
}

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

   // 允许 Attached RPTID 为空：()
   std::wregex pattern(L"^\\d+,[^,]*,[^,]*,\\(\\d*(,\\d+)*\\).*");  // 匹配以数字+逗号开头的字符串
   std::vector<SERVO::CCollectionEvent*> events;
   int index, last;
   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(L",", last);
      if (index < 0) continue;
      strId = strLine.Left(index);
      last = index + 1;

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

      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);
      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(
         _wtoi(strId), sName.c_str(), sDesc.c_str(), prtids);
      for (auto rptid : prtids) {
         SERVO::CReport* pReport = getReport(rptid);
         if (pReport != nullptr) {
            pEvent->addReport(pReport);
         }
      }
      events.push_back(pEvent);
   }

   if (!events.empty()) {
      clearAllCollectionEvent();
      for (auto item : events) {
         m_collectionEvents.push_back(item);
      }
   }
   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()
{
   for (auto item : m_collectionEvents) {
      delete item;
   }
   m_collectionEvents.clear();
}

SERVO::CCollectionEvent* CHsmsPassive::getEvent(unsigned short CEID)
{
   for (auto item : m_collectionEvents) {
      if (item->getEventId() == CEID) {
         return item;
      }
   }

   return nullptr;
}

std::vector<unsigned int> CHsmsPassive::parseVidList(CString& strNums)
{
   // 1. 先去掉可能出现的空白符（空格、制表符等）
   strNums.Trim();

   // 2️.
   std::vector<unsigned int> result;
   int i = 0;
   CString strVid;
   while (1) {
      if (!AfxExtractSubString(strVid, (LPCTSTR)strNums, i, ',')) {
         break;
      }
      if (!strVid.IsEmpty())                 // 防御性检查
         result.push_back(std::stoi((LPTSTR)(LPCTSTR)strVid));
      i++;

   }

   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;
}

@@ -205,8 +1229,8 @@
   auto onStatusChanged = [&](void* pFrom, STATE state) -> void {
      m_pModel->notifyInt(RX_CODE_PASSIVE_STATUS_CHANGED, (int)state);

      // 连上之后发S1F1
      // 修改为不主动发送，而是响应
      // 连上之后发S1F1
      // 修改为不主动发送，而是响应
      /*
      if (STATE::SELECTED == state) {
         m_bAreYouThereRequest = FALSE;
@@ -218,18 +1242,18 @@
      */
   };
   auto onRecvSysMessage = [&](void* pFrom, IMessage* pMessage) -> void {
      LOGI("<HSMS>onRecvSysMessage:sessionId:%d, sType:%d systemBytes:%d",
         pMessage->getHeader()->sessionId, pMessage->getHeader()->sType, pMessage->getHeader()->systemBytes);
      LOGI("<HSMS>[Received]sessionId:%d, sType:%d systemBytes:%d",
      pMessage->getHeader()->sessionId, pMessage->getHeader()->sType, pMessage->getHeader()->systemBytes);
      onRecvMsg(pMessage);
      if (MSG_LINKTEST_REQ == pMessage->getHeader()->sType) {
         /*
         Sleep(10);
         if (!m_bAreYouThereRequest) {
            m_bAreYouThereRequest = TRUE;
            requestYouThere();
         }
         */
      /*
      Sleep(10);
      if (!m_bAreYouThereRequest) {
         m_bAreYouThereRequest = TRUE;
         requestYouThere();
      }
      */
}
   };

   auto onError = [&](void* pFrom, int error) -> void {
@@ -245,10 +1269,13 @@
      HEADER* pHeader = pMessage->getHeader();
      int nStream = (pHeader->stream & 0x7F);

      LOGI("<HSMS>收到消息 S%dF%d", nStream, pHeader->function);
      LOGI("<HSMS>[Received]%s", pMessage->toString());
      if (nStream == 1 && pHeader->function == 1) {
         // S1F1
         replyAreYouThere(pMessage);
      }
      else if (nStream == 1 && pHeader->function == 3) {
         replySelectedEquipmentStatusData(pMessage);
      }
      else if (nStream == 1 && pHeader->function == 13) {
         replyEstablishCommunications(pMessage);
@@ -280,14 +1307,29 @@
      else if (nStream == 2 && pHeader->function == 41) {
         replyCommand(pMessage);
      }
      else if (nStream == 2 && pHeader->function == 43) {
         replyConfigureSpooling(pMessage);
      }
      else if (nStream == 3 && pHeader->function == 17) {
         replyCarrierAction(pMessage);
      }
      else if (nStream == 5 && pHeader->function == 3) {
         replyEanbleDisableAlarmReport(pMessage);
      }
      else if (nStream == 6 && pHeader->function == 23) {
         replyPurgeSpooledData(pMessage);
      }
      else if (nStream == 7 && pHeader->function == 19) {
         replyQueryPPIDList(pMessage);
      }
      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);
      }
   };

@@ -299,7 +1341,7 @@
   listener.funError = onError;
   m_pPassive->setListener(listener);

   // 启动工作线程
   // 启动工作线程
   m_bCimWorking = TRUE;
   m_hCimWorkThreadHandle = (HANDLE)_beginthreadex(NULL, 0, ::CimWorkThreadFunction, this,
      0, &m_nCimWorkThrdaddr);
@@ -310,9 +1352,45 @@
   return 0;
}

int CHsmsPassive::loadCacheFromFile(const char* pszFilepath)
{
   m_strCacheFilepath = pszFilepath;

   CFile file;
   if (!file.Open(m_strCacheFilepath.c_str(), CFile::modeRead) ) {
      return -1;
   }

   int nBufSize = file.GetLength();
   char* pszBuffer = new char[nBufSize];
   file.Read(pszBuffer, nBufSize);
   file.Close();
   int nRet = unserialize(pszBuffer, nBufSize);
   delete[] pszBuffer;

   return nRet;
}

int CHsmsPassive::saveCache()
{
   CFile file;
   if (!file.Open(m_strCacheFilepath.c_str(), CFile::modeWrite | CFile::modeCreate)) {
      return -1;
   }

   int nSize = serialize(nullptr, 0);
   char* pszBuffer = new char[nSize];
   int nRet = serialize(pszBuffer, nSize);
   file.Write(pszBuffer, nSize);
   file.Close();
   delete[] pszBuffer;

   return nRet;
}

int CHsmsPassive::term()
{
   // 结束线程
   // 结束线程
   m_bCimWorking = FALSE;
   SetEvent(m_hCimWorkEvent);
   if (m_hCimWorkThreadHandle != NULL) {
@@ -326,60 +1404,234 @@
      m_pPassive = NULL;
   }

   clearAllVariabel();
   clearAllReport();
   clearAllCollectionEvent();

   return 0;
}

int CHsmsPassive::serialize(char* pszBuffer, int nBufferSize)
{
   int index = 0;
   const auto calcSpoolCfgSize = [&]() -> int {
      // magic(4) + ver(2) + enabled(1) + mapSize(4) + entries...
      int sz = 0;
      sz += 4; // 'SPOL'
      sz += 2; // version
      sz += 1; // enabled
      sz += 4; // map size
      for (const auto& kv : m_spoolBlacklistByStream) {
         sz += 2; // streamId (U16)
         sz += 4; // fn count (U32)
         sz += static_cast<int>(kv.second.size()) * 2; // fn ids (U16 each)
      }
      return sz;
   };
   if (pszBuffer == nullptr) {
      index += sizeof(int);
      for (auto item : m_listActionSpooling) {
         index += item->serialize(pszBuffer, nBufferSize);
      }

      index += calcSpoolCfgSize();

      return index;
   }
   else {
      int nTemp, nRet;

      nTemp = (int)m_listActionSpooling.size();
      memcpy(&pszBuffer[index], &nTemp, sizeof(int));
      index += sizeof(int);

      for (auto item : m_listActionSpooling) {
         nRet = item->serialize(&pszBuffer[index], nBufferSize);
         if (nRet <= 0) break;
         index += nRet;
      }

      // Append spooling config (backward compatible via magic+version)
      auto writeU32 = [&](uint32_t v) {
         memcpy(&pszBuffer[index], &v, sizeof(v));
         index += sizeof(v);
      };
      auto writeU16 = [&](uint16_t v) {
         memcpy(&pszBuffer[index], &v, sizeof(v));
         index += sizeof(v);
      };
      auto writeU8 = [&](uint8_t v) {
         memcpy(&pszBuffer[index], &v, sizeof(v));
         index += sizeof(v);
      };

      const uint32_t magic = 0x4C4F5053; // 'SPOL' little-endian
      writeU32(magic);
      writeU16(1); // version
      writeU8(m_spoolingEnabled ? 1 : 0);
      writeU32(static_cast<uint32_t>(m_spoolBlacklistByStream.size()));
      for (const auto& kv : m_spoolBlacklistByStream) {
         writeU16(static_cast<uint16_t>(kv.first));
         writeU32(static_cast<uint32_t>(kv.second.size()));
         for (const auto& fn : kv.second) {
            writeU16(static_cast<uint16_t>(fn));
         }
      }

      return index;
   }
}

int CHsmsPassive::unserialize(const char* pszBuffer, int nBufferSize)
{
   int index = 0, nTemp, nRet = 0;

   if (index + sizeof(int) > nBufferSize) return -1;
   memcpy(&nTemp, &pszBuffer[index], sizeof(int));
   index += sizeof(int);

   for (int i = 0; i < nTemp; i++) {
      CHsmsAction* pAction = new CHsmsAction();
      nRet = pAction->unserialize(&pszBuffer[index], nBufferSize - index);
      if (nRet <= 0) break;
      index += nRet;
      m_listActionSpooling.push_back(pAction);
   }

   // Parse optional spooling config tail (magic+version). If absent, keep defaults.
   const auto remaining = nBufferSize - index;
   if (remaining >= 4) {
      uint32_t magic = 0;
      memcpy(&magic, &pszBuffer[index], sizeof(magic));
      if (magic == 0x4C4F5053) { // 'SPOL'
         index += 4;
         if (nBufferSize - index >= 2 + 1 + 4) {
            uint16_t ver = 0;
            memcpy(&ver, &pszBuffer[index], sizeof(ver));
            index += 2;
            if (ver >= 1) {
               uint8_t enabled = 1;
               memcpy(&enabled, &pszBuffer[index], sizeof(enabled));
               index += 1;
               m_spoolingEnabled = (enabled != 0);

               uint32_t mapSize = 0;
               memcpy(&mapSize, &pszBuffer[index], sizeof(mapSize));
               index += 4;

               m_spoolBlacklistByStream.clear();
               for (uint32_t mi = 0; mi < mapSize; ++mi) {
                  if (nBufferSize - index < 2 + 4) break;
                  uint16_t streamId = 0;
                  memcpy(&streamId, &pszBuffer[index], sizeof(streamId));
                  index += 2;
                  uint32_t fnCount = 0;
                  memcpy(&fnCount, &pszBuffer[index], sizeof(fnCount));
                  index += 4;

                  auto& setRef = m_spoolBlacklistByStream[streamId];
                  setRef.clear();
                  for (uint32_t fi = 0; fi < fnCount; ++fi) {
                     if (nBufferSize - index < 2) break;
                     uint16_t fn = 0;
                     memcpy(&fn, &pszBuffer[index], sizeof(fn));
                     index += 2;
                     setRef.insert(fn);
                  }
               }
            }
         }
      }
   }

   return index;
}

unsigned CHsmsPassive::OnCimWork()
{
   while (m_bCimWorking) {

      // 待退出信号或时间到
      // 待退出信号或时间到
      int nRet = WaitForSingleObject(m_hCimWorkEvent, INFINITE);
      ResetEvent(m_hCimWorkEvent);
      if (!m_bCimWorking) break;

      // 取出请求列表并进行处理
      // 取出请求列表并进行处理
      std::list<CHsmsAction*> list;
      Lock();
      list.splice(list.end(), m_listAction);
      Unlock();

      while (!list.empty()) {
         CHsmsAction* pAction = nullptr;
         Lock();
         CHsmsAction* pAction = list.front();
         pAction = list.front();
         Unlock();
         list.pop_front();

         Lock();
         const bool selected = (m_pPassive != NULL && STATE::SELECTED == m_pPassive->getState());
         Unlock();
         if (!selected) {
            IMessage* pMsg = pAction->getSendMessage();
            uint8_t streamId = 0;
            uint8_t functionId = 0;
            if (pMsg && pMsg->getHeader()) {
               streamId = static_cast<uint8_t>(pMsg->getHeader()->stream & 0x7F);
               functionId = static_cast<uint8_t>(pMsg->getHeader()->function & 0xFF);
            }
            if (shouldSpool(streamId, functionId)) {
               Lock();
               m_listActionSpooling.push_back(pAction);
               Unlock();
            }
            else {
               LOGI("<HSMS>spooling disabled for S%dF%d, drop action", (int)streamId, (int)functionId);
               delete pAction;
            }
            continue;
         }
         TRACE("OnCimWork 004.\n");

         IMessage* pMessage = pAction->getSendMessage();
         ASSERT(pMessage);
         m_pPassive->sendMessage(pMessage);
         LOGI("<HSMS> [SEND] SysByte=%u sessionId:%d", pMessage->getHeader()->systemBytes, pMessage->getHeader()->sessionId);

         if (pAction->isNeedWaitReply()) {
            // 如果需要等待回复
            // 如果需要等待回复
            Lock();
            m_pActiveAction = pAction;
            IMessage* pMessage = pAction->getSendMessage();
            Unlock();

            ASSERT(pMessage);
            m_pPassive->sendMessage(pMessage);
            LOGI("<HSMS>[SEND]SysByte=%u sessionId:%d", pMessage->getHeader()->systemBytes, pMessage->getHeader()->sessionId);
            LOGI("<HSMS>[SEND]%s", pMessage->toString());

            int nRet = WaitForSingleObject(pAction->getEvent(), pAction->getTimeout() * 1000);
            if (nRet == WAIT_TIMEOUT) {
               TRACE("Timeout...\n");
               CContext* pContext = pAction->getContext();
               if (pContext != NULL) {
                  //pContext->setRetCode(CRC_TIMEOUT);
                  //pContext->setRetMsg("超时");
                  //pContext->setRetMsg("超时");
                  //pContext->setEvent();
               }
            }

            delete pAction;
            pAction = NULL;
            TRACE("delete m_pCurrentAction, next...\n");
            Lock();
            delete m_pActiveAction;
            m_pActiveAction = nullptr;
            Unlock();
         }
         else {
            Lock();
            m_listActionSent.push_back(pAction);
            IMessage* pMessage = pAction->getSendMessage();
            Unlock();

            ASSERT(pMessage);
            m_pPassive->sendMessage(pMessage);
            LOGI("<HSMS>[SEND]SysByte=%u sessionId:%d", pMessage->getHeader()->systemBytes, pMessage->getHeader()->sessionId);
            LOGI("<HSMS>[SEND]%s", pMessage->toString());

         }


      }

      TRACE("OnCimWork \n");
@@ -390,7 +1642,7 @@
   return 0;
}

// 通用的reply ack函数
// 通用的reply ack函数
void CHsmsPassive::replyAck(int s, int f, unsigned int systemBytes, BYTE ack, const char* pszAckName)
{
   IMessage* pMessage = NULL;
@@ -399,7 +1651,9 @@
   ISECS2Item* pItem = pMessage->getBody();
   pItem->setBinary((const char*)&ack, 1, pszAckName);
   m_pPassive->sendMessage(pMessage);
   LOGI("<HSMS>[SECS Msg SEND]S%dF%d (SysByte=%u)", s, f, systemBytes);
   LOGI("<HSMS>[SEND]sessionId:%d, sType:%d systemBytes:%d",
      pMessage->getHeader()->sessionId, pMessage->getHeader()->sType, pMessage->getHeader()->systemBytes);
   LOGI("<HSMS>[SEND]%s", pMessage->toString());
   HSMS_Destroy1Message(pMessage);
}

@@ -421,6 +1675,7 @@
   SetEvent(m_hCimWorkEvent);
   Unlock();


   return ER_NOERROR;
}

@@ -439,7 +1694,9 @@
   pItem->addItem(m_strEquipmentModelType.c_str(), "MDLN");
   pItem->addItem(m_strSoftRev.c_str(), "SOFTREV");
   m_pPassive->sendMessage(pMessage);
   LOGI("<HSMS>[SECS Msg SEND]S1F2 (SysByte=%u)", pMessage->getHeader()->systemBytes);
   LOGI("<HSMS>[SEND]sessionId:%d, sType:%d systemBytes:%d",
      pMessage->getHeader()->sessionId, pMessage->getHeader()->sType, pMessage->getHeader()->systemBytes);
   LOGI("<HSMS>[SEND]%s", pMessage->toString());
   HSMS_Destroy1Message(pMessage);

   return 0;
@@ -453,13 +1710,13 @@
   }


   // 交由上层应用来获取机器常量值
   // 交由上层应用来获取机器常量值
   if (m_listener.onEQOffLine != nullptr) {
      m_listener.onEQOffLine(this);
   }


   // 回复
   // 回复
   replyAck(1, 16, pRecv->getHeader()->systemBytes, BYTE(0), "OFLACK");
   return 0;
}
@@ -472,17 +1729,18 @@
   }


   // 交由上层应用来获取机器常量值
   // 交由上层应用来获取机器常量值
   if (m_listener.onEQOnLine != nullptr) {
      m_listener.onEQOnLine(this);
   }


   // 回复
   // 回复
   replyAck(1, 18, pRecv->getHeader()->systemBytes, BYTE(0), "ONLACK");
   return 0;
}

// S1F13
int CHsmsPassive::replyEstablishCommunications(IMessage* pRecv)
{
   if (m_pPassive == NULL || STATE::SELECTED != m_pPassive->getState()) {
@@ -499,8 +1757,54 @@
   pList->addItem(m_strEquipmentModelType.c_str(), "MDLN");
   pList->addItem(m_strSoftRev.c_str(), "SOFTREV");
   m_pPassive->sendMessage(pMessage);
   LOGI("<HSMS>[SECS Msg SEND]%s", pMessage->toString());
   LOGI("<HSMS>[SEND]sessionId:%d, sType:%d systemBytes:%d",
      pMessage->getHeader()->sessionId, pMessage->getHeader()->sType, pMessage->getHeader()->systemBytes);
   LOGI("<HSMS>[SEND]%s", pMessage->toString());
   HSMS_Destroy1Message(pMessage);

   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)) {
      if (!pBody->getSubItemI2(0, (short&)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>[SEND]sessionId:%d, sType:%d systemBytes:%d",
      pMessage->getHeader()->sessionId, pMessage->getHeader()->sType, pMessage->getHeader()->systemBytes);
   LOGI("<HSMS>[SEND]%s", pMessage->toString());
   HSMS_Destroy1Message(pMessage);



   return 0;
}
@@ -513,7 +1817,7 @@
   }


   // 要获取的常量表表
   // 要获取的常量表表
   BOOL bCheckData = FALSE;
   std::vector<EQConstant> eqcs;
   {
@@ -530,13 +1834,13 @@
   }


   // 交由上层应用来获取机器常量值
   // 交由上层应用来获取机器常量值
   if (m_listener.onEQConstantRequest != nullptr) {
      m_listener.onEQConstantRequest(this, eqcs);
   }


   // 回复
   // 回复
   IMessage* pMessage = NULL;
   HSMS_Create1Message(pMessage, m_nSessionId, 1, 14, pRecv->getHeader()->systemBytes);
   ASSERT(pMessage);
@@ -546,7 +1850,9 @@
   }

   m_pPassive->sendMessage(pMessage);
   LOGI("<HSMS>[SECS Msg SEND]S2F14 (SysByte=%u)", pMessage->getHeader()->systemBytes);
   LOGI("<HSMS>[SEND]sessionId:%d, sType:%d systemBytes:%d",
      pMessage->getHeader()->sessionId, pMessage->getHeader()->sType, pMessage->getHeader()->systemBytes);
   LOGI("<HSMS>[SEND]%s", pMessage->toString());
   HSMS_Destroy1Message(pMessage);

   return 0;
@@ -560,7 +1866,7 @@
   }


   // 要设置的常量表表
   // 要设置的常量表表
   BOOL bCheckData = FALSE;
   std::vector<EQConstant> eqcs;
   {
@@ -583,14 +1889,14 @@
   }


   // 交由上层应用来保存和设置机器常量值
   // 交由上层应用来保存和设置机器常量值
   std::vector<unsigned int> ecvs;
   if (m_listener.onEQConstantSend != nullptr) {
      m_listener.onEQConstantSend(this, eqcs);
   }


   // 回复
   // 回复
   replyAck(2, 16, pRecv->getHeader()->systemBytes, BYTE(0), "EACK");
   return 0;
}
@@ -605,7 +1911,7 @@
   if (pBody == nullptr || pBody->getType() != SITYPE::A) ER_PARAM_ERROR;
   const char* pszMessage;
   if (pBody->getString(pszMessage)) {
      // 更新时间
      // 更新时间
      SYSTEMTIME time;
      char szBuffer[20];
      memcpy(szBuffer, pszMessage, 16);
@@ -642,41 +1948,51 @@

   ISECS2Item* pBody = pRecv->getBody();
   ISECS2Item* defineItem, *rptListItem, * vidListItem;
   unsigned int dataId, rptid, vid;
   if (!pBody->getSubItemU4(0, dataId)) goto MYREPLY;
   unsigned short dataId;
   unsigned int rptid, vid;

   if (!pBody->getSubItemU2(0, dataId)) goto MYREPLY;
   rptListItem = pBody->getSubItem(1);
   if (rptListItem == nullptr) goto MYREPLY;
   if (rptListItem->getSubItemSize() == 0) {
      deleteAllReport();
      clearAllReport(TRUE);
      goto MYREPLY;
   }

   for (int i = 0; i < rptListItem->getSubItemSize(); i++) {
      defineItem = rptListItem->getSubItem(i);
      if (defineItem == nullptr) continue;

      std::vector<unsigned int> vids;
      SERVO::CReport* pReport = nullptr;
      vidListItem = defineItem->getSubItem(1);
      if (defineItem->getSubItemU4(0, rptid)
         && vidListItem != nullptr) {
         int vidCount = vidListItem->getSubItemSize();
         if (vidCount == 0) {
            deleteReport(rptid);
         }
         else {
            for (int k = 0; k < vidCount; k++) {
               if (vidListItem->getSubItemU4(k, vid)) {
                  defineReport(vid, rptid);
               }
         for (int k = 0; k < vidListItem->getSubItemSize(); k++) {
            if (vidListItem->getSubItemU4(k, vid)) {
               vids.push_back(vid);
            }
         }
      }

      if (vids.empty()) {
         deleteReport(rptid);
      } else {
         removeReport(rptid);
         pReport = defineReport(rptid, vids);
      }

      // 检验结果是否正确
      if (pReport != nullptr) {
         auto variables = pReport->getVariables();
         for (auto item : variables) {
            LOGE("=== prtid:%d, vid:%d", rptid, item->getVarialbleId());
         }
      }
   }


MYREPLY:
   // 检验结果是否正确
   for (auto item : m_mapValueIdToPRTID) {
      LOGE("=== vid:%d, prtid:%d", item.first, item.second);
   }

   replyAck(2, 34, pRecv->getHeader()->systemBytes, BYTE(0), "DRACK");
   return 0;
}
@@ -691,8 +2007,10 @@

   ISECS2Item* pBody = pRecv->getBody();
   ISECS2Item* linkItem, *ceidListItem, *rptListItem;
   unsigned int dataId, ceid, rptid;
   if (!pBody->getSubItemU4(0, dataId)) goto MYREPLY;
   unsigned short dataId;
   unsigned int ceid, rptid;
   bool bChanged = false;
   if (!pBody->getSubItemU2(0, dataId)) goto MYREPLY;
   ceidListItem = pBody->getSubItem(1);
   if (ceidListItem == nullptr) goto MYREPLY;
   for (int i = 0; i < ceidListItem->getSubItemSize(); i++) {
@@ -704,23 +2022,33 @@
         int prtCount = rptListItem->getSubItemSize();
         if (prtCount == 0) {
            unlinkEventReport(ceid);
            bChanged = true;
         }
         else {
            for (int k = 0; k < prtCount; k++) {
               if (rptListItem->getSubItemU4(k, rptid)) {
                  linkEventReport(rptid, ceid);
                  linkEventReport(ceid, rptid);
                  bChanged = true;
               }
            }
         }
      }
   }


   // 检验结果是否正确
   for (auto item : m_mapReportIdToCEID) {
      LOGE("=== prtid:%d, ceid:%d", item.first, item.second);
   // 持久化到 CollectionEventList.txt（便于下次启动仍保持 Link/Unlink 结果）
   if (bChanged && !m_strCollectionEventFilepath.empty()) {
      writeCollectionEventsToFile(m_strCollectionEventFilepath);
   }

   // 检验结果是否正确
   for (auto item : m_collectionEvents) {
      unsigned int reportId = item->getFirstReportID();
      if(reportId != 0)
         LOGI("=== ceid:%d, prtid:%d", item->getEventId(), reportId);
      else 
         LOGI("=== ceid:%d, prtid:--", item->getEventId());
   }
	
MYREPLY:
   replyAck(2, 36, pRecv->getHeader()->systemBytes, BYTE(0), "LRACK");
   return 0;
@@ -803,7 +2131,7 @@
   }


   // 回调到应用层
   // 回调到应用层
   if (bCheckData) {
      if (m_listener.onCommand != nullptr) {
         m_listener.onCommand(this, pszCmdName, params);
@@ -812,6 +2140,115 @@

MYREPLY:
   replyAck(2, 42, pRecv->getHeader()->systemBytes, BYTE(0), "ERACK");
   return 0;
}

// S2F43
int CHsmsPassive::replyConfigureSpooling(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;

   // 清空所有
   if (pBody->getSubItemSize() == 0) {
      LOGI("<CHsmsPassive>turns off all streams and fns");
      m_spoolBlacklistByStream.clear();
      m_spoolingEnabled = false;
      goto MYREPLY;
   }
   m_spoolingEnabled = true;

   // 依次配置Stream
   for (int i = 0; i < pBody->getSubItemSize(); i++) {
      ISECS2Item* pStreamItem = pBody->getSubItem(i);
      ASSERT(pStreamItem);
      unsigned char STRID, FCNID;
      pStreamItem->getSubItemU1(0, STRID);
      ISECS2Item* pFcnItemList = pStreamItem->getSubItem(1);
      if (pFcnItemList == nullptr || pFcnItemList->getSubItemSize() == 0) {
         // No functions listed => blacklist the whole stream
         m_spoolBlacklistByStream[STRID].clear();
      }
      else {
         // Update blacklist for this stream
         m_spoolBlacklistByStream[STRID].clear();
         for (int j = 0; j < pFcnItemList->getSubItemSize(); j++) {
            pFcnItemList->getSubItemU1(j, FCNID);
            m_spoolBlacklistByStream[STRID].insert(FCNID);
         }
      }
   }

   // 打印验证结果
   for (auto s : m_spoolBlacklistByStream) {
      LOGI("====> spool blacklist stream:%d", s.first);
      if (s.second.empty()) {
         LOGI("blacklist all functions");
      }
      else {
         for (auto f : s.second) {
            LOGI("blacklist function:%d", f);
         }
      }
   }
MYREPLY:
   replyAck(2, 44, pRecv->getHeader()->systemBytes, BYTE(0), "ERACK");
   return 0;
}

// S3F17
int CHsmsPassive::replyCarrierAction(IMessage* pRecv)
{
   if (m_pPassive == NULL || STATE::SELECTED != m_pPassive->getState()) {
      return ER_NOTSELECT;
   }

   unsigned char CAACK = CAACK_0;
   unsigned int ERRCODE = 0;
   std::string strError = "no error";
   if (m_listener.onCarrierAction == nullptr) {
      CAACK = 5;
      ERRCODE = CAACK_5;
      strError = "Not supported";
      goto MYREPLY;
   }


   ISECS2Item* pBody = pRecv->getBody();
   if (pBody == nullptr || pBody->getType() != SITYPE::L) ER_PARAM_ERROR;

   unsigned short DATAID;
   unsigned char PTN;
   const char* pszCarrierAction, *pszCarrierId;
   pBody->getSubItemU2(0, DATAID);
   pBody->getSubItemString(1, pszCarrierAction);
   pBody->getSubItemString(2, pszCarrierId);
   pBody->getSubItemU1(3, PTN);
   ERRCODE = m_listener.onCarrierAction(this,
      DATAID, 
      pszCarrierAction,
      pszCarrierId, 
      PTN,
      strError);
   CAACK = ERRCODE;

   // 回复
MYREPLY:
   IMessage* pMessage = NULL;
   HSMS_Create1Message(pMessage, m_nSessionId, 3, 18, pRecv->getHeader()->systemBytes);
   pMessage->getBody()->addU1Item(CAACK, "CAACK");
   ISECS2Item* pErrItem = pMessage->getBody()->addItem();
   pErrItem->addU4Item(ERRCODE, "ERRCODE");
   pErrItem->addItem(strError.c_str(), "ERRTEXT");
   m_pPassive->sendMessage(pMessage);
   LOGI("<HSMS>[SEND]sessionId:%d, sType:%d systemBytes:%d",
      pMessage->getHeader()->sessionId, pMessage->getHeader()->sType, pMessage->getHeader()->systemBytes);
   LOGI("<HSMS>[SEND]%s", pMessage->toString());
   HSMS_Destroy1Message(pMessage);
	
   return 0;
}

@@ -848,27 +2285,73 @@
   return 0;
}

// S6F23
int CHsmsPassive::replyPurgeSpooledData(IMessage* pRecv)
{
   if (m_pPassive == NULL || STATE::SELECTED != m_pPassive->getState()) {
      return ER_NOTSELECT;
   }
   ISECS2Item* pBody = pRecv->getBody();
   if (pBody == nullptr || pBody->getType() != SITYPE::U1) ER_PARAM_ERROR;
   unsigned char RSDC;      // 0 - transmit; 1 - purge;
   pBody->getU1(RSDC);
   if (RSDC != 0 && RSDC != 1) ER_PARAM_ERROR;
	
   BYTE ACK = 0;      // 0 - ok;   1 - retryable busy;   2 - no spool data;
   if (m_listActionSpooling.empty()) {
      ACK = 2;
   }
   replyAck(6, 24, pRecv->getHeader()->systemBytes, ACK, "RSDA");


   // 丢弃
   if (RSDC == 1) {
      LOGI("<CHsmsPassive>Purge Spooled Data.");
      Lock();
      for (auto item : m_listActionSpooling) {
         delete item;
      }
      m_listActionSpooling.clear();
      Unlock();
   }
   else {
      LOGI("<CHsmsPassive>Request Spooled Data.");
      Lock();
      for (auto item : m_listActionSpooling) {
         m_listAction.push_back(item);
      }
      m_listActionSpooling.clear();
      Unlock();
      SetEvent(m_hCimWorkEvent);
   }

   return 0;
}

// S7F19
int CHsmsPassive::replyQueryPPIDList(IMessage* pRecv)
{
   if (m_pPassive == NULL || STATE::SELECTED != m_pPassive->getState()) {
      return ER_NOTSELECT;
   }

   if (m_listener.onQueryPPIDList == nullptr) {
      return ER_NO_PPID_LIST;
   }

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

   ISECS2Item* pItem = pMessage->getBody();
   pItem->addItem("banana1", "PPID1");
   pItem->addItem("banana2", "PPID2");
   pItem->addF8Item(-123.45, "PPID2");
   pItem->addF4Item(-568.99f, "PPID2");
   pItem->addF8Item(456.456, "PPID2");
   pItem->addF4Item(123.123f, "PPID2");
   auto ppids = m_listener.onQueryPPIDList(this);
   for (auto item : ppids) {
      pItem->addItem(item.c_str(), "PPID");
   }

   m_pPassive->sendMessage(pMessage);
   LOGI("<HSMS>[SECS Msg SEND]S7F20 (SysByte=%u)", pMessage->getHeader()->systemBytes);
   LOGI("<HSMS>[SEND]sessionId:%d, sType:%d systemBytes:%d",
      pMessage->getHeader()->sessionId, pMessage->getHeader()->sType, pMessage->getHeader()->systemBytes);
   LOGI("<HSMS>[SEND]%s", pMessage->toString());
   HSMS_Destroy1Message(pMessage);

   return 0;
@@ -905,19 +2388,259 @@
   return 0;
}

// S5F1
int CHsmsPassive::requestAlarmReport(int ALCD, int ALID, const char* ALTX)
// 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);



   // 解释数据，得到ControlJob
   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) {

      // 类id
      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];

      // 创建类CControlJob
      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>[SEND]sessionId:%d, sType:%d systemBytes:%d",
      pReply->getHeader()->sessionId, pReply->getHeader()->sType, pReply->getHeader()->systemBytes);
   LOGI("<HSMS>[SEND]%s", pReply->toString());
   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;


   // 解释数据，得到CProcessJob
   ISECS2Item* pItemPjs, * pItemPj,* pItemCarriers, * pItemCarrier, *pItemSlots, *pItemRecipes;
   unsigned short 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->getSubItemU2(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);
   }


   // 回复报文
   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>[SEND]sessionId:%d, sType:%d systemBytes:%d",
      pMessage->getHeader()->sessionId, pMessage->getHeader()->sType, pMessage->getHeader()->systemBytes);
   LOGI("<HSMS>[SEND]%s", pMessage->toString());
   HSMS_Destroy1Message(pMessage);


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


   // 释放有问题(未添加到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)
{
   char szALCD[1];
   szALCD[0] = ALCD & 0xff;

   Lock();
   CHsmsAction* pAction = new CHsmsAction(ACTION_ALARM_REPORT, TRUE, m_nActionTimeout);
   m_listAction.push_back(pAction);

   IMessage* pMessage = NULL;
   HSMS_Create1Message(pMessage, m_nSessionId, 5 | REPLY, 1, ++m_nSystemByte);
   ASSERT(pMessage);
@@ -926,43 +2649,196 @@
   pItem->addU4Item(ALID, "ALID");
   pItem->addItem(ALTX, "ALTX");
   pAction->setSendMessage(pMessage);

   SetEvent(m_hCimWorkEvent);
   if (m_pPassive == NULL || STATE::SELECTED != m_pPassive->getState()) {
      if (shouldSpool(5, 1)) {
         m_listActionSpooling.push_back(pAction);
      }
      else {
         LOGI("<HSMS>spooling disabled for S5F1, drop alarm report");
         delete pAction;
      }
   }
   else {
      m_listAction.push_back(pAction);
      SetEvent(m_hCimWorkEvent);
   }
   Unlock();

   return ER_NOERROR;
}

// S6F11
int CHsmsPassive::requestEventReportSend(unsigned int DATAID, unsigned int RPTID, const std::vector<std::string>& values)
static unsigned short DATAID = 0;
int CHsmsPassive::requestEventReportSend(unsigned int CEID)
{
   if (m_pPassive == NULL || STATE::SELECTED != m_pPassive->getState()) {
      return ER_NOTSELECT;
   SERVO::CCollectionEvent* pEvent = getEvent(CEID);
   if (pEvent == nullptr) {
      return ER_NO_EVENT;
   }

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


   Lock();
   CHsmsAction* pAction = new CHsmsAction(ACTION_EVENT_REPORT, TRUE, m_nActionTimeout);
   m_listAction.push_back(pAction);
   IMessage* pMessage = NULL;
   HSMS_Create1Message(pMessage, m_nSessionId, 6 | REPLY, 11, ++m_nSystemByte);
   ASSERT(pMessage);
   ISECS2Item* pItem = pMessage->getBody();
   pItem->addU4Item(DATAID, "DATAID");
   pItem->addU4Item(getCEID(RPTID), "CEID");
   ISECS2Item* pItemList1 = pItem->addItem();
   ISECS2Item* pItemList2 = pItemList1->addItem();
   pItemList2->addU4Item(RPTID, "RPTID");
   ISECS2Item* pItemList3 = pItemList2->addItem();
   for (auto item : values) {
      pItemList3->addItem(item.c_str(), "V");
   // pItem->addU2Item(++DATAID, "DATAID");      // 根据别的日志显示DATAID恒为0，所以我们先照使用0
   pItem->addU2Item(0, "DATAID");
   std::string ceidNote("CEID");
   if (pEvent != nullptr) {
      auto& name = pEvent->getName();
      if (!name.empty()) {
         ceidNote += " -> ";
         ceidNote += name;
      }
   }
   pItem->addU4Item(CEID, ceidNote.c_str());
   ISECS2Item* pItemList1 = pItem->addItem(); // L[n] reports
   if (pReport != nullptr) {
      ISECS2Item* pItemList2 = pItemList1->addItem();
      pItemList2->addU4Item(pReport->getReportId(), "RPTID");
      ISECS2Item* pItemList3 = pItemList2->addItem();

      auto vars = pReport->getVariables();
      for (auto var : vars) {
         addVariableValueToItem(pItemList3, var);
      }
   }
   pAction->setSendMessage(pMessage);

   SetEvent(m_hCimWorkEvent);
   if (m_pPassive == NULL || STATE::SELECTED != m_pPassive->getState()) {
      if (shouldSpool(6, 11)) {
         m_listActionSpooling.push_back(pAction);
      }
      else {
         LOGI("<HSMS>spooling disabled for S6F11, drop event report (CEID=%u)", CEID);
         delete pAction;
      }
   }
   else {
      m_listAction.push_back(pAction);
      SetEvent(m_hCimWorkEvent);
   }
   Unlock();
   
   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");
}

int CHsmsPassive::requestEventReportSend_LoadPortNotAssoc()
{
   return requestEventReportSend("LoadPortNotAssoc");
}

int CHsmsPassive::requestEventReportSend_ProcessDataReport()
{
   return requestEventReportSend("ProcessDataReport");
}

int CHsmsPassive::requestEventReportSend_SubEqpStart()
{
   return requestEventReportSend("SubEqpStart");
}

int CHsmsPassive::requestEventReportSend_SubEqpEnd()
{
   return requestEventReportSend("SubEqpEnd");
}