Show Posts

This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.


Messages - FlyingDoc

Pages: [1] 2 3 ... 30
1
Ich habe wie du empfohlen hast den 2.3.0 installiert.
Jetzt funktioneren die Callback wieder.

Danke. 8)

2
Ich arbeite gerade an beiden Varianten.
Mit neuem Image (da muß ich aber noch viel anpassen) und mit dem Versuch den Daemon zu aktualisieren.

Dabei kommt folgender Fehler.
Quote
2019-01-14 17:33:21.309458 <I> <main_linux.c:291> Brick Daemon 2.3.2+redbrick started (pid: 2023, daemonized: 0)
brickd: symbol lookup error: brickd: undefined symbol: libusb_free_pollfds

Ich habe den Daemon nach eurer Anleitung mit
Quote
# On RED Brick
wget http://download.tinkerforge.com/tools/brickd/linux/brickd_linux_latest+redbrick_armhf.deb
sudo dpkg -i brickd_linux_latest+redbrick_armhf.deb

aktualisisert. Der Daemon startet aber wie schon beschrieben nicht.

3
So. Nach dem ich Zeit zum Testen hab, die Italiener haben gerade bei uns das gesamte Netzwerk im Betrieb geändert, habe ich festgestellt, das es an der RED Img Version liegt. Beim 1.8er gehen die Callback nicht.

4
Habe gerade festgestellt , das wenn ich das Bricklet an einen einzelnen Master stecke, geht alles.
Da muss ich den Stapel mal auseinander nehmen und einzeln testen.

5
Hab ich gerade getestet. Kein Erfolg. Auch ein andere Anschluß geht nicht.
Und die Pins sind alle OK.

6
Hallo TF Team.
Erst einmal ein gesundes und erfolgreiches Jahr 2019!

Ich habe folgendes Problem.
Ich hab die IDI4 V2 in mein Programm eingebunden und bekomme den Callback nicht zum laufen.
Ich benutze die aktuellen Bindings. DIe Firmware ist auch aktuell.
Fehler werden nicht produziert.
Der Callback wird aber nicht ausgelöst.

Ich habe dann den IDI im BrickViewer V2.3.16 angeschaut.
Dort werden die Eingänge ebenfalls nicht angezeigt!
Egal welchen Zustand sie haben. Die Eingangs LED der DI zeigen aber den jeweiligen Zustand korrekt an.
Was mache ich falsch?

Das Programm ist in C++ geschrieben.


7
Allgemeine Diskussionen / Re: BrickDaemon startet nicht...
« on: December 16, 2018, 22:04:45 »
Das ist ein nur bei Windows 10 auftretender Fehler.
Der Deamon selber läuft schon. Kann aber den virtuellen Port nicht zur Verfügung stellen.
Es hilft nach dem Windows Start den Dienst einfach mal zu beenden und neu zu starten. Irgend ein Dienst im System der gebraucht wird, startet zu spät.
Zum Dienstneustart infach folgendes machen.

Auf dem Desktop mit der Maus auf das Computericon für den PC gehen
-> rechte Maustaste
-> Verwalten anwählen
-> Punkt Dienste und Anwendungen -> Dienst auswählen
In der Dienstiste den Brickdeamon suchen und anklicken
-> Oben in der Symbolleiste das Symbol |> (für Dienst neu starten) anklicken
Der Dienst wird dann beendet und neu gestartet.
Dannach funktioniert alles wie gewünscht.

8
Allgemeine Diskussionen / Re: Red Brick Wlan
« on: December 09, 2018, 15:58:20 »
Da musst du schon etwas genauer werden mit deinen Infos.
WLan Stick e.t.c.
Ich hab mit WLan keine Probleme.

9
Hardware / Re: Servobrick explodiert in Kombination mit LED
« on: December 04, 2018, 15:51:55 »
Kann es vielleicht sein , das du die Anschlusskabel am Power Supply verwechselt hast. Weil beide Stecker bei dir grün sind?
Normal ist ja einer Schwarz und der andere Grün.
Das sichert zwar nur optisch, aber es hilft.

10
Quote
Allerding funktioniert die Funktion nicht solllage wie alle Enumerate Callbacks ausgelöst nicht wurden.

