Bus Protokoll Körting/EBV Gamma 2B

[Tim G. (timg)]

Hallo,

ich besitze als Heizungssteuerung eine Körting Gamma 2B und bin an dem 
Protokoll interessiert, das die über RS485 spricht. Ich habe mal meine 
bisherigen Informationen und Code-Zeilen in ein Github-Repository und 
Wiki unter https://github.com/bogeyman/gamma/wiki gesammelt.

Ich habe einen RaspberryPi und einen USB-RS485 Dongle geholt und mir 
eine ganze Weile aus Spaß die Bytes angeguckt, die da rausfallen. Nach 
ein wenig Programmieren und Probieren hab ich einen kleines Python 
Programm geschrieben, dass die Nachrichten etwas auswertet und loggt. 
Zurzeit bekomme ich Datum und Uhrzeit, drei Temperaturen und eine 
Handvoll noch nicht zugeordneter Werte von der Heizung. Die Brenn-Zeiten 
versuche ich gerade zu ermitteln. Ein kleines Munin Skipt zum grafischen 
Auswerten der Temperaturen ist auch dabei.

Wenn jemand eine Körting, EBV(, Hoval Toptronic?), Typen Gamma/KB 2B, 
23B, 233B, 223B, 2233B oder ähnliche hat und Lust hat zu helfen, wäre 
ich über ein Feedback sehr froh. Klar kann es gut sein, dass je nach 
EEPROM Version und Hersteller die sich ganz anders verhalten.

Richtig interessiert bin ich natürlich an Mitschnitten von der 
Raumstation RS-10 oder einer Steuersoftware, falls jemand dazu Zugriff 
hat. Dann wäre vielleicht ein schreibender Zugriff möglich zum Ändern 
der Warmwasser Temperatur, Party-Taste-Emulation, usw. Wenn jemand ein 
EEPROM Dump hat, vielleicht lässt sich damit auch was anfangen ;)

Da meine Heizung plus Heizungssteuerung nicht mehr die neuste ist, habe 
ich aber nicht vor, z.B. viel Geld für eine Raumstation auszugeben. Ich 
gucke regelmäßig nach gebrauchen, aber die liegen meist um den original 
Preis und das bin ich nicht bereit zu investieren. Aber am Protokoll zu 
basteln macht jedoch noch genug Spaß, ich kann Daten auswerten, und 
vielleicht ist ja noch mehr möglich.

Schöne Grüße,
Tim

[NightFox (Gast)]

Hi,
Ich habe mir die Raumstation 10 vor einiger Zeit gekauft. Wollte anfangs 
auch was eigenes basteln, hatte jedoch nicht die Zeit dazu und noch 
nicht das benötigte know-how .... Mein Plan war es mal den Datenbus 
abzuhören um per SMS oä die Heizung steuern zu können. Habe leider bis 
mitte November wenig Zeit mich mit weiteren Projekten zu beschäftigen 
:-/ Es wäre hilfreich wenn du eine Verdrahtungsskizze des Pi's mit noch 
evtl. benötigter Hardware online stellen würdest, dann könnte ich mir 
das schnell nachbauen und ein paar Sachen dumpen =)

mfG

NighFox

[Tim G. (timg)]

Ich freu mich über jeden, der sich meldet. Ich hatte schon befürchtet, 
dass ich keinen mehr finde, der Interesse an der doch etwas betagten 
Hardware hat. Zeit ist immer ein knappes Gut, ist bei mir nicht anders. 
Um so schöner, dass Du eine Interesse (und Raumstation) hast. Ich bau in 
der nächsten Zeit mal die Mitmach-Seite im Wiki aus, damit jeder im 
besten Fall auch ohne Ahnung einfache Listen abarbeiten kann: Hardware 
bestellen, an Heizung anschließen, Pi einrichten. Ich schreib hier, wenn 
es was neues gibt.

Aus Interesse noch ein paar schnelle Fragen:
- Hast Du die Raumstation selber angeschlossen, oder das machen lassen? 
Anschluss über "Schraubklemmen" auf der Rückseite oder 5pol DIN Stecker?
- Wie ist die genaue Bezeichnung der Raumstation und Heizungsteuerung, 
am besten von der Bedienungsanleitung? Also Hersteller und Modellname
- Erfahrung Pi/Linux/Shell?

Schöne Grüße,
Tim

[NightFox (Gast)]

Hi,
Wenn ich alles aufgebaut habe sind ja schnell ein paar Szenarien 
durchgespielt und Protokollmitschnitte gezogen. Raspberrys hab ich noch 
genügend übrig ;) Ich brauche nur einen RS485 Adapter, kannst du mir da 
einen empfehlen, nicht dass ich mir schon die Uhr breche um den am 
Raspberry zum laufen zu bringen.
Zu deinen Fragen:
-Die RS habe ich selbst über die 4-polige Schraubklemme angeschlossen 
(leider über ein nicht-abgeschirmtes Kabel, ~6m, es sind bisher aber 
noch keine Probleme aufgetaucht)
-Die Heizungssteuerung ist die Gamma 2B, firmware version 1.09.
Von der "Raumstation Gamma RS-10" finde ich keine genauere Bezeichnung. 
Eventuell steht da mehr auf der Rückseite. Firmware 1.20
- Erfahrung mit Pi, Linux und Shell habe ich schon etwas.

mfG

[Tim G. (timg)]

Hi,

leider ist der Adapter, den ich damals geholt habe nicht mehr verfügbar. 
Aber eigentlich sollte jeder gehen, den Du bei Amazon/ebay/usw mit "usb 
rs485 adapter" findest, solange der Treiber beim Pi dabei ist. Ich habe 
mir zu testen mal einen zur Reseve bei ebay für unter 5 Euro direkt aus 
China geordert, dauert halt nur drei Wochen bis das ankommmt. Conrad und 
Reichelt und Co hab ich mir noch nicht angeguckt.

Zur Verkabelung und Inbetirebnahme hab ich schon was geschrieben, aber 
noch nicht im Wiki.  Bis zum Wochenende komm ich dazu, denke ich.

