LAPTOP-SNT8I5JK\Boounion
2025-05-21 83c4b402947892eafe9ec9d732d3159d07d6228a
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
#pragma once
#include <string>
#include "IUnit.h"
#include <functional>
#include <map>
 
 
#define LAYER_LOAD_INIT        0
#define LAYER_NOT_READY        1
#define LAYER_LOAD_REQ        2
#define LAYER_UNLOAD_REQ    3
 
namespace BEQ {
    typedef std::function<void(void* pUnit, EQ_STATE)> ONSTATECHANGED;
    typedef std::function<void(void* pUnit, int stete)> ONDOORSTATECHANGED;
    typedef std::function<void(void* pUnit, int code, int level, const char* pszText)> ONALARM;
    typedef std::function<void(void* pUnit, STEP_STATE state)> ONSTEPCHANGED;
    typedef std::function<void(void* pUnit, unsigned long long time)> ONDATACHANGED;
    typedef std::function<void(void* pUnit, int layer)> ONREQLOAD;
 
    typedef struct _UnitListener
    {
        ONSTATECHANGED        onStateChanged;
        ONDOORSTATECHANGED    onDoorStateChanged;
        ONALARM                onAlarm;
        ONALARM                onRemoveAlarm;
        ONSTEPCHANGED        onStepChanged;
        ONDATACHANGED        onDataChanged;
        ONREQLOAD            onReqNotReady;
        ONREQLOAD            onReqLoad;
        ONREQLOAD            onReqUnload;
    } UnitListener;
 
    class CUnit :
        public IUnit
    {
    public:
        CUnit();
        CUnit(const char* pszName);
        ~CUnit();
 
    public:
        virtual int getName(char* pszBuffer, int nMaxCount);
        virtual void setState(EQ_STATE state);
        virtual EQ_STATE getState();
        virtual void setDoorCount(int count);
        virtual void setDoorState(int state);
        virtual int getDoorState();
        virtual void setLayerCount(int count);
        virtual int getLayerCount();
        virtual void setIndex(int index);
        virtual int getIndex();
        virtual void setAlarm(int code, int level, const char* pszText);
        virtual int getAlarmCode();
        virtual int getAlarmLevel();
        virtual void stepIdle();
        virtual void stepMaterialReceived(const char* pszID);
        virtual void stepMaterialRemoved(const char* pszID);
        virtual void stepProcessingStarted(const char* pszID);
        virtual void stepProcessing(const char* pszID, int nSvTime, int nTvTime);
        virtual void stepProcessingCompleted(const char* pszID);
        virtual STEP_STATE getStepState();
        virtual void setDataTime(unsigned long long time);
        virtual void setDataTimeAndResetData(unsigned long long time);
        virtual unsigned long long getDataTime();
        virtual void addData(const char* pszName, const char* pszDataText, bool bComplete);
        virtual void addRecipe(int id, const char* pszName, bool bComplete);
        virtual int reqNotReady(int layer);
        virtual int reqLoad(int layer);
        virtual int reqUnload(int layer);
        
    public:
        void setListener(UnitListener listener);
        std::string& getName();
        const char* getStateText();
        void setStateFromString(std::string& strState);
        std::string& getDoorState(std::string& strState);
        std::string& getAlarmText();
        const char* getStepStateText();
        std::string& getStepMaterialId();
        int getStepSvTime();
        int getSetpPvTime();
        uint64_t stringToTimeStamp(const std::string& strTime);
        const char* getDataTimeText(uint64_t time);
        std::map<std::string, std::string>& getDatas();
        std::map<int, std::string>& getRecipes();
        bool checkRecipe(int id, const char* pszName);
        void resetLoadState();
 
    private:
        UnitListener m_listener;
        std::string m_strName;
        EQ_STATE m_eqState;
        int m_nDoorCount;
        int m_doorState;
        int m_nAlarmCode;
        int m_nAlarmLevel;
        std::string m_strAlarmText;
 
    private:
        STEP_STATE m_stepState;
        std::string m_stepMaterialId;
        int m_stepSvTime;
        int m_stepPvTime;
        unsigned long long m_dataTime;
        std::map<std::string, std::string> m_dataMap;
        std::map<int, std::string> m_mapRecipe;
 
    private:
        int m_nLayerCount;
        int m_nLayerLoadState[8];        // ¸÷²ãÉÏÏÂÁÏ״̬£¬0£ºÎ´Öª£»1£ºÉÏÁÏÇëÇó£»2£ºÏÂÁÏÇëÇó
        int m_nIndex;
    };
}