Z-Wave -Story und Meine Entscheidung für's HCL

Ich arbeitet seit IPS Version 3.4 als Dachplattform mit IP-Symcon. Mit Symcon habe ich die Möglichkeit viele Einzelsysteme zu visualisieren, steuern oder zu überwachen. Dabei habe ich stets besonderen Wert darauf gelegt, das jedes Einzelsystem Standalone arbeiten kann aber ich die Überwachung und Steuerung über eine zentrale Plattform habe.
Hier nochmals allen Entwicklern von Symcon, IPSView und den fleißigen Helfern im Forum meine Dank für euer Bemühungen. Ich möchte Eingangs noch einmal betonen, dass es meine Entscheidung ist das HCL einzusetzen und nicht die Anstrengungen von Symcon Z-Wave Modul zu kritisieren.

Zum Thema Z-Wave.
Ich habe aktuell 12 Fibaro Double-Switch, 4x Fibaro Optische Augen, 3 Cyrus Wassersensoren, 10x Fibaro u. Aeon Zwischenstecker mit Energiemessung verbaut. Als Gateway nutzte ich das Z-Wave ZMEERAZ2 Z-Wave.Me RaZberry 2 Modul. Dieses war zuerst auf einen Raspberry PI3 , dann auf 3+ und auf RockPI4 und zu guter Letzt einen separaten Raspberry. Sogar das RaZberry 2 Modul habe ich ausgetauscht. Alles nur mit bedingten Erfolg.
Vorab das Z-Wave System hat gearbeitet, aber nie zu 100%. Ich habe wie Viele hier im Forum mit den gleichen Problemen gekämpft.
Bsp.:
-Erforderliche Klassen wurden nicht immer geladen → Hilfe Secure Modus abwählen
-Stromwerte bei Fibaro Double Switch Kanal2 wurden bis zur Version 5.x nicht übertragen
-Rückmeldungen Fibaro DoppelSwitch über Istzustand bei Handbetätigung des Schalters wurden ab Version 5.x für Neu hinzugefügte Schalter nicht mehr übertragen
-Anmeldung funktionierte nicht → Wähle simple Assoziationen (es gehen dann bloß keine Untergeräte mehr)
Die Liste ist lang und in Vielen Forumsbeiträgen erläutert. Einen Weg mit Kompromissen findet man immer – man fragt sich dann nur ob man die erforderliche Sicherheit wirklich noch hat.

Nach langen Test habe ich mich entschlossen das Home Center Lite (HCL) zu testen.
Ich weis den Vorbehalt von einigen hier das es gern als Konkurrenzprodukt bezeichnet wird. Das ist aber nicht so. Das HCL ist mit einer CCU 2/3 ohne Zusatz AdOns vergleichbar. Es dient als Gateway, man kann direkt Verknüpfungen programmieren, hat ein eigenes Webinterface und noch einiges mehr. Die Kosten liegen für Neugeräte bei eBay unter 200,-EUR. Das ist nur unwesentlich mehr als das Gateway von Symcon. Die größere Version Home Center 2 und 3 kann man gern als Konkurrenzprodukt bezeichnen. Dies benötigt man, wenn man nicht mit Symcon arbeitet.
Fibaro hat zwar auch seine Eigenheiten besonders bei Updates aber alle Signal und Rückmeldungen kommen so wie es sein muss ohne sich mit Assoziationen, Klassen und Routingdetails rum zuschlagen und man hat alle Funktionalitäten wie Backups, Parametrierungen und vieles mehr inklusive. Bei Vielen Sachen ist man leider auch beim HCL auf das Forum angewiesen, aber die Community ist wie bei Symcon aktiv.

Als Schnittstelle zu Symcon nutze ich das Rest-API Interface von Fibaro. Hier mit kann man alle Daten abrufen und Signal an das HCL senden. Für Zeitkritische Funktionen kann man mit Hilfe eines Virtuellen Moduls Direkt vom HCL aus Variablen in Symcon beschreiben oder Scripte direkt starten. Das HCL hat zwar keine LUA Scripte , aber man benötigt diese auch nicht unbedingt. Hierfür ist Symcon da.
Die Abfrage der Schnittstelle habe ich im Zeitraster 1sec 5sec und 10sec getestet. Ohne nennenswerte Einschränkungen.
Mein System IP-Symcon Version 5.3 ca. 3500 Variablen, Schnittstellen zu piVCCU3, pihole, Solarlog, Sonnenbatterie, Velux, Polldigital, CMS (techn.Alternative), 6x Drehstromzähler via Modbus, Wetterstation, Unifi mit 3xVlan und ca. 30 Clients

Nachfolgend möchte ich Euch mein Projekt HCL vorstellen.

Alle Komponenten werden im HCL angelegt und Parametriert


Überblick HCL

Für die Kommunikation benötigt man nur zwei Scripte.
→ Script HCL Funktionen (siehe Teil 1 - HCL Funktionen)
Hier sind alle Funktionen definiert, die für die Kommunikation notwendig sind. Das Script wird über einen include Befehl bei den entsprechenden Scripts eingebunden, um z.B. Ausgänge zu schalten „ HCL_write(<id>,true);“

→ Script HCL Staus lesen (siehe Teil 2 - HCL Status lesen)
Bei manuellen Aufruf des Skriptes wird die Datenstruktur in Symcon automatisch angelegt und ein Scripttimer für die zyklische Abfrage aktiviert. Bei Veränderungen auf der Seite HCL einfach die entsprechende Konfiguration erneuern und nochmals von Hand auslösen.
Alle Statusdaten werden nur geschrieben, wenn deren Zustand sich ändert

