Announcement: there is an English version of this forum on 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
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
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
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
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
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
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
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
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
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
Bei Körting ist der CODE 2129. Je nach Hersteller aber unterschiedlich.
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 ...
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.
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
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.
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...
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.
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!
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.
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...
Hört sich vielversprechend an! Ich hatte dir die Logs der CETA geschickt. Wenn du noch mehr brauchst sag einfach Bescheid.
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
Hallo, gibt es bzgl. der Ceta 104 Fortschritte? Hat schon mal jemand versucht die RC Schnittstelle auszulesen? Gruß, Thorsten
Tim G. hat sich seit über einen Jahr nicht mehr gemeldet. Ich glaube das Projekt ist tot...Schade.
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?
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.
:
Bearbeitet durch User
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/
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?
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
> 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
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).
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.
:
Bearbeitet durch User
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
:
Bearbeitet durch User
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
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.
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
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 ;)
> 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.
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.
1 | root@bananapim2ultra:/home/tomas/ebv-theta-to-mqtt# python3 protocol_parse.py dump-2023-02-12T23\:03\:59+01\:00.jsonl |
2 | Traceback (most recent call last): |
3 | File "/home/tomas/ebv-theta-to-mqtt/protocol_parse.py", line 75, in <module> |
4 | timestamp: datetime, message: bytes, plot_data: dict[str, list[dict]] | None |
5 | TypeError: unsupported operand type(s) for |: 'types.GenericAlias' and 'NoneType' |
Hab ich da eine falsche Lib ?
:
Bearbeitet durch User
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.
Angehängte Dateien:
-
2023-02-12-23-19-33.png
230 KB
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 :)
:
Bearbeitet durch User
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 ;)
> 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.
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
1 | esphome:
|
2 | name: "name" |
3 | includes: |
4 | - my_CETA100_uart.h |
5 | |
6 | esp32: |
7 | board: esp32dev |
8 | framework: |
9 | type: arduino |
10 | |
11 | # Enable logging
|
12 | logger: |
13 | |
14 | # Enable Home Assistant API
|
15 | api: |
16 | encryption: |
17 | key: "XXXXXXX" |
18 | |
19 | ota: |
20 | password: "XXXXXXX" |
21 | |
22 | |
23 | wifi: |
24 | ssid: !secret wifi_ssid |
25 | password: !secret wifi_password |
26 | |
27 | # Enable fallback hotspot (captive portal) in case wifi connection fails
|
28 | ap: |
29 | ssid: "XXXXXXX" |
30 | password: "XXXXXXX" |
31 | |
32 | captive_portal: |
33 | |
34 | |
35 | |
36 | #CETA100 control
|
37 | uart: |
38 | id: uart_bus |
39 | tx_pin: 3 |
40 | rx_pin: 1 |
41 | 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) |
42 | stop_bits: 1 |
43 | # debug:
|
44 | # direction: BOTH
|
45 | |
46 | binary_sensor: |
47 | - platform: template |
48 | name: "CETA100 Pumpen Mode" |
49 | device_class: "running" |
50 | lambda: |- |
51 | if (id(CETA100_Pumpen_Mode).state > 0) { |
52 | return true; |
53 | } else { |
54 | return false; |
55 | }
|
56 | |
57 | |
58 | sensor: |
59 | - platform: custom |
60 | # auto CETA100_Sensor = new CETA100Sensor(id(uart_bus),60000);
|
61 | lambda: |- |
62 | auto CETA100_Sensor = new CETA100Sensor(id(uart_bus)); |
63 | App.register_component(CETA100_Sensor); |
64 | return {CETA100_Sensor->burnerMode_sensor, |
65 | CETA100_Sensor->PVTemp_sensor, |
66 | CETA100_Sensor->ActWasserspeicherTemp_sensor, |
67 | CETA100_Sensor->BetriebsStundenPumpe_sensor, |
68 | CETA100_Sensor->AnzahlStartsPumpe_sensor}; |
69 | sensors: |
70 | - name: "CETA100 Pumpen Mode temp" |
71 | internal: true |
72 | id: CETA100_Pumpen_Mode |
73 | # filters:
|
74 | # - lambda: !lambda |-
|
75 | # if (x == 3) return {true};
|
76 | # return false;
|
77 | - name: "CETA100 Solar Modul Temperature" |
78 | unit_of_measurement: °C |
79 | device_class: temperature |
80 | accuracy_decimals: 1 |
81 | - name: "CETA100 Speicher Temperature" |
82 | device_class: temperature |
83 | unit_of_measurement: °C |
84 | accuracy_decimals: 1 |
85 | - name: "CETA100 Betriebsstunden Pumpe" |
86 | unit_of_measurement: h |
87 | device_class: duration |
88 | - name: "CETA100 Anzahl Starts Pumpe" |
89 | id: CETA100_Anzahl_Starts_Pumpe |
my_CETA100_uart.h
1 | #include "esphome.h" |
2 | |
3 | class CETA100Sensor : public Component, public UARTDevice , public Sensor{ |
4 | public:
|
5 | |
6 | CETA100Sensor(UARTComponent *parent) : UARTDevice(parent) {} |
7 | |
8 | Sensor *burnerMode_sensor = new Sensor(); |
9 | Sensor *PVTemp_sensor = new Sensor(); |
10 | Sensor *ActWasserspeicherTemp_sensor = new Sensor(); |
11 | Sensor *BetriebsStundenPumpe_sensor = new Sensor(); |
12 | Sensor *AnzahlStartsPumpe_sensor = new Sensor(); |
13 | |
14 | |
15 | void setup() override { |
16 | // nothing to do here
|
17 | }
|
18 | |
19 | std::vector<int> bytes; |
20 | int count = 0; |
21 | |
22 | // void update() override {
|
23 | void loop() override { |
24 | const int message_length = 43; |
25 | const int pushinterval = 15; |
26 | |
27 | while (available()) { |
28 | |
29 | bytes.push_back(read()); //UART Read into Bytes variable. HIer muss geändert werden auf die letzten 43 Bytes. |
30 | |
31 | if(bytes.size() < message_length) |
32 | {
|
33 | continue; |
34 | }
|
35 | //ESP_LOGD("custom", "checking bytes");
|
36 | if(bytes[0] != 0x21 || bytes[1] != 0x0A || bytes[2] != 0x15 ) { |
37 | //sync to start
|
38 | bytes.erase(bytes.begin()); //remove first byte from buffer |
39 | continue; |
40 | }
|
41 | |
42 | if(bytes.size() == message_length) { |
43 | |
44 | if(count == pushinterval) { //meachanism to only send every X received messages from UART - otherwise overflow of Data |
45 | |
46 | //burnerMode_sensor->publish_state(burnermode);
|
47 | burnerMode_sensor->publish_state(bytes[13]); |
48 | //ESP_LOGD("custom", "Parsed burnerMode_sensor: %i", bytes[13]);
|
49 | |
50 | //Temperatur Wärmelieferant
|
51 | TwoByte PVTemp; |
52 | PVTemp.Byte[0] = bytes[14]; |
53 | PVTemp.Byte[1] = bytes[15]; |
54 | PVTemp_sensor->publish_state(float(PVTemp.Int16)/10); |
55 | //ESP_LOGD("custom", "Parsed PVTemp_sensor: %.1f", float(PVTemp.Int16)/10);
|
56 | |
57 | // Temperatur Wasserspeicher
|
58 | TwoByte ActWasserspeicherTemp; |
59 | ActWasserspeicherTemp.Byte[0] = bytes[16]; |
60 | ActWasserspeicherTemp.Byte[1] = bytes[17]; |
61 | ActWasserspeicherTemp_sensor->publish_state(float(ActWasserspeicherTemp.UInt16)/10); |
62 | //ESP_LOGD("custom", "Parsed ActWasserspeicherTemp_sensor: %.1f", float(ActWasserspeicherTemp.UInt16)/10);
|
63 | |
64 | // Betriebsstunden Pumpe
|
65 | TwoByte BetriebsStundenPumpe; |
66 | BetriebsStundenPumpe.Byte[0] = bytes[18]; |
67 | BetriebsStundenPumpe.Byte[1] = bytes[19]; |
68 | BetriebsStundenPumpe_sensor->publish_state(BetriebsStundenPumpe.UInt16); |
69 | //ESP_LOGD("custom", "Parsed BetriebsStundenPumpe: %i", BetriebsStundenPumpe);
|
70 | |
71 | // Starts Pumpe
|
72 | TwoByte AnzahlStartsPumpe; |
73 | AnzahlStartsPumpe.Byte[0] = bytes[20]; |
74 | AnzahlStartsPumpe.Byte[1] = bytes[21]; |
75 | AnzahlStartsPumpe_sensor->publish_state(AnzahlStartsPumpe.UInt16); |
76 | //ESP_LOGD("custom", "Parsed AnzahlStartsPumpe: %i", AnzahlStartsPumpe.UInt16);
|
77 | |
78 | //ESP_LOGD("custom", "Countreached: %i", count);
|
79 | count=0; |
80 | |
81 | }
|
82 | //ESP_LOGD("custom", "Countinterim status: %i", count);
|
83 | bytes.clear(); |
84 | count++; |
85 | }
|
86 | }
|
87 | }
|
88 | |
89 | typedef union |
90 | {
|
91 | unsigned char Byte[2]; |
92 | int16_t Int16; |
93 | uint16_t UInt16; |
94 | unsigned char UChar; |
95 | char Char; |
96 | }TwoByte; |
97 | |
98 | };
|
grüße, Christian
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?
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);
}
}
}
}
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
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.
: > 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.
Hello, Thank you all for sharing this useful information about the protocol behind Gamma device. I own one Gamma as well. Has anyone had sucess in sending commands to this device rather than reading from it? Looks like Tim G had dumps from people owning an RS10 station that sends commands but these are not shared here. Last resort would be to use the protocol for reading only, and using small servo-motors to rotate both knobs! Thanks
Thread beobachten
Seitenaufteilung abschaltenBitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.