1.增加EV_PROCESS_DATA_REPORT事件（CEID)

chenluhua1980

2026-01-04 2f970f748458c34496445a9a7ae50973f97fb824

 SourceCode/Bond/Servo/HsmsPassive.cpp

@@ -8,6 +8,8 @@
#include <time.h>  
#include <stdlib.h>  
#include <string.h>  
#include <algorithm>
#include <set>
#include <regex>


@@ -103,6 +105,43 @@

}

void CHsmsPassive::addVariableValueToItem(ISECS2Item* pParent, SERVO::CVariable* pVariable)
{
   ASSERT(pParent);
   ASSERT(pVariable);


   ISECS2Item* pItemList;
   SERVO::SVFromat format = pVariable->getFormat();
   switch (format)
   {
   case SERVO::SVFromat::U1:
      pParent->addU1Item((unsigned char)pVariable->getIntValue(), "SV");
      break;
   case SERVO::SVFromat::U2:
      pParent->addU2Item((unsigned char)pVariable->getIntValue(), "SV");
      break;
   case SERVO::SVFromat::I2:
      pParent->addI2Item((unsigned char)pVariable->getIntValue(), "SV");
      break;
   case SERVO::SVFromat::A20:
   case SERVO::SVFromat::A50:
      pParent->addItem(pVariable->getValue().c_str(), "SV");
      break;
   case SERVO::SVFromat::L:
      pItemList = pParent->addItem();
      {
         auto vars = pVariable->getVarsValue();
         for (auto v : vars) {
            addVariableValueToItem(pItemList, &v);
         }
      }
      break;
   default:
      break;
   }
}

void CHsmsPassive::linkEventReport(unsigned int CEID, unsigned int RPTID)
{
   SERVO::CCollectionEvent* pEvent = getEvent(CEID);
@@ -191,40 +230,133 @@

int CHsmsPassive::loadVarialbles(const char* pszFilepath)
{
   CStdioFile file;
   if (!file.Open(pszFilepath, CFile::modeRead)) {
   m_strVariableFilepath = pszFilepath;
   m_bVariableUtf8 = false;
   m_bVariableUtf8Bom = false;
   // 先读原始字节，后续再按 UTF-8/BOM 或本地编码转换
   CFile file;
   if (!file.Open(pszFilepath, CFile::modeRead | CFile::shareDenyNone)) {
      return -1;
   }

   std::regex pattern("^\\d+,.*");  // 匹配以数字+逗号开头的字符串
   const ULONGLONG nLen = file.GetLength();
   if (nLen == 0) {
      return -1;
   }

   std::string buffer;
   buffer.resize(static_cast<size_t>(nLen));
   file.Read(buffer.data(), static_cast<UINT>(nLen));
   file.Close();

   const unsigned char* bytes = reinterpret_cast<const unsigned char*>(buffer.data());
   size_t offset = 0;
   CStringW content;

   // UTF-8 BOM
   if (nLen >= 3 && bytes[0] == 0xEF && bytes[1] == 0xBB && bytes[2] == 0xBF) {
      offset = 3;
      m_bVariableUtf8 = true;
      m_bVariableUtf8Bom = true;
   }

   // UTF-16 LE BOM
   if (nLen >= 2 && bytes[0] == 0xFF && bytes[1] == 0xFE) {
      const wchar_t* wdata = reinterpret_cast<const wchar_t*>(buffer.data() + 2);
      const size_t wlen = (nLen - 2) / sizeof(wchar_t);
      content.SetString(wdata, static_cast<int>(wlen));
   }
   // UTF-16 BE BOM
   else if (nLen >= 2 && bytes[0] == 0xFE && bytes[1] == 0xFF) {
      const size_t wlen = (nLen - 2) / sizeof(wchar_t);
      std::wstring temp;
      temp.reserve(wlen);
      for (size_t i = 0; i < wlen; ++i) {
         wchar_t ch = static_cast<wchar_t>(bytes[2 + i * 2] << 8 | bytes[2 + i * 2 + 1]);
         temp.push_back(ch);
      }
      content = temp.c_str();
   }
   // 尝试 UTF-8（含无 BOM）
   else {
      auto tryUtf8 = [&](size_t off) -> bool {
         int need = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, buffer.data() + off,
            static_cast<int>(buffer.size() - off), nullptr, 0);
         if (need <= 0) return false;
         std::wstring temp;
         temp.resize(need);
         MultiByteToWideChar(CP_UTF8, 0, buffer.data() + off,
            static_cast<int>(buffer.size() - off), temp.data(), need);
         content = temp.c_str();
         m_bVariableUtf8 = true;
         return true;
      };

      if (!tryUtf8(offset)) {
         // 回退到本地代码页
         int need = MultiByteToWideChar(CP_ACP, 0, buffer.data(), static_cast<int>(buffer.size()), nullptr, 0);
         if (need > 0) {
            std::wstring temp;
            temp.resize(need);
            MultiByteToWideChar(CP_ACP, 0, buffer.data(), static_cast<int>(buffer.size()), temp.data(), need);
            content = temp.c_str();
         }
      }
   }

   if (content.IsEmpty()) {
      return -1;
   }

   std::wregex pattern(L"^\\d+,.+");  // 匹配以数字+逗号开头的字符串
   std::vector<SERVO::CVariable*> variables;
   int index, last;
   CString strLine;
   CString strId, strName, strFormat, strRemark;
   while (file.ReadString(strLine)) {
      if (!std::regex_match((LPTSTR)(LPCTSTR)strLine, pattern)) {
   CStringW strLine;
   CStringW strId, strName, strFormat, strRemark;
   std::wstringstream ss(content.GetString());
   auto narrowFromW = [](const CStringW& s) -> std::string {
      int need = WideCharToMultiByte(CP_ACP, 0, s, -1, nullptr, 0, nullptr, nullptr);
      if (need <= 0) return {};
      std::string out(static_cast<size_t>(need - 1), '\0');
      WideCharToMultiByte(CP_ACP, 0, s, -1, out.data(), need, nullptr, nullptr);
      return out;
   };
   std::wstring line;
   while (std::getline(ss, line, L'\n')) {
      strLine = line.c_str();
      strLine.Trim();
      if (strLine.IsEmpty()) continue;
      if (!std::regex_match(static_cast<LPCWSTR>(strLine), pattern)) {
         continue;
      }

      last = 0;
      index = strLine.Find(",", last);
      index = strLine.Find(L",", last);
      if (index < 0) continue;
      strId = strLine.Left(index);
      last = index + 1;

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

      index = strLine.Find(",", last);
      index = strLine.Find(L",", last);
      if (index < 0) continue;
      strFormat = strLine.Mid(last, index - last);
      strRemark = strLine.Right(strLine.GetLength() - index - 1);
      strRemark.Replace(_T("\\r\\n"), _T("\r\n"));
      strRemark.Replace(L"\\r\\n", L"\r\n");

      std::string sId = narrowFromW(strId);
      std::string sName = narrowFromW(strName);
      std::string sFormat = narrowFromW(strFormat);
      std::string sRemark = narrowFromW(strRemark);

      SERVO::CVariable* pVarialble = new SERVO::CVariable(
         (LPTSTR)(LPCTSTR)strId, (LPTSTR)(LPCTSTR)strName, (LPTSTR)(LPCTSTR)strFormat, (LPTSTR)(LPCTSTR)strRemark);
         sId.c_str(),
         sName.c_str(),
         sFormat.c_str(),
         sRemark.c_str());
      variables.push_back(pVarialble);
   }

@@ -235,8 +367,6 @@
      }
   }


   file.Close();
   return 0;
}