→ Funktionen zum direkten Schreiben vom HCL in IPS ( Teil3)
Durch die Nutzung von Virtuellen Modulen und Graphischen Szenen kann man direkt vom HCL Variablen in IPS schreiben bzw lesen oder Scripte direkt starten

→ Script Wartungsmodus HCL (siehe Teil 4 Wartungsmodus)
Das Script ist optional. Es aktiviert bzw deaktiviert die Kommunikation mit den HCL.


Datenstruktur in IP-Symcon

Folgende Einschränkungen konnte ich bei der API von Fibaro bis jetzt feststellen:
・ Status Fibaro Button wird nicht zurückgemeldet.
Diese Rückmeldung kann man aber über das HCL in Verbindung mit einen Virtuellen Modul und einer graphischen Szene leicht realisieren.

In den nächsten Beiträgen stelle ich Euch meine Lösung im Detail vor.

Das Script in den Ordner HCL-ZWave legen , parametrieren und abspeichern.
Die Kommunikation läuft über einen Curl Aufruf der die Daten vom HCL zyklisch abholt.
Intern in Symcon werden die Daten in Jons-Format gewandelt und verarbeitet.

Alle Funktionen sind im Script dokumentiert.

//Konfiguration
$ip       = "xxx.xxx.xxx.xxx";      // IP HCL
$user_pw  = "c3ltY29uOnN5bWNvbg=="; // Zugangsdaten HCL user:pw  base64

Hier am Beispiel $user_pw symcon:symcon das ganze dann base64 codiert (Nutzer und Passwort im HCL)

Bsp. Zum Schalten eines Ausganges mit der HCL-ID 60

//Script Lampe Ein  
HCL_write(60,true);

Spript HCL-Funktionen

<?
// Script Sammlung  zum Datenaustausch mit HCL von Fibaro  TE 19.01.2020 Version 1
/* 
Einbindung über include Befehl
include("46991.ips.php"); //HCL Funktionen
Inhalt:
1. Funktion HCL Status  Devices lesen
    HCL_read(29);  Parameter: [ID Device-HCL]
2. Funktion HCL alle Devices lesen 
    HCL_devices();
3. Funktion HCL Device Schalten
    HCL_write(60,true); Parameter: [ID Device-HCL] , [Schaltzustand false/true o. 0/1]
4. Funktion HCL Globalvariablen lesen
    HCL_global();
5. Funktion HCL Info lesen
    HCL_info();
6. Funktion HCL Diagnose lesen
   HCL_diagnostics();
Versionshistory:
Version 1  - TE 19.01.2020 Script Sammlung  zum Datenaustausch mit HCL von Fibaro  
*/

//Konfiguration
$ip       = "xxx.xxx.xxx.xxx";      // IP HCL
$user_pw  = "c3ltY29uOnN5bWNvbg=="; // Zugangsdaten HCL user:pw  base64

//------------------------------------------------------------------------------------------

// Funktion HCL Status  Devices lesen
//HCL_read(104);
function HCL_read($deviceID)  
{
    global $ip;
    global $user_pw;
    $curl = curl_init();
    curl_setopt_array($curl, array(
        CURLOPT_URL => "http://".$ip."/api/devices?id=".$deviceID,
        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); 
};

// Funktion HCL alle Devices lesen 
//HCL_devices();
function HCL_devices()  
{
    global $ip;
    global $user_pw;
    $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); 
};

// Funktion HCL Device Schalten
//HCL_write(60,true);
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); 
};

