टैंगो नियंत्रण

क्या है टैंगो?

यह विभिन्न हार्डवेयर और सॉफ्टवेयर के प्रबंधन के लिए एक प्रणाली है।
टैंगो वर्तमान में 4 प्लेटफार्मों का समर्थन करता है: लिनक्स, विंडोज एनटी, सोलारिस और एचपी-यूएक्स।
यहां हम लिनक्स (उबंटू 18.04) के साथ काम करने का वर्णन करेंगे

यह किस लिए है?

विभिन्न उपकरणों और सॉफ्टवेयर के साथ काम को सरल बनाता है।

• आपको यह सोचने की ज़रूरत नहीं है कि डेटाबेस में डेटा कैसे संग्रहीत किया जाए, यह आपके लिए पहले ही हो चुका है।
• केवल मतदान सेंसरों के तंत्र का वर्णन करना आवश्यक है।
• आपके सभी कोड को एक मानक पर कम कर देता है।

कहां से लाएं?

• सूत्रों का कहना है
• स्थापना निर्देश
• उबंटू पर आधारित टैंगोबॉक्स छवि

मैं इसे स्रोत कोड से लॉन्च नहीं कर सका; मैंने काम करने के लिए टैंगोबॉक्स 9.3 की तैयार छवि का उपयोग किया।
निर्देश बताते हैं कि पैकेजों से कैसे स्थापित किया जाए।

इसमें क्या शामिल होता है?

• बक - टैंगो डेटाबेस को देखने और संपादित करने के लिए उपयोग किया जाता है।
• पोगो - टैंगो डिवाइस सर्वर के लिए कोड जनरेटर।
• एस्टर - टैंगो प्रणाली के लिए प्रोग्राम मैनेजर।

हमें केवल पहले दो घटकों में रुचि होगी।

समर्थित प्रोग्रामिंग भाषाएँ

• C
• सी + +
• जावा
• जावास्क्रिप्ट
• अजगर
• matlab
• LabVIEW

मैंने इसके साथ पायथन और सी++ में काम किया। यहां C++ को उदाहरण के तौर पर इस्तेमाल किया जाएगा.

आइए अब इस विवरण पर आगे बढ़ें कि डिवाइस को टैंगो से कैसे जोड़ा जाए और इसके साथ कैसे काम किया जाए। शुल्क को एक उदाहरण के रूप में लिया जाएगा जीपीएस नियो-6एम-0-001:

जैसा कि आप चित्र में देख सकते हैं, हम बोर्ड को UART CP2102 के माध्यम से पीसी से जोड़ते हैं। पीसी से कनेक्ट होने पर, डिवाइस दिखाई देता है /dev/ttyUSB[0-N], आमतौर पर /dev/ttyUSB0.

पोगो

अब लॉन्च करते हैं पोगो, और हमारे बोर्ड के साथ काम करने के लिए स्केलेटन कोड तैयार करें।

pogo

मैंने पहले ही कोड बना लिया है, चलिए इसे फिर से बनाते हैं फ़ाइल->नया.

हमें निम्नलिखित मिलता है:

हमारा उपकरण (भविष्य में, उपकरण से हमारा तात्पर्य सॉफ्टवेयर भाग से होगा) खाली है और इसमें दो नियंत्रण आदेश हैं: राज्य & स्थिति.

इसे आवश्यक विशेषताओं से भरा होना चाहिए:

डिवाइस संपत्ति - डिफ़ॉल्ट मान जिन्हें हम डिवाइस को आरंभ करने के लिए स्थानांतरित करते हैं; जीपीएस बोर्ड के लिए, आपको सिस्टम में बोर्ड का नाम स्थानांतरित करना होगा com='/dev/ttyUSB0' और कॉम पोर्ट स्पीड बॉड्रेड=9600

कमानों - हमारे डिवाइस को नियंत्रित करने के लिए आदेश; उन्हें तर्क और रिटर्न मान दिया जा सकता है।