Schöne Grüße,
Tim

[Tim G. (timg)]

An alle Interessierten:

Ich habe mittlerweile ein paar Dumps bekommen, die schon sehr 
weiterhelfen. Ich bin gerade dabei etwas mehr Licht in das Protokoll zu 
bringen, hab aber noch keinen Stand den ich dokumentieren will.

Updates folgen unter
https://github.com/bogeyman/gamma/wiki

Schöne Grüße,
Tim

[Thomas (Gast)]

Hallo Tim,

ich habe inzwischen meinen (neuen) RasPi mit USB-Dongle an die RS485 
Schnittstelle der Heizung angeschlossen. Ich habe eine Körting KB233 
(V 1.03) mit RS10 Raumstation.

Nach ein bischen ausprobieren kann ich die Brenner, Vorlauf, Außen- und 
Wassertemperatur auslesen. Ebenso das Datum.
Nachrichtentypen sind 2004, 0905 und 4002 wie auch z.T. von Dir 
dokumentiert.

Realisiert habe ich dies mit Node-RED unter Iobroker zur Einbindung in 
die Hausautomatisierung. Nachdem ich 20 Jahre nicht mehr programmiert 
hatte, war die Hürde Javascript. Hat mich dann 2-3 Tage gekostet, die 
Syntax zu verstehen. Danach geht die Datenauswertung als reines 
Info-System unter Node-RED mit wenigen Zeilen Code.

Wie kann ich ggfs. noch unterstützen? Interessant wäre das Verändern der 
Parameter.

Viele Grüße
Thomas

[Tim G. (timg)]

Hallo Thomas,

das hört sich gut an. Iobroker kannte ich noch gar nicht, aber ich hab 
mal eine zeit lang Javascript beruflich entwickelt, das gucke ich mir 
mal an. Ich knabbere gerade ein wenig am Timing der Steuerung und der 
Raumstation (ich habe eine günstig überlassen bekommen). Da werden 
Bytes, die ich sende schon mal schnell ignoriert, wenn sie nicht 
punktgenau ankommen. Leider haben die USB-RS485 Dongles zum effizienten 
Übertragen vieler Daten über den USB Bus einen Timer btw. eine 
Minimum-Paketgröße bzw. ein bestimmbares Event-Byte, wann der Buffer vom 
Dongle an den Rechner übertragen wird. Und das macht erstmal mein Timing 
kaputt. Ich bin aber dran. (Zur Erklärung: bei 9600 baud mit Start und 
Stopbit kommt man auf knapp 1ms pro Byte, der Minimuntimer beim 
USB-Dongle ist auch 1ms. Das scheint auch grob die Toleranz bei der 
Raumstation und der Heizungssteuerung zu sein :/ )

Wenn mir die Simulation einer Heizungssteuerung gegen einer echten 
Raumstation oder die Simulation einer Raumstation gegen einer echten 
Heizungssteuerung gelingt, dann sind die Werte nur noch eine kleine 
Detektivarbeit.

Wen Du noch Erkenntnisse hast, die noch nicht unter 
https://github.com/bogeyman/gamma/wiki/Protokoll dokumentiert sind, sag 
mal Bescheid.

Magst Du mir Deinen Javascript mal geben, zum probieren? Im wiki steht 
auch eine email Adresse.

Wenn es einen Durchbruch gibt schreib ich auch nochmal hier.

Beste Grüße,
Tim

[Bernd (Gast)]

Hallo, mal eine ähnliche Frage. Ich hab ein gebrauchte KBM 233b gekauft. 
Da ist ein Code für die Fachmann Einstellung. Gibt es einen Weg den zu 
deaktivieren oder zurück zu setzen? Muss die Vorrang Einstellung ändern.

Grüße
Bernd

[Tim G. (timg)]

Hallo Bernd,

wir haben leider keinen Fachmann Ebenen Code. Für mich wäre der 
interessant, da man dort die Busadresse ändern könnte. Aus Erfahrung, da 
ich auch gesucht habe:

- Du findest häufig Aussagen, wie "Ich kenne den auch nicht , aber 
probier doch mal (0000|1234|0123|0815|0615|9999) oder Kombinationen 
daraus". Ich habe was rumprobiert, aber nach dem fünfzehnten Code macht 
das keinen Spaß mehr.

- Dann gibt es Leute in Foren, die sagen "Ich hab den Code jetzt, geb 
den aber nur via PM weiter". Abgeschrieben, nichts passiert. Beiträge 
waren aber auch in der Regel einige Jahre alt...

- Frag einen entsprechenden "Fachmann". Werde ich bei meiner 
Heizungswartung jetzt machen. ;) Klar, doof, kostet Geld. Und kann sein, 
dass der sagt, dass er das entsprechend einstellt, aber Dir den Code 
nicht verrät. Weil man da Sachen einstellen kann, die die Hardware auch 
eher kaputt machen können...

Hoffe es ist wenigstens eine kleine Hilfe,
Tim

[Thomas (Gast)]

Bei Körting ist der CODE 2129.
Je nach Hersteller aber unterschiedlich.

[Simon S. (simschmid)]

Wenn du eine RS-10 hast probiere mal das Zauberwort 0010, wenn du eine 
RS-30 hast 0030, hab ich mal so in einem anderen Forenbeitrag gesehen 
...

[Micha M. (bavilo)]

Gibt es hierzu updates?

Habe eine Ceta 104 und 106 von EBV. Währe echt dankbar wenn ich diese 
beiden über den Bus auslesen könnte.

[Tim G. (timg)]

Hallo zusammen,

