क्वांटम लीप्स के आधार पर एंबेडेड सिस्टम के लिए विकास

क्वांटम लीप्स या क्यूपी एम्बेडेड सिस्टम को विकसित करने के लिए ओपन सोर्स फ्रेमवर्क का एक परिवार है। QP मुख्य OS (Linux, Windows, FreeRTOS, आदि) या इसके बिना काम कर सकता है। QP को विभिन्न प्रोसेसर परिवारों की एक बड़ी संख्या में पोर्ट किया गया है।

एक QP एप्लिकेशन को कई राज्य मशीनों के रूप में डिज़ाइन किया गया है जो UML राज्यचर्चा पर आधारित हैं।

निम्नलिखित एक बहुत ही सरल परिमित स्टेट मशीन एप्लीकेशन डिजाइन करने का एक उदाहरण है।





1. रूपरेखा प्राप्त करें

आरंभ करने के लिए, परियोजना की वेबसाइट पर जाएं और पुस्तकालय स्रोतों को डाउनलोड करें। अगला, Win32 के लिए उदाहरण के साथ एसडीके डाउनलोड करें। उदाहरण कंसोल में डाइनिंग दार्शनिकों की समस्या के समाधान को Win32 API और MFC पर दिखाता है। दस्तावेज़ फ़ोल्डर में कंसोल एप्लिकेशन डिज़ाइन प्रक्रिया का पूरा विवरण भी होता है।

उदाहरण काफी जटिल है, इसलिए, बहुत सरल कुछ के साथ शुरू करने के लिए, मैंने अपनी समस्या को हल करने के साथ आने का फैसला किया।



2. समस्या का विवरण

लोडर बॉब कन्वेयर पर काम करता है, जो बक्से को गोदाम तक पहुंचाता है। अगर कन्वेयर पर एक बॉक्स है, तो बॉब इसे लेता है और उसे ढेर करता है। यदि कोई बॉक्स नहीं है, तो बॉब खड़ा है और इंतजार करता है। जब बॉक्स कन्वेयर पर दिखाई देता है, तो बॉब का ध्यान आकर्षित करने के लिए एक घंटी बजती है। जब बीन बॉक्स उठाता है, तो वह बटन दबाता है और दिखाता है कि अगले बॉक्स को कन्वेयर के साथ जोड़ा जा सकता है।



3. राज्य आरेख

हम राज्य आरेख के रूप में समस्या का वर्णन करते हैं। समस्या में दो ऑटोमेटा (सक्रिय वस्तुएं) हैं।







पहली बीओबी मशीन नि: शुल्क स्थिति में अपना जीवन शुरू करती है (लोडर काम में व्यस्त नहीं है और बॉक्स लेने के लिए तैयार है)। BOB समय-समय पर एक Timeout_sig सिग्नल उत्पन्न करता है। ऐसा करने के लिए, इसे CONVEYOR को टाइमआउट सिग्नल प्रसारित करना होगा। टाइमआउट सिग्नल प्राप्त करते समय, CONVEYOR को पूर्ण स्थिति में जाना चाहिए (एक बॉक्स कन्वेयर पर दिखाई दिया है) और तैयार सिग्नल के रूप में एक बीओबी अधिसूचना भेजें। तैयार सिग्नल प्राप्त करने वाले BOB को WORK राज्य में जाना चाहिए (बॉक्स ले लिया) और गेट सिग्नल को वापस भेजना चाहिए। Get प्राप्त करने पर, CONVEYOR ऑब्जेक्ट EMPTY अवस्था में प्रवेश करता है। BOB जब Timeout_sig को मुफ़्त स्थिति में लाती है।



4. अनुप्रयोग विकास

QP डेवलपर का मुख्य कार्य राज्य आरेख का उपयोग करके सक्रिय वस्तुओं की कक्षाएं लिखना है। वस्तुओं को प्राप्त संकेतों को संसाधित करना होगा और कुछ निश्चित परिस्थितियों में आवश्यक सिग्नल भेजना होगा।



