ProHoster > blog > administratie > Tango-bediening

Tango-bediening

Tango-bediening

Wat TANGO?

Het is een systeem voor het beheren van verschillende hardware en software.
TANGO ondersteunt momenteel 4 platforms: Linux, Windows NT, Solaris en HP-UX.
Hier beschrijven we het werken met Linux (Ubuntu 18.04)

Waar is het voor?

Vereenvoudigt het werken met diverse apparatuur en software.

  • U hoeft niet na te denken over hoe u gegevens in de database opslaat, dit wordt al voor u gedaan.
  • Het is alleen nodig om het mechanisme voor het opvragen van sensoren te beschrijven.
  • Reduceert al uw code tot één standaard.

Waar te krijgen?

Ik kon het niet starten vanuit de broncode; ik gebruikte een kant-en-klare afbeelding van TangoBox 9.3 om te werken.
De instructies beschrijven hoe u vanuit pakketten kunt installeren.

Waar bestaat het uit?

  • JIVE — gebruikt om de TANGO-database te bekijken en te bewerken.
  • POGO — codegenerator voor TANGO-apparaatservers.
  • Astor — programmamanager voor het TANGO-systeem.

We zullen alleen geïnteresseerd zijn in de eerste twee componenten.

Ondersteunde programmeertalen

  • C
  • C + +
  • Java
  • JavaScript
  • Python
  • matlab
  • LabVIEW

Ik heb ermee gewerkt in Python & C++. Hier wordt C++ als voorbeeld gebruikt.

Laten we nu verder gaan met een beschrijving van hoe u het apparaat op TANGO aansluit en hoe u ermee kunt werken. De vergoeding zal als voorbeeld worden genomen GPS-neo-6m-0-001:

Tango-bediening

Zoals je op de foto kunt zien, verbinden we het bord via UART CP2102 met de pc. Wanneer het apparaat op een pc is aangesloten, verschijnt het /dev/ttyUSB[0-N], meestal /dev/ttyUSB0.

POGO

Laten we nu lanceren pogoen genereer skeletcode voor het werken met ons bord.

pogo

Tango-bediening

Ik heb de code al gemaakt, laten we deze opnieuw maken Bestand->Nieuw.

Tango-bediening

Wij krijgen het volgende:

Tango-bediening

Ons apparaat (in de toekomst bedoelen we met apparaat het softwaregedeelte) is leeg en heeft twee bedieningsopdrachten: Land & Status.

Het moet worden gevuld met de benodigde attributen:

Apparaateigenschap — standaardwaarden die we naar het apparaat overbrengen om het te initialiseren; voor het GPS-bord moet u de naam van het bord in het systeem overbrengen com="/dev/ttyUSB0" en com-poortsnelheid baudrade=9600

commando's — opdrachten om ons apparaat te besturen; er kunnen argumenten en een retourwaarde aan worden gegeven.

  • STAAT - retourneert de huidige status, van Staten
  • STATUS - retourneert de huidige status, dit is het complement van de string STAAT
  • GPSArray - geeft terug gps tekenreeks in het formulier DevVarCharArray

Stel vervolgens de apparaatkenmerken in die kunnen worden gelezen/geschreven van/naar het apparaat.
Scalaire attributen — eenvoudige attributen (char, string, long, etc.)
Spectrumkenmerken - eendimensionale arrays
Afbeeldingskenmerken - tweedimensionale arrays

Staten — de staat waarin ons apparaat zich bevindt.

  • OPEN — het apparaat is geopend.
  • SLUIT - het apparaat is gesloten.
  • FOUT - fout.
  • ON — gegevens ontvangen van het apparaat.
  • UIT — geen gegevens van het apparaat.

Voorbeeld van het toevoegen van een attribuut gps_string:

Tango-bediening

Polling-periode tijd in ms, hoe vaak de gps_string-waarde wordt bijgewerkt. Als de updatetijd niet is opgegeven, wordt het kenmerk alleen op verzoek bijgewerkt.

Het bleek:

Tango-bediening

Nu moet je de code genereren Bestand->Genereren

Tango-bediening

Standaard wordt de Makefile niet gegenereerd; de eerste keer moet u het vakje aanvinken om het te maken. Dit wordt gedaan zodat de aangebrachte wijzigingen niet worden verwijderd tijdens een nieuwe generatie. Nadat u het eenmaal hebt aangemaakt en voor uw project hebt geconfigureerd (compilatiesleutels registreren, extra bestanden), kunt u het vergeten.

Laten we nu verder gaan met programmeren. pogo with heeft voor ons het volgende gegenereerd:

Tango-bediening

Wij zijn geïnteresseerd in NEO6M.cpp & NEO6M.h. Laten we een voorbeeld nemen van een klassenconstructor:

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
}

Wat is er en wat is hier belangrijk? De functie init_device() wijst geheugen toe voor onze attributen: gps_string & gps_array, maar het is niet belangrijk. Het belangrijkste hier, dit zijn de opmerkingen:

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

Alles wat zich in dit commentaarblok bevindt, wordt tijdens daaropvolgende coderegeneraties niet in pogo opgenomen ga weg!. Alles wat niet in blokken zit, zal dat wel zijn! Dit zijn de plaatsen waar we kunnen programmeren en onze eigen bewerkingen kunnen uitvoeren.

Wat zijn nu de belangrijkste functies die de klasse bevat? 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);

Wanneer we de attribuutwaarde willen lezen gps_string, worden de functies in de volgende volgorde aangeroepen: altijd_uitgevoerde_hook, lees_attr_hardware и lees_gps_string. Read_gps_string vult gps_string met de waarde.

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
}

Compilatie

Ga naar de bronmap en:

make

Het programma wordt gecompileerd in de map ~/DeviceServers.

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

JIVE

jive

Tango-bediening

Er zijn al enkele apparaten in de database, laten we nu de onze maken Bewerken->Server maken

Tango-bediening

Laten we nu proberen er verbinding mee te maken:

Tango-bediening

Niets zal werken, eerst moeten we ons programma uitvoeren:

sudo ./NEO6M neo6m -v2

Ik kan alleen verbinding maken met de com-poort met rechten wortel-A. v — logniveau.

Nu kunnen we verbinding maken:

Tango-bediening

klant

Grafisch is het kijken naar afbeeldingen zeker goed, maar je hebt iets nuttigers nodig. Laten we een client schrijven die verbinding maakt met ons apparaat en er metingen van doet.

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

Hoe te compileren:

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

Resultaat:

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

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

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

We kregen het resultaat als een opdrachtretour, waarbij we de attributen van een string en een reeks karakters namen.

referenties

Ik heb het artikel voor mezelf geschreven, omdat ik na een tijdje begin te vergeten hoe en wat ik moet doen.

Dank u voor uw aandacht.

Bron: www.habr.com

Voeg een reactie