mittlerweile habe ich verschiedene Daten von der Gamma und Ceta Serie 
bekommen (RS-485), die ich gerade in einen Parser einarbeite, damit die 
Leute möglichst viele Werte auslesen können. Bei der Theta Serie konnte 
mir noch niemand verraten, wie das Protokoll auf Hardware-Ebene 
funktioniert (T2B), so dass man das z.Z. gar nicht anschließen kann. Das 
Schreiben von Nachrichten ist noch nicht ganz gelöst, aber ich habe das 
Interesse noch nicht verloren ;) Da es aber darauf hinauslaufen wird, 
ein separates Programm oder Hardware neben der Heimautomatisierung 
nutzen zu müssen, tendiere ich gerade dazu die Werte z.B. via JSON zur 
Verfügung zu stellen, dann muss ich weniger Code pflegen. Updates sollen 
in den nächsten Wochen folgen...

Grüße, Tim

[Da geht was (Gast)]

Tim G. schrieb:
> Bei der Theta Serie konnte
> mir noch niemand verraten, wie das Protokoll auf Hardware-Ebene
> funktioniert (T2B), so dass man das z.Z. gar nicht anschließen kann.

Das Signal wird über einen Trafo ausgekoppelt. Auf der Theta findest du 
hinter der Abdeckung oben rechst eine Debug-Schnittstelle. Dort liegt 
das Signal vom UART (µC) mit Logikpegel.

[Tim G. (timg)]

Da geht was schrieb:
> Tim G. schrieb:
>> Bei der Theta Serie konnte
>> mir noch niemand verraten, wie das Protokoll auf Hardware-Ebene
>> funktioniert (T2B), so dass man das z.Z. gar nicht anschließen kann.
>
> Das Signal wird über einen Trafo ausgekoppelt. Auf der Theta findest du
> hinter der Abdeckung oben rechst eine Debug-Schnittstelle. Dort liegt
> das Signal vom UART (µC) mit Logikpegel.
Ich habe leider selber keinen Zugriff auf eine Theta. Hast Du noch ein 
paar mehr Infos dazu? Hat die debug Schnittstelle einen Stecker? Ist das 
RS485 in nicht Standard? Mir würde es darum gehen, dass andere genug 
Infos bekommen, um irgendwelche Adapter anschließen zu können. Wäre 
spannend...

[Da geht was (Gast)]

Tim G. schrieb:
> Hat die debug Schnittstelle einen Stecker

Es handelt sich um eine Buchsenleiste. Mit einem RS232 Wandler kannst du 
dort die Kommunikation mit lesen.

Ich muss erst wühlen bevor ich an die alten Adapter komme. Auf der 
Platine kann man die Rx/Tx Leitungen gut nachverfolgen.

[Tim G. (timg)]

Schick! +5v/-5v? Hmm, ich hätte da eine Wunschliste: Ein Foto vom 
Anschluss zum Veröffentlichen auch gern via Mail und ein RAW dump der 
Daten ;) wäre super!

[Da geht was (Gast)]

Tim G. schrieb:
> +5v/-5v?

Nö, direkt von den Ports abgegriffen. Also nur Logik.


Tim G. schrieb:
> Ein Foto vom
> Anschluss

Klapp den Deckel auf. ;-)


Tim G. schrieb:
> RAW dump der
> Daten

Wenn ich viel Langeweile habe, kram ich das Zeug mal wieder raus. Meine 
Motivation für das Thema ist mikroskopisch.

[Tim G. (timg)]

Da geht was schrieb:
> Tim G. schrieb:
>> +5v/-5v?
>
> Nö, direkt von den Ports abgegriffen. Also nur Logik.
>
"Logikpegel", Mist, wer lesen kann, ist klar im Vorteil.

Aber der Hinweis ist schonmal Gold wert, wenn jemand anders eine Theta 
hat uns sich dran versuchen will. Ich bastel erstmal auf meinen 
Baustellen weiter...

[Micha M. (bavilo)]

Hört sich vielversprechend an!

Ich hatte dir die Logs der CETA geschickt. Wenn du noch mehr brauchst 
sag einfach Bescheid.

[Sulla (Gast)]

Hallo!
Ich habe eine Hoval RS-10 Raumsteuerung für einen Hoval TopTronic 23B 
Controller an einem Holz-Stückgut-Brenner Hoval Agrolyt 20.

Der Hoval Holzbrenner hat verschiedene Betriebsstatus, die er auf seinem 
kleinen Kesseldisplay (das ist nur ein LED-Display) kund tut.
1 = Anheizphase
2 = volle Leistung
...
5 = Ausbrand
6 = Kessel-Restwärmeausnutzung
7 = Temperatur im Kessel zu hoch
8 = Türe offen

Mich würde interessieren, ob man auf diese Betriebsmodi irgendwie über 
RS485 dran kommt. Auf der RS-10 habe ich die Modi nicht, daher ist 
fraglich, ob diese dem Bus grundsätzlich zugänglich sind. Die 
Programmierung der Kesselsteuerung ist nämlich so grottenschlecht 
umgesetzt, dass das System sehr viel Energie verschwendet, die 
Restwärmeausnutzung funktioniert nämlich mehr schlecht als recht.

Wäre seeeehr gut, diese in einen Raspberry einzulesen und übers 
SmartHome zugänglich zu machen. Ob das geht?
Ich mag irgendwie nicht an die Steuerplatine des LED-Displays ran. 
Theoretisch könnte man natürlich die LEDs alle abgreifen und über I/O 
Pins in einen Raspi einlesen...

Thx,
Sulla

[Thorsten (Gast)]

Hallo,

gibt es bzgl. der Ceta 104 Fortschritte?
Hat schon mal jemand versucht die RC Schnittstelle auszulesen?

Gruß,
Thorsten

[Michael (Gast)]

Tim G. hat sich seit über einen Jahr nicht mehr gemeldet. Ich glaube das 
Projekt ist tot...Schade.

[Kim M. (kimdo8)]

Hat an der Arbeit von Tim G. noch jemand angeknüpft?
Ich überlege, mittels ESP32 Daten der Heizungssteuerung per WLAN 
abrufbar zu machen. Die Idee: z.B. Einbindung in HomeAssistant. Wenn Tim 
G. seine ersten an der Schnittstelle mit dem Raspi gemacht hatte, wie er 
schreibt, dann sollte das mit dem ESP32 auch gehen. Hat da schon mal 
jemand etwas gemacht?