Das habe ich ganz einfach gelöst.
Ich habe einen Timer der bei einem EnumerateCallback gestartet wird.
Dieser läuft als Singel Shot. Jedesmal wenn ein EnumerateCallback kommt, wird er wieder angeschubst. Das Timout ist so groß gewählt, das der Timer sein Callback erst auslösen kann wenn kein EnumerateCallback  mehr eintrifft. Dann wird die Sortierfunktion ausgelöst.
Mit der Zeit musst du dann experimentieren. All zu groß muss sie aber nicht sein. Alles im Bereich von msec. ;)

11
Doch. Das kann man sehrwohl.

Ich baue meine Programme so auf.

Der Callback gibt ja die Position (char position) zurück und wenn es ein Bricklet ist an welchem Master (char *connected_uid) es verbunden ist.

Code: [Select]
void cb_enumerate(const char *uid, const char *connected_uid, char position, uint8_t hardware_version[3], uint8_t firmware_version[3], uint16_t device_identifier, uint8_t enumeration_type, void *user_data)

Ich sammle alles in einer Tabelle und sortiere dann zum Schluß.
Die RS232 oder RS485 bekommen bei mir der Reihenfolge nach einen Namen verpasst.
COM1 , COM2 .......
So spreche ich sie dann auch an.
Genau so verfahre ich mit allen Bricklet.
Aus den Eingängen wird dann DI0 DI1 DI........ Ausgängen DO0 DO1 DO......

Mir ist egal an welchem Master diese hängen. Wichtig ist nur die Reihenfolge.
Also z.B. Der erste DI der gefunden wird ist DI0. Egal an welchem Master im Stack.
Wobei ich beim ersten Master anfange zu sortieren.
Wo die Master im Stack hängen bekommt man beim Callback mitgeteilt.

Quote
Der Callback empfängt sieben Parameter:

    uid: Die UID des Bricks/Bricklets.
    connected_uid: Die UID des Bricks mit dem das Brick/Bricklet verbunden ist. Für ein Bricklet ist dies die UID des Bricks mit dem es verbunden ist. Für einen Brick ist es die UID des untersten Master Bricks in einem Stapel. Der unterste Master Brick hat die Connected-UID "0". Mit diesen Informationen sollte es möglich sein die komplette Netzwerktopologie zu rekonstruieren.
    position: Für Bricks: '0' - '8' (Position in Stapel). Für Bricklets: 'a' - 'd' (Position an Brick).
    hardware_version: Major, Minor und Release Nummer der Hardwareversion.
    firmware_version: Major, Minor und Release Nummer der Firmwareversion.
    device_identifier: Eine Zahl, welche den Brick/Bricklet repräsentiert.
    enumeration_type: Art der Enumerierung

12
Wie groß ist denn die längte Strecke?

Wenn du PTC Bricklet nimmst benutze 4 Leiter Sensoren.
Dann kannst du auch lange Strecken verlegen vom Bricklet zum Sensor.
Durch die 4 Leitertechnik wird der Messfehler vernachlässigbar.

Ansonsten nimmst du halt bei sehr weiten Strecken jeweils einen Master mit PTC Bricklet und eine RS485 vor Ort und verbindest die Stapel mit RS485 untereinander.
Diese kannst du dann als einen Stapel behandeln.

13
Software, Programmierung und externe Tools / Re: GPSv2 c++ Bugs?
« on: August 17, 2018, 13:11:57 »
Läuft der Brick Demon auf deinem Rechner?
Wenn du nicht über das Netzwerk gehst sollte dieser laufen.
Also. Siehst du deinen Stapel im Brick Viewer?

14
Das hast du richtig verstanden.

Die Konfiguration machst du über den Brick Viewer.
Dann können deine Programme ganz normal über das Netzwerk kommunizieren.
Der Brick Viewer kann dann ebenfalls über das LAN auf deinen Stapel zugreifen.
Die erste Konfig musst du aber über USB machen.

15
Anfängerfragen und FAQ / Re: UID auslesen in C++
« on: July 20, 2018, 00:01:52 »
Hier mal meinen Code wie ich es benutze.
Schreiben tue ich mit QT. Dann kann man das Programm sowohl auf Windows als auch auf Linux Rechnern laufen lassen.