परियोजना की सामग्री

QP प्रोजेक्ट को आमतौर पर निम्नलिखित भागों में विभाजित किया जाता है:

1) वैश्विक चर और स्थिरांक - qpbob.h

2) हार्डवेयर-विशिष्ट कोड - bsp.h, bsp.cpp

3) सक्रिय वस्तुएं - bob.cpp, कन्वेयर ।pp

4) प्रवेश बिंदु - main.cpp



हम संकेतों को निर्धारित करते हैं

राज्य आरेख का उपयोग करके, हम उन संकेतों को निर्धारित करते हैं जो सिस्टम में हैं और qpbob.h फ़ाइल में उनके प्रकार की गणना निर्धारित करते हैं।

#ifndef qpbob_h

#define qpbob_h

//(1)

enum DPPSignals {

READY = Q_USER_SIG,

GET,

TIMEOUT,

TERMINATE_SIG,

MAX_PUB_SIG,

MAX_SIG

};



//(2)

extern QActive * const AO_BOB;

extern QActive * const AO_CONVEYOR;



#endif



* This source code was highlighted with Source Code Highlighter .

स्पष्टीकरण:

1) पहला उपयोगकर्ता संकेत निरंतर Q_USER_SIG से शुरू होना चाहिए। गणना में कई सर्विस सिग्नल होते हैं: TERMINATE_SIG - एप्लिकेशन पूरा होने के संकेत; रसीद पर, सक्रिय वस्तुओं को सही ढंग से अपने काम को रोकना चाहिए; MAX_PUB_SIG - इसके बाद घोषित संकेतों को केवल ऑब्जेक्ट से ऑब्जेक्ट पर सीधे प्रेषित किया जा सकता है, और शेष सिग्नल सिस्टम के सभी ऑब्जेक्ट्स के लिए उपलब्ध हैं; MAX_SIG - सिस्टम में अधिकतम सिग्नल संख्या। TIMEOUT_SIG संकेत यहां निर्दिष्ट नहीं है क्योंकि इसका उपयोग केवल सक्रिय बॉब ऑब्जेक्ट के अंदर किया जाता है।

2) सक्रिय सिस्टम ऑब्जेक्ट्स के लिए वैश्विक संकेत। ऑब्जेक्ट बनाते समय प्रारंभिक।



हार्डवेयर डिपेंडेंट कोड लिखना

क्यूपी का उपयोग बड़ी संख्या में हार्डवेयर प्लेटफार्मों के साथ किया जा सकता है। सक्रिय वस्तुओं का विवरण और उनकी बातचीत एक विशिष्ट मंच पर निर्भर नहीं करती है। कोड जो हार्डवेयर पर निर्भर करता है, सक्रिय वस्तुओं से अलग लिखना बेहतर होता है। हमारे उदाहरण में, सक्रिय ऑब्जेक्ट bsp.h फ़ाइल में खुले कार्यों का उपयोग करते हैं

#ifndef bsp_h

#define bsp_h

//(1)

#define BSP_TICKS_PER_SEC 1

//(2)

void BSP_init( int argc, char *argv[]);

void BSP_print( char const *str);

#endif // bsp_h



* This source code was highlighted with Source Code Highlighter .

स्पष्टीकरण:

1) हम आंतरिक सिस्टम टाइमर की आवृत्ति सेट करते हैं।

2) BSP_init फ़ंक्शन हार्डवेयर को प्रारंभ करता है। BSP_print फंक्शन एक सेकंड के कई दसवें हिस्से के रूप में टाइम स्टैम्प लगाकर कंसोल को टेक्स्ट प्रिंट करता है।

फ़ंक्शन का कार्यान्वयन bsp.cpp फ़ाइल में है।

#include "qp_port.h"

#include "qpbob.h"

#include "bsp.h"



#include <conio.h>

#include <stdlib.h>

#include <stdio.h>

#include <time.h>



Q_DEFINE_THIS_FILE



//(1)

unsigned int TimeCounter;

//(2)

void BSP_timeStamp()