[Thomas M. (tomas_m)]

Kim M. schrieb:
> Hat an der Arbeit von Tim G. noch jemand angeknüpft?
>... Hat da schon mal jemand etwas gemacht?

Ich hätte auch Interesse, bereite gerade den RS485 Adapter vor.

[Centrus (Gast)]

Thomas M. schrieb:
> Ich hätte auch Interesse, bereite gerade den RS485 Adapter vor.

Naja. RS485 Adapter gibt es ja billigst auch in EU.
https://www.ramser-elektro.at/shop/module-sensoren-adapter-und-co/adapter-usb-auf-rs485-modbus/

[Kim M. (kimdo8)]

Ich bin jetzt soweit und kann über ein RS485-Shield mittels Arduino wie 
von Tim G. beschrieben, das Protokoll mitlesen. Mein Problem: ich komme 
aus den Protokollwerten nicht auf die tatsächlichen Temperaturwerte, die 
mich interessieren. Die von Tim G. angegebenen Bytepositionen im 
Protokoll scheinen zwar die Temperaturwerte zu sein, jedoch habe ich 
noch keinen Zusammenhang gefunden, die Protokollwerte in tatsächliche 
Temperatur umzurechnen. Tim G. schreibt ja auch, dass dies über einen 
Faktor umgerechnet wird. Dieser ist aber nicht konstant. Beim Vergleich 
von Protokollwerten und tatsächlich gemessenen Temperaturen habe ich 
keinen linearen Zusammenhang erkennen können. Hat jemand hierzu Infos 
oder eine Idee?

[Thomas M. (tomas_m)]

Centrus schrieb:
> Naja. RS485 Adapter gibt es ja billigst auch in EU.
?! klar. Mit Vorbereiten meinte ich in meinem Falle eine Linux 
Installation des SBC, dass ich an den Adapter hänge.


Kim M. schrieb:
> Ich bin jetzt soweit und kann über ein RS485-Shield mittels Arduino wie
> von Tim G. beschrieben, das Protokoll mitlesen.

Mitlesen bedeutet, dass man ein Remote Gerät benötigt, dass mit der 
Regelung spricht, oder ? Wie man das "ohne" antriggert, weisst Du nicht, 
oder?

> Mein Problem: ich komme
> aus den Protokollwerten nicht auf die tatsächlichen Temperaturwerte,

Hast Du mal ein paar Werte zum Mitgrübeln ?

Gruss, Tomas

[Kim M. (kimdo8)]

> Mitlesen bedeutet, dass man ein Remote Gerät benötigt, dass mit der
> Regelung spricht, oder ? Wie man das "ohne" antriggert, weisst Du nicht,
> oder?
Wenn ich den Arduino über RS485 an das vordere Interface stecke, kann 
ich die Datagramme (wie von Tim G. beschrieben) ohne besondere Aktion 
meinerseits mitlesen. Das passt zumindest zu meinem Verständnis, dass es 
sich ja hier bereits um einen Bus handelt, auf dem zyklisch Daten 
ausgetauscht werden. Mit meinem Arduino will ich zunächst nur mitlesen. 
Aktives Auslesen oder Antriggern mache ich zumindest nicht bewußt.

> Hast Du mal ein paar Werte zum Mitgrübeln ?
Hier mal ein paar Datagramm-Ausschnitte (beginnend mit "FF 82 10 20 20 4 
...") sowie abgelesene Werte. Die Beispiele 1.+2. liegen zeitlich nur 
wenige Min. auseinander.
1.) ... 85 10 1 10 0 0 0 0 0 0 0 0 0 0 0 7E 10 1 10 0 0 0 0 0 0 0 0 0 0 
0 60 4C ...
AußenT: 15,0
KesselT: 44
VorlaufT: 33
Brenner läuft

2.) ... 85 10 0 0 0 0 0 0 0 0 0 0 0 0 0 52 10 0 10 0 0 0 0 0 0 0 0 0 0 0 
62 4C ...
AußenT: 15,0
KesselT: 44
VorlaufT: 35
Brenner hat gestoppt

3.) ... 7B 10 1 10 0 0 0 0 0 0 0 0 0 0 0 7E 10 1 10 0 0 0 0 0 0 0 0 0 0 
0 68 4C ...
AußenT: 9,5
KesselT: 47
VorlaufT: 40

4.) ... 77 10 0 0 0 0 0 0 0 0 0 0 0 0 0 68 10 0 10 0 0 0 0 0 0 0 0 0 0 0 
70 4C ...
AußenT: 8,0
KesselT: 50
VorlaufT: 42

5.) ... 75 10 0 0 0 0 0 0 0 0 0 0 0 0 0 69 10 1 10 0 0 0 0 0 0 0 0 0 0 0 
6E 4C ...
AußenT: 6,5
KesselT: 50
VorlaufT: 44

Die Aussentemperatur wurde direkt an der Steuerung ausgelesen.
Kessel- und Vorlauftemperatur wurden von analogen Anzeigen an der 
Heizung abgelesen. Da kann es also Ablese-/Anzeigefehler geben. Auch ist 
denkbar, dass diese analogen Anzeigen und die Steuerungsinternen 
Sensoren unterschiedlich träge sind, so dass es bei Temperaturänderungen 
zu Abweichungen kommt.

Gruß Kim

[Thomas M. (tomas_m)]

Hi Kim,
du machst nichts mit Gallipoli ? Ich hab es installiert und erstmal 
versucht ans Laufen zu bekommen, aber ich verstehe nicht so ganz, wie 
das funktionieren soll, also werde ich mich glaube ich jetzt auch 
erstmal ans manuelle Dekodieren machen. Ich schau mir Deine 
Beispiel-Datensätze mal an (Hatte völlig vergessen, dass ich Dich danach 
gefragt hatte und war zwischendurch krank).

[Kim M. (kimdo8)]