Ich hoffe es hilft dir etwas weiter.
Mein Programm geht dynamisch mit den Komponenten um.
Ich habe eine Dynamische Liste in der alle gespeichert werden.
Ausserdem ordne ich diese dann der Reihenfolge im Stapel nach.
Es ist auch egal wo sie angesteckt werden.
Zum Beispiel:
Der erste gefundene Quad Relais bekommt bei mir die ID 0 - 3.
Egal an welchem Master er angesteckt wird.
Wenn in der Reihenfolge kein anderer Quad davor kommt, bekommt er die Nummern 0-3. Der nächste dann 4-7 u.s.w.
In meiner Liste ist jede Komponente mit Typ und UID hinterlegt.
Darüber kann ich sie dann finden und ansprechen. Bei Callback zum Beispiel.

Code: [Select]
void Create_REDBrick(const char* device_uid, uint8_t device_identifier, const char *connected_uid,char position, bool is_new)
{
    qDebug() << "Create_REDBrick " << device_uid << " connected_uid " << connected_uid << " position " << position;
    /****************************************************************************/
    /* Create_REDBrick Bricklet einbinden */
    /****************************************************************************/
    Brick* NewBrick = NULL;
    QString DEVICE_UID = QString(device_uid);
    QString CONNECTED_UID   = QString(connected_uid);
    UID = strdup(device_uid);
    if(UID)
    {
//            _strset( UID, 0 );
//            strncpy_s(UID,strlen(device_uid),  device_uid, strlen(device_uid)-1);
        /****************************************************************************/
        /*                             RED Brick erstellen      */
        /****************************************************************************/
        if(Mainprogramm)
        {
            if(!Mainprogramm->Check_Brick(DEVICE_UID))
            {
                NewBrick = new Brick("Redbrick",0,0,DEVICE_UID,CONNECTED_UID,(QString)position);
                NewBrick->Redbrick = new RED();
                red_create(NewBrick->Redbrick, device_uid,ipcon);
                Mainprogramm->Bricklist.append(NewBrick);
            }
            else
            {
                NewBrick = Mainprogramm->Get_Brick(DEVICE_UID);
            }
            Mainprogramm->Set_enumeratebit();
        }
    }
}

void Create_Master(const char* device_uid, uint8_t device_identifier, const char *connected_uid,char position, bool is_new)
{
    qDebug() << "Create_Master " << device_uid << " connected_uid " << connected_uid << " position " << position;
    /****************************************************************************/
    /* Master Brick einbinden */
    /****************************************************************************/
    Brick*  NewBrick    = NULL;
    QString DEVICE_UID  = QString(device_uid);
    QString CONNECTED_UID   = QString(connected_uid);
    UID = strdup(device_uid);
    if(UID)
    {
        /****************************************************************************/
        /* Master Brick erstellen */
        /****************************************************************************/
        if(Mainprogramm)
        {
            if(!Mainprogramm->Check_Brick(DEVICE_UID))
            {
                NewBrick = new Brick("Master",0,0,DEVICE_UID,CONNECTED_UID,(QString)position);
                NewBrick->master = new Master();
                master_create(NewBrick->master, device_uid,ipcon);
                Mainprogramm->Bricklist.append(NewBrick);
            }
            else
            {
                NewBrick = Mainprogramm->Get_Brick(DEVICE_UID);
            }
            if(NewBrick)
            {
                uint16_t voltage    = 0;
                uint16_t current    = 0;
                uint16_t usbvoltage = 0;
                master_get_stack_voltage(NewBrick->master, &voltage);
                master_get_stack_current(NewBrick->master, &current);
                master_get_usb_voltage(  NewBrick->master, &usbvoltage);
                Mainprogramm->Set_Stackvoltage(voltage/1000);
                Mainprogramm->Set_Stack_current(current/1000);
                /****************************************************************************/
                /* Master Brick Callback erstellen */
                /****************************************************************************/
                master_register_callback(NewBrick->master,MASTER_CALLBACK_STACK_VOLTAGE , (void*)cb_stack_voltage,NewBrick->master);
                master_register_callback(NewBrick->master,MASTER_CALLBACK_USB_VOLTAGE , (void*)cb_stack_voltage,NewBrick->master);
                master_register_callback(NewBrick->master,MASTER_CALLBACK_STACK_CURRENT , (void*)cb_stack_current,NewBrick->master);

            }
            Mainprogramm->Set_enumeratebit();
        }
    }
}

