ಟ್ಯಾಂಗೋ ನಿಯಂತ್ರಣಗಳು

ಏನು ಟ್ಯಾಂಗೋ?

ಇದು ವಿವಿಧ ಹಾರ್ಡ್‌ವೇರ್ ಮತ್ತು ಸಾಫ್ಟ್‌ವೇರ್ ಅನ್ನು ನಿರ್ವಹಿಸುವ ವ್ಯವಸ್ಥೆಯಾಗಿದೆ.
TANGO ಪ್ರಸ್ತುತ 4 ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ: Linux, Windows NT, Solaris ಮತ್ತು HP-UX.
ಲಿನಕ್ಸ್ (ಉಬುಂಟು 18.04) ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದನ್ನು ನಾವು ಇಲ್ಲಿ ವಿವರಿಸುತ್ತೇವೆ.

ದಲ್ಯ ಚೆಗೋ ನುಜ್ನೋ?

ವಿವಿಧ ಉಪಕರಣಗಳು ಮತ್ತು ಸಾಫ್ಟ್‌ವೇರ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸವನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ.

• ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಡೇಟಾವನ್ನು ಹೇಗೆ ಸಂಗ್ರಹಿಸುವುದು ಎಂಬುದರ ಕುರಿತು ನೀವು ಯೋಚಿಸಬೇಕಾಗಿಲ್ಲ, ಇದು ಈಗಾಗಲೇ ನಿಮಗಾಗಿ ಮಾಡಲಾಗಿದೆ.
• ಮತದಾನ ಸಂವೇದಕಗಳ ಕಾರ್ಯವಿಧಾನವನ್ನು ವಿವರಿಸಲು ಮಾತ್ರ ಇದು ಅಗತ್ಯವಾಗಿರುತ್ತದೆ.
• ನಿಮ್ಮ ಎಲ್ಲಾ ಕೋಡ್ ಅನ್ನು ಒಂದು ಮಾನದಂಡಕ್ಕೆ ತಗ್ಗಿಸುತ್ತದೆ.

ಎಲ್ಲಿ ಪಡೆಯುವುದು?

• ಮೂಲಗಳು
• ಅನುಸ್ಥಾಪನಾ ಸೂಚನೆಗಳು
• ಉಬುಂಟು ಆಧಾರಿತ ಟ್ಯಾಂಗೋಬಾಕ್ಸ್ ಚಿತ್ರ

ನಾನು ಅದನ್ನು ಮೂಲ ಕೋಡ್‌ನಿಂದ ಪ್ರಾರಂಭಿಸಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ; ನಾನು ಕೆಲಸ ಮಾಡಲು TangoBox 9.3 ನ ಸಿದ್ಧ ಚಿತ್ರವನ್ನು ಬಳಸಿದ್ದೇನೆ.
ಪ್ಯಾಕೇಜ್‌ಗಳಿಂದ ಹೇಗೆ ಸ್ಥಾಪಿಸಬೇಕು ಎಂಬುದನ್ನು ಸೂಚನೆಗಳು ವಿವರಿಸುತ್ತವೆ.

ಇದು ಏನು ಒಳಗೊಂಡಿದೆ?

• ಜೀವ - TANGO ಡೇಟಾಬೇಸ್ ಅನ್ನು ವೀಕ್ಷಿಸಲು ಮತ್ತು ಸಂಪಾದಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.
• POGO - TANGO ಸಾಧನ ಸರ್ವರ್‌ಗಳಿಗಾಗಿ ಕೋಡ್ ಜನರೇಟರ್.
• ಆಸ್ಟರ್ - ಟ್ಯಾಂಗೋ ಸಿಸ್ಟಮ್ಗಾಗಿ ಪ್ರೋಗ್ರಾಂ ಮ್ಯಾನೇಜರ್.

ನಾವು ಮೊದಲ ಎರಡು ಘಟಕಗಳಲ್ಲಿ ಮಾತ್ರ ಆಸಕ್ತಿ ಹೊಂದಿದ್ದೇವೆ.

ಬೆಂಬಲಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳು

• C
• ಸಿ ++
• ಜಾವಾ
• ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್
• ಪೈಥಾನ್
• ಮಾಟ್ಲಾಬ್
• ಲ್ಯಾಬ್‌ವ್ಯೂ