Nein, meine Idee war, mittels ESP32 und einem RS485-Adapter den Bus der 
Heizung mit zu lesen und die für mich interessanten Werte per http 
abfragbar zu machen. Daher hatte ich auf Basis der Doku von Tim G. die 
Dekodierung im ESP „zu Fuß“ vornehmen wollen und komme da jetzt nicht 
weiter.

[Thomas M. (tomas_m)]

Ok, so werde ich das "langfristig" vermutlich auch machen, bzw. nicht 
per http, sondern der ESP wird die Werte per MQTT pushen.

Wenn ich mir Deine Werte so anschaue, dann passt die Aussentemperatur 
auf jeden Fall mit den Angaben in
https://github.com/bogeyman/gamma/wiki/Protokoll

ueberein:

#2  dez  x/2-52  Aussentemp
85  133  14.5    15
85  133  14.5    15
7b  123   9.5    9,5
77  119   7.5    8,0
75  117   6.5    6,5

die Kesseltemperatur, mit einer relativ konstanten Abweichung (die 
analoge Anzeige duerfte nicht zu genau sein) auch:

#32 dez  x/2  Kessel
60  96   48   44
62  98   49   44
68  104  52   47
70  112  56   50
6e  110  55   50

Hinter den Vorlaufwert bin ich noch nicht gekommen, aber da kann 
natuerlich tatsaechlich die von Dir genannten Traegheit zum Tragen 
kommen, denn die Vorlauftemperatur aendert sich ja bei offenen Ventilen 
relativ schnell.
Gruss/Tomas

[Thomas M. (tomas_m)]

Ich hab gestern meine Steuerung mal angeklemmt und im Nachgang ist mir 
aufgefallen, dass ich die falschen Klemmen benutzt habe, (weil die mit 
AB bezeichnet waren und an den RC Klemmen keine Polaritaet angegeben 
war). Die Datagramme, die da raus kommen, sehen ein wenig anders aus, 
aber beinhalten vermutlich die gleichen Informationen etwas anders 
repraesentiert. Ich hab's erstmal nicht umgeklemmt, weil ich hoffe 
eventuell das Brenner ein/ausschalten mitbekommen zu koennen.
Ich hab die ganze Nacht geloggt, in der Hoffnung, dass ich was erkennen 
kann:

https://termbin.com/l48z

[Phire S. (phire_s)]

Hallo zusammen.

Ich hab den Thread nur halb gelesen aber da das hier eine von zwei 
Konversationen die man übernhaupt im Internet zu dem Thema findet ist 
erwähne ich es mal:

Ich habe in den letzten Tagen eine Brücke von meiner Theta N 23B zu MQTT 
und Home Assistant geschrieben (per serieller Debug-Schnittstelle). Mein 
Code dazu und info zum Protokoll das das Ding verwendet ist hier 
zusammengefasst:

https://github.com/phiresky/ebv-theta-to-mqtt

Das was ich sehe sieht recht ähnlich aus was Thomas in seiner letzten 
Nachricht geschickt hat, und recht anders als das was in dem Wiki zur 
Gamma oben verlinkt ist.

[Oliver S. (oliverso)]

Phire S. schrieb:
> Das was ich sehe sieht recht ähnlich aus was Thomas in seiner letzten
> Nachricht geschickt hat, und recht anders als das was in dem Wiki zur
> Gamma oben verlinkt ist.

Nun ja, deine ist eine Theta, die oben eine Gamma. Das sind 
unterschiedliche Steuerungsgenerationen, und die haben bis auf den 
selben Hersteller nicht allzu viel miteinander zu tun.

Oliver

[Thomas M. (tomas_m)]

Phire S. schrieb:

>
> Das was ich sehe sieht recht ähnlich aus was Thomas in seiner letzten
> Nachricht geschickt hat, und recht anders als das was in dem Wiki zur
> Gamma oben verlinkt ist.

Ich hab etwas ähnliches über die Ceta angefangen:

https://github.com/tmuehlhoff/ceta

Da Du -speziell in Sachen MQTT- schon weiter bist werde ich vermutlich 
das ein oder andere von Dir übernehmen! Danke ;)

[Phire S. (phire_s)]

> Ich hab etwas ähnliches über die Ceta angefangen

Super!

Das Nachrichtenformat sieht echt ziemlich gleich aus, du könntest mal 
versuchen meinen Code unverändert bei dir laufen zu lassen. Also erst 
`justdump.py` um zu loggen und dann protocol_parse.py um die logs zu 
parsen (und einen plot zu erstellen mit den interesting_values über 
zeit.

Lass mich wissen wenn ich irgendwie helfen kann.

Bis auf das grundlegende Nachrichtenformat (210a0a + 16-bit nachrichten 
typ + nachrichten länge + ... + CRC16) ist an meinem Code eigentlich 
nichts speziell. Die Nachrichteninhalte sind in deklarative liste von 
interessanten Offsets/Namen in interesting_values.yaml.

[Thomas M. (tomas_m)]

Phire S. schrieb:
...
> versuchen meinen Code unverändert bei dir laufen zu lassen. Also erst
> `justdump.py` um zu loggen und dann protocol_parse.py um die logs zu
> parsen (und einen plot zu erstellen mit den interesting_values über
> zeit.

Ich hatte die Plots schon von Hand in gnumeric erstellt, sehen Deinen 
ziemlich ähnlich. Kann ich natütlich trotzdem mal machen.
Vor allem diese Stati sind mir noch unklar, da wollte ich mal ein paar 
Sachen "rumstellen" an der Steuerung und die entsprechenden Änderungen 
anschauen... Bin ich noch nicht zu gekommen.

Ich bin nicht so firm in JSON, ist irgendwie nicht mein Format, aber 
muss ich mich wohl durchwuseln ;) Macht ja für SONOFF-MQTT eh Sinn.

[Thomas M. (tomas_m)]

root@bananapim2ultra:/home/tomas/ebv-theta-to-mqtt# python3 protocol_parse.py  dump-2023-02-12T23\:03\:59+01\:00.jsonl 
Traceback (most recent call last):
  File "/home/tomas/ebv-theta-to-mqtt/protocol_parse.py", line 75, in <module>
    timestamp: datetime, message: bytes, plot_data: dict[str, list[dict]] | None
TypeError: unsupported operand type(s) for |: 'types.GenericAlias' and 'NoneType'

Hab ich da eine falsche Lib ?

[Phire S. (phire_s)]

Wenn du sie schon hast ist nat. auch gut ;)