{

printf( "%d - " ,TimeCounter);

}



//(3) idle-

static uint8_t l_running;

//(4) idle-

static DWORD WINAPI idleThread(LPVOID par) {

TimeCounter=0;

( void )par;

l_running = (uint8_t)1;

while (l_running) {

Sleep(100);

TimeCounter++;

//(5) Esc

if (_kbhit()) {

if (_getch() == '\33' ) {

QF::publish(Q_NEW(QEvent, TERMINATE_SIG));

BSP_print( "Esc exit" );

}

}



}

return 0;

}

//(6)

void BSP_init( int argc, char *argv[]) {

HANDLE hIdle;

//(7)

QF_setTickRate(BSP_TICKS_PER_SEC);

//(8) idle

hIdle = CreateThread(NULL, 1024, &idleThread, ( void *)0, 0, NULL);

Q_ASSERT(hIdle != (HANDLE)0);

SetThreadPriority(hIdle, THREAD_PRIORITY_IDLE);



printf( "QP example"

"\nQEP %s\nQF %s\n"

"Press ESC to quit...\n" ,

QEP::getVersion(),

QF::getVersion());

}

//............................................................................

void QF::onStartup( void ) {

}

//(9)..........................................................................

void QF::onCleanup( void ) {

l_running = (uint8_t)0;

}



//............................................................................

void BSP_print( char const *str)

{

BSP_timeStamp();

printf( "%s\n" , str);

}

//(10)

void Q_onAssert( char const Q_ROM * const Q_ROM_VAR file, int line) {

fprintf(stderr, "Assertion failed in %s, line %d" , file, line);

exit(0);

}





* This source code was highlighted with Source Code Highlighter .

स्पष्टीकरण:

1) सिस्टम शुरू करने से ऑपरेटिंग समय की गणना के लिए चर।

2) समय काउंटर का मूल्य प्रदर्शित करता है।

3) जबकि चर का मान 0 नहीं है, निष्क्रिय थ्रेड काम कर रहा है।

4) कीबोर्ड की निगरानी के लिए सिस्टम में एक बेकार धागा लॉन्च किया गया है।

5) जब Esc दबाया जाता है, तो TERMINATE_SIG को समाप्त करने के लिए एक संदेश सिस्टम पर भेजा जाता है।

6) फ़ंक्शन एप्लिकेशन को इनिशियलाइज़ करता है।

7) सिस्टम टाइमर की आवृत्ति।

8) बेकार की धारा शुरू करना।

9) सिस्टम बंद होने के बाद, निष्क्रिय धारा बंद हो जाती है।

10) डिबगिंग सूचना के उत्पादन के लिए एक समारोह का कार्यान्वयन।



सिस्टम स्टार्टअप

सिस्टम main.cpp फ़ाइल के मुख्य फ़ंक्शन में शुरू होता है। आपको सभी आवश्यक वस्तुओं को बनाने और सक्रिय वस्तुओं पर नियंत्रण स्थानांतरित करने की आवश्यकता है।

#include "qp_port.h"

#include "qpbob.h"

#include "bsp.h"



//(1)

static QEvent const *l_bobQueueSto[10];

static QEvent const *l_conQueueSto[10];

//(2)

static QSubscrList l_subscrSto[MAX_PUB_SIG];

//(3) ,

static union SmallEvents {

void *min_size;



} l_smlPoolSto[10];