@@ -245,10 +375,32 @@
   return m_variabels;
}

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

SERVO::CVariable* CHsmsPassive::getVariable(int variableId)
{
   for (auto item : m_variabels) {
      if (item->getVarialbleId() == variableId) {
         return item;
      }
   }

   return nullptr;
}

SERVO::CVariable* CHsmsPassive::getVariable(const char* pszName)
{
   for (auto item : m_variabels) {
      if (item->getName().compare(pszName) == 0) {
         return item;
      }
   }
@@ -264,32 +416,298 @@
   m_variabels.clear();
}

CStringA WideToUtf8(const CStringW& ws)
{
   int need = WideCharToMultiByte(CP_UTF8, 0, ws, -1, nullptr, 0, nullptr, nullptr);
   if (need <= 0) return "";
   CStringA out;
   LPSTR buf = out.GetBufferSetLength(need - 1);
   WideCharToMultiByte(CP_UTF8, 0, ws, -1, buf, need, nullptr, nullptr);
   out.ReleaseBuffer();
   return out;
}

CStringA WideToAnsi(const CStringW& ws)
{
   int need = WideCharToMultiByte(CP_ACP, 0, ws, -1, nullptr, 0, nullptr, nullptr);
   if (need <= 0) return "";
   CStringA out;
   LPSTR buf = out.GetBufferSetLength(need - 1);
   WideCharToMultiByte(CP_ACP, 0, ws, -1, buf, need, nullptr, nullptr);
   out.ReleaseBuffer();
   return out;
}

static CStringA AnsiToUtf8(const std::string& s)
{
   int wlen = MultiByteToWideChar(CP_ACP, 0, s.c_str(), -1, nullptr, 0);
   if (wlen <= 0) return "";
   CStringW ws;
   LPWSTR wbuf = ws.GetBufferSetLength(wlen - 1);
   MultiByteToWideChar(CP_ACP, 0, s.c_str(), -1, wbuf, wlen);
   ws.ReleaseBuffer();
   return WideToUtf8(ws);
}

int CHsmsPassive::deleteVariable(int variableId)
{
   Lock();
   auto it = std::find_if(m_variabels.begin(), m_variabels.end(), [=](SERVO::CVariable* v) {
      return v != nullptr && v->getVarialbleId() == variableId;
      });
   if (it == m_variabels.end()) {
      Unlock();
      return -1;
   }
   delete *it;
   m_variabels.erase(it);
   auto filepath = m_strVariableFilepath;
   Unlock();

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

   return writeVariablesToFile(filepath);
}

void CHsmsPassive::setVariableValue(const char* pszName, __int64 value)
{
   auto v = getVariable(pszName);
   if (v != nullptr) {
      v->setValue(value);
   }
}

void CHsmsPassive::setVariableValue(const char* pszName, const char* value)
{
   auto v = getVariable(pszName);
   if (v != nullptr) {
      v->setValue(value);
   }
}

void CHsmsPassive::setVariableValue(const char* pszName, std::vector<SERVO::CVariable>& vars)
{
   auto v = getVariable(pszName);
   if (v != nullptr) {
      v->setValue(vars);
   }
}

static bool isValidFormat(const std::string& fmt)
{
   static const std::set<std::string> allow = { "U1","U2","I2","A20","A50","L" };
   return allow.count(fmt) > 0;
}

