क्वांटम लीप्स QP और UML राज्यचक्र

प्रस्तावना

यह लेख, मुझे ऐसा लगता है, जो उन लोगों के लिए दिलचस्प होगा जो यूएमएल राज्य और अनुक्रम आरेख (स्टेटचर्ट्स आरेख और अनुक्रम आरेख) के साथ - साथ घटना-उन्मुख प्रोग्रामिंग (इवेंट-संचालित प्रोग्रामिंग) के साथ परिचित हैं।

प्रविष्टि

क्वांटम लीप्स क्रॉस-प्लेटफॉर्म QP फ्रेमवर्क (क्वांटम प्लेटफॉर्म) को इसके रचनाकारों ने COS / C ++ में RTOS विकसित करने के साधन के रूप में पेश किया था। यह विकास की गति और अनुप्रयोगों की विश्वसनीयता में काफी वृद्धि करेगा, और इसमें शक्तिशाली डिबगिंग और लॉगिंग टूल भी होंगे। इन सभी में यह तथ्य जोड़ा गया है कि क्यूपी बहुत लचीला और आसान है: इसे कई मॉड्यूलों में विभाजित किया गया है, जिनमें से प्रत्येक को फ्रेमवर्क का निर्माण करते समय या प्रस्तावित समाधान का उपयोग करते हुए स्वयं द्वारा कार्यान्वित किया जा सकता है; कई सेटिंग्स precompilation के दौरान किए जाते हैं।



क्यूपी का उपयोग करते हुए लिखा गया एक कार्यक्रम यूएमएल राज्यचरों के एक सेट का कार्यान्वयन है।
यह लेख क्यूईपी मॉड्यूल की एक अंतर्निहित समीक्षा है, जो कि रूपरेखा (क्यूईपी इम्प्लिमेंट्स इवेंट प्रोसेसिंग) का आधार है, और आगे के अध्ययन को प्रोत्साहित करने के उद्देश्य से लिखा गया है।

QP में इवेंट प्रोसेसिंग सिस्टम

राज्य आरेखों को लागू करने के लिए, क्यूपी एक यूएमएल-संगत इवेंट प्रोसेसिंग सिस्टम प्रदान करता है। लेकिन आपको एक परिस्थिति पर ध्यान देना चाहिए: केवल स्थानीय बदलावों को फ्रेमवर्क द्वारा समर्थित किया जाता है, अर्थात्, एक विकल्प के लिए एक संक्रमण एक निकास घटना के साथ नहीं होता है, और एक सुपरस्टेट के लिए एक संक्रमण एक प्रविष्टि घटना नहीं बढ़ाता है। यूएमएल 2 में, पिछले संस्करणों के साथ संगतता के लिए, बाहरी संक्रमण करने की क्षमता छोड़ी गई थी। भाषा के पुराने संस्करणों में, केवल बाहरी परिवर्तन उपलब्ध हैं: किसी भी संक्रमण के साथ क्रमशः वर्तमान और लक्ष्य राज्यों के लिए एक निकास और प्रवेश घटना होती है।



QP डेवलपर को निम्न वर्ग प्रदान करता है:
एकल स्तरीय राज्य मशीन (सुपरस्टेट के बिना) लागू करने के लिए QFsm
एक पदानुक्रमित ऑटोमेटन (सुपरस्टेट के साथ) को लागू करने के लिए QHsm
इन वर्गों की वस्तुएं यूएमएल आरेख की वर्तमान स्थिति को संग्रहीत करती हैं, और इस घटना को संभालने के लिए एक सार्वजनिक विधि void dispatch ( const QEvent * e ) है।
QP, QActive वर्ग भी प्रदान करता है, जो डिफ़ॉल्ट रूप से QHsm का विस्तार है (इसे QFsm में बदला जा सकता है)। इस वर्ग की वस्तुएं, जिन्हें सक्रिय वस्तु कहा जाता है, निष्पादन की एक अलग थ्रेड में काम करने की मशीन की क्षमता को लागू करती हैं।

QP में एक घटना QEvent वर्ग या उसके वंशजों की एक वस्तु है। प्रत्येक घटना को एक संकेत द्वारा चित्रित किया जाता है - एक सिग क्षेत्र जो एक प्रकार की घटना को दूसरे से अलग करता है।

QP में एक अवस्था एक फंक्शन (या स्टैटिक मेथड) है, एक पॉइंटर जिसका रूप है:
typedef QState ( * QStateHandler ) ( void * me, QEvent const * e ) , जहां मेरा संदर्भ है (एक ऑटोमेटन ऑब्जेक्ट), e प्राप्त घटना है

घटना को संभालने के लिए राज्य तीन मुख्य तरीकों के लिए रूपरेखा प्रदान करता है:

• Q_HANDLED () , यदि आपको संक्रमण किए बिना घटना को संसाधित करने की आवश्यकता है;
• Q_TRAN (<अगले राज्य का पता>) - एक परिवर्तन करें;
• Q_SUPER (<सुपरस्टेट एड्रेस>) - सुपरस्टेट करने के लिए पास। केवल QHsm वेंडिंग मशीनों के लिए उपलब्ध है।

क्यूपी में विशेष घटनाएं भी हैं जो संक्रमण के दौरान उत्पन्न हो सकती हैं। इन घटनाओं के होने का क्रम और संक्रमण के दौरान क्रियाओं का क्रम निम्नानुसार है:

1. परमाणु संक्रमण क्रियाएं की जाती हैं;
2. निकास घटना ( Q_EXIT_SIG )। इसे बाहर निकलने पर वर्तमान स्थिति में होता है। यदि, इसके अलावा, सुपरस्टेट बाहर निकल जाता है, तो इस सुपरस्टेट के लिए बाहर निकलने के तुरंत बाद बाहर निकलता है। बाहर निकलने की घटना को केवल संसाधित किया जा सकता है ( Q_HANDLED );
3. मशीन लक्ष्य अवस्था में चली जाती है;
4. प्रविष्टि घटना ( Q_ENTRY_SIG )। राज्य में प्रवेश करते समय होता है। इस घटना को केवल संसाधित किया जा सकता है;
5. एक संकेत के साथ घटना Q_INIT_SIG (केवल QHsm- स्वचालित उपकरणों के लिए) - एक आरंभ करने वाली घटना। यह हमेशा उठता है। स्थानापन्न करने के लिए संक्रमण ( Q_TRAN ) बनाने के लिए कार्य करता है, लेकिन सिद्धांत रूप में इसे बस संसाधित किया जा सकता है;

QFsm राज्यों का सामान्य दृष्टिकोण:

static QState state1(Fsm* me, const QEvent* e) {
switch (e->sig) {
case Q_ENTRY_SIG: {
/* processing */
return Q_HANDLED();
}
case EVENT1_SIG: {
/* processing */
return Q_TRAN(&state2);
}
case EVENT2_SIG: {
/* processing */
return Q_HANDLED();
}
case Q_EXIT_SIG: {
/* processing */
return Q_HANDLED();
}
}
return Q_HANDLED();
}

* This source code was highlighted with Source Code Highlighter .

QHsm राज्यों का सामान्य दृष्टिकोण:

static QState state1(Hsm* me, const QEvent* e) {
switch (e->sig) {
case Q_ENTRY_SIG: {
/* processing */
return Q_HANDLED();
}
case Q_INIT_SIG: {
/* processing */
return Q_TRAN(&state1_substate1); // return Q_HANDLED();
}
case EVENT1_SIG: {
/* processing */
return Q_TRAN(&state2);
}
case EVENT2_SIG: {
/* processing */
return Q_HANDLED();
}
case Q_EXIT_SIG: {
/* processing */
return Q_HANDLED();
}
}
return Q_SUPER(&superstate1);
}

* This source code was highlighted with Source Code Highlighter .

Q_ENTRY_SIG , Q_INIT_SIG , Q_EXIT_SIG प्रकार की विशेष घटनाएँ एक ही राज्य में मौजूद हैं और उन्हें सुपरस्टेट में नहीं सौंपा गया है, उन्हें संसाधित करना आवश्यक नहीं है।

उदाहरण

एक सक्रिय ऑब्जेक्ट ( sm ) और उस पर एक तरफ़ा प्रभाव वाली प्रणाली पर विचार करें। इस स्थिति में, आप मल्टीटास्किंग मॉड्यूल ( QK ) और QActive वर्ग का उपयोग किए बिना कर सकते हैं।



बता दें कि ऑब्जेक्ट स्म में एक स्टेट डायग्राम होता है, जो एक पदानुक्रमित परिमित स्टेट मशीन है।



यह आप QP का उपयोग करके इस कार्य को कैसे लागू कर सकते हैं:

//
enum Signals {
PROCEED_SIG = Q_USER_SIG,
CANCEL_SIG,
};

// , PROCEED_SIG
struct ProceedEvt : public QEvent {
ProceedEvt( int value = 0) : value ( value ) { sig = PROCEED_SIG; }
int value ;
};

// , CANCEL_SIG
struct CancelEvt : public QEvent {
CancelEvt() { sig = CANCEL_SIG; }
};

