Navigation

    Logo
    • Register
    • Login
    • Search
    • Recent
    • Tags
    • Unread
    • Categories
    • Unreplied
    • Popular
    • GitHub
    • Docu
    • Hilfe
    1. Home
    2. Deutsch
    3. Hardware
    4. Homeduino an Iobroker anbinden

    NEWS

    • ioBroker@Smart Living Forum Solingen, 14.06. - Agenda added

    • ioBroker goes Matter ... Matter Adapter in Stable

    • Monatsrückblick - April 2025

    Homeduino an Iobroker anbinden

    This topic has been deleted. Only users with topic management privileges can see it.
    • T
      thobastian last edited by

      Auch bei mir funktioniert das toll.

      Danke für die gute Erklärung und die Skripte !!

      Gruß

      Thomas

      1 Reply Last reply Reply Quote 0
      • K
        klassisch Most Active last edited by

        Vielen Dank für die Ausführungen!

        Wenn ich das richtig verstanden habe, wird hier der "ioBroker simple web Adapter" mit seiner eingebauten simpleAPI über Port 8082 verwendet.

        Ich verwende derzeit die eigenständige simpleAPI (Port8087) https://github.com/ioBroker/ioBroker.simple-api . Dort gibt es mittlerweile setBulk, womit man gleich mehrere Werte auf einen Streich setzen kann. Find ich sehr praktisch.

        Befehle lt. help:

          "getPlainValue": "http://ipaddress:8087/getPlainValue/stateID",
          "get": "http://ipaddress:8087/get/stateID/?prettyPrint",
          "getBulk": "http://ipaddress:8087/getBulk/stateID1,stateID2/?prettyPrint",
          "set": "http://ipaddress:8087/set/stateID?value=1&prettyPrint",
          "toggle": "http://ipaddress:8087/toggle/stateID&prettyPrint",
          "setBulk": "http://ipaddress:8087/setBulk?stateID1=0.7&stateID2=0&prettyPrint",
          "objects": "http://ipaddress:8087/objects?pattern=system.adapter.admin.0*&prettyPrint",
          "objects": "http://ipaddress:8087/objects?pattern=system.adapter.admin.0*&type=adapter&prettyPrint",
          "states": "http://ipaddress:8087/states?pattern=system.adapter.admin.0*&prettyPrint"
        
        
        1 Reply Last reply Reply Quote 0
        • P
          PrinzEisenherz1 last edited by

          Hi klassisch!

          Ja das mit setBulk ist/wäre ne feine Sache. Man muss aber aufpassen das die Gesamtlänge der URL einen bestimmten Wert nicht überschreitet da in sonst das Ethernetshield nicht verarbeitet.

          Ich weiß bloß jetzt aus m Kopf nicht wie die Limitierung war.

          Da bin ich drauf gestoßen als ich meine Wetterstation auf setBulk umstellen wollte. Kleiner Befehle gingen und bei größeren kam nichts an.

          Gruß

          Johnny

          1 Reply Last reply Reply Quote 0
          • K
            klassisch Most Active last edited by

            Hi, Johnny,

            vielen Dank für den Hinweis. Habe mal bei Apollon77 nach den Limitationen gefragt. Denke, dann wissen wir mehr.

            1 Reply Last reply Reply Quote 0
            • P
              PrinzEisenherz1 last edited by

              Hi klassisch, die Limitierung der Gesamtlänge der URL ist n Problem vom ethernet shield. Hat, glaub ich mal gelesen zu haben, nen Zusammenhang mit der SPI Schnittstelle wo das ethernet shield andockt.

              1 Reply Last reply Reply Quote 0
              • K
                klassisch Most Active last edited by

                Gut, das macht Sinn. Bei meinen ESP8266 bin ich bei der Web-Ausgabe an den Browser auch an eine soche Grenze gestoßen. Wenn die Antwort zu lang wird, fehlt plötzlich ein Teil, also ein Großteil.

                Apollon hat ja auch geantwortet, daß wissentlich und willentlich keine Limitation in den Adapter eingeabut ist. Es wird aber irgendwo in der Kette eine geben.

                1 Reply Last reply Reply Quote 0
                • P
                  PrinzEisenherz1 last edited by

                  Also über spi ist der buffer wohl 64 Byte groß.

                  Für mich stellt sich die Frage wie man am besten mit client.print die Übertragung mit setBulk kombiniert.

                  Derzeit sende ich über set jede Variable in einer eigenen URL. Mit setBulk wäre das natürlich ne leitungslösung da ich dann nur immer einmal übertragen musste um alle Variablen zu aktualisieren.

                  Gruß Johnny

                  1 Reply Last reply Reply Quote 0
                  • S
                    schneidy76 last edited by

                    als blutiger homeduino Anfänger habe ich da ne Frage:

                     createState("javascript.0.Technikraum.Homeduino.homeduino_001_IP", 0, {read: true, write: true, name: 'Homeduino IP', desc: 'Homeduino IP'});
                    

                    muss da die IP vom Homeduino rein, oder holt der sie sich selber? :?:

                    1 Reply Last reply Reply Quote 0
                    • P
                      PrinzEisenherz1 last edited by

                      Hi

                      In dem state hinterlegt der Homeduino später seine IP Adresse die er vom Router bekommen hat.

                      Dann siehst du welche IP Adresse dein Homeduino hat

                      Gruß Johnny

                      1 Reply Last reply Reply Quote 0
                      • S
                        schneidy76 last edited by

                        heul, ich kriege es nicht hin 😞
                        2631_2017-10-04_16_51_15-homeduino-sht2x_iobroker___arduino_1.8.4.png
                        wollte hier D2 und 3 konfigurieren

                        function CreateAllStates(){
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_IP", 0, {read: true, write: true, name: 'Homeduino IP', desc: 'Homeduino IP'});
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_D2", false, {read: true, write: true, type: 'boolean', name: 'Wintergarten Fenster links kipp', desc: 'true = geschlossen, false=offen'});
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_D3", true, {read: true, write: true, type: 'boolean', name: 'Wintergarten Fenster links offen', desc: 'true = geschlossen, false=offen'});
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_D4", true, {read: true, write: true, type: 'boolean', name: 'Bewegungsmelder Gartennlage', desc: 'true = inaktiv, false=Bewegung'});
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_D4", false, {read: true, write: true, type: 'boolean', name: 'LED-Fluter Garten', desc: 'false=aus, true=an'});
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_D5", false, {read: true, write: true, type: 'boolean', name: 'Alarm-LED grün rot', desc: 'Alarm-LED grün rot'});
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_D6", true, {read: true, write: true, type: 'boolean', name: 'RFID-Haustür', desc: 'RFID-Haustür'});
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_D7", true, {read: true, write: true, type: 'boolean', name: 'Briefkastensperre', desc: 'Briefkastensperre'});
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_D8", false, {read: true, write: true, type: 'boolean', name: 'Briefeinwurf', desc: 'Briefeinwurf'});
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_D9", true, {read: true, write: true, type: 'boolean', name: 'Garagentor', desc: 'Garagentor'});
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_D10", 0, {read: true, write: true, type: 'number', name: 'Wintergarten DHT22 Temperatur', desc: 'Wintergarten DHT22 Temperatur', unit:'°C'});
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_D11", 0, {read: true, write: true, type: 'number', name: 'Wintergarten DHT22 Luftfeuchte', desc: 'Wintergarten DHT22 Luftfeuchte', unit:'%'});
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_D12", 0, {read: true, write: true, type: 'number', name: 'Pufferspeicher Kerntemperatur', desc: 'Pufferspeicher Kerntemperatur', unit:'°C'});
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_D13", 0, {read: true, write: true, type: 'number', name: 'Austritt Warmwasser', desc: 'Austritt Warmwasser', unit:'°C'});
                        }
                        CreateAllStates();
                        

                        und hier das Script,

                        aber ich bekomme weder was raus noch rein.

                        Nur die states die im script stehen habe ich auch so als Object,

                        die gefundene IP passt
                        2631_2017-10-04_16_55_30-microsoft_edge.png

                        update: das mit den Eingängen habe ich hin bekommen, was noch fehlt die Ausgänge…

                        geht das mit dem io20 überhaupt?
                        2631_2017-10-04_21_55_15-homeduino-sht2x_iobroker___arduino_1.8.4.png

                        function CreateAllStates(){
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_IP", 0, {read: true, write: true, name: 'Homeduino IP', desc: 'Homeduino IP'});
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_D2", 0, {read: true, write: true, type: 'state', name: 'Wintergarten Fenster links kipp', desc: 'true = geschlossen, false=offen'});
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_D3", true, {read: true, write: true, type: 'boolean', name: 'Wintergarten Fenster links offen', desc: 'true = geschlossen, false=offen'});
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_D4", true, {read: true, write: true, type: 'boolean', name: 'Bewegungsmelder Gartennlage', desc: 'true = inaktiv, false=Bewegung'});
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_D4", true, {read: true, write: true, type: 'boolean', name: 'LED-Fluter Garten', desc: 'false=aus, true=an'});
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_D5", true, {read: true, write: true, type: 'boolean', name: 'Alarm-LED grün rot', desc: 'Alarm-LED grün rot'});
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_D6", true, {read: true, write: true, type: 'boolean', name: 'RFID-Haustür', desc: 'RFID-Haustür'});
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_D7", true, {read: true, write: true, type: 'boolean', name: 'Briefkastensperre', desc: 'Briefkastensperre'});
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_D8", true, {read: true, write: true, type: 'boolean', name: 'Briefeinwurf', desc: 'Briefeinwurf'});
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_D9", true, {read: true, write: true, type: 'boolean', name: 'Garagentor', desc: 'Garagentor'});
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_D10", true, {read: true, write: true, type: 'boolean', name: 'Wintergarten DHT22 Temperatur', desc: 'Wintergarten DHT22 Temperatur'});
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_D11", true, {read: true, write: true, type: 'boolean', name: 'Wintergarten DHT22 Luftfeuchte', desc: 'Wintergarten DHT22 Luftfeuchte'});
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_D12", true, {read: true, write: true, type: 'boolean', name: 'Pufferspeicher Kerntemperatur', desc: 'Pufferspeicher Kerntemperatur'});
                           createState("javascript.0.Technikraum.Homeduino.homeduino_001_D13", true, {read: true, write: true, type: 'boolean', name: 'Austritt Warmwasser', desc: 'Austritt Warmwasser'});
                        }
                        CreateAllStates();
                        

                        2631_2017-10-04_21_58_25-microsoft_edge.png

                        1 Reply Last reply Reply Quote 0
                        • P
                          PrinzEisenherz1 last edited by

                          Hi schneidy76 (lach… heißt wohl Schneider und bist 76 geboren - wie ich ...lach)

                          also zum schalten von Ausgängen musst über script machen. Einfach den state ändern geht leider nicht.

                          hier mal n Beispiel zum schalten eines Ausgangs.

                          Nehmen wir mal Deinen konfigurierten Port D11. Den hast de ja als digital output konfiguriert.

                          Wenn Du jetzt im Browser folgendes eingibst:

                          http://<ip-adresse deines/homeduino="">/?D11:1</ip-adresse>
                          

                          Dann schaltet der Port D11 am homeduino ein und wenn Du:

                          http://<ip-adresse deines/homeduino="">/?D11:0</ip-adresse>
                          

                          eingibst, dann schaltet er wieder aus.

                          In nem Script löst Du das am besten mit nem wget aus einem exec.

                          Hier mal n Beispiel für einschalten bzw auf HIGH setzen des Ports D11:

                          exec("wget http://<ip-adresse deines/homeduino="">/?D11:1");</ip-adresse>
                          

                          Ich hoffe es war verständlich genug 😄

                          Gruß

                          Johnny

                          1 Reply Last reply Reply Quote 0
                          • S
                            schneidy76 last edited by

                            ` > Hi schneidy76 (lach… heißt wohl Schneider und bist 76 geboren - wie ich ...lach)

                            also zum schalten von Ausgängen musst über script machen. Einfach den state ändern geht leider nicht. `
                            Kannst auch Torsten sagen - verdammt da wollt ich mal kreativ sein….

                            Aber alles richtig! :lol:

                            Ich probiere das mal mit dem Script.

                            Des geht auch in iobroker denke ich?

                            VG Torsten

                            1 Reply Last reply Reply Quote 0
                            • P
                              PrinzEisenherz1 last edited by

                              Hi Thorsten,

                              Also das Beispiel mit exec ist für n Javascript gedacht.

                              Also im iobroker javascript Adapter.

                              Das kannst du dann zum Beispiel mit dem Taster triggern.

                              Ich steuere damit zum Beispiel meine Gartenbeleuchtung

                              Gruß Johnny

                              1 Reply Last reply Reply Quote 0
                              • S
                                schneidy76 last edited by

                                Danke

                                über den Browser geht es schon mal

                                jetzt muss ich mir nur noch überlegen wie ich die Ausgänge potentialfrei bekomme :?: :?: :?: :?:

                                Wenn aus, dann habe ich 4VDC gegen gnd. Daraus macht mein DuoFern Installationssender ein 1 Signal.

                                Hätte auch einfach sein können

                                1 Reply Last reply Reply Quote 0
                                • P
                                  PrinzEisenherz1 last edited by

                                  Das freut mich das es geklappt hat!

                                  Potenzialfrei hab ich auch verbaut. Ich hab da einfach n passendes Relais - shield verbaut. War die schnellste und einfachste Lösung!

                                  Gruß Johnny

                                  1 Reply Last reply Reply Quote 0
                                  • S
                                    schneidy76 last edited by

                                    @PrinzEisenherz1:

                                    Das freut mich das es geklappt hat!

                                    Potenzialfrei hab ich auch verbaut. Ich hab da einfach n passendes Relais - shield verbaut. War die schnellste und einfachste Lösung!

                                    Gruß Johnny `
                                    Hab da auch noch ne 8er Relais Karte am Start. Berichte weiter

                                    VG Torsten

                                    1 Reply Last reply Reply Quote 0
                                    • P
                                      PrinzEisenherz1 last edited by

                                      Wenn de hilfe brauchst, meld dich einfach!

                                      Bei mir verrichtet der Homeduino seit 2 Jahren gute Dienste und ich würde ihn nicht mehr hergeben wollen!

                                      Nochmal tausend Dank an Eugen.

                                      Damit bin ich richtiger arduino Liebhaber geworden. Hab mir mittlerweile eine eigene Wetterstation auf Basis von arduino gebaut.
                                      1058_imag0314.jpg

                                      Gruß Johnny

                                      1 Reply Last reply Reply Quote 0
                                      • S
                                        schneidy76 last edited by

                                        Da passt irgendwas nicht …

                                        Sende ich zum Beispiel D2:0 - egal ob Browser oder hier:
                                        2631_arduino.png

                                        schalten mehrere IOs mit, also beispielsweise 2 plus 5 und 7?????????

                                        Sketch:

                                        `const String Version = "hduino412_LAN";  /*Stand: 2015.09.07 / Verfasser: Eugen Stall
                                        erprobt fuer Arduino Mega 2560 mit Arduino 1.6.5r2
                                        hier ist immer die aktuelle Version:
                                        http://www.stall.biz/project/homeduino-4-0-das-universelle-mess-und-aktormodul-fuer-die-hausautomation
                                        das folgende homeduino-programm sendet messdaten zur iobroker (homeduino als webclient) ...
                                        und empfängt ausgabedaten für die homeduino-outputs (homeduino als webserver)
                                        _________________            ________________
                                        |port 8181 server|<---------<| client        |
                                        |                |           |               |
                                        | CCU            |           |     Homeduino | 
                                        |                |           |               |
                                        |          client|>--------->|server port 80 | 
                                        |________________|           |_______________|
                                        
                                        /Quellen:Arduino website plus http://arduino.cc/en/Tutorial/WebClient und ...
                                         http://tushev.org/articles/arduino/item/52-how-it-works-ds18b20-and-arduino und ...  */
                                        //#############################################################################################
                                        //#############################################################################################
                                        //Auswahl der verwendeten Shields: 
                                        #define lcd_display //"tft_display" oder "lcd_display"                         < <user-eingabe<< 0/115/120/"lcd_display"/auch/wenn/kein/display/verwendet/wird/#define/w5100/"cc3000"/wifi-modul/oder/"w5100"/ethernet/shield/<<user-eingabe<</byte/iobroker[]="{" 192,/168,/0,/};/ip/von/iobroker/mac-adresse/dieses/homeduinos/,bei/mehreren/mac-.adresse/ändern!!:/mac[]="{" 0xcc,/0xcc/homeduino[]="{" des/homeduino,wenn/dhcp/versagt/char/ap_ssid[]="ssid" ;/ssid/wlan/in/anführungszeichen/ap_password[]="password" passwort/xyz/ist/indiv./bezeichnung/homeduino,/keine/sonderzeichen,/öäüß.../const/string/homeduino_nummer="001" hm_systemvariable="homeduino_" +/+"_";/#############################################################################################/i/o-kennung:/hier/die/funktion/aller/verwendbaren/io´s/mit/einer/kennziffer/festgelegt/dabei/haben/alle/standardfunktionen/plus/spez./sonderfunktionen/sind:/'0'="andere" nutzg;/'1'="dig_in;" '2'="dig_out;" '3'="1wire" '4'="DHTxx;" '5'="U_Schall" iomodus_d[80]="{" 0,0,/2,/d2/:/std-fkt;/<<user/io-shield20<</d3/d4/d5/d6/d7/d8/d9/20,/d10/'20'="W5100" ss-pin;/1,/d11/d12/d13/d14/tx3/'12'="rfid3;" io-shield-plus<</d15/rx3/d16/tx2/d17/rx2/d18/tx1/'6'="ImpCount;" '21'="CC3000" d19/rx1/d20/sda/'8'="I2C;" d21/scl/d22/d23/d24/d25/d26/d27/d28/d29/0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,/miso/icsp-stecker/mosi/sck/ss/d54/a0/'10'="analog;" '11'="NTC;" '31'="tft;" '30'="lcd;" ser/io-shield-20<</d55/a1/d56/a2/d57/a3/d58/a4/d59/a5/d62/a8/d63/a9/d64/a10/d65/a11/d66/a12/d67/a13/d68/a14/d69/a15/werden/sensoren/am/i2c-eingang/aktiviert/iomodus_baro="0;" iomodus_lux="0;" iomodus_sht="0;" kennwerte/fuer/impulszaehler/volatile/unsigned/long/pulsecounter[6]="{" zaehlerstand/-impulseingang/bei/reset/d21-impulseingang/d20-impulseingang/d19-impulseingang/d18-impulseingang/der/teilerfaktor/für/int/pulsedivider[6]="{1," anzeigetexte/lcd/und/tft/display_message[80]="{" "0","0",/anzeige/"beweg/tuer:",/anzeigetext/port/d02/gart:",/d03/"0","0","0","0","0","0",/ports/belegt/durch/lcd-shield/"0",/w5100-shield,/pin/abbiegen!/"11/status/:",/"12/",/"13/"14/"rfid/tuer/"16/gara/"18/s03/"19/gas/m3/s02/"21/i2c/sda:",/s01/scl:",/s00/"offner/gara",/tuer",/"24/"25/"26/"27/"28/ds20b18:",/"29/t_dht22:",/"0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0",/"temp_auss.:",/"temp_innen:",/"57/"58/"59/spg_a5/"62/"63/"64/"65/"66/"67/"68/"abstand/cm:",/folgenden/sind/module/datenpunkten/z.b./i2c-module/"l-druck/mb:",/"l-temp./c/"lux/lx/"uv-index/"74/"75/"76/"77/"78/"79/:"/zugangsberechtigungen/den/rdm6300/rfid-reader/fobs/fob_anzahl="2;" fob[3*fob_anzahl]="{" "2381286","eugen","1",/tueroeffner/"2381287","eugen","1",/unlock_time1="5000;" oeffnungszeit/rfid1/ms/unlock_time2="5000;" rfid2/boolean/oeffner_polarity="1;" normal,/invers/#include/<spi.h="">#include <wire.h>#include <onewire.h>//für Temperatursensoren DS18B20
                                                               //http://www.hacktronics.com/code/OneWire.zip
                                        #include <newping.h>//für Ultraschallsensoren SR04
                                                               //https://arduino-new-ping.googlecode.com/files/NewPing_v1.5.zip
                                        #include "DHT.h"       //für Temperatursensoren DHT22
                                                               //https://github.com/adafruit/DHT-sensor-library/archive/master.zip
                                        #include <as_bh1750.h>//für I2C-Luxmeter
                                                               //https://github.com/hexenmeister/AS_BH1750/archive/master.zip
                                        #include <sfe_bmp180.h>//für I2C-Barometer
                                                               //https://github.com/sparkfun/BMP180_Breakout/archive/master.zip
                                        #include <rcswitch.h>// läuft noch nicht!
                                        #include <eeprom.h>#include <sht2x.h>//#include <irremote.h>// läuft noch nicht!
                                        
                                        //der folgende Bereich ist bei verwendung w5100 auszukommentieren
                                        //ausblenden mit " #if defined (5100)" funktioniert leider nicht!! 
                                        /*
                                        //Initialisierung des CC3000 Wifi auf dem IO-Shield-Plus  
                                        #include <sfe_cc3000.h>// fuer cc3000 wifi
                                                         // http://github.com/sparkfun/SFE_CC3000_Library/archive/master.zip
                                        #include <sfe_cc3000_client.h>// Pins
                                        #define CC3000_INT 18  // int-Pin mit Wifi Shield ist D3, mit breakout auf IO-Shield-Plus D18
                                        #define CC3000_EN 46   // en-Pin mit Wifi Shield ist D5, mit breakout auf IO-Shield-Plus  D46
                                        #define CC3000_CS 53   // cs-Pin mit Wifi Shield ist D10, mit breakout auf IO-Shield-Plus D53
                                        SFE_CC3000 wifi = SFE_CC3000(CC3000_INT, CC3000_EN, CC3000_CS);
                                        SFE_CC3000_Client client = SFE_CC3000_Client(wifi);
                                        unsigned int ap_security = WLAN_SEC_WPA2; // Security of network
                                        unsigned int timeout = 30000; // Milliseconds
                                        char server[] = "192,168,178,50"; // Remote host site
                                        */
                                        #if defined (w5100)  //************************************************************************ 
                                        //der folgende Bereich ist die Initialisierung des LAN bei Verwendung des LAN-Shields
                                        #include <ethernet.h>EthernetClient client;
                                        EthernetServer server(80);
                                        #endif  //************************************************************************************* 
                                        
                                        #if defined(tft_display)  //*******************************************************************
                                        #include <adafruit_gfx.h>//Quelle: https://github.com/adafruit/Adafruit-GFX-Library
                                        #include <adafruit_tftlcd.h>//Quelle:   https://github.com/buhosoft/TFTLCD-Library
                                        #include <stdint.h>#include "TouchScreen.h"      
                                        //Quelle: http://www.smokeandwires.co.nz/blog/a-2-4-tft-touchscreen-shield-for-arduino/
                                        #define YP A1  // must be an analog pin, use "An" notation!
                                        #define XM A2  // must be an analog pin, use "An" notation!
                                        #define YM 7   // can be a digital pin
                                        #define XP 6   // can be a digital pin
                                        #define MINPRESSURE 10
                                        #define MAXPRESSURE 1000
                                        TouchScreen ts = TouchScreen(XP, YP, XM, YM, 330);
                                        #define BLACK   0x0000
                                        #define BLUE    0x001F
                                        #define RED     0xF800
                                        #define GREEN   0x07E0
                                        #define CYAN    0x07FF
                                        #define MAGENTA 0xF81F
                                        #define YELLOW  0xFFE0
                                        #define WHITE   0xFFFF
                                        #define LCD_CS A3 // Chip Select goes to Analog 3
                                        #define LCD_CD A2 // Command/Data goes to Analog 2
                                        #define LCD_WR A1 // LCD Write goes to Analog 1
                                        #define LCD_RD A0 // LCD Read goes to Analog 0
                                        #define tft_rotation 3 //3 oder 1 abhägig vom tft-shield typ               < <user-eingabe<< 1/2/3/4/#define/lcd_reset/a4/can/alternately/just/connect/to/arduino's/reset/pin/adafruit_tftlcd/tft(lcd_cs,/lcd_cd,/lcd_wr,/lcd_rd,/lcd_reset);/int/touch_y;/const/byte/zeilenzahl="6;" px,py,pz;/boolean/touch,/touch_alt;/unsigned/long/next_touch_time="0;" 2,4''/display/px_a="901," py_a="183;" touch-koordinaten/oben-links/px_b="192," py_b="189;" oben-rechts/px_c="936," py_c="860;" unten-links/schriftgroesse/tft_type/ist/2,4''display/3.95''display/3,95''/p_x,/p_y/;/normierte/aktuelle/touch-koordinaten:/oben/links/0,0/und/unten/rechts/1000,1000/#endif/*************************************************************************************/#if/defined(lcd_display)/*******************************************************************/https:/www.dfrobot.com/wiki/index.php?title="Arduino_LCD_KeyPad_Shield_%28SKU:_DFR0009%29" #include/<liquidcrystal.h="">LiquidCrystal lcd(8, 9, 4, 5, 6, 7); // initialize library with numbers of the interface pins
                                        const byte zeilenzahl = 2;
                                        #endif  //*************************************************************************************
                                        
                                        int x, x_alt;
                                        byte zeile_pointer[6];
                                        String zeile_data[6] = {"     ","     ","     ","     ","     ","     "};
                                        String display_zeile_alt[6],display_zeile[6];
                                        String taster;
                                        
                                        char zeichen,buffer[50];
                                        boolean fob_da =0;
                                        String zeich, fob_hex, fob_dec,Name, lcd_rfid_message, oeffner, Value;
                                        unsigned long fob_zahl,time_rfid3 = 0,time_rfid2 = 0; 
                                        byte zeichen_zahl;
                                        
                                        //********************************************************************************************* 
                                        AS_BH1750 sensor; //Initialize BH1750 Luxmeter library
                                        float lux;
                                        long Lux;
                                        int laenge;
                                        const float ALTITUDE = 299.0; // eigene seehoehe in metern              < <user io-shield-plus<</sfe_bmp180/pressure;/char/status;/double/t,p,p0,/t_sht21,/h_sht21;/boolean/reading="false;" string/command="String(200);" baro_string,barot_string,/lux_string,/shth_string,shtt_string;/*********************************************************************************************/last_digital_value_d[80];/float/last_value_d[80],last_ir_value,last_rf_value;/unsigned/long/next_time[80];/last_baro_value,last_barot_value,last_shth_value,last_shtt_value;/complete_loop="1;" wenn/1,/dann/einmal/komplett/durchlaufen/befehl,sub_command="String(20),parameter" =/string(20),header="String(20);" befehl2,sub_command2="String(20),parameter2" string(20),header2="String(20);" int/param,port_pin;/port_data;/value;/i;/analogwert;/tempntc;/const/b_wert="3950;" aus/dem/datenblatt/des/ntc/<<user-eingabe<</tn="298.15;" 25°celsius/in/°kelvin/rv="10000;" vorwiderstand/rn="10000;" ntc-widerstand/bei/25°c/rt,temp_tur,humidity;/delta_onewire="0.2;" deltas/für/sendeauslösung/delta_dht="0.1;" °c/delta_us="3.0;" cm/delta_analog="2.0;" inkrement/delta_ntc="0.5;" delta_lux="15;" lux/delta_counter="5;" counter/delta_baro="0.5;" mb/delta_barot="0.5;" delta_shth="0.2;" %/delta_shtt="0.1;" duration,/cm;/variable/ultraschallsensor/time_sr04;/next_full_loop="0;" delta_time="3600000;" jede/stunde/werden/alle/inputs/aktualisiert/delta_tx="500;" ms,/minimaler/abstand/der/telegramme/an/die/iobroker/next_tx="0," time_wait="0;" rf_key;/rfkey;/rcswitch/myswitch="RCSwitch();" zaehlwert;/last_zaehlwert[6]="{0,0,0,0,0,0};" #############################################################################################/void/setup()/{serial.begin(9600);/wire.begin();/+++++++/einrichtung/interrupts/fuer/impulszahler/d2,d3,d18,d19,d20,d21/if/((pulsedivider[0]="">0) && (iomodus_D[2] == 6)) 
                                           {pinMode(2, INPUT_PULLUP); attachInterrupt(0, ISR_0, FALLING);}
                                         if ((pulsedivider[1] > 0) && (iomodus_D[3] == 6)) 
                                           {pinMode(3, INPUT_PULLUP); attachInterrupt(1, ISR_1, FALLING);} 
                                         if ((pulsedivider[2] > 0) && (iomodus_D[21] == 6)) 
                                           {pinMode(21, INPUT_PULLUP); attachInterrupt(2, ISR_2, FALLING);}
                                         if ((pulsedivider[3] > 0) && (iomodus_D[20] == 6)) 
                                           {pinMode(20, INPUT_PULLUP); attachInterrupt(3, ISR_3, FALLING);}
                                         if ((pulsedivider[4] > 0) && (iomodus_D[19] == 6)) 
                                           {pinMode(19, INPUT_PULLUP); attachInterrupt(4, ISR_4, FALLING);}
                                        
                                         #if defined (w5100)  //************************************************************************* 
                                         if ((pulsedivider[5] > 0) && (iomodus_D[18] == 6))  //interrupt reserviert fuer cc3000
                                           {pinMode(18, INPUT_PULLUP); attachInterrupt(5, ISR_5, FALLING);}
                                         #endif  //*************************************************************************************
                                        
                                        //+++++++ rfid initialisieren
                                         if ((iomodus_D[15] == 12) && (iomodus_D[14] == 12)){Serial3.begin(9600);}
                                         if ((iomodus_D[17] == 12) && (iomodus_D[16] == 12)){Serial2.begin(9600);}
                                        
                                        #if defined (lcd_display)  //******************************************************************
                                        //+++++++ lcd initialisieren
                                         lcd.begin(16, 2); delay(200);  //16 zeichen in 2 zeilen
                                         lcd.setCursor(0,0);
                                         lcd.print(" Homeduino 4.0  ");
                                        #endif  //*************************************************************************************
                                        
                                        #if defined (tft_display)  //******************************************************************
                                        //+++++++ tft initialisieren
                                         tft.reset();
                                         int identifier = tft.readID();  tft.begin(identifier);
                                         Serial.print(" tft identifier:" ); Serial.println(identifier);   
                                         delay(100);
                                         tft.fillScreen(BLACK); tft.setRotation(tft_rotation);
                                         if (tft_type ==1) //2,4'' display
                                           {tft_print (1,"  Homeduino",4,YELLOW);
                                            tft_print (2,"     4.0",4,YELLOW);
                                            tft_print (5,"www.stall.biz",4,CYAN);
                                            tft.drawRect(0,0, 319, 240, GREEN);
                                           } 
                                          if (tft_type ==2)  //3,95'' display
                                           {tft_print (1,"   Homeduino",5,YELLOW);
                                            tft_print (2,"      4.0",5,YELLOW);
                                            tft_print (5," www.stall.biz",5,CYAN);
                                            tft.drawRect(5,5, 475, 310, GREEN);
                                           }   
                                        #endif  //*************************************************************************************
                                        
                                        for(int i=0; i<zeilenzahl; i++)/{zeile_pointer[i]="EEPROM.read(i);" anzeige-pointer/aus/eeprom/holen/if/(zeile_pointer[i]="">79) {zeile_pointer[i] = 0;}  //wenn eeprom erstes mal benutzt wird
                                           } 
                                        
                                        #if defined (w5100)  //************************************************************************
                                        //hier folgt die LAN Initialisierung 
                                        char myIpString[24];
                                         if (Ethernet.begin(mac) == 0) // start the Ethernet connection:
                                           {Serial.println("Failed to configure Ethernet using DHCP"); Ethernet.begin(mac, homeduino);}
                                            delay(1000);// give the Ethernet shield a second to initialize:
                                            Serial.println("connecting..."); // if you get a connection, report back via serial:
                                         if (client.connect(iobroker, 8082)) {}
                                           else {Serial.println("connection to iobroker failed");} // if you didn't get a connection to the server:
                                         client.stop();
                                         IPAddress myIp = Ethernet.localIP();
                                         sprintf(myIpString, "%d.%d.%d.%d", myIp[0], myIp[1], myIp[2], myIp[3]); 
                                         I = myIpString;
                                         befehl = "GET /set/javascript.0.Technikraum.Homeduino."+hm_systemvariable+"IP"+"?value="+I;
                                         set_sysvar();
                                         server.begin();
                                        #endif  //*************************************************************************************
                                        
                                        #if defined (cc3000)  //**********************************************************************
                                        // hier folgt die CC3000 Initialisierung 
                                         ConnectionInfo connection_info;
                                         char myIpString[24]; 
                                         Serial.println("SparkFun CC3000 - WebClient");
                                         if ( wifi.init() ) {Serial.println("init complete");} 
                                         else {Serial.println("problem with init!");}
                                         // Connect using DHCP
                                         if (!wifi.connect(ap_ssid, ap_security, ap_password, timeout)) 
                                           {Serial.println("no connection to AP");}
                                         //build IP address
                                         if ( !wifi.getConnectionInfo(connection_info) ) {Serial.println("no connection details");} 
                                           else {sprintf(myIpString, "%d.%d.%d.%d", connection_info.ip_address[0], 
                                           connection_info.ip_address[1],connection_info.ip_address[2], connection_info.ip_address[3]); 
                                                 I = myIpString;
                                                }
                                         befehl = "GET /xy.exe?antwort=dom.GetObject('"+hm_systemvariable+"IP"+"').State('" + I + "')";
                                         set_sysvar(); 
                                         client.stop();
                                        #endif  //*************************************************************************************
                                        
                                        #if defined (lcd_display)  //****************************************************************** 
                                        //bei erfolgreichem einloggen ausgabe ip-adresse 
                                        lcd.setCursor(0,1);
                                        lcd.print(myIpString);
                                        delay(3000);
                                        #endif  //*************************************************************************************
                                        
                                        #if defined (tft_display) //*******************************************************************
                                        //bei erfolgreichem einloggen ausgabe ip-adresse 
                                        tft.fillScreen(BLACK);
                                        if (tft_type ==1) //2,4'' display
                                          {tft.setCursor(8, 230); //fusszeile
                                           tft.setTextColor(GREEN);  
                                           tft.setTextSize(1);
                                           tft.print(Version + "   Homeduino IP: "); tft.print( myIpString);
                                          }
                                        if (tft_type ==2) //3,95'' display
                                          {tft.setCursor(1, 300); //fusszeile
                                           tft.setTextColor(GREEN);  
                                           tft.setTextSize(2);
                                           tft.print(Version + " IP: "); tft.print( myIpString);
                                          }
                                        #endif  //*************************************************************************************
                                        for (int i = 0; i < 80; i++) {next_Time[i]=0;} //
                                         //delay(2000);
                                        }
                                        //#############################################################################################
                                        //#############################################################################################
                                        void loop() 
                                        {complete_loop = 0;
                                         if (millis() > next_full_loop) //mindestens jede Stunde eine komplette Aktualisierung
                                           {complete_loop = 1; next_full_loop = millis() + delta_time; 
                                            if (next_full_loop < millis()) {complete_loop = 0;} //wichtig wegen Zahlensprung 
                                                                                                //von millis() alle 50 Tage
                                           } 
                                        //*********************************************************************************************
                                         for (int i = 2; i < 70; i++) //behandlung aller Ports D2 bis D69 
                                         {while ((iomodus_D[i] == 0) || (iomodus_D[i] >29 )) {i++;}  // unbenutzte pins überspringen
                                          datenempfang(); //nach jeder Messung auf Datenempfang schalten
                                          display_data(); //display ausgeben und abfragen
                                         //******************************************************************************************** 
                                         if (iomodus_D[i] == 1) //behandlung digitaleingänge 
                                           {if (millis() > next_Time[i])
                                              {next_Time[i] = next_Time[i] +1000;  //digitaleingänge nicht häufiger als alle 1000ms abfragen
                                               pinMode(i, INPUT_PULLUP); 
                                               digitalWrite(i, HIGH);
                                               value =digitalRead(i);
                                               for (int m=0; m < zeilenzahl; m++)
                                                 {if (zeile_pointer[m] == i) 
                                                    {if (value ==0) {zeile_data[m] = "LOW";} else {zeile_data[m] = "HIGH";}}}
                                               if ((!value == last_digital_value_D[i]) || complete_loop) 
                                                 {I = String(i);
                                                  befehl="GET /set/javascript.0.Technikraum.Homeduino."+hm_systemvariable+"D"+I+"?value="+value;
                                                  set_sysvar();
                                                  last_digital_value_D[i] = value;
                                                 }
                                              } 
                                           }
                                        //********************************************************************************************* 
                                         if (iomodus_D[i] == 3) //behandlung onewire 
                                           {if (millis() > next_Time[i])
                                              {next_Time[i] = next_Time[i] +10000;  //onewire nicht häufiger als alle 10s abfragen 
                                               pinMode(i, INPUT_PULLUP);
                                               digitalWrite(i,HIGH);
                                               OneWire ds(i); 
                                               #define DS18S20_ID 0x10
                                               #define DS18B20_ID 0x28 
                                               byte present = 0;   byte data[12];    byte addr[8];
                                               temp_tur = 1000.0;
                                               if (!ds.search(addr)) { ds.reset_search(); temp_tur = -1000.0; } //find a device
                                               if ((OneWire::crc8( addr, 7) != addr[7]) && (temp_tur > -1000.0)) {temp_tur = -1000.0; }
                                               if ((addr[0] != DS18S20_ID && addr[0] != DS18B20_ID)&& (temp_tur > -1000.0)) 
                                                 {temp_tur = -1000.0;}
                                               if (temp_tur > -1000.0) 
                                                 {ds.reset(); 
                                                  ds.select(addr); 
                                                  ds.write(0x44, 1); // Start conversion
                                                  //delay(850); // Wait some time...
                                                  time_wait = millis() +850;                       //wahrend der 2s wartezeit, daten empfangen
                                                  while (millis() < time_wait) {datenempfang();display_data;} //und display weiter bedienen 
                                                  present = ds.reset(); 
                                                  ds.select(addr);
                                                  ds.write(0xBE); // Issue Read scratchpad command
                                                  for ( int k = 0; k < 9; k++) { data[k] = ds.read(); } // Receive 9 bytes
                                                  temp_tur = ( (data[1] << 8) + data[0] )*0.0625; // Calculate temperature value 18B20
                                                  //temp_tur = ( (data[1] << 8) + data[0] )*0.5 // Calculate temperature value 18S20
                                                 }
                                               for (int m=0; m < zeilenzahl; m++)
                                                 {if (zeile_pointer[m] == i) {zeile_data[m] = String(temp_tur,1);}
                                                 }
                                               if ((temp_tur > (last_value_D[i] + delta_onewire)) || (temp_tur < (last_value_D[i] - delta_onewire)) || complete_loop) 
                                                 {I = String(i);
                                                  befehl="GET /set/javascript.0.Technikraum.Homeduino."+hm_systemvariable+"D"+I+"?value="+temp_tur;
                                                  set_sysvar();
                                                  last_value_D[i] = temp_tur;
                                                 }
                                              }   
                                          }
                                        //********************************************************************************************* 
                                         if (iomodus_D[i] == 4) //behandlung DHT temperatur- und feuchtesensoren
                                           {if (millis() > next_Time[i])
                                              {next_Time[i] = next_Time[i] +30000;  //DHT nicht häufiger als alle 30s abfragen 
                                               DHT dht(i, DHT22); //je nach verwendetem sensor "DHT11", "DHT22" (AM2302),"DHT 21" (AM2301)
                                               dht.begin();
                                               //delay(2000); // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
                                               time_wait = millis() +2000;                       //wahrend der 2s wartezeit, daten empfangen
                                               while (millis() < time_wait) {datenempfang();display_data;} //und display weiter bedienen 
                                               humidity = dht.readHumidity(); // Read temperature as Celsius
                                               temp_tur = dht.readTemperature(); 
                                               if (isnan(humidity) || isnan(temp_tur) ) // Check if any reads failed and 
                                                 {//Serial.println("Failed to read from DHT sensor!");
                                                  temp_tur = -1000;
                                                 }
                                               for (int m=0; m < zeilenzahl; m++)
                                                 {if (zeile_pointer[m] == i) {zeile_data[m] = String(temp_tur,1);}
                                                 }
                                                 if ((temp_tur > (last_value_D[i] + delta_DHT))|| (temp_tur < (last_value_D[i] - delta_DHT)) || complete_loop)
                                                 {I = String(i);
                                                  befehl="GET /set/javascript.0.Technikraum.Homeduino."+hm_systemvariable+"D"+I+"?value="+temp_tur;
                                                  set_sysvar();
                                                  befehl="GET /set/javascript.0.Technikraum.Homeduino."+hm_systemvariable+"D"+I+"_1"+"?value="+humidity;
                                                  set_sysvar();
                                                  last_value_D[i] = temp_tur;
                                                 }
                                                }
                                           } 
                                         //******************************************************************************************** 
                                         if (iomodus_D[i] == 5) //behandlung ultraschallsensoren 
                                           {if (millis() > next_Time[i])
                                              {next_Time[i] = next_Time[i] +2000;  //ultraschall nicht häufiger als alle 2s abfragen 
                                         //achtung: zu beachten 
                                         //bei verwendung der US-Sensoren beim IO-Shield-Plus sind die 150-Ohm-Schutzwiderstände 
                                         //zu überbrücken (Jumper setzen!), entsprechend beim IO-Shield20 der Jumper 4-5 zu setzen!! 
                                               NewPing sonar(i, i, 200); // NewPing setup of pin and maximum distance.
                                               unsigned int uS = sonar.ping(); // Send ping, get ping time in microseconds (uS).
                                               int cm = uS / US_ROUNDTRIP_CM;
                                               for (int m=0; m < zeilenzahl; m++)
                                                 {if (zeile_pointer[m] == i) {zeile_data[m] = String(cm);}}
                                                  if ((cm > (last_value_D[i] + delta_us)) || (cm < (last_value_D[i] - delta_us)) || complete_loop) 
                                                    {I = String(i);
                                                     befehl = "GET /set/javascript.0.Technikraum.Homeduino."+hm_systemvariable+"D"+I+"?value="+cm;
                                                     set_sysvar();
                                                     last_value_D[i] = cm;
                                                    } 
                                              }
                                           }
                                        //********************************************************************************************* 
                                         if (iomodus_D[i] == 10) //behandlung analogeingänge 
                                           {if (millis() > next_Time[i])
                                              {next_Time[i] = next_Time[i] +1000;  //analogeingänge nicht häufiger als alle 1000ms abfragen 
                                               analogwert =analogRead(i);
                                               for (int m=0; m < zeilenzahl; m++)
                                                 {if (zeile_pointer[m] == i) {zeile_data[m] = String(analogwert);}}
                                               if ((analogwert > (last_value_D[i] + delta_analog)) 
                                                        || (analogwert < (last_value_D[i] - delta_analog)) || complete_loop) 
                                                 {I = String(i);
                                                  befehl="GET /set/javascript.0.Technikraum.Homeduino."+hm_systemvariable+"D"+I+"?value="+analogwert;
                                                  set_sysvar();
                                                  last_value_D[i] = analogwert;
                                                 }
                                              }
                                           } 
                                        //*********************************************************************************************
                                         if (iomodus_D[i] == 11) //behandlung NTC 
                                           {if (millis() > next_Time[i])
                                              {next_Time[i] = next_Time[i] +10000;  //NTC-eingänge nicht häufiger als alle 10s abfragen
                                               Rt = Rv/((1024.0/analogRead(i))- 1.0);
                                               tempNTC = (B_wert * Tn / ( B_wert + (Tn * log(Rt/Rn)))) -Tn +25.0 ;
                                               for (int m=0; m < zeilenzahl; m++)
                                                 {if (zeile_pointer[m] == i) {zeile_data[m] = String(tempNTC,1);}}
                                                  if ((tempNTC > (last_value_D[i] + delta_ntc)) || (tempNTC < (last_value_D[i] - delta_ntc)) || complete_loop) 
                                                    {I = String(i);
                                                     befehl="GET /set/javascript.0.Technikraum.Homeduino."+hm_systemvariable+"D"+I+"?value="+tempNTC;
                                                     set_sysvar();
                                                     last_value_D[i] = tempNTC;
                                                    } 
                                              }
                                           }     
                                        //********************************************************************************************* 
                                         if (iomodus_D[i] == 6) //behandlung impulszahler D2,D3,D21,D20,D19,D18 
                                           {byte offset =23;
                                            if (i ==2) {offset = 4;} if (i ==3) {offset = 6;}
                                            zaehlwert = pulsecounter[offset - i ] / pulsedivider[offset - i ];
                                            for (int m=0; m < zeilenzahl; m++)
                                              {if (zeile_pointer[m] == i) {zeile_data[m] = String(zaehlwert);}}
                                               if ((pulsedivider[offset -i] > 0) && ((zaehlwert > (last_zaehlwert[offset - i]+ delta_counter) || complete_loop))) 
                                                 {I = String(offset -i);
                                                  befehl="GET /set/javascript.0.Technikraum.Homeduino."+hm_systemvariable+"imp"+I+"?value="+zaehlwert;
                                                  set_sysvar();
                                                  last_zaehlwert[offset - i] = zaehlwert;
                                                 } 
                                           } 
                                        //*********************************************************************************************
                                        //behandlung I2C sensoren an pin 20(sda) und pin 21 (scl)
                                         if ((iomodus_D[i] == 8)&&(i == 20))
                                           {i++;  // da I2C Bus 2 eingaenge belegt
                                        
                                        //behandlung Luxmeter BH1750 an SCL pin21 und SDA pin 20 ***********************************
                                        // for normal sensor resolution (1 lx resolution, 0-65535 lx, 120ms, no PowerDown) 
                                        //use: sensor.begin(RESOLUTION_NORMAL, false); 
                                            if (iomodus_lux ==1)
                                              {if (millis() > next_Time[72])
                                                 {next_Time[72] = next_Time[72] +5000;  //luxmeter nicht haeufiger als alle 5s abfragen 
                                                  if(!sensor.begin()) { Serial.println("Sensor not present"); }
                                                  lux = sensor.readLightLevel(); //delay(1000);
                                                  Lux = (int)lux;
                                                  //Serial.print("Helligkeit/lux: "); Serial.print(lux); Serial.println();
                                                  lux_string = "      " + String(Lux);
                                                  int laenge = lux_string.length();
                                                  lux_string = lux_string.substring(laenge -6,laenge);
                                                  for (int m=0; m < zeilenzahl; m++)
                                                    {if (zeile_pointer[m] == 72) {zeile_data[m] = lux_string;}}
                                                     if (((Lux > (last_value_D[72] + delta_lux)) || (Lux < (last_value_D[72] - delta_lux)) || complete_loop)) 
                                                       {befehl="GET /set/javascript.0.Technikraum.Homeduino."+hm_systemvariable+"lux"+"?value="+Lux;
                                                        set_sysvar();
                                                        last_value_D[72] = Lux;
                                                       }
                                                 } 
                                               }
                                        //behandlung barometer BMP180 an SCL pin21 und SDA pin 20
                                            if (iomodus_baro ==1)
                                              {if (millis() > next_Time[70])
                                                 {next_Time[70] = next_Time[70] +30000;  //barometer nicht häufiger als alle 30s abfragen 
                                                  if (pressure.begin()) {status = pressure.startTemperature();}
                                                  if (status) {delay(status); status = pressure.getTemperature(T);} //messung T
                                                  if (status) {status = pressure.startPressure(3);} // //messung P mit resolution 0 bis 3
                                                  if (status) {delay(status); status = pressure.getPressure(P,T);}
                                                  if (status) {p0 = pressure.sealevel(P,ALTITUDE);} // umrechnung auf N.N.
                                        //Serial.print("Hoehe/m: "); Serial.print(ALTITUDE); Serial.print(" Temperatur/C: "); 
                                        //Serial.print(T); Serial.print(" Normaldruck /mb: "); Serial.println(p0); 
                                                  baro_string = "     " + String(p0);
                                                  laenge = baro_string.length();
                                                  baro_string = baro_string.substring(laenge -7,laenge -1);
                                                  baroT_string = "      " + String(T);
                                                  laenge = baroT_string.length();
                                                  baroT_string = baroT_string.substring(laenge -7,laenge -1);
                                                  for (int m=0; m < zeilenzahl; m++) {if (zeile_pointer[m] == 70) {zeile_data[m] = baro_string;}}
                                                  if ((p0 > (last_baro_value + delta_baro)) || (p0 < (last_baro_value - delta_baro)) || complete_loop) 
                                                    {befehl="GET /set/javascript.0.Technikraum.Homeduino."+hm_systemvariable+"baro"+"?value="+p0;
                                                     set_sysvar();
                                                     last_baro_value = p0;
                                                     last_value_D[70] = p0;
                                                    }
                                                  for (int m=0; m < zeilenzahl; m++) {if (zeile_pointer[m] == 71) {zeile_data[m] = baroT_string;}}  
                                                  if ((T > (last_baroT_value + delta_baroT)) || (p0 < (last_baroT_value - delta_baroT)) || complete_loop) 
                                                    {befehl="GET /set/javascript.0.Technikraum.Homeduino."+hm_systemvariable+"baroT"+"?value="+T;
                                                     set_sysvar();
                                                     last_baroT_value = T;
                                                     last_value_D[71] = T;
                                                    } 
                                                 }
                                              }  
                                        //***********************************************************************
                                        //behandlung SHT21 an SCL pin21 und SDA pin 20
                                        //behandlung Temperatur- und Feuchtesensor an SCL pin21 und SDA pin 20
                                        
                                            if (iomodus_sht ==1)
                                              {if (millis() > next_Time[73])
                                                 {next_Time[73] = next_Time[73] +15000;  //SHT nicht häufiger als alle 10s abfragen 
                                        
                                                  h_sht21 = ( SHT2x.GetHumidity() ) ; // ggf ( ) nicht setzten.
                                                  t_sht21 = ( SHT2x.GetTemperature() ) ; // ggf ( ) nicht setzten.
                                        
                                                  shtH_string = "     " + String(h_sht21);
                                                  laenge = shtH_string.length();
                                                  shtH_string = shtH_string.substring(laenge -7,laenge -1);
                                        
                                                  shtT_string = "      " + String(t_sht21);
                                                  laenge = shtT_string.length();
                                                  shtT_string = shtT_string.substring(laenge -7,laenge -1);
                                        
                                                  for (int m=0; m < zeilenzahl; m++) {if (zeile_pointer[m] == 73) {zeile_data[m] = shtH_string;}}
                                                  if ((h_sht21 > (last_shtH_value + delta_shtH)) || (h_sht21 < (last_shtH_value - delta_shtH)) || complete_loop)
                                                  {befehl="GET /set/javascript.0.Technikraum.Homeduino."+hm_systemvariable+"SHT-Feuchte"+"?value="+h_sht21;
                                                   set_sysvar();
                                                   last_shtH_value = h_sht21;
                                                   last_value_D[73] = h_sht21;
                                                  }
                                                  for (int m=0; m < zeilenzahl; m++) {if (zeile_pointer[m] == 74) {zeile_data[m] = shtT_string;}}
                                                  if ((t_sht21 > (last_shtT_value + delta_shtT)) || (t_sht21 < (last_shtT_value - delta_shtT)) || complete_loop)
                                                  {befehl="GET /set/javascript.0.Technikraum.Homeduino."+hm_systemvariable+"SHT-Temp"+"?value="+t_sht21;
                                                    set_sysvar();
                                                    last_shtT_value = t_sht21;
                                                    last_value_D[74] = t_sht21;
                                                  }
                                                 }
                                              }
                                          }
                                        //*********************************************************************************************
                                         if (iomodus_D[3] == 7) //behandlung 433Mhz-rx 
                                           {if (mySwitch.available()) 
                                              {int value = mySwitch.getReceivedValue();
                                               if (value == 0) {client.print("Unknown encoding");} 
                                                  else {Serial.print("Pin D3 received : ");
                                                        Serial.print (mySwitch.getReceivedValue() );
                                                        Serial.print (" / ");
                                                        Serial.print( mySwitch.getReceivedBitlength() );
                                                        Serial.print("bit Protocol: ");
                                                        Serial.println( mySwitch.getReceivedProtocol() + " \n\r" );
                                                       }
                                              mySwitch.resetAvailable();
                                             }
                                           } 
                                          //******************************************************************************************* 
                                         if ((iomodus_D[i] == 12) && (i==22))  //behandlung rfid3 tueroeffner an D22 des Mega
                                           {pinMode(i,OUTPUT);
                                            if (millis()< time_rfid3)         //D22-als normal-Ausgang für tueröffner schalten
                                              {Value = " AUF"; 
                                               if (oeffner_polarity) {digitalWrite(i, HIGH);} else {digitalWrite(i,LOW);}
                                               }
                                                 else {Value = "  ZU"; if (!oeffner_polarity) 
                                                                       {digitalWrite(i, HIGH);} else {digitalWrite(i,LOW);}}
                                               for (int m=0; m < zeilenzahl; m++)
                                                 {if (zeile_pointer[m] == i) {zeile_data[m] = Value;}}
                                            }
                                          if ((iomodus_D[i] == 12) && (i==23))  //behandlung rfid2 tueroeffner  an D23 des Mega
                                            {pinMode(i,OUTPUT);
                                             if (millis()< time_rfid2)         //D23-als normal-Ausgang für tueröffner schalten
                                               {Value = " AUF"; if (oeffner_polarity) 
                                                                  {digitalWrite(i, HIGH);} 
                                                                  else {digitalWrite(i,LOW);}}
                                               else {Value = "  ZU"; if (!oeffner_polarity) {digitalWrite(i, HIGH);} 
                                                                                            else {digitalWrite(i,LOW);}} 
                                             for (int m=0; m < zeilenzahl; m++)
                                               {if (zeile_pointer[m] == i) {zeile_data[m] = Value;}
                                               }
                                            }
                                         //******************************************************************************************** 
                                          if (iomodus_D[i] == 12) //behandlung rfid-modul RDM6300 
                                            {int m = 0; fob_zahl=0;  fob_hex ="";
                                             if (i == 15){while((Serial3.available()>0)&&(m <11 ))  //behandlung rfid3
                                                               {fob_da=1;  m++;  zeichen = Serial3.read();
                                                                if (m>4)  //die ersten 4 zeichen ignorieren
                                                                  {fob_hex += zeichen; fob_zahl = hexToDec(fob_hex);}
                                                                if (m > 10) //Datenübertragung fertig, dann buffer leeren 
                                                                  {while(Serial3.available()>0) {zeichen = Serial3.read();}}
                                                     }
                                                 }    
                                             if (i == 17){while((Serial2.available()>0)&&(m <11 ))//behandlung rfid2
                                                              {fob_da=1;  m++;  zeichen = Serial2.read();
                                                               if (m>4)  //die ersten 4 zeichen ignorieren
                                                                 {fob_hex += zeichen; fob_zahl = hexToDec(fob_hex);}
                                                               if (m > 10) //Datenübertragung fertig, dann buffer leeren 
                                                                 {while(Serial2.available()>0) {zeichen = Serial2.read();}}
                                                    }
                                                   }
                                             if (fob_da)
                                               {fob_dec = ""; 
                                                sprintf(buffer,"%lu", fob_zahl); //zahl umwandeln in string
                                                for(int k = 0; k<7; k++) {fob_dec += buffer[k];} 
                                                Name = "";  //gueltigen namen und oeffner aus tabelle ermitteln  
                                                for (int k = 0; k < fob_anzahl; k++) {if (fob_dec == fob[3*k]) 
                                                                                        {Name += fob[(3*k)+1];
                                                                                         oeffner= fob[(3*k)+2]; 
                                                                                         break;
                                                                                        }
                                                                                      }
                                                if ((Name != "") && ((oeffner =="1") ||(oeffner =="3"))) 
                                                  {time_rfid3 = millis() + unlock_time1;}
                                                if ((Name != "") && ((oeffner =="2") ||(oeffner =="3")))  
                                                  {time_rfid2 = millis() + unlock_time2;}
                                                if (Name == "") {Name = fob_dec;}
                                                lcd_rfid_message = Name + "          "; //lcd mmeldung modifizieren für rfid
                                                lcd_rfid_message = lcd_rfid_message.substring(0,9);
                                        
                                                for (int n=0; n < zeilenzahl; n++)
                                                  {if (zeile_pointer[n] == i) 
                                                     {display_message[i]= lcd_rfid_message; zeile_data[n] = fob_dec;}
                                                  }
                                        
                                             //Serial.println(Name + " " + fob_dec);
                                                I = String(i);
                                                befehl="GET /set/javascript.0.Technikraum.Homeduino."+hm_systemvariable+"D"+I+"?value="+Name;
                                                set_sysvar();
                                                fob_da =0;
                                               }
                                             delay(500);  
                                            }
                                        //**************************   ende loop  *****************************************************
                                         }
                                        } 
                                        //#############################################################################################
                                        //#############################################################################################
                                        //#############################  Unterprogramme   #############################################
                                        
                                        void datenempfang() //Unterprogramm datenempfang: daten von iobroker an homeduino senden
                                        {command = ""; 
                                        
                                        #if defined (w5100)  //************************************************************************
                                         EthernetClient client = server.available();   //mit W5100
                                        #endif  //************************************************************************************* 
                                        
                                        #if defined (cc3000)  //***********************************************************************
                                         SFE_CC3000_Client client = SFE_CC3000_Client(wifi);   //mit CC3000
                                        #endif  //************************************************************************************* 
                                        
                                         if (client) // an http request ends with a blank line
                                           {boolean currentLineIsBlank = true;
                                            while (client.connected())
                                              {if (client.available()) 
                                                 {char c = client.read();
                                                  if (reading && c == ' ') reading =false;
                                                  if (c == '?') reading = true; // beginn der Befehlssequenz 
                                                  if (reading) 
                                                    {if (command.length() < 100) //read char by char HTTP request
                                                       {command = command + c; } //store characters to string
                                                    } 
                                                  if (c == '\n' && currentLineIsBlank) break;
                                                  if (c == '\n') {currentLineIsBlank = true;} 
                                                    else if (c != '\r') { currentLineIsBlank = false;}
                                                 } 
                                               } 
                                             client.println(command);
                                             delay(1); 
                                             client.stop();
                                        //*********************************************************************************************
                                            if (command.length() > 2) //behandlung Datenempfang von iobroker: port auf 0/1 setzen 
                                              {Serial.println(command); //empfangenen befehl ausgeben
                                               client.print(command); //befehl dann dekodieren 
                                               int colonPosition = command.indexOf(':');
                                               sub_command = command.substring(2,colonPosition); //portpin erkennen
                                               Serial.print("D" + sub_command + " :");
                                               port_pin = sub_command.toInt();
                                               command = command.substring((colonPosition+1)); //Rest-command bilden
                                               if (((iomodus_D[port_pin] == 2)||(iomodus_D[port_pin] == 12)) && (command == "0")) 
                                                 {for (int m=0; m < zeilenzahl; m++)
                                                    {if (zeile_pointer[m] == port_pin) {zeile_data[m] = " LOW";}
                                                    }
                                                  pinMode(port_pin, OUTPUT); digitalWrite(port_pin, LOW); Serial.println(command);
                                                 }
                                               if ((iomodus_D[port_pin] == 2) && (command == "1")) 
                                                 {for (int m=0; m < zeilenzahl; m++)
                                                    {if (zeile_pointer[m] == port_pin) {zeile_data[m] = " HIGH";}
                                                    }
                                                  pinMode(port_pin, OUTPUT); digitalWrite(port_pin, HIGH); Serial.println(command);}
                                                  if ((iomodus_D[port_pin] == 7) && (port_pin ==4)) 
                                                    {rf_send(command); Serial.println(command);} 
                                                  if ((iomodus_D[port_pin] == 5) && (port_pin ==9)) 
                                                    {ir_send(command); Serial.println(command);} 
                                              }
                                          } 
                                        } 
                                        //*********************************************************************************************
                                        void set_sysvar() // subroutine HTTP request an ioBroker absetzen:
                                        {//while (millis() < next_tx) {} //warten bis time > next_tx oder timeout
                                         next_tx = millis() +delta_tx;
                                         if (client.connect(iobroker, 8082)) 
                                           {Serial.println(befehl);
                                            client.println(befehl);
                                            client.println();
                                            client.stop();
                                           } else {Serial.println("connection to iobroker failed");}
                                        }
                                        //*********************************************************************************************
                                        void rf_send(String rf_command) // subroutine rf telegramm senden
                                        {
                                        }
                                        //*********************************************************************************************
                                        void ir_send(String ir_command) // subroutine ir telegramm senden
                                        {
                                        }
                                        //*********************************************************************************************
                                        //hier sind die interrupt-service-routinen fuer die impulszaehler  //**************************
                                        void ISR_0() //Interrupt an D2
                                        {pulsecounter[0]++;}
                                        void ISR_1() //Interrupt an D3
                                        {pulsecounter[1]++;}
                                        void ISR_2() //Interrupt an D21
                                        {pulsecounter[2]++;}
                                        void ISR_3() //Interrupt an D20
                                        {pulsecounter[3]++;}
                                        void ISR_4() //Interrupt an D19
                                        {pulsecounter[4]++;}
                                        void ISR_5() //Interrupt an D18 
                                        {pulsecounter[5]++;}
                                        //*********************************************************************************************
                                        //Unterprogramm:  Converting from Hex (unsigned long) to Decimal: *****************************
                                        //Quelle https://github.com/benrugg/Arduino-Hex-Decimal-Conversion/blob/master/hex_dec.ino
                                        unsigned long hexToDec(String hexString) 
                                        {unsigned long decValue = 0;
                                         int nextInt;
                                         for (int k = 0; k < hexString.length(); k++) 
                                           {nextInt = int(hexString.charAt(k));
                                            if (nextInt >= 48 && nextInt <= 57) nextInt = map(nextInt, 48, 57, 0, 9);
                                            if (nextInt >= 65 && nextInt <= 70) nextInt = map(nextInt, 65, 70, 10, 15);
                                            if (nextInt >= 97 && nextInt <= 102) nextInt = map(nextInt, 97, 102, 10, 15);
                                            nextInt = constrain(nextInt, 0, 15);
                                            decValue = (decValue * 16) + nextInt;
                                          }
                                         return decValue;
                                        }
                                        
                                        //*********************************************************************************************
                                        void display_data() //gibt daten auf dem lcd oder tft display aus
                                        
                                        //*********************************************************************************************
                                        #if defined (lcd_display)  //behandlung lcd-display: erkennung des tasters und lcd-anzeige
                                        {x = analogRead (0);  //abfrage A0
                                         if (x < (x_alt -100))  {tastererkennung();}
                                         x_alt = x; 
                                         for (int m = 0; m < zeilenzahl; m++)
                                           {while (zeile_data[m].length() < 5) {zeile_data[m] = " " + zeile_data[m];}
                                            if (display_message[zeile_pointer[m]] == "0") {zeile_data[m] = "                ";}
                                            display_zeile[m] =  display_message[zeile_pointer[m]] + zeile_data[m];
                                        
                                            if (display_zeile[m] != display_zeile_alt[m])  //datenausgabe auf display nur wenn aenderung 
                                              {lcd.setCursor(0,m); lcd.print (display_zeile[m]); display_zeile_alt[m] = display_zeile[m];}
                                           } 
                                        } 
                                        //*********************************************************************************************
                                        void tastererkennung()
                                        {if (x < 60) 
                                           {taster == "right"; 
                                            zeile_pointer[0]--;  if (zeile_pointer[0] ==1) {zeile_pointer[0] = 79;}
                                            while((iomodus_D[zeile_pointer[0]] ==0) || (iomodus_D[zeile_pointer[0]] >19))
                                                 {zeile_pointer[0]--; if (zeile_pointer[0] ==1) {zeile_pointer[0] =79;} }
                                            EEPROM.write(0,zeile_pointer[0]);//delay(4);
                                           } 
                                           else if (x < 200) 
                                                  {taster == "up";
                                                   zeile_pointer[0]++;  if (zeile_pointer[0] ==80) {zeile_pointer[0] = 2;}
                                                   while((iomodus_D[zeile_pointer[0]] ==0) || (iomodus_D[zeile_pointer[0]] >19))
                                                       {zeile_pointer[0]++; if (zeile_pointer[0] ==80) {zeile_pointer[0] = 2;} }
                                                   EEPROM.write(0,zeile_pointer[0]);//delay(4);
                                                  } 
                                                  else if (x < 400) 
                                                           {taster == "down";
                                                            zeile_pointer[1]++; if (zeile_pointer[1] ==80) {zeile_pointer[1] = 2;}
                                                            while((iomodus_D[zeile_pointer[1]] ==0) || (iomodus_D[zeile_pointer[1]] >19))
                                                                 {zeile_pointer[1]++; if (zeile_pointer[1] ==80) {zeile_pointer[1] = 2;} } 
                                                            EEPROM.write(1,zeile_pointer[1]);//delay(4);     
                                                           } 
                                                          else if (x < 600)
                                                                 {taster == "left";
                                                                  zeile_pointer[1]--;
                                                                  if (zeile_pointer[1] ==1) {zeile_pointer[1] = 79;}
                                                                  while((iomodus_D[zeile_pointer[1]] ==0) || (iomodus_D[zeile_pointer[1]] >19))
                                                                       {zeile_pointer[1]--; if (zeile_pointer[1] ==1) {zeile_pointer[1] =79;} }
                                                                  EEPROM.write(1,zeile_pointer[1]);//delay(4);
                                                                 } 
                                                                 else if (x < 800)
                                                                        {taster = "select";}
                                                                        else {taster ="";}
                                        }
                                        #endif  //************************************************************************************* 
                                        
                                        //*********************************************************************************************
                                        #if defined (tft_display)  //behandlung tft toucheingabe und  display 2.4''
                                         {if (millis() > next_touch_time)  //touch-display abfragen
                                           {TSPoint p = ts.getPoint();// a point object holds x y and z coordinates
                                            px = p.x; py = p.y; pz =p.z;  
                                            pinMode(XM, OUTPUT);   pinMode(YP, OUTPUT);
                                            if (pz > MINPRESSURE && pz < MAXPRESSURE ) 
                                              {Serial.print("px : ");Serial.print( px); Serial.print("  py : " ); Serial.print(py);
                                               Serial.print("  pz : " ); Serial.print(pz);
                                               if (abs(px_B - px_A) > 100) {p_x = (1000 *(px- px_A))/(px_B -px_A); p_y = (1000 *(py - py_A))/(py_C -py_A);} 
                                                 else {p_x = (1000 *(py -py_A))/(py_B - py_A); p_y = (1000 *(px - px_A)) /(px_C - px_A);}
                                               Serial.print("  p_x : ");Serial.print( p_x); Serial.print("  p_y : " ); Serial.print(p_y);
                                               if (p_y < 154) {touch_y = 0;}   //p_y = 1000 entspricht 6,5 Zeilen 
                                                 else {if (p_y < 308) {touch_y = 1;}
                                                         else {if (p_y < 462) {touch_y = 2;}
                                                                 else {if (p_y < 616) {touch_y = 3;}
                                                                         else {if (p_y < 770) {touch_y = 4;}
                                                                                 else {touch_y = 5;}}}}}
                                               Serial.print("     touch_y "); Serial.print(touch_y); Serial.println();
                                               if (p_x < 500) {zeile_pointer_minus();}  //Serial.println(zeile_pointer[touch_y]);}
                                               if (p_x > 500) {zeile_pointer_plus(); }  //Serial.println(zeile_pointer[touch_y]);}
                                               touch_alt = touch;
                                              }
                                            for (int m = 0; m < zeilenzahl; m++)  //datenausgabe auf tft-display
                                              {while (zeile_data[m].length() < 7) {zeile_data[m] = " " + zeile_data[m];}
                                               display_zeile[m] =  display_message[zeile_pointer[m]] + zeile_data[m];
                                               if (display_zeile[m] != display_zeile_alt[m]) //displayausgabe nur wenn aenderung 
                                                 {tft_print (m,display_zeile[m],schriftgroesse,WHITE); display_zeile_alt[m] = display_zeile[m];}
                                              }
                                           } 
                                        }
                                        //*********************************************************************************************
                                        //mit diesem Unterprogramm wird auf dem tft display ein zeilen-display 6 x 16  emuliert
                                        void tft_print (int line, String textline, int font_size, long int color)
                                        {if (tft_type ==1)
                                           {tft.fillRect(0,38*line, 319, 38, BLACK); //x0,y0, width,heights  //zeile loeschen
                                            tft.setCursor(0, 38*line+6);              //und dann erst schreiben
                                           }
                                         if (tft_type ==2)
                                           {tft.fillRect(0,50*line, 479, 50, BLACK); //x0,y0, width,heights  //zeile loeschen
                                            tft.setCursor(5, 50*line+6);              //und dann erst schreiben
                                           }  
                                         tft.setTextColor(color);  
                                         tft.setTextSize(font_size);
                                         tft.print(textline);
                                        }
                                        //mit diesen Unterprogrammen wird der zeile_pointer im eeprom abgelegt
                                        void zeile_pointer_plus()
                                        {next_touch_time = millis() + 200; 
                                          zeile_pointer[touch_y]++;  if (zeile_pointer[touch_y] >79) {zeile_pointer[touch_y] = 2;}
                                         while((iomodus_D[zeile_pointer[touch_y]] ==0) || (iomodus_D[zeile_pointer[touch_y]] >19))
                                          {zeile_pointer[touch_y]++; if (zeile_pointer[touch_y] >79) {zeile_pointer[touch_y] = 2;} }
                                         EEPROM.write(touch_y,zeile_pointer[touch_y]);//delay(4);
                                        }
                                        void zeile_pointer_minus()
                                        {next_touch_time = millis() + 200; 
                                          zeile_pointer[touch_y]--;  if (zeile_pointer[touch_y] <2) {zeile_pointer[touch_y] = 79;}
                                         while((iomodus_D[zeile_pointer[touch_y]] ==0) || (iomodus_D[zeile_pointer[touch_y]] >19))
                                           {zeile_pointer[touch_y]--; if (zeile_pointer[touch_y] <2) {zeile_pointer[touch_y] =79;}  }
                                         EEPROM.write(touch_y,zeile_pointer[touch_y]);//delay(4);
                                        }      
                                        #endif  //*************************************************************************************</zeilenzahl;></user></user-eingabe<<></stdint.h></adafruit_tftlcd.h></adafruit_gfx.h></ethernet.h></sfe_cc3000_client.h></sfe_cc3000.h></irremote.h></sht2x.h></eeprom.h></rcswitch.h></sfe_bmp180.h></as_bh1750.h></newping.h></onewire.h></wire.h></user-eingabe<<>` 
                                        
                                        Woran könnte es liegen????
                                        
                                        VG Torsten[/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i]
                                        
                                        1 Reply Last reply Reply Quote 0
                                        • P
                                          PrinzEisenherz1 last edited by

                                          Hi Thorsten, könntest du mal den serial Monitor dranhängen und beobachten was er dir anzeigt wenn du den digital output schaltest?

                                          Und das hier mal posten?

                                          Gruß Johnny

                                          1 Reply Last reply Reply Quote 0
                                          • S
                                            schneidy76 last edited by

                                            Hi, habe das Relaisboard direkt durchverdrahtet. Also Jumper auf 4-5.

                                            Danach alle IOs an, also Relais alle aus.

                                            Nach D2:0 das hier:
                                            2631_io_1.png

                                            geschaltet haben auch noch 8 und 6 low

                                            nach D2:1
                                            2631_io_2.png

                                            geschaltet haben auch noch 3,4,5 und 9 low

                                            8 und 6 sind wieder high

                                            sehr seltsam…. :?: :?:

                                            1 Reply Last reply Reply Quote 0
                                            • First post
                                              Last post

                                            Support us

                                            ioBroker
                                            Community Adapters
                                            Donate

                                            982
                                            Online

                                            31.7k
                                            Users

                                            79.8k
                                            Topics

                                            1.3m
                                            Posts

                                            7
                                            32
                                            5785
                                            Loading More Posts
                                            • Oldest to Newest
                                            • Newest to Oldest
                                            • Most Votes
                                            Reply
                                            • Reply as topic
                                            Log in to reply
                                            Community
                                            Impressum | Datenschutz-Bestimmungen | Nutzungsbedingungen
                                            The ioBroker Community 2014-2023
                                            logo