int CHsmsPassive::addVariable(const char* pszName, const char* pszFormat, const char* pszRemark, int& outId)
{
   if (pszName == nullptr || pszFormat == nullptr) return -1;
   std::string fmt = pszFormat;
   std::transform(fmt.begin(), fmt.end(), fmt.begin(), ::toupper);
   if (!isValidFormat(fmt)) return -2;

   Lock();
   int maxId = 0;
   for (auto v : m_variabels) {
      if (v != nullptr && v->getVarialbleId() > maxId) {
         maxId = v->getVarialbleId();
      }
   }
   outId = maxId + 1;

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

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

int CHsmsPassive::updateVariable(int variableId, const char* pszName, const char* pszFormat, const char* pszRemark)
{
   if (pszName == nullptr || pszFormat == nullptr) return -1;
   std::string fmt = pszFormat;
   std::transform(fmt.begin(), fmt.end(), fmt.begin(), ::toupper);
   if (!isValidFormat(fmt)) return -2;

   Lock();
   auto it = std::find_if(m_variabels.begin(), m_variabels.end(), [=](SERVO::CVariable* v) {
      return v != nullptr && v->getVarialbleId() == variableId;
      });
   if (it == m_variabels.end()) {
      Unlock();
      return -4;
   }
   (*it)->setName(pszName);
   (*it)->setFormat(fmt.c_str());
   (*it)->setRemark(pszRemark ? pszRemark : "");
   auto filepath = m_strVariableFilepath;
   Unlock();

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

int CHsmsPassive::writeVariablesToFile(const std::string& filepath)
{
   if (filepath.empty()) return -3;

   CFile file;
   if (!file.Open(filepath.c_str(), CFile::modeCreate | CFile::modeWrite | CFile::shareDenyNone)) {
      return -3;
   }

   // header
   const std::string headerAnsi = "SVID,SV Name,SV Format,SV Remark\r\n";
   if (m_bVariableUtf8) {
      if (m_bVariableUtf8Bom) {
         const BYTE bom[3] = { 0xEF, 0xBB, 0xBF };
         file.Write(bom, 3);
      }
      CStringA header = AnsiToUtf8(headerAnsi);
      file.Write(header.GetString(), header.GetLength());
   }
   else {
      file.Write(headerAnsi.data(), (UINT)headerAnsi.size());
   }

   for (auto v : m_variabels) {
      if (v == nullptr) continue;
      std::string lineAnsi;
      lineAnsi.reserve(256);
      lineAnsi += std::to_string(v->getVarialbleId());
      lineAnsi.push_back(',');
      lineAnsi += v->getName();
      lineAnsi.push_back(',');
      lineAnsi += SERVO::CVariable::formatToString(v->getFormat());
      lineAnsi.push_back(',');
      lineAnsi += v->getRemark();
      lineAnsi.append("\r\n");

      if (m_bVariableUtf8) {
         CStringA outLine = AnsiToUtf8(lineAnsi);
         file.Write(outLine.GetString(), outLine.GetLength());
      }
      else {
         file.Write(lineAnsi.data(), (UINT)lineAnsi.size());
      }
   }
   file.Close();

   return 0;
}

int CHsmsPassive::loadReports(const char* pszFilepath)
{
   CStdioFile file;
   if (!file.Open(pszFilepath, CFile::modeRead)) {
   m_strReportFilepath = pszFilepath;
   m_bReportUtf8 = false;
   m_bReportUtf8Bom = false;
   // 兼容 UTF-8/BOM 与本地编码读取
   CFile file;
   if (!file.Open(pszFilepath, CFile::modeRead | CFile::shareDenyNone)) {
      return -1;
   }

   std::regex pattern("^\\d+,\\(\\d+(,\\d+)*\\).*");  // 匹配以数字+逗号开头的字符串
   const ULONGLONG nLen = file.GetLength();
   if (nLen == 0) {
      return -1;
   }

   std::string buffer;
   buffer.resize(static_cast<size_t>(nLen));
   file.Read(buffer.data(), static_cast<UINT>(nLen));
   file.Close();

   const unsigned char* bytes = reinterpret_cast<const unsigned char*>(buffer.data());
   size_t offset = 0;
   CStringW content;

   // UTF-8 BOM
   if (nLen >= 3 && bytes[0] == 0xEF && bytes[1] == 0xBB && bytes[2] == 0xBF) {
      offset = 3;
      m_bReportUtf8 = true;
      m_bReportUtf8Bom = true;
   }

   // UTF-16 LE BOM
   if (nLen >= 2 && bytes[0] == 0xFF && bytes[1] == 0xFE) {
      const wchar_t* wdata = reinterpret_cast<const wchar_t*>(buffer.data() + 2);
      const size_t wlen = (nLen - 2) / sizeof(wchar_t);
      content.SetString(wdata, static_cast<int>(wlen));
   }
   // UTF-16 BE BOM
   else if (nLen >= 2 && bytes[0] == 0xFE && bytes[1] == 0xFF) {
      const size_t wlen = (nLen - 2) / sizeof(wchar_t);
      std::wstring temp;
      temp.reserve(wlen);
      for (size_t i = 0; i < wlen; ++i) {
         wchar_t ch = static_cast<wchar_t>(bytes[2 + i * 2] << 8 | bytes[2 + i * 2 + 1]);
         temp.push_back(ch);
      }
      content = temp.c_str();
   }
   else {
      auto tryUtf8 = [&](size_t off) -> bool {
         int need = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, buffer.data() + off,
            static_cast<int>(buffer.size() - off), nullptr, 0);
         if (need <= 0) return false;
         std::wstring temp;
         temp.resize(need);
         MultiByteToWideChar(CP_UTF8, 0, buffer.data() + off,
            static_cast<int>(buffer.size() - off), temp.data(), need);
         content = temp.c_str();
         m_bReportUtf8 = true;
         return true;
      };

      if (!tryUtf8(offset)) {
         int need = MultiByteToWideChar(CP_ACP, 0, buffer.data(), static_cast<int>(buffer.size()), nullptr, 0);
         if (need > 0) {
            std::wstring temp;
            temp.resize(need);
            MultiByteToWideChar(CP_ACP, 0, buffer.data(), static_cast<int>(buffer.size()), temp.data(), need);
            content = temp.c_str();
         }
      }
   }

   if (content.IsEmpty()) {
      return -1;
   }

   std::wregex pattern(L"^\\d+,\\(\\d+(,\\d+)*\\).*");  // 匹配以数字+逗号开头的字符串
   std::vector<SERVO::CReport*> reports;
   int index;
   CString strLine, strVariable;
   CString strId;
   while (file.ReadString(strLine)) {
      if (!std::regex_match((LPTSTR)(LPCTSTR)strLine, pattern)) {
   CStringW strLine, strVariable;
   CStringW strId;
   std::wstringstream ss(content.GetString());
   auto narrowFromW = [](const CStringW& s) -> std::string {
      int need = WideCharToMultiByte(CP_ACP, 0, s, -1, nullptr, 0, nullptr, nullptr);
      if (need <= 0) return {};
      std::string out(static_cast<size_t>(need - 1), '\0');
      WideCharToMultiByte(CP_ACP, 0, s, -1, out.data(), need, nullptr, nullptr);
      return out;
   };
   std::wstring line;
   while (std::getline(ss, line, L'\n')) {
      strLine = line.c_str();
      strLine.Trim();
      if (strLine.IsEmpty()) continue;
      if (!std::regex_match(static_cast<LPCWSTR>(strLine), pattern)) {
         continue;
      }

      index = strLine.Find(",", 0);
      index = strLine.Find(L",", 0);
      if (index < 0) continue;
      strId = strLine.Left(index);
      strVariable = strLine.Right(strLine.GetLength() - index - 1);
      strVariable.Delete(0);
      strVariable.Delete(strVariable.GetLength() - 1);
      auto vids = parseVidList(strVariable);
      CString strVariableA(narrowFromW(strVariable).c_str());
      auto vids = parseVidList(strVariableA);

      SERVO::CReport* pReport = new SERVO::CReport(atoi((LPTSTR)(LPCTSTR)strId), vids);
      SERVO::CReport* pReport = new SERVO::CReport(_wtoi(strId), vids);
      for (auto vid : vids) {
         SERVO::CVariable* pVariable = getVariable(vid);
         if (pVariable != nullptr) {
@@ -308,13 +726,23 @@
   }
   

   file.Close();
   return 0;
}

std::vector<SERVO::CReport*>& CHsmsPassive::getReports()
{
   return m_reports;
}

unsigned int CHsmsPassive::getMaxReportId() const
{
   unsigned int maxId = 0;
   for (auto item : m_reports) {
      if (item && item->getReportId() > maxId) {
         maxId = item->getReportId();
      }
   }
   return maxId;
}

SERVO::CReport* CHsmsPassive::getReport(int rptid)
@@ -341,6 +769,49 @@
   return false;
}

int CHsmsPassive::deleteReport(int rptid)
{
   if (!removeReport(rptid)) {
      return -1;
   }
   return writeReportsToFile(m_strReportFilepath);
}

int CHsmsPassive::addReport(int rptid, const std::vector<unsigned int>& vids)
{
   if (getReport(rptid) != nullptr) {
      return -1;
   }
   SERVO::CReport* pReport = new SERVO::CReport(rptid, vids);
   for (auto vid : vids) {
      SERVO::CVariable* pVariable = getVariable((int)vid);
      if (pVariable != nullptr) {
         pReport->addVariable(pVariable);
      }
   }
   m_reports.push_back(pReport);
   return writeReportsToFile(m_strReportFilepath);
}

int CHsmsPassive::updateReport(int rptid, const std::vector<unsigned int>& vids)
{
   for (auto iter = m_reports.begin(); iter != m_reports.end(); ++iter) {
      if ((*iter)->getReportId() == rptid) {
         delete (*iter);
         SERVO::CReport* pReport = new SERVO::CReport(rptid, vids);
         for (auto vid : vids) {
            SERVO::CVariable* pVariable = getVariable((int)vid);
            if (pVariable != nullptr) {
               pReport->addVariable(pVariable);
            }
         }
         *iter = pReport;
         return writeReportsToFile(m_strReportFilepath);
      }
   }
   return -1;
}

void CHsmsPassive::clearAllReport()
{
   for (auto item : m_reports) {
@@ -349,44 +820,183 @@
   m_reports.clear();
}

int CHsmsPassive::loadCollectionEvents(const char* pszFilepath)
int CHsmsPassive::writeReportsToFile(const std::string& filepath)
{
   CStdioFile file;
   if (!file.Open(pszFilepath, CFile::modeRead)) {
   if (filepath.empty()) return -1;

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

   std::regex pattern("^\\d+,[^,]*,[^,]*,\\(\\d+(,\\d+)*\\).*");  // 匹配以数字+逗号开头的字符串
   if (m_bReportUtf8 && m_bReportUtf8Bom) {
      const BYTE bom[3] = { 0xEF, 0xBB, 0xBF };
      file.Write(bom, 3);
   }

   // header
   const std::string headerAnsi = "RPTID,(VID1,VID2,...)\r\n";	
   if (m_bReportUtf8) {
      CStringA header = AnsiToUtf8(headerAnsi);
      file.Write(header.GetString(), header.GetLength());
   }
   else {
      file.Write(headerAnsi.data(), (UINT)headerAnsi.size());
   }

   for (auto rpt : m_reports) {
      if (rpt == nullptr) continue;
      std::string line;
      line.reserve(64);
      line += std::to_string(rpt->getReportId());
      line += ",(";

      const auto& vids = rpt->getVids();
      for (size_t i = 0; i < vids.size(); ++i) {
         line += std::to_string(vids[i]);
         if (i + 1 < vids.size()) {
            line.push_back(',');
         }
      }
      line += ")\r\n";

      if (m_bReportUtf8) {
         CStringA out = AnsiToUtf8(line);
         file.Write(out.GetString(), out.GetLength());
      }
      else {
         file.Write(line.data(), (UINT)line.size());
      }
   }

   file.Close();
   return 0;
}

int CHsmsPassive::loadCollectionEvents(const char* pszFilepath)
{
   m_strCollectionEventFilepath = pszFilepath;
   m_bCollectionUtf8 = false;
   m_bCollectionUtf8Bom = false;
   CFile file;
   if (!file.Open(pszFilepath, CFile::modeRead | CFile::shareDenyNone)) {
      return -1;
   }

   const ULONGLONG nLen = file.GetLength();
   if (nLen == 0) {
      return -1;
   }

   std::string buffer;
   buffer.resize(static_cast<size_t>(nLen));
   file.Read(buffer.data(), static_cast<UINT>(nLen));
   file.Close();

   const unsigned char* bytes = reinterpret_cast<const unsigned char*>(buffer.data());
   size_t offset = 0;
   CStringW content;

   // UTF-8 BOM
   if (nLen >= 3 && bytes[0] == 0xEF && bytes[1] == 0xBB && bytes[2] == 0xBF) {
      offset = 3;
      m_bCollectionUtf8 = true;
      m_bCollectionUtf8Bom = true;
   }

   // UTF-16 LE BOM
   if (nLen >= 2 && bytes[0] == 0xFF && bytes[1] == 0xFE) {
      const wchar_t* wdata = reinterpret_cast<const wchar_t*>(buffer.data() + 2);
      const size_t wlen = (nLen - 2) / sizeof(wchar_t);
      content.SetString(wdata, static_cast<int>(wlen));
   }
   // UTF-16 BE BOM
   else if (nLen >= 2 && bytes[0] == 0xFE && bytes[1] == 0xFF) {
      const size_t wlen = (nLen - 2) / sizeof(wchar_t);
      std::wstring temp;
      temp.reserve(wlen);
      for (size_t i = 0; i < wlen; ++i) {
         wchar_t ch = static_cast<wchar_t>(bytes[2 + i * 2] << 8 | bytes[2 + i * 2 + 1]);
         temp.push_back(ch);
      }
      content = temp.c_str();
   }
   else {
      auto tryUtf8 = [&](size_t off) -> bool {
         int need = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, buffer.data() + off,
            static_cast<int>(buffer.size() - off), nullptr, 0);
         if (need <= 0) return false;
         std::wstring temp;
         temp.resize(need);
         MultiByteToWideChar(CP_UTF8, 0, buffer.data() + off,
            static_cast<int>(buffer.size() - off), temp.data(), need);
         content = temp.c_str();
         m_bCollectionUtf8 = true;
         return true;
      };

      if (!tryUtf8(offset)) {
         int need = MultiByteToWideChar(CP_ACP, 0, buffer.data(), static_cast<int>(buffer.size()), nullptr, 0);
         if (need > 0) {
            std::wstring temp;
            temp.resize(need);
            MultiByteToWideChar(CP_ACP, 0, buffer.data(), static_cast<int>(buffer.size()), temp.data(), need);
            content = temp.c_str();
         }
      }
   }

   if (content.IsEmpty()) {
      return -1;
   }

   std::wregex pattern(L"^\\d+,[^,]*,[^,]*,\\(\\d+(,\\d+)*\\).*");  // 匹配以数字+逗号开头的字符串
   std::vector<SERVO::CCollectionEvent*> events;
   int index, last;
   CString strLine, strRPTIDs;
   CString strId, strName, strDescription;
   while (file.ReadString(strLine)) {
      if (!std::regex_match((LPTSTR)(LPCTSTR)strLine, pattern)) {
   CStringW strLine, strRPTIDs;
   CStringW strId, strName, strDescription;
   std::wstringstream ss(content.GetString());
   auto narrowFromW = [](const CStringW& s) -> std::string {
      int need = WideCharToMultiByte(CP_ACP, 0, s, -1, nullptr, 0, nullptr, nullptr);
      if (need <= 0) return {};
      std::string out(static_cast<size_t>(need - 1), '\0');
      WideCharToMultiByte(CP_ACP, 0, s, -1, out.data(), need, nullptr, nullptr);
      return out;
   };
   std::wstring line;
   while (std::getline(ss, line, L'\n')) {
      strLine = line.c_str();
      strLine.Trim();
      if (strLine.IsEmpty()) continue;
      if (!std::regex_match(static_cast<LPCWSTR>(strLine), pattern)) {
         continue;
      }

      last = 0;
      index = strLine.Find(",", last);
      index = strLine.Find(L",", last);
      if (index < 0) continue;
      strId = strLine.Left(index);
      last = index + 1;

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

      index = strLine.Find(",", last);
      index = strLine.Find(L",", last);
      if (index < 0) continue;
      strDescription = strLine.Mid(last, index - last);
      strRPTIDs = strLine.Right(strLine.GetLength() - index - 1);
      strRPTIDs.Delete(0);
      strRPTIDs.Delete(strRPTIDs.GetLength() - 1);
      auto prtids = parseVidList(strRPTIDs);
      CString strRPTIDsA(narrowFromW(strRPTIDs).c_str());
      auto prtids = parseVidList(strRPTIDsA);

      std::string sName = narrowFromW(strName);
      std::string sDesc = narrowFromW(strDescription);

      SERVO::CCollectionEvent* pEvent = new SERVO::CCollectionEvent(
         atoi(strId), (LPTSTR)(LPCTSTR)strName, (LPTSTR)(LPCTSTR)strDescription, prtids);
         _wtoi(strId), sName.c_str(), sDesc.c_str(), prtids);
      for (auto rptid : prtids) {
         SERVO::CReport* pReport = getReport(rptid);
         if (pReport != nullptr) {
@@ -402,15 +1012,70 @@
         m_collectionEvents.push_back(item);
      }
   }


   file.Close();
   return 0;
}

std::vector<SERVO::CCollectionEvent*>& CHsmsPassive::getCollectionEvents()
{
   return m_collectionEvents;
}

unsigned int CHsmsPassive::getMaxCollectionEventId() const
{
   unsigned int maxId = 0;
   for (auto item : m_collectionEvents) {
      if (item && item->getEventId() > maxId) {
         maxId = item->getEventId();
      }
   }
   return maxId;
}

int CHsmsPassive::deleteCollectionEvent(unsigned short CEID)
{
   for (auto iter = m_collectionEvents.begin(); iter != m_collectionEvents.end(); ++iter) {
      if ((*iter)->getEventId() == CEID) {
         delete (*iter);
         m_collectionEvents.erase(iter);
         return writeCollectionEventsToFile(m_strCollectionEventFilepath);
      }
   }
   return -1;
}

int CHsmsPassive::addCollectionEvent(unsigned int CEID, const char* name, const char* desc, const std::vector<unsigned int>& rptids)
{
   if (getEvent((unsigned short)CEID) != nullptr) {
      return -1;
   }
   auto* pEvent = new SERVO::CCollectionEvent(CEID, name, desc, const_cast<std::vector<unsigned int>&>(rptids));
   for (auto rptid : rptids) {
      SERVO::CReport* pReport = getReport((int)rptid);
      if (pReport != nullptr) {
         pEvent->addReport(pReport);
      }
   }
   m_collectionEvents.push_back(pEvent);
   return writeCollectionEventsToFile(m_strCollectionEventFilepath);
}

int CHsmsPassive::updateCollectionEvent(unsigned int CEID, const char* name, const char* desc, const std::vector<unsigned int>& rptids)
{
   for (auto iter = m_collectionEvents.begin(); iter != m_collectionEvents.end(); ++iter) {
      if ((*iter)->getEventId() == CEID) {
         delete (*iter);
         auto* pEvent = new SERVO::CCollectionEvent(CEID, name, desc, const_cast<std::vector<unsigned int>&>(rptids));
         for (auto rptid : rptids) {
            SERVO::CReport* pReport = getReport((int)rptid);
            if (pReport != nullptr) {
               pEvent->addReport(pReport);
            }
         }
         *iter = pEvent;
         return writeCollectionEventsToFile(m_strCollectionEventFilepath);
      }
   }
   return -1;
}

void CHsmsPassive::clearAllCollectionEvent()
@@ -452,6 +1117,62 @@
   }

   return result;
}

int CHsmsPassive::writeCollectionEventsToFile(const std::string& filepath)
{
   if (filepath.empty()) return -1;

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

   if (m_bCollectionUtf8 && m_bCollectionUtf8Bom) {
      const BYTE bom[3] = { 0xEF, 0xBB, 0xBF };
      file.Write(bom, 3);
   }

   const std::string headerAnsi = "CEID,CE Name,Descriptions,Attached RPTID\r\n";
   if (m_bCollectionUtf8) {
      CStringA header = AnsiToUtf8(headerAnsi);
      file.Write(header.GetString(), header.GetLength());
   }
   else {
      file.Write(headerAnsi.data(), (UINT)headerAnsi.size());
   }

   for (auto ev : m_collectionEvents) {
      if (ev == nullptr) continue;
      std::string line;
      line.reserve(128);
      line += std::to_string(ev->getEventId());
      line.push_back(',');
      line += ev->getName();
      line.push_back(',');
      line += ev->getDescription();
      line.push_back(',');
      line.push_back('(');
      auto rptIds = ev->getReportIds();
      for (size_t i = 0; i < rptIds.size(); ++i) {
         line += std::to_string(rptIds[i]);
         if (i + 1 < rptIds.size()) {
            line.push_back(',');
         }
      }
      line += ")\r\n";

      if (m_bCollectionUtf8) {
         CStringA out = AnsiToUtf8(line);
         file.Write(out.GetString(), out.GetLength());
      }
      else {
         file.Write(line.data(), (UINT)line.size());
      }
   }

   file.Close();
   return 0;
}

int CHsmsPassive::init(CModel* pModel, const char* pszName, unsigned int port)
@@ -509,6 +1230,9 @@
         // S1F1
         replyAreYouThere(pMessage);
      }
      else if (nStream == 1 && pHeader->function == 3) {
         replySelectedEquipmentStatusData(pMessage);
      }
      else if (nStream == 1 && pHeader->function == 13) {
         replyEstablishCommunications(pMessage);
      }
@@ -542,6 +1266,9 @@
      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);
      }
@@ -553,6 +1280,12 @@
      }
      else if (nStream == 10 && pHeader->function == 3) {
         replyTerminalDisplay(pMessage);
      }
      else if (nStream == 14 && pHeader->function == 9) {
         replyCreateObj(pMessage);
      }
      else if (nStream == 16 && pHeader->function == 15) {
         replyPRJobMultiCreate(pMessage);
      }
   };

@@ -872,6 +1605,46 @@
   return 0;
}

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

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

   unsigned char SVU1 = 0;
   unsigned short SVID = 0;
   ISECS2Item* pBody = pRecv->getBody();
   if (pBody == nullptr || pBody->getType() != SITYPE::L) {
      pMessage->getBody()->addU1Item(SVU1, "SV");
      goto MYREPLY;
   }
   if (!pBody->getSubItemU2(0, SVID)) {
      pMessage->getBody()->addU1Item(SVU1, "SV");
      goto MYREPLY;
   }

   SERVO::CVariable* pVariable = getVariable((int)SVID);
   if (pVariable == nullptr) {
      pMessage->getBody()->addU1Item(SVU1, "SV");
      goto MYREPLY;
   }
   addVariableValueToItem(pMessage->getBody(), pVariable);