int main( int argc, char *argv[]) {



//(4) BSP

BSP_init(argc, argv);



//(5)

QF::init();



//(6)

QS_FILTER_ON(QS_ALL_RECORDS);

QS_FILTER_OFF(QS_QF_INT_LOCK);

QS_FILTER_OFF(QS_QF_INT_UNLOCK);

QS_FILTER_OFF(QS_QF_ISR_ENTRY);

QS_FILTER_OFF(QS_QF_ISR_EXIT);

QS_FILTER_OFF(QS_QF_TICK);

QS_FILTER_OFF(QS_QK_SCHEDULE);



//(7)

QS_OBJ_DICTIONARY(l_smlPoolSto);



//(8)

QF::psInit(l_subscrSto, Q_DIM(l_subscrSto));



//(9)

QF::poolInit(l_smlPoolSto, sizeof (l_smlPoolSto), sizeof (l_smlPoolSto[0]));



//(10)

AO_CONVEYOR->start(2,

l_conQueueSto, Q_DIM(l_conQueueSto),

( void *)0, 1024, (QEvent *)0);

AO_BOB->start(3,

l_bobQueueSto, Q_DIM(l_bobQueueSto),

( void *)0, 1024, (QEvent *)0);





//(11)

QF::run();



return 0;

}



* This source code was highlighted with Source Code Highlighter .

स्पष्टीकरण:

1) प्रत्येक सक्रिय वस्तु को संकेतों को संग्रहीत करने के लिए एक सरणी की आवश्यकता होती है।

2) हमें संकेतों के लिए वस्तुओं की सदस्यता को संग्रहीत करने के लिए एक सरणी की आवश्यकता है। यदि वस्तु सार्वजनिक संकेत प्राप्त करना चाहती है, तो उसे इसकी सदस्यता लेनी चाहिए।

3) अतिरिक्त डेटा वाले सिग्नल को एक विशेष पूल (यहां उपयोग नहीं किया गया) की आवश्यकता होती है।

4) हम हार्डवेयर को इनिशियलाइज़ करते हैं।

5) हम सिस्टम को इनिशियलाइज़ करते हैं।

6) सिस्टम सेटअप।

7) ईवेंट पूल को पंजीकृत करें।

8) हम ग्राहकों की सूची को इनिशियलाइज़ करते हैं।

9) हम ईवेंट पूल को इनिशियलाइज़ करते हैं।

10) सक्रिय वस्तुओं को चलाएं।

11) हम सिस्टम शुरू करते हैं। अब सक्रिय ऑब्जेक्ट एक दूसरे के साथ बातचीत करते हैं और एप्लिकेशन चल रहा है।



सक्रिय वस्तुओं

सक्रिय सिस्टम ऑब्जेक्ट एक राज्य आरेख के आधार पर लिखे गए हैं। आइए बॉब ऑब्जेक्ट के कार्यान्वयन पर विस्तार से विचार करें, bob.cpp फ़ाइल। सक्रिय वस्तुएं QActive वर्ग से विरासत में मिली हैं।

#include "qp_port.h"

#include "qpbob.h"

#include "bsp.h"



Q_DEFINE_THIS_FILE



class Bob : public QActive {



private :

//(1)

QTimeEvt m_timeEvt;

public :

Bob();



private :

//(2)

//

static QState initial(Bob *me, QEvent const *e);

static QState free(Bob *me, QEvent const *e);

static QState work(Bob *me, QEvent const *e);

};



static Bob l_Bob;



#define TIMEOUT_TIME 1



//(3)

enum InternalSignals {

TIMEOUT_SIG = MAX_SIG

};



QActive * const AO_BOB = &l_Bob;



//............................................................................

Bob::Bob() : QActive((QStateHandler)&Bob::initial),

m_timeEvt(TIMEOUT_SIG){ //(4)







}

//............................................................................

QState Bob::initial(Bob *me, QEvent const *) {



BSP_print( "Bob initial" );

//

QS_OBJ_DICTIONARY(&l_Bob);

QS_OBJ_DICTIONARY(&l_Bob.m_timeEvt);

//

QS_FUN_DICTIONARY(&QHsm::top);

QS_FUN_DICTIONARY(&Bob::initial);

QS_FUN_DICTIONARY(&Bob::free);

QS_FUN_DICTIONARY(&Bob::work);

//



QS_SIG_DICTIONARY(READY, me);

QS_SIG_DICTIONARY(TIMEOUT_SIG, me);

//(5)



me->subscribe(READY);

me->subscribe(TERMINATE_SIG);



//(6)

me->m_timeEvt.postIn(me, TIMEOUT_TIME);



//(7)

return Q_TRAN(&Bob::free);

}

