Zehnder ComfoAir Q350 TR

[Syon]

Hat schon mal jemand die Zehnder ComfoAir Q350 TR (Die neue aus diesem Jahr) mit FHEM zum laufen bekommen? Ich habe die Comfo Connect LAN C für eine Steuerung per App dabei.

[keptenkrems]

Das Thema würde mich auch interessieren, da ich dieses Jahr baue und mit diese Lüftung mit dem Modul auch einbauen möchte! Bin schon sehr gespannt!

[Phill]

Hallo,
ich spiele mit dem Gedanken mir die LAN-Box zuzulegen. Ist ja nicht so teuer aber ich hadere noch mit dem nutzen.
So weit ist der weg zur Lüftung nicht und eigentlich muss ich auch nur 2 mal im Jahr an die Einstellungen der Lüftung. (Sommer/Winter-Einstellung)

Am interessantesten wären wohl die Physikalischen Werte in FHEM zu speichern und dann über Plots auszuwerten.

Ein Modul dafür ließe sich sicherlich leicht schreiben. Muss man das Webportal mal analysieren.

Weiß jemand ob das über Zehnder-Server läuft! Oder läuft auf der LAN-Box ein eigener Webserver. Sprich muss man sich bei Zehnder registrieren und über deren Homepage auf die Anlage zugreifen oder reicht die IP-Adresse der Box im Browser einzugeben?

Gruß

[Syon]

Hey,
die LAN-Box kann ausschließlich mit der APP.
Für FHEM wird man wohl die KNX-Box benötigen. Nicht zu vergessen, dass man für's KNX noch weitere Komponenten benötigt.
Damit sollten sich aber alle Daten auslesen und auch die Anlage steuern können.

Ich plane das in diesem Jahr, also vielleicht ende des Jahres mehr dazu.

[sido]

Bei mir läuft eine Zehnder Q450 mit Comfo Connect LAN C und natürlich auch eine FHEM Installation. Leider gibt es ja aber noch kein FHEM Modul dafür. Hier habe ich aber eine Python Implementierung für die Ansteuerung der Zehnder Q-Serie gefunden:
https://github.com/michaelarnauts/comfoconnect
Könnte man damit nicht ein FHEM-Modul bauen? Kann mir jemand Hinweise geben, wie man dies realisieren könnte?

Gruß,
Sido

[Fistandantilus]

Hi,

ich wäre auch brennend daran interessiert, da seit dem Wochenende bei mir auch eine Q350 steht.

VG
F.

[Phill]

Hi, ich habe heute mal etwas zeit investiert und ein Script geschrieben das als Vermittler zwischen pycomfoconnect und FHEM fungiert.

Für ein ganzes Modul haber ich leider keine Zeit. Denn der Umweg über pycomfoconnect ist eigentlich nicht notwendig und das Ganze sollte komplett in einem Modul erfolgen.

Ich stelle das jetzt erst mal hier vor, wenn das Script dann stabil läuft mache ich einen eigenen Beitrag dafür.

Das Script funktioniert momentan nur auf dem FHEM Rechner selbst. Kann aber leicht erweitert werden das es auf jedem Rechner im Netzwerk läuft. Es benötigt aber auch so gut wie keine Ressourcen, deswegen sollte es kein Problem sein es auf dem gleichen Rechner zu installieren.
Folgendes wird benötigt:

Code Auswählen Erweitern

sudo apt-get install python3 python3-pip python3-setuptools
Wichtig

Code Auswählen Erweitern

python3 --version sollte >3.5 zeigen. 3.4 hat bei mir nicht funktioniert.

Danach:

Code Auswählen Erweitern

sudo pip3 install wheel pycomfoconnect

Einen Dummy in FHEM erzeugen

Code Auswählen Erweitern

define comfoconnect dummy
attr comfoconnect devStateIcon {".*:vent_ventilation_level_".ReadingsVal("comfoconnect","Stufe",0).(ReadingsVal("comfoconnect","Modus",0) ne -1 ? '@green' : "")}

Jetzt das angehängte Script in irgendein Verzeichnis kopieren. z.B.

Code Auswählen Erweitern

/opt/fhem/scripts
Und die Rechte setzen

Code Auswählen Erweitern

chmod 755 /opt/fhem/scripts/ccfhem.py

Jetzt sollte es laufen. Hier könnt ihr euch die vorläufigen Parameter mal anschauen.

Code Auswählen Erweitern

/opt/fhem/scripts/ccfhem.py -h
usage: ccfhem.py [-h] [--host HOST] [--port PORT] [--servport SERVPORT]
                 [--ip IP] [--fhemdummy FHEMDUMMY]

optional arguments:
  -h, --help            show this help message and exit
  --host HOST           fhem server address. (localhost)
  --port PORT           fhem telnet port. (7072)
  --servport SERVPORT   port to listen for commands. (7077)
  --ip IP               ip address of the comfocontrol bridge (auto)
  --fhemdummy FHEMDUMMY
                        name of the fhem dummy (comfoconnect)

In Klammern stehen die Standartwerte wenn nichts angeben ist.
Am besten das Script mal in einer "screen"-Session laufen lassen, und ein paar Tage beobachten was passiert. Werde ich jetzt auch erst mal tun.

Momentan werden folgende READINGS gebildet:

Code Auswählen Erweitern

   READINGS:
     2017-09-28 16:21:36   Abluftfeuchte   57
     2017-09-28 16:21:36   Ablufttemperatur 24.0
     2017-09-28 16:29:48   Aussenluftfeuchte 52
     2017-09-28 16:28:35   Aussenlufttemperatur 23.6
     2017-09-28 16:21:36   Bypass          0
     2017-09-28 16:21:36   Filterwechsel   88
     2017-09-28 16:22:52   Fortluftfeuchte 60
     2017-09-28 16:27:27   Fortlufttemperatur 24.1
     2017-09-28 16:21:36   Modus           1
     2017-09-28 16:21:36   Stufe           2
     2017-09-28 16:28:37   Zuluftfeuchte   51
     2017-09-28 16:21:36   Zulufttemperatur 24.5
     2017-09-28 16:21:36   comfoNetVersion 1073750016
     2017-09-28 16:21:36   gatewayVersion  1049610
     2017-09-28 16:21:36   registeredDevices HONOR PLK-L01 iPad 3 Computer
     2017-09-28 16:21:36   serialNumber    DEM0116411818


Modus hat folgende Werte:

-1 Auto
1 Manuell bis zu einem bestimmten Zeitpunkt
5 Manuell

Die anderen Werte haben mir entweder zuviel overload erzeugt oder sind noch nicht entschlüsselt.

Momentan lassen sich nur die Lüfterstufen ändern. Dazu folgendes in FHEM eingeben.

Code Auswählen Erweitern

"echo CMD_FAN_MODE_MEDIUM | netcat localhost 7077"
Oder in einer Kommandozeile ohne Anführungszeichen.
Folgende Wörte werden akzeptiert.

CMD_FAN_MODE_AWAY
CMD_FAN_MODE_LOW
CMD_FAN_MODE_MEDIUM
CMD_FAN_MODE_HIGH

So und jetzt viel Erfolg beim testen. Würde mich über eure Hilfe freuen.

[lichtimc]

Mit dem KNX-Modul siehts bei mir wie im Anhang aus.

Nutzen tu ich die visualisierten Werte vor allem im Winter für die Kontrolle der Luftfeuchtigkeit und später dann baue ich mir noch die Steuerung der Stufen in Abhängigkeit mit dem Residents Modul dazu. (Z.B. beim Einschlafen Stufe 1, Bei Family-Feier Stufe 3, usw.)

[Zaschii]

Servus Zusammen,

bin aktuell kurz vor der Bestellung der Q350 für unseren Neubau. Wir bekommen ein KNX Bussystem und als SmartHome Server möchte ich natürlich FHEM nutzen.
Ich bin mir aktuell nicht sicher ob ich das LAN Modul oder KNX Modul nehmen soll.

komplette Steuerung der Anlage soll über FHEM möglich sein was wohl aktuell für das KNX Modul spricht, beim LAN Modull gefällt mir aber dass zB die ServiceTechniker remote zugreifen könnten.
Wird es zukünftig evtl. ein Modul geben, welches die Steuerung in FHEM mit dem LAN Modul ermöglicht, so dass ich die gleichen Funktionen wie mit dem KNX Modul hätte?

Danke im Voraus und VG

[Phill]

Bis jetzt gibt es m.M.n. nur die Bastellösung von mir zwei Beträge vorher. Funktioniert eigentlich ganz gut.
Aber ist halt sicher kein out-of-the box. Und für ein modul habe ich keine zeit, da es eigentlich auch alles kann was ich brauche.

Servicetechniker hab ich noch nie gebraucht, aber die app von zehnder für das LAN-Modul ist auch nicht schlecht.

[Zaschii]

Hi Phil,

danke für deine schnelle Antwort.
Deine Lösung hab ich gelesen, gute Arbeit auf jeden Fall.

Aber ich würde gerne vermeiden eine "Bastelllösung" zu verwenden, wegen zukunftsicherheit usw ...
Die App ist natürlich auch eine feine Sache, aber für mich wäre es auch wichtig das sauber ins Gesamtkonzept zu integrieren und das geht wohl aktuell mit dem KNX Modul besser, so wie ich das sehe.

VG

[stixif]

Hallo,
bin nun auch Besitzer einer Q350 TR...
gibt es keinen direkten weg die CAN-Bus Schnittstelle zu nutzen?!?
oder wird zwingend eine Lan c box benötigt?!?

[Phill]

Ich meine, so weit ich mich erinnere ist das Protokoll geändert worden bei den neuen Modellen. Oder sogar die Schnittstelle. Die vorhandenen Lösungen für die Zehnder Lüftungen können also nicht so leicht angewendet werden.

Da gibt es bis jetzt noch nichts, möglich wäre es aber bestimmt. Hab mich aber auch nicht in die Tiefe damit beschäftigt. Also könnte ich mich auch irren.

[Arne_]

Hi Phill,
ich habe nach deiner Anleitung installiert, bekomme aber nach Aufruf des Scripts folgenden Fehler:
"ERROR: Could not connect to the bridge since the PIN seems to be invalid."
Fehlt hier noch eine Konfiguration?

Danke und Gruß, Arne.

[Phill]

Ist bei dir ein PIN eingerichtet?
Im Script kannst du am Anfang ein Pin eintragen, habe das aber bei mir nicht benötigt und deswegen auch nicht als Parameter rausgeführt.

Gruß

[Arne_]

Hallo Phill,
ja tatsächlich - hatte ich wohl vor 1,5 Jahren bei der Einrichtung gemacht und jetzt vollkommen vergessen. Ich habe sie aber wieder herausgefunden und dein Script jetzt funktioniert super. Danke dafür!Es hat mich allerdings gleich in der App disconnected - eine gleichzeitige Nutzung ist damit wohl nicht möglich?

[Phill]

Das ist kein Problem, für die Zeit in der du die App benutzt kommen nur keine Daten in fhem an, geht aber beim Beenden weiter.
Unschön ist aktuell nur das das Script neu gestartet werden muss wenn fhem neu startet.

