Hallo lueralba,
bei mir ist das Schalten auch langsam. Bei mir klemmt es aber schon im HCL. Wenn ich dort schalte, dauert es manchmal echt sehr lange bis die Lampe an, oder aus geht.
Ich hatte das HCL schon länger im Schrank und nun mal 3 Geräte angelernt. Irgendwie bin ich mit der Performance nicht zufrieden.
Übrigens hast du dir für das Schalten ein Aktionsskript geschrieben?
viele Grüße
cervicor
Hallo cervicor
Dann bin ich ja nicht alleine…
Hier ein Action-Script:
<?php
include("26912.ips.php"); //HCL Funktionen (ID 26912 musst du an dein HCL Funktionen Script anpassen)
$deviceID = 16; //HCL ID meines Aktors
HCL_write($deviceID ,$_IPS['VALUE']); //Parameter: [ID Device-HCL] , [Schaltzustand false/true o. 0/1]
Gruß
lueralba
Na, da bin ich doch gar nicht so verkehrt.
<?php
//Einbindung - HCL Funktionen
include(IPS_GetScriptFile(19782));
$Parent_ID = IPS_GetParent($_IPS['VARIABLE']);
$HCL_ID = GetValueInteger(IPS_GetVariableIDByName("ID-HCL", $Parent_ID));
//Variable passend setzen wenn Schaltvorgang erfolgreich
if (HCL_write($HCL_ID, (boolean)$_IPS['VALUE'])) {
SetValue($_IPS['VARIABLE'], $_IPS['VALUE']);
}
Bin mir nur mit der Erfolgsrückgabe nicht sicher. Ich habe in die HCL_write-Funktion noch ein „return“ eingesetzt.
function HCL_write($deviceID,$state)
{
global $ip;
global $user_pw;
$curl = curl_init();
if ($state == false) $action = "turnOff";
else $action = "turnOn";
curl_setopt_array($curl, array(
CURLOPT_URL => "http://".$ip."/api/devices/".$deviceID."/action/".$action,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_TIMEOUT => 1,
CURLOPT_HTTP_VERSION => "HTTP/1.1",
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => array("authorization: Basic ".$user_pw),
));
$response = curl_exec($curl);
curl_close($curl);
return $response
};
Gruß cervicor
Hallo lueralba,
Ich habe mir überlegt, eine Rückgabe (return) brauche ich nicht aus der Schalt-Funktion. Ich bekomme ja durch die zyklische Abfrage das Ergebnis viel besser zurück.
Da ist ja deine Funktion viel besser, da absolut ausreichend und einfacher 
Gruß
cervicor
Hallo,
leider verdichtet sich langsam doch der Verdacht bei mir, dass wenn ich das Script laufen lasse (bisher Test bei 1s und 2s Ausführungszeit), ich eine Verzögerung bei der Schaltreaktion bekomme. Das geht bis zu Verzögerungen von eine Minute und dann werden alle Schaltvorgänge nacheinander ausgeführt.
Egal ob ich aus dem Symcon-Webfront oder aus dem HomeCenter schalte.
Habt ihr ähnliche Beobachtungen?
Gruß
cervicor
ich habe bisher nur einen Dimmer um testen danebenliegen.
Da ist eine Routing-Optimierung egal.
Hast du daran gedacht, falls die Geräte bei dir weit versteut sind ?
Gruß
lueralba
Hallo,
schön wenn man seine Probleme selbst lösen kann
Ich habe nun alle Module vom HCL abgelernt und wieder ohne den „Sicherheitsmodus“ inkludiert. Nun läuft es alles recht rund. Ich werde das noch überprüfen.
Grund ist, dass das HCL noch einen Gen3 Chip hat und einige Gen5 Features über Software emulierten muss. Dazu scheint das HCL zu schwachbrüstig zu sein.
Das ist übrigens hier sehr gut erklärt.
viele Grüße
cervicor
Interessant !
Da stelle ich doch nochmal meine Frage von oben
das ein Schaltkommando via Curl deutlich langsam (1-2sec) ist.
Hast Du dieses Verhalten auch ?
Ich habe deswegen mal HTTP Kommandos anstelle Curl ausprobiert und die sind gefühlt im 0,3sec Bereich :eek:
Gruß
lueralba
Hallo lueralba,
Ja, das hab ich auch. Bei mir dauert das Schalten auch 1-2 Sekunden.
Wie sieht denn dein HTTP-Kommando aus? Ich steh da ein bisschen auf dem Schlauch. Ich schaffe es weder die devices auszulesen, noch die zu schalten.
Warning: file_get_contents(http://192.168.144.19:80/api/devices/104/action/turnOff): failed to open stream: HTTP request failed! HTTP/1.1 401 User not logged in
Ich bekomme immer die Nachricht, dass ich nicht eingeloggt bin. So richtig komme ich in API-Doku auch nicht weiter. Ich muss sagen ich bin nicht mehr so drin im Programmieren :o
Vielleicht könntest du ja mal deinen Ansatz posten?
Danke und Gruß
cervicor
Hallo cervicor !
Vielleicht könntest du ja mal deinen Ansatz posten?
Immer gerne 
Auszüge aus dem Script „HCL-FUNKTIONEN“:
<?php
//Neu:
$HCL_http_user = "<HCL User>";
$HCL_http_user_pw = "<HCL Passwort>";
...
...
...
//Geändert auf HTTP:
//Funktion HCL Device Schalten
//HCL_write(60,true);
function HCL_write($deviceID,$state)
{
global $ip;
global $HCL_user_pw;
global $HCL_http_user;
global $HCL_http_user_pw;
//$curl = curl_init();
if ($state == false) $action = "turnOff";
else $action = "turnOn";
$response = file_get_contents("http://".$HCL_http_user.":".$HCL_http_user_pw."@".$ip."/api/callAction?deviceID=".$deviceID."&name=".$action);
return $response;
};
//Geändert auf HTTP:
// Funktion HCL Device Dimmen
// HCL_dim(60,0-99);
function HCL_dim($deviceID,int $value)
{
global $ip;
global $HCL_http_user;
global $HCL_http_user_pw;
$response = file_get_contents("http://".$HCL_http_user.":".$HCL_http_user_pw."@".$ip."/api/callAction?deviceID=".$deviceID."&name=setValue&arg1=".$value);
return $response;
};
//Geändert auf HTTP:
// Funktion HCL Virtual Device PressButton
// HCL_Virtual_Device_PressButton (60 , 1 - n);
function HCL_Virtual_Device_PressButton($deviceID , $btnID)
{
global $ip;
global $HCL_http_user;
global $HCL_http_user_pw;
$response = file_get_contents("http://".$HCL_http_user.":".$HCL_http_user_pw."@".$ip."/api/callAction?deviceID=".$deviceID."&name=pressButton&arg1=".$btnID);
return $response;
};
//Geändert auf HTTP:
// Funktion HCL Virtual Device SetSlider
// HCL_Virtual_Device_SetSlider (60 , 1 , 0 - 99);
// Bei mir funktioniert dieses Kommando NICHT !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
function HCL_Virtual_Device_SetSlider($deviceID , $sliderID , $value)
{
global $ip;
global $HCL_http_user;
global $HCL_http_user_pw;
$response = file_get_contents("http://".$HCL_http_user.":".$HCL_http_user_pw."@".$ip."/api/callAction?deviceID=".$deviceID."&name=setSlider&arg1=".$sliderID."&arg2=".$value);
return $response;
};
Gruß
lueralba
Danke dir
Ich selbst habe noch nie ein Modul geschrieben,
aber würde ein Modul für das HCL nicht sogar sinn machen?
Für mich habe ich das ganze jetzt umgemodelt.
Jetzt läuft Installation automatisch und es lassen sich Schalter und Rolladen im Webfront bedienen.
Ist bestimmt noch stark Erweiterungsfähigkeit.
Und bestimmt auch schöner in eine syntax zu setzen…
<?php
$ip = "192.168.***.***"; // IP HCL
$user_pw = "**************************************"; // Zugangsdaten HCL user:pw base64
$json = "";
$user = "name@provider.de";
$PW = "1234568790";
$a = "'VALUE'";
$b = "'VARIABLE'";
$c = "'ObjectInfo'";
//*** Bolean Skript
$boleanscript = IPS_CreateScript(0);
IPS_SetName($boleanscript, "Aktion-Bolean");
$inhalt='<?php
SetValue($_IPS['.$b.'], $_IPS['.$a.']);
$deviceID = IPS_GetObject ($_IPS['.$b.']);
if ($_IPS['.$a.'] == false) $action = "turnOff";
if ($_IPS['.$a.'] == true) $action = "turnOn" ;
file_get_contents("http://'.$user.':'.$PW.'@'.$ip.'/api/callAction?deviceID=".$deviceID['.$c.']."&name=".$action);
';
IPS_SetScriptContent($boleanscript, $inhalt);
//*** Shutter skript
$shutterscript = IPS_CreateScript(0);
IPS_SetName($shutterscript, "Aktion-Shutter");
$inhalt='<?php
SetValue($_IPS['.$b.'], $_IPS['.$a.']);
$deviceID = IPS_GetObject ($_IPS['.$b.']);
$action = ($_IPS['.$a.']);
file_get_contents("http://'.$user.':'.$PW.'@'.$ip.'/api/callAction?deviceID=".$deviceID['.$c.']."&name=setValue&arg1=".$action);
';
IPS_SetScriptContent($shutterscript, $inhalt);
//*** Setpoint skript
$Setpointscript = IPS_CreateScript(0);
IPS_SetName($Setpointscript, "Aktion-Setpoint");
$inhalt='<?php
SetValue($_IPS['.$b.'], $_IPS['.$a.']);
$deviceID = IPS_GetObject ($_IPS['.$b.']);
$action = ($_IPS['.$a.']);
file_get_contents("http://'.$user.':'.$PW.'@'.$ip.'/api/callAction?deviceID=".$deviceID['.$c.']."&name=setTargetLevel&arg1=".$action);
';
IPS_SetScriptContent($Setpointscript, $inhalt);
//*** Aktualisierungs Skript
$ScriptID = IPS_CreateScript(0);
$ScriptName = "HCL-Run.ips.php"; //Skriptdatei
$Parent = IPS_GetParent($_IPS['SELF']);
IPS_SetParent($ScriptID, $Parent);
IPS_SetName($ScriptID, $ScriptName);
$content='<?php
$ip = "'.$ip.'";
$user_pw = "'.$user_pw.'";
$json = "" ;
$curl = curl_init();
curl_setopt_array($curl, array(
CURLOPT_URL => "http://".$ip."/api/devices",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => "HTTP/1.1",
CURLOPT_HTTPHEADER => array("authorization: Basic ".$user_pw),
));
$response = curl_exec($curl);
$json = json_decode($response); //Dekodierung nach Json
curl_close($curl);
foreach ($json as $i) {
switch ($i->id) {
';
// Funktion HCL Devices lesen
$curl = curl_init();
curl_setopt_array($curl, array(
CURLOPT_URL => "http://".$ip."/api/devices",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTP_VERSION => "HTTP/1.1",
CURLOPT_HTTPHEADER => array("authorization: Basic ".$user_pw),
));
$response = curl_exec($curl);
$json = json_decode($response); //Dekodierung nach Json
curl_close($curl);
$cat = IPS_CreateCategory();
IPS_SetParent($cat, 0);
IPS_SetName($cat, "HCL-Zwave");
foreach ($json as $i)
{
If ($i->parentId == 1)
{
$Dummy = IPS_CreateInstance ("{485D0419-BE97-4548-AA9C-C083EB82E61E}");
IPS_SetParent($Dummy, $cat);
IPS_SetName($Dummy, $i->name);
IPS_SetInfo($Dummy, $i->id);
IPS_SetPosition($Dummy, $i->id);
//** ID variable
$IPS_id_ID_HCL = ips_CreateVariable(1);
IPS_SetParent($IPS_id_ID_HCL, $Dummy);
IPS_SetName($IPS_id_ID_HCL, "ID-HCL");
IPS_SetInfo($IPS_id_ID_HCL, "");
IPS_SetPosition($IPS_id_ID_HCL,1);
$ziel = '$i->id';
$content.="case '";
$content.=$i->id;
$content.="':
";
$zielid = $i->id;
setvalue ($IPS_id_ID_HCL,$zielid);
//Nodeid
$info = "nodeId";
$ziel = '$i->properties->nodeId';
$nodeIDinh = $i->properties->nodeId;
if (array_key_exists ($info,$i->properties ))
{
$vab_A = ips_CreateVariable(1);
IPS_SetParent($vab_A, $Dummy);
IPS_SetName($vab_A, $info);
IPS_SetPosition($vab_A,2);
setvalue ($vab_A,$nodeIDinh);
}
IPS_SetPosition($Dummy,$nodeIDinh);
//ZWversion
$info = "zwaveVersion";
$ziel = '$i->properties->zwaveVersion';
$ZWversion = $i->properties->zwaveVersion;
if (array_key_exists ($info,$i->properties ))
{
$vab_A = ips_CreateVariable(3);
IPS_SetParent($vab_A, $Dummy);
IPS_SetName($vab_A, $info);
IPS_SetInfo($vab_A,$i->id);
IPS_SetPosition($vab_A,3);
setvalue ($vab_A,$ZWversion);
}
}
if ($i->parentId > 2)
{
//** ermittlung des mutterobjektes
$childs = IPS_GetChildrenIDs ($cat);
foreach ($childs as $j)
{
$ob = @IPS_GetObjectIDByName("ID-HCL", $j);
$iid = getvalue ($ob);
If ($iid==$i->parentId)
{
$Dummy = $j;
}
}
$info = "categories";
$Texta = $i->properties->categories;
$Textb = substr($Texta,2);
$categorie = substr($Textb,0,-2);
$typea = $i->type;
$type = substr($typea,11);
$caktion = 0;
if (array_key_exists ($info,$i->properties ))
{
if ($categorie == 'blinds')
{
$var_type=1;
$var_pro="~Intensity.100";
$ziel = '$i->properties->value';
$caktion = "Ja";
$zielaktion = "$shutterscript";
}
if ($categorie == 'lights')
{
$var_type=0;
$var_pro="~Switch";
$ziel = '$i->properties->value';
$caktion = "Ja";
$zielaktion = $boleanscript;
}
if ($categorie == 'remotes')
{
$var_type=1;$var_pro="";
$ziel = '$i->properties->deviceControlType';
}
if ($categorie == 'climate')
{
If ($type == 'setPoint')
{
$var_type=2;
$var_pro="~Temperature.Room";
$ziel = '$i->properties->value';
$caktion = "Ja";
$zielaktion = $Setpointscript;
}
else
{
$var_type=2;
$var_pro="~Temperature.Room";
$ziel = '$i->properties->value';
}
}
if ($categorie == 'safety')
{
$var_type=0;
$var_pro="";
$ziel = '$i->properties->value';
}
if ($categorie == 'security')
{
$var_type=0;
$var_pro="";
$ziel = '$i->properties->value';
}
if ($categorie == 'ambience')
{
$var_type=2;
$var_pro="~Illumination.F";
$ziel = '$i->properties->value';
}
if ($categorie == 'other')
{
If ($type == 'accelerometer')
{
$var_type=3;
$var_pro="";
$ziel = '$i->properties->value';
}
}
$vab_B = ips_CreateVariable($var_type);
IPS_SetVariableCustomProfile($vab_B,$var_pro);
IPS_SetName($vab_B, $type);
IPS_SetInfo($vab_B,$i->id);
IPS_SetPosition($vab_B,$i->id);
If ($caktion == "Ja")
{
IPS_SetVariableCustomAction($vab_B,$zielaktion);
}
IPS_SetParent($vab_B, $Dummy);
$content.="case'";
$content.=$i->id;
$content.="':
setvalue (";//':
$content.=$vab_B;
$content.=",";
$content.=$ziel;
$content.=");";
$ziel = '$i->properties->batteryLevel';
if (array_key_exists ("batteryLevel",$i->properties ))
{
$VariablenID = @IPS_GetVariableIDByName("batteryLevel", $Dummy);
if ($VariablenID == false)
{
$vab_c = ips_CreateVariable(1);
IPS_SetVariableCustomProfile($vab_c,"~Battery.100");
IPS_SetParent($vab_c, $Dummy);
IPS_SetName($vab_c, "batteryLevel");
IPS_SetInfo($vab_c,$i->id);
IPS_SetPosition($vab_c,$i->id);
$content.="
setvalue (";//':
$content.=$vab_c;
$content.=",";
$content.='$i->properties->batteryLevel';
$content.=");
break;
";
}
}
else
{
$content.="
break;
";
}
}
IPS_Sleep (1);
}
}
$content.="}}";
$cat_skripte=IPS_CreateCategory();
IPS_SetParent($cat_skripte,$cat);
IPS_SetName ($cat_skripte,"Skripte");
IPS_SetPosition($cat_skripte,99999);
IPS_SetScriptContent($ScriptID, $content);
IPS_SetParent($ScriptID, $cat_skripte);
IPS_SetPosition($ScriptID,1);
IPS_RunScript ($ScriptID);
IPS_SetScriptTimer($ScriptID,12);
IPS_SetParent($boleanscript, $cat_skripte);
IPS_SetParent($Setpointscript, $cat_skripte);
IPS_SetParent($shutterscript, $cat_skripte);
// Bei mir funktioniert dieses Kommando NICHT !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
Für die Nachwelt:
Es lag an dem zusätzlich angelegten HCL User. Der kann nur reale Module (Geräte) setzen, aber keine virtuellen Module !
Das führte bei mir immer zu einem „401“ Fehler.
Abhilfe: Alles über den SuperUser „machen“, dann klappts sofort.
Positives:
Inzwischen triggere ich aus dem HCL per Szenen bei An/Aus bzw. Änderungen des W/kWh Wertes eine Variable in IPS, die dann (Ereignis) wiederum den Gerätestatus aus dem HCL abholt. Das geht alles ausreichend flott !
Schalten (also senden von IPS an HCL) geht ebenfalls ohne merkliche Verzögerungen !
Gruß
lueralba
Noch etwas:
Was ebenfalls für eine Rückmeldung der Module (Geräte) eingestellt sein muss (Endpoint0 - Group1 - M):
Sonst kommen die W/kWh Werte bei deren Änderung nicht im HCL an.
Das sollte zwar beim Einrichten per default gesetzt sein, war es bei einem Modul bei mir aber nicht (mehr) !
Gruß
lueralba
Moin Moin,
Ein interessanter Ansatz das HCL als Gateway für die Einbindung der zwave devices zu nutzen. Ich bin nun auch Benutzer eines HCL und habe am Wochenende mich mit euren Skripten beschäftigt. Die Frage nach dem Modul zur einfachen Einbindung des HCL liegt natürlich nahe. Ich habe ebenfalls noch kein Modul programmiert mich aber am gestrigen Sonntag an die ersten Schritte herangewagt.
Dank des hervorragenden Tutorials von paresy und DrNiels sind die ersten Schritte recht einfach nachvollziehbar.
inzwischen gibt es ein Device HCL welches die HCL-ID speichern kann sowie schon ein paar Eigenschaften. nun stehe ich vor der Frage wie die Kommunikation zur HCL aufgebaut werden sollte. Ist dazu ein Splitter erforderlich?
Oder lege ich dafür ein weiteres device an welches per php-curl die Verbindung zum HCL aufbaut.
Die Kommunikation erfolgt von symcon via http / https? zur HCL, welche dann als Gateway die Kommunikation zu den zwave Geräten aufbaut.
Freue mich über jede Anregung und Hilfe. Einen Schönen Tag euch allen.
Gruß Detlev.
Hallo TE999,
vielen Dank für diesen Post und die Informationen rund um die HCL.
Da meine ZWave-Steckdosen-Infrastruktur (64 Fibaro Wall-Plugs mit RaZberry2-Modul in der SymBox und keine weiteren ZWave-Bausteine) nach wie vor nicht stabil läuft, habe ich mich auch für ein Fibaro HCL entschieden. Es tauchen bei meiner bisherigen Lösung viele Zombie-Variablen auf (die es beim Fibaro-Plug einfach nicht gibt) und immer wieder werden Ein- oder Ausschalt-Befehl nicht ausgeführt. Meiner Meinung nach haben entweder das RaZberry-Modul oder IPS ein Problem mit dem ZWave-Protokoll. Nun liegt das beim HCL und ich habe die Hoffnung, dass Fibaro seine eigenen Steckdosen zuverlässig ansteuert.
Ich habe erste Steckdosen an das HCL angelernt und das Schalten und Auslesen über HTTP funktioniert schon.
Meine Frage an die, die HCL schon länger angebunden haben ist folgende: Wie erkennt Ihr, wenn sich ein Steckdosen-Status ändert? Pollt Ihr regelmäßig (in welchen Abständen?) das HCL und holt die Zustände ab? Oder gibt es ein Signal, dass man an IPS übermitteln kann, quasi als Trigger? Wird das mit 64 Geräten ein Problem werden?
Ich habe diesen Thread gelesen und erkannt, dass automatisch Skripte angelegt werden. Ich hoffe es, etwas einfacher zu gestalten. Das Schalten der Steckdosen habe ich ähnlich wie bei meinen anderen Steckdosen (EIB, Homematic, Shelly, Tasmota, DECT) eingebaut - mir fehlt nur noch die Erkennung der Statusänderungen, falls zum Beispiel von Hand geschaltet wird.
Danke für Eure Tipps.
Viele Grüße aus dem Unterallgäu
Harry
Hallo lueralba,
kannst Du mir einen Tipp geben, wie Du eine Status-Änderung vom HCL an IPS übergibst? Ich habe mein HCL seit gestern und noch keine Ahnung von der Fibaro-Oberfläche.
In Deinem Screenshot sehe ich „onChange Button11“. Ist es das?
Danke.
Viele Grüße aus dem Unterallgäu
Harry
Hallo Harry28,
als erstes muß Du Dich erst einmal mit den HCL auseinandersetzen bevor Du an die Kommunikation mit Symcon gehst. HCL auf aktuelle Version updaten (keine Beta) und eine Steckdose anlernen. Über den Webbrowser z.B Firefox --> Web-Entwickler–> Netzwerkanalyse kannst Du dann sehen welche Befehle beim Schalten der Steckdoes vom HCL gelesen und gesendet werden.
Am Anfang des Themas sind zwei Varianten aufgeführt, wie der Datenaustausch zwischen HCL und Symcon erfolgt.
Var. 1 Zyklisches Lesen des Status aktiv von Symcon aus.
–> siehe Post #3 Teil 2 - HCL-Status lesen
Das ist die einfachste Variante, bei der Du auf der HCL Seite außer die Devices anlegen nichts weiter machen müsstes.
//Bsp. Fibaro Steckdose mit Energiemessung
case '96':
hcl_switch($CatID_Steckdosen,"Stecker 1",1,$i);
break;
Hier werden 4 Variablen angelegt HCL-ID, Status,Verbrauch und Leistung.
Durch den eingetragenen Scripttimer bestimmts Du wie oft der Status vom HCL gelesen wird.
$TimerInterval = 2; //Abfrageintervall-Aktualisierung - Angabe in Sekunden
Für das Lesen des Statuses einer Steckdose kann man den Timer ruhig auf größer 2-3 sec setzen.
Var.2 Aktives Schreiben des Statuses vom HCL
Da das HCL keine LUA Scripte ausführen kann ist dies etwas aufwendiger.
→ siehe Post #4 Teil 3 -Funktionen zum direkten Schreiben vom HCL in IPS
Ich würde Dir Variante 1 empfehlen. da es sich hier um keine Zeitkritischen Prozesse handelt.
Zum Aktives Schalter der Steckdose ist der Befehl
HCL_write(60,true); // Parameter: [ID Device-HCL] , [Schaltzustand false/true o. 0/1]
–> siehe Post #2 Teil 1 - HCL-Funktionen
Wichtig ist hier dabei generell, da die Kommunikation über Http Protokolle laufen ist das ganze etwas träge. Ich habe festgestellt, dass fast alle Fibaro Komponenten gut über die Schnittstelle funktionieren. Für Steckdosen oder Schalter spielt die Statusaktualisierung zeitlich nicht so die Rolle. Wichtig ist mir hier aber, das alle Verbrauchswerte sauber kommen.
Für Zeitkritische Prozesse z.B. bei Bewegungsmelder ist evtl. Zweigleisig zu fahren. Ich habe Heute beide Schnittstellen zur Einbindung von Z-Wave Komponenten wieder aktiv und fahre recht gut damit.
(Schnittstelle über HCL via Http und Schnittstelle über Razberry2 via Symcon). Die Razberry Variante nutze ich z.Bsp. für Türschlösser und Alarmsensoren wo es auf mehr Sicherheit ankommt. Das liegt daran da das HCL den Security Modus 2 nicht integriert hat.
Gruß Thomas
Hallo Thomas,
Vielen Dank für die schnelle und ausführliche Rückmeldung.
Die ersten Dinge habe ich bereits erledigt (Update nicht Beta, erste Steckdosen angelernt, HTTP-Ansteuerung) und es funktioniert prima.
Ich habe wirklich nur Fibaro-Plugs, so dass es für mich einfach bleibt. Ich habe etwas über Webhooks nachgelesen und setze dies für die Ansteuerung von wenigen Steckdosen aus einer HTML-Seite ein. Das könnte eine Lösung sein, vom HCL aus ein Symcon-Skript zu triggern.
Viele Deiner Posts habe ich jetzt wiederholt und genauer studiert. Mit 2-3 Sekunden Polling werde ich mal starten, aber ich habe eine sehr große Symcon-Installation, denn mein SmartHome ist umfangreich, und ich habe daher Bedenken mit der Last.
Energiewerte sind auch wichtig, aber da habe ich bereits plausible Werte ausgelesen. Bevor ich nun alle 64 Steckdosen umstelle muss der Mechanismus zuverlässig funktionieren. Das RaZberry-Modul wollte ich am Ende rauswerfen, denn da habe ich auch keine richtige Backup-Lösung.
Danke für die Unterstützung. Wenn Dich meine Aktivitäten interessieren kannst Du hier schauen: http://www.harrykellner.de
Viele Grüße aus dem Unterallgäu
Harry
Hallo Harry,
ich werde bei mir in Kürze mal einen Wallplug anlernen.
Dann kann ich Dir „meine“ Variante (die sich aber an die sehr gute Einführung von TE999 anlehnt) darstellen.
Und ja, ich polle nicht zyklisch !
Ich lasse mir bei Status- / Messwerte-Änderungen durch eine Scene via virtuelles Modul via Webhook eine Bool Variable in IPS aktualisieren. Ein Ereignis (auf Aktualisierung dieser Bool Variable) triggert dann das Script „HCL-Status lesen“ und holt (im Augenblick noch) alle Modul-Daten aus dem HCL ab.
Scene am Beispiel FGS212:
Beispiel: Virtuelles Modul zum Senden der Änderung an IPS:
Über den Webbrowser z.B Firefox --> Web-Entwickler–> Netzwerkanalyse kannst Du dann sehen welche Befehle beim Schalten der Steckdoes vom HCL gelesen und gesendet werden.
Hab das mal probiert, wo kannst Du dort etwas brauchbares entnehmen. Ich habe da auf die Schnelle nix gesehen was ich verwenden könnte 
Gruß
lueralba