//............................................................................

QState Bob::free(Bob *me, QEvent const *e) {



BSP_print( "Bob free" );

//(8)

switch (e->sig) {

//(9)

case Q_ENTRY_SIG: {



return Q_HANDLED();

}

//(10)



case READY:

{

BSP_print( "O my box READY. Going work" );



return Q_TRAN(&Bob::work);

}

case TIMEOUT_SIG:

{

BSP_print( "Tick Free - Bob" );

//(11)

me->m_timeEvt.postIn(me, TIMEOUT_TIME);

//(12)

QEvent* be=Q_NEW(QEvent,TIMEOUT);

QF::publish(be);





return Q_HANDLED();

}

//(13)

case TERMINATE_SIG: {

BSP_print( "Bob terminate.----------------------------------------------" );

QF::stop(); //(14)

//(15)

return Q_HANDLED();

}

}

return Q_SUPER(&QHsm::top);

}



QState Bob::work(Bob *me, QEvent const *e) {



BSP_print( "Bob work" );



switch (e->sig) {



case Q_ENTRY_SIG: {

QEvent* be=Q_NEW(QEvent,GET);

QF::publish(be);

BSP_print( "Bob public GET" );





return Q_HANDLED();

}



case TIMEOUT_SIG:

{

BSP_print( "Tick Work - Bob" );

BSP_print( "I am going to free." );

me->m_timeEvt.postIn(me, TIMEOUT_TIME);

QEvent* be=Q_NEW(QEvent,TIMEOUT);

QF::publish(be);



return Q_TRAN(&Bob::free);

}



case TERMINATE_SIG: {

BSP_print( "Bob terminate.----------------------------------------------" );

QF::stop();

return Q_HANDLED();

}

}

return Q_SUPER(&QHsm::top);

}



* This source code was highlighted with Source Code Highlighter .

स्पष्टीकरण

1) बॉब को समय-समय पर एक TIMEOUT_SIG संदेश उत्पन्न करना चाहिए, इसके लिए हम अपने टाइमर का उपयोग करते हैं।

2) सक्रिय वस्तु हमेशा अपने राज्यों में से एक में होती है। जब एक संकेत प्राप्त होता है, तो इसे उस फ़ंक्शन में स्थानांतरित किया जाता है जिसे इस राज्य में बुलाया जाना चाहिए। राज्य के कार्यों के अपने विशेष हस्ताक्षर हैं। एक बॉब ऑब्जेक्ट में दो राज्य होते हैं, FREE और WORK, लेकिन आपको ऑब्जेक्ट को शुरू करने के लिए प्रारंभिक अवस्था का वर्णन करने की भी आवश्यकता है।

3) आंतरिक टाइमर के लिए, आपको एक आंतरिक सिग्नल बनाने की आवश्यकता है।

4) ऑब्जेक्ट के कंस्ट्रक्टर को टाइमर के कंस्ट्रक्टर को कॉल करना होगा।

5) वस्तु को सार्वजनिक संकेतों की सदस्यता लेनी चाहिए जो वह प्राप्त करना चाहता है।

6) टाइमर शुरू होता है और एक निर्दिष्ट अंतराल के बाद एक सिग्नल TIMEOUT_SIG भेजता है।

7) प्रांतीय राज्य से हम वस्तु को मुक्त अवस्था में स्थानांतरित करते हैं।

8) मुफ़्त स्थिति में, जब एक संकेत प्राप्त होता है, तो मुफ्त फ़ंक्शन को कहा जाता है जिसमें आपको सिग्नल को संसाधित करने की आवश्यकता होती है।

9) उपयोगकर्ता संकेतों के अलावा, एक राज्य में प्रवेश करने और बाहर निकलने के लिए मानक संकेत हैं।

10) उपयोगकर्ता सिग्नल को संसाधित करने का एक उदाहरण। सिग्नल को संसाधित करने के बाद, WORK स्थिति पर जाएं।