Gruß

[alancord]

Hallo zusammen,

Habe ebenso eine 350Q. Kann man theoretisch mit FHEM und dem KNX Modul über FHEM die LüfterStufen einstellen ?

[lichtimc]

Ja, geht ohne Probleme...

[Bongo_1st]

Hallo Zusammen

Ich bin absoluter Neuling mit FHEM und versuche mich zurechtzufinden...
Ich hoffe ich erhalte hier eine Antwort
Folgendes:
Ich habe einen Loxberry bei jenem ich das Plugin für FHEM installiert habe.
Danach habe ich gemäß Anleitung von Phill den "comfoconnect" dummy installiert.
Bis dahin funktioniert alles reibungslos, ich erhalte die neuen Werte stetig.

Nun würde ich jedoch nie neu geänderten Daten per HTTP oder UDP an einen Loxone-Server weitersenden. Leider habe ich keine Ahnung wo ich da ansetzen soll...

Bei Google habe ich leider auch Tutorial gefunden wie dummy-Werte weitergesendet werden können.

Besten Dank im Voraus, ebenfalls auch für das kleine Tool zum die Q350 Lüftungswerte auszulesen

[DoubleD]

Hallo Phill

Danke für das Script, das funktioniert soweit super!
Arbeitest du noch weiter daran, oder daran es direkt in ein Modul zu integrieren?

Gibt es eine Möglichkeit den Bypass von Script aus zu steuern?

Danke & Gruß
Daniel

[DoubleD]

Hier noch eine Lösung um den "Modus" im Textformat anzuzeigen.

Code Auswählen Erweitern

attr comfoconnect userReadings ModusTXT {if(ReadingsVal("comfoconnect","Modus","") == -1) {return "Auto"} elsif (ReadingsVal("comfoconnect","Modus","") == 1) {return "Manuell Zeit"} elsif (ReadingsVal("comfoconnect","Modus","") == 5) {return "Manuell"} else {return "Fehler"}}

[Phill]

Hallo, leider komme ich momentan nicht dazu weiter zu machen.
Theoretisch sollte es möglich sein den Bypass zwischen Auto/ein/aus umzuschalten, ist aber noch nicht umgesetzt.

Gruß

[DoubleD]

Hi Phill

Danke für Deine Antwort

Kannst du mir einen kurzen Tipp geben wo ich absetzen muss.
Vielleicht kann ich ja selber was erreichen...

Gruß
Daniel

[Phill]

Hi, ich musste mir es erst nochmal selbst anschauen, ist doch schon etwas her. Und wie ich gerade sehe ist es doch schon implementiert. 

In der Datei /pycomfoconnect/const.py stehen die aktuell möglichen Kommandos drin.

CMD_FAN_MODE_AWAY
CMD_FAN_MODE_LOW
CMD_FAN_MODE_MEDIUM
CMD_FAN_MODE_HIGH
CMD_MODE_AUTO
CMD_MODE_MANUAL
CMD_VENTMODE_SUPPLY
CMD_VENTMODE_BALANCE
CMD_TEMPPROF_NORMAL
CMD_TEMPPROF_COOL
CMD_TEMPPROF_WARM
CMD_BYPASS_ON
CMD_BYPASS_OFF
CMD_BYPASS_AUTO
CMD_SENSOR_TEMP_OFF
CMD_SENSOR_TEMP_AUTO
CMD_SENSOR_TEMP_ON
CMD_SENSOR_HUMC_OFF
CMD_SENSOR_HUMC_AUTO
CMD_SENSOR_HUMC_ON
CMD_SENSOR_HUMP_OFF
CMD_SENSOR_HUMP_AUTO
CMD_SENSOR_HUMP_ON

PS: Worum sich eventuell jemand mit etwas Python-Erfahrung kümmern könnte wäre, dass das Script (ccfhem.py) nicht immer abschmiert wenn FHEM mal nicht erreichbar ist. Also wenn die Telnet Verbindung nicht mehr erreichbar ist. Dafür wäre ich sehr Dankbar.

Gruß

[tpoetschan]

Hallöle zusammen,

hier hat jemand wohl direkt auf dem CAN aufgebaut:

https://github.com/marco-hoyer/zcan

Kennt den Entwickler jemand?

Viele Grüße

[woody7]

Hallo Zusammen,
kann mir jemand sagen, was ich hier falsch mache?
Die Werte werden bei mir in FHEM nur aktualisiert, wenn ich eine Telnet Verbindung mit laufendem "ccfhem.px --ip xxx" habe.
Beende ich Telnet, werden auch die Daten im FHEM nicht mehr aktualisiert???
Danke schon mal.

FHEM läuft als Plugin auf einem LoxBerry

EDIT:
So, habs. In der fhem.cfg eintragen

Code Auswählen Erweitern

define FHEMStart notify global:INITIALIZED.* {system("/opt/loxberry/data/plugins/fhem/scripts/ccfhem.py --ip xxx.xxx.xxx.xxx &")}
xxx.xxx.xxx.xxx = EURE ComfoConnectLANC IP

EDIT:
Ach ja, den Pfad müsst Ihr natürlich auch an Euren eigenen anpassen.

[Phill]

Das Problem mit der Telnetverbindung ist das ccfhem leider abschmiert sobald die Telnetverbindung unterbrochen wird.
Wie zwei Beträge zuvor angesprochen mit der Bitte das sich dem mal jemand annehmen könnte. Hab leider keine Zeit.

Gruß

[woody7]

@Phill
Ich habe den Eindruck, dass ccfhem als "Dienst" laufen muss.
Die Lösung hatte ich in meinem vorigen Post schon als EDIT nachgetragen.
Läuft bei mir problemlos, auch wenn zwischendurch die zehnder App die Daten abruft uns somit die Verbindung zu FHEM unterbricht.
Auch wenn ich FHEM beende/ neu starte oder den Raspberry stromlos mache etc. verbindet sich ccfhem automatisch wieder.
Schönen Sonntag noch.

[woody7]

Hallo zusammen,
stehe zur Zeit auf dem Schlauch - bin nur gelegentlicher Anwender!
Kann mir jemand ein Beispiel geben, wie ich ein Reading z.B. Bypass an-/steuern kann?
Vielen Dank im Voraus.
Gruß

[Phill]

Du musst dem Script ccfhem.py das Kommando über Port 7077 schicken. Das kann man über die Konsole z.B. mit

Code Auswählen Erweitern

echo CMD_BYPASS_ON | netcat localhost 7077
erreichen. Wenn du es aus FHEM heraus machen willst, musst du den Befehl in doppelte Anführungszeichen setzen, das ist in FHEM der Marker für ein Kommandozeilenbefehl.

Code Auswählen Erweitern

"echo CMD_BYPASS_OFF | netcat localhost 7077"

Gruß

[woody7]

