ടാംഗോ നിയന്ത്രണങ്ങൾ

എന്ത് ടാംഗോ?

വിവിധ ഹാർഡ്‌വെയറുകളും സോഫ്റ്റ്‌വെയറുകളും കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഒരു സംവിധാനമാണിത്.
TANGO നിലവിൽ 4 പ്ലാറ്റ്‌ഫോമുകളെ പിന്തുണയ്ക്കുന്നു: Linux, Windows NT, Solaris, HP-UX.
ലിനക്സുമായി (ഉബുണ്ടു 18.04) പ്രവർത്തിക്കുന്നത് ഞങ്ങൾ ഇവിടെ വിവരിക്കും.

ദല്യാ ചെഗോ നൂഷ്നോ?

വിവിധ ഉപകരണങ്ങളും സോഫ്റ്റ്വെയറുകളും ഉപയോഗിച്ച് ജോലി ലളിതമാക്കുന്നു.

• ഡാറ്റാബേസിൽ ഡാറ്റ എങ്ങനെ സംഭരിക്കാം എന്നതിനെക്കുറിച്ച് നിങ്ങൾ ചിന്തിക്കേണ്ടതില്ല, ഇത് നിങ്ങൾക്കായി ഇതിനകം ചെയ്തുകഴിഞ്ഞു.
• പോളിംഗ് സെൻസറുകൾക്കുള്ള സംവിധാനം വിവരിക്കാൻ മാത്രം മതി.
• നിങ്ങളുടെ എല്ലാ കോഡുകളും ഒരു സ്റ്റാൻഡേർഡിലേക്ക് കുറയ്ക്കുന്നു.

എവിടെ ലഭിക്കും?

• ഉറവിടങ്ങൾ
• ഇന്സ്റ്റല്ലേഷന് നിര്ദ്ദേശങ്ങള്
• ഉബുണ്ടു അടിസ്ഥാനമാക്കിയുള്ള TangoBox ചിത്രം

സോഴ്സ് കോഡിൽ നിന്ന് ഇത് സമാരംഭിക്കാനായില്ല; പ്രവർത്തിക്കാൻ ഞാൻ TangoBox 9.3-ന്റെ ഒരു റെഡിമെയ്ഡ് ഇമേജ് ഉപയോഗിച്ചു.
പാക്കേജുകളിൽ നിന്ന് എങ്ങനെ ഇൻസ്റ്റാൾ ചെയ്യാമെന്ന് നിർദ്ദേശങ്ങൾ വിവരിക്കുന്നു.

അതിൽ എന്താണ് അടങ്ങിയിരിക്കുന്നത്?

• ജീവ് - TANGO ഡാറ്റാബേസ് കാണാനും എഡിറ്റ് ചെയ്യാനും ഉപയോഗിക്കുന്നു.
• പോഗോ - TANGO ഉപകരണ സെർവറുകൾക്കുള്ള കോഡ് ജനറേറ്റർ.
• ആസ്റ്റർ - TANGO സിസ്റ്റത്തിന്റെ പ്രോഗ്രാം മാനേജർ.

ആദ്യത്തെ രണ്ട് ഘടകങ്ങളിൽ മാത്രമേ ഞങ്ങൾക്ക് താൽപ്പര്യമുണ്ടാകൂ.

പിന്തുണയ്ക്കുന്ന പ്രോഗ്രാമിംഗ് ഭാഷകൾ

• C
• സി ++
• ജാവ
• ജാവാസ്ക്രിപ്റ്റ്
• പൈത്തൺ
• മാത്‌ലാബ്
• ലാബ്‌വ്യൂ

പൈത്തണിലും സി++ ലും ഞാൻ അതിനൊപ്പം പ്രവർത്തിച്ചു. ഇവിടെ C++ ഒരു ഉദാഹരണമായി ഉപയോഗിക്കും.

ടാൻഗോയിലേക്ക് ഉപകരണം എങ്ങനെ ബന്ധിപ്പിക്കാം, അത് എങ്ങനെ പ്രവർത്തിക്കണം എന്നതിന്റെ വിവരണത്തിലേക്ക് നമുക്ക് പോകാം. ഫീസ് ഉദാഹരണമായി എടുക്കും GPS നിയോ-6m-0-001:

ചിത്രത്തിൽ നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, UART CP2102 വഴി ഞങ്ങൾ ബോർഡ് പിസിയിലേക്ക് ബന്ധിപ്പിക്കുന്നു. ഒരു പിസിയിലേക്ക് കണക്റ്റുചെയ്യുമ്പോൾ, ഉപകരണം ദൃശ്യമാകുന്നു /dev/ttyUSB[0-N], സാധാരണയായി /dev/ttyUSB0.

പോഗോ

ഇനി നമുക്ക് ലോഞ്ച് ചെയ്യാം പോഗോ, കൂടാതെ ഞങ്ങളുടെ ബോർഡിനൊപ്പം പ്രവർത്തിക്കാൻ അസ്ഥികൂട കോഡ് സൃഷ്ടിക്കുക.

pogo

ഞാൻ ഇതിനകം കോഡ് സൃഷ്ടിച്ചു, നമുക്ക് അത് വീണ്ടും സൃഷ്ടിക്കാം ഫയൽ->പുതിയത്.

ഞങ്ങൾക്ക് ഇനിപ്പറയുന്നവ ലഭിക്കുന്നു:

ഞങ്ങളുടെ ഉപകരണം (ഭാവിയിൽ, സോഫ്‌റ്റ്‌വെയർ ഭാഗം എന്ന് അർത്ഥമാക്കുന്നത്) ശൂന്യമാണ് കൂടാതെ രണ്ട് നിയന്ത്രണ കമാൻഡുകൾ ഉണ്ട്: അവസ്ഥ & പദവി.

ആവശ്യമായ ആട്രിബ്യൂട്ടുകൾ കൊണ്ട് ഇത് പൂരിപ്പിക്കണം:

ഉപകരണ സ്വത്ത് - ഡിവൈസ് ആരംഭിക്കുന്നതിനായി ഞങ്ങൾ ഉപകരണത്തിലേക്ക് കൈമാറുന്ന സ്ഥിര മൂല്യങ്ങൾ; ജിപിഎസ് ബോർഡിനായി, നിങ്ങൾ സിസ്റ്റത്തിലെ ബോർഡിന്റെ പേര് കൈമാറേണ്ടതുണ്ട്. com="/dev/ttyUSB0" കോം പോർട്ട് വേഗതയും ബോഡ്രേഡ്=9600

കമാൻഡുകൾ — ഞങ്ങളുടെ ഉപകരണം നിയന്ത്രിക്കുന്നതിനുള്ള കമാൻഡുകൾ; അവയ്ക്ക് ആർഗ്യുമെന്റുകളും റിട്ടേൺ മൂല്യവും നൽകാം.

• STATE - നിന്ന് നിലവിലെ അവസ്ഥ നൽകുന്നു സംസ്ഥാനങ്ങൾ
• പദവി - നിലവിലെ നില നൽകുന്നു, ഇത് സ്ട്രിംഗിന്റെ പൂരകമാണ് STATE
• GPSArray - മടങ്ങുന്നു ജിപിഎസ് രൂപത്തിൽ സ്ട്രിംഗ് ദേവ്വർചാർഅറേ

അടുത്തതായി, ഉപകരണത്തിൽ നിന്ന് വായിക്കാൻ/എഴുതാൻ കഴിയുന്ന ആട്രിബ്യൂട്ടുകൾ സജ്ജമാക്കുക.
സ്കെയിലർ ആട്രിബ്യൂട്ടുകൾ - ലളിതമായ ആട്രിബ്യൂട്ടുകൾ (ചാർ, സ്ട്രിംഗ്, നീളം മുതലായവ)
സ്പെക്ട്രം ആട്രിബ്യൂട്ടുകൾ - ഏകമാന ശ്രേണികൾ
ഇമേജ് ആട്രിബ്യൂട്ടുകൾ - ദ്വിമാന ശ്രേണികൾ

സംസ്ഥാനങ്ങൾ - ഞങ്ങളുടെ ഉപകരണം സ്ഥിതിചെയ്യുന്ന സംസ്ഥാനം.

• തുറക്കുക - ഉപകരണം തുറന്നിരിക്കുന്നു.
• അടയ്ക്കുക - ഉപകരണം അടച്ചിരിക്കുന്നു.
• പരാജയം - പിശക്.
• 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