• राज्य - वर्तमान स्थिति लौटाता है, से राज्य
• स्थिति - वर्तमान स्थिति लौटाता है, यह स्ट्रिंग का पूरक है राज्य
• जीपीएसअरे - रिटर्न जीपीएस प्रपत्र में स्ट्रिंग DevVarCharArray

इसके बाद, डिवाइस विशेषताएँ सेट करें जिन्हें इससे पढ़ा/लिखा जा सके।
अदिश गुण - सरल विशेषताएँ (चार, स्ट्रिंग, लंबी, आदि)
स्पेक्ट्रम गुण - एक आयामी सरणियाँ
छवि गुण - द्वि-आयामी सरणियाँ

राज्य - वह स्थिति जिसमें हमारा उपकरण स्थित है।

• खुली - डिवाइस खुला है.
• बंद - डिवाइस बंद है.
• असफल - गलती।
• ON - डिवाइस से डेटा प्राप्त करें।
• बंद — डिवाइस से कोई डेटा नहीं.

एक विशेषता जोड़ने का उदाहरण जीपीएस_स्ट्रिंग:

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

घटित:

अब आपको कोड जनरेट करना होगा फ़ाइल->जनरेट करें

डिफ़ॉल्ट रूप से, मेकफ़ाइल जेनरेट नहीं होती है; पहली बार आपको इसे बनाने के लिए बॉक्स को चेक करना होगा। ऐसा इसलिए किया जाता है ताकि नई पीढ़ी के दौरान इसमें किए गए बदलाव डिलीट न हो जाएं। इसे एक बार बनाने और इसे अपने प्रोजेक्ट (रजिस्टर संकलन कुंजी, अतिरिक्त फ़ाइलें) के लिए कॉन्फ़िगर करने के बाद, आप इसके बारे में भूल सकते हैं।

अब चलिए प्रोग्रामिंग की ओर बढ़ते हैं। पोगो ने हमारे लिए निम्नलिखित उत्पन्न किया:

हमें NEO6M.cpp और NEO6M.h में रुचि होगी। आइए क्लास कंस्ट्रक्टर का एक उदाहरण लें:

NEO6M::NEO6M(Tango::DeviceClass *cl, string &s)
 : TANGO_BASE_CLASS(cl, s.c_str())
{
    /*----- PROTECTED REGION ID(NEO6M::constructor_1) ENABLED START -----*/
    init_device();

    /*----- PROTECTED REGION END -----*/    //  NEO6M::constructor_1
}

वहाँ क्या है और यहाँ क्या महत्वपूर्ण है? Init_device() फ़ंक्शन हमारी विशेषताओं के लिए मेमोरी आवंटित करता है: जीपीएस_स्ट्रिंग & gps_array, लेकिन यह महत्वपूर्ण नहीं है. यहां सबसे महत्वपूर्ण बात है, ये टिप्पणियाँ हैं:

/*----- PROTECTED REGION ID(NEO6M::constructor_1) ENABLED START -----*/
    .......
/*----- PROTECTED REGION END -----*/    //  NEO6M::constructor_1

इस टिप्पणी ब्लॉक के अंदर जो कुछ भी है उसे बाद के कोड पुनर्जनन के दौरान पोगो में शामिल नहीं किया जाएगा टलना!. वह सब कुछ जो ब्लॉकों में नहीं है वह होगा! ये वे स्थान हैं जहां हम प्रोग्राम कर सकते हैं और अपना संपादन कर सकते हैं।

अब कक्षा में मुख्य कार्य क्या हैं? NEO6M:

void always_executed_hook();
void read_attr_hardware(vector<long> &attr_list);
void read_gps_string(Tango::Attribute &attr);
void read_gps_array(Tango::Attribute &attr);

