ProHoster > Blog > Verwaltung > Tango-Steuerung

Tango-Steuerung

Tango-Steuerung

Welche TANGO?

Es handelt sich um ein System zur Verwaltung verschiedener Hardware und Software.
TANGO unterstützt derzeit 4 Plattformen: Linux, Windows NT, Solaris und HP-UX.
Hier beschreiben wir die Arbeit mit Linux (Ubuntu 18.04)

Was ist das überhaupt?

Vereinfacht die Arbeit mit verschiedenen Geräten und Software.

  • Sie müssen nicht darüber nachdenken, wie Sie Daten in der Datenbank speichern, das ist bereits für Sie erledigt.
  • Es ist lediglich erforderlich, den Mechanismus zur Abfrage von Sensoren zu beschreiben.
  • Reduziert Ihren gesamten Code auf einen Standard.

Wo man es bekommt?

Ich konnte es nicht über den Quellcode starten; ich habe ein vorgefertigtes Image von TangoBox 9.3 verwendet, um zu funktionieren.
Die Anleitung beschreibt die Installation aus Paketen.

Woraus besteht es?

  • jive – dient zum Anzeigen und Bearbeiten der TANGO-Datenbank.
  • POGO — Codegenerator für TANGO-Geräteserver.
  • Astor — Programmmanager für das TANGO-System.

Wir werden uns nur für die ersten beiden Komponenten interessieren.

Unterstützte Programmiersprachen

  • C
  • C + +
  • Javac
  • JavaScript
  • Python
  • Matlab
  • LabVIEW

Ich habe damit in Python und C++ gearbeitet. Hier wird C++ als Beispiel verwendet.

Kommen wir nun zu einer Beschreibung, wie man das Gerät mit TANGO verbindet und wie man damit arbeitet. Als Beispiel soll die Gebühr genommen werden GPS neo-6m-0-001:

Tango-Steuerung

Wie auf dem Bild zu sehen ist, verbinden wir das Board per UART CP2102 mit dem PC. Bei Anschluss an einen PC erscheint das Gerät /dev/ttyUSB[0-N], normalerweise /dev/ttyUSB0.

POGO

Jetzt lasst uns starten Pogo, und generieren Sie Grundcode für die Arbeit mit unserem Board.

pogo

Tango-Steuerung

Ich habe den Code bereits erstellt, erstellen wir ihn erneut Datei->Neu.

Tango-Steuerung

Wir erhalten Folgendes:

Tango-Steuerung

Unser Gerät (mit Gerät meinen wir in Zukunft den Softwareteil) ist leer und verfügt über zwei Steuerbefehle: Bundesstaat & Status.

Es muss mit den notwendigen Attributen gefüllt sein:

Geräteeigenschaft — Standardwerte, die wir zur Initialisierung an das Gerät übertragen; für die GPS-Karte müssen Sie den Namen der Karte im System übertragen com="/dev/ttyUSB0" und COM-Port-Geschwindigkeit Baudrade=9600

Befehle – Befehle zur Steuerung unseres Geräts; ihnen können Argumente und ein Rückgabewert zugewiesen werden.

  • STATE - gibt den aktuellen Status zurück, von Staaten
  • STATUS - gibt den aktuellen Status zurück, dies ist das Komplement zu der Zeichenfolge STATE
  • GPSArray - kehrt zurück gps Zeichenfolge im Formular DevVarCharArray

Als nächstes legen Sie die Geräteattribute fest, die darauf gelesen/geschrieben werden können.
Skalare Attribute — einfache Attribute (char, string, long usw.)
Spektrumattribute - eindimensionale Arrays
Bildattribute - zweidimensionale Arrays

Staaten — der Zustand, in dem sich unser Gerät befindet.

  • OPEN — Das Gerät ist geöffnet.
  • SCHLIESSEN — Das Gerät ist geschlossen.
  • FEHLGESCHLAGEN - Fehler.
  • ON — Daten vom Gerät empfangen.
  • OFF — Keine Daten vom Gerät.

Beispiel für das Hinzufügen eines Attributs gps_string:

Tango-Steuerung

Abstimmungszeitraum Zeit in ms, wie oft der gps_string-Wert aktualisiert wird. Wenn die Aktualisierungszeit nicht angegeben ist, wird das Attribut nur auf Anfrage aktualisiert.

Es stellte sich heraus:

Tango-Steuerung

Jetzt müssen Sie den Code generieren Datei->Generieren

Tango-Steuerung

Standardmäßig wird das Makefile nicht generiert. Beim ersten Mal müssen Sie das Kontrollkästchen aktivieren, um es zu erstellen. Dies geschieht, damit die daran vorgenommenen Änderungen bei einer neuen Generation nicht gelöscht werden. Nachdem Sie es einmal erstellt und für Ihr Projekt konfiguriert haben (Kompilierungsschlüssel registrieren, zusätzliche Dateien), können Sie es vergessen.

Kommen wir nun zur Programmierung. pogo with hat für uns Folgendes generiert:

Tango-Steuerung

Wir werden an NEO6M.cpp und NEO6M.h interessiert sein. Nehmen wir ein Beispiel für einen Klassenkonstruktor:

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
}

Was gibt es und was ist hier wichtig? Die Funktion init_device() reserviert Speicher für unsere Attribute: gps_string & gps_array, aber es ist nicht wichtig. Das Wichtigste hier, das sind die Kommentare:

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

Alles, was sich in diesem Kommentarblock befindet, wird bei nachfolgenden Code-Neugenerierungen nicht in Pogo einbezogen wegziehen!. Alles, was nicht in Blöcken ist, wird es sein! Dies sind die Orte, an denen wir programmieren und unsere eigenen Bearbeitungen vornehmen können.

Was sind nun die Hauptfunktionen, die die Klasse enthält? 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);

Wenn wir den Attributwert lesen möchten gps_string, werden die Funktionen in der folgenden Reihenfolge aufgerufen: Always_executed_hook, read_attr_hardware и read_gps_string. Read_gps_string füllt gps_string mit dem Wert.

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
}

Zusammenstellung

Gehen Sie zum Quellordner und:

make

Das Programm wird in den Ordner ~/DeviceServers kompiliert.

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

jive

jive

Tango-Steuerung

Es sind bereits einige Geräte in der Datenbank vorhanden, jetzt erstellen wir eines Bearbeiten->Server erstellen

Tango-Steuerung

Versuchen wir nun, eine Verbindung herzustellen:

Tango-Steuerung

Nichts wird funktionieren, zuerst müssen wir unser Programm ausführen:

sudo ./NEO6M neo6m -v2

Ich kann mich nur mit Rechten mit dem COM-Port verbinden Wurzel-a. v — Protokollierungsstufe.

Jetzt können wir Folgendes verbinden:

Tango-Steuerung

Auftraggeber

In der Grafik ist das Betrachten von Bildern sicherlich gut, aber Sie brauchen etwas Nützlicheres. Schreiben wir einen Client, der sich mit unserem Gerät verbindet und Messwerte von diesem erfasst.

#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);
    }
}

So kompilieren Sie:

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++

Ergebnis:

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

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

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

Wir haben das Ergebnis als Befehlsrückgabe erhalten und dabei die Attribute einer Zeichenfolge und eines Zeichenarrays übernommen.

Referenzen

Ich habe den Artikel für mich selbst geschrieben, weil ich nach einer Weile vergesse, wie und was ich tun soll.

Vielen Dank für Ihre Aufmerksamkeit.

Source: habr.com

Kommentar hinzufügen