ನಾನು ಅದರೊಂದಿಗೆ ಪೈಥಾನ್ ಮತ್ತು ಸಿ++ ನಲ್ಲಿ ಕೆಲಸ ಮಾಡಿದ್ದೇನೆ. ಇಲ್ಲಿ C++ ಅನ್ನು ಉದಾಹರಣೆಯಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ.

ಸಾಧನವನ್ನು TANGO ಗೆ ಹೇಗೆ ಸಂಪರ್ಕಿಸುವುದು ಮತ್ತು ಅದರೊಂದಿಗೆ ಹೇಗೆ ಕೆಲಸ ಮಾಡುವುದು ಎಂಬುದರ ವಿವರಣೆಗೆ ಈಗ ನಾವು ಹೋಗೋಣ. ಶುಲ್ಕವನ್ನು ಉದಾಹರಣೆಯಾಗಿ ತೆಗೆದುಕೊಳ್ಳಲಾಗುವುದು GPS ನಿಯೋ-6m-0-001:

ಚಿತ್ರದಲ್ಲಿ ನೀವು ನೋಡುವಂತೆ, UART CP2102 ಮೂಲಕ ನಾವು ಬೋರ್ಡ್ ಅನ್ನು PC ಗೆ ಸಂಪರ್ಕಿಸುತ್ತೇವೆ. ಪಿಸಿಗೆ ಸಂಪರ್ಕಿಸಿದಾಗ, ಸಾಧನವು ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ /dev/ttyUSB[0-N], ಸಾಮಾನ್ಯವಾಗಿ /dev/ttyUSB0.

POGO

ಈಗ ಲಾಂಚ್ ಮಾಡೋಣ ಪೋಗೊ, ಮತ್ತು ನಮ್ಮ ಬೋರ್ಡ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಅಸ್ಥಿಪಂಜರ ಕೋಡ್ ಅನ್ನು ರಚಿಸಿ.

pogo

ನಾನು ಈಗಾಗಲೇ ಕೋಡ್ ಅನ್ನು ರಚಿಸಿದ್ದೇನೆ, ಅದನ್ನು ಮತ್ತೆ ರಚಿಸೋಣ ಫೈಲ್->ಹೊಸ.

ನಾವು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಪಡೆಯುತ್ತೇವೆ:

ನಮ್ಮ ಸಾಧನ (ಭವಿಷ್ಯದಲ್ಲಿ, ಸಾಧನದಿಂದ ನಾವು ಸಾಫ್ಟ್‌ವೇರ್ ಭಾಗವನ್ನು ಅರ್ಥೈಸುತ್ತೇವೆ) ಖಾಲಿಯಾಗಿದೆ ಮತ್ತು ಎರಡು ನಿಯಂತ್ರಣ ಆಜ್ಞೆಗಳನ್ನು ಹೊಂದಿದೆ: ರಾಜ್ಯ & ಸ್ಥಿತಿ.

ಇದು ಅಗತ್ಯ ಗುಣಲಕ್ಷಣಗಳೊಂದಿಗೆ ತುಂಬಿರಬೇಕು:

ಸಾಧನದ ಆಸ್ತಿ - ನಾವು ಅದನ್ನು ಪ್ರಾರಂಭಿಸಲು ಸಾಧನಕ್ಕೆ ವರ್ಗಾಯಿಸುವ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳು; ಜಿಪಿಎಸ್ ಬೋರ್ಡ್‌ಗಾಗಿ, ನೀವು ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ ಬೋರ್ಡ್‌ನ ಹೆಸರನ್ನು ವರ್ಗಾಯಿಸಬೇಕಾಗುತ್ತದೆ com="/dev/ttyUSB0" ಮತ್ತು ಕಾಮ್ ಪೋರ್ಟ್ ವೇಗ ಬೌಡ್ರೇಡ್=9600

ಆದೇಶಗಳು — ನಮ್ಮ ಸಾಧನವನ್ನು ನಿಯಂತ್ರಿಸಲು ಆಜ್ಞೆಗಳು; ಅವರಿಗೆ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳು ಮತ್ತು ರಿಟರ್ನ್ ಮೌಲ್ಯವನ್ನು ನೀಡಬಹುದು.

• ರಾಜ್ಯ - ಪ್ರಸ್ತುತ ಸ್ಥಿತಿಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ರಾಜ್ಯಗಳು
• ಸ್ಥಿತಿ - ಪ್ರಸ್ತುತ ಸ್ಥಿತಿಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಇದು ಸ್ಟ್ರಿಂಗ್‌ನ ಪೂರಕವಾಗಿದೆ ರಾಜ್ಯ
• GPSArray - ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಜಿಪಿಎಸ್ ರೂಪದಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ದೇವ್‌ವರ್‌ಚಾರ್‌ಅರೇ