Hallo Phill,
danke für die schnelle Rückmeldung.
Habs versucht, aber leider keine Reaktion.
Die Readings bleiben z.B. auf "Modus -1", obwohl ich "echo CMD_FAN_MODE_AWAY | netcat localhost 7077" in fhem eingegeben habe.
Allerdings würde ich gern via HTTP schalten (in etwa so: http://admin:xxx@ip:8085/fhem?cmd=set%20Stufe%201).
Aber Eines nach dem Anderen - scheinbar habe ich ja schon vorher ein Problem.
Hast Du eine Idee?
Gruß

[Phill]

Wird etwas in die fhem.log geschrieben? Oder gibt ccfhem.py etwas aus wenn du das Kommando absetzt?

[woody7]

Also im fhem.log steht nichts und wenn ich es in der Konsole eingebe, dann springt der Cursor in die nächste Zeile und die Konsole hängt sich auf/reagiert auf keinerlei Kommandos mehr.

... vielleicht liegt es daran, dass ich loxberry nutze?

[sido]

Hallo,
kann es sein, dass für die ganze Konstruktion aus ccfhem.py und comfoconnect Telnet auf dem Rechner wo es läuft, verfügbar sein muss? Ich bekomme nämlich immer ein Errno 111, Connection refused.
Ich meine ich hatte aus Sicherheitsgründen auf meinem Raspi Telnet deaktiviert. Kann das der Grund für den Fehler sein?

Gruß,
Sido

[Phill]

Ja richtig, die Verbindung wird über Telnet aufgebaut.

[sido]

Hallo Phill,
das war aber kompliziert...
Am Ende hat in FHEM folgendes gefehlt:
defmod tPort telnet 7072
um den telnet in FHEM zu aktivieren.
Zusätzlich musste ich dein Script explizit mit python3 starten:
python3 ccfhem.py ...

Jetzt geht es endlich.
Woher bekomme ich nun die Volumenströme?

Gruß,
Sido

[Phill]

Schau mal in das Script rein, da sind ein paar werte mit "#" auskommentiert.

Diese Werte haben mir persönlich zu viele Daten geliefert. Theoretisch sollte doch die aktuelle Stufe reichen, oder nicht?

[Fistandantilus]

Hallo zusammen,

ich habe jetzt auch mal versucht das Setup hinzubekommen, was aber noch nicht wirklich funktioniert.
Bei mir läuft noch Jessie mit Python 3.4 als default. Ich habe jetzt parallel die 3.5 installiert, die auch als default verwendet wird.
Dann mit pip3.5 install wheel pycomfoconnect die Installation durchgeführt.
FHEM ist auch vorbereitet.
phython3 --version zeigt mir die 3.5.2, sollte also passen.
Wenn ich jetzt python3 ccfhem.py aufrufe, findet er das Modul nicht: "ImportError: No module named 'pycomfoconnect'".

Was muss ich noch machen? Unter 3.4 liegt alles im Verzeichnis dist-packages, unter 3.5 im Verzeichnis site-packages.

VG
F.

[Fistandantilus]

So, ich konnte das Problem beheben. Ich hab jetzt einfach das Script in das Python Verzeichnis geschoben und starte es von da

Ich habe jetzt allerdings ein neues Problem. Rufe ich das Script über die Konsole auf:

Code Auswählen Erweitern

python3 /usr/local/lib/python3.5/site-packages/ccfhem.py

Läuft alles bestens.

Starte ich das über FHEM erhalte ich folgenden Fehler im LOG:

Code Auswählen Erweitern

Socket opened: localhost listen to 7077
localhost
7072
Traceback (most recent call last):
  File "/usr/local/lib/python3.5/site-packages/ccfhem.py", line 313, in <module>
    main()
  File "/usr/local/lib/python3.5/site-packages/ccfhem.py", line 208, in main
    bridge = bridge_discovery()
  File "/usr/local/lib/python3.5/site-packages/ccfhem.py", line 184, in bridge_discovery
    print("Bridge found: %s (%s)" % (bridge.uuid.hex(), bridge.host))
AttributeError: 'bytes' object has no attribute 'hex'

Konfiguriert ist es wie folgt:

Code Auswählen Erweitern

global:INITIALIZED.* {system("python3 /usr/local/lib/python3.5/site-packages/ccfhem.py &")}

[Fistandantilus]

Keiner eine Idee? Grundsätzlich, wenn ich das Script über die Konsole starte, bekomme ich im Device im FHEM auch brav meine Daten angezeigt, das passt also.

Noch ein weiterer Punkt:

Wie habt Ihr das mit der Steuerung im FHEM konfiguriert - über device dummies? Man kann ja über die Eingabe von beispielsweise "echo CMD_FAN_MODE_MEDIUM | netcat localhost 7077" die Stufe ändern. Schöner wäre das natürlich, wenn man das direkt über das device machen kann: set comfoconnect ...

Aktuell hab ich einen Dummy angelegt mit setlist state: 1,2,3,abwesend und kann dann mit doif reagieren und das commando absetzen.


VG
F.

[Fistandantilus]

Update: Ich habe den Fehler gefunden. Ich habe bei mir über pyenv python3.5 installiert, Standardmässig kommt Jessie nur mit 3.4. Leider passen dann aber die Pfade nicht mehr. Man kann zwar die globale Version über pyenv setzen -> damit lief dann auch das Script in der Console, allerdings hat FHEM Python3 über /usr/bin/ aufgerufen und dort auf die 3.4 verzweigt. Über einen Symlink konnte ich jetzt zwar das Script auch über FHEM starten (Prozess lief), allerdings startete die webui dann nicht mehr. Fhem status sagt aber running sehr komisch
Naja, jetzt habe ich einen Daemon gebaut, der das Script automatisch startet...

[Fistandantilus]

Hi Phill,

weißt Du, ob es möglich ist, das Datum für die Abwesenheit zu setzen? Oder reicht es die Anlage auf "CMD_FAN_MODE_AWAY" zu setzen. Ich bin mir nicht sicher, ob der Modus auch überschrieben wird vom Automatikmodus. Bei den anderen Stufen schaltet er ja, wenn man die Stufe manuell ändert, spätestens nach 2h wieder in die Automatik.
Ich habe bei mir in der Haussteuerung einen Urlaubsmodus eingebaut, bei dem ich die Anlage in der Urlaubszeit dann auch auf away setzen möchte.

VG F.

[Phill]

Es gibt drei modie Zustände.
Auto, timed manuel und manuel
1 5 und -1 soweit ich das jetzt aus dem Kopf noch weiß.
Wenn du vor "away" den Status explizit auf "manuel" setzt ist das Zeitprogramm ausgeschaltet bis du es selbst wieder auf Auto setzt.

[Fistandantilus]

Perfekt, das hilft!

[Fistandantilus]

Kurzes Update, welches auch für anderer interessant sein könnte. Bei mir enthielt die  /pycomfoconnect/const.py nicht alle Kommandos, die auch auf github im Original drin standen. Deshalb hat der erste Versuch mit  "echo CMD_MODE_MANUAL | netcat localhost 7077" auch nicht funktioniert und sich FHEM direkt mal aufgehängt. Nachdem ich die Kommandos dann ergänzt hatte, hat es auf Anhieb funktioniert.
Grundsätzlich musste ich bei meinen Dummies noch berücksichtigen, dass die Anlage auch von extern gesteuert werden kann und dann der Zustand nicht mehr konsistent ist, aber ansonsten passt das.
Im Frontend (SmartVisu) sieht das jetzt wie im Anhang aus. Die Modus-Umschaltung brauch ich da nicht, das wird ja dann nur im Hintergrund angetriggert, wenn ich in den Urlaub gehe.

[Fistandantilus]

Hallo zusammen,

ich habe gerade mein System aus verschiedenen Gründen komplett aufgesetzt und auch mit der Python Version jetzt keine Probleme mehr. Das Script starte ich jetzt auch wie hier im Thread angegeben mit:

Code Auswählen Erweitern

define FHEMStart notify global:INITIALIZED.* {system("/opt/loxberry/data/plugins/fhem/scripts/ccfhem.py --ip xxx.xxx.xxx.xxx &")}

Das funktioniert auch soweit gut. Was mich allerdings stört, sind die Logeinträge. Habt Ihr eine Idee, wie ich die noch los werde? Hab schon verbose=0 und DbLogExclude .* versucht - ohne Erfolg.

VG
F.

[Fistandantilus]

Hab es gerade selbst gelöst.

Im Script folgende Zeilen einfügen:

Code Auswählen Erweitern

import sys
sys.stdout = None

VG
F.

[dark-forest]

Hallo Zusammen,

ich bin absoluter FHEM Neuling. Habe es parallel auf meinen Raspberry Pi mit IO Broker am Laufen.
Die Installation von Python3, das speichern des Skripts, sowie das Anlegen des Dummys in FHEM
habe ich auch hinbekommen.
Wenn ich nun aber über Telnet das Skript starte kommen folgende Fehler:

Tut mir leid, dass ich euch damit belästige, komme aber einfach nicht weiter...

Code Auswählen Erweitern


/opt/fhem/scripts/ccfhem.py
Socket opened: localhost listen to 7077
localhost
7072
Bridge found: 00000000000d10128001144fd71e070d (192.168.178.7)
BRIDGE: write_message(): 00000000000000000000000000000010 -> 00000000000d10128001144fd71e070d: 08032001 0801
type: StartSessionRequestType
reference: 1

takeover: true

BRIDGE: read_message(): 00000000000d10128001144fd71e070d -> 00000000000000000000000000000010: 083510002001
type: StartSessionConfirmType
result: OK
reference: 1


BRIDGE: write_message(): 00000000000000000000000000000010 -> 00000000000d10128001144fd71e070d: 08652002
type: KeepAliveType
reference: 2

BRIDGE: write_message(): 00000000000000000000000000000010 -> 00000000000d10128001144fd71e070d: 08262003 08c00110011802
type: CnRpdoRequestType
reference: 3

pdid: 192
zone: 1
type: 2


BRIDGE: read_message(): 00000000000d10128001144fd71e070d -> 00000000000000000000000000000010: 0820 0801100118012002
type: CnNodeNotificationType

nodeId: 1
productId: 1
zoneId: 1
mode: NODE_NORMAL

BRIDGE: read_message(): 00000000000d10128001144fd71e070d -> 00000000000000000000000000000010: 0820 080d100518ff012002
type: CnNodeNotificationType

nodeId: 13
productId: 5
zoneId: 255
mode: NODE_NORMAL

BRIDGE: read_message(): 00000000000d10128001144fd71e070d -> 00000000000000000000000000000010: 082710002003
type: CnRpdoConfirmType
result: OK
reference: 3


BRIDGE: write_message(): 00000000000000000000000000000010 -> 00000000000d10128001144fd71e070d: 08262004 084110011801
type: CnRpdoRequestType
reference: 4

pdid: 65
zone: 1
type: 1

BRIDGE: read_message(): 00000000000d10128001144fd71e070d -> 00000000000000000000000000000010: 082710002004
type: CnRpdoConfirmType
result: OK
reference: 4


BRIDGE: write_message(): 00000000000000000000000000000010 -> 00000000000d10128001144fd71e070d: 08262005 08a20210011801
type: CnRpdoRequestType
reference: 5

pdid: 290
zone: 1
type: 1

BRIDGE: read_message(): 00000000000d10128001144fd71e070d -> 00000000000000000000000000000010: 082710002005
type: CnRpdoConfirmType
result: OK
reference: 5


BRIDGE: write_message(): 00000000000000000000000000000010 -> 00000000000d10128001144fd71e070d: 08262006 08a30210011801
type: CnRpdoRequestType
reference: 6

pdid: 291
zone: 1
type: 1

BRIDGE: read_message(): 00000000000d10128001144fd71e070d -> 00000000000000000000000000000010: 082710002006
type: CnRpdoConfirmType
result: OK
reference: 6


BRIDGE: write_message(): 00000000000000000000000000000010 -> 00000000000d10128001144fd71e070d: 08262007 08a40210011801
type: CnRpdoRequestType
reference: 7

pdid: 292
zone: 1
type: 1

BRIDGE: read_message(): 00000000000d10128001144fd71e070d -> 00000000000000000000000000000010: 082710002007
type: CnRpdoConfirmType
result: OK
reference: 7


BRIDGE: write_message(): 00000000000000000000000000000010 -> 00000000000d10128001144fd71e070d: 08262008 08a60210011801
type: CnRpdoRequestType
reference: 8

pdid: 294
zone: 1
type: 1

BRIDGE: read_message(): 00000000000d10128001144fd71e070d -> 00000000000000000000000000000010: 082710002008
type: CnRpdoConfirmType
result: OK
reference: 8


BRIDGE: write_message(): 00000000000000000000000000000010 -> 00000000000d10128001144fd71e070d: 08262009 08e30110011801
type: CnRpdoRequestType
reference: 9

pdid: 227
zone: 1
type: 1

BRIDGE: read_message(): 00000000000d10128001144fd71e070d -> 00000000000000000000000000000010: 082710002009
type: CnRpdoConfirmType
result: OK
reference: 9


BRIDGE: write_message(): 00000000000000000000000000000010 -> 00000000000d10128001144fd71e070d: 0826200a 083110011801
type: CnRpdoRequestType
reference: 10

pdid: 49
zone: 1
type: 1

BRIDGE: read_message(): 00000000000d10128001144fd71e070d -> 00000000000000000000000000000010: 08271000200a
type: CnRpdoConfirmType
result: OK
reference: 10


BRIDGE: write_message(): 00000000000000000000000000000010 -> 00000000000d10128001144fd71e070d: 0826200b 08920210011806
type: CnRpdoRequestType
reference: 11

pdid: 274
zone: 1
type: 6

BRIDGE: read_message(): 00000000000d10128001144fd71e070d -> 00000000000000000000000000000010: 08271000200b
type: CnRpdoConfirmType
result: OK
reference: 11


BRIDGE: write_message(): 00000000000000000000000000000010 -> 00000000000d10128001144fd71e070d: 0826200c 08930210011806
type: CnRpdoRequestType
reference: 12

pdid: 275
zone: 1
type: 6

BRIDGE: read_message(): 00000000000d10128001144fd71e070d -> 00000000000000000000000000000010: 0828 08c00112023d00
type: CnRpdoNotificationType

pdid: 192
data: "=\000"

192 = 61
BRIDGE: read_message(): 00000000000d10128001144fd71e070d -> 00000000000000000000000000000010: 0828 0841120102
type: CnRpdoNotificationType

pdid: 65
data: "\002"

65 = 2
BRIDGE: read_message(): 00000000000d10128001144fd71e070d -> 00000000000000000000000000000010: 08271000200c
type: CnRpdoConfirmType
result: OK
reference: 12


BRIDGE: write_message(): 00000000000000000000000000000010 -> 00000000000d10128001144fd71e070d: 0826200d 08940210011806
type: CnRpdoRequestType
reference: 13

pdid: 276
zone: 1
type: 6

BRIDGE: read_message(): 00000000000d10128001144fd71e070d -> 00000000000000000000000000000010: 08271000200d
type: CnRpdoConfirmType
result: OK
reference: 13


BRIDGE: write_message(): 00000000000000000000000000000010 -> 00000000000d10128001144fd71e070d: 0826200e 08dd0110011806
type: CnRpdoRequestType
reference: 14

pdid: 221
zone: 1
type: 6

BRIDGE: read_message(): 00000000000d10128001144fd71e070d -> 00000000000000000000000000000010: 08271000200e
type: CnRpdoConfirmType
result: OK
reference: 14


BRIDGE: write_message(): 00000000000000000000000000000010 -> 00000000000d10128001144fd71e070d: 0805200f
type: ListRegisteredAppsRequestType
reference: 15


BRIDGE: read_message(): 00000000000d10128001144fd71e070d -> 00000000000000000000000000000010: 0837200f 0a240a100967118d4f8f42f1bef58de381a83c7012106950686f6e6520766f6e204a6f7365660a1f0a10cd11975849c24c73b29712c0854c76dd120b4a6f7365667320695061640a180a100000000000000000000000000000001012044648454d
type: ListRegisteredAppsConfirmType
reference: 15

apps {
  uuid: "\tg\021\215O\217B\361\276\365\215\343\201\250<p"
  devicename: "iPhone von Josef"
}
apps {
  uuid: "\315\021\227XI\302Ls\262\227\022\300\205Lv\335"
  devicename: "Josefs iPad"
}
apps {
  uuid: "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020"
  devicename: "FHEM"
}

Traceback (most recent call last):
  File "/opt/fhem/scripts/ccfhem.py", line 313, in <module>
    main()
  File "/opt/fhem/scripts/ccfhem.py", line 260, in main
    setreading('registeredDevices', devices)
  File "/opt/fhem/scripts/ccfhem.py", line 163, in setreading
    fhemsend(cmd)
  File "/opt/fhem/scripts/ccfhem.py", line 150, in fhemsend
    fhem.send(msg.encode('ascii'))
BrokenPipeError: [Errno 32] Broken pipe
BRIDGE: read_message(): 00000000000d10128001144fd71e070d -> 00000000000000000000000000000010: 0828 08a30212013f
type: CnRpdoNotificationType

pdid: 291
data: "?"

291 = 63
Exception in thread Thread-2:
Traceback (most recent call last):
  File "/usr/lib/python3.5/threading.py", line 914, in _bootstrap_inner
    self.run()
  File "/usr/lib/python3.5/threading.py", line 862, in run
    self._target(*self._args, **self._kwargs)
  File "/usr/local/lib/python3.5/dist-packages/pycomfoconnect/comfoconnect.py", line 315, in _message_thread_loop
    self._handle_rpdo_notification(message)
  File "/usr/local/lib/python3.5/dist-packages/pycomfoconnect/comfoconnect.py", line 361, in _handle_rpdo_notification
    self.callback_sensor(message.msg.pdid, val)
  File "/opt/fhem/scripts/ccfhem.py", line 195, in callback_sensor
    setreading(var, value)
  File "/opt/fhem/scripts/ccfhem.py", line 163, in setreading
    fhemsend(cmd)
  File "/opt/fhem/scripts/ccfhem.py", line 150, in fhemsend
    fhem.send(msg.encode('ascii'))
BrokenPipeError: [Errno 32] Broken pipe

BRIDGE: write_message(): 00000000000000000000000000000010 -> 00000000000d10128001144fd71e070d: 08032010 0800
type: StartSessionRequestType
reference: 16

takeover: false

BRIDGE: read_message(): 00000000000d10128001144fd71e070d -> 00000000000000000000000000000010: 083510002010
type: StartSessionConfirmType
result: OK
reference: 16


BRIDGE: write_message(): 00000000000000000000000000000010 -> 00000000000d10128001144fd71e070d: 08652011
type: KeepAliveType
reference: 17


BRIDGE: write_message(): 00000000000000000000000000000010 -> 00000000000d10128001144fd71e070d: 08262012 08c00110011802
type: CnRpdoRequestType
reference: 18

pdid: 192
zone: 1
type: 2

BRIDGE: read_message(): 00000000000d10128001144fd71e070d -> 00000000000000000000000000000010: 0820 0801100118012002
type: CnNodeNotificationType

nodeId: 1
productId: 1
zoneId: 1
mode: NODE_NORMAL

BRIDGE: read_message(): 00000000000d10128001144fd71e070d -> 00000000000000000000000000000010: 0820 080d100518ff012002
type: CnNodeNotificationType

nodeId: 13
productId: 5
zoneId: 255
mode: NODE_NORMAL

BRIDGE: read_message(): 00000000000d10128001144fd71e070d -> 00000000000000000000000000000010: 082710002012
type: CnRpdoConfirmType
result: OK
reference: 18


BRIDGE: write_message(): 00000000000000000000000000000010 -> 00000000000d10128001144fd71e070d: 08262013 084110011801
type: CnRpdoRequestType
reference: 19

pdid: 65
zone: 1
type: 1

BRIDGE: read_message(): 00000000000d10128001144fd71e070d -> 00000000000000000000000000000010: 0828 08c00112023d00
type: CnRpdoNotificationType

pdid: 192
data: "=\000"

192 = 61
Exception in thread Thread-3:
Traceback (most recent call last):
  File "/usr/lib/python3.5/threading.py", line 914, in _bootstrap_inner
    self.run()
  File "/usr/lib/python3.5/threading.py", line 862, in run
    self._target(*self._args, **self._kwargs)
  File "/usr/local/lib/python3.5/dist-packages/pycomfoconnect/comfoconnect.py", line 315, in _message_thread_loop
    self._handle_rpdo_notification(message)
  File "/usr/local/lib/python3.5/dist-packages/pycomfoconnect/comfoconnect.py", line 361, in _handle_rpdo_notification
    self.callback_sensor(message.msg.pdid, val)
  File "/opt/fhem/scripts/ccfhem.py", line 195, in callback_sensor
    setreading(var, value)
  File "/opt/fhem/scripts/ccfhem.py", line 163, in setreading
    fhemsend(cmd)
  File "/opt/fhem/scripts/ccfhem.py", line 150, in fhemsend
    fhem.send(msg.encode('ascii'))
BrokenPipeError: [Errno 32] Broken pipe

Exception in thread Thread-1:
Traceback (most recent call last):
  File "/usr/lib/python3.5/threading.py", line 914, in _bootstrap_inner
    self.run()
  File "/usr/lib/python3.5/threading.py", line 862, in run
    self._target(*self._args, **self._kwargs)
  File "/usr/local/lib/python3.5/dist-packages/pycomfoconnect/comfoconnect.py", line 254, in _connection_thread_loop
    self.cmd_rpdo_request(sensor_id)
  File "/usr/local/lib/python3.5/dist-packages/pycomfoconnect/comfoconnect.py", line 480, in cmd_rpdo_request
    use_queue=use_queue
  File "/usr/local/lib/python3.5/dist-packages/pycomfoconnect/comfoconnect.py", line 157, in _command
    reply = self._get_reply(confirm_type, use_queue=use_queue)
  File "/usr/local/lib/python3.5/dist-packages/pycomfoconnect/comfoconnect.py", line 219, in _get_reply
    raise ValueError('Timeout waiting for response.')
ValueError: Timeout waiting for response.


[stixif]

Hallo Zusammen,

habe das gleich Problem wie dark-forest
kann hier wer evtl. n anhaltspunkt geben was das Problem sein könnte?!?
installiert ist raspbian buster auf einem PI3

[sn0000py]

Also habe es auch heute gerade mal installiert, und läuft mal etwas ... ab und zu schmiert es ab und es kommen keine WriteMEssage mehr durch.

Was mich auch interssiert weiss jemand wie diese Timer da laufen, an der app kann man ja auch timer setzten - Party mode für 2 stunden ein?

[hme0354]

Hat jemand schon eine Idee, wie man die Daten an Loxone weiterleiten kann?

[apollon9]

Hallo zusammen,
wer bisher Probleme mit gelegentliche Abbrüchen hatte (passiert insbesondere, wenn man parallel noch die Zehnder APP benutzt, dann läuft das Skript gerne mal in einen Timeout und bleibt hängen  - was es aber auch ohne ersichtlichen Grund ganz gern mal so gemacht hat):
Michael Arnauts hat eine neue Version seines 'pycomfoconnect' auf Github gestellt! (am 13.4.2020)
Wichtigstes Feature: "better error handling" - bei mir stellt sich das jetzt so dar, dass mit Öffnen der App eine entsprechende Meldung auf dem Logscreen aufläuft, aber das wichtigste: das Skript nimmt danach die Verbindung wieder auf!

Hoffe das hilft ..

Viele Grüße,
Leonhard

[sido]

Hallo Leonard,
wie kann ich denn sinnvoll upgraden? Muss ich alle Dateien von Hand ersetzen?
Wollte eigentlich mit
pip3 install --upgrade pycomfoconnect
upgraden, aber Michael hat scheinbar die Versionsnummer nicht erhöht, so dass bei mir nix upgegraded wird.

[sido]

Habe jetzt so das Upgrade erfolgreich geschafft:
sudo pip3 install --no-index --no-cache-dir --force-reinstall git+https://github.com/michaelarnauts/comfoconnect
Sicher sind nicht alle Optionen notwendig...

[hme0354]

Hat jemand eine Idee wie man einen Befehl über fhem im hex format an das comfoconnect schickt?

[hme0354]

hab gerade vom Entwickler des pycomfoconnect gehört, dass er an einer neuen Version arbeitet, die aber nicht kompatibel mit der Kommunikation der alten sein wird.

[mh83lox]

Hallo,
ich hänge bei/nach der Installation des Scripts. Es erscheint:

loxberry@loxberry:/opt/fhem/scripts $ /opt/fhem/scripts/ccfhem.py -h
  File "/opt/fhem/scripts/ccfhem.py", line 3
    import argparse import socket import ast from pycomfoconnect import *
                         ^
SyntaxError: invalid syntax


Was habe ich falsch gemacht?

[ChristianR77]

Hallo Zusammen!

hme0354 hat sich viel Zeit genommen und für mich das Script installiert. Es läuft seit einer Woche ohne größere Probleme.

Jetzt hab ich aber eine Problem mit dem UDP-Traffic. Mir würde der Status alle 1-5 Minuten locker ausreichen. Zur Zeit wird jede Sekunde ein Status an Loxone geschickt. Das verursacht mir zuviel Traffic und dadurch gehen andere UDPs verloren.

Hat jemand ne Idee, wie ich den Traffic reduzieren kann?

Grüße
Chris

[ChristianR77]

Hallo nochmal!


Unten ist mal das myUtils-File mit dem das UDP-Paket generiert wird.


Habe ich hier eine Möglichkeit ein Sendeintervall festzulegen? Falls nein, wo kann ich das machen?
Jetzt sendet er UDP-Pakete im Sekundentakt - und das ist mir eindeutig zu häufig.


Grüße
Chris



[/code]

Code Auswählen Erweitern

[font=verdana][size=78%]##############################################[/font][/size]
# $Id: myUtilsTemplate.pm 7570 2015-01-14 18:31:44Z rudolfkoenig $
#
# Save this file as 99_myUtils.pm, and create your own functions in the new
# file. They are then available in every Perl expression.


package main;


use strict;
use warnings;
use POSIX;


sub
myUtils_Initialize($$)
{
  my ($hash) = @_;
}


# Enter you functions below _this_ line.


#UDP Befehle senden
sub UDP_Msg($$$)
{
my ($dest,$port,$cmd) = @_;
my $sock = IO::Socket::INET->new(
Proto => 'udp',
PeerPort => $port,
PeerAddr => $dest
) or die "Could not create socket: $!\n";
$sock->send($cmd) or die "Send error: $!\n";
return "send $cmd";
}


#HarmonyActivityToLoxone
#1 currentActivity
#2 state


sub Q350ToLoxone($)
{
my ($device) = @_;
my
$Abluftfeuchte=ReadingsVal("$device","Abluftfeuchte","-1");
my
$Ablufttemperatur=ReadingsVal("$device","Ablufttemperatur","-1");
my
$Abluftventilatorvolumen=ReadingsVal("$device","Abluftventilatorvolumen","-1");
my
$Aussenluftfeuchte=ReadingsVal("$device","Aussenluftfeuchte","-1");
my
$Aussenlufttemperatur=ReadingsVal("$device","Aussenlufttemperatur","-1");
my
$Bypass=ReadingsVal("$device","Bypass","-1");
my
$Filterwechsel=ReadingsVal("$device","Filterwechsel","-1");
my
$Fortluftfeuchte=ReadingsVal("$device","Fortluftfeuchte","-1");
my
$Fortlufttemperatur=ReadingsVal("$device","Fortlufttemperatur","-1");
my
$Leistung=ReadingsVal("$device","Leistung","-1");
my
$ModusTXT=ReadingsVal("$device","Modus","-1");
my
$Stufe=ReadingsVal("$device","Stufe","-1");
my
$Zuluftfeuchte=ReadingsVal("$device","Zuluftfeuchte","-1");
my
$Zulufttemperatur=ReadingsVal("$device","Zulufttemperatur","-1");
my
$Zuluftventilatorvolumen=ReadingsVal("$device","Zuluftventilatorvolumen","-1");
my
$NextTime=ReadingsVal("$device","NextTime","-1");
my
$BYPASS_MODUS=ReadingsVal("$device","BYPASS_MODUS","-1");
my
$BypassZeit=ReadingsVal("$device","BypassZeit","-1");
my
$Temperaturprofil=ReadingsVal("$device","Temperaturprofil","-1");
my
$DrehzahlAbluftventilator=ReadingsVal("$device","DrehzahlAbluftventilator","-1");
my
$DrehzahlZuluftventilator=ReadingsVal("$device","DrehzahlZuluftventilator","-1");


UDP_Msg("192.168.178.65" , "7002" , "$device: $Abluftfeuchte $Ablufttemperatur $Abluftventilatorvolumen $Aussenluftfeuchte $Aussenlufttemperatur $Bypass $Filterwechsel $Fortluftfeuchte $Fortlufttemperatur $Leistung $ModusTXT $Stufe $Zuluftfeuchte $Zulufttemperatur $Zuluftventilatorvolumen $NextTime $BYPASS_MODUS $BypassZeit $Temperaturprofil $DrehzahlAbluftventilator $DrehzahlZuluftventilator");
}


1;

[stixif]

Hi, und frohe Ostern

hat evtl. schon wer das script von Phill (ccfhem.py) auf
die neue pycomfoconnect version (0.4) umgebaut??
oder gibt es hier schon eine andere Lösung um die werte zu lesen
und befehle zu senden??

hab ganz frisch
pip3 install pycomfoconnect

Code Auswählen Erweitern


pip3 install pycomfoconnect
Looking in indexes: https://pypi.org/simple, https://www.piwheels.org/simple
Collecting pycomfoconnect
Using cached https://www.piwheels.org/simple/pycomfoconnect/pycomfoconnect-0.4-py3-none-any.whl (21 kB)
Requirement already satisfied: protobuf>=3.0.0 in /usr/local/lib/python3.7/dist-packages (from pycomfoconnect) (3.9.1)
Requirement already satisfied: six>=1.9 in /usr/lib/python3/dist-packages (from protobuf>=3.0.0->pycomfoconnect) (1.12.0)
Requirement already satisfied: setuptools in /usr/lib/python3/dist-packages (from protobuf>=3.0.0->pycomfoconnect) (40.8.0)
Installing collected packages: pycomfoconnect
Successfully installed pycomfoconnect-0.4


und die ccfhem.py von hier:
https://github.com/hme0354/lox2comfoconnectwithfhem/blob/main/ccfhem.py

bekomme nun aber diese Meldung im Log:

Code Auswählen Erweitern


2021.04.04 20:27:02 3: FHEMStart return value: -1
2021.04.04 20:27:02 0: Featurelevel: 6
2021.04.04 20:27:02 0: Server started with 13 defined entities (fhem.pl:23904/2021-03-07 perl:5.028001 os:linux user:fhem pid:3686)
Traceback (most recent call last):
  File "/opt/fhem/scripts/ccfhem.py", line 561, in <module>
    main()
  File "/opt/fhem/scripts/ccfhem.py", line 499, in main
    comfoconnect.register_sensor(regno)
  File "/usr/local/lib/python3.7/dist-packages/pycomfoconnect/comfoconnect.py", line 176, in register_sensor
    raise Exception("Registering sensor %d with unknown type" % sensor_id)
Exception: Registering sensor 277 with unknown type
Exception in thread Thread-2:
Traceback (most recent call last):
  File "/usr/lib/python3.7/threading.py", line 917, in _bootstrap_inner
    self.run()
  File "/usr/lib/python3.7/threading.py", line 865, in run
    self._target(*self._args, **self._kwargs)
  File "/usr/local/lib/python3.7/dist-packages/pycomfoconnect/comfoconnect.py", line 388, in _message_thread_loop
    self._handle_rpdo_notification(message)
  File "/usr/local/lib/python3.7/dist-packages/pycomfoconnect/comfoconnect.py", line 438, in _handle_rpdo_notification
    self.callback_sensor(message.msg.pdid, val)
  File "/opt/fhem/scripts/ccfhem.py", line 443, in callback_sensor
    setreading(var, value)
  File "/opt/fhem/scripts/ccfhem.py", line 411, in setreading
    fhemsend(cmd)
  File "/opt/fhem/scripts/ccfhem.py", line 398, in fhemsend
    fhem.send(msg.encode('ascii'))
UnicodeEncodeError: 'ascii' codec can't encode character '\xdf' in position 42: ordinal not in range(128)

Exception in thread Thread-3:
Traceback (most recent call last):
  File "/usr/lib/python3.7/threading.py", line 917, in _bootstrap_inner
    self.run()
  File "/usr/lib/python3.7/threading.py", line 865, in run
    self._target(*self._args, **self._kwargs)
  File "/usr/local/lib/python3.7/dist-packages/pycomfoconnect/comfoconnect.py", line 388, in _message_thread_loop
    self._handle_rpdo_notification(message)
  File "/usr/local/lib/python3.7/dist-packages/pycomfoconnect/comfoconnect.py", line 438, in _handle_rpdo_notification
    self.callback_sensor(message.msg.pdid, val)
  File "/opt/fhem/scripts/ccfhem.py", line 443, in callback_sensor
    setreading(var, value)
  File "/opt/fhem/scripts/ccfhem.py", line 411, in setreading
    fhemsend(cmd)
  File "/opt/fhem/scripts/ccfhem.py", line 398, in fhemsend
    fhem.send(msg.encode('ascii'))
UnicodeEncodeError: 'ascii' codec can't encode character '\xdf' in position 42: ordinal not in range(128)

Exception in thread Thread-4:
Traceback (most recent call last):
  File "/usr/lib/python3.7/threading.py", line 917, in _bootstrap_inner
    self.run()
  File "/usr/lib/python3.7/threading.py", line 865, in run
    self._target(*self._args, **self._kwargs)
  File "/usr/local/lib/python3.7/dist-packages/pycomfoconnect/comfoconnect.py", line 388, in _message_thread_loop
    self._handle_rpdo_notification(message)
  File "/usr/local/lib/python3.7/dist-packages/pycomfoconnect/comfoconnect.py", line 438, in _handle_rpdo_notification
    self.callback_sensor(message.msg.pdid, val)
  File "/opt/fhem/scripts/ccfhem.py", line 443, in callback_sensor
    setreading(var, value)
  File "/opt/fhem/scripts/ccfhem.py", line 411, in setreading
    fhemsend(cmd)
  File "/opt/fhem/scripts/ccfhem.py", line 398, in fhemsend
    fhem.send(msg.encode('ascii'))
UnicodeEncodeError: 'ascii' codec can't encode character '\xdf' in position 42: ordinal not in range(128)

Exception in thread Thread-5:
Traceback (most recent call last):
  File "/usr/lib/python3.7/threading.py", line 917, in _bootstrap_inner
    self.run()
  File "/usr/lib/python3.7/threading.py", line 865, in run
    self._target(*self._args, **self._kwargs)
  File "/usr/local/lib/python3.7/dist-packages/pycomfoconnect/comfoconnect.py", line 388, in _message_thread_loop
    self._handle_rpdo_notification(message)
  File "/usr/local/lib/python3.7/dist-packages/pycomfoconnect/comfoconnect.py", line 438, in _handle_rpdo_notification
    self.callback_sensor(message.msg.pdid, val)
  File "/opt/fhem/scripts/ccfhem.py", line 443, in callback_sensor
    setreading(var, value)
  File "/opt/fhem/scripts/ccfhem.py", line 411, in setreading
    fhemsend(cmd)
  File "/opt/fhem/scripts/ccfhem.py", line 398, in fhemsend
    fhem.send(msg.encode('ascii'))
UnicodeEncodeError: 'ascii' codec can't encode character '\xdf' in position 42: ordinal not in range(128)

Exception in thread Thread-6:
Traceback (most recent call last):
  File "/usr/lib/python3.7/threading.py", line 917, in _bootstrap_inner
    self.run()
  File "/usr/lib/python3.7/threading.py", line 865, in run
    self._target(*self._args, **self._kwargs)
  File "/usr/local/lib/python3.7/dist-packages/pycomfoconnect/comfoconnect.py", line 388, in _message_thread_loop
    self._handle_rpdo_notification(message)
  File "/usr/local/lib/python3.7/dist-packages/pycomfoconnect/comfoconnect.py", line 438, in _handle_rpdo_notification
    self.callback_sensor(message.msg.pdid, val)
  File "/opt/fhem/scripts/ccfhem.py", line 443, in callback_sensor
    setreading(var, value)
  File "/opt/fhem/scripts/ccfhem.py", line 411, in setreading
    fhemsend(cmd)
  File "/opt/fhem/scripts/ccfhem.py", line 398, in fhemsend
    fhem.send(msg.encode('ascii'))
UnicodeEncodeError: 'ascii' codec can't encode character '\xdf' in position 42: ordinal not in range(128)

Exception in thread Thread-7:
Traceback (most recent call last):
  File "/usr/lib/python3.7/threading.py", line 917, in _bootstrap_inner
    self.run()
  File "/usr/lib/python3.7/threading.py", line 865, in run
    self._target(*self._args, **self._kwargs)
  File "/usr/local/lib/python3.7/dist-packages/pycomfoconnect/comfoconnect.py", line 388, in _message_thread_loop
    self._handle_rpdo_notification(message)
  File "/usr/local/lib/python3.7/dist-packages/pycomfoconnect/comfoconnect.py", line 438, in _handle_rpdo_notification
    self.callback_sensor(message.msg.pdid, val)
  File "/opt/fhem/scripts/ccfhem.py", line 443, in callback_sensor
    setreading(var, value)
  File "/opt/fhem/scripts/ccfhem.py", line 411, in setreading
    fhemsend(cmd)
  File "/opt/fhem/scripts/ccfhem.py", line 398, in fhemsend
    fhem.send(msg.encode('ascii'))
UnicodeEncodeError: 'ascii' codec can't encode character '\xdf' in position 42: ordinal not in range(128)

Exception in thread Thread-8:
Traceback (most recent call last):
  File "/usr/lib/python3.7/threading.py", line 917, in _bootstrap_inner
    self.run()
  File "/usr/lib/python3.7/threading.py", line 865, in run
    self._target(*self._args, **self._kwargs)
  File "/usr/local/lib/python3.7/dist-packages/pycomfoconnect/comfoconnect.py", line 388, in _message_thread_loop
    self._handle_rpdo_notification(message)
  File "/usr/local/lib/python3.7/dist-packages/pycomfoconnect/comfoconnect.py", line 438, in _handle_rpdo_notification
    self.callback_sensor(message.msg.pdid, val)
  File "/opt/fhem/scripts/ccfhem.py", line 443, in callback_sensor
    setreading(var, value)
  File "/opt/fhem/scripts/ccfhem.py", line 411, in setreading
    fhemsend(cmd)
  File "/opt/fhem/scripts/ccfhem.py", line 398, in fhemsend
    fhem.send(msg.encode('ascii'))
UnicodeEncodeError: 'ascii' codec can't encode character '\xdf' in position 42: ordinal not in range(128)

Exception in thread Thread-9:
Traceback (most recent call last):
  File "/usr/lib/python3.7/threading.py", line 917, in _bootstrap_inner
    self.run()
  File "/usr/lib/python3.7/threading.py", line 865, in run
    self._target(*self._args, **self._kwargs)
  File "/usr/local/lib/python3.7/dist-packages/pycomfoconnect/comfoconnect.py", line 388, in _message_thread_loop
    self._handle_rpdo_notification(message)
  File "/usr/local/lib/python3.7/dist-packages/pycomfoconnect/comfoconnect.py", line 438, in _handle_rpdo_notification
    self.callback_sensor(message.msg.pdid, val)
  File "/opt/fhem/scripts/ccfhem.py", line 443, in callback_sensor
    setreading(var, value)
  File "/opt/fhem/scripts/ccfhem.py", line 411, in setreading
    fhemsend(cmd)
  File "/opt/fhem/scripts/ccfhem.py", line 398, in fhemsend
    fhem.send(msg.encode('ascii'))
UnicodeEncodeError: 'ascii' codec can't encode character '\xdf' in position 42: ordinal not in range(128)

Exception in thread Thread-10:
Traceback (most recent call last):
  File "/usr/lib/python3.7/threading.py", line 917, in _bootstrap_inner
    self.run()
  File "/usr/lib/python3.7/threading.py", line 865, in run
    self._target(*self._args, **self._kwargs)
  File "/usr/local/lib/python3.7/dist-packages/pycomfoconnect/comfoconnect.py", line 388, in _message_thread_loop
    self._handle_rpdo_notification(message)
  File "/usr/local/lib/python3.7/dist-packages/pycomfoconnect/comfoconnect.py", line 438, in _handle_rpdo_notification
    self.callback_sensor(message.msg.pdid, val)
  File "/opt/fhem/scripts/ccfhem.py", line 443, in callback_sensor
    setreading(var, value)
  File "/opt/fhem/scripts/ccfhem.py", line 411, in setreading
    fhemsend(cmd)
  File "/opt/fhem/scripts/ccfhem.py", line 398, in fhemsend
    fhem.send(msg.encode('ascii'))
UnicodeEncodeError: 'ascii' codec can't encode character '\xdf' in position 42: ordinal not in range(128)



die Readings kommen...


grüße
stixi

[stixif]

habs für mich lösen können...
mit aktueller comfoconnect Version (0.4)

hab mir hier einiges abgeschaut:
https://github.com/hme0354

ccfhem.py so angepasst:

Code Auswählen Erweitern


#!/usr/bin/python3

### Version 0.0.1

import argparse
import socket
import ast

import sys
sys.stdout = None

from pycomfoconnect import *

#TODO check for version
#pip3 show pycomfoconnect | grep Version
#print(socket.__version__)

############# Argumentparsing and definition #################

pin = 0
local_name = 'FHEM'
local_uuid = bytes.fromhex('00000000000000000000000000000010')


parser = argparse.ArgumentParser()
parser.add_argument('--host', help='fhem server address. (localhost)')
parser.add_argument('--port', help='fhem telnet port. (7072)')
parser.add_argument('--servport', help='port to listen for commands. (7077)')
parser.add_argument('--ip', help='ip address of the comfocontrol bridge (auto)')
parser.add_argument('--fhemdummy', help='name of the fhem dummy (comfoconnect)')
args = parser.parse_args()

args.host = 'localhost' if args.host == None else args.host
args.port = 7072 if args.port == None else args.port

args.servport = 7077 if args.servport == None else args.servport
servhost = 'localhost'

args.fhemdummy = "comfoconnect" if args.fhemdummy == None else args.fhemdummy


conf = {
16 : {
  'NAME' : 'ModusAbwesend',
  'TYPE' : 1
},
# 33 : {
  # 'NAME' : 'Test33',
  # 'TYPE' : 1
# },
# 37 : {
  # 'NAME' : 'Test37',
  # 'TYPE' : 1
# },
49 : {
  'NAME' : 'Modus',
  'TYPE' : 1
},
# 53 : {
  # 'NAME' : 'Test53',
  # 'TYPE' : 1
# },
  56 : {
   'NAME' : 'ModusAutoManuell',
   'TYPE' : 1
  },
  65 : {
   'NAME' : 'Stufe',
   'TYPE' : 1,
   'CONV' : 'str(%i)[-1:]'
  },
  66 : {
   'NAME' : 'ModusBypass',
   'TYPE' : 1
  },
  67 : {
   'NAME' : 'ModusTemperaturprofil',
   'TYPE' : 1
  },
  70 : {
   'NAME' : 'ModusNurZuluftventilator',
   'TYPE' : 1
  },
  71 : {
   'NAME' : 'ModusNurAbluftventilator',
   'TYPE' : 1
  },
81 : {
  'NAME' : 'ZeitAllgemeinHex',
  'TYPE' : 3
},
82 : {
  'NAME' : 'ZeitBypassHex',
  'TYPE' : 3
},
# 85 : {
  # 'NAME' : 'Test85',
  # 'TYPE' : 3
# },
86 : {
  'NAME' : 'ZeitZuluftHEX',
  'TYPE' : 3
},
87 : {
  'NAME' : 'ZeitAbluftHEX',
  'TYPE' : 3
},
117 : {
   'NAME' : 'VentilatorLeistungAbluft',
   'TYPE' : 1,
   'UNIT' : '%'
  },
  118 : {
   'NAME' : 'VentilatorLeistungZuluft',
   'TYPE' : 1,
   'UNIT' : '%'
  },
  119 : {
   'NAME' : 'VentilatorVolumenAbluft',
   'TYPE' : 2,
   'UNIT' : 'm³/h'
  },
  120 : {
   'NAME' : 'VentilatorVolumenZuluft',
   'TYPE' : 2,
   'UNIT' : 'm³/h'
  },
  121 : {
   'NAME' : 'VentilatorDrehzahlAbluft',
   'TYPE' : 2,
   'UNIT' : 'U/min'
  },
  122 : {
   'NAME' : 'VentilatorDrehzahlZuluft',
   'TYPE' : 2,
   'UNIT' : 'U/min'
  },
  128 : {
   'NAME' : 'VerbrauchLueftungAktuell',
   'TYPE' : 2,
   'UNIT' : 'W'
  },
  129 : {
   'NAME' : 'VerbrauchLueftungLaufendesJahr',
   'TYPE' : 2  
  },
  130 : {
   'NAME' : 'VerbrauchLueftungGesamt',
   'TYPE' : 2
  },
# 144 : {
  # 'NAME' : 'VerbrauchVorheizregisterProJahr',
  # 'TYPE' : 2,
  # 'UNIT' : 'W'
# },
# 145 : {
  # 'NAME' : 'VerbrauchVorheizregisterGesamt',
  # 'TYPE' : 2,
  # 'UNIT' : 'kWh'
# },
# 146 : {
  # 'NAME' : 'LeistungVorheizregisterIST',
  # 'TYPE' : 2,
  # 'UNIT' : 'kWh'
# },
  176 : {
   'NAME' : 'SETTING RF PAIRING',
   'TYPE' : 1
  },
  192 : {
   'NAME' : 'ZeitFilterwechsel',
   'TYPE' : 2,
   'UNIT' : 'Tage'
  },
  208 : {
   'NAME' : 'EinstellungEinheitGUI',
   'TYPE' : 1
  },
  209 : {
    'NAME' : 'GrenztemeraturAktuell',
    'TYPE' : 6,
    'CONV' : "%i / 10",
    'UNIT' : '°C'
  },
  210 : {
   'NAME' : 'ModusHeizperiode',
   'TYPE' : 0
  },
  211 : {
   'NAME' : 'ModusKuehlperiode',
   'TYPE' : 0
  },
  212 : {
   'NAME' : 'TemperaturSollRegelung',
   'TYPE' : 6,
   'CONV' : "%i / 10",
   'UNIT' : '°C'
  },
  213 : {
   'NAME' : 'VerbrauchVermiedenerHeizstrom',
   'TYPE' : 2,
   'UNIT' : 'W'
  },
  214 : {
   'NAME' : 'VerbrauchVermiedenerHeizstromJahr',
   'TYPE' : 2,
   'UNIT' : 'kWh'
  },
  215 : {
   'NAME' : 'VerbrauchVermiedenerHeizstromGesamt',
   'TYPE' : 2,
   'UNIT' : 'kWh'
  },
# 219 : {
  # 'NAME' : 'LeistungVorheizregisterSOLL',
  # 'TYPE' : 2  
# },
  221 : {
   'NAME' : 'TemperaturZuluftInnen',
   'TYPE' : 6,
   'CONV' : "%i / 10",
   'UNIT' : '°C'
  },
# 224 : {
  # 'NAME' : 'Test224',
  # 'TYPE' : 1
# },
  225 : {
   'NAME' : 'ModusKomfortregelung',
   'TYPE' : 1
  },
# 226 : {
  # 'NAME' : 'Test226',
  # 'TYPE' : 2
# },
  227 : {
   'NAME' : 'ZustandBypass',
   'TYPE' : 1,
   'UNIT' : '%'
  },
  228 : {
   'NAME' : 'ZustandFrostschutzAusgleich',
   'TYPE' : 1
  },
  274 : {
   'NAME' : 'TemperaturAbluftInnen',
   'TYPE' : 6,
   'CONV' : "%i / 10",
   'UNIT' : '°C'
  },
  275 : {
   'NAME' : 'TemperaturAbluftAussen',
   'TYPE' : 6,
   'CONV' : "%i / 10",
   'UNIT' : '°C'
  },
  276 : {
   'NAME' : 'TemperaturZuluftAussen',
   'TYPE' : 6,
   'CONV' : "%i / 10",
   'UNIT' : '°C'
  },
# 277 : {
  # 'NAME' : 'TemperaturNachVorheizregister',
  # 'TYPE' : 6,
  # 'CONV' : "%i / 10",
  # 'UNIT' : '°C'
# },
  290 : {
   'NAME' : 'LuftfeuchteAbluftInnen',
   'TYPE' : 1,
   'UNIT' : '%'
  },
  291 : {
   'NAME' : 'LuftfeuchteAbluftAussen',
   'TYPE' : 1,
   'UNIT' : '%'
  },
  292 : {
   'NAME' : 'LuftfeuchteZuluftAussen',
   'TYPE' : 1,
   'UNIT' : '%'
  },
  # 293 : {
   # 'NAME' : 'LuftfeuchtNachVorheizregister',
   # 'TYPE' : 1,
   # 'UNIT' : '%'
  # },
  294 : {
   'NAME' : 'LuftfeuchteZuluftInnen',
   'TYPE' : 1,
   'UNIT' : '%'
  }
# 321 : {
  # 'NAME' : 'Test321',
  # 'TYPE' : 2
# },
# 325 : {
  # 'NAME' : 'Test325',
  # 'TYPE' : 3
# },
# 341 : {
  # 'NAME' : 'Test341',
  # 'TYPE' : 3
# },
# 369 : {
  # 'NAME' : 'Test369',
  # 'TYPE' : 1
# },
# 370 : {
  # 'NAME' : 'Test370',
  # 'TYPE' : 1
# },
# 371 : {
  # 'NAME' : 'Test371',
  # 'TYPE' : 1
# },
# 372 : {
  # 'NAME' : 'Test372',
  # 'TYPE' : 1
# },
# 384 : {
  # 'NAME' : 'Test384',
  # 'TYPE' : 6
# },
# 386 : {
  # 'NAME' : 'Test386',
  # 'TYPE' : 0
# },
# 400 : {
  # 'NAME' : 'Test400',
  # 'TYPE' : 6
# },
# 401 : {
  # 'NAME' : 'Test401',
  # 'TYPE' : 1
# },
# 402 : {
  # 'NAME' : 'Test402',
  # 'TYPE' : 0
# },
# 416 : {
  # 'NAME' : 'Test416',
  # 'TYPE' : 6
# },
# 417 : {
  # 'NAME' : 'Test417',
  # 'TYPE' : 6
# },
# 418 : {
  # 'NAME' : 'Test418',
  # 'TYPE' : 1
# },
# 419 : {
  # 'NAME' : 'Test419',
  # 'TYPE' : 0
# }

}


############# Create incomming connections #################

serv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

serv.bind((servhost, args.servport))
serv.listen(5)

print("Socket opened: %s listen to %s" % (servhost,args.servport))

def send(client, msg):
msg+="\r\n"
client.send(msg.encode('ascii'))


############# Create Outgoing FHEM connection ###################

print(args.host)
print(args.port)
fhem = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
fhem.connect((args.host, args.port))

def fhemsend(msg):
## fhem send here for comfoconnect requests
msg+="\r\n"
fhem.send(msg.encode('ascii'))

   
def setreading(var, value):
# setreading <devspec> <reading> <value>
#cmd = "setreading " + args.fhemdummy + " " + var + " " + value
#temp = eval(conf[var]['CONV'] % (val))
#print("%s hat %s " % (conf[var]['CONST'], temp))
if var in conf:
if 'CONV' in conf[var]:
value = eval(conf[var]['CONV'] % (value))
var = conf[var]['NAME']
cmd = "setreading %s %s %s" % (args.fhemdummy, str(var), str(value))
#print(cmd)
fhemsend(cmd)



############## Bridge discovery ###################################

def bridge_discovery():

    bridges = Bridge.discover(args.ip)
    if bridges:
        bridge = bridges[0]
    else:
        bridge = None

    # Method 3: Setup bridge manually
    # bridge = Bridge(args.ip, bytes.fromhex('0000000000251010800170b3d54264b4'))

    if bridge is None:
        print("No bridges found!")
        exit(1)

    print("Bridge found: %s (%s)" % (bridge.uuid.hex(), bridge.host))
    bridge.debug = True

    return bridge


################# Callback sensors ####################################

def callback_sensor(var, value):

    print("%s = %s" % (var, value))
    setreading(var, value)





def main():
    def request(req):
     if req.startswith("CMD_"):
      comfoconnect.cmd_rmi_request(eval(req))
     else:
      print("Unkown Command: " + req)
    # Discover the bridge
    bridge = bridge_discovery()

    ## Setup a Comfoconnect session  ###################################################################################

    comfoconnect = ComfoConnect(bridge, local_uuid, local_name, pin)
    comfoconnect.callback_sensor = callback_sensor

    try:
        # Connect to the bridge
        # comfoconnect.connect(False)  # Don't disconnect existing clients.
        comfoconnect.connect(True)  # Disconnect existing clients.

    except Exception as e:
        print('ERROR: %s' % e)
        exit(1)

    ## Register sensors ################################################################################################

    # comfoconnect.register_sensor(SENSOR_FAN_NEXT_CHANGE)  # General: Countdown until next fan speed change
    # comfoconnect.register_sensor(SENSOR_FAN_SPEED_MODE)  # Fans: Fan speed setting
    # comfoconnect.register_sensor(SENSOR_FAN_SUPPLY_DUTY)  # Fans: Supply fan duty
    # comfoconnect.register_sensor(SENSOR_FAN_EXHAUST_DUTY)  # Fans: Exhaust fan duty
    # comfoconnect.register_sensor(SENSOR_FAN_SUPPLY_FLOW)  # Fans: Supply fan flow
    # comfoconnect.register_sensor(SENSOR_FAN_EXHAUST_FLOW)  # Fans: Exhaust fan flow
    # comfoconnect.register_sensor(SENSOR_FAN_SUPPLY_SPEED)  # Fans: Supply fan speed
    # comfoconnect.register_sensor(SENSOR_FAN_EXHAUST_SPEED)  # Fans: Exhaust fan speed
    # comfoconnect.register_sensor(SENSOR_POWER_CURRENT)  # Power Consumption: Current Ventilation
    # comfoconnect.register_sensor(SENSOR_POWER_TOTAL_YEAR)  # Power Consumption: Total year-to-date
    # comfoconnect.register_sensor(SENSOR_POWER_TOTAL)  # Power Consumption: Total from start
    # comfoconnect.register_sensor(SENSOR_DAYS_TO_REPLACE_FILTER)  # Days left before filters must be replaced
    # comfoconnect.register_sensor(SENSOR_AVOIDED_HEATING_CURRENT)  # Avoided Heating: Avoided actual
    # comfoconnect.register_sensor(SENSOR_AVOIDED_HEATING_TOTAL_YEAR)  # Avoided Heating: Avoided year-to-date
    # comfoconnect.register_sensor(SENSOR_AVOIDED_HEATING_TOTAL)  # Avoided Heating: Avoided total
    # comfoconnect.register_sensor(SENSOR_TEMPERATURE_SUPPLY)  # Temperature & Humidity: Supply Air (temperature)
    # comfoconnect.register_sensor(SENSOR_TEMPERATURE_EXTRACT)  # Temperature & Humidity: Extract Air (temperature)
    # comfoconnect.register_sensor(SENSOR_TEMPERATURE_EXHAUST)  # Temperature & Humidity: Exhaust Air (temperature)
    # comfoconnect.register_sensor(SENSOR_TEMPERATURE_OUTDOOR)  # Temperature & Humidity: Outdoor Air (temperature)
    # comfoconnect.register_sensor(SENSOR_HUMIDITY_SUPPLY)  # Temperature & Humidity: Supply Air (temperature)
    # comfoconnect.register_sensor(SENSOR_HUMIDITY_EXTRACT)  # Temperature & Humidity: Extract Air (temperature)
    # comfoconnect.register_sensor(SENSOR_HUMIDITY_EXHAUST)  # Temperature & Humidity: Exhaust Air (temperature)
    # comfoconnect.register_sensor(SENSOR_HUMIDITY_OUTDOOR)  # Temperature & Humidity: Outdoor Air (temperature)
    # comfoconnect.register_sensor(SENSOR_BYPASS_STATE)  # Bypass state
    for regno in conf.keys():
       comfoconnect.register_sensor(regno)

    ## Execute functions ###############################################################################################

    # ListRegisteredApps
    devices=''
    for app in comfoconnect.cmd_list_registered_apps():
        # print('%s: %s' % (app['uuid'].hex(), app['devicename']))
        devices+=app['devicename']+" "
    setreading('registeredDevices', devices)


    # DeregisterApp
    # comfoconnect.cmd_deregister_app(bytes.fromhex('00000000000000000000000000000001'))

    # VersionRequest
    version = comfoconnect.cmd_version_request()
    for key in version:
      setreading(key, version[key])
    # TimeRequest
    #timeinfo = comfoconnect.cmd_time_request()
    #print(timeinfo)

    ## Executing functions #############################################################################################

#     comfoconnect.cmd_rmi_request(CMD_FAN_MODE_AWAY)  # Go to away mode
#     comfoconnect.cmd_rmi_request(CMD_FAN_MODE_LOW)  # Set fan speed to 1
#     comfoconnect.cmd_rmi_request(CMD_FAN_MODE_MEDIUM)  # Set fan speed to 2
#     comfoconnect.cmd_rmi_request(CMD_FAN_MODE_HIGH)  # Set fan speed to 3

    ## Example interaction #############################################################################################

    try:
        print('Waiting... Stop with CTRL+C')
        while True:
            # Callback messages will arrive in the callback method.
            clien,addr = serv.accept()
            print("Got a connection from %s" % str(addr))
            send(clien, "Connection accepted")
            msg=clien.recv(1024)
            # commandhandler here
            strdec=str(msg.decode('ascii'))
            print ('Message received: ' + strdec)
            request(strdec)
            clien.close()

            if not comfoconnect.is_connected():
                print('We are not connected anymore...')




    except KeyboardInterrupt:
        pass

    ## Closing the session #############################################################################################

    fhem.close()
    comfoconnect.disconnect()


if __name__ == "__main__":
    main()




und die const.py so:

Code Auswählen Erweitern


# Commands
CMD_FAN_MODE_AWAY               = b'\x84\x15\x01\x01\x00\x00\x00\x00\x01\x00\x00\x00\x00'
CMD_FAN_MODE_LOW                = b'\x84\x15\x01\x01\x00\x00\x00\x00\x01\x00\x00\x00\x01'
CMD_FAN_MODE_MEDIUM             = b'\x84\x15\x01\x01\x00\x00\x00\x00\x01\x00\x00\x00\x02'
CMD_FAN_MODE_HIGH               = b'\x84\x15\x01\x01\x00\x00\x00\x00\x01\x00\x00\x00\x03'
CMD_MODE_AUTO                   = b'\x85\x15\x08\x01'
CMD_MODE_MANUAL                 = b'\x84\x15\x08\x01\x00\x00\x00\x00\x01\x00\x00\x00\x01'
CMD_VENTMODE_STOP_SUPPLY_FAN_1  = b'\x84\x15\x07\x01\x00\x00\x00\x00\x10\x0e\x00\x00\x01' # Stoppt Supply-Fan für 1h
CMD_START_SUPPLY_FAN            = b'\x85\x15\x07\x01'
CMD_VENTMODE_STOP_EXHAUST_FAN_1 = b'\x84\x15\x06\x01\x00\x00\x00\x00\x10\x0e\x00\x00\x01' # Stoppt Exhaust-Fan für 1h
CMD_START_EXHAUST_FAN           = b'\x85\x15\x06\x01'
CMD_TEMPPROF_NORMAL             = b'\x84\x15\x03\x01\x00\x00\x00\x00\xff\xff\xff\xff\x00'
CMD_TEMPPROF_COOL               = b'\x84\x15\x03\x01\x00\x00\x00\x00\xff\xff\xff\xff\x01'
CMD_TEMPPROF_WARM               = b'\x84\x15\x03\x01\x00\x00\x00\x00\xff\xff\xff\xff\x02'
CMD_BYPASS_ON                   = b'\x84\x15\x02\x01\x00\x00\x00\x00\x10\x0e\x00\x00\x01'
CMD_BYPASS_OFF                  = b'\x84\x15\x02\x01\x00\x00\x00\x00\x10\x0e\x00\x00\x02'
CMD_BYPASS_AUTO                 = b'\x85\x15\x02\x01'
CMD_SENSOR_TEMP_OFF             = b'\x03\x1d\x01\x04\x00'
CMD_SENSOR_TEMP_AUTO            = b'\x03\x1d\x01\x04\x01'
CMD_SENSOR_TEMP_ON              = b'\x03\x1d\x01\x04\x02'
CMD_SENSOR_HUMC_OFF             = b'\x03\x1d\x01\x06\x00'
CMD_SENSOR_HUMC_AUTO            = b'\x03\x1d\x01\x06\x01'
CMD_SENSOR_HUMC_ON              = b'\x03\x1d\x01\x06\x02'
CMD_SENSOR_HUMP_OFF             = b'\x03\x1d\x01\x07\x00'
CMD_SENSOR_HUMP_AUTO            = b'\x03\x1d\x01\x07\x01'
CMD_SENSOR_HUMP_ON              = b'\x03\x1d\x01\x07\x02'
CMD_BOOST_MODE_1                = b'\x84\x15\x01\x06\x00\x00\x00\x00\x08\x07\x00\x00\x03'   # Partymode 0.5h
CMD_BOOST_MODE_2                = b'\x84\x15\x01\x06\x00\x00\x00\x00\x10\x0E\x00\x00\x03'   # Partymode 1h
CMD_BOOST_MODE_3                = b'\x84\x15\x01\x06\x00\x00\x00\x00\x20\x1C\x00\x00\x03'   # Partymode 2h
CMD_BOOST_MODE_4                = b'\x84\x15\x01\x06\x00\x00\x00\x00\x30\x2A\x00\x00\x03'   # Partymode 3h
CMD_BOOST_MODE_5                = b'\x84\x15\x01\x06\x00\x00\x00\x00\x40\x38\x00\x00\x03'   # Partymode 4h
CMD_BOOST_MODE_6                = b'\x84\x15\x01\x06\x00\x00\x00\x00\x50\x46\x00\x00\x03'   # Partymode 5h
CMD_BOOST_MODE_7                = b'\x84\x15\x01\x06\x00\x00\x00\x00\x60\x54\x00\x00\x03'   # Partymode 6h
CMD_BOOST_MODE_8                = b'\x84\x15\x01\x06\x00\x00\x00\x00\x80\x70\x00\x00\x03'   # Partymode 8h
CMD_BOOST_MODE_0                = b'\x85\x15\x01\x06'                                       # End Partymode

# Sensor locations

SENSOR_AWAY = 16
Test_33 = 33
Test_37 = 37
SENSOR_OPERATING_MODE_BIS = 49
Test_53 = 53
SENSOR_OPERATING_MODE = 56
SENSOR_FAN_SPEED_MODE = 65
SENSOR_BYPASS_MODE = 66
SENSOR_PROFILE_TEMPERATURE = 67
SENSOR_FAN_MODE_SUPPLY = 70
SENSOR_FAN_MODE_EXHAUST = 71
SENSOR_FAN_NEXT_CHANGE = 81
SENSOR_BYPASS_NEXT_CHANGE = 82
Test_85 = 85
SENSOR_SUPPLY_NEXT_CHANGE = 86
SENSOR_EXHAUST_NEXT_CHANGE = 87
SENSOR_FAN_EXHAUST_DUTY = 117
SENSOR_FAN_SUPPLY_DUTY = 118
SENSOR_FAN_SUPPLY_FLOW = 119
SENSOR_FAN_EXHAUS_FLOW = 120
SENSOR_FAN_EXHAUST_SPEED = 121
SENSOR_FAN_SUPPLY_SPEED = 122
SENSOR_POWER_CURRENT = 128
SENSOR_POWER_TOTAL_YEAR = 129
SENSOR_POWER_TOTAL = 130
SENSOR_PREHEATER_POWER_TOTAL_YEAR = 144
SENSOR_PREHEATER_POWER_TOTAL = 145
SENSOR_PREHEATER_POWER_CURRENT = 146
SENSOR_SETTING_RF_PAIRING = 176
SENSOR_DAYS_TO_REPLACE_FILTER = 192
Test_208 = 208
SENSOR_CURRENT_RMOT = 209
SENSOR_HEATING_SEASON = 210
SENSOR_COOLING_SEASON = 211
SENSOR_TARGET_TEMPERATURE = 212
SENSOR_AVOIDED_HEATING_CURRENT = 213
SENSOR_AVOIDED_HEATING_TOTAL_YEAR = 214
SENSOR_AVOIDED_HEATING_TOTAL = 215
SENSOR_AVOIDED_COOLING_CURRENT = 216
SENSOR_AVOIDED_COOLING_YEAR = 217
SENSOR_AVOIDED_COOLING_TOTAL = 218
SENSOR_AVOIDED_COOLING_CURRENT_Target = 219
SENSOR_TEMPERATURE_SUPPLY = 221
Test_224 = 224
SENSOR_COMFORTCONTROL_MODE = 225
Test_226 = 226
SENSOR_BYPASS_STATE = 227
SENSOR_FROSTPROTECTION_UNBALANCE = 228
SENSOR_TEMPERATURE_EXTRACT = 274
SENSOR_TEMPERATURE_EXHAUST = 275
SENSOR_TEMPERATURE_OUTDOOR = 276
SENSOR_TEMPERATURE_AFTER_PREHEATER = 277
SENSOR_HUMIDITY_EXTRACT = 290
SENSOR_HUMIDITY_EXHAUST = 291
SENSOR_HUMIDITY_OUTDOOR = 292
SENSOR_HUMIDITY_AFTER_PREHEATER = 293
SENSOR_HUMIDITY_SUPPLY = 294
TEST_321 = 321
TEST_325 = 325
TEST_341 = 341
TEST_369 = 369
TEST_370 = 370
TEST_371 = 371
TEST_372 = 372
TEST_384 = 384
TEST_386 = 386
TEST_400 = 400
TEST_401 = 401
TEST_402 = 402
TEST_416 = 416
TEST_417 = 417
TEST_418 = 418
TEST_419 = 419


nun läuft das ganze bisher stabil
und solange sich die APP nicht eingewählt hat,
funktionieren auch die befehle

grüße
stixi

[hme0354]

@stixif meld dich beim Beta Programm von Zehnder an, dann kannst du APP und FHEM gleichzeitig nutzen.

Nun eine Frage meiner Seits. Bei einem Kumpel haben wir versucht alles zu installieren. Er bekommt alle Daten schön in FHEM rein, aber keine Befehle raus. Auch nicht direkt über die Comandline am raspberry. Wenn ich einen Befehl da eingebe, bekomm ich zurück "Connection accepted". Bei ihm hängt es sich auf. Hat jemand einen Tipp?

[stixif]

Das mit den befehlen ging bei mir erst mit der aktuellen Version
Und wenn keine Fehler mehr im Log waren...

[hme0354]

Interessant ist, dass er alle Daten FHEM reinbekommen und die auch aktualisiert werden, aber keine Befehle senden kann.

[stixif]

Interessant ist, dass er alle Daten FHEM reinbekommen und die auch aktualisiert werden, aber keine Befehle senden kann.

hatte selbes verhalten bis zum anpassen!

und natürlich wenn kein Neustart von FHEM nach APP login...
(brauch ich aber i Zukunft nicht mehr... war nur zum prüfen)

ahh und "phyton wheel" ist drauf...
war auch mal in irgend einer anleitung...

[stixif]

Hi Zusammen,

bei mir wollte die Lüftungsanlage nicht mehr ausgelesen werden...
somit hab ich mich  nun mit der neuen Version von
https://github.com/michaelarnauts/aiocomfoconnect
auseinandergesetzt

und mir diese Scripte erstellt!
https://github.com/stixif/FHEM-aiocomfoconnect

wem es was hilft darfs gerne nutzen wer weitere Verbesserungen hat darf diese natürlich einfließen lassen

[Hanjo]

und mir diese Scripte erstellt!
https://github.com/stixif/FHEM-aiocomfoconnect

Wow, nice, danke! Ich hatte gar nicht mitbekommen, dass es da eine neue Bibliothek gibt. Das werde ich in den nächsten Tagen direkt mal ausprobieren.

[stixif]

freut mich wenns wem hilft...

[innasa]

Hallo, ich habe das aiocomfoconnect ans laufen bekommen, vielen Dank für deinen Input. Mir fehlen allerdings die Sensoren 215 und 218 (Avoided Heating: Avoided total und Avoided Cooling Total), kannst du mir einen Tipp geben wo ich die nachpflegen kann?^
In der Sensors.py ist der Sensor aufgeführt, ich verzweifele aber daran ihns in FHEM zu bekommen.

Vielen Dank.

Edit: Hab das Script im Debug laufen lassen, dort kommen die Werte korrekt raus. Kann es sein, dass das Reading wegen der Klammer nicht angelegt wird?

[innasa]

Falls jemand mal selbst das Problem hat: Ich habe aus den Namen in der Sensors.py alle Klammern entfernt, dann sind alle Readings angelegt worden!