1.增加Job模式，如果不是Job模式，沿用原来的调度方式，否则为批处理模式；

LAPTOP-SNT8I5JK\Boounion

2025-08-22 7a20b6f44d2ea3f23ef8d228ec4c1424925e5dfb

 SourceCode/Bond/Servo/CMaster.cpp

@@ -4,6 +4,8 @@
#include <future>
#include <vector>
#include "RecipeManager.h"
#include <fstream>
#include "SerializeUtil.h"


namespace SERVO {
@@ -53,20 +55,27 @@
      m_pActiveRobotTask = nullptr;
      m_nLastError = 0;
      m_isCompareMapsBeforeProceeding = FALSE;
      m_bJobMode = FALSE;
      m_bEnableEventReport = true;
      m_bEnableAlarmReport = true;
      m_bContinuousTransfer = false;
      m_nContinuousTransferCount = 0;
      m_nContinuousTransferStep = CTStep_Unknow;
      m_pControlJob = nullptr;
      InitializeCriticalSection(&m_criticalSection);
   }

   CMaster::~CMaster()
   {
      // 释放Job相关
      for (auto item : m_processJobs) {
         delete item;
      }
      m_processJobs.clear();
      if (m_pControlJob != nullptr) {
         delete m_pControlJob;
         m_pControlJob = nullptr;
      }

      if (m_hEventReadBitsThreadExit[0] != nullptr) {
         ::CloseHandle(m_hEventReadBitsThreadExit[0]);
@@ -676,7 +685,7 @@
               if (!rmd.armState[0] && pLoadPorts[s]->isEnable()
                  && (pt == PortType::Loading || pt == PortType::Both)
                  && pLoadPorts[s]->getPortStatus() == PORT_INUSE) {
                  m_pActiveRobotTask = createTransferTask(pLoadPorts[s], pAligner, primaryType, secondaryType);
                  m_pActiveRobotTask = createTransferTask(pLoadPorts[s], pAligner, primaryType, secondaryType, m_bJobMode);
                  if (m_pActiveRobotTask != nullptr) {
                     pEFEM->setContext(m_pActiveRobotTask->getContext());
                     goto PORT_GET;
@@ -1135,6 +1144,25 @@
      };
      listener.onPortStatusChanged = [&](void* pEquipment, short status, __int64 data) {
         LOGE("<Master-%s>onPortStatusChanged。status=%d, data=%lld", ((CEquipment*)pEquipment)->getName().c_str(), status);
         if (status == PORT_INUSE && m_pControlJob != nullptr) {
            CLoadPort* pPort = (CLoadPort*)pEquipment;
            auto pjs = m_pControlJob->getPjs();
            for (auto pj : pjs) {
               auto carrier = pj->getCarrier(pPort->getCassetteId());
               if (carrier != nullptr) {
                  for (auto slot : carrier->slots) {
                     CGlass* pGlass = pPort->getGlassFromSlot(slot);
                     carrier->contexts.push_back((void*)pGlass);
                     if (pGlass != nullptr) {
                        pGlass->setProcessJob(pj);
                     }
                  }
               }
            }


         }
			
         if (m_listener.onLoadPortStatusChanged != nullptr) {
            m_listener.onLoadPortStatusChanged(this, (CEquipment*)pEquipment, status, data);
         }
@@ -1540,7 +1568,7 @@
   static int taskSeqNo = 0;
   CRobotTask* CMaster::createTransferTask(CEquipment* pSrcEq, CEquipment* pTarEq,
      MaterialsType primaryType/* = MaterialsType::G1*/, MaterialsType secondaryType/* = MaterialsType::G2*/,
      int armNo/* = 1*/)
      int armNo/* = 1*/, BOOL bJobMode/* = FALSE*/)
   {
      if (!pSrcEq->IsEnabled()) { 
         return nullptr;
@@ -1549,10 +1577,10 @@
      CRobotTask* pTask = nullptr;
      CSlot* pSrcSlot, * pTarSlot;
      pTarSlot = pTarEq->getAvailableSlotForGlass(primaryType);
      pSrcSlot = pSrcEq->getProcessedSlot(primaryType);
      pSrcSlot = pSrcEq->getProcessedSlot(primaryType, bJobMode);
      if (pSrcSlot == nullptr || nullptr == pTarSlot) {
         pTarSlot = pTarEq->getAvailableSlotForGlass(secondaryType);
         pSrcSlot = pSrcEq->getProcessedSlot(secondaryType);
         pSrcSlot = pSrcEq->getProcessedSlot(secondaryType, bJobMode);
      }


@@ -1794,6 +1822,11 @@
      m_isCompareMapsBeforeProceeding = bCompare;
   }

   void CMaster::setJobMode(BOOL bJobMode)
   {
      m_bJobMode = bJobMode;
   }

   void CMaster::datetimeSync(SYSTEMTIME& time)
   {
      for (auto item : m_listEquipment) {
@@ -1847,22 +1880,83 @@
      m_nContinuousTransferCount = round;
   }

   int CMaster::setProcessJobs(std::vector<SERVO::CProcessJob*>& pjs)
   int CMaster::setProcessJobs(std::vector<CProcessJob*>& pjs)
   {
      std::vector<SERVO::CProcessJob*> temp;
      for (auto p : pjs) {
         if (p->validate(*this)) {
            p->queue();
            temp.push_back(p);
         }
      }

      m_processJobs = temp;
      return m_processJobs.size();
      this->saveState();

      return (int)m_processJobs.size();
   }

   std::vector<SERVO::CProcessJob*>& CMaster::getProcessJobs()
   std::vector<CProcessJob*>& CMaster::getProcessJobs()
   {
      return m_processJobs;
   }

   CProcessJob* CMaster::getProcessJob(const std::string& id)
   {
      for (auto item : m_processJobs) {
         if (item->id().compare(id) == 0) return item;
      }

      return nullptr;
   }

   int CMaster::setControlJob(CControlJob& controlJob)
   {
      // 回调：是否参创建ControlJob
      auto canCreateCjFn = [&](uint32_t& cc, std::string& mm) -> bool {
         if (m_pControlJob != nullptr) {
            cc = 1100;
            mm = "当前ControlJob未结批，不能创建新的ControlJob";
            return false;
         }
         return true;
      };


      // 回调：是否存在
      auto pjExists = [&](const std::string& id) -> bool {
         return getProcessJob(id) != nullptr;
      };

      // 回调：是否可加入 CJ（这里定义：必须是 Queued）
      auto pjJoinable = [&](const std::string& id) -> bool {
         auto pj = getProcessJob(id);
         if (pj == nullptr) return false;
         return pj->state() == PJState::Queued;
      };

      bool bRet = controlJob.validateForCreate(canCreateCjFn, pjExists, pjJoinable);
      if (!bRet) return -1;

      std::vector<CProcessJob*> temps;
      m_pControlJob = new CControlJob(controlJob);
      auto pjIds = controlJob.pjIds();
      for (auto id : pjIds) {
         auto pj = getProcessJob(id);
         if (pj != nullptr) {
            temps.push_back(pj);
         }
      }
      m_pControlJob->setPJs(temps);
      this->saveState();


      return 0;
   }

   CControlJob* CMaster::getControlJob()
   {
      return m_pControlJob;
   }

   CLoadPort* CMaster::getPortWithCarrierId(const std::string& carrierId) const
@@ -1910,4 +2004,95 @@
      return true;
   }

   bool CMaster::saveState() const
   {
      std::ofstream ofs(m_strStatePath, std::ios::binary);
      if (!ofs) return false;

      // 文件头
      uint32_t magic = 0x4D415354; // 'MAST'
      uint16_t version = 1;
      ofs.write(reinterpret_cast<const char*>(&magic), sizeof(magic));
      ofs.write(reinterpret_cast<const char*>(&version), sizeof(version));

      // 保存 ControlJob
      bool hasCJ = (m_pControlJob != nullptr);
      ofs.write(reinterpret_cast<const char*>(&hasCJ), sizeof(hasCJ));
      if (hasCJ) {
         m_pControlJob->serialize(ofs);
      }

      // 保存 ProcessJob 列表
      uint32_t count = static_cast<uint32_t>(m_processJobs.size());
      ofs.write(reinterpret_cast<const char*>(&count), sizeof(count));
      for (const auto& job : m_processJobs) {
         job->serialize(ofs);
      }

      // 以后可以在这里追加新字段
      return true;
   }

   bool CMaster::loadState(const std::string& path)
   {
      // 保存文件路径
      m_strStatePath = path;


      std::ifstream ifs(path, std::ios::binary);
      if (!ifs) return false;

      // 文件头
      uint32_t magic = 0;
      uint16_t version = 0;
      ifs.read(reinterpret_cast<char*>(&magic), sizeof(magic));
      ifs.read(reinterpret_cast<char*>(&version), sizeof(version));

      if (magic != 0x4D415354) {
         // 文件不合法
         return false;
      }

      if (m_pControlJob != nullptr) {
         delete m_pControlJob;
         m_pControlJob = nullptr;
      }

      // 读取 ControlJob
      bool hasCJ = false;
      ifs.read(reinterpret_cast<char*>(&hasCJ), sizeof(hasCJ));
      if (hasCJ) {
         m_pControlJob = new CControlJob();
         if (!CControlJob::deserialize(ifs, *m_pControlJob)) return false;
      }


      // 读取 ProcessJob 列表
      uint32_t count = 0;
      ifs.read(reinterpret_cast<char*>(&count), sizeof(count));
      m_processJobs.clear();
      for (uint32_t i = 0; i < count; i++) {
         CProcessJob* pProcessJob = new CProcessJob();
         if (!CProcessJob::deserialize(ifs, *pProcessJob)) return false;
         m_processJobs.push_back(pProcessJob);
      }


      // 找到CProcessJob指针加入列表中
      std::vector<CProcessJob*> tempPjs;
      auto ids = m_pControlJob->pjIds();
      for (auto id : ids) {
         auto pj = getProcessJob(id);
         if (pj != nullptr) {
            tempPjs.push_back(pj);
         }
      }
      m_pControlJob->setPJs(tempPjs);


      // 如果版本升级，可在这里判断 version 来加载新字段


      return true;
   }
}