🥇Tango Controls

Wat is TANGO?

Dit is een systeem voor het beheer van verschillende hardware en software.
TANGO ondersteunt momenteel 4 platforms: Linux, Windows NT, Solaris en HP-UX.
Hier wordt de werking met Linux (Ubuntu 18.04) beschreven

Waarvoor is het nodig?

Het vereenvoudigt het werken met verschillende hardware en software.

U hoeft niet na te denken over het opslaan van gegevens in de database, dat is al voor u gedaan.
U hoeft alleen maar het mechanisme voor het polls van sensoren te beschrijven.
Brengt al uw code terug naar één standaard.

Waar te vinden?

Ik kon het niet vanuit de bron uitvoeren, ik heb een kant-en-klaar TangoBox-image 9.3 gebruikt.
In de handleiding staat beschreven hoe deze uit pakketten te installeren.

Waaruit bestaat het?

JIVE — dient voor het bekijken en bewerken van de TANGO-database.
POGO — codegenerator voor TANGO-apparaatservers.
Astor — softwaremanager 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++. In dit voorbeeld wordt c++ gebruikt.

Laten we nu beschrijven hoe een apparaat aan TANGO te verbinden en ermee te werken. In dit voorbeeld nemen we de kaart GPS neo-6m-0-001:

Zoals te zien op de afbeelding, verbinden we de kaart met de pc via UART CP2102. Bij aansluiting op de pc verschijnt het apparaat /dev/ttyUSB[0-N], meestal /dev/ttyUSB0.

POGO

Nu gaan we starten. pogo, en we genereren een skeleton code voor het werken met onze kaart.

pogo

Ik had al code gemaakt, laten we het opnieuw creëren Bestand->Nieuw.

We krijgen het volgende:

Ons apparaat (met 'apparaat' bedoelen we hier de softwarezijde) is leeg en heeft twee stuurcommando's: Status & Status.

Het moet worden ingevuld met de nodige attributen:

Apparaatspecifiek — standaardwaarden die we naar het apparaat sturen voor initialisatie, voor de GPS-kaart moet de naam van de kaart in het systeem worden doorgegeven com="/dev/ttyUSB0" en de snelheid van de com-poort baudrate=9600

Commando's — stuurcommando's voor ons apparaat, waaraan argumenten en een retourwaarde kunnen worden toegekend.

STATUS — geeft de huidige status weer, uit Statussen
STATUS — geeft de huidige status weer, als tekstuele aanvulling op STATUS
GPSArray — geeft weer gps een string in de vorm van DevVarCharArray

Vervolgens worden de attributen van het apparaat gedefinieerd die we kunnen lezen/schrijven naar/van.
Scalair Attributen — eenvoudige attributen (char, string, long, enz.)
Spectrum Attributen — eendimensionale arrays
Afbeelding Attributen — tweedimensionale arrays

Statussen — de toestanden waarin ons apparaat zich bevindt.

OPEN — apparaat is geopend.
CLOSE — apparaat is gesloten.
FAILT — fout.
AAN — we ontvangen gegevens van het apparaat.
UIT — er zijn geen gegevens van het apparaat.

Voorbeeld van het toevoegen van een attribuut gps_string:

Polling-periode tijd in ms, hoe vaak de waarde van gps_string zal worden bijgewerkt. Als de update tijd niet wordt ingesteld, zal het attribuut alleen op verzoek worden bijgewerkt.

Het is gelukt:

Nu moet we de code genereren Bestand->Genereren

Standaard wordt het Makefile niet gegenereerd, de eerste keer moet je een vinkje zetten om het te maken. Dit is gedaan zodat wijzigingen erop niet worden verwijderd bij een nieuwe generatie. Zodra je het eenmaal hebt gemaakt en ingesteld voor je project (compiler sleutels, extra bestanden), kun je het vergeten.

Nu gaan we direct naar de programmering. pogo heeft het volgende voor ons gegenereerd:

We zullen geïnteresseerd zijn in NEO6M.cpp & NEO6M.h. Laten we als voorbeeld de constructor van de klasse bekijken:

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 hier en wat is hier belangrijk? In de functie init_device() wordt geheugen toegewezen voor onze attributen: gps_string & gps_array, maar dat is niet belangrijk. Het belangrijkste hier is, dat zijn de commentaren:

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

Alles wat binnen dit commentaarblok staat, zal bij toekomstige codegeneraties in pogo niet verwijderd worden!. Alles wat buiten de blokken staat, zal dat wel doen! Dit zijn de plaatsen waar we kunnen programmeren en onze wijzigingen kunnen aanbrengen.

Wat zijn nu de belangrijkste functies van de klasse NEO6M:

void always_executed_hook();
void read_attr_hardware(vector &attr_list);
void read_gps_string(Tango::Attribute &attr);
void read_gps_array(Tango::Attribute &attr);

Wanneer we de waarde van het attribuut willen lezen gps_string, zullen de functies in de volgende volgorde worden aangeroepen: always_executed_hook, read_attr_hardware en read_gps_string. In read_gps_string zal gps_string worden gevuld met een waarde.

void NEO6M::read_gps_string(Tango::Attribute &attr)
{
    DEBUG_STREAM << "NEO6M::read_gps_string(Tango::Attribute &attr) entering... " <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 map met bronnen en:

make

Het programma zal worden gecompileerd in de map ~/DeviceServers.

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

JIVE

jive

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

Laten we nu proberen verbinding te maken:

Dit zal niet werken, eerst moet je ons programma starten:

sudo ./NEO6M neo6m -v2

Ik kan alleen verbinding maken met de com-poort met rechten root-a. v — niveau van logging.

We kunnen nu verbinding maken:

Klant

Het is natuurlijk leuk om naar plaatjes in de grafiek te kijken, maar we hebben iets nuttigers nodig. We gaan een client schrijven die verbinding maakt met ons apparaat en de meetwaarden ophaalt.

#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 hebben het resultaat ontvangen in de vorm van een commando-retour, het ophalen van stringattributen en een tekenarray.

Tango Controls