MYREPLY:
   m_pPassive->sendMessage(pMessage);
   LOGI("<HSMS>[SECS Msg SEND]%s", pMessage->toString());
   HSMS_Destroy1Message(pMessage);



   return 0;
}

// S2F13
int CHsmsPassive::replyEquipmentConstantRequest(IMessage* pRecv)
{
@@ -1092,7 +1865,7 @@

   // 检验结果是否正确
   for (auto item : m_collectionEvents) {
      LOGE("=== ceid:%d, prtid:%d", item->getEventId(), item->getPortID());
      LOGE("=== ceid:%d, prtid:%d", item->getEventId(), item->getFirstPortID());
   }
   
MYREPLY:
@@ -1234,6 +2007,57 @@
   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 int DATAID;
   unsigned char PTN;
   const char* pszCarrierAction, *pszCarrierId;
   pBody->getSubItemU4(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>[SECS Msg SEND]S3F18 (SysByte=%u)", pMessage->getHeader()->systemBytes);
   HSMS_Destroy1Message(pMessage);
	
   return 0;
}

// S5F3
int CHsmsPassive::replyEanbleDisableAlarmReport(IMessage* pRecv)
{
@@ -1314,19 +2138,20 @@
   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);
   HSMS_Destroy1Message(pMessage);
@@ -1365,6 +2190,245 @@
   return 0;
}