ಮುಂದೆ, ಸಾಧನದ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊಂದಿಸಿ ಅದನ್ನು ಓದಬಹುದು/ಬರೆಯಬಹುದು.
ಸ್ಕೇಲಾರ್ ಗುಣಲಕ್ಷಣಗಳು - ಸರಳ ಗುಣಲಕ್ಷಣಗಳು (ಚಾರ್, ಸ್ಟ್ರಿಂಗ್, ಉದ್ದ, ಇತ್ಯಾದಿ)
ಸ್ಪೆಕ್ಟ್ರಮ್ ಗುಣಲಕ್ಷಣಗಳು - ಒಂದು ಆಯಾಮದ ಸರಣಿಗಳು
ಚಿತ್ರದ ಗುಣಲಕ್ಷಣಗಳು - ಎರಡು ಆಯಾಮದ ಸರಣಿಗಳು

ರಾಜ್ಯಗಳು - ನಮ್ಮ ಸಾಧನವು ಇರುವ ರಾಜ್ಯ.

• ತೆರೆಯಿರಿ - ಸಾಧನವು ತೆರೆದಿರುತ್ತದೆ.
• ಮುಚ್ಚಿ - ಸಾಧನವನ್ನು ಮುಚ್ಚಲಾಗಿದೆ.
• ವಿಫಲವಾಗಿದೆ - ದೋಷ.
• ON - ಸಾಧನದಿಂದ ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸಿ.
• ಆಫ್ - ಸಾಧನದಿಂದ ಯಾವುದೇ ಡೇಟಾ ಇಲ್ಲ.

ಗುಣಲಕ್ಷಣವನ್ನು ಸೇರಿಸುವ ಉದಾಹರಣೆ gps_string:

ಮತದಾನದ ಅವಧಿ ms ನಲ್ಲಿ ಸಮಯ, gps_string ಮೌಲ್ಯವನ್ನು ಎಷ್ಟು ಬಾರಿ ನವೀಕರಿಸಲಾಗುತ್ತದೆ. ನವೀಕರಣ ಸಮಯವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸದಿದ್ದರೆ, ವಿನಂತಿಯ ಮೇರೆಗೆ ಮಾತ್ರ ಗುಣಲಕ್ಷಣವನ್ನು ನವೀಕರಿಸಲಾಗುತ್ತದೆ.

ಸಂಭವಿಸಿದ:

ಈಗ ನೀವು ಕೋಡ್ ಅನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ ಫೈಲ್-> ರಚಿಸಿ

ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಮೇಕ್‌ಫೈಲ್ ಅನ್ನು ರಚಿಸಲಾಗಿಲ್ಲ; ಅದನ್ನು ರಚಿಸಲು ನೀವು ಮೊದಲ ಬಾರಿಗೆ ಬಾಕ್ಸ್ ಅನ್ನು ಪರಿಶೀಲಿಸಬೇಕಾಗುತ್ತದೆ. ಹೊಸ ಪೀಳಿಗೆಯ ಸಮಯದಲ್ಲಿ ಅದರಲ್ಲಿ ಮಾಡಿದ ಬದಲಾವಣೆಗಳನ್ನು ಅಳಿಸದಂತೆ ಇದನ್ನು ಮಾಡಲಾಗುತ್ತದೆ. ಅದನ್ನು ಒಮ್ಮೆ ರಚಿಸಿದ ನಂತರ ಮತ್ತು ಅದನ್ನು ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್‌ಗಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಿದ ನಂತರ (ರಿಜಿಸ್ಟರ್ ಸಂಕಲನ ಕೀಗಳು, ಹೆಚ್ಚುವರಿ ಫೈಲ್‌ಗಳು), ನೀವು ಅದರ ಬಗ್ಗೆ ಮರೆತುಬಿಡಬಹುದು.

ಈಗ ಪ್ರೋಗ್ರಾಮಿಂಗ್ಗೆ ಹೋಗೋಣ. ಪೋಗೊ ನಮಗಾಗಿ ಈ ಕೆಳಗಿನವುಗಳನ್ನು ರಚಿಸಲಾಗಿದೆ:

ನಾವು 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