void cb_enumerate(const char *uid, const char *connected_uid, char position, uint8_t hardware_version[3], uint8_t firmware_version[3], uint16_t device_identifier, uint8_t enumeration_type, void *user_data)
{
    qDebug() << QTime::currentTime().toString("hh:mm:ss:zzz   ")  << "cb_enumerate( " << uid << " , " << connected_uid << " , " << position << " , " << hardware_version << " , " << firmware_version << " , " << device_identifier << " , " << enumeration_type << "*user_data)";
    /****************************************************************************/
    /* Antwort auf Komponentenabfrage (Bricks,Bricklets) */
    /****************************************************************************/
    int n = 0;
    bool New = false;
    QString DEVICE_UID = QString(uid);
    if(Mainprogramm)
    {
        if(!Mainprogramm->Check_Brick(DEVICE_UID))
        {
            New = true;
        }
    }
    if(enumeration_type == IPCON_ENUMERATION_TYPE_DISCONNECTED)
    {
        Mainprogramm->Remove_Brick(DEVICE_UID);
    }

    if(device_identifier==MASTER_DEVICE_IDENTIFIER)
    {
        if(enumeration_type == IPCON_ENUMERATION_TYPE_AVAILABLE)
        {
            Create_Master(uid,device_identifier, connected_uid, position,true);
            uid_master = uid;
            qDebug() << "Enumeration Type: " << enumeration_type;
            qDebug() << "Master Brick gefunden";
            printf("Enumeration Type:  %d\n", enumeration_type);
        }
        if(enumeration_type == IPCON_ENUMERATION_TYPE_CONNECTED)
        {
            Create_Master(uid,device_identifier, connected_uid, position,true);
            uid_master = uid;
            printf("Enumeration Type:  %d\n", enumeration_type);
            qDebug() << "Enumeration Type: " << enumeration_type;
            qDebug() << "Master Brick verbunden";
        }
        if(enumeration_type == IPCON_ENUMERATION_TYPE_DISCONNECTED)
        {
            printf("Enumeration Type:  %d\n", enumeration_type);
            qDebug() << "Enumeration Type: " << enumeration_type;
            qDebug() << "Master Brick disconnected";
            Brick* OldBrick = Mainprogramm->Get_Brick(DEVICE_UID);
            if(OldBrick)
            {
                Mainprogramm->Remove_Brick(DEVICE_UID);
                master_destroy(OldBrick->master);
                delete OldBrick->master;
                OldBrick->master = NULL;
                Mainprogramm->Remove_Brick(DEVICE_UID);
            }
        }

    if(device_identifier==INDUSTRIAL_QUAD_RELAY_DEVICE_IDENTIFIER)
    {
        if(enumeration_type == IPCON_ENUMERATION_TYPE_AVAILABLE)
        {
            Create_Industrial_Quad_Relay[n](uid,device_identifier, connected_uid, position,true);
            uid_Digital_In = uid;
            qDebug() << "Enumeration Type: " << enumeration_type;
            qDebug() << "DIGITAL QUAD OUT Brickled gefunden";
            printf("Enumeration Type:  %d\n", enumeration_type);
        }
        if(enumeration_type == IPCON_ENUMERATION_TYPE_CONNECTED)
        {
            Create_Industrial_Quad_Relay(uid,device_identifier, connected_uid, position,true);
            qDebug() << "Enumeration Type: " << enumeration_type;
            qDebug() << "DIGITAL QUAD OUT Brickled gefunden";
            printf("Enumeration Type:  %d\n", enumeration_type);
        }
        if(enumeration_type == IPCON_ENUMERATION_TYPE_DISCONNECTED)
        {
            printf("Enumeration Type:  %d\n", enumeration_type);
            qDebug() << "Enumeration Type: " << enumeration_type;
            qDebug() << "DIGITAL QUAD OUT Brickled disconnected";
            Brick* OldBrick = Mainprogramm->Get_Brick(DEVICE_UID);
            if(OldBrick)
            {
                industrial_quad_relay_destroy(OldBrick->Quad_Relay);
                delete OldBrick->Quad_Relay;
                OldBrick->Quad_Relay = NULL;
            }
        }
    }
    }

    if(device_identifier==RED_DEVICE_IDENTIFIER)
    {
        if(enumeration_type == IPCON_ENUMERATION_TYPE_AVAILABLE)
        {
            Create_REDBrick(uid,device_identifier, connected_uid, position,true);
            uid_Redbrick = uid;
            qDebug() << "Enumeration Type: " << enumeration_type;
            qDebug() << "RED Brick gefunden";
            printf("Enumeration Type:  %d\n", enumeration_type);
        }
        if(enumeration_type == IPCON_ENUMERATION_TYPE_CONNECTED)
        {
            Create_REDBrick(uid,device_identifier, connected_uid, position,true);
            uid_Redbrick = uid;
            qDebug() << "Enumeration Type: " << enumeration_type;
            qDebug() << "RED Brick gefunden";
            uid_Redbrick = uid;
            printf("Enumeration Type:  %d\n", enumeration_type);
        }
        if(enumeration_type == IPCON_ENUMERATION_TYPE_DISCONNECTED)
        {
            printf("Enumeration Type:  %d\n", enumeration_type);
            qDebug() << "Enumeration Type: " << enumeration_type;
            qDebug() << "RED Brick disconnected";
            Brick* OldBrick = Mainprogramm->Get_Brick(DEVICE_UID);
            if(OldBrick)
            {
                red_destroy(OldBrick->Redbrick);
                delete OldBrick->Redbrick;
                OldBrick->Redbrick = NULL;
                Mainprogramm->Remove_Brick(DEVICE_UID);
            }
        }
    }

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    qDebug() << "main(" << argc << " , " << argv << ")";
    QString Puffer;
    int Pos = 0;
    while(Pos < argc)
    {
        Puffer = argv[Pos];
        qDebug() << "Arg " << Pos << " : " << Puffer;
        if(Puffer.contains("IP="))
        {
            TFIP = Puffer.remove("IP=");
        }
        else if(Puffer.contains("PORT="))
        {
            Puffer = Puffer.remove("PORT=");
            PORT = Puffer.toInt();
        }
        Pos++;
    }
    /****************************************************************************/
    /* Hauptprogramm starten */
    /****************************************************************************/
    if(Mainprogramm == NULL)
    {
        qDebug() << "Touchprogram erstellen";
        Mainprogramm = new Touchprogram();
        Mainprogramm->Read_Ini();
        Mainprogramm->Run();
        Mainprogramm->window->update();
        if(Mainprogramm->LOCALHOST)
        {
            TFIP = "localhost";
        }
        else
        {
            TFIP = Mainprogramm->TFIP;
        }
        PORT = Mainprogramm->PORT;
    }

    /****************************************************************************/
    /* IPConnection erstellen */
    /****************************************************************************/

    HOST = (char *)malloc((TFIP.length() + 1) * sizeof(char));
    strcpy(HOST, TFIP.toStdString().c_str());
    qDebug() << "Create IPConnection";
    if(!ipcon)
    {
       ipcon = new IPConnection();
    }
    if(ipcon)
    {
        qDebug() << "Create IPConnection success";
        ipcon_create(ipcon);
        qDebug() << "connect to " << HOST << " Port: " << PORT;
        if(ipcon_connect(ipcon, HOST, PORT) < 0)
        {
            qDebug() << "Could not create connection";
            fprintf(stderr, "Could not create connection\n");
            ipcon_set_auto_reconnect(ipcon,true);
        }
    }
    else
    {
        qDebug() << "Could not create  IPConnection";
    }
    /****************************************************************************/
    /* Komponenten (Bricks,Bricklets) abfragen */
    /****************************************************************************/
    ipcon_register_callback(ipcon,   IPCON_CALLBACK_ENUMERATE,(void *)cb_enumerate   ,NULL);
    ipcon_enumerate(ipcon);

    return a.exec();
}



Pages: [1] 2 3 ... 30