// sm
class Hsm : public QHsm {
public :
Hsm() : QHsm((QStateHandler)&initial) { init(); }

private :
// initial state
static QState initial(Hsm* me, const QEvent* e) {
return Q_TRAN(&superState);
}

static QState superState(Hsm* me, const QEvent* e) {
switch (e->sig) {
case Q_ENTRY_SIG: {
me->count = 10;
return Q_HANDLED();
}
case Q_INIT_SIG: {
return Q_TRAN(&stateA);
}
case CANCEL_SIG: {
return Q_TRAN(&stateC);
}
}

/* QHsm::top - ,
* Q_HANDLED(). */
return Q_SUPER(&QHsm::top);
}

static QState stateA(Hsm* me, const QEvent* e) {
switch (e->sig) {
case PROCEED_SIG: {
return Q_TRAN(&stateB);
}
}
return Q_SUPER(&superState);
}

static QState stateB(Hsm* me, const QEvent* e) {
switch (e->sig) {
case PROCEED_SIG: {
if (me->count > 1) {
me->count *= 2;
return Q_TRAN(&stateA);
}
++me->count;
return Q_HANDLED();
}
case Q_EXIT_SIG: {
cout << "count = " << me->count << endl;
me->count = 0;
return Q_HANDLED();
}
}
return Q_SUPER(&superState);
}

static QState stateC(Hsm* me, const QEvent* e) {
switch (e->sig) {
case PROCEED_SIG: {
if (static_cast< const ProceedEvt*>(e)-> value == 1) {
return Q_TRAN(&superState);
}
break ;
}
}
return Q_SUPER(&QHsm::top);
}

int count;
};

* This source code was highlighted with Source Code Highlighter .

अब कक्षा Hsm की एक स्माइल ऑब्जेक्ट बनाएं (ऊपर दिए गए अनुक्रम आरेख देखें) और एक दर्जन घटनाओं की प्रक्रिया करें:

int main( int argc, char * argv[]) {
Hsm sm; // stateA, count = 10

for ( int i = 0; i < 2; ++i) {
sm.dispatch(&ProceedEvt()); // stateB, count = 10
sm.dispatch(&ProceedEvt()); // stateA, count = 0
sm.dispatch(&ProceedEvt()); // stateB, count = 0
sm.dispatch(&ProceedEvt()); // stateB, count = 1
sm.dispatch(&ProceedEvt()); // stateB, count = 2
sm.dispatch(&ProceedEvt()); // stateA, count = 0
sm.dispatch(&ProceedEvt()); // stateB, count = 0
sm.dispatch(&ProceedEvt()); // stateB, count = 1
sm.dispatch(&ProceedEvt()); // stateB, count = 2
sm.dispatch(&CancelEvt()); // stateC, count = 2
sm.dispatch(&CancelEvt()); // stateC, count = 2
sm.dispatch(&ProceedEvt()); // stateC, count = 2
sm.dispatch(&ProceedEvt(1)); // stateA, count = 10
}

return 0;
}

* This source code was highlighted with Source Code Highlighter .

निष्कर्ष

यूएमएल राज्यों के अन्य साधन: छद्म राज्य प्रारंभिक, अंतिम, इतिहास, गहरा इतिहास और अन्य; स्थगित घटना प्रसंस्करण, राज्य के ऑर्थोगोनल घटक, छिपी हुई स्थिति, आदि को "राज्य डिजाइन पैटर्न" का उपयोग करके आसानी से लागू किया जाता है, जिनमें से पांच पुस्तक में दिए गए हैं, जिनकी मैं नीचे चर्चा करूंगा।

QP के लाभ

• C में उपयोग का सिद्धांत C ++ से लगभग अलग नहीं है;
• खुलता है, स्रोत कोड अच्छी तरह से टिप्पणी की है;
• QP को पहले से ही कई प्रणालियों में चित्रित किया गया है, विशेष रूप से GNU लिनक्स सिस्टम में;
• क्वांटम लीप्स से क्यूएम राज्य आरेख मॉडलिंग के लिए एक उपकरण है;
• क्वांटम लीप्स उत्पादों का उपयोग काफी बड़ी कंपनियों द्वारा किया जाता है।

किताब के बारे में

QP एक बड़ी पुस्तक के साथ आता है, C / C ++ में प्रैक्टिकल यूएमएल स्टेटचर्स, दूसरा संस्करण: क्वांटम लीप्स के संस्थापक से एंबेडेड सिस्टम के लिए इवेंट-ड्रिव्ड प्रोग्रामिंग, जिसे 2 भागों में विभाजित किया गया है: पहला बताता है कि फ्रेमवर्क का उपयोग कैसे करें, और दूसरा एक। यह कैसे काम करता है, अपने सिस्टम के लिए QP को कैसे तेज करें, QS ट्रैसर (QSpy) का उपयोग कैसे करें, और QP-nano क्या है।

ट्यूटोरियल फ्रेमवर्क, स्टेट पैटर्न और स्विच विधि के उपयोग की तुलना भी करता है।

पुस्तक में पैसा खर्च होता है, लेकिन "मुफ्त डाउनलोड" के लिए इंटरनेट पर पाया जा सकता है।

संदर्भ

• यहाँ लेख के उदाहरण हैं ;
• यहाँ GNU लिनक्स x64 के लिए 32-बिट QP पोर्ट है।