FlyingDoc's Content - Seite 2

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.

GPSv2 c++ Bugs?

in Software, Programmierung und externe Tools

Geschrieben August 17, 2018 at 11:1117. Aug 2018

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?

Netzwerkzugriff via Ethernet-Extension und RED

in Anfängerfragen und FAQ

Geschrieben August 9, 2018 at 07:479. Aug 2018

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.

UID auslesen in C++

in Anfängerfragen und FAQ

Geschrieben July 19, 2018 at 22:0119. Jul 2018

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.

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

Betrieb von Außen-Wetterstation WS-6147

in Hardware

Geschrieben June 28, 2018 at 08:5028. Jun 2018

Zum Helligkeit Sensor kommst duhier.

Red Brick Upgrade

in Allgemeine Diskussionen

Geschrieben May 11, 2018 at 20:4711. Mai 2018

Klingt interessant.

Wie sieht es dann mit Audioausgabe aus?

Eventuell über den Videoausgang?

Red Brick Upgrade

in Allgemeine Diskussionen

Geschrieben May 11, 2018 at 07:5811. Mai 2018

Kurze Frage an das Thinkerforge Team.

Ist es eigentlich geplant dem RED irgendwann ein CPU Upgrade zu spendieren?

Ich arbeite sehr gerne mit dem RED, da er sich sehr gut in den Stapel integriert.

Neue Bindings?

in Allgemeine Diskussionen

Geschrieben April 30, 2018 at 14:1430. Apr 2018

ok. THX for Information

Neue Bindings?

in Allgemeine Diskussionen

Geschrieben April 30, 2018 at 09:4130. Apr 2018

Wann ist geplannt die neuen Bindings zu veröffentlichen?

Ich bräuchte die Callbackfunktion für den PTC "PTC_CALLBACK_SENSOR_CONNECTED"

in den 2.1.19 ist diese noch nicht eingebaut.

Probleme beim Updaten auf neue Versionen

in Software, Programmierung und externe Tools

Geschrieben April 16, 2018 at 20:1316. Apr 2018

Hat dein Master die aktuelle Firmeware?

Vorschlag für den Brick Viewer

in Software, Programmierung und externe Tools

Geschrieben March 13, 2018 at 23:3713. Mär 2018

Da ihr ja ab dem 10er Image den CPU frequency scaling governor benutzt hätte ich einen Vorschlag.

Wie wäre es wenn ihr im Brick Viewer die Möglichkeit anbietet, der CPU frequency scaling governor einstellen zu können und der RED dann damit auch startet und läuft. Es also permanent hinterlegt.

So könnte man diesen seinen Bedürfnissen anpassen.

Einige würden gerne Strom sparen, andere wiederum immer mit Highperformance.

Andere wiederum die Standardeinstellung nutzen.

Sun Tracker / Sonnennachführung

in Projektvorstellungen und Projektideen

Geschrieben February 25, 2018 at 22:2925. Feb 2018

Also so we ich es sehe fürst du dein Solarmodul Zeitgesteuert. Also je nach Zeit eine bestimmte Position. Richtig?

Warum fürst du dein Solarmodul nicht nach dem wirklichen Sonnenstand?

Ich habe sowas vor knapp über 20 Jahren mit einer Microsteuerung von Conrad für einen Kumpel gebaut.

Nur das ich seine Solarmodule, hatte er selber gebaut in dem er Wasser durch Rohre geführt hat um seinen Kessel zu erwärmen, über zwei kleine Solarmodule dem Sonnenstand nachgeführt habe.

Ich hab nur eine Achse gesteuert. Lässt sich aber einfach auf 2 Achsen, also Höhe und Schwenken, erweitern.

Dazu habe ich einfach 2 Minisolarzellen direkt nebeneinander gelegt und dann das ganze in ein Gehäuse eingebaut, das oben eine definierte Öffnung hatte.

Dazu habe ich die Spannung beider Solarzellen verglichen und die Solarmodule , an dem meine Solarmesseinrichtung mit befestigt waren, einfach solange in die Richtung bewegt bis beide Solarzellen den fast gleichen Wert brachten.

Die Richtung die man bewegen muss erkennt man daran, welche Solarzelle mehr Spannung liefert.

Ansonsten eine gute einfache Umsetzung.

Anderes Touchdisplay Treiberinstallation

in Software, Programmierung und externe Tools

Geschrieben January 26, 2018 at 07:2826. Jan 2018

Danke. Jetzt funktioniert es.

Anderes Touchdisplay Treiberinstallation

in Software, Programmierung und externe Tools

Geschrieben January 25, 2018 at 07:3225. Jan 2018

Nein.