// S14F9
int CHsmsPassive::replyCreateObj(IMessage* pRecv)
{
   if (m_pPassive == NULL || STATE::SELECTED != m_pPassive->getState()) {
      return ER_NOTSELECT;
   }
   ISECS2Item* pBody = pRecv->getBody();
   if (pBody == nullptr || pBody->getType() != SITYPE::L) ER_PARAM_ERROR;
	

   // 是否创建成功并准备回复报文
   bool bCreateOk = false;
   IMessage* pReply = NULL;
   HSMS_Create1Message(pReply, m_nSessionId, 14, 10, ++m_nSystemByte);
   ASSERT(pReply);



   // 解释数据，得到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>[SECS Msg SEND]S14F10 (SysByte=%u)", pReply->getHeader()->systemBytes);
   HSMS_Destroy1Message(pReply);


   return 0;
}

// S16F15
int CHsmsPassive::replyPRJobMultiCreate(IMessage* pRecv)
{
   if (m_pPassive == NULL || STATE::SELECTED != m_pPassive->getState()) {
      return ER_NOTSELECT;
   }
   ISECS2Item* pBody = pRecv->getBody();
   if (pBody == nullptr || pBody->getType() != SITYPE::L) ER_PARAM_ERROR;


   // 解释数据，得到CProcessJob
   ISECS2Item* pItemPjs, * pItemPj,* pItemCarriers, * pItemCarrier, *pItemSlots, *pItemRecipes;
   unsigned int DATAID;
   const char* pszPrjobid, *pszMF, *pszCarrierId, *pszRecipeName;
   std::string strCarrierId;
   unsigned int len;
   unsigned char slot, PRRECIPEMETHOD;
   std::vector<unsigned char> slots;
   std::vector<SERVO::CProcessJob*> pjs;

   if (!pBody->getSubItemU4(0, DATAID)) return ER_PARAM_ERROR;
   pItemPjs = pBody->getSubItem(1);
   if (pItemPjs == nullptr) return ER_PARAM_ERROR;
   for (int i = 0; i < pItemPjs->getSubItemSize(); i++) {
      pItemPj = pItemPjs->getSubItem(i);
      if (pItemPj == nullptr) continue;
      if (!pItemPj->getSubItemString(0, pszPrjobid)) continue;
      if (!pItemPj->getSubItemBinary(1, pszMF, len)) continue;
      pItemCarriers = pItemPj->getSubItem(2);
      if (pItemCarriers == nullptr) continue;
      pItemRecipes = pItemPj->getSubItem(3);
      if (pItemRecipes == nullptr) continue;
      SERVO::CProcessJob* pj = new SERVO::CProcessJob(pszPrjobid);
      int size = pItemCarriers->getSubItemSize();
      for (int j = 0; j < size; j++) {
         pItemCarrier = pItemCarriers->getSubItem(j);
         strCarrierId.clear();
         if (pItemCarrier->getSubItemString(0, pszCarrierId)) {
            strCarrierId = pszCarrierId;
         }

         slots.clear();
         pItemSlots = pItemCarrier->getSubItem(1);
         if (pItemSlots != nullptr) {
            int size2 = pItemSlots->getSubItemSize();
            for (int k = 0; k < size2; k++) {
               if (pItemSlots->getSubItemU1(k, slot)) {
                  slots.push_back(slot);
               }
            }
         }
         pj->addCarrier(strCarrierId, slots);
      }
      if (pItemRecipes->getSubItemU1(0, PRRECIPEMETHOD)
         && pItemRecipes->getSubItemString(1, pszRecipeName)) {
         pj->setRecipe(SERVO::RecipeMethod(PRRECIPEMETHOD), std::string(pszRecipeName));
      }

      pjs.push_back(pj);
   }

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


   // 回复报文
   IMessage* pMessage = NULL;
   HSMS_Create1Message(pMessage, m_nSessionId, 16, 16, ++m_nSystemByte);
   ASSERT(pMessage);
   ISECS2Item* pItemPrjobIds = pMessage->getBody()->addItem();
   ISECS2Item* pItemErrors = pMessage->getBody()->addItem();
   bool bHasError = false;
   for (auto p : pjs) {
      if (p->issues().empty()) {
         pItemPrjobIds->addItem(p->id().c_str(), "PRJOBID");
      }
      else {
         bHasError = true;
      }
   }
   if (bHasError) {
      pItemErrors->addBoolItem(false, "ACKA");
      ISECS2Item* pItemErrors2 = pItemErrors->addItem();
      for (auto p : pjs) {
         if (!p->issues().empty()) {
            ISECS2Item* pItemErr = pItemErrors2->addItem();
            pItemErr->addU4Item(p->issues()[0].code, "ERRCODE");
            pItemErr->addItem(("<" + p->id() + ">" + p->issues()[0].text).c_str(), "ERRTEXT");
         }
      }
   }
   m_pPassive->sendMessage(pMessage);
   LOGI("<HSMS>[SECS Msg SEND]S16F16 (SysByte=%u)", pMessage->getHeader()->systemBytes);
   HSMS_Destroy1Message(pMessage);


   // 释放有问题(未添加到master)的内存
   for (auto p : pjs) {
      if(!p->issues().empty()) delete p;
   }
   pjs.clear();

   return 0;
}