// Funktion HCL Globalvariablen lesen
//HCL_global();
function HCL_global()  
{
    global $ip;
    global $user_pw;
    $curl = curl_init();
    curl_setopt_array($curl, array(
        CURLOPT_URL => "http://".$ip."/api/globalVariables ",
        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); 
};

// Funktion HCL Info lesen
//HCL_info();
function HCL_info()  
{
    global $ip;
    global $user_pw;
    $curl = curl_init();
    curl_setopt_array($curl, array(
        CURLOPT_URL => "http://".$ip."/api/settings/info",
        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); 
};

// Funktion HCL Diagnose lesen
//HCL_diagnostics();
function HCL_diagnostics()  
{
    global $ip;
    global $user_pw;
    $curl = curl_init();
    curl_setopt_array($curl, array(
        CURLOPT_URL => "http://".$ip."/api/diagnostics",
        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); 
};

Das Script in den Ordner HCL-ZWave legen , parametrieren und 1xhändisch ausführen.
Bei manuellen Aufruf des Skriptes wird die Datenstruktur in Symcon automatisch angelegt und ein Scripttimer für die zyklische Abfrage aktiviert. Bei Erweiterungen bzw. Veränderungen auf der Seite HCL einfach die entsprechende Konfiguration erneuern und nochmals von Hand auslösen.
Alle Statusdaten werden nur geschrieben, wenn deren Zustand sich ändert.

Alle Funktionen sind im Script dokumentiert.
Übersicht:

//Konfiguration
$ip            = "xxx.xxx.xxx.xxx";      // IP HCL
$user_pw       = "c3ltY29uOnN5bWNvbg=="; // Zugangsdaten HCL user:pw  base64
$json          = "";
$ScriptName    = "HCL-Status lesen";
$TimerInterval = 1; //Abfrageintervall-Aktualisierung - Angabe in Sekunden

Datenstruktur
In meine Script werden die einzelnen Z-Wave Geräte funktionell in 4 Gruppen abgelegt.

// Anlegen Menüstrucktur
$CatID_Handsender     = CreateCategoryByName($parentID,"Handsender",100);
$CatID_Schalter       = CreateCategoryByName($parentID,"Schalter",200);
$CatID_Sensoren       = CreateCategoryByName($parentID,"Sensoren",300);
$CatID_Steckdosen     = CreateCategoryByName($parentID,"Steckdosen",400);

Aufbereitung der Daten:
Die einzelnen Z-Wave Gerät müssen entsprechend ihrer Datenstruktur ein bis mehrfach aufgerufen werden. Entscheiden ist hier die Fibaro . Die Abarbeitung erfolgt in einer forech Schleife

// Aufbereitung der Daten
foreach ($json as $i) {
    switch ($i->id) {
        //Bsp. Fibaro Double Switch
        case '91':
            hcl_switch($CatID_Schalter,"Schalter 1.1 Wohnzimmer Licht",1,$i); 
            break;

91 - HCL ID
hcl_switch(<Menü Ordner> , , , $i)

Script HCL-Status lesen

<?
/* HCL Status lesen via Rest-API TE 19.01.2020  Version 1.1
Script ruft in eingestellten Timerintervall Stus alle Geräte vom HCL ab
Script in den Ordner HCL-Zwave legen , parametroeren und und einmal händisch ausführen.
Bei Änderunge oder Erweiterung Script nochmals händisch ausführen
Script erstellt Strucktur selbsständig
versionshistorie:
Version 1  - TE 19.01.2020 HCL Status lesen via Rest-API
--> Sensor - Fibaro Motion Sensor FGMS-001, Schalter - Fibaro Double Switch FGS-213/223, Steckdose mit Energiemessung - Fibaro Wall Plug FGWPE/F-102 ,AEOTEC SmartSwitch A 647729
Version 1.1- TE 15.02.2020 HCL Status lesen via Rest-API
--> Taster- Fibaro FGBP-101-8 , Wassersensor -CyrusSmarthome Flood Sensor A691411

*/

//Konfiguration
$ip            = "xxx.xxx.xxx.xxx";      // IP HCL
$user_pw       = "c3ltY29uOnN5bWNvbg=="; // Zugangsdaten HCL user:pw  base64
$json          = "";
$ScriptName    = "HCL-Status lesen";
$TimerInterval = 1; //Abfrageintervall-Aktualisierung - Angabe in Sekunden

//-----------------------------------------------------------------------------------------------------

// übergeordnete Instanz identifizieren
$parentID         = IPS_GetParent($_IPS['SELF']);

//Installer
if ($IPS_SENDER == "Execute")
{
    //Script umbennen und Timer setzen
    IPS_SetHidden($IPS_SELF, true);
    IPS_SetName($IPS_SELF, $ScriptName);
    IPS_SetScriptTimer($IPS_SELF,$TimerInterval);   //Scripttimer auf gewünschen Intervall setzen

    // Variablenprofile anlegen
    if (!IPS_VariableProfileExists('HCL_Button'))
    {
	    IPS_CreateVariableProfile('HCL_Button',1);
	    IPS_SetVariableProfileAssociation('HCL_Button', 0, 'Taster nicht betätigt', '' , 0xFFFFFF);
        IPS_SetVariableProfileAssociation('HCL_Button', 1, 'Taster 1x betätigt', '' , 0x32cd32);
        IPS_SetVariableProfileAssociation('HCL_Button', 2, 'Taster 2x betätigt', '' , 0x32cd32);
        IPS_SetVariableProfileAssociation('HCL_Button', 3, 'Taster 3x betätigt', '' , 0x32cd32);
        IPS_SetVariableProfileAssociation('HCL_Button', 4, 'Taster 4x betätigt', '' , 0x32cd32);
        IPS_SetVariableProfileAssociation('HCL_Button', 5, 'Taster 5x betätigt', '' , 0x32cd32);
        IPS_SetVariableProfileAssociation('HCL_Button', 6, 'Taster gedrückt gehalten', '' , 0x32cd32);
	    echo "Profil HCL_Button erzeugt:".PHP_EOL;
	}
    if (!IPS_VariableProfileExists('HCL_Battery'))  
    {
	    IPS_CreateVariableProfile('HCL_Battery',0);
	    IPS_SetVariableProfileAssociation('HCL_Battery', 0, 'Batterie OK', '' , 0x00FF00);
        IPS_SetVariableProfileAssociation('HCL_Battery', 1, 'Batterie leer', '' , 0xFF0000);
        IPS_SetVariableProfileIcon('HCL_Battery','Battery');
	    echo "Profil HCL_Battery erzeugt:".PHP_EOL;
	}
    if (!IPS_VariableProfileExists('HCL_Floodsensor'))  
    {
	    IPS_CreateVariableProfile('HCL_Floodsensor',0);
	    IPS_SetVariableProfileAssociation('HCL_Floodsensor', 0, 'OK', '' , 0x00FF00);
        IPS_SetVariableProfileAssociation('HCL_Floodsensor', 1, 'Wasserschaden', '' , 0xFF0000);
        IPS_SetVariableProfileIcon('HCL_Floodsensor','Fog');
	    echo "Profil HCL_Floodsensor erzeugt:".PHP_EOL;
	}
}

// Anlegen Menüstrucktur
$CatID_Handsender     = CreateCategoryByName($parentID,"Handsender",100);
$CatID_Schalter       = CreateCategoryByName($parentID,"Schalter",200);
$CatID_Sensoren       = CreateCategoryByName($parentID,"Sensoren",300);
$CatID_Steckdosen     = CreateCategoryByName($parentID,"Steckdosen",400);
    
// Variablen anlegen
$errorID          = CreateVariableByName($parentID, "Error Counter HCL", 1,"",2);

// 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); 

// Kommunikationsstörung zum HCL
if ($json == "") 
{
    SetValue ($errorID, (GetValue($errorID)+1));
    IPS_LogMessage(IPS_GetName($_IPS['SELF']), "Kommunikationsstörung HCL - Missing Datenpackage");
    IPS_SetScriptTimer($IPS_SELF,0);   //Scripttimer pausieren
    Sleep (10);
    IPS_SetScriptTimer($IPS_SELF,$TimerInterval);   //Scripttimer auf gewünschen Intervall setzen
    exit;
}

// Aufbereitung der Daten   
foreach ($json as $i) {
    switch ($i->id) {
        //Bsp. Fibaro Button 
        case '104':
            hcl_button($CatID_Handsender,"Taster orange",1,$i); 
            break;
        //Bsp. Fibaro Double Switch
        case '91':
            hcl_switch($CatID_Schalter,"Schalter 1.1 Wohnzimmer Licht",1,$i); 
            break; 
        case '92':
            hcl_switch($CatID_Schalter,"Schalter 1.2 WZ-Vitrine Licht",2,$i);
            break;
        //Bsp. Fibaro Motion Sensor
        case '117':
            hcl_motion($CatID_Sensoren,"Auge 1",1,$i);
            break;
        case '118':
            hcl_temperature($CatID_Sensoren,"Auge 1",1,$i);
            break;
        case '119':
            hcl_lumintensity($CatID_Sensoren,"Auge 1",1,$i);
            break;
        //Bsp. Cyrus Wassersensor
        case '134':
            hcl_flood($CatID_Sensoren,"Wassersensor 1",51,$i); 
            break;
        //Bsp. Fibaro Steckdose mit Energiemessung
        case '96':
            hcl_switch($CatID_Steckdosen,"Stecker 1",1,$i);
            break;
        default:
            break;
    }
}

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/*Taster- Fibaro FGBP-101-8 */
function hcl_button($parent,$name,$pos,$index)  
{
    global $json;
    $InsID = CreateInstanzByName($parent,$name,"{485D0419-BE97-4548-AA9C-C083EB82E61E}",$pos);
    //Wert id
    $id0   = CreateVariableByName($InsID, "ID-HCL", 1,"",5);
    $state0 = $index->id;
    if (GetValue($id0)<> $state0) {SetValue ($id0,$state0);}
    //Wert Status
    $id1   = CreateVariableByName($InsID, "Status", 0,"HCL_Button",10);
    /*Wert wird direkt über HCL beschrieben (Virtuelles Modul + Graph.Szene)*/
    //Wert Batterielevel %
    $id2   = CreateVariableByName($InsID, "Batterielevel", 1,"~Intensity.100",11);
    $state2 = $index->properties->batteryLevel;
    if (GetValue($id2)<> $state2) {SetValue ($id2,$state2);}
    //Wert Batterielevel
    $id3   = CreateVariableByName($InsID, "Batterie", 0,"HCL_Battery",12);
    $state3 = $index->properties->batteryLowNotification;
    if($state3 == "false") {$state3 = 1;} else {$state3=0;}
    if (GetValue($id3)  <> $state3) {SetValue ($id3, $state3);}
};

/*Wassersensor -CyrusSmarthome Flood Sensor A691411 */
function hcl_flood($parent,$name,$pos,$index)  
{
    global $json;
    $InsID = CreateInstanzByName($parent,$name,"{485D0419-BE97-4548-AA9C-C083EB82E61E}",$pos);
    //Wert id
    $id0   = CreateVariableByName($InsID, "ID-HCL", 1,"",5);
    $state0 = $index->id;
    if (GetValue($id0)<> $state0) {SetValue ($id0,$state0);}
    //Wert Status
    $id1   = CreateVariableByName($InsID, "Status", 0,"HCL_Floodsensor",10);
    $state1 = $index->properties->value;
    if($state1 == "false") {$state1 = 0;} else {$state1=1;}
    if (GetValue($id1)  <> $state1) {SetValue ($id1, $state1);}
    //Wert Batterielevel %
    $id2   = CreateVariableByName($InsID, "Batterielevel", 1,"~Intensity.100",11);
    $state2 = $index->properties->batteryLevel;
    if (GetValue($id2)<> $state2) {SetValue ($id2,$state2);}
    //Wert Batterielevel
    $id3   = CreateVariableByName($InsID, "Batterie", 0,"HCL_Battery",12);
    $state3 = $index->properties->batteryLowNotification;
    if($state3 == "false") {$state3 = 1;} else {$state3=0;}
    if (GetValue($id3)  <> $state3) {SetValue ($id3, $state3);}
};

/*Bewegungssensor - Fibaro Motion Sensor FGMS-001 */
function hcl_motion($parent,$name,$pos,$index)  
{
    global $json;
    $InsID = CreateInstanzByName($parent,$name,"{485D0419-BE97-4548-AA9C-C083EB82E61E}",$pos);
    //Wert id
    $id0   = CreateVariableByName($InsID, "ID-HCL", 1,"",5);
    $state0 = $index->id;
    if (GetValue($id0)<> $state0) {SetValue ($id0,$state0);}
    //Wert Status
    $id1   = CreateVariableByName($InsID, "Status", 0,"~Switch",10);
    $state1 = $index->properties->value;
    if($state1 == "false") {$state1 = 0;} else {$state1=1;}
    if (GetValue($id1)  <> $state1) {SetValue ($id1, $state1);}
    //Wert Batterielevel %
    $id2   = CreateVariableByName($InsID, "Batterielevel", 1,"~Intensity.100",11);
    $state2 = $index->properties->batteryLevel;
    if (GetValue($id2)<> $state2) {SetValue ($id2,$state2);}
    //Wert Batterielevel
    $id3   = CreateVariableByName($InsID, "Batterie", 0,"HCL_Battery",12);
    $state3 = $index->properties->batteryLowNotification;
    if($state3 == "false") {$state3 = 1;} else {$state3=0;}
    if (GetValue($id3)  <> $state3) {SetValue ($id3, $state3);}
};

/*Temperatursensor - Fibaro Motion Sensor FGMS-001 */
function hcl_temperature($parent,$name,$pos,$index)  
{
    global $json;
    $InsID = CreateInstanzByName($parent,$name,"{485D0419-BE97-4548-AA9C-C083EB82E61E}",$pos);
    //Wert Temperatur
    $id1   = CreateVariableByName($InsID, "Temperatur", 2,"~Temperature",12);
    $state1 = $index->properties->value;
    if (GetValue($id1)  <> $state1) {SetValue ($id1, $state1);}
};

/*Lichtstärkesensor - Fibaro Motion Sensor FGMS-001 */
function hcl_lumintensity($parent,$name,$pos,$index)  
{
    global $json;
    $InsID = CreateInstanzByName($parent,$name,"{485D0419-BE97-4548-AA9C-C083EB82E61E}",$pos);
    //Wert Temperatur
    $id1   = CreateVariableByName($InsID, "Beleuchtungsstärke", 2,"~Illumination.F",13);
    $state1 = $index->properties->value;
    if (GetValue($id1)  <> $state1) {SetValue ($id1, $state1);}
};

/*Schalter - Fibaro Double Switch FGS-213/223 */
/*Steckdose mit Energiemessung - Fibaro ,AEOTEC SmartSwitch A 647729 */
function hcl_switch($parent,$name,$pos,$index)  
{
    global $json;
    $InsID = CreateInstanzByName($parent,$name,"{485D0419-BE97-4548-AA9C-C083EB82E61E}",$pos);
    //Wert id
    $id0   = CreateVariableByName($InsID, "ID-HCL", 1,"",5);
    $state0 = $index->id;
    if (GetValue($id0)<> $state0) {SetValue ($id0,$state0);}
    //Wert Status
    $id1   = CreateVariableByName($InsID, "Status", 0,"~Switch",10);
    $state1 = $index->properties->value;
    if($state1 == "false") {$state1 = 0;} else {$state1=1;}
    if (GetValue($id1)  <> $state1) {SetValue ($id1, $state1);}
    //Wert Verbrauch
    $id2   = CreateVariableByName($InsID, "Verbrauch", 2,"~Electricity",11);
    $state2 = $index->properties->energy;
    if (GetValue($id2)<> $state2) {SetValue ($id2,$state2);}
    //Wert Leistung
    $id3   = CreateVariableByName($InsID, "Leistung", 2,"~Watt.3680",12);
    $state3 = $index->properties->power;
    if (GetValue($id3) <> $state3) {SetValue ($id3,$state3);}
};



function CreateEventIDByName($id, $name, $type)
{
   $eid = @IPS_GetEventIDByName($name, $id);
   if($eid===false) {
      $eid = IPS_CreateEvent($type);
      IPS_SetParent($eid, $id);
      IPS_SetName($eid, $name);
   }
   return $eid;
} 

 
function CreateLinkByName($id, $name, $link, $pos)
{
    global $IPS_SELF;
    $vid = @IPS_GetLinkIDByName($name, $id);
    if($vid === false)
    {
        $vid = IPS_CreateLink();
        IPS_SetParent($vid, $id);
        IPS_SetName($vid, $name);
        IPS_SetInfo($vid, "");
        IPS_SetPosition($vid,$pos);
		IPS_SetLinkTargetID($vid, $link);    // Link verknüpfen
    }
    return $vid;
} 

function CreateCategoryByName($id, $name, $pos)
{
    global $IPS_SELF;
    $vid = @IPS_GetCategoryIDByName($name, $id);
    if($vid === false)
    {
        $vid = IPS_CreateCategory();
        IPS_SetParent($vid, $id);
        IPS_SetName($vid, $name);
        IPS_SetInfo($vid, "");
        IPS_SetPosition($vid,$pos);
    }
    return $vid;
} 

function CreateInstanzByName($id, $name, $type, $pos)
{
    global $IPS_SELF;
    $vid = @IPS_GetInstanceIDByName($name, $id);
    if($vid === false)
    {
        $vid = IPS_CreateInstance($type);
        IPS_SetParent($vid, $id);
        IPS_SetName($vid, $name);
        IPS_SetInfo($vid, "");
        IPS_SetPosition($vid,$pos);
    }
    return $vid;
} 

function CreateVariableByName($id, $name, $type, $profile = "", $pos)
{
    global $IPS_SELF;
    $vid = @IPS_GetVariableIDByName($name, $id);
    if($vid === false)
    {
        $vid = IPS_CreateVariable($type);
        IPS_SetParent($vid, $id);
        IPS_SetName($vid, $name);
        IPS_SetInfo($vid, "");
        if($profile !== "") { IPS_SetVariableCustomProfile($vid, $profile); }
		IPS_SetPosition($vid,$pos);
    }
    return $vid;
}


function CreateScriptByName($ScriptNAME, $ParentID, $ScriptTEXT)
{
   global $IPS_SELF,$ScriptID;
    $ScriptID = @IPS_GetScriptIDByName($ScriptNAME, $ParentID);
    if ($ScriptID == 0){
       $ScriptID = IPS_CreateScript(0);
       IPS_SetName($ScriptID, $ScriptNAME);
       IPS_SetParent($ScriptID, $ParentID);
       IPS_SetInfo($ScriptID, "");
       $ScriptPath = $ScriptID.".ips.php";     //Skriptdatei
       IPS_SetScriptFile($ScriptID, $ScriptPath);
       IPS_SetHidden($ScriptID, true);
       IPS_SetScriptContent($ScriptID, $ScriptTEXT);
    }
	return $ScriptID;
}

//Funktion extract_unit
function extract_unit($string, $start, $end)
 {
 $pos = stripos($string, $start);
 $str = substr($string, $pos);
 $str_two = substr($str, strlen($start));
 $second_pos = stripos($str_two, $end);
 $str_three = substr($str_two, 0, $second_pos);
 $unit = trim($str_three);
 return $unit;
 }

Durch die Nutzung von Virtuellen Modulen und Graphischen Szenen kann man direkt vom HCL Variablen in IPS schreiben bzw lesen oder Scripte direkt starten
Vorrausetzung hierfür ist auf Seite von Symcon ein Webhook.
Hier nutze ich die Scriptsammlung von Bayaro. Viele Dank an dieser Stelle, die Scriptsammlung hat schon so manches mal weitergeholfen.
https://www.symcon.de/forum/threads/28210-IP-Symcon-Wie-kann-ich-2-0?p=267779#post267779

Das folgende Skript z.B. mit dem Namen „WebhookBY.php“ im IP-Symcon Ordner unter /webfront/user abspeichern:

<?
if (isset($_GET["RUNScriptID"])) {
    $IPS_RunScriptID = (int)$_GET["RUNScriptID"];
    IPS_RunScript($IPS_RunScriptID);
    //echo "Skript mit der ID ".$IPS_RunScriptID." wurde ausgeführt!";
}
elseif ((isset($_GET["SETVarID"])) AND (isset($_GET["SETVarVALUE"]))) {
    $IPS_SETVarID = (int)$_GET["SETVarID"];
    $IPS_SETVarVALUE = (int)$_GET["SETVarVALUE"];
    SetValue($IPS_SETVarID, $IPS_SETVarVALUE);
    //echo "Die Variable mit der ID ".$IPS_SETVarID." wurde auf den Wert ".$IPS_SETVarVALUE." gesetzt!";
}
elseif (isset($_GET["GETVALVarID"])) {
    $IPS_GETVarID = (int)$_GET["GETVALVarID"];
    $GETWert = GetValue($IPS_GETVarID);
    //echo "Die Variable mit der ID ".$IPS_GETVarID." hat den Wert '".$GETWert."'!";
} 

Auf der Seite vom HCL ist eine Virtuelles Modul zu erstellen und die Zuständes der Variablen in grapischen Szenen zu übergeben. Ein Script Sprache (LUA) gibt es leider erst bei den teueren HC Modellen. Es ist zwar ewas aufwändig aber es funktioniert sehr gut.

Bsp. Motion Sensor Fibaro Bewegung direkt in eine Variable von IPS schreiben.
Zuerst Datei Symcon-Auge.txt in Datei Symcon-Auge.vfib umbennen

  1. Dazu im HCL→ Module→ Neue Modul hinzufügen →Virtuelles Modul importieren
    Datei Symcon-Auge.vfib auswählen und ausführen.
    →Reiter Allgemein
    Name: Symcon Auge
    Raum: z.B. Technik
    IP: xxx.xxx.xxx.xxx IP von IP-Symcon
    TCP Port : 3777
    →Reiter Fortgeschritten
    In Scriptbox Aktiv jeweils die IPSymcon Objekt ID eintragen (SETVarID=xxxxxx)
    Und Speichern
    Die Funktionalität des rücksetzten des Signales erfolgt über die zyklische Stausmeldung.

  2. Dazu im HCL→ Szenen→ Szene hinzufügen →Graphische Szene
    →Reiter Allgemein
    Name: Auge 1 Aktiv
    Raum: z.b Technik
    →Reiter Erweitert

Bsp. Fibaro Button Betätigung direkt in eine Variable von IPS schreiben.
Dazu Datei Symcon-TA.txt ind Symcon.TA.vfib umbennen

  1. Dazu im HCL→ Module→ Neue Modul hinzufügen →Virtuelles Modul importieren
    Datei Symcon-TA.vfib auswählen und ausführen.
    →Reiter Allgemein
    Name: Symcon -TA
    Raum: z.B. Technik
    IP: xxx.xxx.xxx.xxx IP von IP-Symcon
    TCP Port : 3777
    →Reiter Fortgeschritten
    In Scriptboxen jeweils die IPSymcon Objekt ID (SETVarID=xxxxxx)eintragen
    Und Speichern

  2. Dazu im HCL→ Szenen→ Szene hinzufügen →Graphische Szene
    →Reiter Allgemein
    Name: TA 1x betätigt
    Raum: z.b Technik
    →Reiter Erweitert

Diesen Vorgang noch 6x wiederholen für 2x 3x 4x 5x betätigt, TA losgelassen, TA gedrückt gehalten.
Zustand 0 Taster losgelassen
Zustand 6 Taster permamnet betätigt
Zustand 1 Taster 1x gedrückt
Zustand 2 Taster 2x gedrückt
Zustand 3 Taster 3x gedrückt
Zustand 4 Taster 4x gedrückt
Zustand 5 Taster 5x gedrückt

Symcon-Auge.txt (500 Bytes)

Symcon-TA.txt (1.82 KB)

Das Script in den Ordner HCL-ZWave legen und 1xhändisch ausführen.

Das Script ist optional. Es dient dazu die Kommunikation zum HCl zu aktivieren bzw. deaktiviren. Hintergrund hierbei ist, das bei Wartungsarbeiten am HCL z.B Backup erstellen, Update Hcl oder Device die Kommuikation zu Symcon unterbrochen wird und dann Fehler auflaufen. der Schalter Wartungsmodus kann über Webfront/IPSView oder direkt am HCL geschalten werden. Ein Koniguration ist hier nicht notwendig. Vorraussetzung hierfür sind die Funktionen im Teil 3 Direktes Schreiben vom HCL aus.

Script Wartungsmodus HCL

Das Schalten direkt vom HCL erfolgt über ein Viruelles Modul.
Zuerst Datei Wartungsmodus.txt in Wartungsmodus.vfib umbennen
Das Schalten direkt vom HCL erfolgt über ein Viruelles Modul.
Dazu im HCL→ Module→ Neue Modul hinzufügen →Virtuelles Modul importieren
Datei Wartungsmodus.vfib auswählen und ausführen.
→Reiter Allgemein
Name: Wartungsmodus
Raum: z.B. Technik
IP: xxx.xxx.xxx.xxx IP von IP-Symcon
TCP Port : 3777
→Reiter Fortgeschritten
In Scriptbox AUS und Aktiv jeweils die IPSymcon Objekt ID eintragen (SETVarID=xxxxxx)
Und Speichern

Wartungsmodus.txt (726 Bytes)

Anbei noch ein paar allgemeine Tipps, vieleicht helfen sie weiter.

Erstinbetriebnahme:
Beim HCL kann nur der Hauptuser Geräte hinzufügen oder entfernen bzw. Daten bearbeiten.
Das HCL bietet nur ein Cloud Backup, dazu ist eine sogenannte Fibaro ID als Nutzer bei Fibaro anzulegen (siehe Manual Fibaro).

Update HCL:
Mein HCL war neu und originalverpackt, allerdings mit den Firmwarestand von 3.601.
Im Menü Konfiguration–> Reiter Allgemeine wird auf eine Neue Firmwarestand hingewiesen.
Das Update von Version 3.x auf 3.y verläuft ohne Probleme, genauso das 4.x auf 4.y. Vor jeden Update wird ein Erstellen eines Backups abgefragt.
Ich habe festgestellt das beim Update von 3.x auf Version 4 umfangreichere Änderungen vorgenommen wurden. Hier war das HCL nach meheren Stunden noch am arbeiten. Ich habe nach ca. 24h über den Fibarofinder das Gerät neu gesucht und eine Soft Reboot durchgeführt. Dann startet das Gerät nach einigen Minuten mit der neuen Version. Ein Netzstecker ziehen sollte man vermeiden.
Bitte vor einen Update oder Backup den Wartungsmodus aktivieren da die Kommunikation zu Symcon dabei gestört wird(Interne Rest API abgeschalten)

Update Devices:
Generell nur Durchführen wenn Notwendigkeit besteht.
Ich habe bei mir 12 Fibaro Double-Switch auf Version 3.3 upgedatet. Als Hinweis HCL sollte dazu in unmittelbarer Nähe ca. 1m vom Schalter sein. Ein vorhandenes Update wird über die Infobox angezeigt. Man kann auch auf das Gerät direkt gehen (immer Hauptkanal) und über Check das ganze prüfen. Nach Anschieben des Updates erscheint die Meldung Downloding… und dann ist das Gerät wie eingefroren. Nach Test habe ich festgestellt man sollte ca. 45-60min warten und dann über den Fibarofinder das Gerät Soft rebooten. In 90% der Fälle (bei meinen 12 Geräten) hat das Update so beim ersten mal geklappt. Und wenn nicht alles wieder holen.
Ich habe bis jetzt keine Erklärung dafür gefunden.

Kommunikation mit Symcon:
Am einfachsten ist es für die Kommunikation mit Symcon einen Nutzer z.B. Symcon anzulegen. Menü Konfiguration --> Reiter Zugriffssteuerung
Nach einen Soft Reboot ist dieser auch im System angemeldet.
Im Menü Konfiguration --> Reiter Zugriffssteuerung dann den Nutzer (Bearbeiten) auswählen. Im neuen Fenster --> Module Zugriffsrechte bearbeiten auswählen und dann nur die Geräteteile durch anhacken auswählen, die man in Symcon benötigt. Das reduziert das Datenvolumen beim Abruf des Gerätestatus im Script HCL Status lesen.
Nur die Geräte die hier aktiviert sind werden mit den ausgewählten User im IP-Symcon eingelesen.

Hallo TE999,

deine Idee gefällt mir (Das HCL wie eine CCU anbinden) und ich habe angefangen deine Scripte bei mir zum Leben zu erwecken.

Nun ist mir aufgefallen, das die Datei „Symcon-TA.txt“ in deinen Posts fehlt !
Magst Du sie noch nachträglich zur verfügung stellen ?

Ich danke Dir schon Mal :slight_smile:

Gruß
lueralba

Sehr guter Beitrag!! ICh finde es toll das du dir die Mühe gemacht hast einen solch langen Beitrag zu verfassen!
Ich finde es schade das die Jungs von Symcon einige Probleme, bzw Fragen die mit ZWave auftauchen einfach nicht beachten oder beantworten. Sonst müsste man für etwas für das man Geld bezahlt nicht auf so einen Weg ausweichen.

Danke das es Euch gefällt.
Ich werde den Beitrag am Wochenende vervollständigen.

Gruß
Thomas

Gute Idee das Ganze. Ich habe eine HCL primär wegen der Modulupdates gekauft und hatte früher auch schon eine HC 2. Nach dem Wechsel zu Symcon wurde dann alles über ein Razberry Modul erledigt und bis heute (jetzt mit Version 2 des Moduls) läuft weitestgehend alles bei mir.

Die HCL habe ich weiterhin als Second Controller eingebunden, um Fibaro Modul-Updates durchzuführen. Eventuell könnte man so aber auch auf einen „Zwave-Profi“ setzen und den Rest über Symcon abbilden (Logik etc)

Eine Frage… Was hat es den mit den Fibaro Modul Updates auf sich?
Firmwareupdates der Fibaro Aktoren?

Ich habe einen Stall voll Fibaros (Rolladenaktoren aller Versionen, Einfach/Doppelswitche, Wassersensor, Türkontakt)…

Genau, Firmwareupdates. Die Dimmer 2 haben beispielsweise Probleme mit Etagenschaltungen oder Flackern etc. Das soll damit besser sein.

Vielen Dank für den Beitrag. Ich bin gerade echt am überlegen, ob ich mir ne HCL bestelle, vielleicht auch nur für die Firmware-Updates :wink:

Grüße
Stefan

Hallo TE999,

muss dir auch für den TOP Beitrag danken.

Wie von Dir beschrieben quäle ich mich leider auch seit längerem mit den unterschiedlichsten Z_Wave Komponenten und mit jedem neuen Gerät kommt leider immer wieder was dazu.

Schade das SYMCOM mit Z-Wave solche Probleme hat.
Hatte zuvor Homematic und das lief erheblich „geschmeidiger“ - habe aber leider auf Grund der Beschaffenheiten keine Alternative zu Z-Wave.

Vielleicht werde ich auch das HCL mal ausprobieren…

Viele Grüße
HEinz

Habe auch noch nen Sack voll zwave Geräte rumliegen, da ich es im Haus nicht vernüftig zum laufen bekommen habe.
Hier lag es am Funk, der wollte manche Wände nicht durchdringen.:smiley:
Mit Homatik kann ich ach nur einen Kleinen Teil im Haus erreichen und danach kamen die Versuche mit Wlan, da ich im Haus 4 Repeater verteilt habe um alles Ecken zu erwischen. Da haben wir dann Sonoff, Shelly und Eigenbau Module versucht, und die haben bis heute, die besten Ergebnisse gebracht. Da alles auf ESP8266 Basis läuft kann man das sehr gut über KaiS Module in IPS einbauen und viele Dinge machen.Ich setzte da teilweise auf die Tasmota Firmware, und Shelly Firmware, je nach Anwendung.
Mal sehen eir Zigbee auf Dauer geht, ist bis jetzt nur mit einigen Geräten bei mir in der Wohnung, bei KaiS läuft da ein bischen mehr, und die Wohnung von Kai ist etwas kleiner und hat nicht so dicke Wände. Da reicht an zentraler Stelle ein Wlan-AP oder auch anderes Funk Gateway.
Unser Haus ist Bj 1876 mit einigen Anbauten um 1900, daher habe ich in meiner Wohnung auch mal Bruchsteinwände, die mal locker 80cm dick sind, und daher werden die Wlan-AP’s per Kabel gespeißt.

Nur mal so, was ich probiert habe, und das soll niemanden Überzeugen, es genau so zu machen !.
Im Moment scheinen mir die Shelly Lösungen bei Funk und MQTT am günstigsten zu sein, ohne basteln zu müssen, und die laufen hier sehr gut.

Hallo tomgr,

hast Du auch ein HCL? Erfahrungen damit?

Viele Grüße aus dem Unterallgäu
Harry

Offtopic:
Hast Du als Tasmota-Profi auch eine Leseeinheit am Stromzähler?
Ich hab es im zugehörigen Thread nicht so ganz verstanden, ob es ein Standard-Tasmota ist das die Jungs dort einsetzen.

Ich habe nen ollen Ynode mit zwei USB-Leseköpfen an meinen Stromzählern und überlege, ob die Tasmota-Lösung nicht einfacher wäre.

Hallo Thomas,

interessante Scripts die du da veröffentlicht hast. Nachdem ich auch etliche Probleme mit den Fibaro-Geräten habe, überlege ich auch deine Lösung mal auszuprobieren. Ich habe gerade das erste Gerät angelegt.

Bei der Installation des Wartungsmodus habe ich festgestellt, dass das „Script Wartungsmodus HCL“ fehlt. Das ist sicher ein Actionsscript, welches unter der Variable „Wartungsmodus HCL“ steht. Wäre toll, wenn du dein Script hier mit anhängen könntest? Danke!

viele Grüße
cervicor

Hallo Te999,

danke für Deinen ausführlichen Beitrag. Ich habe ähnliche Problem mit der Z-Wave Welt am IPS.
Vor allem die Bewegungssensoren und Rauchmelder arbeiten nicht zuverlässig.

Wie ist den das Antwortverhalten der HCL zum IPS wenn bspw. ein Bewegungssensor eine Bewegung erkennt?
Kannst Du sagen welche „gefühlte“ Zeitspanne vergeht, bis IPS reagiert. Ich schalte in unserem Treppenhaus über den FGMS-001 das Licht ein, über das Z-Wave-Modul im IPS können schon mal 1-2 Sekunden vergehen, bis es hell wird.

Hast Du eventuell auch Erfahrung mit anderen Z-Wave-Geräten am HCL gemacht, ich habe hier ein paar Rauchmelder von Popp, sowie Türkontakte von Aeotec und Devolo Steckdosen MT 02792

Werden diese Devices auch vom HCL verwaltet?

Grüße Detlev.

Hallo TE999,

Kann es sein, dass man bei den Schaltern noch ein Aktionsskript zu den Schaltvariablen schreiben muss, damit man aus dem Webfront oder IPS-Studio schalten kann?

Gruß
cervicor

Hallo.

Habe beim Testen festgestellt, das ein Schaltkommando via Curl deutlich langsam (1-2sec) ist.
Kann das hier jemand bestätigen ?

Danke und Gruß
lueralba