जब हम विशेषता मान पढ़ना चाहते हैं जीपीएस_स्ट्रिंग, फ़ंक्शंस को निम्नलिखित क्रम में कॉल किया जाएगा: हमेशा_निष्पादित_हुक, read_attr_हार्डवेयर и read_gps_string. Read_gps_string gps_string को मान से भर देगा।

void NEO6M::read_gps_string(Tango::Attribute &attr)
{
    DEBUG_STREAM << "NEO6M::read_gps_string(Tango::Attribute &attr) entering... " << endl;
    /*----- PROTECTED REGION ID(NEO6M::read_gps_string) ENABLED START -----*/
    //  Set the attribute value

        *this->attr_gps_string_read = Tango::string_dup(this->gps.c_str());

    attr.set_value(attr_gps_string_read);

    /*----- PROTECTED REGION END -----*/    //  NEO6M::read_gps_string
}

संकलन

स्रोत फ़ोल्डर पर जाएँ और:

make

प्रोग्राम को ~/DeviceServers फ़ोल्डर में संकलित किया जाएगा।

tango-cs@tangobox:~/DeviceServers$ ls
NEO6M

बक

jive

डेटाबेस में पहले से ही कुछ डिवाइस मौजूद हैं, आइए अब अपना डिवाइस बनाएं संपादित करें->सर्वर बनाएं

आइए अब इससे जुड़ने का प्रयास करें:

कुछ भी काम नहीं करेगा, पहले हमें अपना प्रोग्राम चलाना होगा:

sudo ./NEO6M neo6m -v2

मैं केवल अधिकारों के साथ कॉम पोर्ट से जुड़ सकता हूं जड़रों। v - लॉगिंग स्तर.

अब हम कनेक्ट कर सकते हैं:

ग्राहक

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

#include <tango.h>
using namespace Tango;

int main(int argc, char **argv) {
    try {

        //
        // create a connection to a TANGO device
        //

        DeviceProxy *device = new DeviceProxy("NEO6M/neo6m/1");

        //
        // Ping the device
        //

        device->ping();

        //
        // Execute a command on the device and extract the reply as a string
        //

        vector<Tango::DevUChar> gps_array;

        DeviceData cmd_reply;
        cmd_reply = device->command_inout("GPSArray");
        cmd_reply >> gps_array;

        for (int i = 0; i < gps_array.size(); i++) {            
            printf("%c", gps_array[i]);
        }
        puts("");

        //
        // Read a device attribute (string data type)
        //

        string spr;
        DeviceAttribute att_reply;
        att_reply = device->read_attribute("gps_string");
        att_reply >> spr;
        cout << spr << endl;

        vector<Tango::DevUChar> spr2;
        DeviceAttribute att_reply2;
        att_reply2 = device->read_attribute("gps_array");
        att_reply2.extract_read(spr2);

        for (int i = 0; i < spr2.size(); i++) {
            printf("%c", spr2[i]);
        }

        puts("");

    } catch (DevFailed &e) {
        Except::print_exception(e);
        exit(-1);
    }
}

संकलन कैसे करें:

g++ gps.cpp -I/usr/local/include/tango -I/usr/local/include -I/usr/local/include -std=c++0x -Dlinux -L/usr/local/lib -ltango -lomniDynamic4 -lCOS4 -lomniORB4 -lomnithread -llog4tango -lzmq -ldl -lpthread -lstdc++

रिजल्ट:

tango-cs@tangobox:~/workspace/c$ ./a.out 
$GPRMC,,V,,,,,,,,,,N*53

$GPRMC,,V,,,,,,,,,,N*53

$GPRMC,,V,,,,,,,,,,N*53

हमें एक स्ट्रिंग और वर्णों की एक सरणी की विशेषताओं को लेते हुए कमांड रिटर्न के रूप में परिणाम मिला।

संदर्भों

• स्रोत कोड

मैंने लेख अपने लिए लिखा, क्योंकि कुछ समय बाद मैं भूलने लगा कि कैसे और क्या करना है।

आपका ध्यान के लिए धन्यवाद.

स्रोत: www.habr.com