// S5F1
int CHsmsPassive::requestAlarmReport(int ALCD, int ALID, const char* ALTX)
{
@@ -1395,15 +2459,19 @@
}

// S6F11
int CHsmsPassive::requestEventReportSend(unsigned int DATAID, unsigned int CEID, const std::vector<std::string>& values)
static unsigned short DATAID = 0;
int CHsmsPassive::requestEventReportSend(unsigned int CEID)
{
   SERVO::CCollectionEvent* pEvent = getEvent(CEID);
   if (pEvent == nullptr) {
      return ER_NO_EVENT;
   }
   if (pEvent == nullptr) {

   SERVO::CReport* pReport = pEvent->getFirstReport();
   if (pReport == nullptr) {
      return ER_UNLINK_EVENT_REPORT;
   }


   Lock();
   CHsmsAction* pAction = new CHsmsAction(ACTION_EVENT_REPORT, TRUE, m_nActionTimeout);
@@ -1411,14 +2479,17 @@
   HSMS_Create1Message(pMessage, m_nSessionId, 6 | REPLY, 11, ++m_nSystemByte);
   ASSERT(pMessage);
   ISECS2Item* pItem = pMessage->getBody();
   pItem->addU4Item(DATAID, "DATAID");
   // pItem->addU2Item(++DATAID, "DATAID");      // 根据别的日志显示DATAID恒为0，所以我们先照使用0
   pItem->addU2Item(0, "DATAID");
   pItem->addU4Item(CEID, "CEID");
   ISECS2Item* pItemList1 = pItem->addItem();
   ISECS2Item* pItemList2 = pItemList1->addItem();
   pItemList2->addU4Item(pEvent->getPortID(), "RPTID");
   pItemList2->addU4Item(pReport->getReportId(), "RPTID");
   ISECS2Item* pItemList3 = pItemList2->addItem();
   for (auto item : values) {
      pItemList3->addItem(item.c_str(), "V");

   auto vars = pReport->getVariables();
   for (auto var : vars) {
      addVariableValueToItem(pItemList3, var);
   }
   pAction->setSendMessage(pMessage);
   if (m_pPassive == NULL || STATE::SELECTED != m_pPassive->getState()) {
@@ -1433,5 +2504,109 @@
   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");
}