sudo systemctl status eGTouch
[sudo] password for tf:
â— eGTouch.service
Loaded: loaded (/etc/init.d/eGTouch.sh; generated; vendor preset: enabled)
Active: inactive (dead)
Docs: man:systemd-sysv-generator(

Anderes Touchdisplay Treiberinstallation

in Software, Programmierung und externe Tools

Geschrieben January 23, 2018 at 10:0723. Jan 2018

Hatte ich auch schon probiert. Bringt folgendes.

sh-4.4# sudo systemctl enable eGTouch
Failed to enable unit: Unit /run/systemd/generator.late/eGTouch.service is transient or generated.
sh-4.4#

Anderes Touchdisplay Treiberinstallation

in Software, Programmierung und externe Tools

Geschrieben January 23, 2018 at 07:2823. Jan 2018

So. War gerade mal an der Anlage. Kann drauf rumdadschen.

Nun muß das nur noch mit Systemstart starten. Muss ich mal schauen.

Anderes Touchdisplay Treiberinstallation

in Software, Programmierung und externe Tools

Geschrieben January 22, 2018 at 16:2922. Jan 2018

Danke. Jetzt scheint es zu laufen. Muß morgen mal am Ofen am Display drauf rumdadschen ob es futzt. Mach jetzt Feierabend.

Mechanische Haltbarkeit Ethernet Master Extension

in Hardware

Geschrieben January 19, 2018 at 20:1819. Jan 2018

Hi. Mir ist ein kleines Problem mit der mechanischen Belastbarkeit der Ethernet Master Extension aufgefallen.

Bei unserem neuem Projekt ist eine Ethernet Master Extension im Stapel verbaut.

Nun ist es unserem Techniker beim Aufbau mehrmals kurz hintereinander "gelungen", das er die Buchse von der Leiterplatte , sagen wir mal "entfernt" hat.

Ich habe mir den mechanischen Aufbau mal genauer angeschaut. Es braucht wirklich nicht viel Kraft, um die Buchse zu entfernen. Man braucht wirklich nur ungünstig an den Stecker zu kommen.

Ich habe es mir angeschaut und habe einen einfachen, praktikablen Vorschlag, der auch nur Centbeträge in der Produktion kostet.

Ihr müsst die Buchse nur zusätzlich aufkleben mit einem entsprechendem Kleber.

Zum Beispiel Locktide oder ähnliche. Schon wäre das ganze Problem gelöst.

Anderes Touchdisplay Treiberinstallation

in Software, Programmierung und externe Tools

Geschrieben January 19, 2018 at 12:2919. Jan 2018

Bitte schön.

tf@ASZ_HBO_Zone4:~$ sudo /etc/init.d/eGTouch.sh start
[sudo] password for tf:
sudo: unable to execute /etc/init.d/eGTouch.sh: No such file or directory
tf@ASZ_HBO_Zone4:~$

RED hat permanent hohe CPU Last

in Software, Programmierung und externe Tools

Geschrieben January 19, 2018 at 09:4219. Jan 2018

Wenn ich auch mal darf.

Arbeite gerade an einem Steuerungsprojekt.

Wollte da das 10 IMG nehmen. Hab aber auch feststellen müssen das da irgend etwas nicht in Ordnung ist. Hab heute Früh mal zwischen einem blankem 10er und 9er Image verglichen. Siehe Bilder. Das 10 hat eine sehr hohe CPU Last. Selbst im Leerlauf.

Die Screens habe ich bei genau der gleichen Hadware gemacht.

Alle Bricks haben die aktuelle Firmware.

Das 10er läuft beim Start bei 100% und pegelt sich bei ~70% ein. Es ist das blanke Image. Auf dem RED steck eine Ethernet Extension mit zugewiesener IP und ist online.

Anderes Touchdisplay Treiberinstallation

in Software, Programmierung und externe Tools

Geschrieben January 4, 2018 at 23:194. Jan 2018

Hallo photron?

Habt ihr mich vergessen oder braucht ihr noch Infos?

New RED bootet nicht

in Hardware

Geschrieben January 3, 2018 at 20:013. Jan 2018

Hast du schon mal das aktuelle IMG neu auf die Karte gespielt? Wenn ich eine SD vom RED beim PC reinschiebe will er sie maximal formatieren.

Der kann damit nix anfangen.

Ich wünsche Euch einen guten Rutsch ins neue Jahr

in Allgemeine Diskussionen

Geschrieben December 31, 2017 at 09:5231. Dez 2017

Ich wünsche allen einen guten Rutsch ins Neue und dem Thinkerforge Team ein erfolgreiches neues Jahr.

Anderes Touchdisplay Treiberinstallation

in Software, Programmierung und externe Tools

Geschrieben December 23, 2017 at 23:1523. Dez 2017

So. Heute ähm Gestern mal Zeit gehabt.

tf@red-brick:/etc/init.d$ sudo eGTouch.sh start
[sudo] password for tf:
sudo: eGTouch.sh: command not found

Hab mir dann mal die eGTouch.sh mit nano angeschaut.

Folgendes steht drin.

#!/bin/sh

export DISPLAY=:0

if [ -e /var/lib/lightdm/.Xauthority ]; then # ubuntu 15.04
        export XAUTHORITY=/var/lib/lightdm/.Xauthority
elif [ -e /root/.xauth* ]; then # RHEL 6.7
        export XAUTHORITY=`ls /root/.xauth*`
elif [ -e /var/run/gdm ]; then # ubuntu 10.04
        export XAUTHORITY=`ls /var/run/gdm/*/database`
else
        export XAUTHORITY=`ls /home/*/.Xauthority`
fi

/usr/bin/eGTouchD

exit 0

TinkerForge Cloud

in Allgemeine Diskussionen

Geschrieben December 20, 2017 at 21:2720. Dez 2017

Die ist gerade mit Siri auf dem Weinachtsmarkt bummeln.

Anmelden

Posts erstellt von FlyingDoc

Configure browser push notifications

Chrome (Android)

Chrome (Desktop)

Safari (iOS 16.4+)

Safari (macOS)

Edge (Android)

Edge (Desktop)

Firefox (Android)

Firefox (Desktop)