Nibe GW ohne openhab

[uzi10]

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?

[ur63]

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...

[elelom]

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.

[uzi10]

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

[elelom]

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.

[elelom]

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:

#/!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

#!/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.

[DerSeppel]

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.

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.

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.

[uzi10]

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!

[elelom]

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.

[elelom]

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

[elelom]

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

[klayman]

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.

[elelom]

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.

[klayman]

[...] 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.

[thesing]

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.