Ankündigung

Einklappen
Keine Ankündigung bisher.

ESP8266 über WLAN an KNX

Einklappen
X
 
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

    Mal so als Zwischenfrage: Könnte mal jemand den Stromverbrauch vom ESP8266 messen (bei aufgebauter WLAN-Verbindung). Ich frage mich ob man dem auch an einer Batterie betreiben kann, bspw. um den Briefkasten auszuwerten...

    Danke schon mal!

    Kommentar


      Machbar ist es: http://www.whatimade.today/esp-8266-...eep-and-blynk/

      Kommentar


        Hier scheint sich etwas in Richtung Anbindung an Tasmota zu tun:
        https://github.com/ascillato/esp-knx-ip

        Interessant in diesem Zusammenhang ist auch noch das hier:
        https://github.com/reloxx13/SonWEB ( Eine Zentrale Verwaltung der Sonoff / Tasmota Geräte ).

        Bezüglich der Telegrammverluste kann ich nach knapp zwei Monaten Betrieb keine Feststellung machen. Ich nutze KNXD, allerdings habe ich auch nur die wenigen ESP als IP Geräte laufen (Mietshaus ).

        Gruß, Sven

        Kommentar


          Hallo Sven,

          was heißt "...keine Feststellung machen."? Gehen bei dir keine Telegramme verloren, oder weißt du nicht, welcher Anteil?

          Bei mir bleibt derzeit etwa jedes zweite Telegramm ohne Reaktion. Also durchaus leicht festzustellen ;-)

          Ich schätze jedoch, dass dies nicht normal ist. Weiß nur noch nicht, wo ich suchen soll. Bin in der Boardverwaltung der Arduino IDE auf das esp8266-Paket Version 2.3.0 zurück gegangen, da dies bei Github empfohlen wurde, jedoch ohne eine Auswirkung. Vielleicht sollte ich es einmal mit einem eigenen Access-Point versuchen, wie du ihn betreibst. Vom Sonoff zu KNX scheint es übrigens stabil zu funktionieren.

          Gruß, Stephan

          Kommentar


            Zitat von OleDeluxe Beitrag anzeigen
            Hier scheint sich etwas in Richtung Anbindung an Tasmota zu tun:
            https://github.com/ascillato/esp-knx-ip
            Da bin ich nicht ganz schuldlos dran. Ich hatte in GitHub bei Tasmota einen Issue geöffnet, um die KNX-Kommunikation als Option mit implementieren zu lassen.
            Dort gab es kein wirkliches Interesse. Aber "ascillato" (ist übrigends aus Argentinien) wollte helfen. Nachdem er aber KNX nicht kennt, glaube ich eher nicht an große Fortschritte.

            Auch bei ESPEasy habe ich einen Issue augemacht. Henfry und ich konnten aber auch dort nicht überzeugen. KNX ist dort unbekannt.
            Tja.

            Kommentar


              Zitat von Harry49 Beitrag anzeigen
              ...
              was heißt "...keine Feststellung machen."? Gehen bei dir keine Telegramme verloren, oder weißt du nicht, welcher Anteil?
              ...
              Es gehen bei mir scheinbar keine Telegramme verloren, ganz im Gegenteil, ich habe mehr Telegramme als nötig. Ich beobachte das hin und wieder über den Bus-Monitor in Edomi.

              Hier mal ein Beispiel:
              Log_Edomi.JPG

              um 17:49:43 löst der BWM aus, dieser ist über ein Koppelrelais am ESP (phy. Adresse 0.0.50) angeschlossen. Auf den Bus wird der Status des BWM 6/4/0 korrekt gesendet. Die Auswertung findet über eine Logik in Edomi statt und sendet dann auf die 1/4/0 Schalt-GA des Strahlers (dieser hängt am gleichen ESP wieder der BWM) eine 1.
              Der ESP antwortet dann nach Erhalt des Telegramms und Einschalten des Strahlers auf die 1/4/1 Status-GA zum Strahler korrekt mit einer 1 (hierüber wird der Status in der Visu auch dargestellt).
              Kurz drauf sendet Edomi aber erneut auf die Schalt-GA und der ESP antwortet diesmal sogar gleich 3 mal. Die Stati sind dabei alle richtig.

              Der BWM fällt dann um 17:49:59 wieder ab und sendet den Status des BWM 6/4/0 als 0 auf den Bus, dies wird aber nirgends ausgewertet.
              Edomi schaltet nach Ablauf der Zeit um 17:50:43 die Schalt-GA 1/4/0 wieder auf 0 und der ESP antwortet wieder auf die 1/4/1 korrekt. Das passiert auch teilweise mehrmals wie beim Einschalten.

              Mein KNX-Netz ist ja keine konventionelle Installation, ich habe da lediglich EDOMI, eine Homebridge und die ESPs am KNXD laufen. Ich vermute aktuell aber dass es an der Konfiguration des KNXD liegt. Muss dem ganzen mal am Wochenende in Ruhe auf den Grund gehen. Wollte auch mal ein paar Szenarien Testen, in denen dann ohne Edomi geschaltet wird über Homekit an der Homebridge, ob es da dann auch auftritt.

              @Sisamiwe: Ach dann ist sein Antrieb eher als Hilfe für dich gedacht, als aus eigener Sache. Schade, ich glaube damit wird man es nicht auf Dauer schaffen das ganze vollumfänglich zu implementieren.

              Gruß, Sven
              Angehängte Dateien
              Zuletzt geändert von OleDeluxe; 20.02.2018, 14:45.

              Kommentar


                Zitat von OleDeluxe Beitrag anzeigen

                @Sisamiwe: Ach dann ist sein Antrieb eher als Hilfe für dich gedacht, als aus eigener Sache. Schade, ich glaube damit wird man es nicht auf Dauer schaffen das ganze vollumfänglich zu implementieren.

                Gruß, Sven
                Das sehe ich auch so. In Summe ist das Intresse von KNX fähigen "IoTs" sehr gering.

                Kommentar


                  Ich bin auch am grübeln. Klar kann man es für den ESP basteln. Aber ist man nicht als Nutzer besser / schneller dran bestehende Lösungen z.B. mit MQTT die durch Communities gestützt sind zu nutzen?

                  Im Endeffekt brauch fast jeder, der etwas auf den Preis achten muss Gateways um das ganze Haus zu verbinden. Und da bieten sich doch Openhab oder ioBroker an.

                  In meinem Fall habe ich eh schon OpenHab laufen für das Nuki-Schloss, Xiaomi Kontakte und Sensoren, Hue Akzentbeleuchtungen und meine Heliotherm Wärmepumpe (ModBus). Da kann ich auch noch die ESPs per MQTT einbinden.

                  Für alles genannte schickt und empfängt OpenHab KNX Gruppenadressen und es läuft stabil. (Bei mir ist es insbesondere der Zeitfaktor, geil ist das schon wenn der ESP direkt über GAs kommuniziert )

                  An einigen (unkritischen) Stellen ist KNX einfach veraltet und/oder überteuert (dank innovativer Unternehmen wie MDT wird es aber subjektiv besser)
                  Das S in IoT steht für Security

                  Kommentar


                    Zitat von mawa Beitrag anzeigen
                    ...
                    An einigen (unkritischen) Stellen ist KNX einfach veraltet und/oder überteuert (dank innovativer Unternehmen wie MDT wird es aber subjektiv besser)
                    An welchen Stellen fiel dir das veraltete KNX so auf, dass du lieber MQTT nutztest?

                    Ich bin froh über jedes Gerät, welches nicht über ein Gateway angesteuert wird und es direkt mit dem altbackenen KNX kommunizieren kann.

                    Ein ESP mit KNX-Sketch ist grundsätzlich nur für die interessant, die sowieso einen KNX-Bus bei sich beherbergen. Der Nutzerkreis, der sowohl KNX besitzt und dann auch noch den Basteldrang hat, ist klein. Dies hat aber nix mit dem angeblichen veraltetem KNX zu tun...

                    Kommentar


                      Ich nutze als Basis smarthomeNG, von daher könnte ich auch MQTT nutzen. Allerdings hat MQTT zumindest für mich einige Nachteile. Zum einen wäre/ist es ein weiteres Protokoll und man braucht wieder eine eigene Infrastruktur mit Broker etc. Zum anderen ist es (zumindest bei der mir bekannten Implementierung von MQTT) so, dass subscribe und publish verschiedene topics sind und so nicht auf ein Item konzentriert werden können.

                      Kommentar


                        Janncsi; Ok hier habe ich mich falsch / missverständlich ausgedrückt. Ich bin hier im Thread hauptsächlich von "Bastlern" ausgegangen.
                        Sagen wir es mal so. Zur Hauptzielgruppe von KNX gehören bekannterweise keine EFH Besitzer bzw. Bastelfreudige. KNX hat einfach keine Verbreitung im Consumer Bereich.
                        Dir ist aber schon bewusst, dass bei dieser Lösung hier jeder ESP auch ein Gateway ist bzw. mit dem IP <->TP Gateway kommuniziert?


                        Ich habe KNX um die Grundfunktionen eines Hauses vernünftig und stabil steuern zu können.

                        Ich versuche jegliche zusätzlich sinnvolle Information auf den Bus zu bringen. Dies mache ich über OpenHab als "MultiGateway", da mir in der Hausplanung die o.g. Alternativlösungen direkt über KNX nicht erschwinglich bzw. overkill für ein EFH waren.

                        Gerade im Bereich RGBW gibt es für meinen Geschmack keine vernünftigen Steuerungen für KNX, außer VISUs, welche ich aber viel günstiger und ansprechender selber bauen kann (OpenHab, Edomi, etc...)
                        Alles was außerhalb der industriellen Basics liegt kostet überproportional oder existiert gar nicht erst.
                        weitere Beispiele: Sprachsteuerung, Multimedia Aktionen, etc.

                        Achtung subjektiv, nur Materialkosten der KNX Aktoren & Sensoren, EFH 160m²:

                        Basics:
                        Die KNX Basics wie SV, IP-GW, Logik, Licht, Heizung ERR, Rollos und Präsenzmelder & Wetterstation inkl. vernünftiger Steuerung über Taster sind per KNX angebunden. Kosten ca. 7000€ (fast alles MDT, gekauft bei Voltus)

                        Addons:
                        "Natives" KNX für el. Türschloss, Steuerung Wärmepumpe, Kontakte, Steuerung Treppenbeleuchtung, RGBW Akzentlichter, Luftfeuchtigkeit, Visu,Sprachsteuerung etc. hätten gut nochmal um die 15.000€ Aufpreis gemacht um die Daten direkt auf dem Bus zu haben.

                        Diese "Addons" habe ich zu einem Bruchteil der Kosten (ganz grob 20%) realisiert und per OpenHab auf den Bus gebracht. Die privat eingesetzte Zeit rechne ich bewusst nicht gegen, da dies keine kritischen Themen sind und nicht bei Einzug laufen müssen. Ich seh das sportlich. Ich will ne Weile in meinem Eigenheim wohnen, da muss nicht alles an Tag 0 fertig sein.

                        Momentan kann ich damit ohne Einschränkungen leben. Die Preise, die im KNX Umfeld für einige Gateways aufgerufen werden sind mMn. utopisch.
                        Da noch einen MQTT Gateway zu meinem Openhab Setup hinzuzufügen macht keinen großen Mehraufwand und ändert auch nichts an der Stabilität.

                        Mit Redundanzen und Watchdogs kann man dies auch recht stabil gestalten.

                        @Sisamiwe: Sorry ich bin jetzt von OpenHab ausgegangen, dort kann ich für ein Item In & Outbound Connections flexibel definieren. Aber auf dem KNX Bus hat man doch i.d.R. eh eine Sende- & eine Statusadresse
                        Das S in IoT steht für Security

                        Kommentar


                          Wäre ein Wassermelder nicht etwas Interessantes, das dieser an den "unmöglichsten" Stellen eingesetzt werden muss und durch WLAN hier eine gewisse "galvanische" Trennung erreicht wird ?

                          http://esp8266-server.de/Wassermelder.html

                          Wassermelder.png
                          Danke und LG, Dariusz
                          GIRA | ENERTEX | MDT | MEANWELL | 24VDC LED | iBEMI | EDOMI | ETS5 | DS214+ | KNX/RS232-GW-ROTEL

                          Kommentar


                            Hallo,

                            ich bräuchte mal Eure Hilfe. Ich möchte einen BME680 an einem ESP8266 betreiben, und zwar mit der Verwendung der Bosch Treiber. Dies ist notwendig, um den richtigen IAQ zu bekommen. Die Berechnungsformel stellt Bosch nicht direkt zur Verfügung, sondern nur in Form von vor-kompilierten Files.

                            Ich habe einen Sketch mit der Verwendung des BME280 (ohne IAQ) und KNX Anbindung und einen mit dem BME680 nur mit serieller Ausgabe.
                            Nun bekomme ich diese beiden leider nicht verheiratet. Dazu reichen meine Kenntnisse einfach nicht aus.
                            Kann jemand von Euch hier helfen?

                            Sketch mit BME280 am ESP8266 mit KNX
                            Code:
                            /*
                             * This is an example showing a simple environment sensor based on a BME280 attached via I2C.
                             * This sketch was tested on a WeMos D1 mini
                             */
                            
                            #include <Adafruit_BME280.h>
                            #include <esp-knx-ip.h>
                            
                            // WiFi config here
                            const char* ssid = "WLAN-Access";
                            const char* pass = "3017489092966120";
                            
                            #define UPDATE_INTERVAL 10000 // This is the default send interval
                            
                            unsigned long next_change = 0;
                            
                            config_id_t temp_ga, hum_ga, pres_ga;
                            config_id_t hostname_id;
                            config_id_t temp_rate_id;
                            config_id_t enable_sending_id;
                            
                            Adafruit_BME280 bme;
                            
                            void setup() {
                              pinMode(BUILTIN_LED, OUTPUT);
                              Serial.begin(115200);
                            
                              // Register the group addresses where to send information to and the other config
                              hostname_id = knx.config_register_string("Hostname", 20, String("env"));
                              enable_sending_id = knx.config_register_bool("Enable periodic sending", true);
                              temp_rate_id = knx.config_register_int("Send rate (ms)", UPDATE_INTERVAL, show_periodic_options);
                              temp_ga = knx.config_register_ga("Temperature", show_periodic_options);
                              hum_ga = knx.config_register_ga("Humidity", show_periodic_options);
                              pres_ga = knx.config_register_ga("Pressure", show_periodic_options);
                            
                              knx.register_callback("Read Temperature", temp_cb);
                              knx.register_callback("Read Humidity", hum_cb);
                              knx.register_callback("Read Pressure", pres_cb);
                            
                              // Load previous values from EEPROM
                              knx.load();
                            
                              // Init sensor
                              if (!bme.begin(0x77)) {  
                                Serial.println("Could not find a valid BME280 sensor, check wiring!");
                              }
                            
                              // Init WiFi
                              WiFi.hostname(knx.config_get_string(hostname_id));
                              WiFi.begin(ssid, pass);
                            
                              Serial.println("");
                              Serial.print("[Connecting]");
                              Serial.print(ssid);
                            
                              digitalWrite(BUILTIN_LED, LOW);
                              while (WiFi.status() != WL_CONNECTED) {
                                digitalWrite(BUILTIN_LED, HIGH);
                                delay(500);
                                Serial.print(".");
                                digitalWrite(BUILTIN_LED, LOW);
                              }
                              digitalWrite(BUILTIN_LED, HIGH);
                            
                              // Start knx
                              knx.start();
                            
                              Serial.println();
                              Serial.println("Connected to wifi");
                              Serial.println(WiFi.localIP());
                            }
                            
                            void loop() {
                              // Process knx events, e.g. webserver
                              knx.loop();
                            
                              unsigned long now = millis();
                            
                              if (knx.config_get_bool(enable_sending_id) && next_change < now)
                              {
                                next_change = now + knx.config_get_int(temp_rate_id);
                                Serial.print("T: ");
                                float temp = bme.readTemperature();
                                float hum = bme.readHumidity();
                                float pres = bme.readPressure()/100.0f;
                                Serial.print(temp);
                                Serial.print("°C H: ");
                                Serial.print(hum);
                                Serial.print("% P: ");
                                Serial.print(pres);
                                Serial.println("hPa");
                                knx.write2ByteFloat(knx.config_get_ga(temp_ga), temp);
                                knx.write2ByteFloat(knx.config_get_ga(hum_ga), hum);
                                knx.write2ByteFloat(knx.config_get_ga(pres_ga), pres);
                              }
                            
                              delay(50);
                            }
                            
                            // This is a enable condition function that is checked by the webui to figure out if some config options should be hidden
                            bool show_periodic_options()
                            {
                              return knx.config_get_bool(enable_sending_id);
                            }
                            
                            void temp_cb(message_t const &msg, void *arg)
                            {
                              switch (msg.ct)
                              {
                                case KNX_CT_READ:
                                {
                                  knx.answer2ByteFloat(msg.received_on, bme.readTemperature());
                                  break;
                                }
                              }
                            }
                            
                            void hum_cb(message_t const &msg, void *arg)
                            {
                              switch (msg.ct)
                              {
                                case KNX_CT_READ:
                                {
                                  knx.answer2ByteFloat(msg.received_on, bme.readHumidity());
                                  break;
                                }
                              }
                            }
                            
                            void pres_cb(message_t const &msg, void *arg)
                            {
                              switch (msg.ct)
                              {
                                case KNX_CT_READ:
                                {
                                  knx.answer2ByteFloat(msg.received_on, bme.readPressure()/100.0f);
                                  break;
                                }
                              }
                            }
                            Hier der Sketch mit derm BME680 am ESP8266 aber nur serieller Kommunikation:
                            Code:
                            /*
                             * Copyright (C) 2017 Robert Bosch. All Rights Reserved. 
                             *
                             * Disclaimer
                             *
                             * Common:
                             * Bosch Sensortec products are developed for the consumer goods industry. They may only be used
                             * within the parameters of the respective valid product data sheet.  Bosch Sensortec products are
                             * provided with the express understanding that there is no warranty of fitness for a particular purpose.
                             * They are not fit for use in life-sustaining, safety or security sensitive systems or any system or device
                             * that may lead to bodily harm or property damage if the system or device malfunctions. In addition,
                             * Bosch Sensortec products are not fit for use in products which interact with motor vehicle systems.
                             * The resale and/or use of products are at the purchasers own risk and his own responsibility. The
                             * examination of fitness for the intended use is the sole responsibility of the Purchaser.
                             *
                             * The purchaser shall indemnify Bosch Sensortec from all third party claims, including any claims for
                             * incidental, or consequential damages, arising from any product use not covered by the parameters of
                             * the respective valid product data sheet or not approved by Bosch Sensortec and reimburse Bosch
                             * Sensortec for all costs in connection with such claims.
                             *
                             * The purchaser must monitor the market for the purchased products, particularly with regard to
                             * product safety and inform Bosch Sensortec without delay of all security relevant incidents.
                             *
                             * Engineering Samples are marked with an asterisk (*) or (e). Samples may vary from the valid
                             * technical specifications of the product series. They are therefore not intended or fit for resale to third
                             * parties or for use in end products. Their sole purpose is internal client testing. The testing of an
                             * engineering sample may in no way replace the testing of a product series. Bosch Sensortec
                             * assumes no liability for the use of engineering samples. By accepting the engineering samples, the
                             * Purchaser agrees to indemnify Bosch Sensortec from all claims arising from the use of engineering
                             * samples.
                             *
                             * Special:
                             * This software module (hereinafter called "Software") and any information on application-sheets
                             * (hereinafter called "Information") is provided free of charge for the sole purpose to support your
                             * application work. The Software and Information is subject to the following terms and conditions:
                             *
                             * The Software is specifically designed for the exclusive use for Bosch Sensortec products by
                             * personnel who have special experience and training. Do not use this Software if you do not have the
                             * proper experience or training.
                             *
                             * This Software package is provided `` as is `` and without any expressed or implied warranties,
                             * including without limitation, the implied warranties of merchantability and fitness for a particular
                             * purpose.
                             *
                             * Bosch Sensortec and their representatives and agents deny any liability for the functional impairment
                             * of this Software in terms of fitness, performance and safety. Bosch Sensortec and their
                             * representatives and agents shall not be liable for any direct or indirect damages or injury, except as
                             * otherwise stipulated in mandatory applicable law.
                             *
                             * The Information provided is believed to be accurate and reliable. Bosch Sensortec assumes no
                             * responsibility for the consequences of use of such Information nor for any infringement of patents or
                             * other rights of third parties which may result from its use. No license is granted by implication or
                             * otherwise under any patent or patent rights of Bosch. Specifications mentioned in the Information are
                             * subject to change without notice.
                             *
                             * It is not allowed to deliver the source code of the Software to any third party without permission of
                             * Bosch Sensortec.
                             *
                             */
                            
                            /*!
                             * @file _example.ino
                             *
                             * @brief
                             * Example for using of BSEC library in a fixed configuration with the BME680 sensor.
                             * This works by running an endless loop in the _loop() function.
                             */
                            
                            /*!
                             * @addtogroup bsec_examples BSEC Examples
                             * @brief BSEC usage examples
                             * @{*/
                            
                            /**********************************************************************************************************************/
                            /* header files */
                            /**********************************************************************************************************************/
                            
                            #include "bsec_integration.h"
                            #include <Wire.h>
                            
                            /**********************************************************************************************************************/
                            /* functions */
                            /**********************************************************************************************************************/
                            
                            /*!
                             * @brief           Write operation in either Wire or SPI
                             *
                             * param[in]        dev_addr        Wire or SPI device address
                             * param[in]        reg_addr        register address
                             * param[in]        reg_data_ptr    pointer to the data to be written
                             * param[in]        data_len        number of bytes to be written
                             *
                             * @return          result of the bus communication function
                             */
                            int8_t bus_write(uint8_t dev_addr, uint8_t reg_addr, uint8_t *reg_data_ptr, uint16_t data_len)
                            {
                                Wire.beginTransmission(dev_addr);
                                Wire.write(reg_addr);    /* Set register address to start writing to */
                            
                                /* Write the data */
                                for (int index = 0; index < data_len; index++) {
                                    Wire.write(reg_data_ptr[index]);
                                }
                            
                                return (int8_t)Wire.endTransmission();
                            }
                            
                            /*!
                             * @brief           Read operation in either Wire or SPI
                             *
                             * param[in]        dev_addr        Wire or SPI device address
                             * param[in]        reg_addr        register address
                             * param[out]       reg_data_ptr    pointer to the memory to be used to store the read data
                             * param[in]        data_len        number of bytes to be read
                             *
                             * @return          result of the bus communication function
                             */
                            int8_t bus_read(uint8_t dev_addr, uint8_t reg_addr, uint8_t *reg_data_ptr, uint16_t data_len)
                            {
                                int8_t comResult = 0;
                                Wire.beginTransmission(dev_addr);
                                Wire.write(reg_addr);                    /* Set register address to start reading from */
                                comResult = Wire.endTransmission();
                            
                                delayMicroseconds(150);                 /* Precautionary response delay */
                                Wire.requestFrom(dev_addr, (uint8_t)data_len);    /* Request data */
                            
                                int index = 0;
                                while (Wire.available())  /* The slave device may send less than requested (burst read) */
                                {
                                    reg_data_ptr[index] = Wire.read();
                                    index++;
                                }
                            
                                return comResult;
                            }
                            
                            /*!
                             * @brief           System specific implementation of sleep function
                             *
                             * @param[in]       t_ms    time in milliseconds
                             *
                             * @return          none
                             */
                            void sleep(uint32_t t_ms)
                            {
                                delay(t_ms);
                            }
                            
                            /*!
                             * @brief           Capture the system time in microseconds
                             *
                             * @return          system_current_time    current system timestamp in microseconds
                             */
                            int64_t get_timestamp_us()
                            {
                                return (int64_t) millis() * 1000;
                            }
                            
                            /*!
                             * @brief           Handling of the ready outputs
                             *
                             * @param[in]       timestamp       time in nanoseconds
                             * @param[in]       iaq             IAQ signal
                             * @param[in]       iaq_accuracy    accuracy of IAQ signal
                             * @param[in]       temperature     temperature signal
                             * @param[in]       humidity        humidity signal
                             * @param[in]       pressure        pressure signal
                             * @param[in]       raw_temperature raw temperature signal
                             * @param[in]       raw_humidity    raw humidity signal
                             * @param[in]       gas             raw gas sensor signal
                             * @param[in]       bsec_status     value returned by the bsec_do_steps() call
                             *
                             * @return          none
                             */
                            void output_ready(int64_t timestamp, float iaq, uint8_t iaq_accuracy, float temperature, float humidity,
                                 float pressure, float raw_temperature, float raw_humidity, float gas, bsec_library_return_t bsec_status)
                            {
                                Serial.print("[");
                                Serial.print(timestamp/1e6);
                                Serial.print("] T: ");
                                Serial.print(temperature);
                                Serial.print("| rH: ");
                                Serial.print(humidity);
                                Serial.print("| p: ");
                                Serial.print(pressure);
                                Serial.print("| Gas: ");
                                Serial.print(gas);
                                Serial.print("| IAQ: ");
                                Serial.print(iaq);
                                Serial.print(" (");
                                Serial.print(iaq_accuracy);
                                Serial.println(")");
                            }
                            
                            /*!
                             * @brief           Load previous library state from non-volatile memory
                             *
                             * @param[in,out]   state_buffer    buffer to hold the loaded state string
                             * @param[in]       n_buffer        size of the allocated state buffer
                             *
                             * @return          number of bytes copied to state_buffer
                             */
                            uint32_t state_load(uint8_t *state_buffer, uint32_t n_buffer)
                            {
                                // ...
                                // Load a previous library state from non-volatile memory, if available.
                                //
                                // Return zero if loading was unsuccessful or no state was available, 
                                // otherwise return length of loaded state string.
                                // ...
                                return 0;
                            }
                            
                            /*!
                             * @brief           Save library state to non-volatile memory
                             *
                             * @param[in]       state_buffer    buffer holding the state to be stored
                             * @param[in]       length          length of the state string to be stored
                             *
                             * @return          none
                             */
                            void state_save(const uint8_t *state_buffer, uint32_t length)
                            {
                                // ...
                                // Save the string some form of non-volatile memory, if possible.
                                // ...
                            }
                            
                            /*!
                             * @brief           Load library config from non-volatile memory
                             *
                             * @param[in,out]   config_buffer    buffer to hold the loaded state string
                             * @param[in]       n_buffer        size of the allocated state buffer
                             *
                             * @return          number of bytes copied to config_buffer
                             */
                            uint32_t config_load(uint8_t *config_buffer, uint32_t n_buffer)
                            {
                                // ...
                                // Load a library config from non-volatile memory, if available.
                                //
                                // Return zero if loading was unsuccessful or no config was available, 
                                // otherwise return length of loaded config string.
                                // ...
                                return 0;
                            }
                            
                            /*!
                             * @brief       Main function which configures BSEC library and then reads and processes the data from sensor based
                             *              on timer ticks
                             *
                             * @return      result of the processing
                             */
                            void setup()
                            {
                                return_values_init ret;
                            
                                /* Init I2C and serial communication */
                                Wire.begin();
                                Serial.begin(115200);
                            
                                /* Call to the function which initializes the BSEC library 
                                 * Switch on low-power mode and provide no temperature offset */
                                ret = _init(BSEC_SAMPLE_RATE_LP, 5.0f, bus_write, bus_read, sleep, state_load, config_load);
                                if (ret.bme680_status)
                                {
                                    /* Could not intialize BME680 */
                                    Serial.println("Error while initializing BME680");
                                    return;
                                }
                                else if (ret.bsec_status)
                                {
                                    /* Could not intialize BSEC library */
                                    Serial.println("Error while initializing BSEC library");
                                    return;
                                }
                            
                                /* Call to endless loop function which reads and processes data based on sensor settings */
                                /* State is saved every 10.000 samples, which means every 10.000 * 3 secs = 500 minutes  */
                                _loop(sleep, get_timestamp_us, output_ready, state_save, 10000);
                            }
                            
                            void loop()
                            {
                            }
                            
                            /*! @}*/
                            Eine Beschreibung des Bosch Treiber im Anhang.

                            Wäre Super, wenn hier jemand helfen könnte!.
                            DANKE
                            Angehängte Dateien

                            Kommentar


                              Zitat von Sisamiwe Beitrag anzeigen
                              Wäre Super, wenn hier jemand helfen könnte!.
                              Ich würde da nicht selber rummachen. Für sowas gibt es Libraries, z.B.:Generell: Nehmt doch einfach platform.io fürs Development. Schöner Atom Editor, umfangreiche libraries und vor allem einfach einbindbar. Darüber hab ich auch die Libraries gefunden: https://platformio.org/lib/search?qu...0BME680&page=1

                              Wenn man dann die Projekte in ein github repository packt, kann man diese auch via Travis CI (kostenloser online service) gleich einmal durchtesten bzw. auch nur kompilieren lassen. Das sieht für meinen Grillsensor dann z.B. so aus:

                              https://github.com/SirUli/Grill-Temp...SP8266-MAX6675

                              Diesen kann ich nun auch recht einfach mit der KNX Library erweitern, da diese via platform.io auch schon verfügbar ist. So kommt nun mein Grill dann auch auf die Visu
                              Zuletzt geändert von SirUli; 22.02.2018, 11:09. Grund: Travis vergessen zu erwähnen.

                              Kommentar


                                SirUli

                                Hallo,

                                Das ist zwar im Prinzip richtig, aber: Der BME680 misst bzw. berechnet auch die IAQ (Indoor Air Quality) die Berechnung dazu ist leider closed source, deshalb stellt Bosch die nur als vor-kompilierte Library zur Verfügung. D.h. damit man den IAQ nutzen kann, muss man den Bosch Weg gehen. Die anderen Libraries (wie auch die genannten) lesen nur die Rohdaten, also Temperatur, Feuchtigkeit und den Widerstand des Heizelementes für die VOC Ermittlung aus. Die Berechnung des IAQ aus diesen Werten ist Bosch IP und nicht in diesen open source libs beinhaltet. Daher meine Frage nach der Hilfe.

                                ​​​​​​​

                                Kommentar

                                Lädt...
                                X