Ich hab grad mal deinen dump von oben durch meinen code geschoben:

    wget https://termbin.com/l48z
    cat l48z|cut -c 1-52 > cut
    pdm run protocol_parse.py cut



 und es hat sie tatsächlich richtig verarbeitet. Also die CRC summe und 
das nachrichtenformat sind gleich.

Du hast in deinem dump irgendwie in jeder Zeile irgendwie links eine 
valide nachricht und rechts noch eine die abgeschnitten aussieht - 
zumindest endet sie nicht in einer CRC16 summe und die nachrichtenlänge 
scheint auch nicht zu stimmen.


> unsupported operand type
Äh ja du brauchst für meinen code python 3.10 weil ich gerne im cutting 
edge lebe ^^, der syntax fehler kommt von python <=3.9.

[Phire S. (phire_s)]

Mit folgender interesting_values.yaml:

- message_type: [0x84, 0x17]
  byte_offset: 1
  format: u8
- message_type: [0x84, 0x17]
  byte_offset: 3
  format: u16le
- message_type: [0x84, 0x17]
  byte_offset: 5
  format: u16le
- message_type: [0x84, 0x17]
  byte_offset: 7
  format: u16le
- message_type: [0x84, 0x17]
  byte_offset: 9
  format: u16le


gibt mein code für deinen obigen paste-bin dump folgendes aus: (siehe 
Anhang)

Sieht also ziemlich gut aus :)

[Thomas M. (tomas_m)]

Phire S. schrieb:
...
>     wget https://termbin.com/l48z
...
> Du hast in deinem dump irgendwie in jeder Zeile irgendwie links eine
> valide nachricht und rechts noch eine die abgeschnitten aussieht -

Richtig ;) Ich hatte die Daten "da noch" mit dem Script von Tim 
ausgelesen, dass aber von einer festen und falschen Länge ausgegangen 
ist (von der Gamma halt).
Ich hatte die Tage Corona und hab das mit Brummschädel erstmal nicht 
bemerkt, mir war zwar klar, dass da "irgendwas nicht in Ordnung" war, 
aber ich hatte mich erst mit den Werten beschäftigt.

Kann ich in Deinem Repo einen Branch aufmachen und meine Ceta Sachen 
einfach hinzufügen ?

Python 3.10, kein Thema, ich hatte die Büchse allerdings erst mühsam auf 
2.7 runtergepatcht (was bei Debian 11 gar nicht so einfach war), um Tims 
Code laufen zu lassen. Bin selbst weder Coder noch mag ich Python 
sonderlich, daher ist das für mich einfacher die Umgebung so 
hinzubasteln, dass der Code läuft und nicht umgekehrt ;)

[Phire S. (phire_s)]

> Kann ich in Deinem Repo einen Branch aufmachen und meine Ceta Sachen
einfach hinzufügen ?

Ja klar, klingt gut.

Macht vielleicht auch Sinn über spezifisches wo anders zu diskutieren 
(z.B. hier: https://github.com/phiresky/ebv-theta-to-mqtt/discussions ) 
um den Thread hier nicht zu sehr ausarten zu lassen.

[Christian H. (christian_h748)]

Hallo zusammen,

dank eurer Vorarbeit hier im Forum habe ich meine CETA 100 erfolgreich 
verbinden können. Andere CETA Versionen sollten ähnlich sein.

Ich habe dazu einen ESP32 (Wemos D1 mini) mit einem RS485 Adapter 
verbunden.
Als Platform habe ich ESPhome verwendet.

Über die UART kann ich jetzt folgende Parameter auslesen:
1. Temperatur am Solarmodul
2. Temperatur im Heizkessel
3. Pumpenmodus / Zirkulationspumpe ein/aus
4. Anzahl Pumpenstarts
5. Betriebstunden

alles read-only!

Hier noch mein Code (bestimmt nicht schön geschrieben - aber es 
funktioniert :-)):

CETA100.YAML

esphome:
  name: "name"
  includes:
    - my_CETA100_uart.h

esp32:
  board: esp32dev
  framework:
    type: arduino

# Enable logging
logger:

# Enable Home Assistant API
api:
  encryption:
    key: "XXXXXXX"

ota:
  password: "XXXXXXX"


wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password

  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "XXXXXXX"
    password: "XXXXXXX"

captive_portal:



#CETA100 control
uart:
  id: uart_bus
  tx_pin: 3
  rx_pin: 1
  baud_rate: 9600 #port = serial.Serial(serialDevice, baudrate=9600, timeout=60.0, bytesize=serial.EIGHTBITS, stopbits=serial.STOPBITS_ONE, parity=serial.PARITY_NONE, xonxoff=False, rtscts=False, dsrdtr=False)
  stop_bits: 1
#  debug:
#    direction: BOTH

binary_sensor:
  - platform: template
    name: "CETA100 Pumpen Mode"
    device_class: "running"
    lambda: |-
      if (id(CETA100_Pumpen_Mode).state > 0) {
        return true;
      } else {
        return false;
      }


sensor:
  - platform: custom
   #     auto CETA100_Sensor = new CETA100Sensor(id(uart_bus),60000);
    lambda: |-
      auto CETA100_Sensor = new CETA100Sensor(id(uart_bus));
      App.register_component(CETA100_Sensor);
      return {CETA100_Sensor->burnerMode_sensor,
              CETA100_Sensor->PVTemp_sensor,
              CETA100_Sensor->ActWasserspeicherTemp_sensor,
              CETA100_Sensor->BetriebsStundenPumpe_sensor,
              CETA100_Sensor->AnzahlStartsPumpe_sensor};
    sensors: 
    - name: "CETA100 Pumpen Mode temp"
      internal: true
      id: CETA100_Pumpen_Mode
