#include "stdafx.h"
|
#include "CEquipment.h"
|
#include "ToolUnits.h"
|
#include <regex>
|
|
|
#define CHECK_READ_STEP_SIGNAL(addr, data, size) { \
|
BOOL bFlag = isBitOn(data, size, addr); \
|
SERVO::CStep* pStep = getStep(addr); \
|
if (pStep != nullptr) { \
|
((CReadStep*)pStep)->onReadSignal(bFlag ? addr : 0); \
|
} \
|
}
|
|
#define CHECK_WRITE_STEP_SIGNAL(addr, data, size) { \
|
BOOL bFlag = isBitOn(data, size, addr); \
|
SERVO::CStep* pStep = getStep(addr); \
|
if (pStep != nullptr) { \
|
((CWriteStep*)pStep)->onRecvSignal(bFlag ? addr : 0); \
|
} \
|
}
|
|
namespace SERVO {
|
|
CEquipment::CEquipment() : m_nID(0), m_strName(""), m_strDescription(""), m_station(0, 255)
|
{
|
m_listener = { nullptr, nullptr, nullptr, nullptr, nullptr };
|
m_alive = { FALSE, 0, FALSE };
|
m_bCimState = FALSE;
|
m_bUpstreamInline = FALSE;
|
m_bDownstreamInline = FALSE;
|
m_bLocalAlarm = FALSE;
|
m_bAutoRecipeChange = FALSE;
|
m_bVCREnable[0] = FALSE;
|
m_pCclink = nullptr;
|
m_nBaseAlarmId = 0;
|
InitializeCriticalSection(&m_criticalSection);
|
}
|
|
CEquipment::~CEquipment()
|
{
|
for (auto item : m_glassList) {
|
item->release();
|
}
|
m_glassList.clear();
|
|
for (auto item : m_mapStep) {
|
delete item.second;
|
}
|
m_mapStep.clear();
|
|
for (auto item : m_inputPins) {
|
delete item;
|
}
|
m_inputPins.clear();
|
|
for (auto item : m_outputPins) {
|
delete item;
|
}
|
m_outputPins.clear();
|
|
DeleteCriticalSection(&m_criticalSection);
|
}
|
|
void CEquipment::setListener(EquipmentListener listener)
|
{
|
m_listener.onAlive = listener.onAlive;
|
m_listener.onCimStateChanged = listener.onCimStateChanged;
|
m_listener.onAlarm = listener.onAlarm;
|
m_listener.onDataChanged = listener.onDataChanged;
|
m_listener.onVcrEventReport = listener.onVcrEventReport;
|
}
|
|
void CEquipment::setCcLink(CCCLinkIEControl* pCcLink)
|
{
|
m_pCclink = pCcLink;
|
}
|
|
void CEquipment::setBaseAlarmId(int nBaseId)
|
{
|
m_nBaseAlarmId = nBaseId;
|
}
|
|
int CEquipment::getBaseAlarmId()
|
{
|
return m_nBaseAlarmId;
|
}
|
|
void CEquipment::getProperties(std::vector<std::pair<std::string, std::string>>& container)
|
{
|
container.clear();
|
// ʾÀý£º½«Ò»Ð©ÊôÐÔÌí¼Óµ½ÈÝÆ÷
|
container.push_back(std::make_pair("DeviceName", "ServoMotor"));
|
container.push_back(std::make_pair("SerialNumber", "123456789"));
|
container.push_back(std::make_pair("Version", "1.0"));
|
}
|
|
std::map<unsigned int, CStep*>& CEquipment::getSteps()
|
{
|
return m_mapStep;
|
}
|
|
CStep* CEquipment::getStep(unsigned int addr)
|
{
|
auto iter = m_mapStep.find(addr);
|
if (iter == m_mapStep.end()) return nullptr;
|
return iter->second;
|
}
|
|
CStep* CEquipment::getStepWithName(const char* pszName)
|
{
|
for (auto item : m_mapStep) {
|
if (item.second->getName().compare(pszName) == 0) {
|
return item.second;
|
}
|
}
|
|
return nullptr;
|
}
|
|
int CEquipment::addStep(unsigned int addr, CStep* pStep)
|
{
|
auto iter = m_mapStep.find(addr);
|
if (iter != m_mapStep.end()) return -1;
|
pStep->setEquipment(this);
|
pStep->setID(addr);
|
pStep->setCcLink(m_pCclink);
|
m_mapStep[addr] = pStep;
|
return 0;
|
}
|
|
void CEquipment::init()
|
{
|
initPins();
|
for (auto item : m_mapStep) {
|
item.second->init();
|
}
|
}
|
|
void CEquipment::term()
|
{
|
for (auto item : m_mapStep) {
|
item.second->term();
|
}
|
}
|
|
void CEquipment::setID(int nID)
|
{
|
m_nID = nID;
|
}
|
|
int CEquipment::getID()
|
{
|
return m_nID;
|
}
|
|
void CEquipment::setName(const char* pszName)
|
{
|
m_strName = pszName;
|
}
|
|
std::string& CEquipment::getName()
|
{
|
return m_strName;
|
}
|
|
void CEquipment::setDescription(const char* pszDescription)
|
{
|
m_strDescription = pszDescription;
|
}
|
|
std::string& CEquipment::getDescription()
|
{
|
return m_strDescription;
|
}
|
|
void CEquipment::setStation(int network, int station)
|
{
|
m_station.nNetNo = network;
|
m_station.nStNo = station;
|
}
|
|
const StationIdentifier& CEquipment::getStation()
|
{
|
return m_station;
|
}
|
|
void CEquipment::getAttributeVector(CAttributeVector& attrubutes)
|
{
|
attrubutes.clear();
|
attrubutes.addAttribute(new CAttribute("Network",
|
std::to_string(m_station.nNetNo).c_str(), ""));
|
attrubutes.addAttribute(new CAttribute("Station",
|
std::to_string(m_station.nStNo).c_str(), ""));
|
attrubutes.addAttribute(new CAttribute("ID",
|
std::to_string(m_nID).c_str(), ""));
|
attrubutes.addAttribute(new CAttribute("Name",
|
m_strName.c_str(), ""));
|
attrubutes.addAttribute(new CAttribute("Description",
|
m_strDescription.c_str(), ""));
|
attrubutes.addAttribute(new CAttribute("Alive",
|
this->isAlive() ? _T("TRUE") : _T("FALSE"), ""));
|
attrubutes.addAttribute(new CAttribute("CIM State",
|
m_bCimState ? _T("ON") : _T("OFF"), ""));
|
attrubutes.addAttribute(new CAttribute("Upstream",
|
m_bUpstreamInline ? _T("Inline") : _T("Offline"), ""));
|
attrubutes.addAttribute(new CAttribute("Downstream",
|
m_bDownstreamInline ? _T("Inline") : _T("Offline"), ""));
|
attrubutes.addAttribute(new CAttribute("Local Alarm",
|
m_bLocalAlarm ? _T("TRUE") : _T("FALSE"), ""));
|
attrubutes.addAttribute(new CAttribute("Auto Recipe Change",
|
m_bAutoRecipeChange ? _T("TRUE") : _T("FALSE"), ""));
|
char szTemp[256];
|
for (int i = 0; i < VCR_MAX; i++) {
|
sprintf_s(szTemp, 256, "VCR-%d", i + 1);
|
attrubutes.addAttribute(new CAttribute(szTemp,
|
m_bVCREnable[i] ? _T("Enable") : _T("Disable"), ""));
|
}
|
|
for (auto item : m_inputPins) {
|
attrubutes.addAttribute(new CAttribute(item->getName().c_str(),
|
std::to_string((int)item->getType()).c_str(), ""));
|
}
|
|
for (auto item : m_outputPins) {
|
attrubutes.addAttribute(new CAttribute(item->getName().c_str(),
|
std::to_string((int)item->getType()).c_str(), ""));
|
}
|
|
for (auto item : m_glassList) {
|
attrubutes.addAttribute(new CAttribute("Glass",
|
item->getID().c_str(), ""));
|
}
|
}
|
|
void CEquipment::setReadBitBlock(unsigned int start, unsigned int end)
|
{
|
m_blockReadBit.type = (unsigned int)DeviceType::B;
|
m_blockReadBit.start = start;
|
m_blockReadBit.end = end;
|
m_blockReadBit.size = (m_blockReadBit.end - m_blockReadBit.start + 1) / 8;
|
ASSERT(m_blockReadBit.size < BLOCK_BUFFER_MAX);
|
}
|
|
MemoryBlock& CEquipment::getReadBitBlock()
|
{
|
return m_blockReadBit;
|
}
|
|
void CEquipment::setWriteBitBlock(unsigned int start, unsigned int end)
|
{
|
m_blockWriteBit.type = (unsigned int)DeviceType::LB;
|
m_blockWriteBit.start = start;
|
m_blockWriteBit.end = end;
|
m_blockWriteBit.size = (m_blockWriteBit.end - m_blockWriteBit.start + 1) / 8;
|
}
|
|
MemoryBlock& CEquipment::getWriteBitBlock()
|
{
|
return m_blockWriteBit;
|
}
|
|
void CEquipment::onTimer(UINT nTimerid)
|
{
|
// ÿ¸ôÒ»Ã룬¼ì²éÒ»ÏÂALIVE״̬
|
|
static int tick = 0;
|
tick++;
|
if (tick % (4 * 1) == 0) {
|
m_alive.count++;
|
if (m_alive.alive && m_alive.count > ALIVE_TIMEOUT) {
|
m_alive.alive = FALSE;
|
if (m_listener.onAlive != nullptr) {
|
m_listener.onAlive(this, m_alive.alive);
|
}
|
}
|
}
|
}
|
|
void CEquipment::serialize(CArchive& ar)
|
{
|
if (ar.IsStoring()) {
|
Lock();
|
int count = (int)m_glassList.size();
|
ar << count;
|
for (auto item : m_glassList) {
|
item->serialize(ar);
|
}
|
Unlock();
|
}
|
else {
|
Lock();
|
int count;
|
ar >> count;
|
for (int i = 0; i < count; i++) {
|
CGlass* pGlass = new CGlass();
|
pGlass->serialize(ar);
|
addGlassToList(pGlass);
|
}
|
Unlock();
|
}
|
}
|
|
void CEquipment::onReceiveLBData(const char* pszData, size_t size)
|
{
|
/*
|
TRACE("%s onReceiveLBData: %d bytes\n", m_strName.c_str(), size);
|
for (unsigned int i = 0; i < size; i++) {
|
if (pszData[i] != 0)
|
TRACE("%d[%x]\n", i, pszData[i]);
|
}
|
*/
|
|
// ÒÔϽâÊͺʹ¦ÀíÊý¾Ý
|
BOOL bFlag;
|
int index = 0x840;
|
|
|
// alive
|
bFlag = isBitOn(pszData, size, index);
|
if (!equalBool(m_alive.flag, bFlag)) {
|
m_alive.flag = bFlag;
|
m_alive.count = 0;
|
|
// ״̬
|
if (!m_alive.alive) {
|
m_alive.alive = TRUE;
|
if (m_listener.onAlive != nullptr) {
|
m_listener.onAlive(this, m_alive.alive);
|
}
|
}
|
}
|
|
// CIM State
|
bFlag = isBitOn(pszData, size, ++index);
|
if (!equalBool(m_bCimState, bFlag)) {
|
m_bCimState = bFlag;
|
if (m_listener.onCimStateChanged != nullptr) {
|
m_listener.onCimStateChanged(this, m_bCimState);
|
}
|
}
|
|
// UpstreamInline
|
bFlag = isBitOn(pszData, size, ++index);
|
if (!equalBool(m_bUpstreamInline, bFlag)) {
|
m_bUpstreamInline = bFlag;
|
}
|
|
// DownstreamInline
|
bFlag = isBitOn(pszData, size, ++index);
|
if (!equalBool(m_bDownstreamInline, bFlag)) {
|
m_bDownstreamInline = bFlag;
|
}
|
|
// LocalAlarm
|
bFlag = isBitOn(pszData, size, ++index);
|
if (!equalBool(m_bLocalAlarm, bFlag)) {
|
m_bLocalAlarm = bFlag;
|
}
|
|
// AutoRecipeChange
|
bFlag = isBitOn(pszData, size, ++index);
|
if (!equalBool(m_bAutoRecipeChange, bFlag)) {
|
m_bAutoRecipeChange = bFlag;
|
}
|
|
// AutoRecipeChange
|
bFlag = isBitOn(pszData, size, ++index);
|
if (!equalBool(m_bVCREnable[0], bFlag)) {
|
m_bVCREnable[0] = bFlag;
|
}
|
|
|
// ÒÔϸù¾ÝÐźÅ×öÁ÷³Ì´¦Àí
|
for (int i = 0; i < 7; i++) {
|
CHECK_READ_STEP_SIGNAL(STEP_ID_EQMODE_CHANGED + i, pszData, size);
|
}
|
|
|
// CIM Mode
|
CHECK_WRITE_STEP_SIGNAL(STEP_ID_CIMMODE_CHANGED_CMD_REPLY, pszData, size);
|
|
// CIM Message Set cmd reply
|
CHECK_WRITE_STEP_SIGNAL(STEP_ID_CIM_MSG_SET_CMD_REPLY, pszData, size);
|
|
// CIM Message Clear cmd reply
|
CHECK_WRITE_STEP_SIGNAL(STEP_ID_CIM_MSG_CLEAR_CMD_REPLY, pszData, size);
|
|
// Datetime set cmd reply
|
CHECK_WRITE_STEP_SIGNAL(STEP_ID_DATETIME_SET_CMD_REPLY, pszData, size);
|
|
// vcr enable cmd reply
|
CHECK_WRITE_STEP_SIGNAL(STEP_ID_VCR_ENABLE_CMD_REPLY, pszData, size);
|
|
// EQ mode change cmd reply
|
CHECK_WRITE_STEP_SIGNAL(STEP_ID_EQMODE_CHANGE_CMD_REPLY, pszData, size);
|
|
// CIM Message Confirm
|
CHECK_READ_STEP_SIGNAL(STEP_ID_CIM_MSG_CONFIRM_REPORT, pszData, size);
|
|
// VCR1 Event report
|
CHECK_READ_STEP_SIGNAL(STEP_ID_VCR1_EVENT_REPORT, pszData, size);
|
|
// EQ Job Event
|
CHECK_READ_STEP_SIGNAL(STEP_ID_RECIVE_JOB_UPS1, pszData, size);
|
CHECK_READ_STEP_SIGNAL(STEP_ID_RECIVE_JOB_UPS2, pszData, size);
|
CHECK_READ_STEP_SIGNAL(STEP_ID_SENT_OUT_JOB_DOWNS1, pszData, size);
|
CHECK_READ_STEP_SIGNAL(STEP_ID_SENT_OUT_JOB_DOWNS2, pszData, size);
|
|
|
// CEqCassetteTranserStateStep
|
CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_CASSETTIE_EMPTY, pszData, size);
|
CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_CASSETTIE_LOAD_READY, pszData, size);
|
CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_CASSETTIE_LOADED, pszData, size);
|
CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_CASSETTIE_INUSE, pszData, size);
|
CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_CASSETTIE_UNLOAD_READY, pszData, size);
|
CHECK_READ_STEP_SIGNAL(STEP_ID_PORT1_CASSETTIE_BLOCKED, pszData, size);
|
CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_CASSETTIE_EMPTY, pszData, size);
|
CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_CASSETTIE_LOAD_READY, pszData, size);
|
CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_CASSETTIE_LOADED, pszData, size);
|
CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_CASSETTIE_INUSE, pszData, size);
|
CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_CASSETTIE_UNLOAD_READY, pszData, size);
|
CHECK_READ_STEP_SIGNAL(STEP_ID_PORT2_CASSETTIE_BLOCKED, pszData, size);
|
CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_CASSETTIE_EMPTY, pszData, size);
|
CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_CASSETTIE_LOAD_READY, pszData, size);
|
CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_CASSETTIE_LOADED, pszData, size);
|
CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_CASSETTIE_INUSE, pszData, size);
|
CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_CASSETTIE_UNLOAD_READY, pszData, size);
|
CHECK_READ_STEP_SIGNAL(STEP_ID_PORT3_CASSETTIE_BLOCKED, pszData, size);
|
CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_CASSETTIE_EMPTY, pszData, size);
|
CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_CASSETTIE_LOAD_READY, pszData, size);
|
CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_CASSETTIE_LOADED, pszData, size);
|
CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_CASSETTIE_INUSE, pszData, size);
|
CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_CASSETTIE_UNLOAD_READY, pszData, size);
|
CHECK_READ_STEP_SIGNAL(STEP_ID_PORT4_CASSETTIE_BLOCKED, pszData, size);
|
}
|
|
BOOL CEquipment::isBitOn(const char* pszData, size_t size, int index)
|
{
|
int byteIndex, bitIndex;
|
byteIndex = (index) / 8;
|
bitIndex = (index) % 8;
|
|
return CToolUnits::getBit(pszData[byteIndex], bitIndex);
|
}
|
|
BOOL CEquipment::equalBool(BOOL b1, BOOL b2)
|
{
|
return (b1 && b2) || (!b1 && !b2);
|
}
|
|
BOOL CEquipment::isAlive()
|
{
|
return m_alive.alive;
|
}
|
|
BOOL CEquipment::isCimOn()
|
{
|
return m_bCimState;
|
}
|
|
BOOL CEquipment::isUpstreamInline()
|
{
|
return m_bUpstreamInline;
|
}
|
|
BOOL CEquipment::isDownstreamInline()
|
{
|
return m_bDownstreamInline;
|
}
|
|
BOOL CEquipment::isLocalAlarm()
|
{
|
return m_bLocalAlarm;
|
}
|
|
BOOL CEquipment::isAutoRecipeChange()
|
{
|
return m_bAutoRecipeChange;
|
}
|
|
BOOL CEquipment::isVCREnable(unsigned int index)
|
{
|
if (index >= VCR_MAX) return FALSE;
|
return m_bVCREnable[index];
|
}
|
|
int CEquipment::onStepEvent(CStep* pStep, int code)
|
{
|
if (code == STEP_EVENT_READDATA) {
|
if (isAlarmStep(pStep)) {
|
SERVO::CEqAlarmStep* pEqAlarmStep = (SERVO::CEqAlarmStep*)pStep;
|
int state = pEqAlarmStep->getAlarmState();
|
ASSERT(state == 0 || state == 1);
|
if (m_listener.onAlarm != nullptr) {
|
m_listener.onAlarm(this, state,
|
pEqAlarmStep->getAlarmId(),
|
pEqAlarmStep->getUnitId(),
|
pEqAlarmStep->getAlarmLevel());
|
}
|
|
return 1;
|
}
|
else if (isCimMessageConfirmStep(pStep)) {
|
SERVO::CEqReadIntStep* pEqReadIntStep = (SERVO::CEqReadIntStep*)pStep;
|
int value = pEqReadIntStep->getValue();
|
// ´Ë´¦½«value°´¸ßµÍλ²ð·ÖΪmessage idºÍpanel no.
|
// ¿ÉÄÜ»¹ÐèÒªÉϱ¨µ½cim
|
short msgId, panelNo;
|
msgId = (value & 0xffff0000 >> 16);
|
panelNo = (value & 0xffff);
|
LOGI("Cim Message Confirm(msgID = %d, panel no.=%d).", msgId, panelNo);
|
}
|
else if (isVcrEventStep(pStep)) {
|
SERVO::CEqVcrEventStep* pEqVcrEventStep = (SERVO::CEqVcrEventStep*)pStep;
|
CVcrEventReport* pVcrEventReport = pEqVcrEventStep->getVcrEventReport();
|
ASSERT(pVcrEventReport);
|
if (m_listener.onVcrEventReport != nullptr) {
|
m_listener.onVcrEventReport(this, pVcrEventReport);
|
}
|
|
// 0426, Ïȹ̶¨·µ»Ø1(OK)
|
pEqVcrEventStep->setReturnCode(1);
|
return 1;
|
}
|
}
|
|
|
return 0;
|
}
|
|
CPin* CEquipment::addPin(PinType type, char* pszName)
|
{
|
// ²»ÔÊÐíÃû×ÖÌí¼ÓÖظ´µÄpin
|
CPin* pPin = getPin(pszName);
|
if (pPin != nullptr) return nullptr;
|
|
|
// Ìí¼Óµ½PinÁÐ±í£¬¿´ÊÇÊäÈëpin»òÊä³öpin
|
if (type == PinType::INPUT) {
|
pPin = new CPin(this, type, pszName);
|
m_inputPins.push_back(pPin);
|
return pPin;
|
}
|
else if (type == PinType::OUTPUT) {
|
pPin = new CPin(this, type, pszName);
|
m_outputPins.push_back(pPin);
|
return pPin;
|
}
|
|
return nullptr;
|
}
|
|
CPin* CEquipment::getPin(char* pszName)
|
{
|
for (auto item : m_inputPins) {
|
if (item->getName().compare(pszName) == 0) {
|
return item;
|
}
|
}
|
|
for (auto item : m_outputPins) {
|
if (item->getName().compare(pszName) == 0) {
|
return item;
|
}
|
}
|
|
return nullptr;
|
}
|
|
std::vector<CPin*>& CEquipment::getInputPins()
|
{
|
return m_inputPins;
|
}
|
|
std::vector<CPin*>& CEquipment::getOutputPins()
|
{
|
return m_outputPins;
|
}
|
|
int CEquipment::recvIntent(CPin* pPin, CIntent* pIntent)
|
{
|
ASSERT(pPin);
|
CPin* pFromPin = pPin->getConnectedPin();
|
ASSERT(pFromPin);
|
CEquipment* pFromEq = pFromPin->getEquipment();
|
ASSERT(pFromEq);
|
|
LOGI("<CEquipment><%s-%s>ÊÕµ½À´×Ô<%s.%s>µÄIntent<%d,%s,0x%x>",
|
this->getName().c_str(),
|
pPin->getName().c_str(),
|
pFromEq->getName().c_str(),
|
pFromPin->getName().c_str(),
|
pIntent->getCode(),
|
pIntent->getMsg(),
|
pIntent->getContext());
|
|
|
|
// ÒÔϽâÊÍ´¦ÀíÊý¾Ý
|
int code = pIntent->getCode();
|
|
|
// ²âÊÔ
|
if (code == FLOW_TEST) {
|
AfxMessageBox(pIntent->getMsg());
|
return FLOW_ACCEPT;
|
}
|
|
|
// ÐźÅ
|
if (code == FLOW_SIGNAL) {
|
return FLOW_ACCEPT;
|
}
|
|
|
// Êý¾Ý
|
if (code == FLOW_SIGNAL) {
|
return FLOW_ACCEPT;
|
}
|
|
|
// ÎïÁÏ
|
if (code == FLOW_MOVE_MATERIAL) {
|
CGlass* pGlass = (CGlass*)pIntent->getContext();
|
ASSERT(pGlass);
|
if (!glassWillArrive(pGlass)) {
|
return FLOW_REJECT;
|
}
|
return glassArrived(pGlass);
|
}
|
|
|
|
return FLOW_ACCEPT;
|
}
|
|
int CEquipment::outputGlass(int port)
|
{
|
CPin* pOutPin = nullptr;
|
if (port == 0) {
|
pOutPin = getPin("Out");
|
if (pOutPin == nullptr) {
|
pOutPin = getPin("Out1");
|
}
|
}
|
else if (port == 1) {
|
pOutPin = getPin("Out2");
|
}
|
if (pOutPin == nullptr) {
|
return -1;
|
}
|
|
|
// Ä£ÄâÈ¡³öµÚÒ»ÕÅPanel,´«Ë͵½ÏÂÒ»»·½Ú
|
ULONGLONG time = CToolUnits::getTimestamp();
|
Lock();
|
if (m_glassList.empty()) {
|
Unlock();
|
return -2;
|
}
|
CGlass* pContext = m_glassList.front();
|
pContext->addRef();
|
|
CIntent intent(FLOW_MOVE_MATERIAL, "", pContext);
|
int nRet = pOutPin->sendIntent(&intent);
|
if (nRet == FLOW_REJECT) {
|
LOGE("<CEquipment>¶Ô·½¾Ü¾ø½ÓÊÕIntent.");
|
}
|
else if (nRet == FLOW_ACCEPT) {
|
CPath* pPath = pContext->getPathWithSiteID(m_nID);
|
if (pPath != nullptr) {
|
pPath->setOutTime(time);
|
}
|
m_glassList.pop_front();
|
pContext->release(); // Ìí¼Óµ½ÁжÓʱaddRef, È¡³öʱrelease
|
if (m_listener.onDataChanged != nullptr) {
|
m_listener.onDataChanged(this, 0);
|
}
|
}
|
|
pContext->release();
|
Unlock();
|
|
return 0;
|
}
|
|
BOOL CEquipment::glassWillArrive(CGlass* pGlass)
|
{
|
return TRUE;
|
}
|
|
int CEquipment::glassArrived(CGlass* pGlass)
|
{
|
Lock();
|
pGlass->addPath(m_nID);
|
pGlass->addRef();
|
m_glassList.push_back(pGlass);
|
Unlock();
|
|
if (m_listener.onDataChanged != nullptr) {
|
m_listener.onDataChanged(this, 0);
|
}
|
|
return FLOW_ACCEPT;
|
}
|
|
void CEquipment::addGlassToList(CGlass* pGlass)
|
{
|
ASSERT(pGlass);
|
|
Lock();
|
pGlass->addRef();
|
m_glassList.push_back(pGlass);
|
Unlock();
|
|
if (m_listener.onDataChanged != nullptr) {
|
m_listener.onDataChanged(this, 0);
|
}
|
}
|
|
BOOL CEquipment::removeClass(CGlass* pGlass)
|
{
|
Lock();
|
bool bExist = std::find(m_glassList.begin(), m_glassList.end(), pGlass) != m_glassList.end();
|
if (bExist) {
|
pGlass->addPath(EQ_ID_OPERATOR_REMOVE);
|
pGlass->release();
|
m_glassList.remove(pGlass);
|
}
|
Unlock();
|
|
if (bExist && m_listener.onDataChanged != nullptr) {
|
m_listener.onDataChanged(this, 0);
|
}
|
|
return bExist;
|
}
|
|
void CEquipment::getGlassList(std::list<CGlass*>& list)
|
{
|
Lock();
|
for (auto item : m_glassList) {
|
item->addRef();
|
list.push_back(item);
|
}
|
Unlock();
|
}
|
|
CGlass* CEquipment::getFrontGlass()
|
{
|
CGlass* pGlass = nullptr;
|
|
Lock();
|
if (!m_glassList.empty()) {
|
pGlass = m_glassList.front();
|
}
|
Unlock();
|
|
return pGlass;
|
}
|
|
bool CEquipment::isAlarmStep(SERVO::CStep* pStep)
|
{
|
return CToolUnits::startsWith(pStep->getName(), STEP_ALARM_START);
|
}
|
|
bool CEquipment::isPortTypeStep(SERVO::CStep* pStep)
|
{
|
std::regex pattern("^EQPort\\d+Type$");
|
return std::regex_match(pStep->getName(), pattern);
|
}
|
|
bool CEquipment::isPortModeStep(SERVO::CStep* pStep)
|
{
|
std::regex pattern("^EQPort\\d+Mode$");
|
return std::regex_match(pStep->getName(), pattern);
|
}
|
|
bool CEquipment::isPortCassetteTypeStep(SERVO::CStep* pStep)
|
{
|
std::regex pattern("^EQPort\\d+CassetteType$");
|
return std::regex_match(pStep->getName(), pattern);
|
}
|
|
bool CEquipment::isPortTransferModeStep(SERVO::CStep* pStep)
|
{
|
std::regex pattern("^EQPort\\d+TransferMode$");
|
return std::regex_match(pStep->getName(), pattern);
|
}
|
|
bool CEquipment::isPortEnableStep(SERVO::CStep* pStep)
|
{
|
std::regex pattern("^EQPort\\d+Enable$");
|
return std::regex_match(pStep->getName(), pattern);
|
}
|
|
bool CEquipment::isPortTypeAutoChangeEnableStep(SERVO::CStep* pStep)
|
{
|
std::regex pattern("^EQPort\\d+CassetteType$");
|
return std::regex_match(pStep->getName(), pattern);
|
}
|
|
bool CEquipment::isCassetteTransferStateStep(SERVO::CStep* pStep)
|
{
|
std::regex pattern("^EQPort\\d+Cassette.*");
|
return std::regex_match(pStep->getName(), pattern);
|
}
|
|
bool CEquipment::isCimMessageConfirmStep(SERVO::CStep* pStep)
|
{
|
return pStep->getName().compare(STEP_EQ_CIM_MESSAGE_CONFIRM) == 0;
|
}
|
|
bool CEquipment::isVcrEventStep(SERVO::CStep* pStep)
|
{
|
return pStep->getName().compare(STEP_EQ_VCR1_EVENT_REPORT) == 0;
|
}
|
|
int CEquipment::setEqMode(short mode)
|
{
|
SERVO::CEqModeChangeStep* pStep = (SERVO::CEqModeChangeStep*)getStepWithName(STEP_EQ_MODE_CHANGE);
|
if (pStep == nullptr) {
|
return -1;
|
}
|
|
return pStep->setEqMode(mode);
|
}
|
|
int CEquipment::setCimMode(BOOL bOn)
|
{
|
SERVO::CEqCimModeChangeStep* pStep = (SERVO::CEqCimModeChangeStep*)getStepWithName(STEP_CIM_MODE_CHANGE);
|
if (pStep == nullptr) {
|
return -1;
|
}
|
|
if (bOn)
|
return pStep->cimOn();
|
else
|
return pStep->cimOff();
|
}
|
|
int CEquipment::setCimMessage(const char* pszMessage, short id, short nTouchPanelNo)
|
{
|
SERVO::CEqCimMessageCmdStep* pStep = (SERVO::CEqCimMessageCmdStep*)getStepWithName(STEP_CIM_MESSAGE_CMD);
|
if (pStep == nullptr) {
|
return -1;
|
}
|
|
return pStep->setCimMessage(pszMessage, id, nTouchPanelNo);
|
}
|
|
int CEquipment::clearCimMessage(short id, short nTouchPanelNo)
|
{
|
SERVO::CEqCimMessageClearStep* pStep = (SERVO::CEqCimMessageClearStep*)getStepWithName(STEP_CIM_MESSAGE_CLEAR);
|
if (pStep == nullptr) {
|
return -1;
|
}
|
|
return pStep->clearCimMessage(id, nTouchPanelNo);
|
}
|
|
int CEquipment::setDateTime(short year, short month, short day, short hour, short minute, short second)
|
{
|
SERVO::CEqDateTimeSetCmdStep* pStep = (SERVO::CEqDateTimeSetCmdStep*)getStepWithName(STEP_DATETIME_SET_CMD);
|
if (pStep == nullptr) {
|
return -1;
|
}
|
|
return pStep->setDateTime(year, month, day, hour, minute, second);
|
}
|
}
|
