🥇Controles de tango

¿Qué TANGO?

Es un sistema para gestionar diversos hardware y software.
TANGO actualmente soporta 4 plataformas: Linux, Windows NT, Solaris y HP-UX.
Aquí describiremos cómo trabajar con Linux (Ubuntu 18.04)

¿Qué se necesita?

Simplifica el trabajo con diversos equipos y software.

No necesita pensar en cómo almacenar datos en la base de datos, ya está hecho por usted.
Sólo es necesario describir el mecanismo de sondeo de los sensores.
Reduce todo su código a un estándar.

¿Dónde conseguirlo?

No pude ejecutarlo desde el código fuente; usé una imagen ya preparada de TangoBox 9.3 para funcionar.
Las instrucciones describen cómo instalar desde paquetes.

¿En qué consiste?

JIVE — se utiliza para ver y editar la base de datos de TANGO.
POGO — generador de código para servidores de dispositivos TANGO.
Astor — director de programa del sistema TANGO.

Sólo nos interesarán los dos primeros componentes.

Lenguajes de programación soportados

C
C + +
Java
JavaScript
Python
Matlab
LabVIEW

Trabajé con él en Python y C++. Aquí se utilizará C++ como ejemplo.

Pasemos ahora a una descripción de cómo conectar el dispositivo a TANGO y cómo trabajar con él. La tarifa se tomará como ejemplo. GPS neo-6m-0-001:

Como podéis ver en la imagen, conectamos la placa al PC mediante UART CP2102. Cuando se conecta a una PC, el dispositivo aparece /dev/ttyUSB[0-N], normalmente /dev/ttyUSB0.

POGO

Ahora lancemos pogoy generar código esqueleto para trabajar con nuestra placa.

pogo

Ya creé el código, vamos a crearlo nuevamente. Archivo->Nuevo.

Obtenemos lo siguiente:

Nuestro dispositivo (en el futuro por dispositivo nos referiremos a la parte de software) está vacío y tiene dos comandos de control: Estado & Estado.

Debe estar lleno de los atributos necesarios:

Propiedad del dispositivo — valores predeterminados que transferimos al dispositivo para inicializarlo; para la placa GPS, es necesario transferir el nombre de la placa en el sistema es="/dev/ttyUSB0" y velocidad del puerto com velocidad en baudios=9600

Comandos — comandos para controlar nuestro dispositivo; se les pueden dar argumentos y un valor de retorno.

STATE - devuelve el estado actual, desde Zonas
ESTADO - devuelve el estado actual, este es el complemento de la cadena a STATE
Matriz GPS - devoluciones gps cadena en la forma DevVarCharArray

A continuación, configure los atributos del dispositivo que se pueden leer/escribir en/desde él.
Atributos escalares — atributos simples (char, string, long, etc.)
Atributos del espectro - matrices unidimensionales
Atributos de imagen - matrices bidimensionales

Zonas — el estado en el que se encuentra nuestro dispositivo.

ABIERTO — el dispositivo está abierto.
CERCA - el dispositivo está cerrado.
FALLA - error.
ON — recibir datos del dispositivo.
OFF — no hay datos del dispositivo.

Ejemplo de agregar un atributo cadena_gps:

Período de votación tiempo en ms, con qué frecuencia se actualizará el valor gps_string. Si no se especifica la hora de actualización, el atributo se actualizará solo cuando se solicite.

Resultó que:

Ahora necesitas generar el código. Archivo->Generar

De forma predeterminada, el Makefile no se genera; la primera vez es necesario marcar la casilla para crearlo. Esto se hace para que los cambios realizados en él no se eliminen durante una nueva generación. Habiéndolo creado una vez y configurado para su proyecto (registrar claves de compilación, archivos adicionales), puede olvidarse de él.

Ahora pasemos a la programación. pogo generó lo siguiente para nosotros:

Estaremos interesados en NEO6M.cpp y NEO6M.h. Tomemos un ejemplo de un constructor de clases:

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
}

¿Qué hay y qué es importante aquí? La función init_device() asigna memoria para nuestros atributos: cadena_gps & matriz_gps, pero no es importante. Lo más importante aquí, estos son los comentarios:

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

Todo lo que esté dentro de este bloque de comentarios no se incluirá en pogo durante las regeneraciones de código posteriores. ¡alejarse!. ¡Todo lo que no esté en bloques lo estará! Estos son los lugares donde podemos programar y realizar nuestras propias ediciones.

Ahora bien, ¿cuáles son las funciones principales que contiene la clase? 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);

Cuando queremos leer el valor del atributo. cadena_gps, las funciones se llamarán en el siguiente orden: gancho_siempre_ejecutado, read_attr_hardware и leer_cadena_gps. Read_gps_string completará gps_string con el valor.

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
}

Compilacion

Vaya a la carpeta de origen y:

make

El programa se compilará en la carpeta ~/DeviceServers.

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

JIVE

jive

Ya hay algunos dispositivos en la base de datos, ahora creemos el nuestro. Editar->Crear servidor

Ahora intentemos conectarnos a él:

Nada funcionará, primero debemos ejecutar nuestro programa:

sudo ./NEO6M neo6m -v2

Solo puedo conectarme al puerto com con derechos raíz-a v — nivel de registro.

Ahora podemos conectarnos:

Cliente

En gráficos, mirar imágenes es ciertamente bueno, pero necesitas algo más útil. Escribamos un cliente que se conectará a nuestro dispositivo y tomará lecturas del mismo.

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

Cómo compilar:

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

Resultado:

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

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

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

Obtuvimos el resultado como retorno de comando, tomando los atributos de una cadena y una matriz de caracteres.

referencias

Códigos fuente

Escribí el artículo por mí mismo, porque después de un tiempo empiezo a olvidar cómo y qué hacer.

Gracias por su atención.

Fuente: habr.com

Controles de tango