Datei im Verzeichnis …\IP-Symcon\scripts\IPSLibrary\app\core\IPSComponent\IPSComponentRGB\ anlegen
Sonst ist nichts zu machen, die Komponente wird rein über den Namen gefunden.
Parameter sind in der Klasse auch nochmals beschrieben:
/**
* @public
*
* Initialisierung eines IPSComponentRGB_PhilipsHUE Objektes
*
* @param string $bridgeIP IP Addresse der HUE Lampe
* @param string $hueKey Key zum Zugriff auf die Lampe
* @param string $lampNr Nummer der Lampe
*/
Hallo Andreas, funktioniert leider nicht. Ich habe die Datei erstellt und im Config-File alles entsprechend eingetragen und das IPSLight Modul neu installiert. Ich sehe leider auch keine Fehlermeldung die weiter helfen könnte.
Tom
@browson
ist es vielleicht mal angedacht Bewegungsmelder zu integrieren?
Das könnte man ja über ein Event steuern. (D.h. unabhängig ob Homematic, FS20, ZWave oder oder…)
D.h. Bewegungsmelder kann Aktor=Licht an/ausschalten.
Lichtschalter kann Aktor=Licht schalten.
Lichtschalter hat Vorrang vor Bewegungsmelder.
Hallo Zusammen,
ich habe meiner IPSLight Konfigurationen jetzt noch zwei Homatic-Steckdosen Schalter als Switch_Homematic hinzugefügt.
Nun habe ich folgendes Problem:
Wenn ich diese Schalter extern (entweder mittels eigener IPS Einbindung oder auch mittels Homematic Schalter) aktiviere, dann synchronisiert sich der Stand in IPSLight auch korrekt und der Schaltzustand bleibt wie gehabt.
Schalte ich nun jedoch diesen Schalter mittels IPSLight ein, dann geht das Licht auch an und die Anzeige ist korrekt, jedoch wird nach ca. 10 Sekunden das Licht wieder ausgeschalten.
Ich habe versucht einwenig in dem Programm zu tracken was passiert. Beim Schalten mittels IPSLight wird auch korrekt der SynchState von HandleEvent auf „An“ gesendet.
Allerdings wird ca. 10 Sekunden später die Variablen „State“ und „Working“ des Homematic Switches auf „Aus“ geschaltet.
Was mir noch aufgefallen ist:
Meine IPS Einbindung und der Homematic Schalter setzten nur den „State“ auf „An“, nicht jedoch „Working“. Eventuell hängt es damit zusammen.
Gruß
Matthias
am einfachsten du registriert ein Event im MessageHandler
Füge das Beispiel (Array) in die Datei: IPSMessageHandler_Configuration.inc.php in die Funktion
IPSMessageHandler_GetEventConfigurationCust ein.
/**
*
* Liefert Liste mit Event Variablen, die vom MessageHandler bearbeitet werden. Diese Liste kann vom Anwender
* frei definiert werden
*
* @return string[] Key-Value Array mit Event Variablen und der dazugehörigen Parametern
*/
function IPSMessageHandler_GetEventConfigurationCust() {
$config = array(
// 54321 : Objekt ID der Statusvariable des Bewegungsmelder
// 12345 : Objekt ID des IPSLight Device (data Ordner)
54321 => array('OnUpdate','IPSComponentSensor_Button','IPSModuleSensor_IPSLight,IPSLight_SetSwitch,12345,true'),
);
return $config;
}
Mit dem folgenden Code (einfach ein neues IPS-Script mit folgenden Inhalt anlegen und ausführen) wird des Event registriert.
<?
IPSUtils_Include ('IPSMessageHandler.class.php', 'IPSLibrary::app::core::IPSMessageHandler');
$messageHandler = new IPSMessageHandler();
$messageHandler->CreateEvents();
?>
[HR][/HR]
@alle IPSLibrary-Benutzer:
Ich arbeite an einem Update an IPSLight um Timer gesteuerte Devices zu erhalten.
Einstellbar sind die Timerlaufzeiten über die Konfigurationseinstellungen.
Folgende Timer sind möglich:
Anzugverzögerung (>= 1 sec):
schaltet das Device nach Ablauf der Anzugverzögerung EIN
kann nicht unterbrochen werden
Timer (>= 1 sec):
schaltet das Device für die angegebene Laufzeit ein
kann unterbrochen oder abgebrochen werden
Abfallverzögerung (>= 1 sec):
schaltet das Device nach Ablauf der Abfallverzögerung AUS
kann nicht unterbrochen werden
Der Timer ist auch bei Synchronisierung der Stati lauffähig.
Die Anzugverzögerung und Abfallverzögerung ist bei Snchronisierung nicht möglich, da direkt (ohne IPS) geschalten wird.
Bei Interesse (Beta Tester) bitte PN an mich.
Gruß
Günter
@Maze
das hört sich irgendwie nach OnTime von Homematic an, hast Du da eventuell was konfiguriert (Aktor selbst oder auch IPSLight)
Danke Andreas,
ne, der Fehler war noch blöder 
Ich hab zwar nen Homematic Switch hinzugefügt, den aber dummerweise als Dimmer deklariert
Hatte somit auch Name#Level und das war das Problem.
Ich Anfänger O_O
Hallo Andreas,
noch ein kleines Problem (mit Lösung) das bei mir aufgetreten ist:
Ich verwende Philipps LED Deckenleuchten mit einem Eltako Dimmer. In deinem IPSLight_Manager.class.php wird der Levelwert auf „10“ gesetzt, wenn der Dimmer einfach eingeschalten wird.
Bei meiner LED und Dimmer Kombination, führt jedoch jeglicher Dimmwert <= 13 zu einem NICHT einschalten der LEDs und einem Resett auf „0“.
Ich habe in einfach in der SetDimmer Funktion den automatisch gesetzten Level auf 15 erhöht.
Vielleicht kannst Du das ja so übernehmen, dann muss ich das nicht jedesmal nach einem Update Ändern.
Danke und Gruß
Matthias
<?
/*
* This file is part of the IPSLibrary.
*
* The IPSLibrary is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published
* by the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* The IPSLibrary is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with the IPSLibrary. If not, see http://www.gnu.org/licenses/gpl.txt.
*/
/**@addtogroup ipslight
* @{
*
* @file IPSLight_Manager.class.php
* @author Andreas Brauneis
* @version
* Version 2.50.1, 26.07.2012<br/>
*
* IPSLight Licht Management
*/
/**
* @class IPSLight_Manager
*
* Definiert ein IPSLight_Manager Objekt
*
* @author Andreas Brauneis
* @version
* Version 2.50.1, 26.07.2012<br/>
*/
class IPSLight_Manager {
/**
* @private
* ID Kategorie mit Schalter und Dimmern
*/
private $switchCategoryId;
/**
* @private
* ID Kategorie mit Schalter
*/
private $groupCategoryId;
/**
* @private
* ID Kategorie mit Programmen
*/
private $programCategoryId;
/**
* @public
*
* Initialisierung des IPSLight_Manager Objektes
*
*/
public function __construct() {
$baseId = IPSUtil_ObjectIDByPath('Program.IPSLibrary.data.modules.IPSLight');
$this->switchCategoryId = IPS_GetObjectIDByIdent('Switches', $baseId);
$this->groupCategoryId = IPS_GetObjectIDByIdent('Groups', $baseId);
$this->programCategoryId = IPS_GetObjectIDByIdent('Programs', $baseId);
}
/**
* @public
*
* Liefert ID eines Schalters anhand des Namens
*
* @param string $name Name des Schalters
* @return int ID des Schalters
*/
public function GetSwitchIdByName($name) {
return IPS_GetVariableIDByName($name, $this->switchCategoryId);
}
/**
* @public
*
* Liefert ID einer Level Variable eines Dimmers anhand des Namens
*
* @param string $name Name des Dimmers
* @return int ID der Level Variable
*/
public function GetLevelIdByName($name) {
return IPS_GetVariableIDByName($name.IPSLIGHT_DEVICE_LEVEL, $this->switchCategoryId);
}
/**
* @public
*
* Liefert ID einer RGB Variable anhand des Namens
*
* @param string $name Name des RGB Lichtes
* @return int ID der RGB Variable
*/
public function GetColorIdByName($name) {
return IPS_GetVariableIDByName($name.IPSLIGHT_DEVICE_COLOR, $this->switchCategoryId);
}
/**
* @public
*
* Liefert ID eines Gruppen Schalters anhand des Namens
*
* @param string $name Name der Gruppe
* @return int ID der Gruppe
*/
public function GetGroupIdByName($name) {
return IPS_GetVariableIDByName($name, $this->groupCategoryId);
}
/**
* @public
*
* Liefert ID eines Programm Schalters anhand des Namens
*
* @param string $name Name des Programm Schalters
* @return int ID des Programm Schalters
*/
public function GetProgramIdByName($name) {
return IPS_GetVariableIDByName($name, $this->programCategoryId);
}
/**
* @public
*
* Liefert Wert einer Control Variable (Schalter, Dimmer, Gruppe, ...) anhand der zugehörigen ID
*
* @param string $variableId ID der Variable
* @return int Wert der Variable
*/
public function GetValue($variableId) {
return GetValue($variableId);
}
/**
* @public
*
* Setzt den Wert einer Control Variable (Schalter, Dimmer, Gruppe, ...) anhand der zugehörigen ID
*
* @param int $variableId ID der Variable
* @param int $value Neuer Wert der Variable
*/
public function SetValue($variableId, $value) {
$parentId = IPS_GetParent($variableId);
switch($parentId) {
case $this->switchCategoryId:
$configName = $this->GetConfigNameById($variableId);
$configLights = IPSLight_GetLightConfiguration();
$lightType = $configLights[$configName][IPSLIGHT_TYPE];
if ($lightType==IPSLIGHT_TYPE_SWITCH) {
$this->SetSwitch($variableId, $value);
} elseif ($lightType==IPSLIGHT_TYPE_DIMMER) {
$this->SetDimmer($variableId, $value);
} elseif ($lightType==IPSLIGHT_TYPE_RGB) {
$this->SetRGB($variableId, $value);
} else {
trigger_error('Unknown LightType '.$lightType.' for Light '.$configName);
}
break;
case $this->groupCategoryId:
$this->SetGroup($variableId, $value);
break;
case $this->programCategoryId:
$this->SetProgram($variableId, $value);
break;
default:
trigger_error('Unknown ControlId '.$variableId);
}
}
/**
* @public
*
* Setzt den Wert einer Schalter Variable anhand der zugehörigen ID
*
* @param int $switchId ID der Variable
* @param bool $value Neuer Wert der Variable
*/
public function SetSwitch($switchId, $value, $syncGroups=true, $syncPrograms=true) {
if (GetValue($switchId)==$value) {
return;
}
$configName = $this->GetConfigNameById($switchId);
$configLights = IPSLight_GetLightConfiguration();
$componentParams = $configLights[$configName][IPSLIGHT_COMPONENT];
$component = IPSComponent::CreateObjectByParams($componentParams);
SetValue($switchId, $value);
IPSLogger_Inf(__file__, 'Turn Light '.$configName.' '.($value?'On':'Off'));
if (IPSLight_BeforeSwitch($switchId, $value)) {
$component->SetState($value);
}
IPSLight_AfterSwitch($switchId, $value);
if ($syncGroups) {
$this->SynchronizeGroupsBySwitch($switchId);
}
if ($syncPrograms) {
$this->SynchronizeProgramsBySwitch ($switchId);
}
}
/**
* @public
*
* Setzt den Wert einer Dimmer Variable anhand der zugehörigen ID
*
* @param int $variableId ID der Variable
* @param bool $value Neuer Wert der Variable
*/
public function SetDimmer($variableId, $value, $syncGroups=true, $syncPrograms=true) {
if (GetValue($variableId)==$value) {
return;
}
$configName = $this->GetConfigNameById($variableId);
$configLights = IPSLight_GetLightConfiguration();
$switchId = IPS_GetVariableIDByName($configName, $this->switchCategoryId);
$switchValue = GetValue($switchId);
$levelId = IPS_GetVariableIDByName($configName.IPSLIGHT_DEVICE_LEVEL, $this->switchCategoryId);
$levelValue = GetValue($levelId);
$componentParams = $configLights[$configName][IPSLIGHT_COMPONENT];
$component = IPSComponent::CreateObjectByParams($componentParams);
if ($variableId==$levelId) {
if (!$switchValue and $value>0) {
SetValue($switchId, true);
} else if ($switchValue and $value==0) {
SetValue($switchId, false);
} else {
}
if (GetValue($levelId) > 100) { $value = 100; }
if (GetValue($levelId) < 0) { $value = 0; }
} else {
if ($value and $levelValue==0) {
SetValue($levelId, 15); //BOMMH von 10 auf 15 geändert
}
}
SetValue($variableId, $value);
$switchValue = GetValue($switchId);
IPSLogger_Inf(__file__, 'Turn Light '.$configName.' '.($switchValue?'On, Level='.GetValue($levelId):'Off'));
if (IPSLight_BeforeSwitch($switchId, $switchValue)) {
$component->SetState(GetValue($switchId), GetValue($levelId));
}
IPSLight_AfterSwitch($switchId, $switchValue);
if ($syncGroups) {
$this->SynchronizeGroupsBySwitch($switchId);
}
if ($syncPrograms) {
$this->SynchronizeProgramsBySwitch ($switchId);
}
}
/**
* @public
*
* Setzt den Wert einer RGB Farb Variable anhand der zugehörigen ID
*
* @param int $variableId ID der Variable
* @param bool $value Neuer Wert der Variable
*/
public function SetRGB($variableId, $value, $syncGroups=true, $syncPrograms=true) {
if (GetValue($variableId)==$value) {
return;
}
$configName = $this->GetConfigNameById($variableId);
$configLights = IPSLight_GetLightConfiguration();
$switchId = IPS_GetVariableIDByName($configName, $this->switchCategoryId);
$colorId = IPS_GetVariableIDByName($configName.IPSLIGHT_DEVICE_COLOR, $this->switchCategoryId);
$levelId = IPS_GetVariableIDByName($configName.IPSLIGHT_DEVICE_LEVEL, $this->switchCategoryId);
$switchValue = GetValue($switchId);
$componentParams = $configLights[$configName][IPSLIGHT_COMPONENT];
$component = IPSComponent::CreateObjectByParams($componentParams);
SetValue($variableId, $value);
if (!$switchValue and ($variableId==$levelId or $variableId==$colorId)) {
SetValue($switchId, true);
}
$switchValue = GetValue($switchId);
IPSLogger_Inf(__file__, 'Turn Light '.$configName.' '.($switchValue?'On, Level='.GetValue($levelId).', Color='.GetValue($colorId):'Off'));
if (IPSLight_BeforeSwitch($switchId, $switchValue)) {
$component->SetState(GetValue($switchId), GetValue($colorId), GetValue($levelId));
}
IPSLight_AfterSwitch($switchId, $switchValue);
if ($syncGroups) {
$this->SynchronizeGroupsBySwitch($switchId);
}
if ($syncPrograms) {
$this->SynchronizeProgramsBySwitch ($switchId);
}
}
/**
* @public
*
* Setzt den Wert einer Gruppen Variable anhand der zugehörigen ID
*
* @param int $variableId ID der Gruppe
* @param bool $value Neuer Wert der Gruppe
*/
public function SetGroup($groupId, $value) {
$groupConfig = IPSLight_GetGroupConfiguration();
$groupName = IPS_GetName($groupId);
if ($value and !$groupConfig[$groupName][IPSLIGHT_ACTIVATABLE]) {
IPSLogger_Trc(__file__, "Ignore ".($value?'On':'Off')." forLightGroup '$groupName' (not allowed)");
} else {
SetValue($groupId, $value);
IPSLogger_Inf(__file__, "Turn LightGroup '$groupName' ".($value?'On':'Off'));
$this->SetAllSwitchesByGroup($groupId);
}
}
/**
* @public
*
* Setzt den Wert einer Programm Variable anhand der zugehörigen ID
*
* @param int $variableId ID der Programm Variable
* @param bool $value Neuer Wert der Programm Variable
*/
public function SetProgram($programId, $value) {
$programName = IPS_GetName($programId);
$programConfig = IPSLight_GetProgramConfiguration();
$programKeys = array_keys($programConfig[$programName]);
if ($value>(count($programKeys)-1)) {
$value=0;
}
$programItemName = $programKeys[$value];
IPSLogger_Inf(__file__, "Set Program $programName=$value ");
// Light On
if (array_key_exists(IPSLIGHT_PROGRAMON, $programConfig[$programName][$programItemName])) {
$switches = $programConfig[$programName][$programItemName][IPSLIGHT_PROGRAMON];
$switches = explode(',', $switches);
foreach ($switches as $idx=>$switchName) {
if ($switchName <> '') {
$switchId = $this->GetSwitchIdByName($switchName);
$configLights = IPSLight_GetLightConfiguration();
$lightType = $configLights[$switchName][IPSLIGHT_TYPE];
if ($lightType==IPSLIGHT_TYPE_SWITCH) {
$this->SetSwitch($switchId, true);
} elseif ($lightType==IPSLIGHT_TYPE_DIMMER) {
$this->SetDimmer($switchId, true);
} elseif ($lightType==IPSLIGHT_TYPE_RGB) {
$this->SetRGB($switchId, true);
} else {
trigger_error('Unknown LightType '.$lightType.' for Light '.$configName);
}
}
}
}
// Light Off
if (array_key_exists(IPSLIGHT_PROGRAMOFF, $programConfig[$programName][$programItemName])) {
$switches = $programConfig[$programName][$programItemName][IPSLIGHT_PROGRAMOFF];
$switches = explode(',', $switches);
foreach ($switches as $idx=>$switchName) {
if ($switchName <> '') {
$switchId = $this->GetSwitchIdByName($switchName);
$configLights = IPSLight_GetLightConfiguration();
$lightType = $configLights[$switchName][IPSLIGHT_TYPE];
if ($lightType==IPSLIGHT_TYPE_SWITCH) {
$this->SetSwitch($switchId, false);
} elseif ($lightType==IPSLIGHT_TYPE_DIMMER) {
$this->SetDimmer($switchId, false);
} elseif ($lightType==IPSLIGHT_TYPE_RGB) {
$this->SetRGB($switchId, false);
} else {
trigger_error('Unknown LightType '.$lightType.' for Light '.$configName);
}
}
}
}
// Light Level
if (array_key_exists(IPSLIGHT_PROGRAMLEVEL, $programConfig[$programName][$programItemName])) {
$switches = $programConfig[$programName][$programItemName][IPSLIGHT_PROGRAMLEVEL];
$switches = explode(',', $switches);
for ($idx=0; $idx<Count($switches)-1; $idx=$idx+2) {
$switchName = $switches[$idx];
$switchValue = (float)$switches[$idx+1];
$switchId = $this->GetSwitchIdByName($switchName);
$this->SetDimmer($switchId, true, true, false);
$switchId = $this->GetSwitchIdByName($switchName.IPSLIGHT_DEVICE_LEVEL);
$this->SetDimmer($switchId, $switchValue, true, false);
}
}
// Light RGB
if (array_key_exists(IPSLIGHT_PROGRAMRGB, $programConfig[$programName][$programItemName])) {
$switches = $programConfig[$programName][$programItemName][IPSLIGHT_PROGRAMRGB];
$switches = explode(',', $switches);
for ($idx=0; $idx<Count($switches)-1; $idx=$idx+5) {
$switchName = $switches[$idx];
$switchLevel = (float)$switches[$idx+1];
$switchColorR = (float)$switches[$idx+2];
$switchColorG = (float)$switches[$idx+3];
$switchColorB = (float)$switches[$idx+4];
$switchColor = $switchColorR*256*256+$switchColorG*256+$switchColorB;
$switchId = $this->GetSwitchIdByName($switchName);
$this->SetRGB($switchId, true, true, false);
$switchId = $this->GetSwitchIdByName($switchName.IPSLIGHT_DEVICE_LEVEL);
$this->SetRGB($switchId, $switchLevel, true, false);
$switchId = $this->GetSwitchIdByName($switchName.IPSLIGHT_DEVICE_COLOR);
$this->SetRGB($switchId, $switchColor, true, false);
}
}
SetValue($programId, $value);
}
// ----------------------------------------------------------------------------------------------------------------------------
private function GetConfigNameById($switchId) {
$switchName = IPS_GetName($switchId);
$switchName = str_replace(IPSLIGHT_DEVICE_COLOR, '', $switchName);
$switchName = str_replace(IPSLIGHT_DEVICE_LEVEL, '', $switchName);
return $switchName;
}
// ----------------------------------------------------------------------------------------------------------------------------
private function SynchronizeGroupsBySwitch ($switchId) {
$switchName = IPS_GetName($switchId);
$lightConfig = IPSLight_GetLightConfiguration();
$groups = explode(',', $lightConfig[$switchName][IPSLIGHT_GROUPS]);
foreach ($groups as $groupName) {
$groupId = IPS_GetVariableIDByName($groupName, $this->groupCategoryId);
$this->SynchronizeGroup($groupId);
}
}
// ----------------------------------------------------------------------------------------------------------------------------
private function SynchronizeGroup ($groupId) {
$lightConfig = IPSLight_GetLightConfiguration();
$groupName = IPS_GetName($groupId);
$groupState = false;
foreach ($lightConfig as $switchName=>$deviceData) {
$switchId = IPS_GetVariableIDByName($switchName, $this->switchCategoryId);
$switchState = GetValue($switchId);
$switchInGroup = array_key_exists($groupName, array_flip(explode(',', $deviceData[IPSLIGHT_GROUPS])));
if ($switchInGroup and GetValue($switchId)) {
$groupState = true;
break;
}
}
if (GetValue($groupId) <> $groupState) {
IPSLogger_Trc(__file__, "Synchronize ".($switchState?'On':'Off')." to Group '$groupName' from Switch '$switchName'");
SetValue($groupId, $groupState);
}
}
// ----------------------------------------------------------------------------------------------------------------------------
private function SynchronizeProgramsBySwitch($switchId) {
$switchName = IPS_GetName($switchId);
$programConfig = IPSLight_GetProgramConfiguration();
foreach ($programConfig as $programName=>$programData) {
foreach ($programData as $programItemName=>$programItemData) {
if (array_key_exists(IPSLIGHT_PROGRAMON, $programItemData)) {
if ($this->SynchronizeProgramItemBySwitch($switchName, $programName, $programItemData[IPSLIGHT_PROGRAMON])) {
return;
}
}
if (array_key_exists(IPSLIGHT_PROGRAMOFF, $programItemData)) {
if ($this->SynchronizeProgramItemBySwitch($switchName, $programName, $programItemData[IPSLIGHT_PROGRAMOFF])) {
return;
}
}
if (array_key_exists(IPSLIGHT_PROGRAMLEVEL, $programItemData)) {
if ($this->SynchronizeProgramItemBySwitch($switchName, $programName, $programItemData[IPSLIGHT_PROGRAMLEVEL])) {
return;
}
}
}
}
}
// ----------------------------------------------------------------------------------------------------------------------------
private function SynchronizeProgramItemBySwitch($switchName, $programName, $property) {
$propertyList = explode(',', $property);
$switchList = array_flip($propertyList);
if (array_key_exists($switchName, $switchList)) {
$programId = IPS_GetVariableIDByName($programName, $this->programCategoryId);
IPSLogger_Trc(__file__, "Reset Program '$programName' by manual Change of '$switchName'");
SetValue($programId, 0);
return true;
}
return false;
}
// ----------------------------------------------------------------------------------------------------------------------------
private function SetAllSwitchesByGroup ($groupId) {
$groupName = IPS_GetName($groupId);
$lightConfig = IPSLight_GetLightConfiguration();
$groupState = GetValue($groupId);
foreach ($lightConfig as $switchName=>$deviceData) {
$switchId = IPS_GetVariableIDByName($switchName, $this->switchCategoryId);
$switchInGroup = array_key_exists($groupName, array_flip(explode(',', $deviceData[IPSLIGHT_GROUPS])));
if ($switchInGroup and GetValue($switchId)<>$groupState) {
IPSLogger_Trc(__file__, "Set Light $switchName=".($groupState?'On':'Off')." for Group '$groupName'");
$this->SetValue($switchId, $groupState);
$this->SynchronizeGroupsBySwitch ($switchId);
}
}
}
public function SynchronizeSwitch($switchName, $deviceState) {
IPSLogger_Trc(__file__, "Received StateChange from Light '$switchName'=$deviceState");
$switchId = IPS_GetVariableIDByName($switchName, $this->switchCategoryId);
$lightConfig = IPSLight_GetLightConfiguration();
$deviceType = $lightConfig[$switchName][IPSLIGHT_TYPE];
if (IPSLight_BeforeSynchronizeSwitch($switchId, $deviceState)) {
if (GetValue($switchId) <> $deviceState) {
IPSLogger_Inf(__file__, 'Synchronize StateChange from Light '.$switchName.', State='.($deviceState?'On':'Off'));
SetValue($switchId, $deviceState);
$this->SynchronizeGroupsBySwitch($switchId);
$this->SynchronizeProgramsBySwitch($switchId);
}
}
IPSLight_AfterSynchronizeSwitch($switchId, $deviceState);
}
public function SynchronizeDimmer($switchName, $deviceState, $deviceLevel) {
IPSLogger_Trc(__file__, 'Received StateChange from Light '.$switchName.', State='.$deviceState.', Level='.$deviceLevel);
$switchId = IPS_GetVariableIDByName($switchName, $this->switchCategoryId);
$levelId = IPS_GetVariableIDByName($switchName.IPSLIGHT_DEVICE_LEVEL, $this->switchCategoryId);
$lightConfig = IPSLight_GetLightConfiguration();
$deviceType = $lightConfig[$switchName][IPSLIGHT_TYPE];
if (IPSLight_BeforeSynchronizeSwitch($switchId, $deviceState)) {
if (GetValue($switchId)<>$deviceState or GetValue($levelId)<>$deviceLevel) {
IPSLogger_Inf(__file__, 'Synchronize StateChange from Light '.$switchName.', State='.($deviceState?'On':'Off').', Level='.$deviceLevel);
SetValue($switchId, $deviceState);
SetValue($levelId, $deviceLevel);
$this->SynchronizeGroupsBySwitch($switchId);
$this->SynchronizeProgramsBySwitch($switchId);
}
}
IPSLight_AfterSynchronizeSwitch($switchId, $deviceState);
}
public function GetPowerConsumption($powerCircle) {
$powerConsumption = 0;
$lightConfig = IPSLight_GetLightConfiguration();
foreach ($lightConfig as $switchName=>$deviceData) {
$lightType = $lightConfig[$switchName][IPSLIGHT_TYPE];
if (array_key_exists(IPSLIGHT_POWERCIRCLE, $deviceData) and $deviceData[IPSLIGHT_POWERCIRCLE]==$powerCircle) {
$switchId = IPS_GetVariableIDByName($switchName, $this->switchCategoryId);
if (GetValue($switchId)) {
switch ($lightType) {
case IPSLIGHT_TYPE_SWITCH:
$powerConsumption = $powerConsumption + $deviceData[IPSLIGHT_POWERWATT];
break;
case IPSLIGHT_TYPE_DIMMER:
case IPSLIGHT_TYPE_RGB:
$levelId = IPS_GetVariableIDByName($switchName.IPSLIGHT_DEVICE_LEVEL, $this->switchCategoryId);
$powerConsumption = $powerConsumption + $deviceData[IPSLIGHT_POWERWATT]*GetValue($levelId)/100;
break;
default:
trigger_error('Unknown LightType '.$lightType.' for Light '.$configName);
}
}
}
}
return $powerConsumption;
}
}
/** @}*/
?>
Hallo Andreas,
vielen Dank erstmal für Deine Mühe. Ich habe heute die ersten Schritte mit IPSLight ausprobiert und wollte natürlich gleich die “ Beta"-Funktionen verwenden. Das Skript für die Philips Hue funktioniert prinzipiell nach einer kleinen Anpassung:
Die Klammern um die Parameter sind unnötig und führen zu einem Fehler. Mit der Änderung
return '"bri":'.$level.', "ct":'.$l.', "hue":'.$h.', "sat":'.$s.', "on":true';
anstatt
return ‘{"bri":'.$level.', "ct":'.$l.', "hue":'.$h.', "sat":'.$s.', "on":true}';
bzw.
$cmd = '"bri":255, "ct":0, "hue":0, "sat":0, "on":false';
anstatt
$cmd = '{"bri":255, "ct":0, "hue":0, "sat":0, "on":false}';
lassen sich die Lampen schalten.
Was leider noch nicht funktioniert, ist die Einstellung der Farben. Hier werde ich noch etwas weiter probieren.
An einer Stelle wäre ich um Deine Hilfe dankbar. Bei jeder Aktion im Web Frontend kommt es zu einer etwas unmotivierten Fehlermeldung:
Sowohl der Logger als auch die Meldungen in der Verwaltungskonsole zeichnen nichts auf … Hast Du eine Idee, wo diese Fehlermeldung erzeugt wird?
Viele Grüße
Jörg
Hallo Jörg,
scheint so als ob diese Meldung irgendwo von einem der Befehle auf den Output geschrieben wird (echo) --> bau Dir einfach mal einige weitere echo Ausgaben ein (speziell vor und nach dem curl Aufruf
@Maze
werde die Änderung übernehmen
Hallo Andreas,
hab noch einige Sachen bzgl. der Fehlermeldung ausprobiert, komme aber leider nicht weiter. Folgende Änderungen/Tests wurden vorgenommen:
Aus der Ausgabe kann ich allerdings nicht erkennen, wo die „leere“ Fehlermeldung erzeugt wird. Hast Du vielleicht noch eine Idee?
Danke und Gruß
Jörg
ok, ich glaub „Fehler“ wird von IP-Symcon ausgegeben, wenn irgendetwas zum Output geschrieben wird.
Da es mit der anderen Komponente funktioniert, hast Du vermutlich in der IPSComponentRGB_PhilipsHUE.class.php einfach ein Leerzeichen/Return vor oder nach den PHP Tags drinnen !
Hallo Andreas,
hab alles ausprobiert und bin am Ende … 
Mir fehlen auch etwas die Debug-Möglichkeiten ( wobei ich gerade die ersten Versuche mit einer externen IDE mache).
Kann ich Dich vielleicht bitten, das Klassengerüst weiter unten kurz bei Dir zu testen? Damit kommt es bei mir unter IPS 3.1 weiterhin zur Fehlermeldung.
Danke und Gruß
Jörg
<?
IPSUtils_Include ('IPSComponentRGB.class.php', 'IPSLibrary::app::core::IPSComponent::IPSComponentRGB');
IPSUtils_Include ("IPSLogger.inc.php", "IPSLibrary::app::core::IPSLogger");
class IPSComponentRGB_PhilipsHUE extends IPSComponentRGB {
private $bridgeIP;
private $lampNr;
private $hueKey;
public function __construct($bridgeIP, $hueKey, $lampNr) {
}
public function HandleEvent($variable, $value, IPSModuleRGB $module){
}
public function GetComponentParams() {
return get_class($this).','.$this->bridgeIP.','.$this->hueKey.','.$this->lampNr;
}
private function hue_SendLampCommand($cmd) {
}
public function SetState($power, $color, $level) {
}
}
?>
:rolleyes:
wollte gerade beschämt mein Haupt senken, ist es aber leider nicht. hab gerade den code noch in einen simplen text-editor kopiert um etwaige versteckte steuerzeichen zu entfernen. hat auch nichts gebracht.
What is the problem, my pc skils are not the best in this situation.
I have the same problem like KHC on page 3/4 or 4/5
Mbj74
:)
PS my english an Deutsch is no good
Automatic WebFront Generation is not part of IPSLight, you can do it manually by generating Dummy-Modules and Links to the IPSLight Variables.
Where is also an advanced Configuration Part for the WebFront Generation in IPSLight_Configuration, but this is not dokumented (maybe you can use it by having a look into the demo configuration)!
Was ist jetzt mit dem Leerzeichen
Die Fehlermeldung ist noch immer da 
Hab jetzt mehrere Stunden in die Fehlersuche investiert und bin nicht weitergekommen. Dafür habe ich jetzt eine funktionierende Debug-Umgebung mit XDebug und einen tieferen Einblick in die Logik der Library 
Die Meldung kommt sogar, wenn ich das (leere) Coding der RGB_Dummy-Klasse verwende und nur die Parameter im Konstruktor anpasse. Vielleicht kannst Du das mal ausprobieren? Ich bin echt am Ende …
Immerhin funktioniert die Klasse an sich. Die Farbumwandlung von RGB ist noch nicht optimal. Steuere ich die Hue und RGB_IPS868 mit dem gleichen RGB-Wert an, stimmen die Farben in 80% der Fälle. Es gibt einen Beispiel-Algorithmus in der API von Philips, der ist aber in Objective-C und recht komplex. Vielleicht mach ich mich an die Umsetzung, zuerst will die beiden Geräte mit definierten Werten je nach Szenario (Morgens, Abends, Lesen, …) ansteuern.
<?
/**@addtogroup ipscomponent
* @{
*
*
* @file IPSComponentRGB_PhilipsHUE.class.php
* @author Andreas Brauneis
*
*
*/
/**
* @class IPSComponentRGB_PhilipsHUE
*
* Definiert ein IPSComponentRGB_PhilipsHUE Object, das ein IPSComponentRGB Object für PhilipsHUE implementiert.
*
* @author Andreas Brauneis
* @version
* Version 2.50.1, 28.01.2014<br/>
*/
IPSUtils_Include ('IPSComponentRGB.class.php', 'IPSLibrary::app::core::IPSComponent::IPSComponentRGB');
IPSUtils_Include ("IPSLogger.inc.php", "IPSLibrary::app::core::IPSLogger");
class IPSComponentRGB_PhilipsHUE extends IPSComponentRGB {
private $bridgeIP;
private $lampNr;
private $hueKey;
/**
* @public
*
* Initialisierung eines IPSComponentRGB_PhilipsHUE Objektes
*
* @param string $bridgeIP IP Addresse der HUE Lampe
* @param string $hueKey Key zum Zugriff auf die Lampe
* @param string $lampNr Nummer der Lampe
*/
public function __construct($bridgeIP, $hueKey, $lampNr) {
$this->bridgeIP = $bridgeIP;
$this->hueKey = $hueKey;
$this->lampNr = $lampNr;
}
/**
* @public
*
* Function um Events zu behandeln, diese Funktion wird vom IPSMessageHandler aufgerufen, um ein aufgetretenes Event
* an das entsprechende Module zu leiten.
*
* @param integer $variable ID der auslösenden Variable
* @param string $value Wert der Variable
* @param IPSModuleRGB $module Module Object an das das aufgetretene Event weitergeleitet werden soll
*/
public function HandleEvent($variable, $value, IPSModuleRGB $module){
}
/**
* @public
*
* Funktion liefert String IPSComponent Constructor String.
* String kann dazu benützt werden, das Object mit der IPSComponent::CreateObjectByParams
* wieder neu zu erzeugen.
*
* @return string Parameter String des IPSComponent Object
*/
public function GetComponentParams() {
return get_class($this).','.$this->bridgeIP.','.$this->hueKey.','.$this->lampNr;
}
/**
* @private
*
* Ansteuerung der HUE Lampe
*
*/
private function hue_SendLampCommand($cmd) {
$json_url = 'http://'.$this->bridgeIP.'/api/'.$this->hueKey.'/lights/'.$this->lampNr.'/state';
$json_string = '{'.$cmd.'}';
// Configuring curl
$ch = curl_init($json_url);
$options = array(
CURLOPT_RETURNTRANSFER => true,
CURLOPT_CUSTOMREQUEST => 'PUT',
CURLOPT_HTTPHEADER => array('Content-type: application/json') ,
CURLOPT_POSTFIELDS => $json_string
);
curl_setopt_array($ch, $options);
IPSLogger_Inf(__file__, 'Send PhilipsHUE: JsonURL='.$json_url.', Command='.$json_string);
// Execute
if ($this->bridgeIP <> '') {
$result = curl_exec($ch);
}
}
/**
* @private
*
* Cmd aus Hex zusammensetzen
* Umrechnung übernommen von http://www.everyhue.com/vanilla/discussion/83/simple-php-gateway/p1
*/
private function getXYCmdFromHEX($color, $level) {
// Convert each tuple to decimal
$hex = sprintf("%06X", $color);
$r = hexdec(substr($hex, 0, 2))/255;
$g = hexdec(substr($hex, 2, 2))/255;
$b = hexdec(substr($hex, 4, 2))/255;
if ($r>0.04045){$rf=pow(($r + 0.055) / (1.0 + 0.055), 2.4);} else {$rf=$r/12.92;};
if ($r>0.04045) {$gf=pow(($g + 0.055) / (1.0 + 0.055), 2.4);} else {$gf=$g/12.92;};
if ($r>0.04045) {$bf=pow(($b + 0.055) / (1.0 + 0.055), 2.4);} else {$bf=$b/12.92;};
$x = $rf * 0.649926 + $gf * 0.103455 + $bf * 0.197109;
$y = $rf * 0.234327 + $gf * 0.743075 + $bf * 0.022598;
$z = $rf * 0.000000 + $gf * 0.053077 + $bf * 1.035763;
$cx = $x / ($x + $y + $z);
$cy = $y / ($x + $y + $z);
if (is_nan($cx)) {$cx=0;};
if (is_nan($cy)) {$cy=0;};
return '"bri":'.$level.', "xy":['.$cx.','.$cy.'], "on":true';
}
/**
* @public
*
* Zustand Setzen
*
* @param boolean $power RGB Gerät On/Off
* @param integer $color RGB Farben (Hex Codierung)
* @param integer $level Dimmer Einstellung der RGB Beleuchtung (Wertebereich 0-100)
*/
public function SetState($power, $color, $level) {
if (!$power) {
$cmd = '"bri":255, "ct":0, "hue":0, "sat":0, "on":false';
} else {
$cmd = $this->getXYCmdFromHEX($color, $level);
}
$this->hue_SendLampCommand($cmd);
}
}
/** @}*/
?>
Gruß
Jörg
Hallo Jörg,
zip mal Deinen Scripts Ordner und sende in an mich, ich vermute Du hast irgendwo ein Leerzeichen drinnen (vielleicht Deine Config)…
Vielen Dank Andreas für Deine Hilfe per Mail, die Vue funktioniert jetzt fehlerlos.
An alle interessierte Besitzer einer Vue, das Skript in Posting #158 funktioniert (bis auf die beschriebene ungenaue Farbumwandlung). Bei Fragen könnt Ihr Euch gerne an mich wenden.