Ankündigung

Einklappen
Keine Ankündigung bisher.

Nibe GW ohne openhab

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

    #16
    Zitat von DerSeppel Beitrag anzeigen
    Beim 1-Wire müsstest du dir aber noch ein Stück Software schreiben, das die Sensoren abfragt und die Daten dann wieder irgendwie zur Verfügung stellt.
    Da meiste sollte es aber schon irgendwo zum zusammenkopieren geben.

    Es gibt auch schon einen KNX-IP Stack hier im Forum. Wenn man zeit hätte () könnte man das mal verheiraten und die Daten direkt auf KNX bringen.

    Wenn man das alles verheiratet könnte man in meinen Forum(Energiesparhausforum) sogar Geld dafür verlangen! Das reissen dir die Leute aus den Händen!
    Jeder will so eine Schnittstelle haben aber nicht mehr als 2-300 ausgeben!! Kann das wer machen? Will sich wer ein Trinkgeld verdienen?

    Kommentar


      #17
      Zitat von uzi10 Beitrag anzeigen
      Die Frage ist halt ob das ein Leistungsstarker 1-Wire Treiber ist, wie der blaue Stick! Für 100m würd ich auch den parasitären Betrieb benötigen! Wenn das alles läuft, dann wär das Ding echt der Hammer,weil es alles integriert hat!
      Schaut Euch mal den Schaltplan des ProDino an. 1-W ist ein digitaler I/O Pin mit 4,7k Pull-Up Widerstand. Nix mit Ähnlichkeiten zum Stick...

      Kommentar


        #18
        Ich will ja nicht als Spielverderber auftreten, aber ich denke eure Wünsche sind etwas unrealistisch.

        Es geht ja schon damit los, das Nibe insgesamt 6 Datenformate für seine Werte hat (u8,u16,u32,s8,s16,s32) und die dann auch noch in Orginalwert oder in 1/10 Wert kodiert.
        Es gibt auch kein für mich sichtbares System, welcher Wert wie codiert wird. Also müsste mal eine Tabelle mit dabei sein, in der die Zuordnung Wert<->Kodierung hinterlegt ist. Dann brauchst du jeweils die passende Umrechnung. Da wird einfach der Speicher im Arduino irgendwann zu klein sein, um das zu erfüllen.

        Eine direkte Umsetzung auf KNX ist auch eher schwierig. Die Anbindung an KNX erfolgt mE auch über einen RS485-Wandler. Die Wandler kommunizieren per seriellem Port mit dem Arduino. Also brauchst du schon 2 serielle Ports. Und auch hier muss im Vorfeld die og Umrechnung der Daten erfolgen.
        Ausserdem ist eine direkte Ausgabe auf den KNX-Bus garnicht so wichtig. Bringt ja nur eine Anzeige der aktuellen Daten. Wichtiger ist (zumindest für mich) das loggen der Daten. Und dazu muss sowieso ein Rechner laufen und der kann ja dann die Umgerechneten Daten auf den Bus senden.

        Zumindest ist das mein Plan: Auslesen und protokollieren der Daten auf meinem ohnehin laufendem 24/7 laufenden Server (Fujitsu Futro S550 Thin Client, unter 20€ bei Ebay, unter 10W Leistungsaufnahme) und dann bei Bedarf die Daten für eine Visu auch per Script und ohnehin vorhandenem KNX-IP Router auf dem Bus schieben.

        Kommentar


          #19
          Wie? Funktioniert der GW jtzt nicht und man kann keine Werte auslesen und die Anlage steuern?..
          bez knx. Man könnte gleich auf KNX IP ausgeben. Es hat eher jeder einen IP GW für Visus und dann spart man die TP Schnittstelle

          Kommentar


            #20
            Unter openhab kann man wohl Daten lesen und schreiben. Momentan allerdings keine 1155/1255 sondern nur ältere bis 1145/1245.
            Ich mag jedoch kein openhab. Daher suche ich eine Lösung um zunächst erstmal Daten aus der WP zu lesen und möglichst Platformneutral aufzubereiten.
            Jede Visu die ich bisher gesehen habe, läuft auf einen 24/7 Server. Daher kann dieser Server auch die Datenaufbereitung übernehmen. Damit ist eine direkte Ausgabe auf KNX mE überflüssig.
            Und die Daten müssen aufbereitet werden, da Nibe bei seinem RS485/Modbus doch zT sehr eigene Formate nutzt.
            Ausserdem müssen die Daten für die Ausgabe auf KNX wiederum in ihr eigenes Format entsprechend den gewünschten DPT-Typen umgesetzt werden.
            Ein Arduino ist wahrscheinlich damit hoffnungslos überfordert.


            Wie aber gesagt, ich möchte erstmal Daten lesen. Sollte jemand weiter Programmieren können und wollen, so ist er herzlichst eingeladen.
            Unter anderem dazu habe ich das Thema hier gestartet in der Hoffnung, das jemand Lust bekommt weiter zu machen.
            Denn letztendlich ahbe ich von Programmierung keine Ahnung.
            Das einzigste Mal , wo ich tatsächlich etwas Programierung gelernt habe, war in meiner Jugend "Basic" auf einem Z1013.
            Zuletzt geändert von elelom; 12.01.2019, 08:33.

            Kommentar


              #21
              So, momentaner Stand ist, das auch ein 2. GW den selben Bitfehler erzeugt. Ein "5C" wird doppelt ausgegeben als "5C5C".
              Momentan ist keine Umsetzung von 32-Bit Werten drin.

              Aktueller Stand mit 13 für mich relevanten Daten:
              Code:
              #/!bin/bash
              
              #Umrechnung (s16)
              function s16(){
                ein="$1"
                ein=$(echo 'obase=10;ibase=16;'$ein | bc)
                  if (( $ein > 32767 )); then
                  kon=(-65536)
                ein=$(echo "$kon+$ein" | bc -l)
              fi
              echo $ein
              }
              
              #Umrechnung (u16)
              function u16(){
                ein="$1"
                ein=$(echo 'obase=10;ibase=16;'$ein | bc)
                echo $ein
              }
              
              #Umrechnung (s8)
              function s8(){
                ein="$1"
                ein=$(echo $ein | cut -b 3-4)
                ein=$(echo 'obase=10;ibase=16;'$ein | bc)
                 if (( $ein > 256 )); then
                 kon=(-256)
                ein=$(echo "$kon+$ein" | bc -l)
                fi
                echo $ein
              }
              
              #Umrechnung (u8)
              function u8(){
                ein="$1"
                ein=$(echo $ein | cut -b 3-4)
                ein=$(echo 'obase=10;ibase=16;'$ein | bc)
                echo $ein
              }
              
              ###########
              
              cd /var/hausdaten                                                             #ins richtige verzeichniss wechseln, bei mir zB /var/udpempf
              
              /usr/sbin/tcpdump -i enp8s0 udp port 9999 and greater 80 -c 1 -w hexroh.txt   #Datenstrom aus UDP auslesen in Datei schreiben, Netzwerkkarte muss angepasst werden
              dathex=$(xxd -plain -cols 9999 -u hexroh.txt)                                 #geschriebene Datei mit xxd als Hex-Code in Variable einlesen
              rm hexroh.txt                                                                 #Hilsdatei löschen
              daten=$( echo $dathex | cut -b 175-)                                          #unwichtigen Teil vor den Messwerte ausschneiden
              daten=$(echo $daten | sed 's/5C5C/5C/')                                       #Fehler doppeltes 5C entfernen
              
              #Ende Daten lesen
              #################
              
              #Wert 1
              bez011=$( echo $daten | cut -b 1-2)                                           #Nibe hat scheinbar die Bytes vertauscht, im Datenstrom steht immer die Bezeichnung und der dazugehörige Wert hintereinander
              bez012=$( echo $daten | cut -b 3-4)                                           #Die Bezeichnungen und Datentypen findet man im Modbus-Manager
              bez01k=$bez012$bez011                                                         #hier werden die Bytes richtig zusammengesetzt
              bez01=$(echo "obase=10; ibase=16; $bez01k" | bc)                              #Und das ganze jetzt 20 mal für alle möglichen Daten
              wer011=$( echo $daten | cut -b 5-6)
              wer012=$( echo $daten | cut -b 7-8)
              wer01k=$wer012$wer011
              wer01=$(s16 $wer01k)                                                          #Umrechnung entspr. dem Datentyp Modbusmanager
              
              #Wert 2
              bez021=$( echo $daten | cut -b 9-10)
              bez022=$( echo $daten | cut -b 11-12)
              bez02k=$bez022$bez021
              bez02=$(echo "obase=10; ibase=16; $bez02k" | bc)
              wer021=$( echo $daten | cut -b 13-14)
              wer022=$( echo $daten | cut -b 15-16)
              wer02k=$wer022$wer021
              wer02=$(s16 $wer02k)
              
              #Wert 3
              bez031=$( echo $daten | cut -b 17-18)
              bez032=$( echo $daten | cut -b 19-20)
              bez03k=$bez032$bez031
              bez03=$(echo "obase=10; ibase=16; $bez03k" | bc)
              wer031=$( echo $daten | cut -b 21-22)
              wer032=$( echo $daten | cut -b 23-24)
              wer03k=$wer032$wer031
              wer03=$(s16 $wer03k)
              
              #Wert 4
              bez041=$( echo $daten | cut -b 25-26)
              bez042=$( echo $daten | cut -b 27-28)
              bez04k=$bez042$bez041
              bez04=$(echo "obase=10; ibase=16; $bez04k" | bc)
              wer041=$( echo $daten | cut -b 29-30)
              wer042=$( echo $daten | cut -b 31-32)
              wer04k=$wer042$wer041
              wer04=$(s16 $wer04k)
              
              #Wert 5
              bez051=$( echo $daten | cut -b 33-34)
              bez052=$( echo $daten | cut -b 35-36)
              bez05k=$bez052$bez051
              bez05=$(echo "obase=10; ibase=16; $bez05k" | bc)
              wer051=$( echo $daten | cut -b 37-38)
              wer052=$( echo $daten | cut -b 39-40)
              wer05k=$wer052$wer051
              wer05=$(s16 $wer05k)
              
              #Wert 6
              bez061=$( echo $daten | cut -b 41-42)
              bez062=$( echo $daten | cut -b 43-44)
              bez06k=$bez062$bez061
              bez06=$(echo "obase=10; ibase=16; $bez06k" | bc)
              wer061=$( echo $daten | cut -b 45-46)
              wer062=$( echo $daten | cut -b 47-48)
              wer06k=$wer062$wer061
              wer06=$(s16 $wer06k)
              
              #Wert 7
              bez071=$( echo $daten | cut -b 49-50)
              bez072=$( echo $daten | cut -b 51-52)
              bez07k=$bez072$bez071
              bez07=$(echo "obase=10; ibase=16; $bez07k" | bc)
              wer071=$( echo $daten | cut -b 53-54)
              wer072=$( echo $daten | cut -b 55-56)
              wer07k=$wer072$wer071
              wer07=$(s16 $wer07k)
              
              #Wert 8
              bez081=$( echo $daten | cut -b 57-58)
              bez082=$( echo $daten | cut -b 59-60)
              bez08k=$bez082$bez081
              bez08=$(echo "obase=10; ibase=16; $bez08k" | bc)
              wer081=$( echo $daten | cut -b 61-62)
              wer082=$( echo $daten | cut -b 63-64)
              wer08k=$wer082$wer081
              wer08=$(u8 $wer08k)
              
              #Wert 9
              bez091=$( echo $daten | cut -b 65-66)
              bez092=$( echo $daten | cut -b 67-68)
              bez09k=$bez092$bez091
              bez09=$(echo "obase=10; ibase=16; $bez09k" | bc)
              wer091=$( echo $daten | cut -b 69-70)
              wer092=$( echo $daten | cut -b 71-72)
              wer09k=$wer092$wer091
              wer09=$(u16 $wer09k)
              
              #Wert 10
              bez101=$( echo $daten | cut -b 73-74)
              bez102=$( echo $daten | cut -b 75-76)
              bez10k=$bez102$bez101
              bez10=$(echo "obase=10; ibase=16; $bez10k" | bc)
              wer101=$( echo $daten | cut -b 77-78)
              wer102=$( echo $daten | cut -b 79-80)
              wer10k=$wer102$wer101
              wer10=$(u8 $wer10k)
              
              #Wert 11
              bez111=$( echo $daten | cut -b 81-82)
              bez112=$( echo $daten | cut -b 83-84)
              bez11k=$bez112$bez111
              bez11=$(echo "obase=10; ibase=16; $bez11k" | bc)
              wer111=$( echo $daten | cut -b 85-86)
              wer112=$( echo $daten | cut -b 87-88)
              wer11k=$wer112$wer111
              wer11=$(s16 $wer11k)
              
              #Wert 12
              bez121=$( echo $daten | cut -b 89-90)
              bez122=$( echo $daten | cut -b 91-92)
              bez12k=$bez122$bez121
              bez12=$(echo "obase=10; ibase=16; $bez12k" | bc)
              wer121=$( echo $daten | cut -b 93-94)
              wer122=$( echo $daten | cut -b 95-96)
              wer12k=$wer122$wer121
              wer12=$(s16 $wer12k)
              
              #Wert 13
              bez131=$( echo $daten | cut -b 97-98)
              bez132=$( echo $daten | cut -b 99-100)
              bez13k=$bez132$bez131
              bez13=$(echo "obase=10; ibase=16; $bez13k" | bc)
              wer131=$( echo $daten | cut -b 101-102)
              wer132=$( echo $daten | cut -b 103-104)
              wer13k=$wer132$wer131
              wer13=$(s16 $wer13k)
              
              #Wert 14
              bez141=$( echo $daten | cut -b 105-106)
              bez142=$( echo $daten | cut -b 107-108)
              bez14k=$bez142$bez141
              bez14=$(echo "obase=10; ibase=16; $bez14k" | bc)
              wer141=$( echo $daten | cut -b 109-110)
              wer142=$( echo $daten | cut -b 111-112)
              wer14k=$wer142$wer141
              wer14=$(echo "obase=10; ibase=16; $wer14k" | bc)
              
              #Wert 15
              bez151=$( echo $daten | cut -b 113-114)
              bez152=$( echo $daten | cut -b 115-116)
              bez15k=$bez152$bez151
              bez15=$(echo "obase=10; ibase=16; $bez15k" | bc)
              wer151=$( echo $daten | cut -b 117-118)
              wer152=$( echo $daten | cut -b 119-120)
              wer15k=$wer152$wer151
              wer15=$(echo "obase=10; ibase=16; $wer15k" | bc)
              
              #Wert 16
              bez161=$( echo $daten | cut -b 121-122)
              bez162=$( echo $daten | cut -b 123-124)
              bez16k=$bez162$bez161
              bez16=$(echo "obase=10; ibase=16; $bez16k" | bc)
              wer161=$( echo $daten | cut -b 125-126)
              wer162=$( echo $daten | cut -b 127-128)
              wer16k=$wer162$wer161
              wer16=$(echo "obase=10; ibase=16; $wer16k" | bc)
              
              #Wert 17
              bez171=$( echo $daten | cut -b 129-130)
              bez172=$( echo $daten | cut -b 131-132)
              bez17k=$bez172$bez171
              bez17=$(echo "obase=10; ibase=16; $bez17k" | bc)
              wer171=$( echo $daten | cut -b 133-134)
              wer172=$( echo $daten | cut -b 135-136)
              wer17k=$wer172$wer171
              wer17=$(echo "obase=10; ibase=16; $wer17k" | bc)
              
              #Wert 18
              bez181=$( echo $daten | cut -b 137-138)
              bez182=$( echo $daten | cut -b 139-140)
              bez18k=$bez182$bez181
              bez18=$(echo "obase=10; ibase=16; $bez18k" | bc)
              wer181=$( echo $daten | cut -b 141-142)
              wer182=$( echo $daten | cut -b 143-144)
              wer18k=$wer182$wer181
              wer18=$(echo "obase=10; ibase=16; $wer18k" | bc)
              
              #Wert 19
              bez191=$( echo $daten | cut -b 145-146)
              bez192=$( echo $daten | cut -b 147-148)
              bez19k=$bez192$bez191
              bez19=$(echo "obase=10; ibase=16; $bez19k" | bc)
              wer191=$( echo $daten | cut -b 149-150)
              wer192=$( echo $daten | cut -b 151-152)
              wer19k=$wer192$wer191
              wer19=$(echo "obase=10; ibase=16; $wer19k" | bc)
              
              #Wert 20
              bez201=$( echo $daten | cut -b 153-154)
              bez202=$( echo $daten | cut -b 155-156)
              bez20k=$bez202$bez201
              bez20=$(echo "obase=10; ibase=16; $bez20k" | bc)
              wer201=$( echo $daten | cut -b 157-158)
              wer202=$( echo $daten | cut -b 159-160)
              wer20k=$wer202$wer201
              wer20=$(echo "obase=10; ibase=16; $wer20k" | bc)
              
              cd /var/hausdaten/variablen
              
              echo -n $wer01 > $bez01                              #nun die errechneten Datenpunke und Werte in die Dateien schreiben
              echo -n $wer02 > $bez02
              echo -n $wer03 > $bez03
              echo -n $wer04 > $bez04
              echo -n $wer05 > $bez05
              echo -n $wer06 > $bez06
              echo -n $wer07 > $bez07
              echo -n $wer08 > $bez08
              echo -n $wer09 > $bez09
              echo -n $wer10 > $bez10
              echo -n $wer11 > $bez11
              echo -n $wer12 > $bez12
              echo -n $wer13 > $bez13
              echo -n $wer14 > $bez14
              echo -n $wer15 > $bez15
              echo -n $wer16 > $bez16
              echo -n $wer17 > $bez17
              echo -n $wer18 > $bez18
              echo -n $wer19 > $bez19
              echo -n $wer20 > $bez20
              
              #echo "$(date +%d.%m.%Y);$(date +%H:%M);$bez01;$bez02;$bez03;$bez04;$bez05;$bez06;$bez07;$bez08;$bez09;$bez10;$bez11;$bez12;$bez13;$bez14;$bez15;$bez16;$bez17;$bez18;$bez19;$bez20" >> nibe1155.csv
              
              
              echo "$(date +%d.%m.%Y);$(date +%H:%M);$wer01;$wer02;$wer03;$wer04;$wer05;$wer06;$wer07;$wer08;$wer09;$wer10;$wer11;$wer12;$wer13;$wer14;$wer15;$wer16;$wer17;$wer18;$wer19;$wer20" >> nibe1155.csv
              Mit diesen Script werden die Daten auf den Bus geschickt


              Code:
              #!/bin/bash
              
              
              #####################
              dec2dpt96()
              {
              ein="$1"
              expo=6
              exp_ges=`echo "scale=0; 2^($expo)" | bc -l`
              ein=`echo "scale=0; $ein * 100" | bc` #erweitern auf 1/100
              ein=`echo "scale=0; $ein / $exp_ges" | bc` #Mantisse berechnen
              
              # Vorzeichen bestimmen
              wahr=$(echo  "$ein >  0 " | bc)
               if  [ $wahr = 1 ]; then
                  vz=0
                 else
                  vz=1
                  eina=`echo "-2048 - $ein" | bc`
                  ein=`echo "$eina * -1" | bc`
               fi
              
              man_bin=`echo "obase=2; $ein" | bc` #Mantisse nach bin
              man11=`echo $man_bin | awk '{printf("%.11u\n", $1)}'` #bin bei bedarf auf 11 Stellen erweitern
              exp_bin=`echo "obase=2; $expo" | bc`
              exp4=`echo $exp_bin | awk '{printf("%.4u\n", $1)}'` #expo auf 4 stellen erweitern
              binresult=$vz$exp4$man11 #komplette bin zusammensetzen
              hexresult=$(echo 'obase=16;ibase=2;'$binresult | bc) #nach hex umrechnen
              hex=`echo ${hexresult:0:2}" "${hexresult:2:2}` #Leerstelle einfugen
              echo $hex
              }
              
              #########################
              dpt92dec(){
              knx="$1"
              hex01=${knx: -6:2}
              hex02=${knx: -3}
              dec01=$(echo "obase=2; ibase=16; $hex01" | bc )
              dec01=$( echo $dec01 | awk '{printf("%.8u\n", $1)}' )
              # auf 8 stellen erweitern, bc macht das nicht von selbst
              dec02=$(echo "obase=2; ibase=16; $hex02" | bc )
              dec02=$( echo $dec02 | awk '{printf("%.8u\n", $1)}' )
              # auf 8 stellen erweitern, bc macht das nicht von selbst
              bin01=$dec01$dec02
              hex03=$(echo "obase=10; ibase=2; $bin01" | bc )
              exp01=`expr substr $bin01 1 4`
              man01=`expr substr $bin01 5 15`
              exp02=$(echo "obase=10; ibase=2; $exp01" | bc )
              man02=$(echo "obase=10; ibase=2; $man01" | bc )
              tmp_float1=`echo "0.01 * ${man02}" | bc -l`
              tmp_float2=`echo "scale=0; 2^($exp02)" | bc -l`
              tmp_float=`echo "${tmp_float1} * ${tmp_float2}" | bc -l`
              tmp_float=`echo "1000 * ${tmp_float}" | bc -l`
              tmp_float=`echo "scale=0; ${tmp_float} / 1" | bc`
              echo $tmp_float
              }
              ####################
              dec2dpt9()
              {
              ein="$1"
              expo=3
              exp_ges=`echo "scale=0; 2^($expo)" | bc -l`
              ein=`echo "scale=0; $ein * 100" | bc` #erweitern auf 1/100
              ein=`echo "scale=0; $ein / $exp_ges" | bc` #Mantisse berechnen
              
              # Vorzeichen bestimmen
              wahr=$(echo  "$ein >  0 " | bc)
               if  [ $wahr = 1 ]; then
                  vz=0
                 else
                  vz=1
                  eina=`echo "-2048 - $ein" | bc`
                  ein=`echo "$eina * -1" | bc`
               fi
              
              man_bin=`echo "obase=2; $ein" | bc` #Mantisse nach bin
              man11=`echo $man_bin | awk '{printf("%.11u\n", $1)}'` #bin bei bedarf auf 11 Stellen erweitern
              exp_bin=`echo "obase=2; $expo" | bc`
              exp4=`echo $exp_bin | awk '{printf("%.4u\n", $1)}'` #expo auf 4 stellen erweitern
              binresult=$vz$exp4$man11 #komplette bin zusammensetzen
              hexresult=$(echo 'obase=16;ibase=2;'$binresult | bc) #nach hex umrechnen
              hex=`echo ${hexresult:0:2}" "${hexresult:2:2}` #Leerstelle einfugen
              echo $hex
              }
              ########################
              
              
              
              
              
              cd /var/hausdaten/variablen
              
              
              
              #Sole-VL
              SoleVL=$(cat 40015)
              SoleVL=$(echo "$SoleVL/10" | bc -l)
              SoleVL=$(dec2dpt9 $SoleVL)
              knxtool groupwrite ip:localhost 14/2/1 $SoleVL
              
              #Sole-RL
              SoleRL=$(cat 40016)
              SoleRL=$(echo "$SoleRL/10" | bc -l)
              SoleRL=$(dec2dpt9 $SoleRL)
              knxtool groupwrite ip:localhost 14/2/2 $SoleRL
              
              #Heiz-VL
              HeizVL=$(cat 40008)
              HeizVL=$(echo "$HeizVL/10" | bc -l)
              HeizVL=$(dec2dpt9 $HeizVL)
              knxtool groupwrite ip:localhost 14/2/3 $HeizVL
              
              #Heiz-RL
              HeizRL=$(cat 40012)
              HeizRL=$(echo "$HeizRL/10" | bc -l)
              HeizRL=$(dec2dpt9 $HeizRL)
              knxtool groupwrite ip:localhost 14/2/4 $HeizRL
              
              #AussenTemp
              Aussen=$(cat 40004)
              Aussen=$(echo "$Aussen/10" | bc -l)
              Aussen=$(dec2dpt9 $Aussen)
              knxtool groupwrite ip:localhost 14/2/5 $Aussen
              
              #Wasser
              Wasser=$(cat 40014)
              Wasser=$(echo "$Wasser/10" | bc -l)
              Wasser=$(dec2dpt9 $Wasser)
              knxtool groupwrite ip:localhost 14/2/6 $Wasser
              
              #Innen
              Innen=$(cat 40033)
              Innen=$(echo "$Innen/10" | bc -l)
              Innen=$(dec2dpt9 $Innen)
              knxtool groupwrite ip:localhost 14/2/7 $Innen
              
              #Komp-Freq
              komfre=$(cat 43136)
              komfre=$(echo "$komfre/10" | bc -l)
              komfre=$(dec2dpt9 $komfre)
              knxtool groupwrite ip:localhost 14/2/9 $komfre
              
              #Solepump
              solepu=$(cat 43439)
              solepu=$(dec2dpt9 $solepu)
              knxtool groupwrite ip:localhost 14/2/8 $solepu
              
              #Gradminuten
              gradmi=$(cat 43005)
              gradmi=$(echo "$gradmi/10" | bc -l)
              gradmi=$(dec2dpt96 $gradmi)
              knxtool groupwrite ip:localhost 14/2/11 $gradmi
              
              #Heizkreispumpe
              heizpu=$(cat 43437)
              heizpu=$(dec2dpt9 $heizpu)
              knxtool groupwrite ip:localhost 14/2/10 $heizpu
              
              #Volumen
              Volumen=$(cat 40072)
              Volumen=$(echo "$Volumen/10" | bc -l)
              Volumen=$(dec2dpt9 $Volumen)
              knxtool groupwrite ip:localhost 14/2/12 $Volumen
              
              #Alarm
              Alarm=$(cat 45001)
              Alarm=$(dec2dpt9 $Alarm)
              knxtool groupwrite ip:localhost 14/2/13 $Alarm
              Beide Scripte laufen als cronjob jede Minute.






              Kommentar


                #22
                Zitat von elelom Beitrag anzeigen
                Es geht ja schon damit los, das Nibe insgesamt 6 Datenformate für seine Werte hat (u8,u16,u32,s8,s16,s32) und die dann auch noch in Orginalwert oder in 1/10 Wert kodiert.
                Die NibeUplink API gibt einige Informationen zur Formatierung mit aus, wenn du Werte abfragst. Daran würde ich mich entlang hangeln.

                Zitat von elelom Beitrag anzeigen
                Und die Daten müssen aufbereitet werden, da Nibe bei seinem RS485/Modbus doch zT sehr eigene Formate nutzt.
                KNX/IP wäre mein Favorit. Da gibt es schon Stacks, die man portieren müsste. Da ich selbst momentan keine Zeit dafür habe, werde ich erst mal den Weg per UDP gehen.

                Zitat von elelom Beitrag anzeigen
                Ein Arduino ist wahrscheinlich damit hoffnungslos überfordert.
                Kommt auf "den" Arduino an. Und die Software die man dafür schreibt. Je nach Menge der Modbus register und GAs die man unterstützen möchte, könnte Speicher ein Thema werden.
                Bin mit Arduino eher unerfahren und aus dem Alltag leistungsfähigere embedded uCs gewohnt. Aber der ATSAMD21G18 sieht für mich nicht komplett undersized aus für das Vorhaben.


                Kommentar


                  #23
                  Zitat von DerSeppel Beitrag anzeigen
                  Die NibeUplink API gibt einige Informationen zur Formatierung mit aus, wenn du Werte abfragst. Daran würde ich mich entlang hangeln.


                  KNX/IP wäre mein Favorit. Da gibt es schon Stacks, die man portieren müsste. Da ich selbst momentan keine Zeit dafür habe, werde ich erst mal den Weg per UDP gehen.


                  Kommt auf "den" Arduino an. Und die Software die man dafür schreibt. Je nach Menge der Modbus register und GAs die man unterstützen möchte, könnte Speicher ein Thema werden.
                  Bin mit Arduino eher unerfahren und aus dem Alltag leistungsfähigere embedded uCs gewohnt. Aber der ATSAMD21G18 sieht für mich nicht komplett undersized aus für das Vorhaben.

                  Meine Programmierkünste auf einen µC sind auch schon 17 Jahre her und waren eher dürftig! Damit bring ich nix mehr auf die Reihe!
                  Wenn wer so was bauen könntet, ihr würdet viele Abnehmer finden(Energiesparhausforum zb)! Ich würd auf jeden Fall so was haben wollen und dafür auch was bezahlen !
                  Du könntest das auch auf einer leistungsfähigeren Plattform bauen !! Muss ja kein Standard Arduino sein!


                  Unter openhab kann man wohl Daten lesen und schreiben. Momentan allerdings keine 1155/1255 sondern nur ältere bis 1145/1245.
                  Die sollten eig gleich sein, bis auf das das die 1x55er Pumpe die modulierende ist und damit sollte nix anders sein!
                  Zuletzt geändert von uzi10; 14.01.2019, 14:38.

                  Kommentar


                    #24
                    Die Unrechnung u8, u16, s8, s16 habe ich drin (jeweils als Funktion im Script). Die 32-Bit Werte könnte man sicherlich auch problemlos mit reinnehmen. Ich brauche sie jedoch nicht.
                    Über 32-Bit Werte werden nur Statistikdaten übertragen wie zB Gesamtlaufzeit oder Gesamtwärmemenge. Diese Werte benötige ich jedoch nur 1x im Monat und dann hole ich sie mir aus dem Nibe-Uplink.

                    Die Implementierung der 1x55 unter openhab2 scheitert momentan daran, das die für eine modulierende WP neuen Datenpunkte wie zB Drehzahl der Pumpen oder des Kompressors einfach noch nicht hinterlegt sind. Also braucht man dort auch wieder eine Tabelle mit den Datenpunkten und der dazugehörigen Kodierung.

                    KNX/IP ist ein reizvoller Gedanke, aber es widerstrebt mir, alle 2 Sek die 20 Datenpunkte auf den Bus zu schieben und damit eine doch nicht unerhebliche Datenmenge auf Bus zu erzeugen. Ich befürchte da doch ein ziemliches zumüllen des KNX-Bus.

                    Daher (und auch weil meine Zeit momentan wieder etwas enger wird) ist der aktuelle Stand für mich erstmal das Ende des Projekt.

                    Kommentar


                      #25
                      Zur Ergänzung noch mein 2. Gateway, diesmal mit einem Arduino Pro, W5100 Ethernet-Shield, RS485-Wandler und Step-Down Regler. Der Stepdown ist für die Stromversorgung des Gateways aus der Nibe. Neben den Anschlüssen für den Modbus ist auch eine 12V-Stromversorgung, die ich für das Gateway nutze. 20190111_204912.jpg

                      Kommentar


                        #26
                        So, so sehen die über das Gateway über 24h gewonnen Daten aufbereitet aus:
                        Oben die Temperaturen, darunter die Drehzahlen der Pumpen in % und des Verdichters in Hz und unten die dazugehörige Leistungsaufnahme.
                        1701.jpg
                        Ich muss nur noch sehen , wie ich die Drehzahlen und die Leistungsaufnahme in eine Grafik bekomme.

                        MfG

                        Jens

                        Kommentar


                          #27
                          Schaut Euch mal den Nibe Modbus Manager an, ist eine Windows Software mit der man die proprietäre Modbus-Erweiterung konfigurieren kann (bzw. was die Heizung von sich auch auf den Modbus schicken soll). Anyways, das Tool enthält jedoch alle verfügbaren Register und zugehörigen Datentypen. Einige sind zur 1145 gleich, so dass das aktuelle binding diese Werte auch von einer 1255 abfragen kann. Um alles abfragen zu können muss man das openHab binding mit den Registern der 1255 entsprechend erweitern.

                          Kommentar


                            #28
                            Zitat von klayman Beitrag anzeigen
                            Schaut Euch mal den Nibe Modbus Manager an, .
                            Richtig, damit sage ich der WP, welche Daten Sie über den Bus schicken soll. Auch habe ich mir daher die Codierung der einzelnen Datenpunkte rausgelesen.
                            Ich konnte mich nur mit openhab2 nicht anfreunden. Unter anderem auch weil die Datenpunkte für die 1x55 noch nicht alle drin sind wie zB Drehzahl der Pumpen und des Verdichters. Und das openhab- Binding erweitern ist mir dann doch etwas zu hoch.

                            Kommentar


                              #29
                              Zitat von elelom Beitrag anzeigen
                              [...] das openhab- Binding erweitern ist mir dann doch etwas zu hoch
                              Wenn ein natives KNX-Interface einfacher ist, dann nur zu . Ich hatte ehrlich gesagt auch schon daran gedacht so etwas zu basteln, muss aber meine Programmierkenntnisse erstmal wieder auffrischen... Das openHab Binding kann wohl auch weitere Register (über die 20 hinaus) von der WP abfragen und beschreiben. Man kommt also u.U. auch ohne vorheriges Konfigurieren der WP aus.

                              Ein Problem (unter vielen) das ich dabei sehe: Je nach dem welche Register ich haben möchte, ändert sich die Länge des Rückgabewerts und damit der Datentyp eines Kommunikationsobjekts. Man kann also nicht einfach 20 (oder wie viele auch immer) Kommunikationsobjekte definieren und den Benutzer auswählen lassen welche Register er damit zurückgeliefert bekommt. Will man wirklich alle Register ermöglichen, bräuchte man nur am Beispiel der F1255 schon 345 16-Bit KOs, 47 32-Bit KOs, 584 8-Bit KOs. Ich glaub das sind auch für die BCU2 zu viele ;-) Alternativ müsste man sich auf eine sinnvolle Kombination beschränken. Allerdings ist bei der BCU1 wohl schon bei 31 KOs Schluss. Weiß nicht was z.B. thesing implementiert hat. Bei selfbus gibts auch die BCU2. Da könnte man dann z.B. 20 8-Bit, 40 16-Bit und 10 32-Bit KOs defnieren, die der Nutzer dann frei zuweisen kann.
                              Zuletzt geändert von klayman; 19.01.2019, 09:22.

                              Kommentar


                                #30
                                Hallo der Stack von mir ist derzeit auf 255 KO beschränkt. Es wären aber nur ein paar Zeile Code zu ändern, wenn man 2^16 KOs haben will. Es ist ein (fast) kompletter SystemB Stack.
                                Zuletzt geändert von thesing; 19.01.2019, 11:29.

                                Kommentar

                                Lädt...
                                X