# Ereignisverwaltung > Symcon Dokumentation · Deutsch · erzeugt am 2026-09-26 > Index: https://www.symcon.de/de/llms.txt Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ ## IPS_CreateEvent Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-createevent/ `int IPS_CreateEvent(int $EreignisTyp)` legt ein neues Ereignis an **Parameter** - `$EreignisTyp` (int) | Wert | Beschreibung | | ---- | -------------------------------------- | | 0 | Legt ein __“ausgelöstes”__ Ereignis an | | 1 | Legt ein __“zyklisches”__ Ereignis an | | 2 | Legt ein __“Wochenplan”__ Ereignis an | **Rückgabewert** (int): ID des neu erstellten Ereignisses | Wert | Beschreibung | | ---- | -------------------------------------- | | 0 | Legt ein __“ausgelöstes”__ Ereignis an | | 1 | Legt ein __“zyklisches”__ Ereignis an | | 2 | Legt ein __“Wochenplan”__ Ereignis an | **Beispiel** ```php $eid = IPS_CreateEvent(0); //Ausgelöstes Ereignis IPS_SetEventTrigger($eid, 1, 15754); //Bei Änderung von Variable mit ID 15754 IPS_SetParent($eid, $_IPS['SELF']); //Ereignis zuordnen IPS_SetEventActive($eid, true); //Ereignis aktivieren $eid = IPS_CreateEvent(1); //Zyklisches Ereignis IPS_SetEventCyclic($eid, 2, 1, 0, 0, 3, 6); //Jeden Tag alle 6 Stunden IPS_SetEventCyclicDateFrom($eid, 1, 12, date("Y")); //Vom 1.12 diesen Jahres IPS_SetEventCyclicDateTo($eid, 31, 12, date("Y")); //Bis 31.12 diesen Jahres IPS_SetEventCyclicTimeFrom($eid, 15, 0, 0); //Von 15:00 IPS_SetEventCyclicTimeTo($eid, 23, 30, 0); //Bis 23:30 IPS_SetParent($eid, $_IPS['SELF']); //Eregnis zuordnen IPS_SetEventActive($eid, true); //Ereignis aktivieren // Seit IP-Symcon 6.0 erforderlich, sofern das Ereignis eine Automation ausführen soll (z.B. ein PHP-Skript) IPS_SetEventAction($eid, '{7938A5A2-0981-5FE0-BE6C-8AA610D654EB}', []); ``` ## IPS_DeleteEvent Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-deleteevent/ `bool IPS_DeleteEvent(int $EreignisID)` löscht eine bestehendes Ereignis **Parameter** - `$EreignisID` (int): ID des zu löschenden Ereignisses **Rückgabewert** (bool): Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis __TRUE__, andernfalls __FALSE__. ID des zu löschenden Ereignisses **Beispiel** ```php IPS_DeleteEvent($EreignisID); ``` ## IPS_EventExists Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-eventexists/ `bool IPS_EventExists(int $EreignisID)` prüft, ob ein Ereignis bereits existiert **Parameter** - `$EreignisID` (int): ID des zu prüfenden Ereignisses **Rückgabewert** (bool): Falls die EreignisID im System existiert, wird __TRUE__ zurückgemeldet, andernfalls __FALSE__. ID des zu prüfenden Ereignisses **Beispiel** ```php if (IPS_EventExists(34881)) echo "Ein Ereignis mit dieser ID existiert!"; ``` ## IPS_GetEvent Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-getevent/ `array IPS_GetEvent(int $EreignisID)` _Benötigt Symcon >= 3.1_ liefert umfassende Informationen über ein Ereignis **Parameter** - `$EreignisID` (int): Die zu zeigende EreignisID **Rückgabewert** (array): Folgende Informationen stehen als __key => value__ Paare zur Verfügung: | Index | Type | Beschreibung | | ------------------------------ | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | __CyclicDateDay__ | integer | Datumstage. Siehe [IPS_SetEventCyclic](management-events.md) | | __CyclicDateDayValue__ | integer | Datumstagesintervall. Siehe [IPS_SetEventCyclic](management-events.md) | | __CyclicDateFrom__ | array | Startdatum als Array von Tag, Monat, Jahr; 0/0/0 = Immer. Siehe [IPS_SetEventCyclicDateFrom](management-events.md) | | __CyclicDateTo__ | array | Enddatum als Array von Tag, Monat, Jahr; 0/0/0 = Nie. Siehe [IPS_SetEventCyclicDateTo](management-events.md) | | __CyclicDateType__ | integer | Datumstyp. Siehe [IPS_SetEventCyclic](management-events.md) | | __CyclicDateValue__ | integer | Datumsintervall. Siehe [IPS_SetEventCyclic](management-events.md) | | __CyclicTimeFrom__ | array | Startzeit als Array von Stunde, Minute, Sekunde; 0/0/0 = Mitternacht. Siehe [IPS_SetEventCyclicTimeFrom](management-events.md) | | __CyclicTimeTo__ | array | Endzeit als Array von Stunde, Minute, Sekunde; 0/0/0 = Nie. Siehe [IPS_SetEventCyclicTimeTo](management-events.md) | | __CyclicTimeType__ | integer | Zeittyp. Siehe [IPS_SetEventCyclic](management-events.md) | | __CyclicTimeValue__ | integer | Zeitintervall. Siehe [IPS_SetEventCyclic](management-events.md) | | __EventActionID__ | string | ID der auszuführenden [Aktion](../concepts/automations.md) | | __EventActionParameters__ | array | Parameter der auszuführenden [Aktion](../concepts/automations.md) | | __EventActive__ | boolean | TRUE, wenn das Ereignis aktiv ist | | __EventConditions__ | array | Array von Bedingungen. Siehe [IPS_SetEventCondition](management-events.md), [IPS_SetEventConditionDateRule](management-events.md), [IPS_SetEventConditionDayOfTheWeekRule](management-events.md), [IPS_SetEventConditionTimeRule](management-events.md) und [IPS_SetEventConditionVariableRule](management-events.md) | | __EventID__ | integer | ID des Ereignisses | | __EventLimit__ | integer | Restliche Anzahl der Ausführungen. 0 = Kein Limit | | __EventScript__ | string | Immer ein leerer String, da dieses Feld nur noch aus Kompatibilitätsgründen vorhanden ist. Die Ausführung wird immer über die Aktion, welche über [IPS_SetEventScheduleAction](management-events.md) konfiguriert wird, gesteuert. | | __EventType__ | integer | Ereignis-Typ: (0: Auslöser, 1: Zyklisch, 2: Wochenplan) | | __LastRun__ | float | Unix Timestamp der letzten Ausführung, 0 = Nie | | __NextRun__ | float | Unix Timestamp der nächsten Ausführung, 0 = Nie | | __LastActionID__ | integer | Aktion ID vom Wochenplan der letzten Ausführung, 0 = Keine Aktion wurde ausgeführt | | __NextActionID__ | integer | Aktion ID vom Wochenplan der nächsten Ausführung, 0 = Keine Aktion wird nächstes mal ausgeführt | | __ScheduleActions__ | array | Array von Aktionen, welche dem Wochenplan zugehörig sind. Siehe [IPS_SetEventScheduleActionEx](management-events.md) | | __ScheduleGroups__ | array | Array von Gruppen mit Schaltpunkten, welche dem Wochenplan zugehörig sind. Siehe [IPS_SetEventScheduleGroup](management-events.md) und [IPS_SetEventScheduleGroupPoint](management-events.md) | | __TriggerSubsequentExecution__ | boolean | Erlaube erneute Ausführung bei Auslösung ohne Wertänderung | | __TriggerType__ | integer | Wert für den Auslöser-Typ: Siehe [IPS_SetEventTrigger](management-events.md) | | __TriggerValue__ | variant | Wert, der für die Prüfung je nach Auslösertyp verwendet wird | | __TriggerVariableID__ | integer | VariablenID, die als Auslöser genutzt werden soll | Die zu zeigende EreignisID **Beispiel** ```php $EreignisID = 46413; $EreignisInfo = IPS_GetEvent($EreignisID); print_r($EreignisInfo); /* liefert z.B.: Array ( [EventID] => 41227 [EventType] => 2 [EventActive] => 1 [EventLimit] => 0 [EventConditions] => Array ( [0] => Array ( [ID] => 0 [ParentID] => 0 [VariableRules] => Array ( [0] => Array ( [ID] => 1 [VariableID] => 29025 [Comparison] => 4 [Value] => 500 ) ) [DateRules] => Array ( [0] => Array ( [ID] => 0 [Comparison] => 0 [Value] => Array ( [Day] => 8 [Month] => 8 [Year] => 2001 ) ) [1] => Array(3) ( [ID] => 1 [Comparison] => 4 [Value] => Array ( [Day] => 1 [Month] => 1 [Year] => 2021 ) ) ) [TimeRules] => Array ( [0] => Array ( [ID] => 1 [Comparison] => 3 [Value] => Array ( [Hour] => 9 [Minute] => 0 [Second] => 0 ) ) [1] => Array ( [ID] => 2 [Comparison] => 5 [Value] => Array ( [Hour] => 17 [Minute] => 0 [Second] => 0 ) ) ) [DayOfTheWeekRules] => Array ( [0] => Array ( [ID] => 0 [Comparison] => 0 [Value] => 3 ) ) [Operation] => 1 ) ) [TriggerType] => 0 [TriggerVariableID] => 0 [TriggerValue] => [TriggerSubsequentExecution] => [CyclicDateType] => 0 [CyclicDateValue] => 0 [CyclicDateDay] => 0 [CyclicDateDayValue] => 0 [CyclicDateFrom] => Array ( [Day] => 0 [Month] => 0 [Year] => 0 ) [CyclicDateTo] => Array ( [Day] => 0 [Month] => 0 [Year] => 0 ) [CyclicTimeType] => 0 [CyclicTimeValue] => 0 [CyclicTimeFrom] => Array ( [Hour] => 0 [Minute] => 0 [Second] => 0 ) [CyclicTimeTo] => Array ( [Hour] => 0 [Minute] => 0 [Second] => 0 ) [ScheduleActions] => Array ( [0] => Array ( [ID] => 0 [Name] => Kalt [Color] => 255 [ScriptText] => [ActionID] => {3644F802-C152-464A-868A-242C2A3DEC5C} [ActionParameters] => Array ( [VALUE] => 2 ) ) [1] => Array ( [ID] => 1 [Name] => Warm [Color] => 16711680 [ScriptText] => [ActionID] => {3644F802-C152-464A-868A-242C2A3DEC5C} [ActionParameters] => Array ( [VALUE] => 0 ) ) ) [ScheduleGroups] => Array ( [0] => Array ( [ID] => 0 [Days] => 127 [Points] => Array ( [0] => Array ( [ID] => 13 [Start] => Array ( [Hour] => 0 [Minute] => 0 [Second] => 0 ) [ActionID] => 1 ) [1] => Array ( [ID] => 14 [Start] => Array ( [Hour] => 12 [Minute] => 0 [Second] => 0 ) [ActionID] => 0 ) ) ) ) [EventScript] => [LastRun] => 0 [NextRun] => 0 [LastActionID] => 0 [NextActionID] => 0 ) */ ``` ## IPS_GetEventIDByName Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-geteventidbyname/ `int IPS_GetEventIDByName(string $EreignisName, int $ÜbergeordneteID)` ermittelt die ID eines Ereignisses anhand des Namens **Parameter** - `$EreignisName` (string): Zu suchender EreignisName - `$ÜbergeordneteID` (int): Objekt, in dessen direkten Unterobjekten gesucht werden soll **Rückgabewert** (int): ID des gefundenen Ereignisses, sonst FALSE Objekt, in dessen direkten Unterobjekten gesucht werden soll **Beispiel** ```php $EreignisID = @IPS_GetEventIDByName("TimerABC", $ParentID); if ($EreignisID === false) echo "Ereignis nicht gefunden!"; else echo "Die Ereignis-ID lautet: ". $EreignisID; ``` ## IPS_GetEventList Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-geteventlist/ `array IPS_GetEventList()` liefert eine Liste aller existierenden Ereignisse **Rückgabewert** (array): Ein Array von Integer-Werten aller IDs der Ereignisse in IP-Symcon Die Funktion ermittelt die IDs aller in IP-Symcon registrierten Ereignisse. Die IDs werden in einem Array aufgelistet. Falls kein Ereignis existiert, ist das Array leer. **Beispiel** ```php $alleEreignisse = IPS_GetEventList(); print_r($alleEreignisse); /* liefert z.B.: Array ( [0] => 37659 [1] => 18326 usw. ... ) */ ``` ## IPS_GetEventListByType Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-geteventlistbytype/ `array IPS_GetEventListByType(int $EreignisTyp)` liefert eine Liste aller Ereignisse eines bestimmten Typs **Parameter** - `$EreignisTyp` (int) | Wert | Beschreibung | | ---- | ------------------------ | | 0 | __Ausgelöstes Ereignis__ | | 1 | __Zyklisches Ereignis__ | | 2 | __Wochenplan Ereignis__ | **Rückgabewert** (array): Ein Array von Integer-Werten aller IDs der Ereignisse vom Typ EreignisTyp in IP-Symcon | Wert | Beschreibung | | ---- | ------------------------ | | 0 | __Ausgelöstes Ereignis__ | | 1 | __Zyklisches Ereignis__ | | 2 | __Wochenplan Ereignis__ | **Beispiel** ```php $alleEreignisse = IPS_GetEventListByType(1); // nur zyklische Ereignisse auflisten print_r($alleEreignisse); /* liefert z.B.: Array ( [0] => 37659 [1] => 18326 usw. … ) */ ``` ## IPS_IsConditionPassing Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-isconditionpassing/ `bool IPS_IsConditionPassing(string $Bedingung)` _Benötigt Symcon >= 6.1_ prüft ob eine Bedingung erfüllt ist **Parameter** - `$Bedingung` (string): Eine Liste von JSON-codierten Bedingungen im Format von [SelectCondition](../developer/sdk-tools/sdk-php/configuration-forms.md) **Rückgabewert** (bool): __TRUE__, falls die Bedingung erfüllt ist, andernfalls __FALSE__ Eine Liste von JSON-codierten Bedingungen im Format von [SelectCondition](../developer/sdk-tools/sdk-php/configuration-forms.md) **Beispiel** ```php if (IPS_IsConditionPassing($Bedingung)) { // Tue etwas nur falls die Bedingung erfüllt ist }; ``` ## IPS_SetEventAction Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventaction/ `bool IPS_SetEventAction(int $EreignisID, string $AktionsID, array $AktionsParameter)` _Benötigt Symcon >= 6.0_ setzt die auszuführende Aktion **Parameter** - `$EreignisID` (int): ID des zu verändernden Ereignisses - `$AktionsID` (string): ID der auszuführenden Aktion - `$AktionsParameter` (array): Liste der Parameter der auszuführenden Aktion **Rückgabewert** (bool): Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis __TRUE__, andernfalls __FALSE__. Liste der Parameter der auszuführenden Aktion **Beispiel** ```php // Multipliziere Zielvariable des Ereignisses mit 3 IPS_SetEventAction($EreignisID, "{A3153696-013A-41B1-A001-5E8085D95465}", ["FACTOR" => 3]); // Führe Zielautomation des Ereignisses aus IPS_SetEventAction($EreignisID, "{7938A5A2-0981-5FE0-BE6C-8AA610D654EB}", []); ``` ## IPS_SetEventActive Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventactive/ `bool IPS_SetEventActive(int $EreignisID, bool $Aktiv)` aktiviert/deaktiviert ein Ereignis **Parameter** - `$EreignisID` (int): ID des zu verändernden Ereignisses - `$Aktiv` (bool): Gibt an, ob das Ereignis aktiviert (__TRUE__) / deaktiviert (__FALSE__) werden soll. **Rückgabewert** (bool): Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis __TRUE__, andernfalls __FALSE__. Gibt an, ob das Ereignis aktiviert (__TRUE__) / deaktiviert (__FALSE__) werden soll. **Beispiel** ```php IPS_SetEventActive($EreignisID, true); // Aktivert Ereignis ``` ## IPS_SetEventCondition Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventcondition/ `bool IPS_SetEventCondition(int $EreignisID, int $BedingungsID, int $ÜbergeordneteID, int $Operation)` _Benötigt Symcon >= 4.4_ modifiziert die Bedingung eines Ereignisses **Parameter** - `$EreignisID` (int): ID des zu verändernden Ereignisses - `$BedingungsID` (int): Eindeutige ID für diese Bedingung. Die Wurzelbedingung hat die ID 0. IDs müssen nur für dieses Ereignis eindeutig sein. - `$ÜbergeordneteID` (int): ID der übergeordneten Bedingung. Bei der Erstellung der Wurzelbedingung muss dieser Parameter 0 sein. - `$Operation` (int) | Wert | Beschreibung | | ---- | ------------------------------- | | 0 | AND | | 1 | OR | | 2 | NAND (noch nicht implementiert) | | 3 | NOR (noch nicht implementiert) | **Rückgabewert** (bool): Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis __TRUE__, andernfalls __FALSE__. | Wert | Beschreibung | | ---- | ------------------------------- | | 0 | AND | | 1 | OR | | 2 | NAND (noch nicht implementiert) | | 3 | NOR (noch nicht implementiert) | **Beispiel** ```php // Erstelle die Wurzelbedingung mit der Operation OR für das Ereignis mit der ID 12345 IPS_SetEventCondition(12345, 0, 0, 1); // Erstelle eine untergeordnete Bedingung mit der Operation AND IPS_SetEventCondition(12345, 1, 0, 0); // Lösche untergeordnete Bedingung IPS_SetEventCondition(12345, 1, -1, 0); ``` ## IPS_SetEventConditionDateRule Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventconditiondaterule/ `bool IPS_SetEventConditionDateRule(int $EreignisID, int $BedingungsID, int $RegelID, int $Vergleich, int $Tag, int $Monat, int $Jahr)` _Benötigt Symcon >= 4.4_ modifiziert die Regel einer Bedingung eines Ereignisses für Datumsvergleiche **Parameter** - `$EreignisID` (int): ID des zu verändernden Ereignisses - `$BedingungsID` (int): ID der Bedingung, welche die Regel beinhaltet - `$RegelID` (int): Eindeutige ID für diese Regel. IDs müssen nur für dieses Bedingung eindeutig sein. - `$Vergleich` (int) | Wert | Beschreibung | | ---- | ------------ | | 0 | == | | 1 | != | | 2 | > | | 3 | >= | | 4 | < | | 5 | <= | - `$Tag` (int): Tag mit dem das aktuelle Datum verglichen wird - `$Monat` (int): Monat mit dem das aktuelle Datum verglichen wird - `$Jahr` (int): Jahr mit dem das aktuelle Datum verglichen wird **Rückgabewert** (bool): Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis __TRUE__, andernfalls __FALSE__. Jahr mit dem das aktuelle Datum verglichen wird **Beispiel** ```php //Eine AND Bedingung hinzufügen IPS_SetEventCondition(12345, 0, 0, 0) // Fügt hinzu/Modifiziert die Regel mit der ID 2 beim Ereignis mit der ObjektID 12345 // Es ist die erste Jahreshälfte -> aktuelles Datum < 01.07.2018 IPS_SetEventConditionDateRule(12345, 0, 2, 4, 1, 7, 2018); // Lösche die Regel mit der ID 1 IPS_SetEventConditionDateRule(12345, 0, 1, 0, -1, 0, 0); ``` ## IPS_SetEventConditionDayOfTheWeekRule Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventconditiondayoftheweekrule/ `bool IPS_SetEventConditionDayOfTheWeekRule(int $EreignisID, int $BedingungsID, int $RegelID, int $Vergleich, int $Wochentag)` _Benötigt Symcon >= 5.2_ modifiziert die Regel einer Bedingung eines Ereignisses für Wochentagsvergleiche **Parameter** - `$EreignisID` (int): ID des zu verändernden Ereignisses - `$BedingungsID` (int): ID der Bedingung, welche die Regel beinhaltet - `$RegelID` (int): Eindeutige ID für diese Regel. IDs müssen nur für dieses Bedingung eindeutig sein. - `$Vergleich` (int) | Wert | Beschreibung | | ---- | ------------ | | 0 | == | | 1 | != | | 2 | > | | 3 | >= | | 4 | < | | 5 | <= | - `$Wochentag` (int) | Wert | Beschreibung | | ---- | ------------ | | 0 | Löschen | | 1 | Montag | | 2 | Dienstag | | 3 | Mittwoch | | 4 | Donnerstag | | 5 | Freitag | | 6 | Samstag | | 7 | Sonntag | **Rückgabewert** (bool): Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis __TRUE__, andernfalls __FALSE__. | Wert | Beschreibung | | ---- | ------------ | | 0 | Löschen | | 1 | Montag | | 2 | Dienstag | | 3 | Mittwoch | | 4 | Donnerstag | | 5 | Freitag | | 6 | Samstag | | 7 | Sonntag | **Beispiel** ```php //Eine AND Bedingung hinzufügen IPS_SetEventCondition(12345, 0, 0, 0) // Fügt hinzu/Modifiziert die Regel mit der ID 2 beim Ereignis mit der ObjektID 12345 // Es ist größer gleich Donnerstag d.h.: Donnerstag bis Sonntag inklusive IPS_SetEventConditionDayOfTheWeekRule(12345, 0, 2, 3, 4); // Fügt hinzu/Modifiziert die Regel mit der ID 3 beim Ereignis mit der ObjektID 12345 // Es ist ungleich Sonntag IPS_SetEventConditionDayOfTheWeekRule(12345, 0, 3, 1, 7); // Lösche die Regel mit der ID 2 IPS_SetEventConditionDayOfTheWeekRule(12345, 0, 2, 0, 0); ``` ## IPS_SetEventConditionTimeRule Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventconditiontimerule/ `bool IPS_SetEventConditionTimeRule(int $EreignisID, int $BedingungsID, int $RegelID, int $Vergleich, int $Stunde, int $Minute, int $Sekunde)` _Benötigt Symcon >= 4.4_ modifiziert die Regel einer Bedingung eines Ereignisses für Uhrzeitvergleiche **Parameter** - `$EreignisID` (int): ID des zu verändernden Ereignisses - `$BedingungsID` (int): ID der Bedingung, welche die Regel beinhaltet - `$RegelID` (int): Eindeutige ID für diese Regel. IDs müssen nur für dieses Bedingung eindeutig sein. - `$Vergleich` (int) | Wert | Beschreibung | | ---- | ------------ | | 0 | == | | 1 | != | | 2 | > | | 3 | >= | | 4 | < | | 5 | <= | - `$Stunde` (int): Stundenwert (0..23) mit dem die aktuelle Zeit verglichen wird - `$Minute` (int): Minutenwert (0..59) mit dem die aktuelle Zeit verglichen wird - `$Sekunde` (int): Sekundenwert (0..59) mit dem die aktuelle Zeit verglichen wird **Rückgabewert** (bool): Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis __TRUE__, andernfalls __FALSE__. Sekundenwert (0..59) mit dem die aktuelle Zeit verglichen wird **Beispiel** ```php // Erstelle eine Wurzelbedingung IPS_SetEventCondition(12345, 0, 0, 0); // Fügt hinzu/Modifiziert die Regel mit der ID 2 beim Ereignis mit der ObjektID 12345 // Es muss genau 22:30 sein damit diese Regel erfüllt ist. IPS_SetEventConditionTimeRule(12345, 0, 2, 1, 22, 30, 0); // Lösche die Regel mit der ID 1 IPS_SetEventConditionTimeRule(12345, 0, 1, 0, -1, 0, 0); ``` ## IPS_SetEventConditionVariableDynamicRule Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventconditionvariabledynamicrule/ `bool IPS_SetEventConditionVariableDynamicRule(int $EreignisID, int $BedingungsID, int $RegelID, int $VariablenID, int $Vergleich, int $VergleichVariablenID)` _Benötigt Symcon >= 6.1_ modifiziert die Regel einer Bedingung eines Ereignisses für Variablenvergleiche **Parameter** - `$EreignisID` (int): ID des zu verändernden Ereignisses - `$BedingungsID` (int): ID der Bedingung welche die Regel beinhaltet - `$RegelID` (int): Eindeutige ID für diese Regel. IDs müssen nur für dieses Bedingung eindeutig sein. - `$VariablenID` (int): ID der geprüften Variable - `$Vergleich` (int) | Wert | Beschreibung | | ---- | ------------ | | 0 | == | | 1 | != | | 2 | > | | 3 | >= | | 4 | < | | 5 | <= | - `$VergleichVariablenID` (int): ID der Variablen, mit der der Wert verglichen werden soll **Rückgabewert** (bool): Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis __TRUE__, andernfalls __FALSE__. ID der Variablen, mit der der Wert verglichen werden soll **Beispiel** ```php // Erstelle eine Wurzelbedingung für das Ereignis mit ID 12345 IPS_SetEventCondition(12345, 0, 0, 0); // Füge eine Regel mit der ID 2 hinzu: Variable 23456 < Variable 34567 IPS_SetEventConditionVariableDynamicRule(12345, 0, 2, 23456, 4, 34567); // Lösche die Regel mit der ID 2 IPS_SetEventConditionVariableDynamicRule(12345, 0, 2, 0, 0, 0); ``` ## IPS_SetEventConditionVariableRule Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventconditionvariablerule/ `bool IPS_SetEventConditionVariableRule(int $EreignisID, int $BedingungsID, int $RegelID, int $VariablenID, int $Vergleich, mixed $Wert)` _Benötigt Symcon >= 4.4_ modifiziert die Regel einer Bedingung eines Ereignisses für Variablenvergleiche **Parameter** - `$EreignisID` (int): ID des zu verändernden Ereignisses - `$BedingungsID` (int): ID der Bedingung welche die Regel beinhaltet - `$RegelID` (int): Eindeutige ID für diese Regel. IDs müssen nur für dieses Bedingung eindeutig sein. - `$VariablenID` (int): ID der geprüften Variable - `$Vergleich` (int) | Wert | Beschreibung | | ---- | ------------ | | 0 | == | | 1 | != | | 2 | > | | 3 | >= | | 4 | < | | 5 | <= | - `$Wert` (mixed): Wert mit dem die geprüfte Variable verglichen wird **Rückgabewert** (bool): Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis __TRUE__, andernfalls __FALSE__. Wert mit dem die geprüfte Variable verglichen wird **Beispiel** ```php // Erstelle eine Wurzelbedingung für das Ereignis mit ID 12345 IPS_SetEventCondition(12345, 0, 0, 0); // Füge eine Regel mit der ID 2 hinzu: Variable 23456 < 75 IPS_SetEventConditionVariableRule(12345, 0, 2, 23456, 4, 75); // Lösche die Regel mit der ID 2 IPS_SetEventConditionVariableRule(12345, 0, 2, 0, 0, 0); ``` ## IPS_SetEventConditionVariableStaticRule Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventconditionvariablestaticrule/ `bool IPS_SetEventConditionVariableStaticRule(int $EreignisID, int $BedingungsID, int $RegelID, int $VariablenID, int $Vergleich, mixed $Wert)` _Benötigt Symcon >= 6.1_ modifiziert die Regel einer Bedingung eines Ereignisses für Variablenvergleiche **Parameter** - `$EreignisID` (int): ID des zu verändernden Ereignisses - `$BedingungsID` (int): ID der Bedingung welche die Regel beinhaltet - `$RegelID` (int): Eindeutige ID für diese Regel. IDs müssen nur für dieses Bedingung eindeutig sein. - `$VariablenID` (int): ID der geprüften Variable - `$Vergleich` (int) | Wert | Beschreibung | | ---- | ------------ | | 0 | == | | 1 | != | | 2 | > | | 3 | >= | | 4 | < | | 5 | <= | - `$Wert` (mixed): Wert mit dem die geprüfte Variable verglichen wird **Rückgabewert** (bool): Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis __TRUE__, andernfalls __FALSE__. Wert mit dem die geprüfte Variable verglichen wird **Beispiel** ```php // Erstelle eine Wurzelbedingung für das Ereignis mit ID 12345 IPS_SetEventCondition(12345, 0, 0, 0); // Füge eine Regel mit der ID 2 hinzu: Variable 23456 < 75 IPS_SetEventConditionVariableStaticRule(12345, 0, 2, 23456, 4, 75); // Lösche die Regel mit der ID 2 IPS_SetEventConditionVariableStaticRule(12345, 0, 2, 0, 0, 0); ``` ## IPS_SetEventCyclic Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventcyclic/ `bool IPS_SetEventCyclic(int $EreignisID, int $Datumstyp, int $Datumsintervall, int $Datumstage, int $Datumstagesintervall, int $Zeittyp, int $Zeitintervall)` konfiguriert ein zyklisches Ereignis **Parameter** - `$EreignisID` (int): ID des zu verändernden Ereignisses - `$Datumstyp` (int) | Wert | Beschreibung | | ---- | ----------------------------------------------------------------------------------------- | | 0 | Kein Datumstyp. Tägliche Ausführung. | | 1 | Einmalig. [IPS_SetEventCyclicDateFrom](management-events.md) für Zieldatum | | 2 | Täglich | | 3 | Wöchentlich | | 4 | Monatlich | | 5 | Jährlich | - `$Datumsintervall` (int) | Wert | Beschreibung | | ---- | -------------------------- | | 0 | 0 (Keine Auswertung) | | 1 | 0 (Keine Auswertung) | | 2 | Alle __X__ Tage | | 3 | Alle __X__ Wochen | | 4 | Alle __X__ Monate | | 5 | 1 = Januar … 12 = Dezember | - `$Datumstage` (int) | Wert | Beschreibung | | ---- | ----------------------------------------------------------------------- | | 0 | 0 (Keine Auswertung) | | 1 | 0 (Keine Auswertung) | | 2 | 0 (Keine Auswertung) | | 3 | siehe Tabelle: Tageswerte (gewünschte Tageswerte müssen addiert werden) | | 4 | siehe Tabelle: Tageswerte oder 0 für jeden __X__ Tag im Monat | | 5 | 0 (Keine Auswertung) | _Tabelle: Tageswerte_ | Tag | Wert | | ---------- | ---- | | Montag | 1 | | Dienstag | 2 | | Mittwoch | 4 | | Donnerstag | 8 | | Freitag | 16 | | Samstag | 32 | | Sonntag | 64 | - `$Datumstagesintervall` (int) | Wert | Beschreibung | | ---- | ------------------------------------------------------------------------------------- | | 0 | 0 (Keine Auswertung) | | 1 | 0 (Keine Auswertung) | | 2 | 0 (Keine Auswertung) | | 3 | 0 (Keine Auswertung) | | 4 | Jeden __X Datumstag__ im Monat oder jeden __X__ Tag im Monat, falls __Datumstag__ = 0 | | 5 | Jeden __X__ Tag im angegebenen Monat | - `$Zeittyp` (int) | Wert | Beschreibung | | ---- | --------------------------------------------------------------------------------------- | | 0 | Einmalig [IPS_SetEventCyclicTimeFrom](management-events.md) für Zielzeit | | 1 | Sekündlich | | 2 | Minütlich | | 3 | Stündlich | - `$Zeitintervall` (int) | Wert | Beschreibung | | ---- | -------------------- | | 0 | 0 (Keine Auswertung) | | 1 | Alle __X__ Sekunden | | 2 | Alle __X__ Minuten | | 3 | Alle __X__ Stunden | **Rückgabewert** (bool): Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis __TRUE__, andernfalls __FALSE__. | Wert | Beschreibung | | ---- | -------------------- | | 0 | 0 (Keine Auswertung) | | 1 | Alle __X__ Sekunden | | 2 | Alle __X__ Minuten | | 3 | Alle __X__ Stunden | **Beispiel** ```php //Zum aktuellen Zeitpunkt alle 8 Wochen etwas ausführen $eid = IPS_CreateEvent(1); IPS_SetParent($eid, $_IPS['SELF']); IPS_SetEventCyclicTimeFrom($eid, (int)date("H"), (int)date("i"), (int)date("s")); IPS_SetEventCyclicDateFrom($eid, (int)date("d"), (int)date("m"), (int)date("Y")); IPS_SetEventCyclic($eid, 2 /* Täglich */ , 8 * 7 /* Alle 8 Wochen */,0,0,0,0); IPS_SetEventActive($eid, true); //Jeden Tag alle 6 Stunden ab 0 Uhr $eid = IPS_CreateEvent(1); IPS_SetParent($eid, $_IPS['SELF']); IPS_SetEventCyclic($eid, 2 /* Täglich */, 1 /* Jeden Tag */, 0, 0, 3 /* Stündlich */, 6 /* Alle 6 Stunden */); //Alle 2 Minuten ab 0 Uhr bis 12 Uhr $eid = IPS_CreateEvent(1); IPS_SetParent($eid, $_IPS['SELF']); IPS_SetEventCyclic($eid, 0 /* Keine Datumsüberprüfung */, 0, 0, 2, 2 /* Minütlich */ , 2 /* Alle 2 Minuten */); IPS_SetEventCyclicTimeTo($eid, 12, 0, 0); //Alle 2 Minuten zwischen 8 Uhr und 10 Uhr $eid = IPS_CreateEvent(1); IPS_SetParent($eid, $_IPS['SELF']); IPS_SetEventCyclic($eid, 0 /* Keine Datumsüberprüfung */, 0, 0, 2, 2 /* Minütlich */ , 2 /* Alle 2 Minuten */); IPS_SetEventCyclicTimeFrom($eid, 8, 0, 0); IPS_SetEventCyclicTimeTo($eid, 10, 0, 0); //Alle 2 Wochen am Montag+Mittwoch einmalig um genau 0:00 Uhr $eid = IPS_CreateEvent(1); IPS_SetParent($eid, $_IPS['SELF']); IPS_SetEventCyclic($eid, 3 /* Wöchentlich */, 2 /* Alle 2 Wochen */, 1+4 /* Montag (1) + Dienstag (4) */, 0, 0, 0); //Täglich um 15 Uhr $eid = IPS_CreateEvent(1); IPS_SetParent($eid, $_IPS['SELF']); IPS_SetEventCyclicTimeFrom($eid, 15, 0, 0); //Am ersten Tag im Monat um 0 Uhr $eid = IPS_CreateEvent(1); IPS_SetParent($eid, $_IPS['SELF']); IPS_SetEventCyclic($eid, 4 /* Monatlich */, 1 /* Jeden Monat */, 0 /* Egal welcher Tag */, 1 /* Erster Tag im Monat */, 0, 0); //Am ersten Freitag im Monat um 0 Uhr $eid = IPS_CreateEvent(1); IPS_SetParent($eid, $_IPS['SELF']); IPS_SetEventCyclic($eid, 4 /* Monatlich */, 1 /* Jeden Monat */, 16 /* Am Freitag */, 1 /* Erster Freitag im Monat */, 0, 0); ``` ## IPS_SetEventCyclicDateBounds Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventcyclicdatebounds/ `bool IPS_SetEventCyclicDateBounds(int $EreignisID, int $Startdatum, int $Enddatum)` konfiguriert die Zeitspanne (Datum) **Parameter** - `$EreignisID` (int): ID des zu verändernden Ereignisses - `$Startdatum` (int): Datum als Unix Timestamp - `$Enddatum` (int): Datum als Unix Timestamp **Rückgabewert** (bool): Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis __TRUE__, andernfalls __FALSE__. Datum als Unix Timestamp **Beispiel** ```php //Kein Start/Enddatum dem Ereignis zuordnen IPS_SetEventCyclicDateBounds($EreignisID, 0, 0); ``` ## IPS_SetEventCyclicDateFrom Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventcyclicdatefrom/ `bool IPS_SetEventCyclicDateFrom(int $EreignisID, int $Tag, int $Monat, int $Jahr)` _Benötigt Symcon >= 3.1_ konfiguriert das Startdatum **Parameter** - `$EreignisID` (int): ID des zu verändernden Ereignisses - `$Tag` (int): Start-Tag (0, 1..31) - `$Monat` (int): Start-Monat (0, 1..12) - `$Jahr` (int): Start-Jahr (0, 1970..2038) **Rückgabewert** (bool): Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis __TRUE__, andernfalls __FALSE__. Start-Jahr (0, 1970..2038) **Beispiel** ```php //Kein Startdatum dem Ereignis zuordnen IPS_SetEventCyclicDateFrom($EreignisID, 0, 0, 0); ``` ## IPS_SetEventCyclicDateTo Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventcyclicdateto/ `bool IPS_SetEventCyclicDateTo(int $EreignisID, int $Tag, int $Monat, int $Jahr)` _Benötigt Symcon >= 3.1_ konfiguriert das Enddatum **Parameter** - `$EreignisID` (int): ID des zu verändernden Ereignisses - `$Tag` (int): End-Tag (0, 1..31) - `$Monat` (int): End-Monat (0, 1..12) - `$Jahr` (int): End-Jahr (0, 1970..2038) **Rückgabewert** (bool): Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis __TRUE__, andernfalls __FALSE__. End-Jahr (0, 1970..2038) **Beispiel** ```php //Den 1.2.2020 als Enddatum dem Ereignis zuordnen IPS_SetEventCyclicDateTo($EreignisID, 1, 2, 2020); ``` ## IPS_SetEventCyclicTimeBounds Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventcyclictimebounds/ `bool IPS_SetEventCyclicTimeBounds(int $EreignisID, int $Startuhrzeit, int $Enduhrzeit)` konfiguriert die Zeitspanne (Zeit) **Parameter** - `$EreignisID` (int): ID des zu verändernden Ereignisses - `$Startuhrzeit` (int): Zeit als Unix Timestamp - `$Enduhrzeit` (int): Zeit als Unix Timestamp **Rückgabewert** (bool): Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis __TRUE__, andernfalls __FALSE__. Zeit als Unix Timestamp **Beispiel** ```php //Keine Start/Endzeiten dem Ereignis zuordnen IPS_SetEventCyclicTimeBounds($EreignisID, 0, 0); //Ereignis um 7:30 starten IPS_SetEventCyclicTimeBounds($EreginisID, mktime(7, 30, 0), 0); ``` ## IPS_SetEventCyclicTimeFrom Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventcyclictimefrom/ `bool IPS_SetEventCyclicTimeFrom(int $EreignisID, int $Stunde, int $Minute, int $Sekunde)` _Benötigt Symcon >= 3.1_ konfiguriert die Startzeit **Parameter** - `$EreignisID` (int): ID des zu verändernden Ereignisses - `$Stunde` (int): Start-Stunde (0..23) - `$Minute` (int): Start-Minute (0..59) - `$Sekunde` (int): Start-Sekunde (0..59) **Rückgabewert** (bool): Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis __TRUE__, andernfalls __FALSE__. Start-Sekunde (0..59) **Beispiel** ```php //Als Startzeit 7:15 dem Ereignis zuordnen IPS_SetEventCyclicTimeFrom($EreignisID, 7, 15, 0); ``` ## IPS_SetEventCyclicTimeTo Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventcyclictimeto/ `bool IPS_SetEventCyclicTimeTo(int $EreignisID, int $Stunde, int $Minute, int $Sekunde)` _Benötigt Symcon >= 3.1_ konfiguriert die Endzeit **Parameter** - `$EreignisID` (int): ID des zu verändernden Ereignisses - `$Stunde` (int): End-Stunde (0..23) - `$Minute` (int): End-Minute (0..59) - `$Sekunde` (int): End-Sekunde (0..59) **Rückgabewert** (bool): Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis __TRUE__, andernfalls __FALSE__. End-Sekunde (0..59) **Beispiel** ```php //Keine Endzeit dem Ereignis zuordnen IPS_SetEventCyclicTimeTo($EreignisID, 0, 0, 0); ``` ## IPS_SetEventLimit Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventlimit/ `bool IPS_SetEventLimit(int $EreignisID, int $Anzahl)` limitiert die Anzahl der Ereignissaufrufe **Parameter** - `$EreignisID` (int): ID des zu verändernden Ereignisses - `$Anzahl` (int): Die Anzahl der Ausführung, bevor das Ereignis deaktiviert wird. 0 = Keine Limitierung **Rückgabewert** (bool): Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis __TRUE__, andernfalls __FALSE__. Die Anzahl der Ausführung, bevor das Ereignis deaktiviert wird. 0 = Keine Limitierung **Beispiel** ```php //Keine Limitierung IPS_SetEventLimit($EreignisID, 0); ``` ## IPS_SetEventScheduleAction Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventscheduleaction/ `bool IPS_SetEventScheduleAction(int $EreignisID, int $WochenplanAktionsID, string $Name, int $Farbe, string $Skriptinhalt)` _Benötigt Symcon >= 3.2_ modifiziert die Aktionsstabelle eines Wochenplans und setzt die Aktion dabei auf "Führe PHP Code aus" **Parameter** - `$EreignisID` (int): ID des zu verändernden Ereignisses - `$WochenplanAktionsID` (int): Eindeutige ID für diese Wochenplanaktion. Die Sortierung wird anhand der ID vorgenommen. IDs müssen nur für dieses Ereignis eindeutig sein. - `$Name` (string): Name zur angegebenen Wochenplanaktion - `$Farbe` (int): Farbwert im HTML Farbcode (z.b. 0x0000FF für Blau) - `$Skriptinhalt` (string): PHP Skript ohne PHP Tags () **Rückgabewert** (bool): Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis __TRUE__, andernfalls __FALSE__. PHP Skript ohne PHP Tags () **Beispiel** ```php //Anlegen von Aktionen IPS_SetEventScheduleAction($EreignisID, 0, "Warm", 0xFF0000, "FHT_SetTemperature(\$_IPS['TARGET'], 22.5);"); IPS_SetEventScheduleAction($EreignisID, 1, "Kalt", 0x0000FF, "FHT_SetTemperature(\$_IPS['TARGET'], 17);"); IPS_SetEventScheduleAction($EreignisID, 2, "Öko", 0x00FF00, "FHT_SetTemperature(\$_IPS['TARGET'], 20);"); //Aktion mit ID 2 wieder löschen IPS_SetEventScheduleAction($EreignisID, 2, "", 0, ""); ``` ## IPS_SetEventScheduleActionEx Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventscheduleactionex/ `bool IPS_SetEventScheduleActionEx(int $EreignisID, int $WochenplanAktionsID, string $Name, int $Farbe, string $AktionsID, array $AktionsParameter)` _Benötigt Symcon >= 6.0_ modifiziert die Aktionsstabelle eines Wochenplans **Parameter** - `$EreignisID` (int): ID des zu verändernden Ereignisses - `$WochenplanAktionsID` (int): Eindeutige ID für diese Wochenplanaktion. Die Sortierung wird anhand der ID vorgenommen. IDs müssen nur für dieses Ereignis eindeutig sein. - `$Name` (string): Name zur angegebenen Wochenplanaktion - `$Farbe` (int): Farbwert im HTML Farbcode (z.b. 0x0000FF für Blau) - `$AktionsID` (string): ID der auszuführenden Aktion - `$AktionsParameter` (array): Liste der Parameter der auszuführenden Aktion **Rückgabewert** (bool): Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis __TRUE__, andernfalls __FALSE__. Liste der Parameter der auszuführenden Aktion **Beispiel** ```php //Anlegen von Wochenplanaktionen IPS_SetEventScheduleActionEx($EreignisID, 0, "Warm", 0xFF0000, "{3644F802-C152-464A-868A-242C2A3DEC5C}", ["VALUE" => 22.5]); IPS_SetEventScheduleActionEx($EreignisID, 1, "Kalt", 0xFF0000, "{3644F802-C152-464A-868A-242C2A3DEC5C}", ["VALUE" => 17]); IPS_SetEventScheduleActionEx($EreignisID, 2, "Öko", 0xFF0000, "{3644F802-C152-464A-868A-242C2A3DEC5C}", ["VALUE" => 20]); //Wochenplanaktion mit ID 2 wieder löschen IPS_SetEventScheduleAction($EreignisID, 2, "", 0, "", []); ``` ## IPS_SetEventScheduleGroup Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventschedulegroup/ `bool IPS_SetEventScheduleGroup(int $EreignisID, int $GruppenID, int $Tage)` _Benötigt Symcon >= 3.2_ modifiziert die Gruppierung der Tage eines Wochenplans **Parameter** - `$EreignisID` (int): ID des zu verändernden Ereignisses - `$GruppenID` (int): Eindeutige ID für diese Gruppe. Die Sortierung wird anhand der ID vorgenommen. IDs müssen nur für dieses Ereignis eindeutig sein. - `$Tage` (int): Addition der Tageswerte, die zur Gruppe gehören. Die Tageswerte können der Tabelle bei [IPS_SetEventCyclic](management-events.md) entnommen werden. **Rückgabewert** (bool): Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis __TRUE__, andernfalls __FALSE__. Addition der Tageswerte, die zur Gruppe gehören. Die Tageswerte können der Tabelle bei [IPS_SetEventCyclic](management-events.md) entnommen werden. **Beispiel** ```php //Wochenplan Ereignis erstellen $EreignisID = IPS_CreateEvent(2); //Anlegen von Gruppen IPS_SetEventScheduleGroup($EreignisID, 0, 31); //Mo - Fr (1 + 2 + 4 + 8 + 16) IPS_SetEventScheduleGroup($EreignisID, 1, 96); //Sa + So (32 + 64) //Gruppe mit ID 1 wieder löschen IPS_SetEventScheduleGroup($EreignisID, 1, 0); ``` ## IPS_SetEventScheduleGroupPoint Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventschedulegrouppoint/ `bool IPS_SetEventScheduleGroupPoint(int $EreignisID, int $GruppenID, int $SchaltpunktID, int $StartStunde, int $StartMinute, int $StartSekunde, int $AktionsID)` _Benötigt Symcon >= 3.2_ modifiziert einen Schaltpunkt der Gruppe eines Wochenplans **Parameter** - `$EreignisID` (int): ID des zu verändernden Ereignisses - `$GruppenID` (int): Eindeutige ID für diese Gruppe. Die Sortierung wird anhand der ID vorgenommen. IDs müssen nur für dieses Ereignis eindeutig sein. - `$SchaltpunktID` (int): Eindeutige ID für diesen Schaltpunkt. IDs müssen nur für diese Gruppe eindeutig sein. - `$StartStunde` (int): Start-Stunde (0..23) - `$StartMinute` (int): Start-Minute (0..59) - `$StartSekunde` (int): Start-Sekunde (0..59) - `$AktionsID` (int): ID der Aktion, welche zum Zeitpunkt ausgeführt werden soll. Die ID muss gültig sein. **Rückgabewert** (bool): Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis __TRUE__, andernfalls __FALSE__. ID der Aktion, welche zum Zeitpunkt ausgeführt werden soll. Die ID muss gültig sein. **Beispiel** ```php //Anlegen von Schaltpunkten für Gruppe mit ID = 0 (=Mo-Fr) IPS_SetEventScheduleGroupPoint($id, 0, 0, 8, 0, 0, 0); //Um 8:00 Aktion mit ID 0 (=Warm) aufrufen IPS_SetEventScheduleGroupPoint($id, 0, 1, 22, 30, 0, 2); //Um 22:30 Aktion mit ID 2 (=Öko) aufrufen //Schaltpunkten mit ID 1 für Gruppe mit ID = 0 (=Mo-Fr) wieder löschen IPS_SetEventScheduleGroupPoint($EreignisID, 0, 1, -1, -1, -1, 0); ``` ## IPS_SetEventScript Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventscript/ `bool IPS_SetEventScript(int $EreignisID, string $Skriptinhalt)` setzt die Aktion auf "Führe PHP Code aus" und definiert den auszuführenden Code **Parameter** - `$EreignisID` (int): ID des zu verändernden Ereignisses - `$Skriptinhalt` (string): PHP Code ohne PHP Tags () **Rückgabewert** (bool): Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis __TRUE__, andernfalls __FALSE__. PHP Code ohne PHP Tags () **Beispiel** ```php //Skriptinhalt dem Ereignis zuordnen IPS_SetEventScript($EreignisID, "echo 'Verknüpftes Objekt:' . \$_IPS['TARGET'];"); ``` ## IPS_SetEventTrigger Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventtrigger/ `bool IPS_SetEventTrigger(int $EreignisID, int $Auslösertyp, int $AuslöserVariablenID)` konfiguriert ein ausgelöstes Ereignis **Parameter** - `$EreignisID` (int): ID des zu verändernden Ereignisses - `$Auslösertyp` (int) | Wert | Beschreibung | | ---- | ------------------------------------------------------------------------------------------------------------------------------------------------------- | | 0 | Bei Variablenaktualisierung | | 1 | Bei Variablenänderung | | 2 | Bei Grenzüberschreitung. Grenzwert wird über [IPS_SetEventTriggerValue](management-events.md) festgelegt | | 3 | Bei Grenzunterschreitung. Grenzwert wird über [IPS_SetEventTriggerValue](management-events.md) festgelegt | | 4 | Bei bestimmtem Wert. Wert wird über [IPS_SetEventTriggerValue](management-events.md) festgelegt | - `$AuslöserVariablenID` (int): VariablenID, auf dessen Änderung/Aktualisierung reagiert werden soll **Rückgabewert** (bool): Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis __TRUE__, andernfalls __FALSE__. VariablenID, auf dessen Änderung/Aktualisierung reagiert werden soll **Beispiel** ```php IPS_SetEventTrigger($eid, 0, 12345); //OnUpdate für Variable 12345 ``` ## IPS_SetEventTriggerSubsequentExecution Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventtriggersubsequentexecution/ `bool IPS_SetEventTriggerSubsequentExecution(string $EreignisID, bool $NachfolgendeAusführungen)` konfiguriert, ob Ereignis bei gleichem Wert erneut ausgelöst wird **Parameter** - `$EreignisID` (string): ID des zu verändernden Ereignisses - `$NachfolgendeAusführungen` (bool): __TRUE__ für Erlaubt, sonst __FALSE__ **Rückgabewert** (bool): Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis __TRUE__, andernfalls __FALSE__. __TRUE__ für Erlaubt, sonst __FALSE__ **Beispiel** ```php IPS_SetEventTriggerSubsequentExecution($EreignisID, true); //Erlauben ``` ## IPS_SetEventTriggerValue Quelle: https://www.symcon.de/de/service/dokumentation/befehlsreferenz/ereignisverwaltung/ips-seteventtriggervalue/ `bool IPS_SetEventTriggerValue(int $EreignisID, mixed $Grenzwert)` konfiguriert den Wert bei dem Ausgelöst werden sol **Parameter** - `$EreignisID` (int): ID des zu verändernden Ereignisses - `$Grenzwert` (mixed): Abhänger Wert/Typ je nach VariablenID vom Auslöser **Rückgabewert** (bool): Konnte der Befehl erfolgreich ausgeführt werden, liefert er als Ergebnis __TRUE__, andernfalls __FALSE__. Abhänger Wert/Typ je nach VariablenID vom Auslöser **Beispiel** ```php IPS_SetEventTriggerValue($EreignisID, true); //Nur auf TRUE Werte auslösen ```