#      filters:
#        - lambda: !lambda |-
#            if (x == 3) return {true};
#            return false;
    - name: "CETA100 Solar Modul Temperature"
      unit_of_measurement: °C
      device_class: temperature
      accuracy_decimals: 1
    - name: "CETA100 Speicher Temperature"
      device_class: temperature
      unit_of_measurement: °C
      accuracy_decimals: 1
    - name: "CETA100 Betriebsstunden Pumpe"
      unit_of_measurement: h
      device_class: duration
    - name: "CETA100 Anzahl Starts Pumpe"
      id: CETA100_Anzahl_Starts_Pumpe

my_CETA100_uart.h

#include "esphome.h"

class CETA100Sensor : public Component, public UARTDevice , public Sensor{
 public:
  
  CETA100Sensor(UARTComponent *parent) : UARTDevice(parent) {}
  
  Sensor *burnerMode_sensor = new Sensor();
  Sensor *PVTemp_sensor = new Sensor();
  Sensor *ActWasserspeicherTemp_sensor = new Sensor();
  Sensor *BetriebsStundenPumpe_sensor = new Sensor();
  Sensor *AnzahlStartsPumpe_sensor = new Sensor();
  
  
  void setup() override {
    // nothing to do here
  }

  std::vector<int> bytes;
  int count = 0;

//  void update() override {
  void loop() override {
    const int message_length = 43;
    const int pushinterval = 15;
    
    while (available()) {
        
      bytes.push_back(read()); //UART Read into Bytes variable.  HIer muss geändert werden auf die letzten 43 Bytes.

      if(bytes.size() < message_length)       
      {
        continue;  
      }
       //ESP_LOGD("custom", "checking bytes");
      if(bytes[0] != 0x21 || bytes[1] != 0x0A || bytes[2] != 0x15 ) {
      //sync to start
        bytes.erase(bytes.begin()); //remove first byte from buffer
        continue;
      } 

      if(bytes.size() == message_length) {
          
          if(count == pushinterval) {  //meachanism to only send every X received messages from UART - otherwise overflow of Data
          
          //burnerMode_sensor->publish_state(burnermode);
          burnerMode_sensor->publish_state(bytes[13]);
          //ESP_LOGD("custom", "Parsed burnerMode_sensor: %i", bytes[13]);
          
          //Temperatur Wärmelieferant
          TwoByte PVTemp;
          PVTemp.Byte[0] = bytes[14];
          PVTemp.Byte[1] = bytes[15];  
          PVTemp_sensor->publish_state(float(PVTemp.Int16)/10); 
          //ESP_LOGD("custom", "Parsed PVTemp_sensor: %.1f", float(PVTemp.Int16)/10);
          
          // Temperatur Wasserspeicher
          TwoByte ActWasserspeicherTemp;
          ActWasserspeicherTemp.Byte[0] = bytes[16];
          ActWasserspeicherTemp.Byte[1] = bytes[17];  
          ActWasserspeicherTemp_sensor->publish_state(float(ActWasserspeicherTemp.UInt16)/10);
          //ESP_LOGD("custom", "Parsed ActWasserspeicherTemp_sensor: %.1f", float(ActWasserspeicherTemp.UInt16)/10);
          
          // Betriebsstunden Pumpe
          TwoByte BetriebsStundenPumpe;
          BetriebsStundenPumpe.Byte[0] = bytes[18];
          BetriebsStundenPumpe.Byte[1] = bytes[19];  
          BetriebsStundenPumpe_sensor->publish_state(BetriebsStundenPumpe.UInt16);
          //ESP_LOGD("custom", "Parsed BetriebsStundenPumpe: %i", BetriebsStundenPumpe);
          
          // Starts Pumpe
          TwoByte AnzahlStartsPumpe;
          AnzahlStartsPumpe.Byte[0] = bytes[20];
          AnzahlStartsPumpe.Byte[1] = bytes[21];  
          AnzahlStartsPumpe_sensor->publish_state(AnzahlStartsPumpe.UInt16);
          //ESP_LOGD("custom", "Parsed AnzahlStartsPumpe: %i", AnzahlStartsPumpe.UInt16);     
          
          //ESP_LOGD("custom", "Countreached: %i", count);
          count=0;
          
          }
        //ESP_LOGD("custom", "Countinterim status: %i", count);
        bytes.clear();
        count++;
      }
    }
  }
  
typedef union
  {
    unsigned char Byte[2];
    int16_t Int16;
    uint16_t UInt16;
    unsigned char UChar;
    char Char;
  }TwoByte;  
  
};

grüße,
Christian

[Thomas G. (tomatos666)]

Hallo,
Tot gesagte leben länger...
Die Sieger S59a hat das gleiche Protokoll wie bei 
https://github.com/bogeyman/gamma/wiki beschrieben.

Gibt es Neuigkeiten bezüglich Auslesen Temperaturen wie 
Vorlauftemperaturen und direkt Ansteuerung von Mischer und Pumpen?

[S. F. (s_f)]

moin,
ich beschäftige mich aktuell gerade etwas damit.
zwar mit ESP32 + RS485 adapter.

für Arduino:



#include <HardwareSerial.h>

HardwareSerial rs485(1);

void setup() {
  // Seriellen Monitor starten
  Serial.begin(115200);
  Serial.println("Setup gestartet");

  // RS485 Serial konfigurieren
  rs485.begin(9600, SERIAL_8N1, 17, 16); // RX_PIN = 17, TX_PIN = 16
  Serial.println("RS485 Leser gestartet");
}