11) TIMEOUT_SIG सिग्नल प्राप्त करते समय, आपको टाइमर को रिचार्ज करना होगा ताकि यह निर्दिष्ट अंतराल पर TIMEOUT_SIG को भेज सके।

12) सिस्टम को एक खुला संकेत भी भेजा जाता है। यह संकेत कन्वेयर वस्तु की प्रतीक्षा करता है।

13) यदि ऑब्जेक्ट कुछ संसाधनों को लेता है, तो उसे सिस्टम स्टॉप सिग्नल को संसाधित करना चाहिए और संसाधनों को सही ढंग से जारी करना चाहिए। सक्रिय वस्तु जो पिछली बार चलायी गयी थी (हमारे मामले में बॉब) को पूरा होने का संकेत देना चाहिए और सिस्टम को बंद कर देना चाहिए।

14) सिस्टम शटडाउन।

15) यदि संकेत संसाधित है, लेकिन ऑब्जेक्ट की स्थिति को नहीं बदलता है, तो प्रसंस्करण ध्वज को वापस किया जाना चाहिए।



कन्वेयर से कन्वेयर ऑब्जेक्ट .pp फ़ाइल सरल है और आप इसे स्वयं समझ सकते हैं।

#include "qp_port.h"

#include "qpbob.h"

#include "bsp.h"



Q_DEFINE_THIS_FILE



class Conveyor : public QActive {



private :



public :

Conveyor();



private :

//

static QState initial(Conveyor *me, QEvent const *e);

static QState empty(Conveyor *me, QEvent const *e);

static QState full(Conveyor *me, QEvent const *e);

};



static Conveyor l_Conveyor;



QActive * const AO_CONVEYOR = &l_Conveyor;



//............................................................................

Conveyor::Conveyor() : QActive((QStateHandler)&Conveyor::initial)

{



}

//............................................................................

QState Conveyor::initial(Conveyor *me, QEvent const *) {



BSP_print( "Conveyor initial" );



QS_OBJ_DICTIONARY(&l_Conveyor);





QS_FUN_DICTIONARY(&QHsm::top);

QS_FUN_DICTIONARY(&Conveyor::initial);

QS_FUN_DICTIONARY(&Conveyor::empty);

QS_FUN_DICTIONARY(&Conveyor::full);



QS_SIG_DICTIONARY(GET, me);

QS_SIG_DICTIONARY(TIMEOUT, me);



me->subscribe(GET);

me->subscribe(TIMEOUT);



return Q_TRAN(&Conveyor::empty);

}

//............................................................................

QState Conveyor::empty(Conveyor *me, QEvent const *e) {



BSP_print( "Conveyor empty" );



switch (e->sig) {





case TIMEOUT:

{

BSP_print( "Tick Empty - Conveyor" );

BSP_print( "Conveyor going to full." );





return Q_TRAN(&Conveyor::full);

}



}

return Q_SUPER(&QHsm::top);

}



QState Conveyor::full(Conveyor *me, QEvent const *e) {



BSP_print( "Conveyor full" );



switch (e->sig) {

//(1)



case Q_ENTRY_SIG: {

QEvent* be=Q_NEW(QEvent,READY);

QF::publish(be);

BSP_print( "Conveyor READY." );

}



case GET:

{

BSP_print( "Bob GET box." );

return Q_TRAN(&Conveyor::empty);

}



}

return Q_SUPER(&QHsm::top);

}





* This source code was highlighted with Source Code Highlighter .

QP का उपयोग करके एम्बेडेड सिस्टम के लिए राज्य मशीनों के आधार पर एक एप्लिकेशन विकसित करने का यह उदाहरण यथार्थवादी या पूरी तरह से सही होने का दिखावा नहीं करता है। लेकिन मुझे लगता है कि यह QP के इच्छुक लोगों की मदद करेगा। आधिकारिक वेबसाइट से सामग्री के आधार पर क्यूपी के आगे के अध्ययन को जारी रखा जा सकता है।



सूत्रों का कहना है:

केवल कोड;

परियोजना में वी.एस.