టాంగో నియంత్రణలు

ఏం TANGO?

ఇది వివిధ హార్డ్‌వేర్ మరియు సాఫ్ట్‌వేర్‌లను నిర్వహించడానికి ఒక వ్యవస్థ.
TANGO ప్రస్తుతం 4 ప్లాట్‌ఫారమ్‌లకు మద్దతు ఇస్తుంది: Linux, Windows NT, Solaris మరియు HP-UX.
ఇక్కడ మనం Linux (Ubuntu 18.04)తో పని చేయడం గురించి వివరిస్తాము.

డుల్యా చెగో నుజ్నో?

వివిధ పరికరాలు మరియు సాఫ్ట్‌వేర్‌లతో పనిని సులభతరం చేస్తుంది.

• డేటాబేస్లో డేటాను ఎలా నిల్వ చేయాలో మీరు ఆలోచించాల్సిన అవసరం లేదు, ఇది ఇప్పటికే మీ కోసం పూర్తి చేయబడింది.
• పోలింగ్ సెన్సార్ల కోసం యంత్రాంగాన్ని వివరించడం మాత్రమే అవసరం.
• మీ కోడ్ మొత్తాన్ని ఒక ప్రమాణానికి తగ్గిస్తుంది.

ఎక్కడ పొందాలి?

• మూలాలు
• సంస్థాపనా సూచనలు
• ఉబుంటు ఆధారంగా టాంగోబాక్స్ చిత్రం

నేను దానిని సోర్స్ కోడ్ నుండి ప్రారంభించలేకపోయాను; నేను పని చేయడానికి TangoBox 9.3 యొక్క రెడీమేడ్ ఇమేజ్‌ని ఉపయోగించాను.
ప్యాకేజీల నుండి ఎలా ఇన్‌స్టాల్ చేయాలో సూచనలు వివరిస్తాయి.

ఇది దేనిని కలిగి ఉంటుంది?

• జీవ్ — TANGO డేటాబేస్ వీక్షించడానికి మరియు సవరించడానికి ఉపయోగిస్తారు.
• POGO — TANGO పరికర సర్వర్‌ల కోసం కోడ్ జనరేటర్.
• Astor - TANGO సిస్టమ్ కోసం ప్రోగ్రామ్ మేనేజర్.

మేము మొదటి రెండు భాగాలపై మాత్రమే ఆసక్తి కలిగి ఉంటాము.

మద్దతు ఉన్న ప్రోగ్రామింగ్ భాషలు

• C
• C ++
• జావా
• జావాస్క్రిప్ట్
• పైథాన్
• మతలబ్
• LabVIEW

నేను దానితో python & c++లో పనిచేశాను. ఇక్కడ C++ ఉదాహరణగా ఉపయోగించబడుతుంది.

ఇప్పుడు పరికరాన్ని TANGOకి ఎలా కనెక్ట్ చేయాలి మరియు దానితో ఎలా పని చేయాలి అనే వివరణకు వెళ్దాం. రుసుము ఉదాహరణగా తీసుకోబడుతుంది GPS నియో-6m-0-001:

మీరు చిత్రంలో చూడగలిగినట్లుగా, మేము UART CP2102 ద్వారా బోర్డుని PC కి కనెక్ట్ చేస్తాము. PCకి కనెక్ట్ చేసినప్పుడు, పరికరం కనిపిస్తుంది /dev/ttyUSB[0-N], సాధారణంగా /dev/ttyUSB0.

POGO

ఇప్పుడు లాంచ్ చేద్దాం పోగో, మరియు మా బోర్డుతో పని చేయడానికి అస్థిపంజరం కోడ్‌ని రూపొందించండి.

pogo

నేను ఇప్పటికే కోడ్‌ని సృష్టించాను, దాన్ని మళ్లీ క్రియేట్ చేద్దాం ఫైల్->కొత్తది.

మేము ఈ క్రింది వాటిని పొందుతాము:

మా పరికరం (భవిష్యత్తులో, పరికరం ద్వారా మేము సాఫ్ట్‌వేర్ భాగాన్ని అర్థం చేసుకుంటాము) ఖాళీగా ఉంది మరియు రెండు నియంత్రణ ఆదేశాలను కలిగి ఉంది: రాష్ట్రం & స్థితి.

ఇది తప్పనిసరిగా అవసరమైన లక్షణాలతో నింపాలి:

పరికర ఆస్తి - డిఫాల్ట్ విలువలు పరికరాన్ని ప్రారంభించడానికి మేము దానిని బదిలీ చేస్తాము; GPS బోర్డు కోసం, మీరు సిస్టమ్‌లోని బోర్డు పేరును బదిలీ చేయాలి com="/dev/ttyUSB0" మరియు com పోర్ట్ వేగం బౌడ్రేడ్=9600

ఆదేశాలు — మా పరికరాన్ని నియంత్రించడానికి ఆదేశాలు; వాటికి ఆర్గ్యుమెంట్‌లు మరియు రిటర్న్ విలువ ఇవ్వవచ్చు.

• రాష్ట్ర - నుండి ప్రస్తుత స్థితిని అందిస్తుంది రాష్ట్రాలు
• STATUS - ప్రస్తుత స్థితిని అందిస్తుంది, ఇది స్ట్రింగ్ యొక్క పూరకంగా ఉంటుంది రాష్ట్ర
• GPSArray - తిరిగి వస్తుంది GPS రూపంలో స్ట్రింగ్ DevVarCharArray

తర్వాత, దాని నుండి చదవగలిగే/వ్రాయగలిగే పరికర లక్షణాలను సెట్ చేయండి.
స్కేలార్ గుణాలు - సాధారణ లక్షణాలు (చార్, స్ట్రింగ్, పొడవు, మొదలైనవి)
స్పెక్ట్రమ్ లక్షణాలు - ఒక డైమెన్షనల్ శ్రేణులు
చిత్ర విశేషణాలు - రెండు డైమెన్షనల్ శ్రేణులు

రాష్ట్రాలు - మా పరికరం ఉన్న స్థితి.

• OPEN - పరికరం తెరిచి ఉంది.
• CLOSE - పరికరం మూసివేయబడింది.
• విఫలమైంది - లోపం.
• ON - పరికరం నుండి డేటాను స్వీకరించండి.
• ఆఫ్ - పరికరం నుండి డేటా లేదు.

లక్షణాన్ని జోడించడానికి ఉదాహరణ gps_string:

పోలింగ్ కాలం msలో సమయం, gps_string విలువ ఎంత తరచుగా నవీకరించబడుతుంది. నవీకరణ సమయం పేర్కొనబడకపోతే, అభ్యర్థనపై మాత్రమే లక్షణం నవీకరించబడుతుంది.

జరిగింది:

ఇప్పుడు మీరు కోడ్‌ను రూపొందించాలి ఫైల్-> రూపొందించండి

డిఫాల్ట్‌గా, Makefile రూపొందించబడదు; మీరు దీన్ని సృష్టించడానికి మొదటిసారిగా బాక్స్‌ను తనిఖీ చేయాలి. కొత్త తరం సమయంలో దానికి చేసిన మార్పులు తొలగించబడకుండా ఉండటానికి ఇది జరుగుతుంది. దీన్ని ఒకసారి సృష్టించి, మీ ప్రాజెక్ట్ కోసం కాన్ఫిగర్ చేసిన తర్వాత (రిజిస్టర్ కంపైలేషన్ కీలు, అదనపు ఫైల్‌లు), మీరు దాని గురించి మరచిపోవచ్చు.

ఇప్పుడు ప్రోగ్రామింగ్‌కు వెళ్దాం. పోగో మా కోసం కింది వాటిని రూపొందించింది:

మేము 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_string & 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);

మనం గుణ విలువను చదవాలనుకున్నప్పుడు gps_string, విధులు క్రింది క్రమంలో పిలువబడతాయి: ఎల్లప్పుడూ_ఎగ్జిక్యూటెడ్_హుక్, read_attr_hardware и రీడ్_జిపిఎస్_స్ట్రింగ్. 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