void loop() {
  // Prüfen, ob genügend Daten verfügbar sind
  if (rs485.available() >= 33) { // Mindestens 33 Bytes für alle Daten 
einschließlich Kesseltemperatur
    // Daten von RS485 lesen
    byte incomingData[33];
    for (int i = 0; i < 33; i++) {
      incomingData[i] = rs485.read();
    }

    // Überprüfen, ob die Daten auf Warmwassertemperatur hinweisen
    for (int i = 0; i < 33 - 3; i++) {
      // Überprüfen, ob das aktuelle Byte und die nächsten drei Bytes 
dem Muster entsprechen
      if (incomingData[i] == 0x04 && incomingData[i + 2] == 0x10 && 
(incomingData[i + 3] == 0x00 || incomingData[i + 3] == 0x02 || 
incomingData[i + 3] == 0xFF)) {
        // Hier können Sie weitere Bedingungen hinzufügen, um 
sicherzustellen, dass die Temperatur korrekt erkannt wird

        // Annahme: Die Temperatur befindet sich im nächsten Byte
        float temperatur = incomingData[i + 4];

        // Debug-Ausgabe der Warmwassertemperatur
        Serial.print("Potenzielle Warmwassertemperatur gefunden: ");
        Serial.println(temperatur);

        // Außentemperaturbedingungen überprüfen
        if (incomingData[0] == 0x04 && incomingData[2] == 0x10 && 
(incomingData[3] == 0x00 || incomingData[3] == 0x02 || incomingData[3] 
== 0xFF)) {
          // Außentemperatur berechnen
          float aussentemperatur = (int)incomingData[1] / 2.0 - 52.0;

          // Kesseltemperatur berechnen (aus hexadezimalem Wert)
          int kesselTempValue = int(incomingData[32]); // 
Hexadezimalwert in Ganzzahl umwandeln

          // Hier nehmen wir eine neue Formel an, um den Wert zu 
korrigieren
          float kesseltemperatur = kesselTempValue / 1.52; // 
Experimenteller Faktor, um den Wert zu korrigieren

          // Debug-Ausgaben
          Serial.print("Kesseltemperatur: ");
          Serial.println(kesseltemperatur);

          // Außentemperatur über den seriellen Monitor ausgeben
          Serial.print("Außentemperatur: ");
          Serial.println(aussentemperatur);
        }
      }
    }

    // Uhrzeit und Datum überprüfen und verarbeiten
    if (incomingData[0] == 0x05 && (incomingData[1] == 0x00 || 
incomingData[1] == 0x02)) {
      byte sekunde = incomingData[2];
      byte minute = incomingData[3];
      byte stunde = incomingData[4];
      byte tag = incomingData[5];
      byte monat = incomingData[6] & 0x0F; // Einerstelle des Monats
      byte tagWoche = (incomingData[6] >> 4) & 0x07; // Tag in der Woche
      byte jahr = incomingData[7];

      // Überprüfen, ob die Uhrzeit und das Datum gültig sind
      if (stunde < 0x24 && minute < 0x60 && sekunde < 0x60 &&
          tag < 0x32 && monat < 0x13 && tagWoche < 0x07 && jahr >= 0x20) 
{

        // Wochentag ermitteln
        const char* wochentage[] = {"Sonntag", "Montag", "Dienstag", 
"Mittwoch", "Donnerstag", "Freitag", "Samstag"};
        const char* monate[] = {"Januar", "Februar", "März", "April", 
"Mai", "Juni", "Juli", "August", "September", "Oktober", "November", 
"Dezember"};

        Serial.print("Datum: ");
        Serial.print(wochentage[tagWoche - 1]); // Wochentage-Index 
beginnt bei 0
        Serial.print(", den ");
        Serial.print(tag, HEX);
        Serial.print(". ");
        Serial.print(monate[monat + 1]); // Monate-Index beginnt bei +1
        Serial.print(" 20");
        Serial.println(jahr, HEX);

        Serial.print("Uhrzeit: ");
        if (stunde < 0x10) Serial.print("0"); // Führende Null für 
einstellige Stunden
        Serial.print(stunde, HEX);
        Serial.print(":");
        if (minute < 0x10) Serial.print("0"); // Führende Null für 
einstellige Minuten
        Serial.print(minute, HEX);
        Serial.print(":");
        if (sekunde < 0x10) Serial.print("0"); // Führende Null für 
einstellige Sekunden
        Serial.println(sekunde, HEX);
      }
    }
  }
}

[Hardy (hardy_0847)]

Hallo zusammen

falls es noch jemanden interessiert: ich bin dabei an einer Toptronic 
23S rumzubasteln.

Die anbindende Hardware ist ein raspi5 + RS495-IF.  Ich kann inzwischen 
ein paar Werte aus dem Datenstrom empfangen und per mqtt versenden.

Alles sehr experimentell, aber hier ist das Repo: 
https://github.com/rgrr/TopTronic23S

[Erik (erik_p249)]

Hardy schrieb:
> Hallo zusammen
>
> falls es noch jemanden interessiert: ich bin dabei an einer Toptronic
> 23S rumzubasteln.
>
> Die anbindende Hardware ist ein raspi5 + RS495-IF.  Ich kann inzwischen
> ein paar Werte aus dem Datenstrom empfangen und per mqtt versenden.
>
> Alles sehr experimentell, aber hier ist das Repo:
> https://github.com/rgrr/TopTronic23S

Hey Hardy,
hast du bei dir noch was am Protocol angepasst oder das so von bogeyman 
übernommen?

Ich habe von Intercal ein RG23B Steuerung, die sieht der TopTronic sehr 
ähnlich. Mein RS485 Adapter kommt morgen, mal gucken was ich 
rausbekomme.

[Hardy (hardy_0847)]

:
> hast du bei dir noch was am Protocol angepasst oder das so von bogeyman
> übernommen?
:

Hi Erik,

das Protokoll ist fast das gleiche.  Die kleinen Unterschiede belaufen 
sich darauf, dass die TopTronic wohl Parity verwendet.  Das sieht man 
recht schnell, wenn im Datenstrom Daten mit abwechselnden 0xff empfangen 
wird (zumindest unter Linux).  Außerdem ist der Datenblock im cmd4 bei 
mir größer.

Ansonsten einfach mal die Skripte in 
https://github.com/rgrr/TopTronic23S/tree/main/testing anschauen.